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

package/dist/rules/index.d.ts

@@ -0,0 +1,173 @@
+declare const rules: {
+    'adjacent-overload-signatures': import("@typescript-eslint/utils/ts-eslint").RuleModule<"adjacentSignature", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'array-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./array-type").MessageIds, import("./array-type").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'await-thenable': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./await-thenable").MessageId, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'ban-ts-comment': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./ban-ts-comment").MessageIds, import("./ban-ts-comment").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'ban-tslint-comment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentDetected", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'class-literal-property-style': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./class-literal-property-style").MessageIds, import("./class-literal-property-style").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'class-methods-use-this': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingThis", import("./class-methods-use-this").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'consistent-generic-constructors': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./consistent-generic-constructors").MessageIds, import("./consistent-generic-constructors").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'consistent-indexed-object-style': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./consistent-indexed-object-style").MessageIds, import("./consistent-indexed-object-style").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'consistent-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturn" | "missingReturnValue" | "unexpectedReturnValue", [({
+        treatUndefinedAsUnspecified?: boolean;
+    } | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'consistent-type-assertions': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./consistent-type-assertions").MessageIds, import("./consistent-type-assertions").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'consistent-type-definitions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"interfaceOverType" | "typeOverInterface", [string], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'consistent-type-exports': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./consistent-type-exports").MessageIds, import("./consistent-type-exports").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'consistent-type-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./consistent-type-imports").MessageIds, import("./consistent-type-imports").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'default-param-last': import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeLast", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'dot-notation': 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>;
+    'explicit-function-return-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingReturnType", import("./explicit-function-return-type").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'explicit-member-accessibility': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./explicit-member-accessibility").MessageIds, import("./explicit-member-accessibility").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'explicit-module-boundary-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./explicit-module-boundary-types").MessageIds, import("./explicit-module-boundary-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'init-declarations': import("@typescript-eslint/utils/ts-eslint").RuleModule<"initialized" | "notInitialized", ["always" | "never", ({
+        ignoreForLoopInit?: boolean;
+    } | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'max-params': import("@typescript-eslint/utils/ts-eslint").RuleModule<"exceed", ({
+        countVoidThis?: boolean;
+        max: number;
+    } | {
+        countVoidThis?: boolean;
+        maximum: number;
+    })[], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'member-ordering': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./member-ordering").MessageIds, import("./member-ordering").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'method-signature-style': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./method-signature-style").MessageIds, import("./method-signature-style").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'naming-convention': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./naming-convention").MessageIds, import("./naming-convention").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-array-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useLiteral", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-array-delete': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-array-delete").MessageId, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-base-to-string': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-base-to-string").MessageIds, import("./no-base-to-string").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-confusing-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-confusing-non-null-assertion").MessageId, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-confusing-void-expression': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-confusing-void-expression").MessageId, import("./no-confusing-void-expression").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-deprecated': import("@typescript-eslint/utils/ts-eslint").RuleModule<"deprecated" | "deprecatedWithReason", [{
+        allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[];
+    }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-dupe-class-members': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-duplicate-enum-values': import("@typescript-eslint/utils/ts-eslint").RuleModule<"duplicateValue", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-duplicate-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-duplicate-type-constituents").MessageIds, import("./no-duplicate-type-constituents").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-dynamic-delete': import("@typescript-eslint/utils/ts-eslint").RuleModule<"dynamicDelete", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-empty-function': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [{
+        allow?: string[];
+    }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-empty-interface': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-empty-interface").MessageIds, import("./no-empty-interface").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-empty-object-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-empty-object-type").MessageIds, import("./no-empty-object-type").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-explicit-any': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-explicit-any").MessageIds, import("./no-explicit-any").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-extra-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noExtraNonNullAssertion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-extraneous-class': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-extraneous-class").MessageIds, import("./no-extraneous-class").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-floating-promises': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-floating-promises").MessageId, import("./no-floating-promises").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-for-in-array': import("@typescript-eslint/utils/ts-eslint").RuleModule<"forInViolation", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-implied-eval': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noFunctionConstructor" | "noImpliedEvalError", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-import-type-side-effects': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useTopLevelQualifier", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-inferrable-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInferrableType", import("./no-inferrable-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-invalid-this': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpectedThis", [({
+        capIsConstructor?: boolean;
+    } | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-invalid-void-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-invalid-void-type").MessageIds, [import("./no-invalid-void-type").Options], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-loop-func': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeRefs", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-loss-of-precision': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLossOfPrecision", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-magic-numbers': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMagic", [{
+        detectObjects?: boolean;
+        enforceConst?: boolean;
+        ignore?: (number | string)[];
+        ignoreArrayIndexes?: boolean;
+        ignoreEnums?: boolean;
+        ignoreNumericLiteralTypes?: boolean;
+        ignoreReadonlyClassProperties?: boolean;
+        ignoreTypeIndexes?: boolean;
+    }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-meaningless-void-operator': import("@typescript-eslint/utils/ts-eslint").RuleModule<"meaninglessVoidOperator" | "removeVoid", import("./no-meaningless-void-operator").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-misused-new': import("@typescript-eslint/utils/ts-eslint").RuleModule<"errorMessageClass" | "errorMessageInterface", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-misused-promises': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-misused-promises").MessageId, import("./no-misused-promises").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-misused-spread': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noArraySpreadInObject" | "noClassDeclarationSpreadInObject" | "noClassInstanceSpreadInObject" | "noFunctionSpreadInObject" | "noIterableSpreadInObject" | "noMapSpreadInObject" | "noPromiseSpreadInObject" | "noStringSpread", [{
+        allow?: import("@typescript-eslint/type-utils").TypeOrValueSpecifier[];
+    }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-mixed-enums': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mixed", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-namespace': import("@typescript-eslint/utils/ts-eslint").RuleModule<"moduleSyntaxIsPreferred", import("./no-namespace").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-non-null-asserted-nullish-coalescing': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noNonNullAssertedNullishCoalescing" | "suggestRemovingNonNull", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-non-null-asserted-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemovingNonNull" | "noNonNullOptionalChain", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-non-null-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-non-null-assertion").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-redeclare': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-redeclare").MessageIds, import("./no-redeclare").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-redundant-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<"overrides" | "errorTypeOverrides" | "literalOverridden" | "overridden" | "primitiveOverridden", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-require-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRequireImports", import("./no-require-imports").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-restricted-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"everything" | "everythingWithCustomMessage" | "importName" | "importNameWithCustomMessage" | "path" | "pathWithCustomMessage" | "patterns" | "patternWithCustomMessage", [import("eslint/lib/rules/no-restricted-imports").ObjectOfPathsAndPatterns] | import("eslint/lib/rules/no-restricted-imports").ArrayOfStringOrObject, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-restricted-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-restricted-types").MessageIds, import("./no-restricted-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-shadow': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-shadow").MessageIds, import("./no-shadow").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-this-alias': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-this-alias").MessageIds, import("./no-this-alias").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-type-alias': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-type-alias").MessageIds, import("./no-type-alias").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-boolean-literal-compare': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unnecessary-boolean-literal-compare").MessageIds, import("./no-unnecessary-boolean-literal-compare").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-condition': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unnecessary-condition").MessageId, import("./no-unnecessary-condition").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-parameter-property-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryAssign", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-qualifier': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryQualifier", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-template-expression': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUnnecessaryTemplateExpression", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-type-arguments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unnecessary-type-assertion").MessageIds, import("./no-unnecessary-type-assertion").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-type-constraint': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-type-parameters': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-argument': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unsafe-argument").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeArraySpread" | "anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeAssignment", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-call': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unsafe-call").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-declaration-merging': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeMerging", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-enum-comparison': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mismatchedCase" | "mismatchedCondition" | "replaceValueWithEnum", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedFunctionType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-member-access': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeComputedMemberAccess" | "unsafeMemberExpression" | "unsafeThisMemberExpression", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeOfAnyTypeAssertion" | "unsafeToAnyTypeAssertion" | "unsafeToUnconstrainedTypeAssertion" | "unsafeTypeAssertion" | "unsafeTypeAssertionAssignableToConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unsafe-unary-minus': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unaryMinus", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unused-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"expected", [{
+        allowShortCircuit?: boolean;
+        allowTaggedTemplates?: boolean;
+        allowTernary?: boolean;
+    }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unused-vars': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unused-vars").MessageIds, import("./no-unused-vars").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-use-before-define': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUseBeforeDefine", import("./no-use-before-define").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-useless-empty-export': import("@typescript-eslint/utils/ts-eslint").RuleModule<"uselessExport", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-var-requires': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noVarReqs", import("./no-var-requires").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-wrapper-object-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"bannedClassType", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'non-nullable-type-assertion-style': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferNonNullAssertion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'only-throw-error': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./only-throw-error").MessageIds, import("./only-throw-error").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'parameter-properties': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./parameter-properties").MessageIds, import("./parameter-properties").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-as-const': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferConstAssertion" | "variableConstAssertion" | "variableSuggest", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-destructuring': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferDestructuring", import("./prefer-destructuring").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-enum-initializers': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./prefer-enum-initializers").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-find': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferFind" | "preferFindSuggestion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-for-of': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferForOf", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-function-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"functionTypeOverCallableType" | "unexpectedThisOnFunctionOnlyInterface", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-includes': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferIncludes" | "preferStringIncludes", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-literal-enum-member': import("@typescript-eslint/utils/ts-eslint").RuleModule<"notLiteral" | "notLiteralOrBitwiseExpression", [{
+        allowBitwiseExpressions: boolean;
+    }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-namespace-keyword': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useNamespace", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-nullish-coalescing': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./prefer-nullish-coalescing").MessageIds, import("./prefer-nullish-coalescing").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-optional-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./prefer-optional-chain-utils/PreferOptionalChainOptions").PreferOptionalChainMessageIds, [import("./prefer-optional-chain-utils/PreferOptionalChainOptions").PreferOptionalChainOptions], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-promise-reject-errors': import("@typescript-eslint/utils/ts-eslint").RuleModule<"rejectAnError", import("./prefer-promise-reject-errors").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-readonly': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferReadonly", import("./prefer-readonly").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-readonly-parameter-types': import("@typescript-eslint/utils/ts-eslint").RuleModule<"shouldBeReadonly", import("./prefer-readonly-parameter-types").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-reduce-type-parameter': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'prefer-regexp-exec': import("@typescript-eslint/utils/ts-eslint").RuleModule<"regExpExecOverStringMatch", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    '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>;
+    '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>;
+    'restrict-plus-operands': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./restrict-plus-operands").MessageIds, import("./restrict-plus-operands").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'restrict-template-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidType", import("./restrict-template-expressions").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'return-await': import("@typescript-eslint/utils/ts-eslint").RuleModule<"disallowedPromiseAwait" | "disallowedPromiseAwaitSuggestion" | "nonPromiseAwait" | "requiredPromiseAwait" | "requiredPromiseAwaitSuggestion", [string], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'sort-type-constituents': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./sort-type-constituents").MessageIds, import("./sort-type-constituents").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'strict-boolean-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./strict-boolean-expressions").MessageId, import("./strict-boolean-expressions").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'switch-exhaustiveness-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./switch-exhaustiveness-check").MessageIds, import("./switch-exhaustiveness-check").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'triple-slash-reference': import("@typescript-eslint/utils/ts-eslint").RuleModule<"tripleSlashReference", import("./triple-slash-reference").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    typedef: import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./typedef").MessageIds, import("./typedef").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'unbound-method': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./unbound-method").MessageIds, import("./unbound-method").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'unified-signatures': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./unified-signatures").MessageIds, import("./unified-signatures").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'use-unknown-in-catch-callback-variable': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./use-unknown-in-catch-callback-variable").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+};
+export = rules;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAqIA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoImB,CAAC;AAE/B,SAAS,KAAK,CAAC"}

