cspell 9.0.1 → 9.1.0

package/dist/esm/options.d.ts

@@ -1,6 +1,6 @@
-import { CSpellSettings } from '@cspell/cspell-types';
+import { CSpellSettings, ReporterConfiguration } from '@cspell/cspell-types';
 import type { CacheOptions } from './util/cache/index.js';
-export interface LinterOptions extends Omit<BaseOptions, 'config'>, Omit<CacheOptions, 'version'> {
+export interface LinterOptions extends Omit<BaseOptions, 'config'>, Omit<CacheOptions, 'version'>, ReporterConfiguration {
     /**
      * Display verbose information
      */
@@ -33,8 +33,8 @@ export interface LinterOptions extends Omit<BaseOptions, 'config'>, Omit<CacheOp
     dot?: boolean;
     /**
      * Show part of a line where an issue is found.
-     * if true, it will show the default number of characters on either side.
-     * if a number, it will shat number of characters on either side.
+     * - if true, it will show the default number of characters on either side.
+     * - if a number, the number of characters to show on either side of the issue.
      */
     showContext?: boolean | number;
     /**
@@ -75,10 +75,22 @@ export interface LinterOptions extends Omit<BaseOptions, 'config'>, Omit<CacheOp
      * Files must be found and processed otherwise it is considered an error.
      */
     mustFindFiles?: boolean;
+    /**
+     * List of dictionary names to use.
+     */
+    dictionary?: string[] | undefined;
+    /**
+     * List of dictionary names to disable.
+     */
+    disableDictionary?: string[] | undefined;
     /**
      * Stop processing and exit if an issue or error is found.
      */
     failFast?: boolean;
+    /**
+     * Keep going even if an error is found.
+     */
+    continueOnError?: boolean;
     /**
      * Optional list of reporters to use, overriding any specified in the
      * configuration.
@@ -94,11 +106,34 @@ export interface LinterOptions extends Omit<BaseOptions, 'config'>, Omit<CacheOp
     config?: string | CSpellConfigFile;
 }
 export interface TraceOptions extends BaseOptions {
+    /**
+     * Use stdin for the input.
+     */
     stdin?: boolean;
+    /**
+     * Enable the `allowCompoundWords` option.
+     */
     allowCompoundWords?: boolean;
+    /**
+     * Ignore case and accents when searching for words.
+     */
     ignoreCase?: boolean;
+    /**
+     * Show all dictionaries, not just the ones that contain the words or are enabled.
+     */
     all?: boolean;
+    /**
+     * Show only dictionaries that contain the words.
+     * If `all` is set, this option is ignored.
+     */
     onlyFound?: boolean;
+    /**
+     * Names of dictionaries to use.
+     */
+    dictionary?: string[] | undefined;
+    /**
+     * Configure how to display the dictionary path.
+     */
     dictionaryPath?: 'hide' | 'long' | 'short' | 'full';
 }
 export interface SuggestionOptions extends BaseOptions {
@@ -136,6 +171,51 @@ export interface SuggestionOptions extends BaseOptions {
      */
     repl?: boolean;
 }
+export interface DictionariesOptions {
+    /**
+     * Path to configuration file.
+     */
+    config?: string;
+    /**
+     * Load the default configuration
+     * @default true
+     */
+    defaultConfiguration?: boolean;
+    /**
+     * Use color in the output.
+     * `true` to force color, `false` to turn off color.
+     * `undefined` to use color if the output is a TTY.
+     */
+    color?: boolean | undefined;
+    /**
+     * Show enabled:
+     * - `true` to show only enabled dictionaries.
+     * - `false` to show only disabled dictionaries.
+     * - `undefined` to show all dictionaries.
+     */
+    enabled?: boolean | undefined;
+    /**
+     * The locale to use when listing dictionaries.
+     */
+    locale?: string;
+    /**
+     * The file type to use when listing dictionaries.
+     */
+    fileType?: string;
+    /**
+     * show the language locales supported by the dictionary.
+     */
+    showLocales?: boolean;
+    /**
+     * show the file types supported by the dictionary.
+     */
+    showFileTypes?: boolean;
+    /**
+     * Dhow the location of the dictionary.
+     */
+    showLocation?: boolean;
+    pathFormat?: 'hide' | 'short' | 'long' | 'full';
+}
 export interface LegacyOptions {
     local?: string;
 }
@@ -247,7 +327,24 @@ export interface LinterCliOptions extends LinterOptions {
      * @since 8.12.0
      */
     issueTemplate?: string;
+    /**
+     * Prevents searching for local configuration files
+     *
+     * When `--no-config-search` is passed on the command line, this will be `true`.
+     * If the flag is not passed, it defaults to `false`.
+     */
+    configSearch?: boolean;
+    /**
+     * Directory paths at which CSpell should stop searching for configuration files.
+     *
+     * These are set via one or more `--stop-config-search-at <dir>` CLI options.
+     * If no flags are passed, this will be `undefined`.
+     */
+    stopConfigSearchAt?: string[];
+    report?: ReportChoices | undefined;
 }
+export type ReportChoices = 'all' | 'simple' | 'typos' | 'flagged';
+export declare const ReportChoicesAll: readonly ReportChoices[];
 export declare function fixLegacy<T extends LegacyFixes>(opts: T & LegacyOptions): Omit<T & LegacyOptions, 'local'>;
 export interface CSpellConfigFile {
     url: URL;

package/dist/esm/options.js

@@ -1,3 +1,4 @@
+export const ReportChoicesAll = ['all', 'simple', 'typos', 'flagged'];
 export function fixLegacy(opts) {
     const { local, ...rest } = opts;
     if (local && !rest.locale) {

package/dist/esm/pkgInfo.d.ts

@@ -1,6 +1,6 @@
 export { pkgDir } from './dirname.js';
 export declare const name = "cspell";
-export declare const version = "9.0.1";
+export declare const version = "9.1.0";
 export declare const engines: {
     node: string;
 };

package/dist/esm/pkgInfo.js

@@ -1,7 +1,7 @@
 // This file is generated by tools/patch-version.mjs
 export { pkgDir } from './dirname.js';
 export const name = 'cspell';
-export const version = '9.0.1';
+export const version = '9.1.0';
 export const engines = { node: '>=20' };
 export const npmPackage = { name, version, engines };
 //# sourceMappingURL=pkgInfo.js.map

package/dist/esm/util/InMemoryReporter.d.ts

@@ -17,12 +17,15 @@ export declare class InMemoryReporter implements CSpellReporter, InMemoryResult
     progressCount: number;
     issues: Issue[];
     runResult: RunResult | undefined;
-    issue: (issue: Issue) => void;
-    error: (message: string, error: Error) => void;
-    info: (message: string) => void;
-    debug: (message: string) => void;
-    progress: (p: ProgressItem) => void;
-    result: (r: RunResult) => void;
-    dump: () => InMemoryResult;
+    issue(issue: Issue): void;
+    error(message: string, error: Error): void;
+    info(message: string): void;
+    debug(message: string): void;
+    progress(p: ProgressItem): void;
+    result(r: RunResult): void;
+    dump(): InMemoryResult;
+    get features(): {
+        issueType: boolean;
+    };
 }
 //# sourceMappingURL=InMemoryReporter.d.ts.map

package/dist/esm/util/InMemoryReporter.js

@@ -11,32 +11,39 @@ export class InMemoryReporter {
     progressCount = 0;
     issues = [];
     runResult;
-    issue = (issue) => {
+    issue(issue) {
         this.issues.push(issue);
         this.issueCount += 1;
         const { uri, row, col, text } = issue;
         this.log.push(`Issue: ${uri}[${row}, ${col}]: Unknown word: ${text}`);
-    };
-    error = (message, error) => {
+    }
+    error(message, error) {
         this.errorCount += 1;
         this.errors.push(error);
         this.log.push(`Error: ${message} ${error.toString()}`);
-    };
-    info = (message) => {
+    }
+    info(message) {
         this.infoCount += 1;
         this.log.push(`Info: ${message}`);
-    };
-    debug = (message) => {
+    }
+    debug(message) {
         this.debugCount += 1;
         this.log.push(`Debug: ${message}`);
-    };
-    progress = (p) => {
+    }
+    progress(p) {
         this.progressCount += 1;
         this.log.push(`Progress: ${p.type} ${p.fileNum} ${p.fileCount} ${p.filename}`);
-    };
-    result = (r) => {
+    }
+    result(r) {
         this.runResult = r;
-    };
-    dump = () => ({ log: this.log, issues: this.issues, runResult: this.runResult });
+    }
+    dump() {
+        return { log: this.log, issues: this.issues, runResult: this.runResult };
+    }
+    get features() {
+        return {
+            issueType: true,
+        };
+    }
 }
 //# sourceMappingURL=InMemoryReporter.js.map

package/dist/esm/util/LintFileResult.d.ts

@@ -0,0 +1,14 @@
+import { Issue, ReportIssueOptions } from '@cspell/cspell-types';
+import { FileInfo, Perf } from './fileHelper.js';
+export interface LintFileResult {
+    fileInfo: FileInfo;
+    processed: boolean;
+    issues: Issue[];
+    errors: number;
+    configErrors: number;
+    elapsedTimeMs: number | undefined;
+    perf?: Perf | undefined;
+    cached?: boolean;
+    reportIssueOptions?: ReportIssueOptions | undefined;
+}
+//# sourceMappingURL=LintFileResult.d.ts.map

package/dist/esm/util/LintFileResult.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LintFileResult.js.map

package/dist/esm/util/cache/CSpellLintResultCache.d.ts

@@ -1,13 +1,13 @@
-import type { FileResult } from '../../util/fileHelper.js';
+import type { LintFileResult } from '../LintFileResult.js';
 export interface CSpellLintResultCache {
     /**
      * Retrieve cached lint results for a given file name, if present in the cache.
      */
-    getCachedLintResults(filename: string): Promise<FileResult | undefined>;
+    getCachedLintResults(filename: string): Promise<LintFileResult | undefined>;
     /**
      * Set the cached lint results.
      */
-    setCachedLintResults(result: FileResult, dependsUponFiles: string[]): void;
+    setCachedLintResults(result: LintFileResult, dependsUponFiles: string[]): void;
     /**
      * Persists the in-memory cache to disk.
      */

package/dist/esm/util/cache/DiskCache.d.ts

@@ -1,7 +1,7 @@
-import type { FileResult } from '../../util/fileHelper.js';
+import type { LintFileResult } from '../../util/LintFileResult.js';
 import type { CSpellLintResultCache } from './CSpellLintResultCache.js';
 import type { FileDescriptor } from './fileEntryCache.js';
-export type CachedFileResult = Omit<FileResult, 'fileInfo' | 'elapsedTimeMs' | 'cached'>;
+export type CachedFileResult = Omit<LintFileResult, 'fileInfo' | 'elapsedTimeMs' | 'cached'>;
 /**
  * This is the data cached.
  * Property names are short to help keep the cache file size small.
@@ -41,8 +41,8 @@ export declare class DiskCache implements CSpellLintResultCache {
     private ocCacheFileResult;
     readonly version: string;
     constructor(cacheFileLocation: string, useCheckSum: boolean, cspellVersion: string, useUniversalCache: boolean);
-    getCachedLintResults(filename: string): Promise<FileResult | undefined>;
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __, ...result }: FileResult, dependsUponFiles: string[]): void;
+    getCachedLintResults(filename: string): Promise<LintFileResult | undefined>;
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __, ...result }: LintFileResult, dependsUponFiles: string[]): void;
     reconcile(): void;
     reset(): void;
     private normalizeResult;

package/dist/esm/util/configFileHelper.d.ts

@@ -10,6 +10,6 @@ export interface FileConfigInfo {
     text: string;
     languageIds: string[];
 }
-export declare function readConfig(configFile: string | CSpellConfigFile | undefined, root: string | undefined): Promise<ConfigInfo>;
+export declare function readConfig(configFile: string | CSpellConfigFile | undefined, root: string | undefined, stopConfigSearchAt?: (URL | string)[] | undefined): Promise<ConfigInfo>;
 export declare function readConfigFile(filename: string | URL): Promise<CSpellConfigFile>;
 //# sourceMappingURL=configFileHelper.d.ts.map

package/dist/esm/util/configFileHelper.js

@@ -2,13 +2,13 @@ import { toFilePathOrHref } from '@cspell/url';
 import * as cspell from 'cspell-lib';
 import { environmentKeys, getEnvironmentVariable } from '../environment.js';
 import { filenameToUrl } from './fileHelper.js';
-export async function readConfig(configFile, root) {
+export async function readConfig(configFile, root, stopConfigSearchAt) {
     configFile ??= getEnvironmentVariable(environmentKeys.CSPELL_CONFIG_PATH);
     if (configFile) {
         const cfgFile = typeof configFile === 'string' ? await readConfigHandleError(configFile) : configFile;
         return configFileToConfigInfo(cfgFile);
     }
-    const config = await cspell.searchForConfig(root);
+    const config = await cspell.searchForConfig(root, { stopSearchAt: stopConfigSearchAt });
     const defaultConfigFile = getEnvironmentVariable(environmentKeys.CSPELL_DEFAULT_CONFIG_PATH);
     if (!config && defaultConfigFile) {
         const cfgFile = await readConfigFile(defaultConfigFile).catch(() => undefined);

package/dist/esm/util/extractContext.d.ts

@@ -0,0 +1,5 @@
+import type { TextDocumentOffset, TextOffset } from '@cspell/cspell-types';
+export declare function fixOffsetToBeginningOfChar(text: string, offset: number): number;
+export declare function lineContext(lineText: string, start: number, end: number, contextRange: number): TextOffset;
+export declare function extractContext(tdo: Pick<TextDocumentOffset, 'line' | 'offset' | 'text'>, contextRange: number): TextOffset;
+//# sourceMappingURL=extractContext.d.ts.map

package/dist/esm/util/extractContext.js

@@ -0,0 +1,75 @@
+export function fixOffsetToBeginningOfChar(text, offset) {
+    const code = text.charCodeAt(offset) || 0;
+    return offset + ((code & 0xfc00) === 0xdc00 ? 1 : 0);
+}
+function prefCharIndex(text, offset, count = 1) {
+    if (offset - count < 0)
+        return 0;
+    for (; count > 0 && offset > 0; count--) {
+        let code = text.charCodeAt(--offset) || 0;
+        if (code === 0xfe0f) {
+            // Remove zero-width joiner
+            code = text.charCodeAt(--offset) || 0;
+        }
+        offset -= (code & 0xfc00) === 0xdc00 ? 1 : 0;
+    }
+    return offset < 0 ? 0 : offset;
+}
+function nextCharIndex(text, offset, count = 1) {
+    if (offset + count >= text.length)
+        return text.length;
+    for (; count > 0 && offset < text.length; count--) {
+        const code = text.charCodeAt(offset++) || 0;
+        offset += (code & 0xfc00) === 0xd800 ? 1 : 0;
+        if (text.charCodeAt(offset) === 0xfe0f) {
+            // Skip zero-width joiner
+            offset++;
+        }
+    }
+    return offset > text.length ? text.length : offset;
+}
+export function lineContext(lineText, start, end, contextRange) {
+    let left = prefCharIndex(lineText, start, contextRange);
+    let right = nextCharIndex(lineText, end, contextRange);
+    const isLetter = /^\p{L}$/u;
+    const isMark = /^\p{M}$/u;
+    for (let n = contextRange / 2; n > 0 && left > 0; n--, left--) {
+        const c = lineText[left - 1];
+        if (isMark.test(c)) {
+            if (!isLetter.test(lineText[left - 2])) {
+                break;
+            }
+            left--;
+            continue;
+        }
+        if (!isLetter.test(lineText[left - 1])) {
+            break;
+        }
+    }
+    for (let n = contextRange / 2; n > 0 && right < lineText.length; n--, right++) {
+        if (!isLetter.test(lineText[right])) {
+            break;
+        }
+        if (isMark.test(lineText[right + 1])) {
+            right++;
+        }
+    }
+    left = left < 0 ? 0 : left;
+    const t0 = lineText.slice(left, right);
+    const tLeft = t0.trimStart();
+    left = Math.min(left + t0.length - tLeft.length, start);
+    const text = tLeft.trimEnd();
+    const context = {
+        text,
+        offset: left,
+    };
+    return context;
+}
+export function extractContext(tdo, contextRange) {
+    const { line, offset, text } = tdo;
+    const start = offset - line.offset;
+    const context = lineContext(line.text, start, start + text.length, contextRange);
+    context.offset += line.offset;
+    return context;
+}
+//# sourceMappingURL=extractContext.js.map

package/dist/esm/util/fileHelper.d.ts

@@ -1,5 +1,5 @@
 import type { BufferEncoding } from 'cspell-io';
-import type { Document, Issue } from 'cspell-lib';
+import type { Document } from 'cspell-lib';
 import * as cspell from 'cspell-lib';
 import type { GlobOptions } from './glob.js';
 export interface FileInfo {
@@ -8,16 +8,6 @@ export interface FileInfo {
     errorCode?: string;
 }
 export type Perf = cspell.SpellCheckFilePerf;
-export interface FileResult {
-    fileInfo: FileInfo;
-    processed: boolean;
-    issues: Issue[];
-    errors: number;
-    configErrors: number;
-    elapsedTimeMs: number | undefined;
-    perf?: Perf | undefined;
-    cached?: boolean;
-}
 export declare function fileInfoToDocument(fileInfo: FileInfo, languageId: string | undefined, locale: string | undefined): Document;
 export declare function filenameToUrl(filename: string | URL, cwd?: string): URL;
 export declare function filenameToUri(filename: string, cwd?: string): URL;
@@ -50,4 +40,5 @@ export declare function readFileListFile(listFile: string): Promise<string[]>;
 export declare function isFile(filename: string): Promise<boolean>;
 export declare function isDir(filename: string): Promise<boolean>;
 export declare function isNotDir(filename: string): Promise<boolean>;
+export declare function relativeToCwd(filename: string | URL, cwd?: string | URL): string;
 //# sourceMappingURL=fileHelper.d.ts.map

package/dist/esm/util/fileHelper.js

@@ -2,7 +2,7 @@ import { promises as fsp } from 'node:fs';
 import * as path from 'node:path';
 import streamConsumers from 'node:stream/consumers';
 import { fileURLToPath } from 'node:url';
-import { toFileDirURL, toFileURL } from '@cspell/url';
+import { toFileDirURL, toFilePathOrHref, toFileURL, urlRelative } from '@cspell/url';
 import { readFileText as cioReadFile, toURL } from 'cspell-io';
 import { fileToDocument, isBinaryFile as isUriBinaryFile } from 'cspell-lib';
 import { asyncAwait, asyncFlatten, asyncMap, asyncPipe, mergeAsyncIterables } from './async.js';
@@ -154,4 +154,12 @@ export async function isDir(filename) {
 export function isNotDir(filename) {
     return isDir(filename).then((a) => !a);
 }
+export function relativeToCwd(filename, cwd = process.cwd()) {
+    const urlCwd = toFileDirURL(cwd);
+    const url = toFileURL(filename, urlCwd);
+    const rel = urlRelative(urlCwd, url);
+    if (rel.startsWith('..'))
+        return toFilePathOrHref(url);
+    return rel;
+}
 //# sourceMappingURL=fileHelper.js.map

package/dist/esm/util/pad.d.ts

@@ -3,4 +3,20 @@ export declare function padWidth(s: string, target: number): number;
 export declare function padLeft(s: string, w: number): string;
 export declare function width(s: string): number;
 export declare function ansiWidth(s: string): number;
+/**
+ * Prune the end of a string to fit within a specified width, adding an ellipsis if necessary.
+ * @param str - the text to prune - ANSI is not supported
+ * @param maxWidth - the maximum width of the text
+ * @param pad - the string to use for padding, default is '…'
+ * @returns the pruned text
+ */
+export declare function pruneTextEnd(str: string, maxWidth: number | undefined, pad?: string): string;
+/**
+ * Prune the start of a string to fit within a specified width, adding an ellipsis if necessary.
+ * @param str - the text to prune - ANSI is not supported
+ * @param maxWidth - the maximum width of the text
+ * @param pad - the string to use for padding, default is '…'
+ * @returns the pruned text
+ */
+export declare function pruneTextStart(str: string, maxWidth: number | undefined, pad?: string): string;
 //# sourceMappingURL=pad.d.ts.map

package/dist/esm/util/pad.js

@@ -20,9 +20,69 @@ export function width(s) {
     return (s
         // eslint-disable-next-line no-control-regex, no-misleading-character-class
         .replaceAll(/[\u0000-\u001F\u0300-\u036F]/g, '')
-        .replaceAll(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, '.').length);
+        .replaceAll(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, '.')
+        .replaceAll('…', '.')
+        .replaceAll(/\p{M}/gu, '').length);
 }
 export function ansiWidth(s) {
     return width(stripVTControlCharacters(s));
 }
+/**
+ * Prune the end of a string to fit within a specified width, adding an ellipsis if necessary.
+ * @param str - the text to prune - ANSI is not supported
+ * @param maxWidth - the maximum width of the text
+ * @param pad - the string to use for padding, default is '…'
+ * @returns the pruned text
+ */
+export function pruneTextEnd(str, maxWidth, pad = '…') {
+    if (!maxWidth || maxWidth <= 0)
+        return str;
+    if (str.length <= maxWidth)
+        return str;
+    const padWidth = width(pad);
+    const maxWidthWithPad = maxWidth - padWidth;
+    const letters = [...str];
+    let len = 0;
+    for (let i = 0; i < letters.length; i++) {
+        const c = letters[i];
+        len += width(c);
+        if (len > maxWidthWithPad) {
+            let j = i + 1;
+            while (j < letters.length && width(letters[j]) === 0) {
+                ++j;
+            }
+            return j === letters.length ? str : letters.slice(0, i).join('') + pad;
+        }
+    }
+    return str;
+}
+/**
+ * Prune the start of a string to fit within a specified width, adding an ellipsis if necessary.
+ * @param str - the text to prune - ANSI is not supported
+ * @param maxWidth - the maximum width of the text
+ * @param pad - the string to use for padding, default is '…'
+ * @returns the pruned text
+ */
+export function pruneTextStart(str, maxWidth, pad = '…') {
+    if (!maxWidth || maxWidth <= 0)
+        return str;
+    if (str.length <= maxWidth)
+        return str;
+    const padWidth = width(pad);
+    const maxWidthWithPad = maxWidth - padWidth;
+    const letters = [...str];
+    let len = 0;
+    for (let i = letters.length - 1; i >= 1; i--) {
+        const c = letters[i];
+        len += width(c);
+        if (len > maxWidthWithPad) {
+            i += 1;
+            while (i < letters.length && width(letters[i]) === 0) {
+                ++i;
+            }
+            return pad + letters.slice(i).join('');
+        }
+    }
+    return str;
+}
 //# sourceMappingURL=pad.js.map

package/dist/esm/util/reporters.d.ts

@@ -1,9 +1,6 @@
-import type { CSpellReporter, FileSettings, ReporterConfiguration } from '@cspell/cspell-types';
+import { type CSpellReporter, type CSpellSettings, type FeaturesSupportedByReporter, type FileSettings, type Issue, type ReporterConfiguration, type ReportIssueOptions, type RunResult } from '@cspell/cspell-types';
+import { LintFileResult } from './LintFileResult.js';
 export type FinalizedReporter = Required<CSpellReporter>;
-/**
- * Mergers several cspell reporters into a single one
- */
-export declare function mergeReporters(...reporters: ReadonlyArray<CSpellReporter>): FinalizedReporter;
 /**
  * Loads reporter modules configured in cspell config file
  */
@@ -11,4 +8,23 @@ export declare function loadReporters(reporters: FileSettings['reporters'], defa
 export declare function finalizeReporter(reporter: undefined): undefined;
 export declare function finalizeReporter(reporter: CSpellReporter): FinalizedReporter;
 export declare function finalizeReporter(reporter: CSpellReporter | undefined): FinalizedReporter | undefined;
+export declare function extractReporterIssueOptions(settings: CSpellSettings | ReportIssueOptions): ReportIssueOptions;
+export declare function mergeReportIssueOptions(a: ReportIssueOptions | CSpellSettings, b: ReportIssueOptions | undefined): ReportIssueOptions;
+export declare class LintReporter {
+    #private;
+    readonly defaultReporter: CSpellReporter;
+    constructor(defaultReporter: CSpellReporter, config: ReporterConfiguration);
+    get config(): ReporterConfiguration;
+    set config(config: ReporterConfiguration);
+    issue(issue: Issue, reportOptions?: ReportIssueOptions): void;
+    info(...params: Parameters<FinalizedReporter['info']>): void;
+    debug(...params: Parameters<FinalizedReporter['debug']>): void;
+    error(...params: Parameters<FinalizedReporter['error']>): void;
+    progress(...params: Parameters<FinalizedReporter['progress']>): void;
+    result(result: RunResult): Promise<void>;
+    get features(): FeaturesSupportedByReporter;
+    loadReportersAndFinalize(reporters: FileSettings['reporters']): Promise<void>;
+    emitProgressBegin(filename: string, fileNum: number, fileCount: number): void;
+    emitProgressComplete(filename: string, fileNum: number, fileCount: number, result: LintFileResult): number;
+}
 //# sourceMappingURL=reporters.d.ts.map