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

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6BE,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBrE,kBAI0B"}

package/dist/index.js

@@ -44,4 +44,3 @@ module.exports = {
     meta,
     rules: rules_1.default,
 };
-//# sourceMappingURL=index.js.map

package/dist/rules/adjacent-overload-signatures.d.ts

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

package/dist/rules/adjacent-overload-signatures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adjacent-overload-signatures.d.ts","sourceRoot":"","sources":["../../src/rules/adjacent-overload-signatures.ts"],"names":[],"mappings":";AAuBA,wBA8IG"}

package/dist/rules/adjacent-overload-signatures.js

@@ -122,4 +122,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=adjacent-overload-signatures.js.map

package/dist/rules/array-type.d.ts

@@ -0,0 +1,11 @@
+export type OptionString = 'array' | 'array-simple' | 'generic';
+export type Options = [
+    {
+        default: OptionString;
+        readonly?: OptionString;
+    }
+];
+export type MessageIds = 'errorStringArray' | 'errorStringArrayReadonly' | 'errorStringArraySimple' | 'errorStringArraySimpleReadonly' | 'errorStringGeneric' | 'errorStringGenericSimple';
+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=array-type.d.ts.map

package/dist/rules/array-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-type.d.ts","sourceRoot":"","sources":["../../src/rules/array-type.ts"],"names":[],"mappings":"AA2EA,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,cAAc,GAAG,SAAS,CAAC;AAChE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,OAAO,EAAE,YAAY,CAAC;QACtB,QAAQ,CAAC,EAAE,YAAY,CAAC;KACzB;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAClB,kBAAkB,GAClB,0BAA0B,GAC1B,wBAAwB,GACxB,gCAAgC,GAChC,oBAAoB,GACpB,0BAA0B,CAAC;;AAE/B,wBAgNG"}

package/dist/rules/array-type.js

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

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

