webpack-cli

env?: Env;

description: string;

license: string;

name: string;

version: string;

analyze?: boolean;

configPath?: string[];

helpfulOutput: boolean;

hot?: boolean | 'only';

isMultiCompiler?: boolean;

prefetch?: string;

progress?: boolean | 'profile';

code?: string;

builtInOptionsCache: WebpackCLIBuiltInOption[] | undefined;

capitalizeFirstLetter: StringFormatter;

colors: WebpackCLIColors;

isColorSupportChanged: boolean | undefined;

logger: WebpackCLILogger;

program: WebpackCLICommand;

toKebabCase: StringFormatter;

webpack: typeof webpack;

buildConfig: (
    config: WebpackCLIConfig,
    options: WebpackDevServerOptions
) => Promise<WebpackCLIConfig>;

checkPackageExists: (packageName: string) => boolean;

createColors: (useColors?: boolean) => WebpackCLIColors;

createCompiler: (
    options: Partial<WebpackDevServerOptions>,
    callback?: Callback<[Error | undefined, WebpackCLIStats | undefined]>
) => Promise<WebpackCompiler>;

doInstall: (
    packageName: string,
    options?: PackageInstallOptions
) => Promise<string>;

getAvailablePackageManagers: () => PackageManager[];

getBuiltInOptions: () => WebpackCLIBuiltInOption[];

getDefaultPackageManager: () => PackageManager | undefined;

getInfoOptions: () => WebpackCLIBuiltInOption[];

getInfoOutput: (options: {
    output: string;
    additionalPackage: string[];
}) => Promise<string>;

getLogger: () => WebpackCLILogger;

isFunction: (value: unknown) => value is CallableFunction;

isMultipleCompiler: (compiler: WebpackCompiler) => compiler is MultiCompiler;

isPromise: <T>(value: Promise<T>) => value is Promise<T>;

isValidationError: (error: Error) => error is WebpackError;

loadConfig: (
    options: Partial<WebpackDevServerOptions>
) => Promise<WebpackCLIConfig>;

loadJSONFile: <T = unknown>(path: Path, handleError: boolean) => Promise<T>;

loadWebpack: (handleError?: boolean) => Promise<typeof webpack>;

makeCommand: (
    commandOptions: WebpackCLIOptions,
    options: WebpackCLICommandOptions,
    action: CommandAction
) => Promise<WebpackCLICommand | undefined>;

makeOption: (
    command: WebpackCLICommand,
    option: WebpackCLIBuiltInOption
) => void;

needWatchStdin: (compiler: Compiler | MultiCompiler) => boolean;

run: (
    args: Parameters<WebpackCLICommand['parseOptions']>[0],
    parseOptions?: ParseOptions
) => Promise<void>;

runWebpack: (
    options: WebpackRunOptions,
    isWatchCommand: boolean
) => Promise<void>;

tryRequireThenImport: <T = unknown>(
    module: ModuleName,
    handleError: boolean
) => Promise<T>;

stringifyStream: typeof stringifyStream;

preMessage?: () => void;

defaultResponse: string;

message: string;

stream: NodeJS.WritableStream;

prepare: typeof prepare;

error: Error;

failures: RechoirError[];

alias?: string;

configs?: Partial<FlagConfig>[];

defaultValue?: string;

describe?: string;

description: string;

helpLevel: 'minimum' | 'verbose';

multiple?: boolean;

name: string;

negatedDescription?: string;

negative?: boolean;

type?: (
    value: string,
    previous: Record<string, BasicPrimitive | object>
) => Record<string, BasicPrimitive | object>;

valueName?: string;

group?: 'core';

hidden?: boolean;

isColorSupported: boolean;

forHelp: boolean | undefined;

pkg: string | undefined;

helpLevel?: 'minimum' | 'verbose';

options: WebpackConfiguration | WebpackConfiguration[];

path: WeakMap<object, string[]>;

error: LogHandler;

info: LogHandler;

log: LogHandler;

raw: LogHandler;

success: LogHandler;

warn: LogHandler;

alias: string | string[];

argsDescription?: {
    [argName: string]: string;
};

dependencies?: string[];

description?: string;

name: string;

pkg?: string;

usage?: string;

presetToOptions?: (item: string | boolean) => StatsOptions;

argv?: Argv;

env: Env;

failOnWarnings?: boolean;

isWatchingLikeCommand?: boolean;

json?: boolean;

progress?: boolean | 'profile';