package/dist/rules/index.js

@@ -265,4 +265,3 @@ const rules = {
     'use-unknown-in-catch-callback-variable': use_unknown_in_catch_callback_variable_1.default,
 };
 module.exports = rules;
-//# sourceMappingURL=index.js.map

package/dist/rules/init-declarations.d.ts

@@ -0,0 +1,14 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
+declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"initialized" | "notInitialized", ["always" | "never", ({
+    ignoreForLoopInit?: boolean;
+} | undefined)?], unknown, {
+    'VariableDeclaration:exit'(node: TSESTree.VariableDeclaration): void;
+}>;
+export type Options = InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"initialized" | "notInitialized", ["always" | "never", ({
+    ignoreForLoopInit?: boolean;
+} | undefined)?], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=init-declarations.d.ts.map

package/dist/rules/init-declarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-declarations.d.ts","sourceRoot":"","sources":["../../src/rules/init-declarations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,OAAO,KAAK,EACV,2BAA2B,EAC3B,wBAAwB,EACzB,MAAM,SAAS,CAAC;AAKjB,QAAA,MAAM,QAAQ;;;qCA6H2lO,SAAU,mBAAmB;EA7H/kO,CAAC;AAExD,MAAM,MAAM,OAAO,GAAG,wBAAwB,CAAC,OAAO,QAAQ,CAAC,CAAC;AAChE,MAAM,MAAM,UAAU,GAAG,2BAA2B,CAAC,OAAO,QAAQ,CAAC,CAAC;;;;AAEtE,wBAgGG"}