@@ -0,0 +1,5 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type MessageId = 'await' | 'awaitUsingOfNonAsyncDisposable' | 'convertToOrdinaryFor' | 'forAwaitOfNonAsyncIterable' | 'removeAwait';
+declare const _default: TSESLint.RuleModule<MessageId, [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=await-thenable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"await-thenable.d.ts","sourceRoot":"","sources":["../../src/rules/await-thenable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAiBnE,MAAM,MAAM,SAAS,GACjB,OAAO,GACP,gCAAgC,GAChC,sBAAsB,GACtB,4BAA4B,GAC5B,aAAa,CAAC;;AAElB,wBAyJG"}

package/dist/rules/await-thenable.js

@@ -144,4 +144,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=await-thenable.js.map

package/dist/rules/ban-ts-comment.d.ts

@@ -0,0 +1,16 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type DirectiveConfig = boolean | 'allow-with-description' | {
+    descriptionFormat: string;
+};
+export interface OptionsShape {
+    minimumDescriptionLength?: number;
+    'ts-check'?: DirectiveConfig;
+    'ts-expect-error'?: DirectiveConfig;
+    'ts-ignore'?: DirectiveConfig;
+    'ts-nocheck'?: DirectiveConfig;
+}
+export type Options = [OptionsShape];
+export type MessageIds = 'replaceTsIgnoreWithTsExpectError' | 'tsDirectiveComment' | 'tsDirectiveCommentDescriptionNotMatchPattern' | 'tsDirectiveCommentRequiresDescription' | 'tsIgnoreInsteadOfExpectError';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=ban-ts-comment.d.ts.map

package/dist/rules/ban-ts-comment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ban-ts-comment.d.ts","sourceRoot":"","sources":["../../src/rules/ban-ts-comment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAQnE,MAAM,MAAM,eAAe,GACvB,OAAO,GACP,wBAAwB,GACxB;IAAE,iBAAiB,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC,MAAM,WAAW,YAAY;IAC3B,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,iBAAiB,CAAC,EAAE,eAAe,CAAC;IACpC,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,YAAY,CAAC,CAAC;AAErC,MAAM,MAAM,UAAU,GAClB,kCAAkC,GAClC,oBAAoB,GACpB,8CAA8C,GAC9C,uCAAuC,GACvC,8BAA8B,CAAC;;AAOnC,wBA8OG"}

package/dist/rules/ban-ts-comment.js

@@ -182,4 +182,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=ban-ts-comment.js.map

package/dist/rules/ban-tslint-comment.d.ts

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

package/dist/rules/ban-tslint-comment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ban-tslint-comment.d.ts","sourceRoot":"","sources":["../../src/rules/ban-tslint-comment.ts"],"names":[],"mappings":";AAiBA,wBA0CG"}

package/dist/rules/ban-tslint-comment.js

@@ -51,4 +51,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=ban-tslint-comment.js.map

package/dist/rules/class-literal-property-style.d.ts

@@ -0,0 +1,6 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type Options = ['fields' | 'getters'];
+export type MessageIds = 'preferFieldStyle' | 'preferFieldStyleSuggestion' | 'preferGetterStyle' | 'preferGetterStyleSuggestion';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=class-literal-property-style.d.ts.map

package/dist/rules/class-literal-property-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-literal-property-style.d.ts","sourceRoot":"","sources":["../../src/rules/class-literal-property-style.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAanE,MAAM,MAAM,OAAO,GAAG,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC;AAC7C,MAAM,MAAM,UAAU,GAClB,kBAAkB,GAClB,4BAA4B,GAC5B,mBAAmB,GACnB,6BAA6B,CAAC;;AAsClC,wBAoLG"}

package/dist/rules/class-literal-property-style.js

@@ -158,4 +158,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=class-literal-property-style.js.map

package/dist/rules/class-methods-use-this.d.ts

@@ -0,0 +1,12 @@
+export type Options = [
+    {
+        enforceForClassFields?: boolean;
+        exceptMethods?: string[];
+        ignoreClassesThatImplementAnInterface?: boolean | 'public-fields';
+        ignoreOverrideMethods?: boolean;
+    }
+];
+export type MessageIds = 'missingThis';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingThis", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=class-methods-use-this.d.ts.map

package/dist/rules/class-methods-use-this.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-methods-use-this.d.ts","sourceRoot":"","sources":["../../src/rules/class-methods-use-this.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,qBAAqB,CAAC,EAAE,OAAO,CAAC;QAChC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QACzB,qCAAqC,CAAC,EAAE,OAAO,GAAG,eAAe,CAAC;QAClE,qBAAqB,CAAC,EAAE,OAAO,CAAC;KACjC;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,aAAa,CAAC;;AAEvC,wBAkSG"}

package/dist/rules/class-methods-use-this.js

@@ -218,4 +218,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=class-methods-use-this.js.map

package/dist/rules/consistent-generic-constructors.d.ts

@@ -0,0 +1,5 @@
+export type MessageIds = 'preferConstructor' | 'preferTypeAnnotation';
+export type Options = ['constructor' | 'type-annotation'];
+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=consistent-generic-constructors.d.ts.map

package/dist/rules/consistent-generic-constructors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-generic-constructors.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-generic-constructors.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,UAAU,GAAG,mBAAmB,GAAG,sBAAsB,CAAC;AACtE,MAAM,MAAM,OAAO,GAAG,CAAC,aAAa,GAAG,iBAAiB,CAAC,CAAC;;AAE1D,wBAqJG"}

package/dist/rules/consistent-generic-constructors.js

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

package/dist/rules/consistent-indexed-object-style.d.ts

@@ -0,0 +1,6 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type MessageIds = 'preferIndexSignature' | 'preferIndexSignatureSuggestion' | 'preferRecord';
+export type Options = ['index-signature' | 'record'];
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=consistent-indexed-object-style.d.ts.map

package/dist/rules/consistent-indexed-object-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-indexed-object-style.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-indexed-object-style.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAanE,MAAM,MAAM,UAAU,GAClB,sBAAsB,GACtB,gCAAgC,GAChC,cAAc,CAAC;AACnB,MAAM,MAAM,OAAO,GAAG,CAAC,iBAAiB,GAAG,QAAQ,CAAC,CAAC;;AAErD,wBA4OG"}

package/dist/rules/consistent-indexed-object-style.js

@@ -248,4 +248,3 @@ function isDeeplyReferencingType(node, superVar, visited) {
     }
     return false;
 }
