webpack 5.92.1 → 5.94.0

package/types.d.ts

@@ -99,10 +99,12 @@ import {
 	AsyncSeriesHook,
 	AsyncSeriesWaterfallHook,
 	HookMap,
+	IfSet,
 	MultiHook,
 	SyncBailHook,
 	SyncHook,
-	SyncWaterfallHook
+	SyncWaterfallHook,
+	TapOptions
 } from "tapable";
 import { SecureContextOptions, TlsOptions } from "tls";
 import { URL } from "url";
@@ -219,6 +221,7 @@ declare interface AggressiveSplittingPluginOptions {
 	 */
 	minSize?: number;
 }
+type Algorithm = string | typeof Hash;
 type Alias = string | false | string[];
 declare interface AliasOption {
 	alias: Alias;
@@ -230,13 +233,13 @@ declare interface AliasOptions {
 	[index: string]: AliasOptionNewRequest;
 }
 declare interface Argument {
-	description: string;
-	simpleType: "string" | "number" | "boolean";
+	description?: string;
+	simpleType: SimpleType;
 	multiple: boolean;
 	configs: ArgumentConfig[];
 }
 declare interface ArgumentConfig {
-	description: string;
+	description?: string;
 	negatedDescription?: string;
 	path: string;
 	multiple: boolean;
@@ -306,6 +309,11 @@ type AssetInfo = KnownAssetInfo & Record<string, any>;
  * Generator options for asset/inline modules.
  */
 declare interface AssetInlineGeneratorOptions {
+	/**
+	 * Whether or not this asset module should be considered binary. This can be set to 'false' to treat this asset module as text.
+	 */
+	binary?: boolean;
+
 	/**
 	 * The options for data url generator.
 	 */
@@ -346,6 +354,11 @@ declare interface AssetParserOptions {
  * Generator options for asset/resource modules.
  */
 declare interface AssetResourceGeneratorOptions {
+	/**
+	 * Whether or not this asset module should be considered binary. This can be set to 'false' to treat this asset module as text.
+	 */
+	binary?: boolean;
+
 	/**
 	 * Emit an output asset from this asset module. This can be set to 'false' to omit emitting e. g. for SSR.
 	 */
@@ -390,7 +403,9 @@ declare abstract class AsyncQueue<T, K, R> {
 		added: SyncHook<[T]>;
 		beforeStart: AsyncSeriesHook<[T]>;
 		started: SyncHook<[T]>;
-		result: SyncHook<[T, Error, R]>;
+		result: SyncHook<
+			[T, undefined | null | WebpackError, undefined | null | R]
+		>;
 	};
 	add(item: T, callback: CallbackAsyncQueue<R>): void;
 	invalidate(item: T): void;
@@ -440,8 +455,8 @@ declare class AutomaticPrefetchPlugin {
 }
 type AuxiliaryComment = string | LibraryCustomUmdCommentObject;
 declare interface BackendApi {
-	dispose: (arg0?: Error) => void;
-	module: (arg0: Module) => { client: string; data: string; active: boolean };
+	dispose: (arg0: (arg0?: null | Error) => void) => void;
+	module: (arg0: Module) => ModuleResult;
 }
 declare class BannerPlugin {
 	constructor(options: BannerPluginArgument);
@@ -566,6 +581,7 @@ declare abstract class BasicEvaluatedExpression {
 		| ThisExpression
 		| UpdateExpression
 		| YieldExpression
+		| SpreadElement
 		| FunctionDeclaration
 		| VariableDeclaration
 		| ClassDeclaration
@@ -603,7 +619,6 @@ declare abstract class BasicEvaluatedExpression {
 		| ArrayPattern
 		| RestElement
 		| AssignmentPattern
-		| SpreadElement
 		| Property
 		| AssignmentProperty
 		| ClassBody
@@ -789,6 +804,7 @@ declare abstract class BasicEvaluatedExpression {
 			| ThisExpression
 			| UpdateExpression
 			| YieldExpression
+			| SpreadElement
 			| FunctionDeclaration
 			| VariableDeclaration
 			| ClassDeclaration
@@ -826,7 +842,6 @@ declare abstract class BasicEvaluatedExpression {
 			| ArrayPattern
 			| RestElement
 			| AssignmentPattern
-			| SpreadElement
 			| Property
 			| AssignmentProperty
 			| ClassBody
@@ -838,6 +853,13 @@ declare abstract class BasicEvaluatedExpression {
 			| TemplateElement
 	): BasicEvaluatedExpression;
 }
+declare interface Bootstrap {
+	header: string[];
+	beforeStartup: string[];
+	startup: string[];
+	afterStartup: string[];
+	allowInlineStartup: boolean;
+}
 type BufferEncoding =
 	| "ascii"
 	| "utf8"
@@ -986,7 +1008,7 @@ declare interface CallExpressionInfo {
 	getMemberRanges: () => [number, number][];
 }
 declare interface CallbackAsyncQueue<T> {
-	(err?: null | WebpackError, result?: T): any;
+	(err?: null | WebpackError, result?: null | T): any;
 }
 declare interface CallbackCacheCache<T> {
 	(err: null | WebpackError, result?: T): void;
@@ -1173,7 +1195,7 @@ declare class ChunkGraph {
 	connectChunkAndEntryModule(
 		chunk: Chunk,
 		module: Module,
-		entrypoint?: Entrypoint
+		entrypoint: Entrypoint
 	): void;
 	connectChunkAndRuntimeModule(chunk: Chunk, module: RuntimeModule): void;
 	addFullHashModuleToChunk(chunk: Chunk, module: RuntimeModule): void;
@@ -1207,7 +1229,7 @@ declare class ChunkGraph {
 		chunkGroup: ChunkGroup
 	): void;
 	disconnectChunkGroup(chunkGroup: ChunkGroup): void;
-	getModuleId(module: Module): ModuleId;
+	getModuleId(module: Module): null | string | number;
 	setModuleId(module: Module, id: ModuleId): void;
 	getRuntimeId(runtime: string): string | number;
 	setRuntimeId(runtime: string, id: string | number): void;
@@ -1322,7 +1344,11 @@ declare abstract class ChunkGroup {
 	hasBlock(block: AsyncDependenciesBlock): boolean;
 	get blocksIterable(): Iterable<AsyncDependenciesBlock>;
 	addBlock(block: AsyncDependenciesBlock): boolean;
-	addOrigin(module: Module, loc: DependencyLocation, request: string): void;
+	addOrigin(
+		module: null | Module,
+		loc: DependencyLocation,
+		request: string
+	): void;
 	getFiles(): string[];
 	remove(): void;
 	sortItems(): void;
@@ -1473,7 +1499,7 @@ declare interface ChunkRenderContext {
 	/**
 	 * rendering in strict context
 	 */
-	strictMode: boolean;
+	strictMode?: boolean;
 }
 declare interface ChunkSizeOptions {
 	/**
@@ -1488,12 +1514,57 @@ declare interface ChunkSizeOptions {
 }
 declare abstract class ChunkTemplate {
 	hooks: Readonly<{
-		renderManifest: { tap: (options?: any, fn?: any) => void };
-		modules: { tap: (options?: any, fn?: any) => void };
-		render: { tap: (options?: any, fn?: any) => void };
-		renderWithEntry: { tap: (options?: any, fn?: any) => void };
-		hash: { tap: (options?: any, fn?: any) => void };
-		hashForChunk: { tap: (options?: any, fn?: any) => void };
+		renderManifest: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (
+					arg0: RenderManifestEntry[],
+					arg1: RenderManifestOptions
+				) => RenderManifestEntry[]
+			) => void;
+		};
+		modules: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: Source, arg1: ModuleTemplate, arg2: RenderContext) => Source
+			) => void;
+		};
+		render: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: Source, arg1: ModuleTemplate, arg2: RenderContext) => Source
+			) => void;
+		};
+		renderWithEntry: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: Source, arg1: Chunk) => Source
+			) => void;
+		};
+		hash: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: Hash) => void
+			) => void;
+		};
+		hashForChunk: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: Hash, arg1: Chunk, arg2: ChunkHashContext) => void
+			) => void;
+		};
 	}>;
 	get outputOptions(): Output;
 }
@@ -1599,7 +1670,7 @@ declare interface CodeGenerationResult {
 	/**
 	 * the runtime requirements
 	 */
-	runtimeRequirements: ReadonlySet<string>;
+	runtimeRequirements: null | ReadonlySet<string>;
 
 	/**
 	 * a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
@@ -1701,10 +1772,10 @@ declare class Compilation {
 		 * inspect, analyze, and/or modify the chunk graph.
 		 */
 		afterChunks: SyncHook<[Iterable<Chunk>]>;
-		optimizeDependencies: SyncBailHook<[Iterable<Module>], any>;
+		optimizeDependencies: SyncBailHook<[Iterable<Module>], boolean | void>;
 		afterOptimizeDependencies: SyncHook<[Iterable<Module>]>;
 		optimize: SyncHook<[]>;
-		optimizeModules: SyncBailHook<[Iterable<Module>], any>;
+		optimizeModules: SyncBailHook<[Iterable<Module>], boolean | void>;
 		afterOptimizeModules: SyncHook<[Iterable<Module>]>;
 		optimizeChunks: SyncBailHook<
 			[Iterable<Chunk>, ChunkGroup[]],
@@ -1729,13 +1800,13 @@ declare class Compilation {
 			[Module, Set<string>, RuntimeRequirementsContext]
 		>;
 		runtimeRequirementInModule: HookMap<
-			SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext], any>
+			SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext], void>
 		>;
 		additionalTreeRuntimeRequirements: SyncHook<
 			[Chunk, Set<string>, RuntimeRequirementsContext]
 		>;
 		runtimeRequirementInTree: HookMap<
-			SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], any>
+			SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>
 		>;
 		runtimeModule: SyncHook<[RuntimeModule, Chunk]>;
 		reviveModules: SyncHook<[Iterable<Module>, any]>;
@@ -1820,7 +1891,9 @@ declare class Compilation {
 		>;
 		statsFactory: SyncHook<[StatsFactory, NormalizedStatsOptions]>;
 		statsPrinter: SyncHook<[StatsPrinter, NormalizedStatsOptions]>;
-		get normalModuleLoader(): SyncHook<[object, NormalModule]>;
+		get normalModuleLoader(): SyncHook<
+			[LoaderContextNormalModule<any>, NormalModule]
+		>;
 	}>;
 	name?: string;
 	startTime?: number;
@@ -1829,7 +1902,7 @@ declare class Compilation {
 	resolverFactory: ResolverFactory;
 	inputFileSystem: InputFileSystem;
 	fileSystemInfo: FileSystemInfo;
-	valueCacheVersions: Map<string, string | Set<string>>;
+	valueCacheVersions: Map<string, ValueCacheVersion>;
 	requestShortener: RequestShortener;
 	compilerPath: string;
 	logger: WebpackLogger;
@@ -1882,7 +1955,7 @@ declare class Compilation {
 	logging: Map<string, LogEntry[]>;
 	dependencyFactories: Map<DepConstructor, ModuleFactory>;
 	dependencyTemplates: DependencyTemplates;
-	childrenCounters: object;
+	childrenCounters: Record<string, number>;
 	usedChunkIds: Set<string | number>;
 	usedModuleIds: Set<number>;
 	needAdditionalPass: boolean;
@@ -1907,7 +1980,7 @@ declare class Compilation {
 	getLogger(name: string | (() => string)): WebpackLogger;
 	addModule(
 		module: Module,
-		callback: (err?: null | WebpackError, result?: Module) => void
+		callback: (err?: null | WebpackError, result?: null | Module) => void
 	): void;
 
 	/**
@@ -1925,21 +1998,21 @@ declare class Compilation {
 	 */
 	buildModule(
 		module: Module,
-		callback: (err?: null | WebpackError, result?: Module) => void
+		callback: (err?: null | WebpackError, result?: null | Module) => void
 	): void;
 	processModuleDependencies(
 		module: Module,
-		callback: (err?: null | WebpackError, result?: Module) => void
+		callback: (err?: null | WebpackError, result?: null | Module) => void
 	): void;
 	processModuleDependenciesNonRecursive(module: Module): void;
 	handleModuleCreation(
 		__0: HandleModuleCreationOptions,
-		callback: (err?: null | WebpackError, result?: Module) => void
+		callback: (err?: null | WebpackError, result?: null | Module) => void
 	): void;
 	addModuleChain(
 		context: string,
 		dependency: Dependency,
-		callback: (err?: null | WebpackError, result?: Module) => void
+		callback: (err?: null | WebpackError, result?: null | Module) => void
 	): void;
 	addModuleTree(
 		__0: {
@@ -1956,23 +2029,23 @@ declare class Compilation {
 			 */
 			contextInfo?: Partial<ModuleFactoryCreateDataContextInfo>;
 		},
-		callback: (err?: null | WebpackError, result?: Module) => void
+		callback: (err?: null | WebpackError, result?: null | Module) => void
 	): void;
 	addEntry(
 		context: string,
 		entry: Dependency,
 		optionsOrName: string | EntryOptions,
-		callback: (err?: null | WebpackError, result?: Module) => void
+		callback: (err?: null | WebpackError, result?: null | Module) => void
 	): void;
 	addInclude(
 		context: string,
 		dependency: Dependency,
 		options: EntryOptions,
-		callback: (err?: null | WebpackError, result?: Module) => void
+		callback: (err?: null | WebpackError, result?: null | Module) => void
 	): void;
 	rebuildModule(
 		module: Module,
-		callback: (err?: null | WebpackError, result?: Module) => void
+		callback: (err?: null | WebpackError, result?: null | Module) => void
 	): void;
 	finish(callback: (err?: null | WebpackError) => void): void;
 	unseal(): void;
@@ -2069,22 +2142,16 @@ declare class Compilation {
 	createModuleAssets(): void;
 	getRenderManifest(options: RenderManifestOptions): RenderManifestEntry[];
 	createChunkAssets(callback: (err?: null | WebpackError) => void): void;
-	getPath(
-		filename: string | ((arg0: PathData, arg1?: AssetInfo) => string),
-		data?: PathData
-	): string;
+	getPath(filename: TemplatePath, data?: PathData): string;
 	getPathWithInfo(
-		filename: string | ((arg0: PathData, arg1?: AssetInfo) => string),
+		filename: TemplatePath,
 		data?: PathData
-	): { path: string; info: AssetInfo };
-	getAssetPath(
-		filename: string | ((arg0: PathData, arg1?: AssetInfo) => string),
-		data: PathData
-	): string;
+	): InterpolatedPathAndAssetInfo;
+	getAssetPath(filename: TemplatePath, data: PathData): string;
 	getAssetPathWithInfo(
-		filename: string | ((arg0: PathData, arg1?: AssetInfo) => string),
+		filename: TemplatePath,
 		data: PathData
-	): { path: string; info: AssetInfo };
+	): InterpolatedPathAndAssetInfo;
 	getWarnings(): WebpackError[];
 	getErrors(): WebpackError[];
 
@@ -2104,13 +2171,13 @@ declare class Compilation {
 	executeModule(
 		module: Module,
 		options: ExecuteModuleOptions,
-		callback: (err?: null | WebpackError, result?: ExecuteModuleResult) => void
+		callback: (err: null | WebpackError, result?: ExecuteModuleResult) => void
 	): void;
 	checkConstraints(): void;
 	factorizeModule: {
 		(
 			options: FactorizeModuleOptions & { factoryResult?: false },
-			callback: (err?: null | WebpackError, result?: Module) => void
+			callback: (err?: null | WebpackError, result?: null | Module) => void
 		): void;
 		(
 			options: FactorizeModuleOptions & { factoryResult: true },
@@ -2267,7 +2334,7 @@ declare class Compiler {
 		invalid: SyncHook<[null | string, number]>;
 		watchClose: SyncHook<[]>;
 		shutdown: AsyncSeriesHook<[]>;
-		infrastructureLog: SyncBailHook<[string, string, any[]], true>;
+		infrastructureLog: SyncBailHook<[string, string, undefined | any[]], true>;
 		environment: SyncHook<[]>;
 		afterEnvironment: SyncHook<[]>;
 		afterPlugins: SyncHook<[Compiler]>;
@@ -2299,7 +2366,11 @@ declare class Compiler {
 	>;
 	fsStartTime?: number;
 	resolverFactory: ResolverFactory;
-	infrastructureLogger?: (arg0: string, arg1: LogTypeEnum, arg2: any[]) => void;
+	infrastructureLogger?: (
+		arg0: string,
+		arg1: LogTypeEnum,
+		arg2?: any[]
+	) => void;
 	platform: Readonly<PlatformTargetProperties>;
 	options: WebpackOptionsNormalized;
 	context: string;
@@ -2505,6 +2576,7 @@ declare interface Configuration {
 		| "jsonp"
 		| "system"
 		| "promise"
+		| "module-import"
 		| "script"
 		| "node-commonjs";
 
@@ -2758,9 +2830,7 @@ declare interface ConsumesConfig {
 declare interface ConsumesObject {
 	[index: string]: string | ConsumesConfig;
 }
-type ContainerOptionsFormat<T> =
-	| Record<string, string | string[] | T>
-	| (string | Record<string, string | string[] | T>)[];
+type ContainerOptionsFormat<T> = Item<T> | (string | Item<T>)[];
 declare class ContainerPlugin {
 	constructor(options: ContainerPluginOptions);
 
@@ -2824,8 +2894,12 @@ declare interface ContainerReferencePluginOptions {
 	 */
 	shareScope?: string;
 }
+declare interface ContextAlternativeRequest {
+	context: string;
+	request: string;
+}
 declare abstract class ContextElementDependency extends ModuleDependency {
-	referencedExports?: string[][];
+	referencedExports?: null | string[][];
 }
 declare class ContextExclusionPlugin {
 	constructor(negativeMatcher: RegExp);
@@ -2861,12 +2935,12 @@ declare abstract class ContextModuleFactory extends ModuleFactory {
 		contextModuleFiles: SyncWaterfallHook<[string[]]>;
 		alternatives: FakeHook<
 			Pick<
-				AsyncSeriesWaterfallHook<[any[]]>,
+				AsyncSeriesWaterfallHook<[ContextAlternativeRequest[]]>,
 				"name" | "tap" | "tapAsync" | "tapPromise"
 			>
 		>;
 		alternativeRequests: AsyncSeriesWaterfallHook<
-			[any[], ContextModuleOptions]
+			[ContextAlternativeRequest[], ContextModuleOptions]
 		>;
 	}>;
 	resolverFactory: ResolverFactory;
@@ -2874,7 +2948,7 @@ declare abstract class ContextModuleFactory extends ModuleFactory {
 		fs: InputFileSystem,
 		options: ContextModuleOptions,
 		callback: (
-			err?: null | Error,
+			err: null | Error,
 			dependencies?: ContextElementDependency[]
 		) => any
 	): void;
@@ -2909,14 +2983,14 @@ declare class ContextReplacementPlugin {
 		resourceRegExp: RegExp,
 		newContentResource?: any,
 		newContentRecursive?: any,
-		newContentRegExp?: any
+		newContentRegExp?: RegExp
 	);
 	resourceRegExp: RegExp;
 	newContentCallback: any;
 	newContentResource: any;
 	newContentCreateContextMap: any;
 	newContentRecursive: any;
-	newContentRegExp: any;
+	newContentRegExp?: RegExp;
 
 	/**
 	 * Apply the plugin
@@ -2930,8 +3004,8 @@ declare interface ContextTimestampAndHash {
 	resolved?: ResolvedContextTimestampAndHash;
 	symlinks?: Set<string>;
 }
-type CreateStatsOptionsContext = KnownCreateStatsOptionsContext &
-	Record<string, any>;
+type CreateStatsOptionsContext = Record<string, any> &
+	KnownCreateStatsOptionsContext;
 type CreateWriteStreamFSImplementation = FSImplementation & {
 	write: (...args: any[]) => any;
 	close?: (...args: any[]) => any;
@@ -3105,14 +3179,14 @@ declare class DefinePlugin {
 		fn: (arg0: {
 			module: NormalModule;
 			key: string;
-			readonly version?: string;
+			readonly version: ValueCacheVersion;
 		}) => CodeValuePrimitive,
 		options?: true | string[] | RuntimeValueOptions
 	): RuntimeValue;
 }
 declare class DelegatedPlugin {
-	constructor(options?: any);
-	options: any;
+	constructor(options: Options);
+	options: Options;
 
 	/**
 	 * Apply the plugin
@@ -3609,6 +3683,9 @@ declare interface Effect {
 	type: string;
 	value: any;
 }
+declare interface EffectData {
+	[index: string]: any;
+}
 declare class ElectronTargetPlugin {
 	constructor(context?: "main" | "preload" | "renderer");
 
@@ -3849,8 +3926,7 @@ type EntryOptions = { name?: string } & Omit<
 >;
 declare class EntryPlugin {
 	/**
-	 * An entry plugin which will handle
-	 * creation of the EntryDependency
+	 * An entry plugin which will handle creation of the EntryDependency
 	 */
 	constructor(context: string, entry: string, options?: string | EntryOptions);
 	context: string;
@@ -3972,9 +4048,9 @@ declare interface Environment {
 	templateLiteral?: boolean;
 }
 declare class EnvironmentPlugin {
-	constructor(...keys: any[]);
-	keys: any[];
-	defaultValues: any;
+	constructor(...keys: (string | string[] | Record<string, string>)[]);
+	keys: string[];
+	defaultValues: Record<string, string>;
 
 	/**
 	 * Apply the plugin
@@ -4180,7 +4256,7 @@ declare abstract class ExportInfo {
 	setTarget(
 		key: any,
 		connection: ModuleGraphConnection,
-		exportName?: string[],
+		exportName?: null | string[],
 		priority?: number
 	): boolean;
 	getUsed(runtime: RuntimeSpec): UsageStateType;
@@ -4200,42 +4276,30 @@ declare abstract class ExportInfo {
 	setUsedName(name: string): void;
 	getTerminalBinding(
 		moduleGraph: ModuleGraph,
-		resolveTargetFilter?: (arg0: {
-			module: Module;
-			export?: string[];
-		}) => boolean
+		resolveTargetFilter?: (arg0: TargetItem) => boolean
 	): undefined | ExportsInfo | ExportInfo;
 	isReexport(): undefined | boolean;
 	findTarget(
 		moduleGraph: ModuleGraph,
 		validTargetModuleFilter: (arg0: Module) => boolean
-	): undefined | false | { module: Module; export?: string[] };
+	): undefined | null | false | TargetItemWithoutConnection;
 	getTarget(
 		moduleGraph: ModuleGraph,
-		resolveTargetFilter?: (arg0: {
-			module: Module;
-			export?: string[];
-		}) => boolean
-	): undefined | { module: Module; export?: string[] };
+		resolveTargetFilter?: (arg0: TargetItem) => boolean
+	): undefined | TargetItem;
 
 	/**
 	 * Move the target forward as long resolveTargetFilter is fulfilled
 	 */
 	moveTarget(
 		moduleGraph: ModuleGraph,
-		resolveTargetFilter: (arg0: {
-			module: Module;
-			export?: string[];
-		}) => boolean,
-		updateOriginalConnection?: (arg0: {
-			module: Module;
-			export?: string[];
-		}) => ModuleGraphConnection
-	): undefined | { module: Module; export?: string[] };
-	createNestedExportsInfo(): undefined | ExportsInfo;
+		resolveTargetFilter: (arg0: TargetItem) => boolean,
+		updateOriginalConnection?: (arg0: TargetItem) => ModuleGraphConnection
+	): undefined | TargetItem;
+	createNestedExportsInfo(): ExportsInfo;
 	getNestedExportsInfo(): undefined | ExportsInfo;
-	hasInfo(baseInfo?: any, runtime?: any): boolean;
-	updateHash(hash?: any, runtime?: any): void;
+	hasInfo(baseInfo: ExportInfo, runtime: RuntimeSpec): boolean;
+	updateHash(hash: Hash, runtime: RuntimeSpec): void;
 	getUsedInfo(): string;
 	getProvidedInfo():
 		| "no provided info"
@@ -4320,12 +4384,9 @@ declare abstract class ExportsInfo {
 	getUsageKey(runtime: RuntimeSpec): string;
 	isEquallyUsed(runtimeA: RuntimeSpec, runtimeB: RuntimeSpec): boolean;
 	getUsed(name: string | string[], runtime: RuntimeSpec): UsageStateType;
-	getUsedName(
-		name: undefined | string | string[],
-		runtime: RuntimeSpec
-	): string | false | string[];
+	getUsedName(name: string | string[], runtime: RuntimeSpec): UsedName;
 	updateHash(hash: Hash, runtime: RuntimeSpec): void;
-	getRestoreProvidedData(): any;
+	getRestoreProvidedData(): RestoreProvidedData;
 	restoreProvided(__0: {
 		otherProvided: any;
 		otherCanMangleProvide: any;
@@ -4347,7 +4408,7 @@ declare interface ExportsSpec {
 	/**
 	 * list of maybe prior exposed, but now hidden exports
 	 */
-	hideExports?: Set<string>;
+	hideExports?: null | Set<string>;
 
 	/**
 	 * when reexported: from which module
@@ -4521,6 +4582,7 @@ declare class ExternalModule extends Module {
 	externalType: string;
 	userRequest: string;
 	dependencyMeta?: ImportDependencyMeta | CssImportDependencyMeta;
+	getModuleImportType(externalType: string): string;
 
 	/**
 	 * restore unsafe cache data
@@ -4622,6 +4684,7 @@ type ExternalsType =
 	| "jsonp"
 	| "system"
 	| "promise"
+	| "module-import"
 	| "script"
 	| "node-commonjs";
 declare interface FSImplementation {
@@ -4799,16 +4862,12 @@ declare interface FileSystem {
 declare abstract class FileSystemInfo {
 	fs: InputFileSystem;
 	logger?: WebpackLogger;
-	fileTimestampQueue: AsyncQueue<string, string, null | FileSystemInfoEntry>;
-	fileHashQueue: AsyncQueue<string, string, null | string>;
-	contextTimestampQueue: AsyncQueue<
-		string,
-		string,
-		null | ContextFileSystemInfoEntry
-	>;
-	contextHashQueue: AsyncQueue<string, string, null | ContextHash>;
-	contextTshQueue: AsyncQueue<string, string, null | ContextTimestampAndHash>;
-	managedItemQueue: AsyncQueue<string, string, null | string>;
+	fileTimestampQueue: AsyncQueue<string, string, FileSystemInfoEntry>;
+	fileHashQueue: AsyncQueue<string, string, string>;
+	contextTimestampQueue: AsyncQueue<string, string, ContextFileSystemInfoEntry>;
+	contextHashQueue: AsyncQueue<string, string, ContextHash>;
+	contextTshQueue: AsyncQueue<string, string, ContextTimestampAndHash>;
+	managedItemQueue: AsyncQueue<string, string, string>;
 	managedItemDirectoryQueue: AsyncQueue<string, string, Set<string>>;
 	unmanagedPathsWithSlash: string[];
 	unmanagedPathsRegExps: RegExp[];
@@ -4854,7 +4913,7 @@ declare abstract class FileSystemInfo {
 		path: string,
 		callback: (
 			arg0?: null | WebpackError,
-			arg1?: ResolvedContextTimestampAndHash
+			arg1?: null | ResolvedContextTimestampAndHash
 		) => void
 	): void;
 	resolveBuildDependencies(
@@ -4875,7 +4934,7 @@ declare abstract class FileSystemInfo {
 		directories: null | Iterable<string>,
 		missing: null | Iterable<string>,
 		options: undefined | null | SnapshotOptionsFileSystemInfo,
-		callback: (arg0?: null | WebpackError, arg1?: null | Snapshot) => void
+		callback: (arg0: null | WebpackError, arg1: null | Snapshot) => void
 	): void;
 	mergeSnapshots(snapshot1: Snapshot, snapshot2: Snapshot): Snapshot;
 	checkSnapshotValid(
@@ -4890,6 +4949,9 @@ declare interface FileSystemInfoEntry {
 	timestamp?: number;
 }
 type FilterItemTypes = string | RegExp | ((value: string) => boolean);
+declare interface Flags {
+	[index: string]: Argument;
+}
 declare interface GenerateContext {
 	/**
 	 * mapping from dependencies to templates
@@ -5030,16 +5092,12 @@ declare class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		contentType: string,
 		name: string,
 		global: string,
-		getFilenameForChunk: (
-			arg0: Chunk
-		) => string | ((arg0: PathData, arg1?: AssetInfo) => string),
+		getFilenameForChunk: (arg0: Chunk) => TemplatePath,
 		allChunks: boolean
 	);
 	contentType: string;
 	global: string;
-	getFilenameForChunk: (
-		arg0: Chunk
-	) => string | ((arg0: PathData, arg1?: AssetInfo) => string);
+	getFilenameForChunk: (arg0: Chunk) => TemplatePath;
 	allChunks: boolean;
 
 	/**
@@ -5063,7 +5121,7 @@ declare class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	static STAGE_TRIGGER: number;
 }
 declare interface GroupConfig {
-	getKeys: (arg0?: any) => string[];
+	getKeys: (arg0?: any) => undefined | string[];
 	createGroup: (arg0: string, arg1: any[], arg2: any[]) => object;
 	getOptions?: (arg0: string, arg1: any[]) => GroupOptions;
 }
@@ -5309,8 +5367,7 @@ declare class IgnorePlugin {
 	options: IgnorePluginOptions;
 
 	/**
-	 * Note that if "contextRegExp" is given, both the "resourceRegExp"
-	 * and "contextRegExp" have to match.
+	 * Note that if "contextRegExp" is given, both the "resourceRegExp" and "contextRegExp" have to match.
 	 */
 	checkIgnore(resolveData: ResolveData): undefined | false;
 
@@ -5339,6 +5396,7 @@ type IgnorePluginOptions =
 type ImportAttributes = Record<string, string> & {};
 declare interface ImportDependencyMeta {
 	attributes?: ImportAttributes;
+	externalType?: "import" | "module";
 }
 declare interface ImportModuleOptions {
 	/**
@@ -5495,6 +5553,13 @@ declare interface IntermediateFileSystemExtras {
 	) => void;
 }
 type InternalCell<T> = T | typeof TOMBSTONE | typeof UNDEFINED_MARKER;
+declare interface InterpolatedPathAndAssetInfo {
+	path: string;
+	info: AssetInfo;
+}
+declare interface Item<T> {
+	[index: string]: string | string[] | T;
+}
 declare abstract class ItemCacheFacade {
 	get<T>(callback: CallbackCacheCacheFacade<T>): void;
 	getPromise<T>(): Promise<T>;
@@ -5519,7 +5584,7 @@ declare class JavascriptModulesPlugin {
 		renderContext: ChunkRenderContext,
 		hooks: CompilationHooksJavascriptModulesPlugin,
 		factory: boolean
-	): Source;
+	): null | Source;
 	renderChunk(
 		renderContext: RenderContext,
 		hooks: CompilationHooksJavascriptModulesPlugin
@@ -5537,13 +5602,7 @@ declare class JavascriptModulesPlugin {
 	renderBootstrap(
 		renderContext: RenderBootstrapContext,
 		hooks: CompilationHooksJavascriptModulesPlugin
-	): {
-		header: string[];
-		beforeStartup: string[];
-		startup: string[];
-		afterStartup: string[];
-		allowInlineStartup: boolean;
-	};
+	): Bootstrap;
 	renderRequire(
 		renderContext: RenderBootstrapContext,
 		hooks: CompilationHooksJavascriptModulesPlugin
@@ -5563,7 +5622,10 @@ declare class JavascriptModulesPlugin {
 	static getCompilationHooks(
 		compilation: Compilation
 	): CompilationHooksJavascriptModulesPlugin;
-	static getChunkFilenameTemplate(chunk?: any, outputOptions?: any): any;
+	static getChunkFilenameTemplate(
+		chunk: Chunk,
+		outputOptions: Output
+	): TemplatePath;
 	static chunkHasJs: (chunk: Chunk, chunkGraph: ChunkGraph) => boolean;
 }
 declare class JavascriptParser extends Parser {
@@ -5576,7 +5638,39 @@ declare class JavascriptParser extends Parser {
 			>
 		>;
 		evaluate: HookMap<
-			SyncBailHook<[Expression], undefined | null | BasicEvaluatedExpression>
+			SyncBailHook<
+				[
+					| UnaryExpression
+					| ArrayExpression
+					| ArrowFunctionExpression
+					| AssignmentExpression
+					| AwaitExpression
+					| BinaryExpression
+					| SimpleCallExpression
+					| NewExpression
+					| ChainExpression
+					| ClassExpression
+					| ConditionalExpression
+					| FunctionExpression
+					| Identifier
+					| ImportExpression
+					| SimpleLiteral
+					| RegExpLiteral
+					| BigIntLiteral
+					| LogicalExpression
+					| MemberExpression
+					| MetaProperty
+					| ObjectExpression
+					| SequenceExpression
+					| TaggedTemplateExpression
+					| TemplateLiteral
+					| ThisExpression
+					| UpdateExpression
+					| YieldExpression
+					| SpreadElement
+				],
+				undefined | null | BasicEvaluatedExpression
+			>
 		>;
 		evaluateIdentifier: HookMap<
 			SyncBailHook<
@@ -6412,7 +6506,37 @@ declare class JavascriptParser extends Parser {
 	enterArrayPattern(pattern: ArrayPattern, onIdent?: any): void;
 	enterRestElement(pattern: RestElement, onIdent?: any): void;
 	enterAssignmentPattern(pattern: AssignmentPattern, onIdent?: any): void;
-	evaluateExpression(expression?: any): BasicEvaluatedExpression;
+	evaluateExpression(
+		expression:
+			| UnaryExpression
+			| ArrayExpression
+			| ArrowFunctionExpression
+			| AssignmentExpression
+			| AwaitExpression
+			| BinaryExpression
+			| SimpleCallExpression
+			| NewExpression
+			| ChainExpression
+			| ClassExpression
+			| ConditionalExpression
+			| FunctionExpression
+			| Identifier
+			| ImportExpression
+			| SimpleLiteral
+			| RegExpLiteral
+			| BigIntLiteral
+			| LogicalExpression
+			| MemberExpression
+			| MetaProperty
+			| ObjectExpression
+			| SequenceExpression
+			| TaggedTemplateExpression
+			| TemplateLiteral
+			| ThisExpression
+			| UpdateExpression
+			| YieldExpression
+			| SpreadElement
+	): BasicEvaluatedExpression;
 	parseString(expression: Expression): string;
 	parseCalculatedString(expression: Expression): any;
 	evaluate(source: string): BasicEvaluatedExpression;
@@ -6455,6 +6579,7 @@ declare class JavascriptParser extends Parser {
 	): boolean;
 	getComments(range: [number, number]): Comment[];
 	isAsiPosition(pos: number): boolean;
+	setAsiPosition(pos: number): void;
 	unsetAsiPosition(pos: number): void;
 	isStatementLevelExpression(expr: Expression): boolean;
 	getTagData(name: string, tag?: any): any;
@@ -6627,6 +6752,11 @@ declare interface JavascriptParserOptions {
 	 */
 	node?: false | NodeOptions;
 
+	/**
+	 * Override the module to strict or non-strict. This may affect the behavior of the module (some behaviors differ between strict and non-strict), so please configure this option carefully.
+	 */
+	overrideStrict?: "strict" | "non-strict";
+
 	/**
 	 * Specifies the behavior of invalid export names in "export ... from ...". This might be useful to disable during the migration from "export ... from ..." to "export type ... from ..." when reexporting types in TypeScript.
 	 */
@@ -6855,7 +6985,7 @@ declare interface KnownBuildInfo {
 	contextDependencies?: LazySet<string>;
 	missingDependencies?: LazySet<string>;
 	buildDependencies?: LazySet<string>;
-	valueDependencies?: Map<string, string | Set<string>>;
+	valueDependencies?: Map<string, ValueCacheVersion>;
 	hash?: any;
 	assets?: Record<string, Source>;
 	assetsInfo?: Map<string, undefined | AssetInfo>;
@@ -6960,14 +7090,14 @@ declare interface KnownStatsChunk {
 	recorded: boolean;
 	reason?: string;
 	size: number;
-	sizes?: Record<string, number>;
-	names?: string[];
-	idHints?: string[];
+	sizes: Record<string, number>;
+	names: string[];
+	idHints: string[];
 	runtime?: string[];
-	files?: string[];
-	auxiliaryFiles?: string[];
+	files: string[];
+	auxiliaryFiles: string[];
 	hash: string;
-	childrenByOrder?: Record<string, (string | number)[]>;
+	childrenByOrder: Record<string, (string | number)[]>;
 	id?: string | number;
 	siblings?: (string | number)[];
 	parents?: (string | number)[];
@@ -6990,11 +7120,11 @@ declare interface KnownStatsChunkGroup {
 	isOverSizeLimit?: boolean;
 }
 declare interface KnownStatsChunkOrigin {
-	module?: string;
-	moduleIdentifier?: string;
-	moduleName?: string;
-	loc?: string;
-	request?: string;
+	module: string;
+	moduleIdentifier: string;
+	moduleName: string;
+	loc: string;
+	request: string;
 	moduleId?: string | number;
 }
 declare interface KnownStatsCompilation {
@@ -7039,14 +7169,14 @@ declare interface KnownStatsError {
 }
 declare interface KnownStatsFactoryContext {
 	type: string;
-	makePathsRelative?: (arg0: string) => string;
-	compilation?: Compilation;
-	rootModules?: Set<Module>;
-	compilationFileToChunks?: Map<string, Chunk[]>;
-	compilationAuxiliaryFileToChunks?: Map<string, Chunk[]>;
-	runtime?: RuntimeSpec;
-	cachedGetErrors?: (arg0: Compilation) => WebpackError[];
-	cachedGetWarnings?: (arg0: Compilation) => WebpackError[];
+	makePathsRelative: (arg0: string) => string;
+	compilation: Compilation;
+	rootModules: Set<Module>;
+	compilationFileToChunks: Map<string, Chunk[]>;
+	compilationAuxiliaryFileToChunks: Map<string, Chunk[]>;
+	runtime: RuntimeSpec;
+	cachedGetErrors: (arg0: Compilation) => WebpackError[];
+	cachedGetWarnings: (arg0: Compilation) => WebpackError[];
 }
 declare interface KnownStatsLogging {
 	entries: StatsLoggingEntry[];
@@ -7055,7 +7185,7 @@ declare interface KnownStatsLogging {
 }
 declare interface KnownStatsLoggingEntry {
 	type: string;
-	message: string;
+	message?: string;
 	trace?: string[];
 	children?: StatsLoggingEntry[];
 	args?: any[];
@@ -7064,10 +7194,10 @@ declare interface KnownStatsLoggingEntry {
 declare interface KnownStatsModule {
 	type?: string;
 	moduleType?: string;
-	layer?: string;
+	layer?: null | string;
 	identifier?: string;
 	name?: string;
-	nameForCondition?: string;
+	nameForCondition?: null | string;
 	index?: number;
 	preOrderIndex?: number;
 	index2?: number;
@@ -7082,45 +7212,45 @@ declare interface KnownStatsModule {
 	optional?: boolean;
 	orphan?: boolean;
 	id?: string | number;
-	issuerId?: string | number;
+	issuerId?: null | string | number;
 	chunks?: (string | number)[];
 	assets?: (string | number)[];
 	dependent?: boolean;
-	issuer?: string;
-	issuerName?: string;
+	issuer?: null | string;
+	issuerName?: null | string;
 	issuerPath?: StatsModuleIssuer[];
 	failed?: boolean;
 	errors?: number;
 	warnings?: number;
 	profile?: StatsProfile;
 	reasons?: StatsModuleReason[];
-	usedExports?: boolean | string[];
-	providedExports?: string[];
+	usedExports?: null | boolean | string[];
+	providedExports?: null | string[];
 	optimizationBailout?: string[];
-	depth?: number;
+	depth?: null | number;
 	modules?: StatsModule[];
 	filteredModules?: number;
 	source?: string | Buffer;
 }
 declare interface KnownStatsModuleIssuer {
-	identifier?: string;
-	name?: string;
+	identifier: string;
+	name: string;
 	id?: string | number;
-	profile?: StatsProfile;
+	profile: StatsProfile;
 }
 declare interface KnownStatsModuleReason {
-	moduleIdentifier?: string;
-	module?: string;
-	moduleName?: string;
-	resolvedModuleIdentifier?: string;
-	resolvedModule?: string;
-	type?: string;
+	moduleIdentifier: null | string;
+	module: null | string;
+	moduleName: null | string;
+	resolvedModuleIdentifier: null | string;
+	resolvedModule: null | string;
+	type: null | string;
 	active: boolean;
-	explanation?: string;
-	userRequest?: string;
-	loc?: string;
-	moduleId?: string | number;
-	resolvedModuleId?: string | number;
+	explanation: null | string;
+	userRequest: null | string;
+	loc?: null | string;
+	moduleId?: null | string | number;
+	resolvedModuleId?: null | string | number;
 }
 declare interface KnownStatsModuleTraceDependency {
 	loc?: string;
@@ -7134,20 +7264,31 @@ declare interface KnownStatsModuleTraceItem {
 	originId?: string | number;
 	moduleId?: string | number;
 }
+declare interface KnownStatsPrinterColorFn {
+	bold?: (str: string) => string;
+	yellow?: (str: string) => string;
+	red?: (str: string) => string;
+	green?: (str: string) => string;
+	magenta?: (str: string) => string;
+	cyan?: (str: string) => string;
+}
 declare interface KnownStatsPrinterContext {
 	type?: string;
 	compilation?: StatsCompilation;
 	chunkGroup?: StatsChunkGroup;
+	chunkGroupKind?: string;
 	asset?: StatsAsset;
 	module?: StatsModule;
 	chunk?: StatsChunk;
 	moduleReason?: StatsModuleReason;
-	bold?: (str: string) => string;
-	yellow?: (str: string) => string;
-	red?: (str: string) => string;
-	green?: (str: string) => string;
-	magenta?: (str: string) => string;
-	cyan?: (str: string) => string;
+	moduleIssuer?: StatsModuleIssuer;
+	error?: StatsError;
+	profile?: StatsProfile;
+	logging?: StatsLogging;
+	moduleTraceItem?: StatsModuleTraceItem;
+	moduleTraceDependency?: StatsModuleTraceDependency;
+}
+declare interface KnownStatsPrinterFormaters {
 	formatFilename?: (file: string, oversize?: boolean) => string;
 	formatModuleId?: (id: string) => string;
 	formatChunkId?: (
@@ -7155,10 +7296,11 @@ declare interface KnownStatsPrinterContext {
 		direction?: "parent" | "child" | "sibling"
 	) => string;
 	formatSize?: (size: number) => string;
+	formatLayer?: (size: string) => string;
 	formatDateTime?: (dateTime: number) => string;
 	formatFlag?: (flag: string) => string;
 	formatTime?: (time: number, boldQuantity?: boolean) => string;
-	chunkGroupKind?: string;
+	formatError?: (message: string) => string;
 }
 declare interface KnownStatsProfile {
 	total: number;
@@ -7535,8 +7677,13 @@ declare class LoadScriptRuntimeModule extends HelperRuntimeModule {
 declare interface Loader {
 	[index: string]: any;
 }
-type LoaderContext<OptionsType> = NormalModuleLoaderContext<OptionsType> &
-	LoaderRunnerLoaderContext<OptionsType> &
+type LoaderContextDeclarationsIndex<OptionsType> =
+	NormalModuleLoaderContext<OptionsType> &
+		LoaderRunnerLoaderContext<OptionsType> &
+		LoaderPluginLoaderContext &
+		HotModuleReplacementPluginLoaderContext;
+type LoaderContextNormalModule<T> = NormalModuleLoaderContext<T> &
+	LoaderRunnerLoaderContext<T> &
 	LoaderPluginLoaderContext &
 	HotModuleReplacementPluginLoaderContext;
 type LoaderDefinition<
@@ -7622,14 +7769,14 @@ declare interface LoaderPluginLoaderContext {
 		request: string,
 		callback: (
 			err: null | Error,
-			source: string,
-			sourceMap: any,
-			module: NormalModule
+			source?: string | Buffer,
+			sourceMap?: null | object,
+			module?: Module
 		) => void
 	): void;
 	importModule(
 		request: string,
-		options: ImportModuleOptions,
+		options: undefined | ImportModuleOptions,
 		callback: (err?: null | Error, exports?: any) => any
 	): void;
 	importModule(request: string, options?: ImportModuleOptions): Promise<any>;
@@ -7790,7 +7937,7 @@ declare class LoaderTargetPlugin {
 }
 declare interface LogEntry {
 	type: string;
-	args: any[];
+	args?: any[];
 	time: number;
 	trace?: string[];
 }
@@ -7850,25 +7997,81 @@ declare interface MainRenderContext {
 	/**
 	 * rendering in strict context
 	 */
-	strictMode: boolean;
+	strictMode?: boolean;
 }
 declare abstract class MainTemplate {
 	hooks: Readonly<{
-		renderManifest: { tap: (options?: any, fn?: any) => void };
+		renderManifest: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (
+					arg0: RenderManifestEntry[],
+					arg1: RenderManifestOptions
+				) => RenderManifestEntry[]
+			) => void;
+		};
 		modules: { tap: () => never };
 		moduleObj: { tap: () => never };
-		require: { tap: (options?: any, fn?: any) => void };
+		require: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: string, arg1: RenderBootstrapContext) => string
+			) => void;
+		};
 		beforeStartup: { tap: () => never };
 		startup: { tap: () => never };
 		afterStartup: { tap: () => never };
-		render: { tap: (options?: any, fn?: any) => void };
-		renderWithEntry: { tap: (options?: any, fn?: any) => void };
+		render: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (
+					arg0: Source,
+					arg1: Chunk,
+					arg2: undefined | string,
+					arg3: ModuleTemplate,
+					arg4: DependencyTemplates
+				) => Source
+			) => void;
+		};
+		renderWithEntry: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: Source, arg1: Chunk, arg2?: string) => Source
+			) => void;
+		};
 		assetPath: {
-			tap: (options?: any, fn?: any) => void;
-			call: (filename?: any, options?: any) => string;
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: string, arg1: object, arg2?: AssetInfo) => string
+			) => void;
+			call: (filename: TemplatePath, options: PathData) => string;
+		};
+		hash: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: Hash) => void
+			) => void;
+		};
+		hashForChunk: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: Hash, arg1: Chunk) => void
+			) => void;
 		};
-		hash: { tap: (options?: any, fn?: any) => void };
-		hashForChunk: { tap: (options?: any, fn?: any) => void };
 		globalHashPaths: { tap: () => void };
 		globalHash: { tap: () => void };
 		hotBootstrap: { tap: () => never };
@@ -7883,12 +8086,12 @@ declare abstract class MainTemplate {
 		get linkPreload(): SyncWaterfallHook<[string, Chunk]>;
 	}>;
 	renderCurrentHashCode: (hash: string, length?: number) => string;
-	getPublicPath: (options: object) => string;
-	getAssetPath: (path?: any, options?: any) => string;
+	getPublicPath: (options: PathData) => string;
+	getAssetPath: (path: TemplatePath, options: PathData) => string;
 	getAssetPathWithInfo: (
-		path?: any,
-		options?: any
-	) => { path: string; info: AssetInfo };
+		path: TemplatePath,
+		options: PathData
+	) => InterpolatedPathAndAssetInfo;
 	get requireFn(): "__webpack_require__";
 	get outputOptions(): Output;
 }
@@ -8018,7 +8221,7 @@ declare class Module extends DependenciesBlock {
 	buildInfo?: BuildInfo;
 	presentationalDependencies?: Dependency[];
 	codeGenerationDependencies?: Dependency[];
-	id: ModuleId;
+	id: null | string | number;
 	get hash(): string;
 	get renderedHash(): string;
 	profile?: ModuleProfile;
@@ -8142,8 +8345,7 @@ declare class Module extends DependenciesBlock {
 	used: any;
 }
 declare class ModuleConcatenationPlugin {
-	constructor(options?: any);
-	options: any;
+	constructor();
 
 	/**
 	 * Apply the plugin
@@ -8244,6 +8446,7 @@ declare interface ModuleFederationPluginOptions {
 		| "jsonp"
 		| "system"
 		| "promise"
+		| "module-import"
 		| "script"
 		| "node-commonjs";
 
@@ -8409,11 +8612,11 @@ declare class ModuleGraphConnection {
 	): void;
 	addExplanation(explanation: string): void;
 	get explanation(): string;
-	active: void;
 	isActive(runtime: RuntimeSpec): boolean;
 	isTargetActive(runtime: RuntimeSpec): boolean;
 	getActiveState(runtime: RuntimeSpec): ConnectionState;
 	setActive(value: boolean): void;
+	active: void;
 	static addConnectionStates: (
 		a: ConnectionState,
 		b: ConnectionState
@@ -8626,6 +8829,11 @@ declare interface ModuleReferenceOptions {
 	 */
 	asiSafe?: boolean;
 }
+declare interface ModuleResult {
+	client: string;
+	data: string;
+	active: boolean;
+}
 declare interface ModuleSettings {
 	/**
 	 * Specifies the layer in which the module should be placed in.
@@ -8660,13 +8868,68 @@ declare interface ModuleSettings {
 declare abstract class ModuleTemplate {
 	type: string;
 	hooks: Readonly<{
-		content: { tap: (options?: any, fn?: any) => void };
-		module: { tap: (options?: any, fn?: any) => void };
-		render: { tap: (options?: any, fn?: any) => void };
-		package: { tap: (options?: any, fn?: any) => void };
-		hash: { tap: (options?: any, fn?: any) => void };
+		content: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (
+					arg0: Source,
+					arg1: Module,
+					arg2: ChunkRenderContext,
+					arg3: DependencyTemplates
+				) => Source
+			) => void;
+		};
+		module: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (
+					arg0: Source,
+					arg1: Module,
+					arg2: ChunkRenderContext,
+					arg3: DependencyTemplates
+				) => Source
+			) => void;
+		};
+		render: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (
+					arg0: Source,
+					arg1: Module,
+					arg2: ChunkRenderContext,
+					arg3: DependencyTemplates
+				) => Source
+			) => void;
+		};
+		package: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (
+					arg0: Source,
+					arg1: Module,
+					arg2: ChunkRenderContext,
+					arg3: DependencyTemplates
+				) => Source
+			) => void;
+		};
+		hash: {
+			tap: <AdditionalOptions>(
+				options:
+					| string
+					| (TapOptions & { name: string } & IfSet<AdditionalOptions>),
+				fn: (arg0: Hash) => void
+			) => void;
+		};
 	}>;
-	get runtimeTemplate(): any;
+	get runtimeTemplate(): RuntimeTemplate;
 }
 declare interface ModuleTemplates {
 	javascript: ModuleTemplate;
@@ -8720,8 +8983,8 @@ declare abstract class MultiStats {
 	get hash(): string;
 	hasErrors(): boolean;
 	hasWarnings(): boolean;
-	toJson(options?: any): StatsCompilation;
-	toString(options?: any): string;
+	toJson(options?: string | boolean | StatsOptions): StatsCompilation;
+	toString(options?: string | boolean | StatsOptions): string;
 }
 declare abstract class MultiWatching {
 	watchings: Watching[];
@@ -8892,7 +9155,7 @@ declare class NormalModule extends Module {
 	createSource(
 		context: string,
 		content: string | Buffer,
-		sourceMap?: string | SourceMapSource,
+		sourceMap?: null | string | SourceMapSource,
 		associatedObjectForCache?: object
 	): Source;
 	markModuleAsErrored(error: WebpackError): void;
@@ -8904,14 +9167,23 @@ declare class NormalModule extends Module {
 	static deserialize(context?: any): NormalModule;
 }
 declare interface NormalModuleCompilationHooks {
-	loader: SyncHook<[object, NormalModule]>;
-	beforeLoaders: SyncHook<[LoaderItem[], NormalModule, object]>;
+	loader: SyncHook<[LoaderContextNormalModule<any>, NormalModule]>;
+	beforeLoaders: SyncHook<
+		[LoaderItem[], NormalModule, LoaderContextNormalModule<any>]
+	>;
 	beforeParse: SyncHook<[NormalModule]>;
 	beforeSnapshot: SyncHook<[NormalModule]>;
 	readResourceForScheme: HookMap<
-		AsyncSeriesBailHook<[string, NormalModule], string | Buffer>
+		FakeHook<
+			AsyncSeriesBailHook<[string, NormalModule], null | string | Buffer>
+		>
+	>;
+	readResource: HookMap<
+		AsyncSeriesBailHook<
+			[LoaderContextNormalModule<any>],
+			null | string | Buffer
+		>
 	>;
-	readResource: HookMap<AsyncSeriesBailHook<[object], string | Buffer>>;
 	needBuild: AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>;
 }
 declare interface NormalModuleCreateData {
@@ -9207,6 +9479,9 @@ declare interface ObjectEncodingOptions {
 		| "base64url"
 		| "hex";
 }
+declare interface ObjectForExtract {
+	[index: string]: any;
+}
 declare interface ObjectSerializer {
 	serialize: (arg0: any, arg1: ObjectSerializerContext) => void;
 	deserialize: (arg0: ObjectDeserializerContext) => any;
@@ -9659,11 +9934,47 @@ declare interface OptimizationSplitChunksOptions {
 	 */
 	usedExports?: boolean;
 }
+declare interface Options {
+	/**
+	 * source
+	 */
+	source: string;
+
+	/**
+	 * absolute context path to which lib ident is relative to
+	 */
+	context: string;
+
+	/**
+	 * content
+	 */
+	content: DllReferencePluginOptionsContent;
+
+	/**
+	 * type
+	 */
+	type?: "object" | "require";
+
+	/**
+	 * extensions
+	 */
+	extensions?: string[];
+
+	/**
+	 * scope
+	 */
+	scope?: string;
+
+	/**
+	 * object for caching
+	 */
+	associatedObjectForCache?: object;
+}
 declare abstract class OptionsApply {
 	process(options?: any, compiler?: any): void;
 }
 declare interface OriginRecord {
-	module: Module;
+	module: null | Module;
 	loc: DependencyLocation;
 	request: string;
 }
@@ -11395,7 +11706,7 @@ declare interface RenderContext {
 	/**
 	 * rendering in strict context
 	 */
-	strictMode: boolean;
+	strictMode?: boolean;
 }
 type RenderManifestEntry =
 	| RenderManifestEntryTemplated
@@ -11410,7 +11721,7 @@ declare interface RenderManifestEntryStatic {
 }
 declare interface RenderManifestEntryTemplated {
 	render: () => Source;
-	filenameTemplate: string | ((arg0: PathData, arg1?: AssetInfo) => string);
+	filenameTemplate: TemplatePath;
 	pathOptions?: PathData;
 	info?: AssetInfo;
 	identifier: string;
@@ -11472,7 +11783,7 @@ declare interface ResolveBuildDependenciesResult {
 	/**
 	 * stored resolve results
 	 */
-	resolveResults: Map<string, string | false>;
+	resolveResults: Map<string, undefined | string | false>;
 
 	/**
 	 * dependencies of the resolving
@@ -12025,6 +12336,13 @@ declare interface ResourceDataWithData {
 	context?: string;
 	data: Record<string, any>;
 }
+declare abstract class RestoreProvidedData {
+	exports: any;
+	otherProvided: any;
+	otherCanMangleProvide: any;
+	otherTerminalBinding: any;
+	serialize(__0: ObjectSerializerContext): void;
+}
 declare interface RmDirOptions {
 	maxRetries?: number;
 	recursive?: boolean;
@@ -12051,7 +12369,7 @@ declare interface RuleSet {
 	/**
 	 * execute the rule set
 	 */
-	exec: (arg0: object) => Effect[];
+	exec: (arg0: EffectData) => Effect[];
 }
 type RuleSetCondition =
 	| string
@@ -12972,13 +13290,13 @@ declare abstract class RuntimeValue {
 	fn: (arg0: {
 		module: NormalModule;
 		key: string;
-		readonly version?: string;
+		readonly version: ValueCacheVersion;
 	}) => CodeValuePrimitive;
 	options: true | RuntimeValueOptions;
 	get fileDependencies(): true | string[];
 	exec(
 		parser: JavascriptParser,
-		valueCacheVersions: Map<string, string | Set<string>>,
+		valueCacheVersions: Map<string, ValueCacheVersion>,
 		key: string
 	): CodeValuePrimitive;
 	getCacheVersion(): undefined | string;
@@ -13123,6 +13441,7 @@ declare class SideEffectsFlagPlugin {
 		cache: Map<string, RegExp>
 	): undefined | boolean;
 }
+type SimpleType = "string" | "number" | "boolean";
 declare class SizeOnlySource extends Source {
 	constructor(size: number);
 }
@@ -13142,32 +13461,36 @@ declare abstract class Snapshot {
 	children?: Set<Snapshot>;
 	hasStartTime(): boolean;
 	setStartTime(value: number): void;
-	setMergedStartTime(value?: any, snapshot?: any): void;
+	setMergedStartTime(value: undefined | number, snapshot: Snapshot): void;
 	hasFileTimestamps(): boolean;
-	setFileTimestamps(value?: any): void;
+	setFileTimestamps(value: Map<string, null | FileSystemInfoEntry>): void;
 	hasFileHashes(): boolean;
-	setFileHashes(value?: any): void;
+	setFileHashes(value: Map<string, null | string>): void;
 	hasFileTshs(): boolean;
-	setFileTshs(value?: any): void;
+	setFileTshs(value: Map<string, null | string | TimestampAndHash>): void;
 	hasContextTimestamps(): boolean;
-	setContextTimestamps(value?: any): void;
+	setContextTimestamps(
+		value: Map<string, null | ResolvedContextFileSystemInfoEntry>
+	): void;
 	hasContextHashes(): boolean;
-	setContextHashes(value?: any): void;
+	setContextHashes(value: Map<string, null | string>): void;
 	hasContextTshs(): boolean;
-	setContextTshs(value?: any): void;
+	setContextTshs(
+		value: Map<string, null | ResolvedContextTimestampAndHash>
+	): void;
 	hasMissingExistence(): boolean;
-	setMissingExistence(value?: any): void;
+	setMissingExistence(value: Map<string, boolean>): void;
 	hasManagedItemInfo(): boolean;
-	setManagedItemInfo(value?: any): void;
+	setManagedItemInfo(value: Map<string, string>): void;
 	hasManagedFiles(): boolean;
-	setManagedFiles(value?: any): void;
+	setManagedFiles(value: Set<string>): void;
 	hasManagedContexts(): boolean;
-	setManagedContexts(value?: any): void;
+	setManagedContexts(value: Set<string>): void;
 	hasManagedMissing(): boolean;
-	setManagedMissing(value?: any): void;
+	setManagedMissing(value: Set<string>): void;
 	hasChildren(): boolean;
-	setChildren(value?: any): void;
-	addChild(child?: any): void;
+	setChildren(value: Set<Snapshot>): void;
+	addChild(child: Snapshot): void;
 	serialize(__0: ObjectSerializerContext): void;
 	deserialize(__0: ObjectDeserializerContext): void;
 	getFileIterable(): Iterable<string>;
@@ -13261,11 +13584,14 @@ declare interface SnapshotOptionsWebpackOptions {
 	 */
 	unmanagedPaths?: (string | RegExp)[];
 }
+declare interface SortFunction<T> {
+	(arg0: T, arg1: T): number;
+}
 declare abstract class SortableSet<T> extends Set<T> {
 	/**
 	 * Sort with a comparer function
 	 */
-	sortWith(sortFn: (arg0: T, arg1: T) => number): void;
+	sortWith(sortFn?: SortFunction<T>): void;
 	sort(): SortableSet<T>;
 
 	/**
@@ -13432,7 +13758,7 @@ declare interface SplitChunksOptions {
 	maxAsyncRequests: number;
 	maxInitialRequests: number;
 	hidePathInfo: boolean;
-	filename: string | ((arg0: PathData, arg1?: AssetInfo) => string);
+	filename: TemplatePath;
 	automaticNameDelimiter: string;
 	getCacheGroups: (
 		module: Module,
@@ -13637,59 +13963,73 @@ declare class Stats {
 	toJson(options?: string | boolean | StatsOptions): StatsCompilation;
 	toString(options?: string | boolean | StatsOptions): string;
 }
-type StatsAsset = KnownStatsAsset & Record<string, any>;
-type StatsChunk = KnownStatsChunk & Record<string, any>;
-type StatsChunkGroup = KnownStatsChunkGroup & Record<string, any>;
-type StatsChunkOrigin = KnownStatsChunkOrigin & Record<string, any>;
-type StatsCompilation = KnownStatsCompilation & Record<string, any>;
-type StatsError = KnownStatsError & Record<string, any>;
+type StatsAsset = Record<string, any> & KnownStatsAsset;
+type StatsChunk = Record<string, any> & KnownStatsChunk;
+type StatsChunkGroup = Record<string, any> & KnownStatsChunkGroup;
+type StatsChunkOrigin = Record<string, any> & KnownStatsChunkOrigin;
+type StatsCompilation = Record<string, any> & KnownStatsCompilation;
+type StatsError = Record<string, any> & KnownStatsError;
 declare abstract class StatsFactory {
-	hooks: Readonly<{
-		extract: HookMap<SyncBailHook<[object, any, StatsFactoryContext], any>>;
-		filter: HookMap<
-			SyncBailHook<[any, StatsFactoryContext, number, number], any>
-		>;
-		sort: HookMap<
-			SyncBailHook<
-				[((arg0?: any, arg1?: any) => number)[], StatsFactoryContext],
-				any
-			>
-		>;
-		filterSorted: HookMap<
-			SyncBailHook<[any, StatsFactoryContext, number, number], any>
-		>;
-		groupResults: HookMap<
-			SyncBailHook<[GroupConfig[], StatsFactoryContext], any>
-		>;
-		sortResults: HookMap<
-			SyncBailHook<
-				[((arg0?: any, arg1?: any) => number)[], StatsFactoryContext],
-				any
-			>
-		>;
-		filterResults: HookMap<
-			SyncBailHook<[any, StatsFactoryContext, number, number], any>
-		>;
-		merge: HookMap<SyncBailHook<[any[], StatsFactoryContext], any>>;
-		result: HookMap<SyncBailHook<[any[], StatsFactoryContext], any>>;
-		getItemName: HookMap<SyncBailHook<[any, StatsFactoryContext], any>>;
-		getItemFactory: HookMap<SyncBailHook<[any, StatsFactoryContext], any>>;
-	}>;
+	hooks: StatsFactoryHooks;
 	create(
 		type: string,
 		data: any,
 		baseContext: Omit<StatsFactoryContext, "type">
 	): any;
 }
-type StatsFactoryContext = KnownStatsFactoryContext & Record<string, any>;
-type StatsLogging = KnownStatsLogging & Record<string, any>;
-type StatsLoggingEntry = KnownStatsLoggingEntry & Record<string, any>;
-type StatsModule = KnownStatsModule & Record<string, any>;
-type StatsModuleIssuer = KnownStatsModuleIssuer & Record<string, any>;
-type StatsModuleReason = KnownStatsModuleReason & Record<string, any>;
-type StatsModuleTraceDependency = KnownStatsModuleTraceDependency &
-	Record<string, any>;
-type StatsModuleTraceItem = KnownStatsModuleTraceItem & Record<string, any>;
+type StatsFactoryContext = Record<string, any> & KnownStatsFactoryContext;
+declare interface StatsFactoryHooks {
+	extract: HookMap<
+		SyncBailHook<[ObjectForExtract, any, StatsFactoryContext], undefined>
+	>;
+	filter: HookMap<
+		SyncBailHook<
+			[any, StatsFactoryContext, number, number],
+			undefined | boolean
+		>
+	>;
+	sort: HookMap<
+		SyncBailHook<
+			[((arg0?: any, arg1?: any) => 0 | 1 | -1)[], StatsFactoryContext],
+			undefined
+		>
+	>;
+	filterSorted: HookMap<
+		SyncBailHook<
+			[any, StatsFactoryContext, number, number],
+			undefined | boolean
+		>
+	>;
+	groupResults: HookMap<
+		SyncBailHook<[GroupConfig[], StatsFactoryContext], undefined>
+	>;
+	sortResults: HookMap<
+		SyncBailHook<
+			[((arg0?: any, arg1?: any) => 0 | 1 | -1)[], StatsFactoryContext],
+			undefined
+		>
+	>;
+	filterResults: HookMap<
+		SyncBailHook<
+			[any, StatsFactoryContext, number, number],
+			undefined | boolean
+		>
+	>;
+	merge: HookMap<SyncBailHook<[any[], StatsFactoryContext], any>>;
+	result: HookMap<SyncBailHook<[any, StatsFactoryContext], any>>;
+	getItemName: HookMap<SyncBailHook<[any, StatsFactoryContext], string>>;
+	getItemFactory: HookMap<
+		SyncBailHook<[any, StatsFactoryContext], undefined | StatsFactory>
+	>;
+}
+type StatsLogging = Record<string, any> & KnownStatsLogging;
+type StatsLoggingEntry = Record<string, any> & KnownStatsLoggingEntry;
+type StatsModule = Record<string, any> & KnownStatsModule;
+type StatsModuleIssuer = Record<string, any> & KnownStatsModuleIssuer;
+type StatsModuleReason = Record<string, any> & KnownStatsModuleReason;
+type StatsModuleTraceDependency = Record<string, any> &
+	KnownStatsModuleTraceDependency;
+type StatsModuleTraceItem = Record<string, any> & KnownStatsModuleTraceItem;
 
 /**
  * Stats options object.
@@ -14138,22 +14478,28 @@ declare interface StatsOptions {
 	 */
 	warningsSpace?: number;
 }
-declare abstract class StatsPrinter {
-	hooks: Readonly<{
-		sortElements: HookMap<SyncBailHook<[string[], StatsPrinterContext], true>>;
-		printElements: HookMap<
-			SyncBailHook<[PrintedElement[], StatsPrinterContext], string>
-		>;
-		sortItems: HookMap<SyncBailHook<[any[], StatsPrinterContext], true>>;
-		getItemName: HookMap<SyncBailHook<[any, StatsPrinterContext], string>>;
-		printItems: HookMap<SyncBailHook<[string[], StatsPrinterContext], string>>;
-		print: HookMap<SyncBailHook<[{}, StatsPrinterContext], string>>;
-		result: HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>;
-	}>;
-	print(type: string, object: object, baseContext?: object): string;
+declare interface StatsPrintHooks {
+	sortElements: HookMap<SyncBailHook<[string[], StatsPrinterContext], void>>;
+	printElements: HookMap<
+		SyncBailHook<[PrintedElement[], StatsPrinterContext], undefined | string>
+	>;
+	sortItems: HookMap<SyncBailHook<[any[], StatsPrinterContext], true>>;
+	getItemName: HookMap<SyncBailHook<[any, StatsPrinterContext], string>>;
+	printItems: HookMap<
+		SyncBailHook<[string[], StatsPrinterContext], undefined | string>
+	>;
+	print: HookMap<SyncBailHook<[any, StatsPrinterContext], string | void>>;
+	result: HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>;
 }
-type StatsPrinterContext = KnownStatsPrinterContext & Record<string, any>;
-type StatsProfile = KnownStatsProfile & Record<string, any>;
+declare abstract class StatsPrinter {
+	hooks: StatsPrintHooks;
+	print(type: string, object?: any, baseContext?: StatsPrinterContext): string;
+}
+type StatsPrinterContext = Record<string, any> &
+	KnownStatsPrinterColorFn &
+	KnownStatsPrinterFormaters &
+	KnownStatsPrinterContext;
+type StatsProfile = Record<string, any> & KnownStatsProfile;
 type StatsValue =
 	| boolean
 	| StatsOptions
@@ -14182,7 +14528,7 @@ declare class SyncModuleIdsPlugin {
 		/**
 		 * operation mode (defaults to merge)
 		 */
-		mode?: "read" | "merge" | "create" | "update";
+		mode?: "read" | "create" | "merge" | "update";
 	});
 
 	/**
@@ -14208,6 +14554,15 @@ declare interface TagInfo {
 	data: any;
 	next?: TagInfo;
 }
+declare interface TargetItem {
+	module: Module;
+	connection: ModuleGraphConnection;
+	export?: string[];
+}
+declare interface TargetItemWithoutConnection {
+	module: Module;
+	export: string[];
+}
 declare class Template {
 	constructor();
 	static getFunctionContent(fn: Function): string;
@@ -14224,7 +14579,7 @@ declare class Template {
 	static renderChunkModules(
 		renderContext: ChunkRenderContext,
 		modules: Module[],
-		renderModule: (arg0: Module) => Source,
+		renderModule: (arg0: Module) => null | Source,
 		prefix?: string
 	): null | Source;
 	static renderRuntimeModules(
@@ -14240,6 +14595,7 @@ declare class Template {
 	static NUMBER_OF_IDENTIFIER_START_CHARS: number;
 	static NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS: number;
 }
+type TemplatePath = string | ((arg0: PathData, arg1?: AssetInfo) => string);
 declare interface TimestampAndHash {
 	safeTime: number;
 	timestamp?: number;
@@ -14290,6 +14646,9 @@ declare interface UpdateHashContextGenerator {
 	runtimeTemplate?: RuntimeTemplate;
 }
 type UsageStateType = 0 | 1 | 2 | 3 | 4;
+type UsedName = string | false | string[];
+type Value = string | number | boolean | RegExp;
+type ValueCacheVersion = undefined | string | Set<string>;
 declare abstract class VariableInfo {
 	declaredScope: ScopeInfo;
 	freeName?: string | true;
@@ -14313,10 +14672,10 @@ declare interface WatchFileSystem {
 		options: WatchOptions,
 		callback: (
 			arg0: null | Error,
-			arg1: Map<string, FileSystemInfoEntry | "ignore">,
-			arg2: Map<string, FileSystemInfoEntry | "ignore">,
-			arg3: Set<string>,
-			arg4: Set<string>
+			arg1?: Map<string, FileSystemInfoEntry | "ignore">,
+			arg2?: Map<string, FileSystemInfoEntry | "ignore">,
+			arg3?: Set<string>,
+			arg4?: Set<string>
 		) => void,
 		callbackUndelayed: (arg0: string, arg1: number) => void
 	) => Watcher;
@@ -14431,28 +14790,7 @@ declare abstract class Watching {
 	closed: boolean;
 	suspended: boolean;
 	blocked: boolean;
-	watchOptions: {
-		/**
-		 * Delay the rebuilt after the first change. Value is a time in ms.
-		 */
-		aggregateTimeout?: number;
-		/**
-		 * Resolve symlinks and watch symlink and real file. This is usually not needed as webpack already resolves symlinks ('resolve.symlinks').
-		 */
-		followSymlinks?: boolean;
-		/**
-		 * Ignore some files from watching (glob pattern or regexp).
-		 */
-		ignored?: string | RegExp | string[];
-		/**
-		 * Enable polling mode for watching.
-		 */
-		poll?: number | boolean;
-		/**
-		 * Stop watching when stdin stream has ended.
-		 */
-		stdin?: boolean;
-	};
+	watchOptions: WatchOptions;
 	compiler: Compiler;
 	running: boolean;
 	watcher?: null | Watcher;
@@ -14559,7 +14897,7 @@ declare abstract class WebpackLogger {
 	status(...args: any[]): void;
 	group(...args: any[]): void;
 	groupCollapsed(...args: any[]): void;
-	groupEnd(...args: any[]): void;
+	groupEnd(): void;
 	profile(label?: string): void;
 	profileEnd(label?: string): void;
 	time(label: string): void;
@@ -14658,6 +14996,7 @@ declare interface WebpackOptionsNormalized {
 		| "jsonp"
 		| "system"
 		| "promise"
+		| "module-import"
 		| "script"
 		| "node-commonjs";
 
@@ -14967,18 +15306,11 @@ declare namespace exports {
 	) => void;
 	export const version: string;
 	export namespace cli {
-		export let getArguments: (schema?: any) => Record<string, Argument>;
+		export let getArguments: (schema?: any) => Flags;
 		export let processArguments: (
-			args: Record<string, Argument>,
+			args: Flags,
 			config: any,
-			values: Record<
-				string,
-				| string
-				| number
-				| boolean
-				| RegExp
-				| (string | number | boolean | RegExp)[]
-			>
+			values: Record<string, Value[]>
 		) => null | Problem[];
 	}
 	export namespace ModuleFilenameHelpers {
@@ -15274,7 +15606,7 @@ declare namespace exports {
 		export { ProfilingPlugin };
 	}
 	export namespace util {
-		export const createHash: (algorithm: string | typeof Hash) => Hash;
+		export const createHash: (algorithm: Algorithm) => Hash;
 		export namespace comparators {
 			export let compareChunksById: (a: Chunk, b: Chunk) => 0 | 1 | -1;
 			export let compareModulesByIdentifier: (
@@ -15403,7 +15735,10 @@ declare namespace exports {
 			) => Serializer;
 			export { MEASURE_START_OPERATION, MEASURE_END_OPERATION };
 		}
-		export const cleverMerge: <T, O>(first: T, second: O) => T | O | (T & O);
+		export const cleverMerge: <T, O>(
+			first?: null | T,
+			second?: null | O
+		) => T | O | (T & O);
 		export function compileBooleanMatcher(
 			map: Record<string | number, boolean>
 		): boolean | ((arg0: string) => string);
@@ -15560,7 +15895,7 @@ declare namespace exports {
 		LoaderDefinitionFunction,
 		PitchLoaderDefinitionFunction,
 		RawLoaderDefinitionFunction,
-		LoaderContext
+		LoaderContextDeclarationsIndex as LoaderContext
 	};
 }
 declare const topLevelSymbolTag: unique symbol;