webpack 5.93.0 → 5.95.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;
@@ -400,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;
@@ -450,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);
@@ -576,6 +581,7 @@ declare abstract class BasicEvaluatedExpression {
 		| ThisExpression
 		| UpdateExpression
 		| YieldExpression
+		| SpreadElement
 		| FunctionDeclaration
 		| VariableDeclaration
 		| ClassDeclaration
@@ -613,7 +619,6 @@ declare abstract class BasicEvaluatedExpression {
 		| ArrayPattern
 		| RestElement
 		| AssignmentPattern
-		| SpreadElement
 		| Property
 		| AssignmentProperty
 		| ClassBody
@@ -799,6 +804,7 @@ declare abstract class BasicEvaluatedExpression {
 			| ThisExpression
 			| UpdateExpression
 			| YieldExpression
+			| SpreadElement
 			| FunctionDeclaration
 			| VariableDeclaration
 			| ClassDeclaration
@@ -836,7 +842,6 @@ declare abstract class BasicEvaluatedExpression {
 			| ArrayPattern
 			| RestElement
 			| AssignmentPattern
-			| SpreadElement
 			| Property
 			| AssignmentProperty
 			| ClassBody
@@ -848,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"
@@ -996,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;
@@ -1183,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;
@@ -1217,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;
@@ -1332,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;
@@ -1483,7 +1499,7 @@ declare interface ChunkRenderContext {
 	/**
 	 * rendering in strict context
 	 */
-	strictMode: boolean;
+	strictMode?: boolean;
 }
 declare interface ChunkSizeOptions {
 	/**
@@ -1498,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;
 }
@@ -1609,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)
@@ -1711,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[]],
@@ -1739,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]>;
@@ -1830,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;
@@ -1839,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;
@@ -1892,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;
@@ -1917,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;
 
 	/**
@@ -1935,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: {
@@ -1966,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;
@@ -2079,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[];
 
@@ -2114,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 },
@@ -2277,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]>;
@@ -2309,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;
@@ -2515,6 +2576,7 @@ declare interface Configuration {
 		| "jsonp"
 		| "system"
 		| "promise"
+		| "module-import"
 		| "script"
 		| "node-commonjs";
 
@@ -2768,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);
 
@@ -2834,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);
@@ -2871,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;
@@ -2884,7 +2948,7 @@ declare abstract class ContextModuleFactory extends ModuleFactory {
 		fs: InputFileSystem,
 		options: ContextModuleOptions,
 		callback: (
-			err?: null | Error,
+			err: null | Error,
 			dependencies?: ContextElementDependency[]
 		) => any
 	): void;
@@ -2919,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
@@ -2940,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;
@@ -3115,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
@@ -3619,6 +3683,9 @@ declare interface Effect {
 	type: string;
 	value: any;
 }
+declare interface EffectData {
+	[index: string]: any;
+}
 declare class ElectronTargetPlugin {
 	constructor(context?: "main" | "preload" | "renderer");
 
@@ -3859,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;
@@ -3982,9 +4048,9 @@ declare interface Environment {
 	templateLiteral?: boolean;
 }
 declare class EnvironmentPlugin {
-	constructor(...keys: any[]);
-	keys: any[];
-	defaultValues: any;
+	constructor(...keys: (string | string[] | Record<string, any>)[]);
+	keys: string[];
+	defaultValues: Record<string, any>;
 
 	/**
 	 * Apply the plugin
@@ -4190,7 +4256,7 @@ declare abstract class ExportInfo {
 	setTarget(
 		key: any,
 		connection: ModuleGraphConnection,
-		exportName?: string[],
+		exportName?: null | string[],
 		priority?: number
 	): boolean;
 	getUsed(runtime: RuntimeSpec): UsageStateType;
@@ -4210,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"
@@ -4330,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;
@@ -4357,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
@@ -4632,6 +4683,7 @@ type ExternalsType =
 	| "jsonp"
 	| "system"
 	| "promise"
+	| "module-import"
 	| "script"
 	| "node-commonjs";
 declare interface FSImplementation {
@@ -4809,16 +4861,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[];
@@ -4864,7 +4912,7 @@ declare abstract class FileSystemInfo {
 		path: string,
 		callback: (
 			arg0?: null | WebpackError,
-			arg1?: ResolvedContextTimestampAndHash
+			arg1?: null | ResolvedContextTimestampAndHash
 		) => void
 	): void;
 	resolveBuildDependencies(
@@ -4885,7 +4933,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(
@@ -4900,6 +4948,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
@@ -5040,16 +5091,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;
 
 	/**
@@ -5073,7 +5120,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;
 }
@@ -5157,6 +5204,7 @@ declare class Hash {
 	 */
 	digest(encoding?: string): string | Buffer;
 }
+type HashFunction = string | typeof Hash;
 declare interface HashableObject {
 	updateHash: (arg0: Hash) => void;
 }
@@ -5319,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;
 
@@ -5349,6 +5396,7 @@ type IgnorePluginOptions =
 type ImportAttributes = Record<string, string> & {};
 declare interface ImportDependencyMeta {
 	attributes?: ImportAttributes;
+	externalType?: "import" | "module";
 }
 declare interface ImportModuleOptions {
 	/**
@@ -5505,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>;
@@ -5529,7 +5584,7 @@ declare class JavascriptModulesPlugin {
 		renderContext: ChunkRenderContext,
 		hooks: CompilationHooksJavascriptModulesPlugin,
 		factory: boolean
-	): Source;
+	): null | Source;
 	renderChunk(
 		renderContext: RenderContext,
 		hooks: CompilationHooksJavascriptModulesPlugin
@@ -5547,24 +5602,20 @@ declare class JavascriptModulesPlugin {
 	renderBootstrap(
 		renderContext: RenderBootstrapContext,
 		hooks: CompilationHooksJavascriptModulesPlugin
-	): {
-		header: string[];
-		beforeStartup: string[];
-		startup: string[];
-		afterStartup: string[];
-		allowInlineStartup: boolean;
-	};
+	): Bootstrap;
 	renderRequire(
 		renderContext: RenderBootstrapContext,
 		hooks: CompilationHooksJavascriptModulesPlugin
 	): string;
-	renameInlineModule(
+	getRenamedInlineModule(
 		allModules: Module[],
 		renderContext: MainRenderContext,
 		inlinedModules: Set<Module>,
 		chunkRenderContext: ChunkRenderContext,
-		hooks: CompilationHooksJavascriptModulesPlugin
-	): Map<Module, Source>;
+		hooks: CompilationHooksJavascriptModulesPlugin,
+		allStrict: boolean,
+		hasChunkModules: boolean
+	): false | Map<Module, Source>;
 	findNewName(
 		oldName: string,
 		usedName: Set<string>,
@@ -5573,7 +5624,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 {
@@ -5586,7 +5640,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<
@@ -6422,7 +6508,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;
@@ -6465,6 +6581,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;
@@ -6870,7 +6987,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>;
@@ -6975,14 +7092,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)[];
@@ -7005,11 +7122,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 {
@@ -7054,14 +7171,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[];
@@ -7070,7 +7187,7 @@ declare interface KnownStatsLogging {
 }
 declare interface KnownStatsLoggingEntry {
 	type: string;
-	message: string;
+	message?: string;
 	trace?: string[];
 	children?: StatsLoggingEntry[];
 	args?: any[];
@@ -7079,10 +7196,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;
@@ -7097,45 +7214,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;
@@ -7149,20 +7266,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?: (
@@ -7170,10 +7298,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;
@@ -7550,8 +7679,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<
@@ -7637,14 +7771,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>;
@@ -7805,7 +7939,7 @@ declare class LoaderTargetPlugin {
 }
 declare interface LogEntry {
 	type: string;
-	args: any[];
+	args?: any[];
 	time: number;
 	trace?: string[];
 }
@@ -7865,25 +7999,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 };
@@ -7898,12 +8088,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;
 }
@@ -8033,7 +8223,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;
@@ -8157,8 +8347,7 @@ declare class Module extends DependenciesBlock {
 	used: any;
 }
 declare class ModuleConcatenationPlugin {
-	constructor(options?: any);
-	options: any;
+	constructor();
 
 	/**
 	 * Apply the plugin
@@ -8259,6 +8448,7 @@ declare interface ModuleFederationPluginOptions {
 		| "jsonp"
 		| "system"
 		| "promise"
+		| "module-import"
 		| "script"
 		| "node-commonjs";
 
@@ -8424,11 +8614,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
@@ -8641,6 +8831,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.
@@ -8675,13 +8870,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;
@@ -8735,8 +8985,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[];
@@ -8907,7 +9157,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;
@@ -8919,14 +9169,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 {
@@ -9123,6 +9382,10 @@ declare interface NormalModuleLoaderContext<OptionsType> {
 	sourceMap?: boolean;
 	mode: "none" | "development" | "production";
 	webpack?: boolean;
+	hashFunction: HashFunction;
+	hashDigest: string;
+	hashDigestLength: number;
+	hashSalt: string;
 	_module?: NormalModule;
 	_compilation?: Compilation;
 	_compiler?: Compiler;
@@ -9222,6 +9485,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;
@@ -9284,6 +9550,11 @@ declare interface Open {
  * Enables/Disables integrated optimizations.
  */
 declare interface Optimization {
+	/**
+	 * Avoid wrapping the entry module in an IIFE.
+	 */
+	avoidEntryIife?: boolean;
+
 	/**
 	 * Check for incompatible wasm types when importing/exporting from/to ESM.
 	 */
@@ -9674,11 +9945,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;
 }
@@ -11410,7 +11717,7 @@ declare interface RenderContext {
 	/**
 	 * rendering in strict context
 	 */
-	strictMode: boolean;
+	strictMode?: boolean;
 }
 type RenderManifestEntry =
 	| RenderManifestEntryTemplated
@@ -11425,7 +11732,7 @@ declare interface RenderManifestEntryStatic {
 }
 declare interface RenderManifestEntryTemplated {
 	render: () => Source;
-	filenameTemplate: string | ((arg0: PathData, arg1?: AssetInfo) => string);
+	filenameTemplate: TemplatePath;
 	pathOptions?: PathData;
 	info?: AssetInfo;
 	identifier: string;
@@ -11487,7 +11794,7 @@ declare interface ResolveBuildDependenciesResult {
 	/**
 	 * stored resolve results
 	 */
-	resolveResults: Map<string, string | false>;
+	resolveResults: Map<string, undefined | string | false>;
 
 	/**
 	 * dependencies of the resolving
@@ -12040,6 +12347,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;
@@ -12066,7 +12380,7 @@ declare interface RuleSet {
 	/**
 	 * execute the rule set
 	 */
-	exec: (arg0: object) => Effect[];
+	exec: (arg0: EffectData) => Effect[];
 }
 type RuleSetCondition =
 	| string
@@ -12987,13 +13301,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;
@@ -13138,6 +13452,7 @@ declare class SideEffectsFlagPlugin {
 		cache: Map<string, RegExp>
 	): undefined | boolean;
 }
+type SimpleType = "string" | "number" | "boolean";
 declare class SizeOnlySource extends Source {
 	constructor(size: number);
 }
@@ -13157,32 +13472,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>;
@@ -13276,11 +13595,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>;
 
 	/**
@@ -13293,11 +13615,6 @@ declare abstract class SortableSet<T> extends Set<T> {
 	 */
 	getFromUnorderedCache<R>(fn: (arg0: SortableSet<T>) => R): R;
 	toJSON(): T[];
-
-	/**
-	 * Iterates over values in the set.
-	 */
-	[Symbol.iterator](): IterableIterator<T>;
 }
 declare class Source {
 	constructor();
@@ -13447,7 +13764,7 @@ declare interface SplitChunksOptions {
 	maxAsyncRequests: number;
 	maxInitialRequests: number;
 	hidePathInfo: boolean;
-	filename: string | ((arg0: PathData, arg1?: AssetInfo) => string);
+	filename: TemplatePath;
 	automaticNameDelimiter: string;
 	getCacheGroups: (
 		module: Module,
@@ -13652,59 +13969,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.
@@ -14153,22 +14484,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
@@ -14197,7 +14534,7 @@ declare class SyncModuleIdsPlugin {
 		/**
 		 * operation mode (defaults to merge)
 		 */
-		mode?: "read" | "merge" | "create" | "update";
+		mode?: "read" | "create" | "merge" | "update";
 	});
 
 	/**
@@ -14223,6 +14560,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;
@@ -14239,7 +14585,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(
@@ -14255,6 +14601,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;
@@ -14305,6 +14652,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;
@@ -14328,10 +14678,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;
@@ -14446,28 +14796,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;
@@ -14574,7 +14903,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;
@@ -14673,6 +15002,7 @@ declare interface WebpackOptionsNormalized {
 		| "jsonp"
 		| "system"
 		| "promise"
+		| "module-import"
 		| "script"
 		| "node-commonjs";
 
@@ -14982,18 +15312,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 {
@@ -15289,7 +15612,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: (
@@ -15418,7 +15741,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);
@@ -15575,7 +15901,7 @@ declare namespace exports {
 		LoaderDefinitionFunction,
 		PitchLoaderDefinitionFunction,
 		RawLoaderDefinitionFunction,
-		LoaderContext
+		LoaderContextDeclarationsIndex as LoaderContext
 	};
 }
 declare const topLevelSymbolTag: unique symbol;