-//# sourceMappingURL=consistent-indexed-object-style.js.map

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

@@ -0,0 +1,17 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
+declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({
+    treatUndefinedAsUnspecified?: boolean;
+} | undefined)?], unknown, {
+    'ArrowFunctionExpression:exit'(node: TSESTree.ArrowFunctionExpression): void;
+    'FunctionDeclaration:exit'(node: TSESTree.FunctionDeclaration): void;
+    'FunctionExpression:exit'(node: TSESTree.FunctionExpression): void;
+    ReturnStatement(node: TSESTree.ReturnStatement): void;
+}>;
+export type Options = InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({
+    treatUndefinedAsUnspecified?: boolean;
+} | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=consistent-return.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-return.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-return.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAKzD,OAAO,KAAK,EACV,2BAA2B,EAC3B,wBAAwB,EACzB,MAAM,SAAS,CAAC;AAKjB,QAAA,MAAM,QAAQ;;;yCAoFkB,SAC1B,uBAAiB;qCAEf,SAAS,mBAAmB;oCAEZ,SAAU,kBACvB;0BACH,SAAG,eACT;EA5FqD,CAAC;AAExD,MAAM,MAAM,OAAO,GAAG,wBAAwB,CAAC,OAAO,QAAQ,CAAC,CAAC;AAChE,MAAM,MAAM,UAAU,GAAG,2BAA2B,CAAC,OAAO,QAAQ,CAAC,CAAC;;;;AAQtE,wBA2GG"}

package/dist/rules/consistent-return.js

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

package/dist/rules/consistent-type-assertions.d.ts

@@ -0,0 +1,13 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type MessageIds = 'angle-bracket' | 'as' | 'never' | 'replaceArrayTypeAssertionWithAnnotation' | 'replaceArrayTypeAssertionWithSatisfies' | 'replaceObjectTypeAssertionWithAnnotation' | 'replaceObjectTypeAssertionWithSatisfies' | 'unexpectedArrayTypeAssertion' | 'unexpectedObjectTypeAssertion';
+type OptUnion = {
+    assertionStyle: 'angle-bracket' | 'as';
+    objectLiteralTypeAssertions?: 'allow' | 'allow-as-parameter' | 'never';
+    arrayLiteralTypeAssertions?: 'allow' | 'allow-as-parameter' | 'never';
+} | {
+    assertionStyle: 'never';
+};
+export type Options = readonly [OptUnion];
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=consistent-type-assertions.d.ts.map

package/dist/rules/consistent-type-assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-type-assertions.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-type-assertions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAgBnE,MAAM,MAAM,UAAU,GAClB,eAAe,GACf,IAAI,GACJ,OAAO,GACP,yCAAyC,GACzC,wCAAwC,GACxC,0CAA0C,GAC1C,yCAAyC,GACzC,8BAA8B,GAC9B,+BAA+B,CAAC;AACpC,KAAK,QAAQ,GACT;IACE,cAAc,EAAE,eAAe,GAAG,IAAI,CAAC;IACvC,2BAA2B,CAAC,EAAE,OAAO,GAAG,oBAAoB,GAAG,OAAO,CAAC;IACvE,0BAA0B,CAAC,EAAE,OAAO,GAAG,oBAAoB,GAAG,OAAO,CAAC;CACvE,GACD;IACE,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AACN,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;;AAM1C,wBA2TG"}

package/dist/rules/consistent-type-assertions.js

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

package/dist/rules/consistent-type-definitions.d.ts

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

package/dist/rules/consistent-type-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-type-definitions.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-type-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;;AAMnE,wBAkJG"}

package/dist/rules/consistent-type-definitions.js

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

package/dist/rules/consistent-type-exports.d.ts

@@ -0,0 +1,10 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type Options = [
+    {
+        fixMixedExportsWithInlineTypeSpecifier: boolean;
+    }
+];
+export type MessageIds = 'multipleExportsAreTypes' | 'singleExportIsType' | 'typeOverValue';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=consistent-type-exports.d.ts.map

package/dist/rules/consistent-type-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-type-exports.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-type-exports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAgBnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sCAAsC,EAAE,OAAO,CAAC;KACjD;CACF,CAAC;AAgBF,MAAM,MAAM,UAAU,GAClB,yBAAyB,GACzB,oBAAoB,GACpB,eAAe,CAAC;;AAEpB,wBAgSG"}

package/dist/rules/consistent-type-exports.js

@@ -333,4 +333,3 @@ function getSpecifierText(specifier) {
         : specifier.local.name;
     return `${localName}${exportedName !== localName ? ` as ${exportedName}` : ''}`;
 }
-//# sourceMappingURL=consistent-type-exports.js.map

package/dist/rules/consistent-type-imports.d.ts

@@ -0,0 +1,14 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+type Prefer = 'no-type-imports' | 'type-imports';
+type FixStyle = 'inline-type-imports' | 'separate-type-imports';
+export type Options = [
+    {
+        disallowTypeAnnotations?: boolean;
+        fixStyle?: FixStyle;
+        prefer?: Prefer;
+    }
+];
+export type MessageIds = 'avoidImportType' | 'noImportTypeAnnotations' | 'someImportsAreOnlyTypes' | 'typeOverValue';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=consistent-type-imports.d.ts.map

package/dist/rules/consistent-type-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-type-imports.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-type-imports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAkBnE,KAAK,MAAM,GAAG,iBAAiB,GAAG,cAAc,CAAC;AACjD,KAAK,QAAQ,GAAG,qBAAqB,GAAG,uBAAuB,CAAC;AAEhE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,uBAAuB,CAAC,EAAE,OAAO,CAAC;QAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;CACF,CAAC;AAoBF,MAAM,MAAM,UAAU,GAClB,iBAAiB,GACjB,yBAAyB,GACzB,yBAAyB,GACzB,eAAe,CAAC;;AACpB,wBAw4BG"}

package/dist/rules/consistent-type-imports.js

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

package/dist/rules/default-param-last.d.ts

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

package/dist/rules/default-param-last.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-param-last.d.ts","sourceRoot":"","sources":["../../src/rules/default-param-last.ts"],"names":[],"mappings":";AAMA,wBA+EG"}

package/dist/rules/default-param-last.js

@@ -65,4 +65,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=default-param-last.js.map

package/dist/rules/dot-notation.d.ts

@@ -0,0 +1,22 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
+declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useBrackets" | "useDot", [{
+    allowIndexSignaturePropertyAccess?: boolean;
+    allowKeywords?: boolean;
+    allowPattern?: string;
+    allowPrivateClassPropertyAccess?: boolean;
+    allowProtectedClassPropertyAccess?: boolean;
+}], unknown, {
+    MemberExpression(node: TSESTree.MemberExpression): void;
+}>;
+export type Options = InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useBrackets" | "useDot", [{
+    allowIndexSignaturePropertyAccess?: boolean;
+    allowKeywords?: boolean;
+    allowPattern?: string;
+    allowPrivateClassPropertyAccess?: boolean;
+    allowProtectedClassPropertyAccess?: boolean;
+}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=dot-notation.d.ts.map

