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

import { Worker } from "jest-worker";

export = TerserPlugin;
/**
    * @template [T=TerserOptions]
    */
class TerserPlugin<T = import("terser").MinifyOptions> {
    /**
        * @param {BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>} [options]
        */
    constructor(
        options?:
            | (BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>)
            | undefined
    );
    /**
        * @param {Compiler} compiler
        * @returns {void}
        */
    apply(compiler: Compiler): void;
}
namespace TerserPlugin {
    export {
        terserMinify,
        uglifyJsMinify,
        swcMinify,
        esbuildMinify,
        Schema,
        Compiler,
        Compilation,
        WebpackError,
        Asset,
        TerserECMA,
        TerserOptions,
        JestWorker,
        SourceMapInput,
        Rule,
        Rules,
        ExtractCommentsFunction,
        ExtractCommentsCondition,
        ExtractCommentsFilename,
        ExtractCommentsBanner,
        ExtractCommentsObject,
        ExtractCommentsOptions,
        MinimizedResult,
        Input,
        CustomOptions,
        InferDefaultType,
        PredefinedOptions,
        MinimizerOptions,
        BasicMinimizerImplementation,
        MinimizeFunctionHelpers,
        MinimizerImplementation,
        InternalOptions,
        MinimizerWorker,
        Parallel,
        BasePluginOptions,
        DefinedDefaultMinimizerAndOptions,
        InternalPluginOptions,
    };
}
type Compiler = import("webpack").Compiler;
type BasePluginOptions = {
    test?: Rules | undefined;
    include?: Rules | undefined;
    exclude?: Rules | undefined;
    extractComments?: ExtractCommentsOptions | undefined;
    parallel?: Parallel;
};
type DefinedDefaultMinimizerAndOptions<T> = T extends TerserOptions
    ? {
            minify?: MinimizerImplementation<T> | undefined;
            terserOptions?: MinimizerOptions<T> | undefined;
        }
    : {
            minify: MinimizerImplementation<T>;
            terserOptions?: MinimizerOptions<T> | undefined;
        };
type Schema = import("schema-utils/declarations/validate").Schema;
type Compilation = import("webpack").Compilation;
type WebpackError = import("webpack").WebpackError;
type Asset = import("webpack").Asset;
type TerserECMA = import("./utils.js").TerserECMA;
type TerserOptions = import("./utils.js").TerserOptions;
type JestWorker = import("jest-worker").Worker;
type SourceMapInput = import("@jridgewell/trace-mapping").SourceMapInput;
type Rule = RegExp | string;
type Rules = Rule[] | Rule;
type ExtractCommentsFunction = (
    astNode: any,
    comment: {
        value: string;
        type: "comment1" | "comment2" | "comment3" | "comment4";
        pos: number;
        line: number;
        col: number;
    }
) => boolean;
type ExtractCommentsCondition =
    | boolean
    | "all"
    | "some"
    | RegExp
    | ExtractCommentsFunction;
type ExtractCommentsFilename = string | ((fileData: any) => string);
type ExtractCommentsBanner =
    | string
    | boolean
    | ((commentsFile: string) => string);
type ExtractCommentsObject = {
    condition?: ExtractCommentsCondition | undefined;
    filename?: ExtractCommentsFilename | undefined;
    banner?: ExtractCommentsBanner | undefined;
};
type ExtractCommentsOptions = ExtractCommentsCondition | ExtractCommentsObject;
type MinimizedResult = {
    code: string;
    map?: import("@jridgewell/trace-mapping").SourceMapInput | undefined;
    errors?: (string | Error)[] | undefined;
    warnings?: (string | Error)[] | undefined;
    extractedComments?: string[] | undefined;
};
type Input = {
    [file: string]: string;
};
type CustomOptions = {
    [key: string]: any;
};
type InferDefaultType<T> = T extends infer U ? U : CustomOptions;
type PredefinedOptions = {
    module?: boolean | undefined;
    ecma?: import("terser").ECMA | undefined;
};
type MinimizerOptions<T> = PredefinedOptions & InferDefaultType<T>;
type BasicMinimizerImplementation<T> = (
    input: Input,
    sourceMap: SourceMapInput | undefined,
    minifyOptions: MinimizerOptions<T>,
    extractComments: ExtractCommentsOptions | undefined
) => Promise<MinimizedResult>;
type MinimizeFunctionHelpers = {
    getMinimizerVersion?: (() => string | undefined) | undefined;
};
type MinimizerImplementation<T> = BasicMinimizerImplementation<T> &
    MinimizeFunctionHelpers;
