## API Report File for "claude-code-lint"

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

```ts

// @public
export abstract class BaseFormatter implements Formatter {
    constructor(options?: FormatterOptions);
    // (undocumented)
    abstract format(results: LintResult[]): string;
    protected getRelativePath(filePath: string): string;
    protected getSummary(results: LintResult[]): {
        fileCount: number;
        errorCount: number;
        warningCount: number;
        fixableErrorCount: number;
        fixableWarningCount: number;
        totalIssues: number;
    };
    // (undocumented)
    protected options: FormatterOptions;
}

// @public
export const BUILTIN_FORMATTERS: readonly ["stylish", "json", "compact", "sarif", "github"];

// @public (undocumented)
export type BuiltinFormatterName = (typeof BUILTIN_FORMATTERS)[number];

// @public
export class ClaudeLint {
    constructor(options?: ClaudeLintOptions);
    calculateConfigForFile(filePath: string): Promise<ClaudeLintConfig>;
    static findConfigFile(cwd: string): string | null;
    static getErrorResults(results: LintResult[]): LintResult[];
    static getFixedContent(results: LintResult[]): Map<string, string>;
    getRules(): Map<string, RuleMetadata>;
    getRulesMetaForResults(results: LintResult[]): Map<string, RuleMetadata>;
    static getVersion(): string;
    static getWarningResults(results: LintResult[]): LintResult[];
    isPathIgnored(filePath: string): boolean;
    lintFiles(patterns: string[]): Promise<LintResult[]>;
    lintText(code: string, options?: LintTextOptions): Promise<LintResult[]>;
    loadFormatter(nameOrPath: string): Promise<Formatter>;
    static outputFixes(results: LintResult[]): Promise<void>;
}

// @public
export interface ClaudeLintConfig {
    extends?: string | string[];
    ignorePatterns?: string[];
    maxWarnings?: number;
    output?: {
        format?: 'stylish' | 'json' | 'compact' | 'sarif' | 'github';
        verbose?: boolean;
        color?: boolean;
        collapseRepetitive?: boolean;
    };
    overrides?: ConfigOverride[];
    reportUnusedDisableDirectives?: boolean;
    rules?: Record<string, RuleConfig | 'off' | 'warn' | 'error'>;
}

// @public
export interface ClaudeLintOptions {
    allowInlineConfig?: boolean;
    cache?: boolean;
    cacheLocation?: string;
    cacheStrategy?: 'metadata' | 'content';
    config?: ClaudeLintConfig;
    cwd?: string;
    errorOnUnmatchedPattern?: boolean;
    fix?: boolean | ((message: LintMessage) => boolean);
    fixTypes?: string[];
    ignore?: boolean;
    ignorePatterns?: string[];
    onComplete?: (results: LintResult[]) => void;
    onProgress?: (file: string, index: number, total: number) => void;
    onStart?: (fileCount: number) => void;
    overrideConfigFile?: string;
    reportUnusedDisableDirectives?: boolean;
    ruleFilter?: (ruleId: string) => boolean;
}

// @public
export interface ConfigOptions {
    cwd?: string;
}

// @public
export interface ConfigOverride {
    files: string[];
    rules: Record<string, RuleConfig | 'off' | 'warn' | 'error'>;
}

// @public
export interface FileInfo {
    ignored: boolean;
    validators: string[];
}

// @public
export interface FileInfoOptions {
    cwd?: string;
}

// @public
export function findConfigFile(startDir: string): string | null;

// @public
export interface FixInfo {
    range: [number, number];
    text: string;
}

// @public
export function formatResults(results: LintResult[], formatterName?: string, options?: {
    cwd?: string;
}): Promise<string>;

// @public
export interface Formatter {
    format(results: LintResult[]): string;
}

// @public
export interface FormatterOptions {
    color?: boolean;
    cwd?: string;
}

// @public
export function getFileInfo(filePath: string, options?: {
    cwd?: string;
}): Promise<FileInfo>;

// @public
export function isBuiltinFormatter(name: string): name is BuiltinFormatterName;

// @public
export function lint(patterns: string[], options?: LintOptions): Promise<LintResult[]>;

// @public
export interface LintMessage {
    column?: number;
    endColumn?: number;
    endLine?: number;
    explanation?: string;
    fix?: FixInfo;
    howToFix?: string;
    line?: number;
    message: string;
    ruleId: string | null;
    severity: 'error' | 'warning';
    suggestions?: SuggestionInfo[];
}

// @public
export type LintOptions = ClaudeLintOptions;

// @public
export interface LintResult {
    // Warning: (ae-forgotten-export) The symbol "DeprecatedRuleUsage" needs to be exported by the entry point index.d.ts
    deprecatedRulesUsed?: DeprecatedRuleUsage[];
    errorCount: number;
    filePath: string;
    fixableErrorCount: number;
    fixableWarningCount: number;
    messages: LintMessage[];
    output?: string;
    source?: string;
    stats?: {
        validationTime: number;
    };
    suppressedMessages: LintMessage[];
    warningCount: number;
}

// @public
export function lintText(code: string, options?: LintTextOptions): Promise<LintResult[]>;

// @public
export interface LintTextOptions {
    filePath?: string;
    warnIgnored?: boolean;
}

// @public
export function loadConfig(configPath: string): ClaudeLintConfig;

// @public
export function loadFormatter(nameOrPath: string, options?: LoadFormatterOptions): Promise<Formatter>;

// @public
export interface LoadFormatterOptions {
    cwd?: string;
}

// @public
export function resolveConfig(filePath: string, options?: {
    cwd?: string;
}): Promise<ClaudeLintConfig>;

// @public
export interface RuleConfig {
    options?: Record<string, unknown>;
    severity: 'off' | 'warn' | 'error';
}

// @public
export interface RuleMetadata {
    category: string;
    description: string;
    docs?: string;
    explanation?: string;
    fixable: boolean;
    ruleId: string;
    severity: 'error' | 'warning';
}

// @public
export interface SuggestionInfo {
    desc: string;
    fix: FixInfo;
}

// (No @packageDocumentation comment for this package)

```