package/dist/rules/dot-notation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dot-notation.d.ts","sourceRoot":"","sources":["../../src/rules/dot-notation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAMzD,OAAO,KAAK,EACV,2BAA2B,EAC3B,wBAAwB,EACzB,MAAM,SAAS,CAAC;AAKjB,QAAA,MAAM,QAAQ;;;;;;;2BAoI4gP,SAAU,gBAAgB;EApIlgP,CAAC;AAEnD,MAAM,MAAM,OAAO,GAAG,wBAAwB,CAAC,OAAO,QAAQ,CAAC,CAAC;AAChE,MAAM,MAAM,UAAU,GAAG,2BAA2B,CAAC,OAAO,QAAQ,CAAC,CAAC;;;;;;;;AAYtE,wBAoHG"}

package/dist/rules/dot-notation.js

@@ -141,4 +141,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=dot-notation.js.map

package/dist/rules/enum-utils/shared.d.ts

@@ -0,0 +1,37 @@
+import * as ts from 'typescript';
+/**
+ * Retrieve only the Enum literals from a type. for example:
+ * - 123 --> []
+ * - {} --> []
+ * - Fruit.Apple --> [Fruit.Apple]
+ * - Fruit.Apple | Vegetable.Lettuce --> [Fruit.Apple, Vegetable.Lettuce]
+ * - Fruit.Apple | Vegetable.Lettuce | 123 --> [Fruit.Apple, Vegetable.Lettuce]
+ * - T extends Fruit --> [Fruit]
+ */
+export declare function getEnumLiterals(type: ts.Type): ts.LiteralType[];
+/**
+ * A type can have 0 or more enum types. For example:
+ * - 123 --> []
+ * - {} --> []
+ * - Fruit.Apple --> [Fruit]
+ * - Fruit.Apple | Vegetable.Lettuce --> [Fruit, Vegetable]
+ * - Fruit.Apple | Vegetable.Lettuce | 123 --> [Fruit, Vegetable]
+ * - T extends Fruit --> [Fruit]
+ */
+export declare function getEnumTypes(typeChecker: ts.TypeChecker, type: ts.Type): ts.Type[];
+/**
+ * Returns the enum key that matches the given literal node, or null if none
+ * match. For example:
+ * ```ts
+ * enum Fruit {
+ *   Apple = 'apple',
+ *   Banana = 'banana',
+ * }
+ *
+ * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'apple') --> 'Fruit.Apple'
+ * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'banana') --> 'Fruit.Banana'
+ * getEnumKeyForLiteral([Fruit.Apple, Fruit.Banana], 'cherry') --> null
+ * ```
+ */
+export declare function getEnumKeyForLiteral(enumLiterals: ts.LiteralType[], literal: unknown): string | null;
+//# sourceMappingURL=shared.d.ts.map

