// Generated by dts-bundle v0.7.3
// Dependencies for this module:
//   ../../../../../../packages/webpack

import type webpack from 'webpack';

export = ForkTsCheckerWebpackPlugin;

class ForkTsCheckerWebpackPlugin {
        /**
            * Current version of the plugin
            */
        static readonly version: string;
        /**
            * Default pools for the plugin concurrency limit
            */
        static readonly issuesPool: import("./utils/async/pool").Pool;
        static readonly dependenciesPool: import("./utils/async/pool").Pool;
        /**
            * @deprecated Use ForkTsCheckerWebpackPlugin.issuesPool instead
            */
        static readonly pool: import("./utils/async/pool").Pool;
        constructor(options?: ForkTsCheckerWebpackPluginOptions);
        static getCompilerHooks(compiler: webpack.Compiler): {
                start: import("tapable").AsyncSeriesWaterfallHook<[import("./files-change").FilesChange, webpack.Compilation], import("tapable").UnsetAdditionalOptions>;
                waiting: import("tapable").SyncHook<[webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
                canceled: import("tapable").SyncHook<[webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
                error: import("tapable").SyncHook<[unknown, webpack.Compilation], void, import("tapable").UnsetAdditionalOptions>;
                issues: import("tapable").SyncWaterfallHook<[import("./issue/issue").Issue[], webpack.Compilation | undefined], void>;
        };
        apply(compiler: webpack.Compiler): void;
}
export { ForkTsCheckerWebpackPlugin };

interface ForkTsCheckerWebpackPluginOptions {
    async?: boolean;
    typescript?: TypeScriptWorkerOptions;
    formatter?: FormatterOptions;
    issue?: IssueOptions;
    logger?: Logger | 'webpack-infrastructure';
    devServer?: boolean;
}
export { ForkTsCheckerWebpackPluginOptions };

type IssuePredicateOption = IssuePredicate | IssueMatch | (IssuePredicate | IssueMatch)[];
interface IssueOptions {
    include?: IssuePredicateOption;
    exclude?: IssuePredicateOption;
}
export { IssueOptions, IssuePredicateOption };

interface Logger {
    log: (message: string) => void;
    error: (message: string) => void;
}
export { Logger };

type TypeScriptWorkerOptions = {
    memoryLimit?: number;
    configFile?: string;
    configOverwrite?: TypeScriptConfigOverwrite;
    context?: string;
    build?: boolean;
    mode?: 'readonly' | 'write-tsbuildinfo' | 'write-dts' | 'write-references';
    diagnosticOptions?: Partial<TypeScriptDiagnosticsOptions>;
    extensions?: {
        vue?: TypeScriptVueExtensionOptions;
    };
    profile?: boolean;
    typescriptPath?: string;
};
export { TypeScriptWorkerOptions };

type Formatter = (issue: Issue) => string;
export { Formatter };

function createBasicFormatter(): Formatter;
export { createBasicFormatter };

function createCodeFrameFormatter(options?: BabelCodeFrameOptions): Formatter;
export { createCodeFrameFormatter, BabelCodeFrameOptions };

function createWebpackFormatter(formatter: Formatter): Formatter;
export { createWebpackFormatter };

type FormatterType = 'basic' | 'codeframe';
type BasicFormatterOptions = {
    type: 'basic';
};
type CodeframeFormatterOptions = {
    type: 'codeframe';
    options?: BabelCodeFrameOptions;
};
type FormatterOptions = undefined | FormatterType | BasicFormatterOptions | CodeframeFormatterOptions | Formatter;
export { FormatterOptions, FormatterType, BasicFormatterOptions, CodeframeFormatterOptions };

type FormatterConfig = Formatter;
function createFormatterConfig(options: FormatterOptions | undefined): FormatterConfig;
export { FormatterConfig, createFormatterConfig };

type IssueMatch = Partial<Pick<Issue, 'severity' | 'code' | 'file'>>;
function createIssuePredicateFromIssueMatch(context: string, match: IssueMatch): IssuePredicate;
export { IssueMatch, createIssuePredicateFromIssueMatch };

type IssuePredicate = (issue: Issue) => boolean;
function createTrivialIssuePredicate(result: boolean): IssuePredicate;
function composeIssuePredicates(predicates: IssuePredicate[]): IssuePredicate;
export { IssuePredicate, createTrivialIssuePredicate, composeIssuePredicates };

type TypeScriptVueExtensionOptions = boolean | {
    enabled?: boolean;
    compiler?: string;
};
export { TypeScriptVueExtensionOptions };

interface TypeScriptConfigOverwrite {
    extends?: string;
    compilerOptions?: any;
    include?: string[];
    exclude?: string[];
    files?: string[];
    references?: {
        path: string;
        prepend?: boolean;
    }[];
}
export { TypeScriptConfigOverwrite };

interface TypeScriptDiagnosticsOptions {
    syntactic: boolean;
    semantic: boolean;
    declaration: boolean;
    global: boolean;
}
export { TypeScriptDiagnosticsOptions };

export interface BabelCodeFrameOptions {
        /** Syntax highlight the code as JavaScript for terminals. default: false */
        highlightCode?: boolean;
        /**  The number of lines to show above the error. default: 2 */
        linesAbove?: number;
        /**  The number of lines to show below the error. default: 3 */
        linesBelow?: number;
        /**
            * Forcibly syntax highlight the code as JavaScript (for non-terminals);
            * overrides highlightCode.
            * default: false
            */
        forceColor?: boolean;
        /**
            * Pass in a string to be displayed inline (if possible) next to the
            * highlighted location in the code. If it can't be positioned inline,
            * it will be placed above the code frame.
            * default: nothing
            */
        message?: string;
}

interface Issue {
    severity: IssueSeverity;
    code: string;
    message: string;
    file?: string;
    location?: IssueLocation;
}
function isIssue(value: unknown): value is Issue;
function deduplicateAndSortIssues(issues: Issue[]): Issue[];
export { Issue, isIssue, deduplicateAndSortIssues };

type IssueSeverity = 'error' | 'warning';
function isIssueSeverity(value: unknown): value is IssueSeverity;
function compareIssueSeverities(severityA: IssueSeverity, severityB: IssueSeverity): number;
export { IssueSeverity, isIssueSeverity, compareIssueSeverities };

interface IssueLocation {
    start: IssuePosition;
    end: IssuePosition;
}
function compareIssueLocations(locationA?: IssueLocation, locationB?: IssueLocation): number;
function formatIssueLocation({ start, end }: IssueLocation): string;
export { IssueLocation, compareIssueLocations, formatIssueLocation };

interface IssuePosition {
    line: number;
    column: number;
}
function compareIssuePositions(positionA?: IssuePosition, positionB?: IssuePosition): number;
export { IssuePosition, compareIssuePositions };