webpack-v5-chain/dist/index.d.ts

import { Configuration, ResolveOptions, RuleSetRule, WebpackPluginInstance } from "webpack";
import { Configuration as Configuration$1 } from "webpack-dev-server";
//#region src/utils/ChainedMap.d.ts
declare class Chained<Parent = unknown> {
  parent: Parent;
  constructor(parent?: Parent);
  batch(handler: (chained: this) => void): this;
  end(): Parent;
}
declare class TypedChainedMap<Parent = unknown, OptionsType = unknown> extends Chained<Parent> {
  store: Map<string, unknown>;
  shorthands: string[];
  constructor(parent?: Parent);
  extend(methods: string[]): this;
  clear(): this;
  delete(key: string): this;
  order(): {
    entries: Record<string, unknown>;
    order: string[];
  };
  entries(): OptionsType;
  values<OptionKey extends keyof OptionsType>(): OptionsType[OptionKey][];
  get<OptionKey extends keyof OptionsType>(key: OptionKey): OptionsType[OptionKey];
  getOrCompute<OptionKey extends keyof OptionsType>(key: OptionKey, fn: () => OptionsType[OptionKey]): OptionsType[OptionKey];
  has(key: string): boolean;
  set<OptionKey extends keyof OptionsType>(key: OptionKey, value: OptionsType[OptionKey]): this;
  merge(obj: Partial<OptionsType>, omit?: string[]): this;
  omitEmpty(obj: Record<string, unknown>): Record<string, unknown>;
  when(condition: boolean, whenTruthy?: (obj: this) => void, whenFalsy?: (obj: this) => void): this;
}
declare class ChainedMap<Parent = unknown> extends TypedChainedMap<Parent, any> {}
//#endregion
//#region src/utils/ChainedSet.d.ts
declare class TypedChainedSet<Parent = unknown, Value = unknown> extends Chained<Parent> {
  store: Set<Value>;
  constructor(parent?: Parent);
  add(value: Value): this;
  prepend(value: Value): this;
  clear(): this;
  delete(key: Value): this;
  values(): Value[];
  has(key: Value): boolean;
  merge(arr: Value[]): this;
  when(condition: boolean, whenTruthy?: (obj: this) => void, whenFalsy?: (obj: this) => void): this;
}
declare class ChainedSet<Parent = unknown> extends TypedChainedSet<Parent, any> {}
//#endregion
//#region src/utils/Callable.d.ts
declare class Callable extends Function {
  constructor();
  classCall(..._args: unknown[]): unknown;
}
//#endregion
//#region src/utils/ChainedValueMap.d.ts
declare class ChainedValueMap<Parent> extends Callable {
  parent: Parent;
  store: Map<string, unknown>;
  shorthands: string[];
  value: unknown;
  useMap: boolean;
  constructor(parent?: Parent);
  end(): Parent;
  batch(handler: (chained: this) => void): this;
  extend(methods: string[]): this;
  order(): {
    entries: Record<string, unknown>;
    order: string[];
  };
  clear(): this;
  delete(key: string): this;
  has(key: string): boolean;
  set(key: string, value: unknown): this;
  get(key: string): unknown;
  getOrCompute(key: string, fn: () => unknown): unknown;
  classCall(value: unknown): Parent;
  entries(): unknown;
  values(): unknown;
  merge(obj: Record<string, unknown>, omit?: string[]): this;
  omitEmpty(obj: Record<string, unknown>): Record<string, unknown>;
  when(condition: boolean, whenTruthy?: (obj: this) => void, whenFalsy?: (obj: this) => void): this;
}
interface ChainedValueMap<Parent> {
  (value: unknown): Parent;
}
//#endregion
//#region src/utils/Orderable.d.ts
interface Orderable {
  before: (name: string) => this;
  after: (name: string) => this;
}
declare const createOrderable: <TBase extends new (...args: any[]) => any>(superClass: TBase) => {
  new (...args: any[]): {
    [x: string]: any;
    __before?: string;
    __after?: string;
    before(name: string): /*elided*/ any;
    after(name: string): /*elided*/ any;
    merge(obj: Record<string, unknown>, omit?: string[]): /*elided*/ any;
  };
} & TBase;
//#endregion
//#region src/DevServerClient.d.ts
type DevServerOptions$1 = Configuration$1;
type ClientConfig = Exclude<NonNullable<DevServerOptions$1["client"]>, boolean>;
declare class DevServerClient extends ChainedMap<DevServer> {
  constructor(parent?: DevServer);
  logging: (value: ClientConfig["logging"]) => this;
  overlay: (value: ClientConfig["overlay"]) => this;
  progress: (value: ClientConfig["progress"]) => this;
  reconnect: (value: ClientConfig["reconnect"]) => this;
  webSocketURL: (value: ClientConfig["webSocketURL"]) => this;
  toConfig(): Record<string, unknown>;
}
//#endregion
//#region src/DevServer.d.ts
type DevServerOptions = Configuration$1;
declare class DevServer extends ChainedMap<Config> {
  #private;
  allowedHosts: TypedChainedSet<this, string>;
  client: DevServerClient;
  constructor(parent?: Config);
  app: (value: DevServerOptions["app"]) => this;
  bonjour: (value: DevServerOptions["bonjour"]) => this;
  compress: (value: DevServerOptions["compress"]) => this;
  devMiddleware: (value: DevServerOptions["devMiddleware"]) => this;
  headers: (value: DevServerOptions["headers"]) => this;
  historyApiFallback: (value: DevServerOptions["historyApiFallback"]) => this;
  host: (value: DevServerOptions["host"]) => this;
  hot: (value: DevServerOptions["hot"]) => this;
  ipc: (value: DevServerOptions["ipc"]) => this;
  liveReload: (value: DevServerOptions["liveReload"]) => this;
  onListening: (value: DevServerOptions["onListening"]) => this;
  open: (value: DevServerOptions["open"]) => this;
  port: (value: DevServerOptions["port"]) => this;
  proxy: (value: DevServerOptions["proxy"]) => this;
  server: (value: DevServerOptions["server"]) => this;
  setupExitSignals: (value: DevServerOptions["setupExitSignals"]) => this;
  setupMiddlewares: (value: DevServerOptions["setupMiddlewares"]) => this;
  static: (value: DevServerOptions["static"]) => this;
  watchFiles: (value: DevServerOptions["watchFiles"]) => this;
  webSocketServer: (value: DevServerOptions["webSocketServer"]) => this;
  disableClient(): this;
  toConfig(): Record<string, unknown>;
  merge(obj: Record<string, unknown>, omit?: string[]): this;
}
//#endregion
//#region src/Plugin.d.ts
type ResolvePlugin$2 = Exclude<NonNullable<ResolveOptions["plugins"]>[number], "...">;
declare class Plugin<Parent = unknown, PluginType extends WebpackPluginInstance | ResolvePlugin$2 = any> extends ChainedMap<Parent> {
  name: string;
  type: string;
  __before?: string;
  __after?: string;
  constructor(parent?: Parent, name?: string, type?: string);
  init: (value: (plugin: PluginType | (new (...opts: unknown[]) => PluginType), args: unknown[]) => PluginType) => this;
  use(plugin: string | PluginType | (new (...opts: unknown[]) => PluginType), args?: unknown[]): this;
  tap(func: (args: unknown[]) => unknown[]): this;
  set(key: any, value: unknown): this;
  before(name: string): this;
  after(name: string): this;
  merge(obj: Record<string, unknown>, omit?: string[]): this;
  toConfig(): PluginType;
}
//#endregion
//#region src/Resolve.d.ts
type WebpackResolve = Required<NonNullable<ResolveOptions>>;
type ResolvePlugin$1 = Exclude<NonNullable<ResolveOptions["plugins"]>[number], "...">;
declare class Resolve<ConfigType = Config> extends ChainedMap<ConfigType> {
  alias: TypedChainedMap<this, Record<string, string | false | string[]>>;
  aliasFields: TypedChainedSet<this, WebpackResolve["aliasFields"][number]>;
  byDependency: TypedChainedMap<this, WebpackResolve["byDependency"]>;
  conditionNames: TypedChainedSet<this, WebpackResolve["conditionNames"][number]>;
  descriptionFiles: TypedChainedSet<this, WebpackResolve["descriptionFiles"][number]>;
  exportsFields: TypedChainedSet<this, WebpackResolve["exportsFields"][number]>;
  extensionAlias: TypedChainedMap<this, WebpackResolve["extensionAlias"]>;
  extensions: TypedChainedSet<this, WebpackResolve["extensions"][number]>;
  fallback: TypedChainedMap<this, Record<string, string | false | string[]>>;
  importsFields: TypedChainedSet<this, WebpackResolve["importsFields"][number]>;
  mainFields: TypedChainedSet<this, WebpackResolve["mainFields"][number]>;
  mainFiles: TypedChainedSet<this, WebpackResolve["mainFiles"][number]>;
  modules: TypedChainedSet<this, WebpackResolve["modules"][number]>;
  plugins: TypedChainedMap<this, Record<string, Plugin<this, ResolvePlugin$1>>>;
  restrictions: TypedChainedSet<this, WebpackResolve["restrictions"][number]>;
  roots: TypedChainedSet<this, WebpackResolve["roots"][number]>;
  constructor(parent?: ConfigType);
  cache: (value: WebpackResolve["cache"]) => this;
  cachePredicate: (value: WebpackResolve["cachePredicate"]) => this;
  cacheWithContext: (value: WebpackResolve["cacheWithContext"]) => this;
  enforceExtension: (value: WebpackResolve["enforceExtension"]) => this;
  fullySpecified: (value: WebpackResolve["fullySpecified"]) => this;
  preferAbsolute: (value: WebpackResolve["preferAbsolute"]) => this;
  preferRelative: (value: WebpackResolve["preferRelative"]) => this;
  symlinks: (value: WebpackResolve["symlinks"]) => this;
  tsconfig: (value: WebpackResolve["tsconfig"]) => this;
  unsafeCache: (value: WebpackResolve["unsafeCache"]) => this;
  useSyncFileSystemCalls: (value: WebpackResolve["useSyncFileSystemCalls"]) => this;
  plugin(name: string): Plugin<this, ResolvePlugin$1>;
  toConfig(): Record<string, unknown>;
  merge(obj: Record<string, unknown>, omit?: string[]): this;
}
declare class RuleResolve<ConfigType = Config> extends Resolve<ConfigType> {
  fullySpecified: (value: boolean) => this;
}
//#endregion
//#region src/Use.d.ts
type LoaderOptions = Record<string, any>;
declare class Use<Parent = Rule> extends ChainedMap<Parent> {
  name: string;
  __before?: string;
  __after?: string;
  constructor(parent?: Parent, name?: string);
  loader: (value: string) => this;
  options: (value: LoaderOptions) => this;
  tap(func: (options: LoaderOptions) => LoaderOptions): this;
  before(name: string): this;
  after(name: string): this;
  merge(obj: Record<string, unknown>, omit?: string[]): this;
  toConfig(): Record<string, unknown>;
}
//#endregion
//#region src/Rule.d.ts
type WebpackRuleSet = Required<RuleSetRule>;
declare class Rule<RuleType = Module> extends ChainedMap<RuleType> {
  ruleName: string;
  names: string[];
  ruleType: string;
  ruleTypes: string[];
  uses: TypedChainedMap<this, Record<string, Use<this>>>;
  include: TypedChainedSet<this, WebpackRuleSet["include"]>;
  exclude: TypedChainedSet<this, WebpackRuleSet["exclude"]>;
  rules: TypedChainedMap<this, Record<string, Rule<any>>>;
  oneOfs: TypedChainedMap<this, Record<string, Rule<any>>>;
  resolve: RuleResolve<Rule<RuleType>>;
  __before?: string;
  __after?: string;
  constructor(parent?: RuleType, name?: string, ruleType?: string);
  assert: (value: WebpackRuleSet["assert"]) => this;
  compiler: (value: WebpackRuleSet["compiler"]) => this;
  dependency: (value: WebpackRuleSet["dependency"]) => this;
  descriptionData: (value: WebpackRuleSet["descriptionData"]) => this;
  enforce: (value: WebpackRuleSet["enforce"]) => this;
  issuer: (value: WebpackRuleSet["issuer"]) => this;
  issuerLayer: (value: WebpackRuleSet["issuerLayer"]) => this;
  layer: (value: WebpackRuleSet["layer"]) => this;
  loader: (value: WebpackRuleSet["loader"]) => this;
  extractSourceMap: (value: WebpackRuleSet["extractSourceMap"]) => this;
  mimetype: (value: WebpackRuleSet["mimetype"]) => this;
  options: (value: WebpackRuleSet["options"]) => this;
  parser: (value: WebpackRuleSet["parser"]) => this;
  generator: (value: WebpackRuleSet["generator"]) => this;
  phase: (value: WebpackRuleSet["phase"]) => this;
  realResource: (value: WebpackRuleSet["realResource"]) => this;
  resource: (value: WebpackRuleSet["resource"]) => this;
  resourceFragment: (value: WebpackRuleSet["resourceFragment"]) => this;
  resourceQuery: (value: WebpackRuleSet["resourceQuery"]) => this;
  scheme: (value: WebpackRuleSet["scheme"]) => this;
  sideEffects: (value: WebpackRuleSet["sideEffects"]) => this;
  test: (value: WebpackRuleSet["test"]) => this;
  type: (value: WebpackRuleSet["type"]) => this;
  with: (value: WebpackRuleSet["with"]) => this;
  before(name: string): this;
  after(name: string): this;
  use(name: string): Use<this>;
  rule(name: string): Rule<this>;
  oneOf(name: string): Rule<this>;
  pre(): this;
  post(): this;
  toConfig(): Record<string, unknown>;
  merge(obj: Record<string, unknown>, omit?: string[]): this;
}
//#endregion
//#region src/Module.d.ts
type WebpackModule = Required<NonNullable<Configuration["module"]>>;
declare class Module extends ChainedMap<Config> {
  rules: TypedChainedMap<this, Record<string, Rule>>;
  defaultRules: TypedChainedMap<this, Record<string, Rule>>;
  generator: ChainedMap<this>;
  parser: ChainedMap<this>;
  constructor(parent?: Config);
  noParse: (value: WebpackModule["noParse"]) => this;
  unsafeCache: (value: WebpackModule["unsafeCache"]) => this;
  exprContextCritical: (value: WebpackModule["exprContextCritical"]) => this;
  exprContextRecursive: (value: WebpackModule["exprContextRecursive"]) => this;
  exprContextRegExp: (value: WebpackModule["exprContextRegExp"]) => this;
  exprContextRequest: (value: WebpackModule["exprContextRequest"]) => this;
  unknownContextCritical: (value: WebpackModule["unknownContextCritical"]) => this;
  unknownContextRecursive: (value: WebpackModule["unknownContextRecursive"]) => this;
  unknownContextRegExp: (value: WebpackModule["unknownContextRegExp"]) => this;
  unknownContextRequest: (value: WebpackModule["unknownContextRequest"]) => this;
  wrappedContextCritical: (value: WebpackModule["wrappedContextCritical"]) => this;
  wrappedContextRecursive: (value: WebpackModule["wrappedContextRecursive"]) => this;
  wrappedContextRegExp: (value: WebpackModule["wrappedContextRegExp"]) => this;
  strictExportPresence: (value: WebpackModule["strictExportPresence"]) => this;
  strictThisContextOnImports: (value: WebpackModule["strictThisContextOnImports"]) => this;
  defaultRule(name: string): Rule<this>;
  rule(name: string): Rule<this>;
  toConfig(): Record<string, unknown>;
  merge(obj: Record<string, unknown>, omit?: string[]): this;
}
//#endregion
//#region src/Optimization.d.ts
type WebpackOptimization = Required<NonNullable<Configuration["optimization"]>>;
type SplitChunksObject = Exclude<WebpackOptimization["splitChunks"], false>;
declare class Optimization extends ChainedMap<Config> {
  minimizers: TypedChainedMap<this, Record<string, Plugin<this, WebpackPluginInstance>>>;
  splitChunks: ChainedValueMap<this> & ((value: SplitChunksObject | false) => this);
  constructor(parent?: Config);
  checkWasmTypes: (value: WebpackOptimization["checkWasmTypes"]) => this;
  chunkIds: (value: WebpackOptimization["chunkIds"]) => this;
  concatenateModules: (value: WebpackOptimization["concatenateModules"]) => this;
  emitOnErrors: (value: WebpackOptimization["emitOnErrors"]) => this;
  avoidEntryIife: (value: WebpackOptimization["avoidEntryIife"]) => this;
  flagIncludedChunks: (value: WebpackOptimization["flagIncludedChunks"]) => this;
  inlineExports: (value: WebpackOptimization["inlineExports"]) => this;
  innerGraph: (value: WebpackOptimization["innerGraph"]) => this;
  mangleExports: (value: WebpackOptimization["mangleExports"]) => this;
  mangleWasmImports: (value: WebpackOptimization["mangleWasmImports"]) => this;
  mergeDuplicateChunks: (value: WebpackOptimization["mergeDuplicateChunks"]) => this;
  minimize: (value: WebpackOptimization["minimize"]) => this;
  moduleIds: (value: WebpackOptimization["moduleIds"]) => this;
  nodeEnv: (value: WebpackOptimization["nodeEnv"]) => this;
  portableRecords: (value: WebpackOptimization["portableRecords"]) => this;
  providedExports: (value: WebpackOptimization["providedExports"]) => this;
  realContentHash: (value: WebpackOptimization["realContentHash"]) => this;
  removeAvailableModules: (value: WebpackOptimization["removeAvailableModules"]) => this;
  removeEmptyChunks: (value: WebpackOptimization["removeEmptyChunks"]) => this;
  runtimeChunk: (value: WebpackOptimization["runtimeChunk"]) => this;
  sideEffects: (value: WebpackOptimization["sideEffects"]) => this;
  usedExports: (value: WebpackOptimization["usedExports"]) => this;
  minimizer(name: string): Plugin<this, WebpackPluginInstance>;
  toConfig(): Record<string, unknown>;
  merge(obj: Record<string, unknown>, omit?: string[]): this;
}
//#endregion
//#region src/Output.d.ts
type WebpackOutput = Required<NonNullable<Configuration["output"]>>;
declare class Output extends ChainedMap<Config> {
  constructor(parent?: Config);
  assetModuleFilename: (value: WebpackOutput["assetModuleFilename"]) => this;
  asyncChunks: (value: WebpackOutput["asyncChunks"]) => this;
  auxiliaryComment: (value: WebpackOutput["auxiliaryComment"]) => this;
  charset: (value: WebpackOutput["charset"]) => this;
  chunkFilename: (value: WebpackOutput["chunkFilename"]) => this;
  chunkFormat: (value: WebpackOutput["chunkFormat"]) => this;
  chunkLoadTimeout: (value: WebpackOutput["chunkLoadTimeout"]) => this;
  chunkLoadingGlobal: (value: WebpackOutput["chunkLoadingGlobal"]) => this;
  chunkLoading: (value: WebpackOutput["chunkLoading"]) => this;
  clean: (value: WebpackOutput["clean"]) => this;
  compareBeforeEmit: (value: WebpackOutput["compareBeforeEmit"]) => this;
  crossOriginLoading: (value: WebpackOutput["crossOriginLoading"]) => this;
  cssChunkFilename: (value: WebpackOutput["cssChunkFilename"]) => this;
  cssFilename: (value: WebpackOutput["cssFilename"]) => this;
  devtoolFallbackModuleFilenameTemplate: (value: WebpackOutput["devtoolFallbackModuleFilenameTemplate"]) => this;
  devtoolModuleFilenameTemplate: (value: WebpackOutput["devtoolModuleFilenameTemplate"]) => this;
  devtoolNamespace: (value: WebpackOutput["devtoolNamespace"]) => this;
  enabledChunkLoadingTypes: (value: WebpackOutput["enabledChunkLoadingTypes"]) => this;
  enabledLibraryTypes: (value: WebpackOutput["enabledLibraryTypes"]) => this;
  enabledWasmLoadingTypes: (value: WebpackOutput["enabledWasmLoadingTypes"]) => this;
  environment: (value: WebpackOutput["environment"]) => this;
  filename: (value: WebpackOutput["filename"]) => this;
  globalObject: (value: WebpackOutput["globalObject"]) => this;
  hashDigest: (value: WebpackOutput["hashDigest"]) => this;
  hashDigestLength: (value: WebpackOutput["hashDigestLength"]) => this;
  hashFunction: (value: WebpackOutput["hashFunction"]) => this;
  hashSalt: (value: WebpackOutput["hashSalt"]) => this;
  hotUpdateChunkFilename: (value: WebpackOutput["hotUpdateChunkFilename"]) => this;
  hotUpdateGlobal: (value: WebpackOutput["hotUpdateGlobal"]) => this;
  hotUpdateMainFilename: (value: WebpackOutput["hotUpdateMainFilename"]) => this;
  html: (value: WebpackOutput["html"]) => this;
  htmlChunkFilename: (value: WebpackOutput["htmlChunkFilename"]) => this;
  htmlFilename: (value: WebpackOutput["htmlFilename"]) => this;
  iife: (value: WebpackOutput["iife"]) => this;
  ignoreBrowserWarnings: (value: WebpackOutput["ignoreBrowserWarnings"]) => this;
  importFunctionName: (value: WebpackOutput["importFunctionName"]) => this;
  importMetaName: (value: WebpackOutput["importMetaName"]) => this;
  library: (value: WebpackOutput["library"]) => this;
  libraryExport: (value: WebpackOutput["libraryExport"]) => this;
  libraryTarget: (value: WebpackOutput["libraryTarget"]) => this;
  module: (value: WebpackOutput["module"]) => this;
  path: (value: WebpackOutput["path"]) => this;
  pathinfo: (value: WebpackOutput["pathinfo"]) => this;
  publicPath: (value: WebpackOutput["publicPath"]) => this;
  scriptType: (value: WebpackOutput["scriptType"]) => this;
  sourceMapFilename: (value: WebpackOutput["sourceMapFilename"]) => this;
  sourcePrefix: (value: WebpackOutput["sourcePrefix"]) => this;
  strictModuleErrorHandling: (value: WebpackOutput["strictModuleErrorHandling"]) => this;
  strictModuleExceptionHandling: (value: WebpackOutput["strictModuleExceptionHandling"]) => this;
  strictModuleResolution: (value: WebpackOutput["strictModuleResolution"]) => this;
  trustedTypes: (value: WebpackOutput["trustedTypes"]) => this;
  umdNamedDefine: (value: WebpackOutput["umdNamedDefine"]) => this;
  uniqueName: (value: WebpackOutput["uniqueName"]) => this;
  wasmLoading: (value: WebpackOutput["wasmLoading"]) => this;
  webassemblyModuleFilename: (value: WebpackOutput["webassemblyModuleFilename"]) => this;
  workerChunkFilename: (value: WebpackOutput["workerChunkFilename"]) => this;
  workerChunkLoading: (value: WebpackOutput["workerChunkLoading"]) => this;
  workerPublicPath: (value: WebpackOutput["workerPublicPath"]) => this;
  workerWasmLoading: (value: WebpackOutput["workerWasmLoading"]) => this;
}
//#endregion
//#region src/Performance.d.ts
type WebpackPerformance = Exclude<Required<NonNullable<Configuration["performance"]>>, false>;
declare class Performance extends ChainedValueMap<Config> {
  constructor(parent?: Config);
  assetFilter: (value: WebpackPerformance["assetFilter"]) => this;
  hints: (value: WebpackPerformance["hints"]) => this;
  maxAssetSize: (value: WebpackPerformance["maxAssetSize"]) => this;
  maxEntrypointSize: (value: WebpackPerformance["maxEntrypointSize"]) => this;
}
interface Performance {
  (value: boolean): Config;
}
//#endregion
//#region src/ResolveLoader.d.ts
declare class ResolveLoader extends Resolve {
  moduleExtensions: TypedChainedSet<this, string>;
  packageMains: TypedChainedSet<this, string>;
  constructor(parent?: unknown);
  toConfig(): Record<string, unknown>;
  merge(obj: Record<string, unknown>, omit?: string[]): this;
}
//#endregion
//#region src/Config.d.ts
type WebpackConfig = Required<Configuration>;
type ResolvePlugin = Exclude<NonNullable<ResolveOptions["plugins"]>[number], "...">;
type WebpackEntry = NonNullable<Configuration["entry"]>;
type WebpackEntryObject = Exclude<WebpackEntry, string | string[] | Function>[string];
declare class EntryPoint extends TypedChainedSet<Config, WebpackEntryObject> {}
declare class Plugins<Parent, PluginType extends WebpackPluginInstance> extends TypedChainedMap<Parent, Record<string, Plugin<Parent, PluginType>>> {}
type PluginClass<PluginType extends WebpackPluginInstance | ResolvePlugin> = new (...opts: any[]) => PluginType;
declare class Config extends ChainedMap<void> {
  entryPoints: TypedChainedMap<Config, Record<string, EntryPoint>>;
  output: Output;
  module: Module;
  optimization: Optimization;
  performance: Performance & ((value: boolean) => this);
  plugins: Plugins<this, WebpackPluginInstance>;
  resolve: Resolve;
  resolveLoader: ResolveLoader;
  devServer: DevServer;
  constructor();
  context: (value: WebpackConfig["context"]) => this;
  mode: (value: WebpackConfig["mode"]) => this;
  cache: (value: WebpackConfig["cache"]) => this;
  devtool: (value: WebpackConfig["devtool"]) => this;
  target: (value: WebpackConfig["target"]) => this;
  watch: (value: WebpackConfig["watch"]) => this;
  watchOptions: (value: WebpackConfig["watchOptions"]) => this;
  externals: (value: WebpackConfig["externals"]) => this;
  externalsType: (value: WebpackConfig["externalsType"]) => this;
  externalsPresets: (value: WebpackConfig["externalsPresets"]) => this;
  dotenv: (value: WebpackConfig["dotenv"]) => this;
  node: (value: WebpackConfig["node"]) => this;
  stats: (value: WebpackConfig["stats"]) => this;
  experiments: (value: WebpackConfig["experiments"]) => this;
  infrastructureLogging: (value: WebpackConfig["infrastructureLogging"]) => this;
  amd: (value: WebpackConfig["amd"]) => this;
  bail: (value: WebpackConfig["bail"]) => this;
  dependencies: (value: WebpackConfig["dependencies"]) => this;
  ignoreWarnings: (value: WebpackConfig["ignoreWarnings"]) => this;
  loader: (value: WebpackConfig["loader"]) => this;
  name: (value: WebpackConfig["name"]) => this;
  parallelism: (value: WebpackConfig["parallelism"]) => this;
  profile: (value: WebpackConfig["profile"]) => this;
  recordsInputPath: (value: WebpackConfig["recordsInputPath"]) => this;
  recordsOutputPath: (value: WebpackConfig["recordsOutputPath"]) => this;
  recordsPath: (value: WebpackConfig["recordsPath"]) => this;
  snapshot: (value: WebpackConfig["snapshot"]) => this;
  static toString(config: Configuration, { verbose, configPrefix }?: {
    configPrefix?: string | undefined;
    verbose?: boolean | undefined;
  }): string;
  entry(name: string): EntryPoint;
  plugin(name: string): Plugin<this, WebpackPluginInstance>;
  toConfig(): Configuration;
  toString(options?: {
    verbose?: boolean;
    configPrefix?: string;
  }): string;
  merge(obj?: Record<string, unknown>, omit?: string[]): this;
}
//#endregion
export { Chained as Chainable, Chained, ChainedMap, ChainedSet, ChainedValueMap, Config, EntryPoint, Orderable, PluginClass, Plugins, TypedChainedMap, TypedChainedSet, createOrderable };
//# sourceMappingURL=index.d.ts.map