package/dist/rules/init-declarations.js

@@ -102,4 +102,3 @@ function getReportLoc(node) {
         end,
     };
 }
-//# sourceMappingURL=init-declarations.js.map

package/dist/rules/max-params.d.ts

@@ -0,0 +1,24 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
+declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"exceed", ({
+    countVoidThis?: boolean;
+    max: number;
+} | {
+    countVoidThis?: boolean;
+    maximum: number;
+})[], unknown, {
+    ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression): void;
+    FunctionDeclaration(node: TSESTree.FunctionDeclaration | TSESTree.TSDeclareFunction | TSESTree.TSFunctionType): void;
+    FunctionExpression(node: TSESTree.FunctionExpression): void;
+}>;
+export type Options = InferOptionsTypeFromRule<typeof baseRule>;
+export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"exceed", ({
+    countVoidThis?: boolean;
+    max: number;
+} | {
+    countVoidThis?: boolean;
+    maximum: number;
+})[], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=max-params.d.ts.map

package/dist/rules/max-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-params.d.ts","sourceRoot":"","sources":["../../src/rules/max-params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,OAAO,KAAK,EACV,2BAA2B,EAC3B,wBAAwB,EACzB,MAAM,SAAS,CAAC;AAcjB,QAAA,MAAM,QAAQ;;;;;;;kCAqFqgC,SAAU,uBAAuB;8BAA6D,SAAU,mBAAmB,GAAY,SAAU,iBAAiB,GAAY,SAAU,cAAc;6BAA+C,SAAU,kBAAkB;EArFpvC,CAAC;AAEjD,MAAM,MAAM,OAAO,GAAG,wBAAwB,CAAC,OAAO,QAAQ,CAAC,CAAC;AAChE,MAAM,MAAM,UAAU,GAAG,2BAA2B,CAAC,OAAO,QAAQ,CAAC,CAAC;;;;;;;;AAEtE,wBA+EG"}