package/dist/rules/enum-utils/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/rules/enum-utils/shared.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAwBjC;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,WAAW,EAAE,CAM/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,WAAW,EAAE,EAAE,CAAC,WAAW,EAC3B,IAAI,EAAE,EAAE,CAAC,IAAI,GACZ,EAAE,CAAC,IAAI,EAAE,CAEX;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,EAAE,CAAC,WAAW,EAAE,EAC9B,OAAO,EAAE,OAAO,GACf,MAAM,GAAG,IAAI,CA+Bf"}

package/dist/rules/enum-utils/shared.js

@@ -119,4 +119,3 @@ function getEnumKeyForLiteral(enumLiterals, literal) {
     }
     return null;
 }
-//# sourceMappingURL=shared.js.map

package/dist/rules/explicit-function-return-type.d.ts

@@ -0,0 +1,16 @@
+export type Options = [
+    {
+        allowConciseArrowFunctionExpressionsStartingWithVoid?: boolean;
+        allowDirectConstAssertionInArrowFunctions?: boolean;
+        allowedNames?: string[];
+        allowExpressions?: boolean;
+        allowFunctionsWithoutTypeParameters?: boolean;
+        allowHigherOrderFunctions?: boolean;
+        allowIIFEs?: boolean;
+        allowTypedFunctionExpressions?: boolean;
+    }
+];
+export type MessageIds = 'missingReturnType';
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturnType", Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=explicit-function-return-type.d.ts.map

