@depup/typescript-eslint__eslint-plugin 8.57.1-depup.0

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'default-param-last',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce default parameters to be last',
+            extendsBaseRule: true,
+            frozen: true,
+        },
+        messages: {
+            shouldBeLast: 'Default parameters should be last.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * checks if node is optional parameter
+         * @param node the node to be evaluated
+         * @private
+         */
+        function isOptionalParam(node) {
+            return ((node.type === utils_1.AST_NODE_TYPES.ArrayPattern ||
+                node.type === utils_1.AST_NODE_TYPES.AssignmentPattern ||
+                node.type === utils_1.AST_NODE_TYPES.Identifier ||
+                node.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                node.type === utils_1.AST_NODE_TYPES.RestElement) &&
+                node.optional);
+        }
+        /**
+         * checks if node is plain parameter
+         * @param node the node to be evaluated
+         * @private
+         */
+        function isPlainParam(node) {
+            return !(node.type === utils_1.AST_NODE_TYPES.AssignmentPattern ||
+                node.type === utils_1.AST_NODE_TYPES.RestElement ||
+                isOptionalParam(node));
+        }
+        function checkDefaultParamLast(node) {
+            let hasSeenPlainParam = false;
+            for (let i = node.params.length - 1; i >= 0; i--) {
+                const current = node.params[i];
+                const param = current.type === utils_1.AST_NODE_TYPES.TSParameterProperty
+                    ? current.parameter
+                    : current;
+                if (isPlainParam(param)) {
+                    hasSeenPlainParam = true;
+                    continue;
+                }
+                if (hasSeenPlainParam &&
+                    (isOptionalParam(param) ||
+                        param.type === utils_1.AST_NODE_TYPES.AssignmentPattern)) {
+                    context.report({ node: current, messageId: 'shouldBeLast' });
+                }
+            }
+        }
+        return {
+            ArrowFunctionExpression: checkDefaultParamLast,
+            FunctionDeclaration: checkDefaultParamLast,
+            FunctionExpression: checkDefaultParamLast,
+        };
+    },
+});

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

@@ -0,0 +1,23 @@
+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> & {
+    name: string;
+};
+export default _default;