package/dist/rules/max-params.js

@@ -70,4 +70,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=max-params.js.map

package/dist/rules/member-ordering.d.ts

@@ -0,0 +1,32 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+export type MessageIds = 'incorrectGroupOrder' | 'incorrectOrder' | 'incorrectRequiredMembersOrder';
+type ReadonlyType = 'readonly-field' | 'readonly-signature';
+type MemberKind = 'accessor' | 'call-signature' | 'constructor' | 'field' | 'get' | 'method' | 'set' | 'signature' | 'static-initialization' | ReadonlyType;
+type DecoratedMemberKind = 'accessor' | 'field' | 'get' | 'method' | 'set' | Exclude<ReadonlyType, 'readonly-signature'>;
+type NonCallableMemberKind = Exclude<MemberKind, 'constructor' | 'readonly-signature' | 'signature'>;
+type MemberScope = 'abstract' | 'instance' | 'static';
+type Accessibility = '#private' | TSESTree.Accessibility;
+type BaseMemberType = `${Accessibility}-${Exclude<MemberKind, 'readonly-signature' | 'signature' | 'static-initialization'>}` | `${Accessibility}-${MemberScope}-${NonCallableMemberKind}` | `${Accessibility}-decorated-${DecoratedMemberKind}` | `${MemberScope}-${NonCallableMemberKind}` | `decorated-${DecoratedMemberKind}` | MemberKind;
+type MemberType = BaseMemberType | BaseMemberType[];
+type AlphabeticalOrder = 'alphabetically' | 'alphabetically-case-insensitive' | 'natural' | 'natural-case-insensitive';
+type Order = 'as-written' | AlphabeticalOrder;
+interface SortedOrderConfig {
+    memberTypes?: 'never' | MemberType[];
+    optionalityOrder?: OptionalityOrder;
+    order?: Order;
+}
+type OrderConfig = 'never' | MemberType[] | SortedOrderConfig;
+type OptionalityOrder = 'optional-first' | 'required-first';
+export type Options = [
+    {
+        classes?: OrderConfig;
+        classExpressions?: OrderConfig;
+        default?: OrderConfig;
+        interfaces?: OrderConfig;
+        typeLiterals?: OrderConfig;
+    }
+];
+export declare const defaultOrder: MemberType[];
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=member-ordering.d.ts.map