type InternalOptions<T> = {
    name: string;
    input: string;
    inputSourceMap: SourceMapInput | undefined;
    extractComments: ExtractCommentsOptions | undefined;
    minimizer: {
        implementation: MinimizerImplementation<T>;
        options: MinimizerOptions<T>;
    };
};
type MinimizerWorker<T> = Worker & {
    transform: (options: string) => MinimizedResult;
    minify: (options: InternalOptions<T>) => MinimizedResult;
};
type Parallel = undefined | boolean | number;
type InternalPluginOptions<T> = BasePluginOptions & {
    minimizer: {
        implementation: MinimizerImplementation<T>;
        options: MinimizerOptions<T>;
    };
};

export type Task<T> = () => Promise<T>;
export type SourceMapInput = import("@jridgewell/trace-mapping").SourceMapInput;
export type TerserFormatOptions = import("terser").FormatOptions;
export type TerserOptions = import("terser").MinifyOptions;
export type TerserCompressOptions = import("terser").CompressOptions;
export type TerserECMA = import("terser").ECMA;
export type ExtractCommentsOptions =
    import("./index.js").ExtractCommentsOptions;
export type ExtractCommentsFunction =
    import("./index.js").ExtractCommentsFunction;
export type ExtractCommentsCondition =
    import("./index.js").ExtractCommentsCondition;
export type Input = import("./index.js").Input;
export type MinimizedResult = import("./index.js").MinimizedResult;
export type PredefinedOptions = import("./index.js").PredefinedOptions;
export type CustomOptions = import("./index.js").CustomOptions;
export type ExtractedComments = Array<string>;
/**
    * Run tasks with limited concurency.
    * @template T
    * @param {number} limit - Limit of tasks that run at once.
    * @param {Task<T>[]} tasks - List of tasks to run.
    * @returns {Promise<T[]>} A promise that fulfills to an array of the results
    */
export function throttleAll<T>(limit: number, tasks: Task<T>[]): Promise<T[]>;
/**
    * @param {Input} input
    * @param {SourceMapInput | undefined} sourceMap
    * @param {PredefinedOptions & CustomOptions} minimizerOptions
    * @param {ExtractCommentsOptions | undefined} extractComments
    * @return {Promise<MinimizedResult>}
    */
export function terserMinify(
    input: Input,
    sourceMap: SourceMapInput | undefined,
    minimizerOptions: PredefinedOptions & CustomOptions,
    extractComments: ExtractCommentsOptions | undefined
): Promise<MinimizedResult>;
export namespace terserMinify {
    /**
        * @returns {string | undefined}
        */
    function getMinimizerVersion(): string | undefined;
}
/**
    * @param {Input} input
    * @param {SourceMapInput | undefined} sourceMap
    * @param {PredefinedOptions & CustomOptions} minimizerOptions
    * @param {ExtractCommentsOptions | undefined} extractComments
    * @return {Promise<MinimizedResult>}
    */
export function uglifyJsMinify(
    input: Input,
    sourceMap: SourceMapInput | undefined,
    minimizerOptions: PredefinedOptions & CustomOptions,
    extractComments: ExtractCommentsOptions | undefined
): Promise<MinimizedResult>;
export namespace uglifyJsMinify {
    /**
        * @returns {string | undefined}
        */
    function getMinimizerVersion(): string | undefined;
}
/**
    * @param {Input} input
    * @param {SourceMapInput | undefined} sourceMap
    * @param {PredefinedOptions & CustomOptions} minimizerOptions
    * @return {Promise<MinimizedResult>}
    */
export function swcMinify(
    input: Input,
    sourceMap: SourceMapInput | undefined,
    minimizerOptions: PredefinedOptions & CustomOptions
): Promise<MinimizedResult>;
export namespace swcMinify {
    /**
        * @returns {string | undefined}
        */
    function getMinimizerVersion(): string | undefined;
}
/**
    * @param {Input} input
    * @param {SourceMapInput | undefined} sourceMap
    * @param {PredefinedOptions & CustomOptions} minimizerOptions
    * @return {Promise<MinimizedResult>}
    */
export function esbuildMinify(
    input: Input,
    sourceMap: SourceMapInput | undefined,
    minimizerOptions: PredefinedOptions & CustomOptions
): Promise<MinimizedResult>;
export namespace esbuildMinify {
    /**
        * @returns {string | undefined}
        */
    function getMinimizerVersion(): string | undefined;
}

export type MinimizedResult = import("./index.js").MinimizedResult;
export type CustomOptions = import("./index.js").CustomOptions;
/**
    * @template T
    * @param {import("./index.js").InternalOptions<T>} options
    * @returns {Promise<MinimizedResult>}
    */
export function minify<T>(
    options: import("./index.js").InternalOptions<T>
): Promise<MinimizedResult>;
/**
    * @param {string} options
    * @returns {Promise<MinimizedResult>}
    */
export function transform(options: string): Promise<MinimizedResult>;