package/dist/rules/explicit-function-return-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-function-return-type.d.ts","sourceRoot":"","sources":["../../src/rules/explicit-function-return-type.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,oDAAoD,CAAC,EAAE,OAAO,CAAC;QAC/D,yCAAyC,CAAC,EAAE,OAAO,CAAC;QACpD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;QACxB,gBAAgB,CAAC,EAAE,OAAO,CAAC;QAC3B,mCAAmC,CAAC,EAAE,OAAO,CAAC;QAC9C,yBAAyB,CAAC,EAAE,OAAO,CAAC;QACpC,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,6BAA6B,CAAC,EAAE,OAAO,CAAC;KACzC;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,mBAAmB,CAAC;;AAO7C,wBAiOG"}

package/dist/rules/explicit-function-return-type.js

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

package/dist/rules/explicit-member-accessibility.d.ts

@@ -0,0 +1,18 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+type AccessibilityLevel = 'explicit' | 'no-public' | 'off';
+export interface Config {
+    accessibility?: AccessibilityLevel;
+    ignoredMethodNames?: string[];
+    overrides?: {
+        accessors?: AccessibilityLevel;
+        constructors?: AccessibilityLevel;
+        methods?: AccessibilityLevel;
+        parameterProperties?: AccessibilityLevel;
+        properties?: AccessibilityLevel;
+    };
+}
+export type Options = [Config];
+export type MessageIds = 'addExplicitAccessibility' | 'missingAccessibility' | 'unwantedPublicAccessibility';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=explicit-member-accessibility.d.ts.map

package/dist/rules/explicit-member-accessibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-member-accessibility.d.ts","sourceRoot":"","sources":["../../src/rules/explicit-member-accessibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAgBnE,KAAK,kBAAkB,GACnB,UAAU,GACV,WAAW,GACX,KAAK,CAAC;AAEV,MAAM,WAAW,MAAM;IACrB,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,SAAS,CAAC,EAAE;QACV,SAAS,CAAC,EAAE,kBAAkB,CAAC;QAC/B,YAAY,CAAC,EAAE,kBAAkB,CAAC;QAClC,OAAO,CAAC,EAAE,kBAAkB,CAAC;QAC7B,mBAAmB,CAAC,EAAE,kBAAkB,CAAC;QACzC,UAAU,CAAC,EAAE,kBAAkB,CAAC;KACjC,CAAC;CACH;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,MAAM,UAAU,GAClB,0BAA0B,GAC1B,sBAAsB,GACtB,6BAA6B,CAAC;;AAElC,wBA0WG"}

package/dist/rules/explicit-member-accessibility.js

@@ -290,4 +290,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=explicit-member-accessibility.js.map

package/dist/rules/explicit-module-boundary-types.d.ts

@@ -0,0 +1,13 @@
+export type Options = [
+    {
+        allowArgumentsExplicitlyTypedAsAny?: boolean;
+        allowDirectConstAssertionInArrowFunctions?: boolean;
+        allowedNames?: string[];
+        allowHigherOrderFunctions?: boolean;
+        allowTypedFunctionExpressions?: boolean;
+    }
+];
+export type MessageIds = 'anyTypedArg' | 'anyTypedArgUnnamed' | 'missingArgType' | 'missingArgTypeUnnamed' | 'missingReturnType';
+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=explicit-module-boundary-types.d.ts.map

package/dist/rules/explicit-module-boundary-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-module-boundary-types.d.ts","sourceRoot":"","sources":["../../src/rules/explicit-module-boundary-types.ts"],"names":[],"mappings":"AAoBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,kCAAkC,CAAC,EAAE,OAAO,CAAC;QAC7C,yCAAyC,CAAC,EAAE,OAAO,CAAC;QACpD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;QACxB,yBAAyB,CAAC,EAAE,OAAO,CAAC;QACpC,6BAA6B,CAAC,EAAE,OAAO,CAAC;KACzC;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAClB,aAAa,GACb,oBAAoB,GACpB,gBAAgB,GAChB,uBAAuB,GACvB,mBAAmB,CAAC;;AAExB,wBAmdG"}

package/dist/rules/explicit-module-boundary-types.js

@@ -370,4 +370,3 @@ exports.default = (0, util_1.createRule)({
         }
     },
 });
-//# sourceMappingURL=explicit-module-boundary-types.js.map