package/dist/rules/member-ordering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"member-ordering.d.ts","sourceRoot":"","sources":["../../src/rules/member-ordering.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAY/E,MAAM,MAAM,UAAU,GAClB,qBAAqB,GACrB,gBAAgB,GAChB,+BAA+B,CAAC;AAEpC,KAAK,YAAY,GAAG,gBAAgB,GAAG,oBAAoB,CAAC;AAE5D,KAAK,UAAU,GACX,UAAU,GACV,gBAAgB,GAChB,aAAa,GACb,OAAO,GACP,KAAK,GACL,QAAQ,GACR,KAAK,GACL,WAAW,GACX,uBAAuB,GACvB,YAAY,CAAC;AAEjB,KAAK,mBAAmB,GACpB,UAAU,GACV,OAAO,GACP,KAAK,GACL,QAAQ,GACR,KAAK,GACL,OAAO,CAAC,YAAY,EAAE,oBAAoB,CAAC,CAAC;AAEhD,KAAK,qBAAqB,GAAG,OAAO,CAClC,UAAU,EACV,aAAa,GAAG,oBAAoB,GAAG,WAAW,CACnD,CAAC;AAEF,KAAK,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEtD,KAAK,aAAa,GAAG,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC;AAEzD,KAAK,cAAc,GACf,GAAG,aAAa,IAAI,OAAO,CACzB,UAAU,EACV,oBAAoB,GAAG,WAAW,GAAG,uBAAuB,CAC7D,EAAE,GACH,GAAG,aAAa,IAAI,WAAW,IAAI,qBAAqB,EAAE,GAC1D,GAAG,aAAa,cAAc,mBAAmB,EAAE,GACnD,GAAG,WAAW,IAAI,qBAAqB,EAAE,GACzC,aAAa,mBAAmB,EAAE,GAClC,UAAU,CAAC;AAEf,KAAK,UAAU,GAAG,cAAc,GAAG,cAAc,EAAE,CAAC;AAEpD,KAAK,iBAAiB,GAClB,gBAAgB,GAChB,iCAAiC,GACjC,SAAS,GACT,0BAA0B,CAAC;AAE/B,KAAK,KAAK,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAE9C,UAAU,iBAAiB;IACzB,WAAW,CAAC,EAAE,OAAO,GAAG,UAAU,EAAE,CAAC;IACrC,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,KAAK,WAAW,GAAG,OAAO,GAAG,UAAU,EAAE,GAAG,iBAAiB,CAAC;AAG9D,KAAK,gBAAgB,GAAG,gBAAgB,GAAG,gBAAgB,CAAC;AAE5D,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,OAAO,CAAC,EAAE,WAAW,CAAC;QACtB,gBAAgB,CAAC,EAAE,WAAW,CAAC;QAC/B,OAAO,CAAC,EAAE,WAAW,CAAC;QACtB,UAAU,CAAC,EAAE,WAAW,CAAC;QACzB,YAAY,CAAC,EAAE,WAAW,CAAC;KAC5B;CACF,CAAC;AAwCF,eAAO,MAAM,YAAY,EAAE,UAAU,EAyKpC,CAAC;;AAwaF,wBA2YG"}

package/dist/rules/member-ordering.js

@@ -825,4 +825,3 @@ exports.default = (0, util_1.createRule)({
         /* eslint-enable @typescript-eslint/no-non-null-assertion */
     },
 });
-//# sourceMappingURL=member-ordering.js.map

package/dist/rules/method-signature-style.d.ts

@@ -0,0 +1,5 @@
+export type Options = [('method' | 'property')?];
+export type MessageIds = 'errorMethod' | 'errorProperty';
+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=method-signature-style.d.ts.map

package/dist/rules/method-signature-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-signature-style.d.ts","sourceRoot":"","sources":["../../src/rules/method-signature-style.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;AACjD,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,eAAe,CAAC;;AAEzD,wBAmOG"}

package/dist/rules/method-signature-style.js

@@ -174,4 +174,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=method-signature-style.js.map

package/dist/rules/naming-convention-utils/enums.d.ts

