## API Report File for "@api-extractor-tools/eslint-plugin"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { DocComment } from '@microsoft/tsdoc';
import { ParserContext } from '@microsoft/tsdoc';
import { RuleListener } from '@typescript-eslint/utils/dist/ts-eslint';
import { RuleModule } from '@typescript-eslint/utils/dist/ts-eslint';
import type { TSESLint } from '@typescript-eslint/utils';
import type { TSESTree } from '@typescript-eslint/utils';

// @alpha
export interface ApiExtractorConfig {
    // (undocumented)
    extends?: string;
    // (undocumented)
    mainEntryPointFilePath?: string;
    // (undocumented)
    messages?: ApiExtractorMessagesConfig;
}

// @alpha
export interface ApiExtractorEslintPlugin {
    // Warning: (ae-forgotten-export) The symbol "PluginConfigs" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    configs: PluginConfigs;
    // (undocumented)
    meta: {
        name: string;
        version: string;
    };
    // (undocumented)
    rules: typeof rules;
}

// @alpha
export type ApiExtractorLogLevel = 'error' | 'none' | 'warning';

// @alpha
export interface ApiExtractorMessagesConfig {
    // (undocumented)
    compilerMessageReporting?: {
        [messageId: string]: MessageConfig | undefined;
        default?: MessageConfig;
    };
    // (undocumented)
    extractorMessageReporting?: {
        'ae-extra-release-tag'?: MessageConfig;
        'ae-forgotten-export'?: MessageConfig;
        'ae-incompatible-release-tags'?: MessageConfig;
        'ae-internal-missing-underscore'?: MessageConfig;
        'ae-missing-release-tag'?: MessageConfig;
        [messageId: string]: MessageConfig | undefined;
        default?: MessageConfig;
    };
    // (undocumented)
    tsdocMessageReporting?: {
        [messageId: string]: MessageConfig | undefined;
        default?: MessageConfig;
    };
}

// @alpha
export interface EnumTypeExtraction {
    count: number;
    found: boolean;
    isValid: boolean;
    rawValue?: string;
    value?: string;
}

// @alpha
export type EnumTypeValue = 'closed' | 'open';

// @alpha
export function extractEnumType(commentText: string): EnumTypeExtraction;

// @alpha
export function extractReleaseTag(docComment: DocComment): ReleaseTag | undefined;

// @alpha
export interface ExtraReleaseTagRuleOptions {
    severity?: ApiExtractorLogLevel;
}

// @alpha
export function findAllTSDocComments(sourceCode: { getAllComments: () => TSESTree.Comment[] }): Array<{
    comment: TSESTree.Comment;
    parsed: ParserContext;
}>;

// @alpha
export interface ForgottenExportRuleOptions {
    severity?: ApiExtractorLogLevel;
}

// @alpha
export function getLeadingTSDocComment(sourceCode: { getCommentsBefore: (node: TSESTree.Node) => TSESTree.Comment[] }, node: TSESTree.Node): string | undefined;

// @alpha @override
export function hasOverrideTag(docComment: DocComment): boolean;

// @alpha
export function hasPackageDocumentation(docComment: DocComment): boolean;

// @alpha
export interface IncompatibleReleaseTagsRuleOptions {
    severity?: ApiExtractorLogLevel;
}

// @alpha
export interface MessageConfig {
    // (undocumented)
    addToApiReportFile?: boolean;
    // (undocumented)
    logLevel: ApiExtractorLogLevel;
}

// @alpha
export interface MissingReleaseTagRuleOptions {
    severity?: ApiExtractorLogLevel;
}

// @alpha
export type OverrideKeywordRuleOptions = Record<string, never>;

// @alpha
export type PackageDocumentationRuleOptions = Record<string, never>;

// @alpha
export function parseTSDocComment(commentText: string): ParserContext;

// @alpha
const plugin: ApiExtractorEslintPlugin;
export default plugin;

// @alpha
export interface PublicOnNonExportedRuleOptions {
    severity?: ApiExtractorLogLevel;
}

// @alpha
export interface PublicOnPrivateMemberRuleOptions {
    severity?: ApiExtractorLogLevel;
}

// @alpha
export const recommendedRules: TSESLint.Linter.RulesRecord;

// @alpha
export const RELEASE_TAGS: readonly ReleaseTag[];

// @alpha
export type ReleaseTag = 'alpha' | 'beta' | 'internal' | 'public';

// @alpha
export interface ResolvedEntryPoints {
    // (undocumented)
    exports: string[];
    // (undocumented)
    main?: string;
    // (undocumented)
    types?: string;
}

// @alpha
export const rules: {
    readonly 'extra-release-tag': RuleModule<"extraReleaseTag", [ExtraReleaseTagRuleOptions], unknown, RuleListener>;
    readonly 'forgotten-export': RuleModule<"forgottenExport", [ForgottenExportRuleOptions], unknown, RuleListener>;
    readonly 'incompatible-release-tags': RuleModule<"incompatibleReleaseTags", [IncompatibleReleaseTagsRuleOptions], unknown, RuleListener>;
    readonly 'missing-release-tag': RuleModule<"missingReleaseTag", [MissingReleaseTagRuleOptions], unknown, RuleListener>;
    readonly 'override-keyword': RuleModule<"missingOverrideKeyword", [OverrideKeywordRuleOptions], unknown, RuleListener>;
    readonly 'package-documentation': RuleModule<"missingPackageDocumentation" | "unexpectedPackageDocumentation", [PackageDocumentationRuleOptions], unknown, RuleListener>;
    readonly 'public-on-non-exported': RuleModule<"publicOnNonExported", [PublicOnNonExportedRuleOptions], unknown, RuleListener>;
    readonly 'public-on-private-member': RuleModule<"publicOnPrivateMember", [PublicOnPrivateMemberRuleOptions], unknown, RuleListener>;
    readonly 'valid-enum-type': RuleModule<"missingValue" | "invalidValue" | "multipleEnumTypes" | "invalidConstruct" | "missingEnumType", [ValidEnumTypeRuleOptions], unknown, RuleListener>;
};

// @alpha
export interface ValidEnumTypeRuleOptions {
    requireOnExported?: boolean;
}

```