package/dist/rules/dot-notation.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+const getESLintCoreRule_1 = require("../util/getESLintCoreRule");
+const baseRule = (0, getESLintCoreRule_1.getESLintCoreRule)('dot-notation');
+const defaultOptions = [
+    {
+        allowIndexSignaturePropertyAccess: false,
+        allowKeywords: true,
+        allowPattern: '',
+        allowPrivateClassPropertyAccess: false,
+        allowProtectedClassPropertyAccess: false,
+    },
+];
+exports.default = (0, util_1.createRule)({
+    name: 'dot-notation',
+    meta: {
+        type: 'suggestion',
+        defaultOptions,
+        docs: {
+            description: 'Enforce dot notation whenever possible',
+            extendsBaseRule: true,
+            frozen: true,
+            recommended: 'stylistic',
+            requiresTypeChecking: true,
+        },
+        fixable: baseRule.meta.fixable,
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        messages: baseRule.meta.messages,
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowIndexSignaturePropertyAccess: {
+                        type: 'boolean',
+                        description: 'Whether to allow accessing properties matching an index signature with array notation.',
+                    },
+                    allowKeywords: {
+                        type: 'boolean',
+                        description: 'Whether to allow keywords such as ["class"]`.',
+                    },
+                    allowPattern: {
+                        type: 'string',
+                        description: 'Regular expression of names to allow.',
+                    },
+                    allowPrivateClassPropertyAccess: {
+                        type: 'boolean',
+                        description: 'Whether to allow accessing class members marked as `private` with array notation.',
+                    },
+                    allowProtectedClassPropertyAccess: {
+                        type: 'boolean',
+                        description: 'Whether to allow accessing class members marked as `protected` with array notation.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions,
+    create(context, [options]) {
+        const rules = baseRule.create(context);
+        const services = (0, util_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        const allowPrivateClassPropertyAccess = options.allowPrivateClassPropertyAccess;
+        const allowProtectedClassPropertyAccess = options.allowProtectedClassPropertyAccess;
+        const allowIndexSignaturePropertyAccess = (options.allowIndexSignaturePropertyAccess ?? false) ||
+            tsutils.isCompilerOptionEnabled(services.program.getCompilerOptions(), 'noPropertyAccessFromIndexSignature');
+        return {
+            MemberExpression(node) {
+                if ((allowPrivateClassPropertyAccess ||
+                    allowProtectedClassPropertyAccess ||
+                    allowIndexSignaturePropertyAccess) &&
+                    node.computed) {
+                    // for perf reasons - only fetch symbols if we have to
+                    const propertySymbol = services.getSymbolAtLocation(node.property) ??
+                        services
+                            .getTypeAtLocation(node.object)
+                            .getNonNullableType()
+                            .getProperties()
+                            .find(propertySymbol => node.property.type === utils_1.AST_NODE_TYPES.Literal &&
+                            propertySymbol.escapedName === node.property.value);
+                    const modifierKind = (0, util_1.getModifiers)(propertySymbol?.getDeclarations()?.[0])?.[0].kind;
+                    if ((allowPrivateClassPropertyAccess &&
+                        modifierKind === ts.SyntaxKind.PrivateKeyword) ||
+                        (allowProtectedClassPropertyAccess &&
+                            modifierKind === ts.SyntaxKind.ProtectedKeyword)) {
+                        return;
+                    }
+                    if (propertySymbol == null && allowIndexSignaturePropertyAccess) {
+                        const objectType = services
+                            .getTypeAtLocation(node.object)
+                            .getNonNullableType();
+                        const indexInfos = checker.getIndexInfosOfType(objectType);
+                        if (indexInfos.some(info => tsutils.isTypeFlagSet(info.keyType, ts.TypeFlags.StringLike))) {
+                            return;
+                        }
+                    }
+                }
+                rules.MemberExpression(node);
+            },
+        };
+    },
+});

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

@@ -0,0 +1,36 @@
+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;

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

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnumLiterals = getEnumLiterals;
+exports.getEnumTypes = getEnumTypes;
+exports.getEnumKeyForLiteral = getEnumKeyForLiteral;
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../../util");
+/*
+ * If passed an enum member, returns the type of the parent. Otherwise,
+ * returns itself.
+ *
+ * For example:
+ * - `Fruit` --> `Fruit`
+ * - `Fruit.Apple` --> `Fruit`
+ */
+function getBaseEnumType(typeChecker, type) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const symbol = type.getSymbol();
+    if (!tsutils.isSymbolFlagSet(symbol, ts.SymbolFlags.EnumMember)) {
+        return type;
+    }
+    return typeChecker.getTypeAtLocation(symbol.valueDeclaration.parent);
+}
+/**
+ * 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]
+ */
+function getEnumLiterals(type) {
+    return tsutils
+        .unionConstituents(type)
+        .filter((subType) => (0, util_1.isTypeFlagSet)(subType, ts.TypeFlags.EnumLiteral));
+}
+/**
+ * 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]
+ */
+function getEnumTypes(typeChecker, type) {
+    return getEnumLiterals(type).map(type => getBaseEnumType(typeChecker, 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
+ * ```
+ */
+function getEnumKeyForLiteral(enumLiterals, literal) {
+    for (const enumLiteral of enumLiterals) {
+        if (enumLiteral.value === literal) {
+            const { symbol } = enumLiteral;
+            const memberDeclaration = symbol.valueDeclaration;
+            const enumDeclaration = memberDeclaration.parent;
+            const memberNameIdentifier = memberDeclaration.name;
+            const enumName = enumDeclaration.name.text;
+            switch (memberNameIdentifier.kind) {
+                case ts.SyntaxKind.Identifier:
+                    return `${enumName}.${memberNameIdentifier.text}`;
+                case ts.SyntaxKind.StringLiteral: {
+                    const memberName = memberNameIdentifier.text.replaceAll("'", "\\'");
+                    return `${enumName}['${memberName}']`;
+                }
+                case ts.SyntaxKind.ComputedPropertyName:
+                    return `${enumName}[${memberNameIdentifier.expression.getText()}]`;
+                default:
+                    break;
+            }
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,17 @@
+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> & {
+    name: string;
+};
+export default _default;

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+const explicitReturnTypeUtils_1 = require("../util/explicitReturnTypeUtils");
+exports.default = (0, util_1.createRule)({
+    name: 'explicit-function-return-type',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require explicit return types on functions and class methods',
+        },
+        messages: {
+            missingReturnType: 'Missing return type on function.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowConciseArrowFunctionExpressionsStartingWithVoid: {
+                        type: 'boolean',
+                        description: 'Whether to allow arrow functions that start with the `void` keyword.',
+                    },
+                    allowDirectConstAssertionInArrowFunctions: {
+                        type: 'boolean',
+                        description: 'Whether to ignore arrow functions immediately returning a `as const` value.',
+                    },
+                    allowedNames: {
+                        type: 'array',
+                        description: 'An array of function/method names that will not have their arguments or return values checked.',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    allowExpressions: {
+                        type: 'boolean',
+                        description: 'Whether to ignore function expressions (functions which are not part of a declaration).',
+                    },
+                    allowFunctionsWithoutTypeParameters: {
+                        type: 'boolean',
+                        description: "Whether to ignore functions that don't have generic type parameters.",
+                    },
+                    allowHigherOrderFunctions: {
+                        type: 'boolean',
+                        description: 'Whether to ignore functions immediately returning another function expression.',
+                    },
+                    allowIIFEs: {
+                        type: 'boolean',
+                        description: 'Whether to ignore immediately invoked function expressions (IIFEs).',
+                    },
+                    allowTypedFunctionExpressions: {
+                        type: 'boolean',
+                        description: 'Whether to ignore type annotations on the variable of function expressions.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowConciseArrowFunctionExpressionsStartingWithVoid: false,
+            allowDirectConstAssertionInArrowFunctions: true,
+            allowedNames: [],
+            allowExpressions: false,
+            allowFunctionsWithoutTypeParameters: false,
+            allowHigherOrderFunctions: true,
+            allowIIFEs: false,
+            allowTypedFunctionExpressions: true,
+        },
+    ],
+    create(context, [options]) {
+        const functionInfoStack = [];
+        function enterFunction(node) {
+            functionInfoStack.push({
+                node,
+                returns: [],
+            });
+        }
+        function popFunctionInfo(exitNodeType) {
+            return (0, util_1.nullThrows)(functionInfoStack.pop(), `Stack should exist on ${exitNodeType} exit`);
+        }
+        function isAllowedFunction(node) {
+            if (options.allowFunctionsWithoutTypeParameters && !node.typeParameters) {
+                return true;
+            }
+            if (options.allowIIFEs && isIIFE(node)) {
+                return true;
+            }
+            if (!options.allowedNames?.length) {
+                return false;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                node.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                const parent = node.parent;
+                let funcName;
+                if (node.id?.name) {
+                    funcName = node.id.name;
+                }
+                else {
+                    switch (parent.type) {
+                        case utils_1.AST_NODE_TYPES.VariableDeclarator: {
+                            if (parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                funcName = parent.id.name;
+                            }
+                            break;
+                        }
+                        case utils_1.AST_NODE_TYPES.MethodDefinition:
+                        case utils_1.AST_NODE_TYPES.PropertyDefinition:
+                        case utils_1.AST_NODE_TYPES.Property: {
+                            if (parent.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                !parent.computed) {
+                                funcName = parent.key.name;
+                            }
+                            break;
+                        }
+                    }
+                }
+                if (!!funcName && options.allowedNames.includes(funcName)) {
+                    return true;
+                }
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+                node.id &&
+                options.allowedNames.includes(node.id.name)) {
+                return true;
+            }
+            return false;
+        }
+        function isIIFE(node) {
+            return node.parent.type === utils_1.AST_NODE_TYPES.CallExpression;
+        }
+        function exitFunctionExpression(node) {
+            const info = popFunctionInfo('function expression');
+            if (options.allowConciseArrowFunctionExpressionsStartingWithVoid &&
+                node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                node.expression &&
+                node.body.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                node.body.operator === 'void') {
+                return;
+            }
+            if (isAllowedFunction(node)) {
+                return;
+            }
+            if (options.allowTypedFunctionExpressions &&
+                ((0, explicitReturnTypeUtils_1.isValidFunctionExpressionReturnType)(node, options) ||
+                    (0, explicitReturnTypeUtils_1.ancestorHasReturnType)(node))) {
+                return;
+            }
+            (0, explicitReturnTypeUtils_1.checkFunctionReturnType)(info, options, context.sourceCode, loc => context.report({
+                loc,
+                node,
+                messageId: 'missingReturnType',
+            }));
+        }
+        return {
+            'ArrowFunctionExpression, FunctionExpression, FunctionDeclaration': enterFunction,
+            'ArrowFunctionExpression:exit': exitFunctionExpression,
+            'FunctionDeclaration:exit'(node) {
+                const info = popFunctionInfo('function declaration');
+                if (isAllowedFunction(node)) {
+                    return;
+                }
+                if (options.allowTypedFunctionExpressions && node.returnType) {
+                    return;
+                }
+                (0, explicitReturnTypeUtils_1.checkFunctionReturnType)(info, options, context.sourceCode, loc => context.report({
+                    loc,
+                    node,
+                    messageId: 'missingReturnType',
+                }));
+            },
+            'FunctionExpression:exit': exitFunctionExpression,
+            ReturnStatement(node) {
+                functionInfoStack.at(-1)?.returns.push(node);
+            },
+        };
+    },
+});

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

@@ -0,0 +1,19 @@
+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> & {
+    name: string;
+};
+export default _default;