@@ -0,0 +1,80 @@
+export declare enum PredefinedFormats {
+    camelCase = 1,
+    strictCamelCase = 2,
+    PascalCase = 3,
+    StrictPascalCase = 4,
+    snake_case = 5,
+    UPPER_CASE = 6
+}
+export type PredefinedFormatsString = keyof typeof PredefinedFormats;
+export declare enum UnderscoreOptions {
+    forbid = 1,
+    allow = 2,
+    require = 3,
+    requireDouble = 4,
+    allowDouble = 5,
+    allowSingleOrDouble = 6
+}
+export type UnderscoreOptionsString = keyof typeof UnderscoreOptions;
+export declare enum Selectors {
+    variable = 1,
+    function = 2,
+    parameter = 4,
+    parameterProperty = 8,
+    classicAccessor = 16,
+    enumMember = 32,
+    classMethod = 64,
+    objectLiteralMethod = 128,
+    typeMethod = 256,
+    classProperty = 512,
+    objectLiteralProperty = 1024,
+    typeProperty = 2048,
+    autoAccessor = 4096,
+    class = 8192,
+    interface = 16384,
+    typeAlias = 32768,
+    enum = 65536,
+    typeParameter = 131072,
+    import = 262144
+}
+export type SelectorsString = keyof typeof Selectors;
+export declare enum MetaSelectors {
+    default = -1,
+    variableLike = 7,
+    memberLike = 8184,
+    typeLike = 253952,
+    method = 448,
+    property = 3584,
+    accessor = 4112
+}
+export type MetaSelectorsString = keyof typeof MetaSelectors;
+export type IndividualAndMetaSelectorsString = MetaSelectorsString | SelectorsString;
+export declare enum Modifiers {
+    const = 1,
+    readonly = 2,
+    static = 4,
+    public = 8,
+    protected = 16,
+    private = 32,
+    '#private' = 64,
+    abstract = 128,
+    destructured = 256,
+    global = 512,
+    exported = 1024,
+    unused = 2048,
+    requiresQuotes = 4096,
+    override = 8192,
+    async = 16384,
+    default = 32768,
+    namespace = 65536
+}
+export type ModifiersString = keyof typeof Modifiers;
+export declare enum TypeModifiers {
+    boolean = 131072,
+    string = 262144,
+    number = 524288,
+    function = 1048576,
+    array = 2097152
+}
+export type TypeModifiersString = keyof typeof TypeModifiers;
+//# sourceMappingURL=enums.d.ts.map

package/dist/rules/naming-convention-utils/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../src/rules/naming-convention-utils/enums.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB;IAC3B,SAAS,IAAI;IACb,eAAe,IAAA;IACf,UAAU,IAAA;IACV,gBAAgB,IAAA;IAChB,UAAU,IAAA;IACV,UAAU,IAAA;CACX;AACD,MAAM,MAAM,uBAAuB,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAErE,oBAAY,iBAAiB;IAC3B,MAAM,IAAI;IACV,KAAK,IAAA;IACL,OAAO,IAAA;IAGP,aAAa,IAAA;IACb,WAAW,IAAA;IACX,mBAAmB,IAAA;CACpB;AACD,MAAM,MAAM,uBAAuB,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAErE,oBAAY,SAAS;IAEnB,QAAQ,IAAS;IACjB,QAAQ,IAAS;IACjB,SAAS,IAAS;IAGlB,iBAAiB,IAAS;IAC1B,eAAe,KAAS;IACxB,UAAU,KAAS;IACnB,WAAW,KAAS;IACpB,mBAAmB,MAAS;IAC5B,UAAU,MAAS;IACnB,aAAa,MAAS;IACtB,qBAAqB,OAAU;IAC/B,YAAY,OAAU;IACtB,YAAY,OAAU;IAGtB,KAAK,OAAU;IACf,SAAS,QAAU;IACnB,SAAS,QAAU;IACnB,IAAI,QAAU;IACd,aAAa,SAAU;IAGvB,MAAM,SAAU;CACjB;AACD,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,SAAS,CAAC;AAErD,oBAAY,aAAa;IAEvB,OAAO,KAAK;IACZ,YAAY,IAGS;IACrB,UAAU,OAUc;IACxB,QAAQ,SAKiB;IACzB,MAAM,MAGgB;IACtB,QAAQ,OAGgB;IACxB,QAAQ,OAAyD;CAElE;AACD,MAAM,MAAM,mBAAmB,GAAG,MAAM,OAAO,aAAa,CAAC;AAC7D,MAAM,MAAM,gCAAgC,GACxC,mBAAmB,GACnB,eAAe,CAAC;AAEpB,oBAAY,SAAS;IAEnB,KAAK,IAAS;IAEd,QAAQ,IAAS;IAEjB,MAAM,IAAS;IAEf,MAAM,IAAS;IACf,SAAS,KAAS;IAClB,OAAO,KAAS;IAChB,UAAU,KAAS;IACnB,QAAQ,MAAS;IAEjB,YAAY,MAAS;IAErB,MAAM,MAAS;IAEf,QAAQ,OAAU;IAElB,MAAM,OAAU;IAEhB,cAAc,OAAU;IAExB,QAAQ,OAAU;IAElB,KAAK,QAAU;IAEf,OAAO,QAAU;IAEjB,SAAS,QAAU;CAGpB;AACD,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,SAAS,CAAC;AAErD,oBAAY,aAAa;IACvB,OAAO,SAAU;IACjB,MAAM,SAAU;IAChB,MAAM,SAAU;IAChB,QAAQ,UAAU;IAClB,KAAK,UAAU;CAChB;AACD,MAAM,MAAM,mBAAmB,GAAG,MAAM,OAAO,aAAa,CAAC"}

package/dist/rules/naming-convention-utils/enums.js

@@ -100,4 +100,3 @@ var TypeModifiers;
     TypeModifiers[TypeModifiers["function"] = 1048576] = "function";
     TypeModifiers[TypeModifiers["array"] = 2097152] = "array";
 })(TypeModifiers || (exports.TypeModifiers = TypeModifiers = {}));
-//# sourceMappingURL=enums.js.map

package/dist/rules/naming-convention-utils/format.d.ts

@@ -0,0 +1,3 @@
+import { PredefinedFormats } from './enums';
+export declare const PredefinedFormatToCheckFunction: Readonly<Record<PredefinedFormats, (name: string) => boolean>>;
+//# sourceMappingURL=format.d.ts.map

package/dist/rules/naming-convention-utils/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/rules/naming-convention-utils/format.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAkG5C,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAQrD,CAAC"}

package/dist/rules/naming-convention-utils/format.js

@@ -87,4 +87,3 @@ exports.PredefinedFormatToCheckFunction = {
     [enums_1.PredefinedFormats.StrictPascalCase]: isStrictPascalCase,
     [enums_1.PredefinedFormats.UPPER_CASE]: isUpperCase,
 };
-//# sourceMappingURL=format.js.map

package/dist/rules/naming-convention-utils/index.d.ts

@@ -0,0 +1,7 @@
+export { Modifiers } from './enums';
+export type { PredefinedFormatsString } from './enums';
+export { parseOptions } from './parse-options';
+export { SCHEMA } from './schema';
+export { selectorTypeToMessageString } from './shared';
+export type { Context, Selector, ValidatorFunction } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/rules/naming-convention-utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rules/naming-convention-utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,YAAY,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,2BAA2B,EAAE,MAAM,UAAU,CAAC;AACvD,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC"}

package/dist/rules/naming-convention-utils/index.js

@@ -9,4 +9,3 @@ var schema_1 = require("./schema");
 Object.defineProperty(exports, "SCHEMA", { enumerable: true, get: function () { return schema_1.SCHEMA; } });
 var shared_1 = require("./shared");
 Object.defineProperty(exports, "selectorTypeToMessageString", { enumerable: true, get: function () { return shared_1.selectorTypeToMessageString; } });
-//# sourceMappingURL=index.js.map

package/dist/rules/naming-convention-utils/parse-options.d.ts

@@ -0,0 +1,3 @@
+import type { Context, ParsedOptions } from './types';
+export declare function parseOptions(context: Context): ParsedOptions;
+//# sourceMappingURL=parse-options.d.ts.map

package/dist/rules/naming-convention-utils/parse-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-options.d.ts","sourceRoot":"","sources":["../../../src/rules/naming-convention-utils/parse-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAEP,aAAa,EAEd,MAAM,SAAS,CAAC;AA6EjB,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,aAAa,CAS5D"}

package/dist/rules/naming-convention-utils/parse-options.js

@@ -67,4 +67,3 @@ function parseOptions(context) {
         (0, validator_1.createValidator)(k, context, normalizedOptions),
     ]));
 }
-//# sourceMappingURL=parse-options.js.map

package/dist/rules/naming-convention-utils/schema.d.ts

@@ -0,0 +1,3 @@
+import type { JSONSchema } from '@typescript-eslint/utils';
+export declare const SCHEMA: JSONSchema.JSONSchema4;
+//# sourceMappingURL=schema.d.ts.map

package/dist/rules/naming-convention-utils/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/rules/naming-convention-utils/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AA2L3D,eAAO,MAAM,MAAM,EAAE,UAAU,CAAC,WA+I/B,CAAC"}

package/dist/rules/naming-convention-utils/schema.js

@@ -303,4 +303,3 @@ exports.SCHEMA = {
     },
     type: 'array',
 };
-//# sourceMappingURL=schema.js.map

package/dist/rules/naming-convention-utils/shared.d.ts

@@ -0,0 +1,6 @@
+import type { IndividualAndMetaSelectorsString, MetaSelectorsString, Selectors, SelectorsString } from './enums';
+import { MetaSelectors } from './enums';
+export declare function selectorTypeToMessageString(selectorType: SelectorsString): string;
+export declare function isMetaSelector(selector: IndividualAndMetaSelectorsString | MetaSelectors | Selectors): selector is MetaSelectorsString;
+export declare function isMethodOrPropertySelector(selector: IndividualAndMetaSelectorsString | MetaSelectors | Selectors): boolean;
+//# sourceMappingURL=shared.d.ts.map

package/dist/rules/naming-convention-utils/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/rules/naming-convention-utils/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gCAAgC,EAChC,mBAAmB,EACnB,SAAS,EACT,eAAe,EAChB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,eAAe,GAC5B,MAAM,CAGR;AAED,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,gCAAgC,GAAG,aAAa,GAAG,SAAS,GACrE,QAAQ,IAAI,mBAAmB,CAEjC;AAED,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,gCAAgC,GAAG,aAAa,GAAG,SAAS,GACrE,OAAO,CAIT"}

package/dist/rules/naming-convention-utils/shared.js

@@ -14,4 +14,3 @@ function isMetaSelector(selector) {
 function isMethodOrPropertySelector(selector) {
     return (selector === enums_1.MetaSelectors.method || selector === enums_1.MetaSelectors.property);
 }
-//# sourceMappingURL=shared.js.map

package/dist/rules/naming-convention-utils/types.d.ts

@@ -0,0 +1,40 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+import type { MessageIds, Options } from '../naming-convention';
+import type { IndividualAndMetaSelectorsString, MetaSelectors, Modifiers, ModifiersString, PredefinedFormats, PredefinedFormatsString, Selectors, SelectorsString, TypeModifiers, TypeModifiersString, UnderscoreOptions, UnderscoreOptionsString } from './enums';
+export interface MatchRegex {
+    match: boolean;
+    regex: string;
+}
+export interface Selector {
+    custom?: MatchRegex;
+    filter?: string | MatchRegex;
+    format: PredefinedFormatsString[] | null;
+    leadingUnderscore?: UnderscoreOptionsString;
+    modifiers?: ModifiersString[];
+    prefix?: string[];
+    selector: IndividualAndMetaSelectorsString | IndividualAndMetaSelectorsString[];
+    suffix?: string[];
+    trailingUnderscore?: UnderscoreOptionsString;
+    types?: TypeModifiersString[];
+}
+export interface NormalizedMatchRegex {
+    match: boolean;
+    regex: RegExp;
+}
+export interface NormalizedSelector {
+    custom: NormalizedMatchRegex | null;
+    filter: NormalizedMatchRegex | null;
+    format: PredefinedFormats[] | null;
+    leadingUnderscore: UnderscoreOptions | null;
+    modifiers: Modifiers[] | null;
+    modifierWeight: number;
+    prefix: string[] | null;
+    selector: MetaSelectors | Selectors;
+    suffix: string[] | null;
+    trailingUnderscore: UnderscoreOptions | null;
+    types: TypeModifiers[] | null;
+}
+export type ValidatorFunction = (node: TSESTree.Identifier | TSESTree.Literal | TSESTree.PrivateIdentifier, modifiers?: Set<Modifiers>) => void;
+export type ParsedOptions = Record<SelectorsString, ValidatorFunction>;
+export type Context = Readonly<TSESLint.RuleContext<MessageIds, Options>>;
+//# sourceMappingURL=types.d.ts.map

package/dist/rules/naming-convention-utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/rules/naming-convention-utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EACV,gCAAgC,EAChC,aAAa,EACb,SAAS,EACT,eAAe,EACf,iBAAiB,EACjB,uBAAuB,EACvB,SAAS,EACT,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,EACxB,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,QAAQ;IACvB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAE7B,MAAM,EAAE,uBAAuB,EAAE,GAAG,IAAI,CAAC;IACzC,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;IAC5C,SAAS,CAAC,EAAE,eAAe,EAAE,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAElB,QAAQ,EACJ,gCAAgC,GAChC,gCAAgC,EAAE,CAAC;IACvC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,kBAAkB,CAAC,EAAE,uBAAuB,CAAC;IAC7C,KAAK,CAAC,EAAE,mBAAmB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACpC,MAAM,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAEpC,MAAM,EAAE,iBAAiB,EAAE,GAAG,IAAI,CAAC;IACnC,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC5C,SAAS,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAE9B,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAExB,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACxB,kBAAkB,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC7C,KAAK,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,MAAM,iBAAiB,GAAG,CAC9B,IAAI,EAAE,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,iBAAiB,EACzE,SAAS,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,KACvB,IAAI,CAAC;AACV,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC;AACvE,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC"}

package/dist/rules/naming-convention-utils/types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/dist/rules/naming-convention-utils/validator.d.ts

@@ -0,0 +1,5 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { SelectorsString } from './enums';
+import type { Context, NormalizedSelector } from './types';
+export declare function createValidator(type: SelectorsString, context: Context, allConfigs: NormalizedSelector[]): (node: TSESTree.Identifier | TSESTree.Literal | TSESTree.PrivateIdentifier) => void;
+//# sourceMappingURL=validator.d.ts.map