/*
 * This file was automatically generated.
 * DO NOT MODIFY BY HAND.
 * Run `yarn fix:special` to update
 */

import { Buffer } from "buffer";
import { CompiledAliasOptions } from "enhanced-resolve/types/AliasUtils";
import {
	ResolveOptions as ResolveOptionsImport,
	UserResolveOptions
} from "enhanced-resolve/types/ResolverFactory";
import {
	ArrayExpression,
	ArrayPattern,
	ArrowFunctionExpression,
	AssignmentExpression,
	AssignmentPattern,
	AssignmentProperty,
	AwaitExpression,
	BigIntLiteral,
	BinaryExpression,
	BlockStatement,
	BreakStatement,
	CatchClause,
	ChainExpression,
	ClassBody,
	ClassDeclaration,
	ClassExpression,
	Comment as CommentImport,
	ConditionalExpression,
	ContinueStatement,
	DebuggerStatement,
	Directive,
	DoWhileStatement,
	EmptyStatement,
	ExportAllDeclaration,
	ExportDefaultDeclaration,
	ExportNamedDeclaration,
	ExportSpecifier,
	ExpressionStatement,
	ForInStatement,
	ForOfStatement,
	ForStatement,
	FunctionDeclaration,
	FunctionExpression,
	Identifier,
	IfStatement,
	ImportDeclaration,
	ImportDefaultSpecifier,
	ImportExpression as ImportExpressionImport,
	ImportNamespaceSpecifier,
	ImportSpecifier,
	LabeledStatement,
	LogicalExpression,
	MaybeNamedClassDeclaration,
	MaybeNamedFunctionDeclaration,
	MemberExpression,
	MetaProperty,
	MethodDefinition,
	NewExpression,
	ObjectExpression,
	ObjectPattern,
	PrivateIdentifier,
	Program,
	Property,
	PropertyDefinition,
	RegExpLiteral,
	RestElement,
	ReturnStatement,
	SequenceExpression,
	SimpleCallExpression,
	SimpleLiteral,
	SourceLocation,
	SpreadElement,
	StaticBlock,
	Super,
	SwitchCase,
	SwitchStatement,
	TaggedTemplateExpression,
	TemplateElement,
	TemplateLiteral,
	ThisExpression,
	ThrowStatement,
	TryStatement,
	UnaryExpression,
	UpdateExpression,
	VariableDeclaration,
	VariableDeclarator,
	WhileStatement,
	WithStatement,
	YieldExpression
} from "estree";
import { FileHandle } from "fs/promises";
import {
	Server as ServerImportHttp,
	ServerOptions as ServerOptionsImportHttp
} from "http";
import {
	Server as ServerImportHttps,
	ServerOptions as ServerOptionsImportHttps
} from "https";
import {
	Session as SessionImportInspectorClass_1,
	Session as SessionImportInspectorClass_2
} from "inspector";
import { JSONSchema4, JSONSchema6, JSONSchema7 } from "json-schema";
import { ListenOptions } from "net";
import {
	ExtendedSchema,
	ValidationErrorConfiguration,
	validate as validateFunction
} from "schema-utils";
import { default as ValidationError } from "schema-utils/declarations/ValidationError";
import {
	AsArray,
	AsyncParallelHook,
	AsyncSeriesBailHook,
	AsyncSeriesHook,
	AsyncSeriesWaterfallHook,
	HookMap,
	IfSet,
	MultiHook,
	SyncBailHook,
	SyncHook,
	SyncWaterfallHook,
	TapOptions,
	TypedHookMap
} from "tapable";
import { Context as ContextImport } from "vm";
import {
	addScopesToSourceMap,
	collectSourceScopes,
	createScopeCollector,
	createScopesWriter,
	encodeScopes
} from "webpack-sources/types/helpers/scopes";
import {
	disableDualStringBufferCaching,
	enableDualStringBufferCaching,
	enterStringInterningRange,
	exitStringInterningRange,
	internString,
	isDualStringBufferCachingEnabled
} from "webpack-sources/types/helpers/stringBufferUtils";
type SetSamplingIntervalParameterType =
	import("inspector").Profiler.SetSamplingIntervalParameterType;
type StopReturnType = import("inspector").Profiler.StopReturnType;

declare interface Abortable {
	signal?: AbortSignal;
}

/**
 * Represents AbstractLibraryPlugin.
 */
declare class AbstractLibraryPlugin<T> {
	/**
	 * Creates an instance of AbstractLibraryPlugin.
	 */
	constructor(__0: AbstractLibraryPluginOptions);

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Returns preprocess as needed by overriding.
	 */
	parseOptions(library: LibraryOptions): T;

	/**
	 * Finish entry module.
	 */
	finishEntryModule(
		module: Module,
		entryName: string,
		libraryContext: LibraryContext<T>
	): void;

	/**
	 * Embed in runtime bailout.
	 */
	embedInRuntimeBailout(
		module: Module,
		renderContext: RenderContextJavascriptModulesPlugin,
		libraryContext: LibraryContext<T>
	): undefined | string;

	/**
	 * Strict runtime bailout.
	 */
	strictRuntimeBailout(
		renderContext: RenderContextJavascriptModulesPlugin,
		libraryContext: LibraryContext<T>
	): undefined | string;

	/**
	 * Processes the provided chunk.
	 */
	runtimeRequirements(
		chunk: Chunk,
		set: Set<string>,
		libraryContext: LibraryContext<T>
	): void;

	/**
	 * Returns source with library export.
	 */
	render(
		source: Source,
		renderContext: RenderContextJavascriptModulesPlugin,
		libraryContext: LibraryContext<T>
	): Source;

	/**
	 * Renders source with library export.
	 */
	renderStartup(
		source: Source,
		module: Module,
		renderContext: StartupRenderContext,
		libraryContext: LibraryContext<T>
	): Source;

	/**
	 * Renders module content.
	 */
	renderModuleContent(
		source: Source,
		module: Module,
		renderContext: ModuleRenderContext,
		libraryContext: Omit<LibraryContext<T>, "options">
	): Source;

	/**
	 * Processes the provided chunk.
	 */
	chunkHash(
		chunk: Chunk,
		hash: Hash,
		chunkHashContext: ChunkHashContext,
		libraryContext: LibraryContext<T>
	): void;
	static COMMON_LIBRARY_NAME_MESSAGE: string;
}

/**
 * Defines the abstract library plugin options type used by this module.
 */
declare interface AbstractLibraryPluginOptions {
	/**
	 * name of the plugin
	 */
	pluginName: string;

	/**
	 * used library type
	 */
	type: string;
}
type AdditionalData = AdditionalDataKnown & Record<string, any>;
declare interface AdditionalDataKnown {
	/**
	 * the AST webpack should parse instead of the source
	 */
	webpackAST?: PreparsedAst;
}
type AfterContextResolveData = ContextResolveData &
	ContextOptions & {
		resource: string | string[];
		resourceQuery?: string;
		resourceFragment?: string;
		resolveDependencies: (
			fs: InputFileSystem,
			options: ContextModuleOptions,
			callback: (
				err: null | Error,
				dependencies?: ContextElementDependency[]
			) => void
		) => void;
	};
declare class AggressiveMergingPlugin {
	/**
	 * Creates an instance of AggressiveMergingPlugin.
	 */
	constructor(options?: AggressiveMergingPluginOptions);
	options: AggressiveMergingPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the aggressive merging plugin options type used by this module.
 */
declare interface AggressiveMergingPluginOptions {
	/**
	 * minimal size reduction to trigger merging
	 */
	minSizeReduce?: number;
}
declare class AggressiveSplittingPlugin {
	/**
	 * Creates an instance of AggressiveSplittingPlugin.
	 */
	constructor(options?: AggressiveSplittingPluginOptions);
	options: AggressiveSplittingPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Was chunk recorded.
	 */
	static wasChunkRecorded(chunk: Chunk): boolean;
}
declare interface AggressiveSplittingPluginOptions {
	/**
	 * Extra cost for each chunk (Default: 9.8kiB).
	 */
	chunkOverhead?: number;

	/**
	 * Extra cost multiplicator for entry chunks (Default: 10).
	 */
	entryChunkMultiplicator?: number;

	/**
	 * Byte, max size of per file (Default: 50kiB).
	 */
	maxSize?: number;

	/**
	 * Byte, split point. (Default: 30kiB).
	 */
	minSize?: number;
}

/**
 * Defines the all code generation schemas type used by this module.
 */
declare interface AllCodeGenerationSchemas {
	/**
	 * top level declarations for javascript modules
	 */
	topLevelDeclarations: Set<string>;

	/**
	 * free identifier names in the rendered source for javascript modules
	 */
	freeNames: Set<string>;

	/**
	 * chunk init fragments for javascript modules
	 */
	chunkInitFragments: InitFragment<ChunkRenderContextJavascriptModulesPlugin>[];

	/**
	 * native external reexport source and attributes
	 */
	externalReexport: string;

	/**
	 * export definitions left out of a javascript module's source on demand (see `KnownMeta.onDemandExports`), to be placed before its body where it is wrapped
	 */
	exportsSource: string;

	/**
	 * export definitions left out on demand that read the module's own declarations, to be placed after its body where it is wrapped
	 */
	exportsBindingSource: string;

	/**
	 * final name of each used export of a concatenated module whose definitions were left out on demand
	 */
	exportsFinalName: Record<string, string>;

	/**
	 * url for asset modules
	 */
	url: { javascript?: string; "asset-url"?: string };

	/**
	 * a filename for asset modules
	 */
	filename: string;

	/**
	 * an asset info for asset modules
	 */
	assetInfo: AssetInfo;

	/**
	 * a full content hash for asset modules
	 */
	fullContentHash: string;

	/**
	 * share-init for modules federation
	 */
	"share-init": [{ shareScope: string; initStage: number; init: string }];
}
type AnalyzableForm =
	"import" | "url" | "url-runtime" | "url-inline" | "wasm" | "wasm-relative";
type AnyLoaderContext = NormalModuleLoaderContext<any> &
	LoaderRunnerMutableContext<any> &
	LoaderRunnerReadonlyContext<any, LoaderData> &
	LoaderPluginLoaderContext &
	HotModuleReplacementPluginLoaderContext;

/**
 * The parts of a language that names none: every node type has every part.
 */
declare interface AnyParts {
	types: number;
	field: number;
	flag: number;
	part: number;
	text: number;
	fields: Record<number, number>;
	flags: Record<number, number>;
	parts: Record<number, number>;
	texts: Record<number, number>;
	items: Record<number, number>;
}

/**
 * Defines the argument type used by this module.
 */
declare interface Argument {
	description?: string;
	simpleType: SimpleType;
	multiple: boolean;
	configs: ArgumentConfig[];
}

/**
 * Defines the argument config type used by this module.
 */
declare interface ArgumentConfig {
	description?: string;
	negatedDescription?: string;
	path: string;
	multiple: boolean;
	type: "string" | "number" | "boolean" | "path" | "enum" | "RegExp" | "reset";
	values?: EnumValue[];
}

/**
 * Defines the asset type used by this module.
 */
declare interface Asset {
	/**
	 * the filename of the asset
	 */
	name: string;

	/**
	 * source of the asset
	 */
	source: Source;

	/**
	 * info about the asset
	 */
	info: AssetInfo;
}
declare abstract class AssetBytesGenerator extends Generator<AssetNormalModule> {
	/**
	 * Generates fallback output for the provided error condition.
	 */
	generateError(
		error: Error,
		module: AssetNormalModule,
		generateContext: GenerateContext
	): null | Source;
}
declare abstract class AssetBytesParser extends Parser<BuiltAssetModule> {}
declare interface AssetDependencyMeta {
	sourceType: "asset-url" | "css-url";
}

/**
 * Defines the asset emitted info type used by this module.
 */
declare interface AssetEmittedInfo {
	content: Buffer;
	source: Source;
	compilation: Compilation;
	outputPath: string;
	targetPath: string;
}
type AssetFilterItemTypes =
	string | RegExp | ((name: string, asset: StatsAsset) => boolean);
declare abstract class AssetGenerator extends Generator<AssetNormalModule> {
	dataUrlOptions?:
		| AssetGeneratorDataUrlOptions
		| ((
				source: string | Buffer,
				context: { filename: string; module: Module }
		  ) => string);
	filename?: string | TemplatePathFn<PathDataModule>;
	publicPath?: string | TemplatePathFn<PathData>;
	outputPath?: string | TemplatePathFn<PathDataModule>;
	emit?: boolean;

	/**
	 * Returns mime type.
	 */
	getMimeType(module: AssetNormalModule): string;

	/**
	 * Generates data uri.
	 */
	generateDataUri(module: AssetNormalModule, renderedSource?: Source): string;

	/**
	 * Generates fallback output for the provided error condition.
	 */
	generateError(
		error: Error,
		module: AssetNormalModule,
		generateContext: GenerateContext
	): null | Source;
}

/**
 * Options object for data url generation.
 */
declare interface AssetGeneratorDataUrlOptions {
	/**
	 * Asset encoding (defaults to base64).
	 */
	encoding?: false | "base64";

	/**
	 * Asset mimetype (getting from file extension by default).
	 */
	mimetype?: string;
}
type AssetGeneratorOptions = AssetInlineGeneratorOptions &
	AssetResourceGeneratorOptions;
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.
	 */
	dataUrl?:
		| AssetGeneratorDataUrlOptions
		| ((
				source: string | Buffer,
				context: { filename: string; module: Module }
		  ) => string);
}
type AssetModuleBuildInfo = KnownBuildInfo &
	Record<string, any> &
	KnownNormalModuleBuildInfo &
	KnownAssetModuleBuildInfo;
declare class AssetModulesPlugin {
	/**
	 * Creates an instance of AssetModulesPlugin.
	 */
	constructor(options: AssetModulesPluginOptions);
	options: AssetModulesPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Represents the asset modules plugin runtime component.
 */
declare interface AssetModulesPluginOptions {
	sideEffectFree?: boolean;
}
type AssetNormalModule = NormalModule & { buildInfo?: AssetModuleBuildInfo };
declare abstract class AssetParser extends Parser<BuiltAssetModule> {
	dataUrlCondition?:
		| boolean
		| AssetParserDataUrlOptions
		| ((
				source: string | Buffer,
				context: { filename: string; module: Module }
		  ) => boolean);
}

/**
 * Options object for DataUrl condition.
 */
declare interface AssetParserDataUrlOptions {
	/**
	 * Maximum size of asset that should be inline as modules. Default: 8kb.
	 */
	maxSize?: number;
}

/**
 * Parser options for asset modules.
 */
declare interface AssetParserOptions {
	/**
	 * The condition for inlining the asset as DataUrl.
	 */
	dataUrlCondition?:
		| AssetParserDataUrlOptions
		| ((
				source: string | Buffer,
				context: { filename: string; module: Module }
		  ) => boolean);
}

/**
 * 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.
	 */
	emit?: boolean;

	/**
	 * The filename of asset modules as relative path inside the 'output.path' directory.
	 */
	filename?: string | TemplatePathFn<PathDataModule>;

	/**
	 * Emit the asset in the specified folder relative to 'output.path'. This should only be needed when custom 'publicPath' is specified to match the folder structure there.
	 */
	outputPath?: string | TemplatePathFn<PathDataModule>;

	/**
	 * The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
	 */
	publicPath?: string | TemplatePathFn<PathData>;
}
declare abstract class AssetSourceGenerator extends Generator<AssetNormalModule> {
	/**
	 * Generates fallback output for the provided error condition.
	 */
	generateError(
		error: Error,
		module: AssetNormalModule,
		generateContext: GenerateContext
	): null | Source;
}
declare abstract class AssetSourceParser extends Parser<BuiltAssetModule> {}

/**
 * Where an asset which is a symbolic link points, as the link itself spells it.
 */
declare interface AssetSymlink {
	/**
	 * what the link points at, left as it is written
	 */
	target: string;

	/**
	 * whether it points at a directory, which is what Windows needs in order to create one
	 */
	isDirectory: boolean;
}

/**
 * Access and modification times an asset carries onto the file it is written to.
 */
declare interface AssetTimestamps {
	/**
	 * last access time, in milliseconds
	 */
	atime: number;

	/**
	 * last modification time, in milliseconds
	 */
	mtime: number;
}

/**
 * What terser's `ast.js` exports: each kind's factory, the predicate
 * `is<Kind>Node` for it, and the walkers and helpers, which stay open.
 */
declare interface Ast {
	[index: string]: any;
	expressionOf(node: NodeShape): undefined | NodeShape;
	createStackTransformer(
		before?: (
			this: CompressorShape,
			node: NodeShape,
			descend: (node: NodeShape, walker: CompressorShape) => void,
			inList?: boolean
		) => null | void | NodeShape | Splice | SkipMarker,
		after?: (
			this: CompressorShape,
			node: NodeShape,
			inList?: boolean
		) => null | void | NodeShape | Splice | SkipMarker
	): CompressorShape;
	namesOf(node: NodeShape): (null | NodeShape)[];
	wrapOptimizer(
		name: string,
		wrap: (
			original: (self: NodeShape, compressor: CompressorShape) => NodeShape
		) => (self: NodeShape, compressor: CompressorShape) => NodeShape
	): boolean;
}
declare class AsyncDependenciesBlock extends DependenciesBlock {
	constructor(
		groupOptions: null | string | GroupOptionsAsyncDependenciesBlock,
		loc?: null | SyntheticDependencyLocation | RealDependencyLocation,
		request?: null | string
	);
	groupOptions: GroupOptionsAsyncDependenciesBlock;
	loc?: null | SyntheticDependencyLocation | RealDependencyLocation;
	request?: null | string;
	chunkName?: null | string;
	get circular(): boolean;
	module: void;
}

/**
 * Represents AsyncQueue.
 */
declare abstract class AsyncQueue<T, K, R> {
	hooks: {
		beforeAdd: AsyncSeriesHook<[T]>;
		added: SyncHook<[T]>;
		beforeStart: AsyncSeriesHook<[T]>;
		started: SyncHook<[T]>;
		result: SyncHook<
			[T, undefined | null | WebpackError, undefined | null | R]
		>;
	};

	/**
	 * Returns context of execution.
	 */
	getContext(): string;

	/**
	 * Updates context using the provided value.
	 */
	setContext(value: string): void;

	/**
	 * Processes the provided item.
	 */
	add(item: T, callback: CallbackAsyncQueue<R>): void;

	/**
	 * Processes the provided item.
	 */
	invalidate(item: T): void;

	/**
	 * Waits for an already started item
	 */
	waitFor(item: T, callback: CallbackAsyncQueue<R>): void;

	/**
	 * Describes how this stop operation behaves.
	 */
	stop(): void;

	/**
	 * Increase parallelism.
	 */
	increaseParallelism(): void;

	/**
	 * Decrease parallelism.
	 */
	decreaseParallelism(): void;

	/**
	 * Checks whether this async queue is processing.
	 */
	isProcessing(item: T): boolean;

	/**
	 * Checks whether this async queue is queued.
	 */
	isQueued(item: T): boolean;

	/**
	 * Checks whether this async queue is done.
	 */
	isDone(item: T): boolean;
	clear(): void;
}
declare class AsyncWebAssemblyModulesPlugin {
	/**
	 * Creates an instance of AsyncWebAssemblyModulesPlugin.
	 */
	constructor(options: AsyncWebAssemblyModulesPluginOptions);
	options: AsyncWebAssemblyModulesPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Renders the newly generated source from rendering.
	 */
	renderModule(
		module: Module,
		renderContext: WebAssemblyRenderContext,
		hooks: CompilationHooks
	): Source;
	static getCompilationHooks: (compilation: Compilation) => CompilationHooks;
}

/**
 * Defines the async web assembly modules plugin options type used by this module.
 */
declare interface AsyncWebAssemblyModulesPluginOptions {
	/**
	 * mangle imports
	 */
	mangleImports?: boolean;
}
declare abstract class AsyncWebAssemblyParser extends Parser<BuiltAsyncWasmModule> {}
type AtRule = NodeSyntaxParser & {
	name: string;
	nameStart: number;
	nameEnd: number;
	prelude: ComponentValue[];
	declarations: null | DeclarationSyntaxParser[];
	childRules: null | RuleSyntaxParser[];
	blockStart: number;
	blockEnd: number;
};

/**
 * Records modules from one compilation and adds them back as prefetch
 * dependencies in the next compilation.
 */
declare class AutomaticPrefetchPlugin {
	constructor();

	/**
	 * Registers hooks that remember previously built normal modules and enqueue
	 * them as `PrefetchDependency` requests during the next make phase.
	 */
	apply(compiler: Compiler): void;
}
type AuxiliaryComment = string | LibraryCustomUmdCommentObject;
declare const BLOCK_DECLARATIONS: unique symbol;

/**
 * Defines the backend api type used by this module.
 */
declare interface BackendApi {
	dispose: (callback: (err?: null | Error) => void) => void;
	module: (module: Module) => ModuleResult;
}

/**
 * Prepends or appends banner text to emitted assets that match the configured
 * file filters.
 */
declare class BannerPlugin {
	/**
	 * Normalizes banner options and compiles the configured banner source into a
	 * function that can render per-asset banner text.
	 */
	constructor(options: BannerPluginArgument);
	options: BannerPluginOptions;
	banner: (data: {
		hash?: string;
		/**
		 * Wraps banner text in a JavaScript block comment, preserving multi-line
		 * formatting and escaping accidental comment terminators.
		 */
		chunk: Chunk;
		filename: string;
	}) => string;

	/**
	 * Validates the configured options and injects rendered banner comments into
	 * matching compilation assets at the configured process-assets stage.
	 */
	apply(compiler: Compiler): void;
}
type BannerPluginArgument =
	| string
	| BannerPluginOptions
	| ((data: {
			hash?: string;
			/**
			 * Wraps banner text in a JavaScript block comment, preserving multi-line
			 * formatting and escaping accidental comment terminators.
			 */
			chunk: Chunk;
			filename: string;
	  }) => string);
declare interface BannerPluginOptions {
	/**
	 * Specifies the banner.
	 */
	banner:
		| string
		| ((data: {
				hash?: string;
				/**
				 * Wraps banner text in a JavaScript block comment, preserving multi-line
				 * formatting and escaping accidental comment terminators.
				 */
				chunk: Chunk;
				filename: string;
		  }) => string);

	/**
	 * If true, the banner will only be added to the entry chunks.
	 */
	entryOnly?: boolean;

	/**
	 * Exclude all modules matching any of these conditions.
	 */
	exclude?:
		string | RegExp | ((str: string) => boolean) | RuleGlob | RuleObject[];

	/**
	 * If true, banner will be placed at the end of the output.
	 */
	footer?: boolean;

	/**
	 * Include all modules matching any of these conditions.
	 */
	include?:
		string | RegExp | ((str: string) => boolean) | RuleGlob | RuleObject[];

	/**
	 * If true, banner will not be wrapped in a comment.
	 */
	raw?: boolean;

	/**
	 * Specifies the stage when add a banner.
	 */
	stage?: number;

	/**
	 * Include all modules that pass test assertion.
	 */
	test?: string | RegExp | ((str: string) => boolean) | RuleGlob | RuleObject[];
}
declare interface BaseResolveRequest {
	/**
	 * path
	 */
	path: string | false;

	/**
	 * content
	 */
	context?: ContextResolver;

	/**
	 * description file path
	 */
	descriptionFilePath?: string;

	/**
	 * description file root
	 */
	descriptionFileRoot?: string;

	/**
	 * description file data
	 */
	descriptionFileData?: JsonObjectResolver;

	/**
	 * tsconfig paths map
	 */
	tsconfigPathsMap?: null | TsconfigPathsMap;

	/**
	 * relative path
	 */
	relativePath?: string;

	/**
	 * true when need to ignore symlinks, otherwise false
	 */
	ignoreSymlinks?: boolean;

	/**
	 * true when full specified, otherwise false
	 */
	fullySpecified?: boolean;

	/**
	 * package id the request was resolved to in the package map, to be propagated to resolutions made from the resulting file (`@experimental`, see the `packageMap` option)
	 */
	packageId?: string;

	/**
	 * inner request for internal usage
	 */
	__innerRequest?: string;

	/**
	 * inner request for internal usage
	 */
	__innerRequest_request?: string;

	/**
	 * inner relative path for internal usage
	 */
	__innerRequest_relativePath?: string;

	/**
	 * internal: shared marker `RestrictionsPlugin` flips when it filters out an existing target, letting `ExportsFieldPlugin` fall back instead of erroring
	 */
	__restrictionsMarker?: { blocked: boolean };
}
declare interface BasenameCacheEntry {
	/**
	 * cached dirname function
	 */
	fn: (maybePath: string, suffix?: string) => string;

	/**
	 * the underlying cache map
	 */
	cache: Map<string, Map<undefined | string, undefined | string>>;
}

/**
 * An instance is allocated for a large share of walked expressions, so the
 * boolean facts live in one packed flags slot and the scalar/identifier
 * fields in five slots shared by type, with accessors keeping every public
 * field readable. This shrinks instances from 224 to 144 bytes on V8.
 */
declare abstract class BasicEvaluatedExpression {
	expression?:
		| Program
		| ImportDeclaration
		| ExportNamedDeclaration
		| ExportAllDeclaration
		| ImportExpressionImport
		| UnaryExpression
		| ArrayExpression
		| ArrowFunctionExpression
		| AssignmentExpression
		| AwaitExpression
		| BinaryExpression
		| SimpleCallExpression
		| NewExpression
		| ChainExpression
		| ClassExpression
		| ConditionalExpression
		| FunctionExpression
		| Identifier
		| SimpleLiteral
		| RegExpLiteral
		| BigIntLiteral
		| LogicalExpression
		| MemberExpression
		| MetaProperty
		| ObjectExpression
		| SequenceExpression
		| TaggedTemplateExpression
		| TemplateLiteral
		| ThisExpression
		| UpdateExpression
		| YieldExpression
		| SpreadElement
		| PrivateIdentifier
		| Super
		| FunctionDeclaration
		| VariableDeclaration
		| ClassDeclaration
		| ExpressionStatement
		| BlockStatement
		| StaticBlock
		| EmptyStatement
		| DebuggerStatement
		| WithStatement
		| ReturnStatement
		| LabeledStatement
		| BreakStatement
		| ContinueStatement
		| IfStatement
		| SwitchStatement
		| ThrowStatement
		| TryStatement
		| WhileStatement
		| DoWhileStatement
		| ForStatement
		| ForInStatement
		| ForOfStatement
		| ExportDefaultDeclaration
		| MethodDefinition
		| PropertyDefinition
		| VariableDeclarator
		| Property
		| CatchClause
		| ClassBody
		| SwitchCase
		| TemplateElement
		| AssignmentProperty
		| ImportSpecifier
		| ImportDefaultSpecifier
		| ImportNamespaceSpecifier
		| ExportSpecifier
		| ObjectPattern
		| ArrayPattern
		| RestElement
		| AssignmentPattern;
	quasis?: BasicEvaluatedExpression[];
	parts?: BasicEvaluatedExpression[];
	items?: BasicEvaluatedExpression[];
	options?: BasicEvaluatedExpression[];
	prefix?: null | BasicEvaluatedExpression;
	postfix?: null | BasicEvaluatedExpression;
	wrappedInnerExpressions?: BasicEvaluatedExpression[];

	/**
	 * Served lazily from the attached expression when not set explicitly:
	 * `evaluateExpression`'s plain results share the expression's range, and
	 * most evaluations never read it, so the node's range array is only
	 * materialized on demand.
	 */
	range?: [number, number];
	type: number;
	truthy: boolean;
	falsy: boolean;
	nullish?: boolean;
	sideEffects: boolean;
	bool?: boolean;
	number?: number;
	bigint?: bigint;
	regExp?: RegExp;
	string?: string;
	templateStringKind?: "cooked" | "raw";
	array?: string[];
	identifier?: string | VariableInfo;
	rootInfo?: string | VariableInfo;
	getMembers?: () => string[];
	getMembersOptionals?: () => boolean[];
	getMemberRanges?: () => [number, number][];
	isUnknown(): boolean;
	isNull(): boolean;
	isUndefined(): boolean;
	isString(): boolean;
	isNumber(): boolean;
	isBigInt(): boolean;
	isBoolean(): boolean;
	isRegExp(): boolean;
	isConditional(): boolean;
	isArray(): boolean;
	isConstArray(): boolean;
	isIdentifier(): boolean;
	isWrapped(): boolean;
	isTemplateString(): boolean;

	/**
	 * Is expression a primitive or an object type value?
	 */
	isPrimitiveType(): undefined | boolean;

	/**
	 * Is expression a runtime or compile-time value?
	 */
	isCompileTimeValue(): boolean;

	/**
	 * As compile time value.
	 */
	asCompileTimeValue():
		undefined | null | string | number | bigint | boolean | RegExp | string[];
	isTruthy(): boolean;
	isFalsy(): boolean;
	isNullish(): undefined | boolean;

	/**
	 * Can this expression have side effects?
	 */
	couldHaveSideEffects(): boolean;

	/**
	 * Creates a boolean representation of this evaluated expression.
	 */
	asBool(): undefined | boolean;

	/**
	 * Creates a nullish coalescing representation of this evaluated expression.
	 */
	asNullish(): undefined | boolean;

	/**
	 * Creates a string representation of this evaluated expression.
	 */
	asString(): undefined | string;

	/**
	 * Updates string using the provided string.
	 */
	setString(string: string): BasicEvaluatedExpression;
	setUndefined(): BasicEvaluatedExpression;
	setNull(): BasicEvaluatedExpression;

	/**
	 * Set's the value of this expression to a number
	 */
	setNumber(number: number): BasicEvaluatedExpression;

	/**
	 * Set's the value of this expression to a BigInt
	 */
	setBigInt(bigint: bigint): BasicEvaluatedExpression;

	/**
	 * Set's the value of this expression to a boolean
	 */
	setBoolean(bool: boolean): BasicEvaluatedExpression;

	/**
	 * Set's the value of this expression to a regular expression
	 */
	setRegExp(regExp: RegExp): BasicEvaluatedExpression;

	/**
	 * Set's the value of this expression to a particular identifier and its members.
	 */
	setIdentifier(
		identifier: string | VariableInfo,
		rootInfo: string | VariableInfo,
		getMembers: () => string[],
		getMembersOptionals?: () => boolean[],
		getMemberRanges?: () => [number, number][]
	): BasicEvaluatedExpression;

	/**
	 * Wraps an array of expressions with a prefix and postfix expression.
	 */
	setWrapped(
		prefix?: null | BasicEvaluatedExpression,
		postfix?: null | BasicEvaluatedExpression,
		innerExpressions?: BasicEvaluatedExpression[]
	): BasicEvaluatedExpression;

	/**
	 * Stores the options of a conditional expression.
	 */
	setOptions(options: BasicEvaluatedExpression[]): BasicEvaluatedExpression;

	/**
	 * Adds the provided basic evaluated expression to the basic evaluated expression.
	 */
	addOptions(options: BasicEvaluatedExpression[]): BasicEvaluatedExpression;

	/**
	 * Set's the value of this expression to an array of expressions.
	 */
	setItems(items: BasicEvaluatedExpression[]): BasicEvaluatedExpression;

	/**
	 * Set's the value of this expression to an array of strings.
	 */
	setArray(array: string[]): BasicEvaluatedExpression;

	/**
	 * Set's the value of this expression to a processed/unprocessed template string. Used
	 * for evaluating TemplateLiteral expressions in the JavaScript Parser.
	 */
	setTemplateString(
		quasis: BasicEvaluatedExpression[],
		parts: BasicEvaluatedExpression[],
		kind: "cooked" | "raw"
	): BasicEvaluatedExpression;
	setTruthy(): BasicEvaluatedExpression;
	setFalsy(): BasicEvaluatedExpression;

	/**
	 * Set's the value of the expression to nullish.
	 */
	setNullish(value: boolean): BasicEvaluatedExpression;

	/**
	 * Set's the range for the expression.
	 */
	setRange(range: [number, number]): BasicEvaluatedExpression;

	/**
	 * Set whether or not the expression has side effects.
	 */
	setSideEffects(sideEffects?: boolean): BasicEvaluatedExpression;

	/**
	 * Set the expression node for the expression.
	 */
	setExpression(
		expression?:
			| Program
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| SpreadElement
			| PrivateIdentifier
			| Super
			| FunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| ExpressionStatement
			| BlockStatement
			| StaticBlock
			| EmptyStatement
			| DebuggerStatement
			| WithStatement
			| ReturnStatement
			| LabeledStatement
			| BreakStatement
			| ContinueStatement
			| IfStatement
			| SwitchStatement
			| ThrowStatement
			| TryStatement
			| WhileStatement
			| DoWhileStatement
			| ForStatement
			| ForInStatement
			| ForOfStatement
			| ExportDefaultDeclaration
			| MethodDefinition
			| PropertyDefinition
			| VariableDeclarator
			| Property
			| CatchClause
			| ClassBody
			| SwitchCase
			| TemplateElement
			| AssignmentProperty
			| ImportSpecifier
			| ImportDefaultSpecifier
			| ImportNamespaceSpecifier
			| ExportSpecifier
			| ObjectPattern
			| ArrayPattern
			| RestElement
			| AssignmentPattern
	): BasicEvaluatedExpression;
}
type BeforeContextResolveData = ContextResolveData & ContextOptions;

/**
 * Defines the bind cache type used by this module.
 */
declare interface BindCache<T> {
	(cache: object): BindCacheResultFn<T>;
}

/**
 * Defines the bind cache result fn type used by this module.
 */
declare interface BindCacheResultFn<T> {
	(value: string): T;
}
declare interface Bootstrap {
	header: string[];
	beforeStartup: string[];
	startup: string[];
	afterStartup: string[];
	allowInlineStartup: boolean;
	exportsAwaited: boolean;
}

/**
 * Which disjunction branch a named group sits in, so that the same name in two
 * alternatives of one disjunction is allowed and a repeat in one is not.
 */
declare abstract class BranchID {
	parent: null | BranchID;
	base: BranchID;
	walk: number;
	taken: null | BranchID;

	/**
	 * Two branches are separated when some disjunction they both sit under took
	 * a different alternative for each, so nothing can match both.
	 */
	separatedFrom(alt: BranchID): boolean;
	sibling(): BranchID;
}
type BufferEncoding =
	| "ascii"
	| "utf8"
	| "utf-8"
	| "utf16le"
	| "utf-16le"
	| "ucs2"
	| "ucs-2"
	| "base64"
	| "base64url"
	| "latin1"
	| "binary"
	| "hex";
type BufferEncodingOption = "buffer" | { encoding: "buffer" };
declare interface BufferEntry {
	map?: null | RawSourceMap;
	bufferedMap?: null | BufferedMap;
	scopes?: ScopesReplay;
}
type BufferSerializableType =
	Buffer | (() => BufferSerializableType[] | Promise<BufferSerializableType[]>);
declare interface BufferedMap {
	/**
	 * version
	 */
	version: number;

	/**
	 * sources
	 */
	sources: string[];

	/**
	 * name
	 */
	names: string[];

	/**
	 * source root
	 */
	sourceRoot?: string;

	/**
	 * sources content
	 */
	sourcesContent?: ("" | Buffer)[];

	/**
	 * mappings
	 */
	mappings?: Buffer;

	/**
	 * file
	 */
	file: string;
}
type BuildDependencyItem =
	| string
	| {
			/**
			 * Request to a dependency (resolved as directory relative to the context directory).
			 */
			dependency: string;
			/**
			 * When true, the dependency may be missing. Existence changes invalidate the cache.
			 */
			optional?: boolean;
	  };

/**
 * What a build recorded for stats and the performance hints to report, kept on the build info so a module restored from the cache still has it.
 */
declare interface BuildDiagnostics {
	/**
	 * what parser plugins reported as optimization bailouts, replayed into the module graph of every compilation that reuses the module
	 */
	optimizationBailouts?: string[];

	/**
	 * the statement whose side effect keeps the module in the bundle, as `type at location`
	 */
	sideEffectStatement?: string;

	/**
	 * how many `#__PURE__` annotations sit where the parser does not read them
	 */
	ineffectivePureAnnotations?: number;

	/**
	 * how many times the module reads `this` at its top level
	 */
	topLevelThis?: number;

	/**
	 * true when the module calls `eval` directly
	 */
	usesEval?: boolean;

	/**
	 * reasons why the module is not cacheable (e.g. paths of loaders that marked it)
	 */
	notCacheableReasons?: string[];
}
type BuildInfo = KnownBuildInfo & Record<string, any>;
type BuildMeta = KnownBuildMeta & Record<string, any>;
type BuiltAssetModule = NormalModule & {
	buildInfo: AssetModuleBuildInfo;
	buildMeta: BuildMeta;
};
type BuiltAsyncWasmModule = NormalModule & {
	buildInfo: NormalModuleBuildInfo;
	buildMeta: BuildMeta;
};
type BuiltCssModule = NormalModule & {
	buildInfo: CssModuleBuildInfo;
	buildMeta: CssModuleBuildMeta;
};
type BuiltHtmlModule = NormalModule & {
	buildInfo: HtmlModuleBuildInfo;
	buildMeta: BuildMeta;
};
type BuiltJavascriptModule = NormalModule & {
	buildInfo: JavascriptModuleBuildInfo;
	buildMeta: JavascriptModuleBuildMeta;
};
type BuiltJsonModule = NormalModule & {
	buildInfo: JsonModuleBuildInfo;
	buildMeta: BuildMeta;
};

/**
 * The map a minify writes, its mappings decoded, less the keys that say nothing.
 */
declare interface BuiltSourceMap {
	version: number;
	file?: string;
	names: string[];
	sourceRoot?: string;
	sources: string[];
	sourcesContent?: (undefined | null | string)[];
	mappings: DecodedSegment[][];
	ignoreList: number[];
}
type BuiltSyncWasmModule = NormalModule & {
	buildInfo: NormalModuleBuildInfo;
	buildMeta: SyncWasmModuleBuildMeta;
};
type BuiltinEmbeddedRendererOptions = Pick<
	CssProcessOptions,
	| "environment"
	| "convertLengthUnits"
	| "convertApproximateColors"
	| "dropOverriddenDeclarations"
	| "rewriteCustomProperties"
	| "transforms"
	| "unusedSymbols"
	| "pseudoClasses"
> &
	BuiltinSvgOptions;
declare interface BuiltinSvgOptions {
	/**
	 * minify an SVG `data:` URL as the `.svg` assets are, wherever that is shorter (default false)
	 */
	svg?: boolean;
}
declare class BunTargetPlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare abstract class ByTypeGenerator<
	TModule extends NormalModule = NormalModule
> extends Generator<TModule> {
	map: { [index: string]: undefined | Generator };
	generateError?: (
		error: Error,
		module: NormalModule,
		generateContext: GenerateContext
	) => null | Source;
}
declare const CIRCULAR_CONNECTION: unique symbol;

/**
 * Abstract cache interface backed by tapable hooks for reading, writing, idle
 * transitions, and shutdown across webpack cache implementations.
 */
declare class Cache {
	/**
	 * Initializes the cache lifecycle hooks implemented by cache backends.
	 */
	constructor();
	hooks: {
		get: AsyncSeriesBailHook<[string, null | Etag, GotHandler<any>[]], any>;
		store: AsyncParallelHook<[string, null | Etag, any]>;
		storeBuildDependencies: AsyncParallelHook<
			[Iterable<string>, Iterable<string>]
		>;
		beginIdle: SyncHook<[]>;
		endIdle: AsyncParallelHook<[]>;
		shutdown: AsyncParallelHook<[]>;
	};

	/**
	 * Retrieves a cached value and lets registered `gotHandlers` observe the
	 * result before the caller receives it.
	 */
	get<T>(
		identifier: string,
		etag: null | Etag,
		callback: CallbackCacheCache<T>
	): void;

	/**
	 * Stores a cache entry for the identifier and etag through the registered
	 * cache backend hooks.
	 */
	store<T>(
		identifier: string,
		etag: null | Etag,
		data: T,
		callback: CallbackCacheCache<void>
	): void;

	/**
	 * Persists the set of build dependencies required to determine whether the
	 * cache can be restored in a future compilation.
	 */
	storeBuildDependencies(
		dependencies: Iterable<string>,
		optionalDependencies: Iterable<string>,
		callback: CallbackCacheCache<void>
	): void;

	/**
	 * Signals that webpack is entering an idle phase and cache backends may flush
	 * or compact pending work.
	 */
	beginIdle(): void;

	/**
	 * Signals that webpack is leaving the idle phase and waits for cache
	 * backends to finish any asynchronous resume work.
	 */
	endIdle(callback: CallbackCacheCache<void>): void;

	/**
	 * Shuts down every registered cache backend and waits for cleanup to finish.
	 */
	shutdown(callback: CallbackCacheCache<void>): void;
	static STAGE_MEMORY: number;
	static STAGE_DEFAULT: number;
	static STAGE_DISK: number;
	static STAGE_NETWORK: number;
}
declare abstract class CacheFacade {
	/**
	 * Returns whether a cache backend is active.
	 */
	isEnabled(): boolean;

	/**
	 * Returns child cache.
	 */
	getChildCache(name: string): CacheFacade;

	/**
	 * Returns item cache.
	 */
	getItemCache(identifier: string, etag: null | Etag): ItemCacheFacade;

	/**
	 * Gets lazy hashed etag.
	 */
	getLazyHashedEtag(obj: HashableObject): Etag;

	/**
	 * Merges the provided values into a single result.
	 */
	mergeEtags(a: Etag, b: Etag): Etag;

	/**
	 * Returns value.
	 */
	get<T>(
		identifier: string,
		etag: null | Etag,
		callback: CallbackCacheCacheFacade<T>
	): void;

	/**
	 * Returns promise with the data.
	 */
	getPromise<T>(identifier: string, etag: null | Etag): Promise<T>;

	/**
	 * Processes the provided identifier.
	 */
	store<T>(
		identifier: string,
		etag: null | Etag,
		data: T,
		callback: CallbackCacheCacheFacade<void>
	): void;

	/**
	 * Stores the provided identifier.
	 */
	storePromise<T>(
		identifier: string,
		etag: null | Etag,
		data: T
	): Promise<void>;

	/**
	 * Processes the provided identifier.
	 */
	provide<T>(
		identifier: string,
		etag: null | Etag,
		computer: (callback: CallbackNormalErrorCache<T>) => void,
		callback: CallbackNormalErrorCache<T>
	): void;

	/**
	 * Returns promise with the data.
	 */
	providePromise<T>(
		identifier: string,
		etag: null | Etag,
		computer: () => T | Promise<T>
	): Promise<T>;
}

/**
 * Defines the cache group source type used by this module.
 */
declare interface CacheGroupSource {
	key: string;
	priority?: number;
	getName?: (
		module: Module,
		chunks: Chunk[],
		key: string
	) => undefined | string;
	chunksFilter?: (chunk: Chunk) => undefined | boolean;
	enforce?: boolean;
	minSize: SplitChunksSizes;
	minSizeReduction: SplitChunksSizes;
	minRemainingSize: SplitChunksSizes;
	enforceSizeThreshold: SplitChunksSizes;
	maxAsyncSize: SplitChunksSizes;
	maxInitialSize: SplitChunksSizes;
	minChunks?: number;
	maxAsyncRequests?: number;
	maxInitialRequests?: number;
	filename?:
		string | ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string);
	idHint?: string;
	automaticNameDelimiter?: string;
	reuseExistingChunk?: boolean;
	usedExports?: boolean;
}

/**
 * Defines the cache groups context type used by this module.
 */
declare interface CacheGroupsContext {
	moduleGraph: ModuleGraph;
	chunkGraph: ChunkGraph;
}
type CacheOptionsNormalized = false | FileCacheOptions | MemoryCacheOptions;
declare interface CachedData {
	/**
	 * source
	 */
	source?: boolean;

	/**
	 * buffer
	 */
	buffer: Buffer;

	/**
	 * size
	 */
	size?: number;

	/**
	 * maps
	 */
	maps: Map<string, BufferEntry>;

	/**
	 * hash
	 */
	hash?: (string | Buffer)[];
}
declare class CachedSource extends Source {
	constructor(source: Source | (() => Source), cachedData?: CachedData);
	getCachedData(): CachedData;
	originalLazy(): Source | (() => Source);
	original(): Source;
	streamChunks(
		options: OptionsStreamChunks,
		onChunk: (
			chunk: undefined | string,
			generatedLine: number,
			generatedColumn: number,
			sourceIndex: number,
			originalLine: number,
			originalColumn: number,
			nameIndex: number
		) => void,
		onSource: (
			sourceIndex: number,
			source: null | string,
			sourceContent?: string,
			scopeBindings?: Map<string, string>
		) => void,
		onName: (nameIndex: number, name: string) => void
	): GeneratedSourceInfo;
}
declare interface CalculatedStringResult {
	range?: [number, number];
	value: string;
	code: boolean;
	conditional: false | CalculatedStringResult[];
}
type CallExpression = SimpleCallExpression | NewExpression;
declare interface CallExpressionInfo {
	type: "call";
	call: CallExpression;
	calleeName: string;
	rootInfo: string | VariableInfo;
	getCalleeMembers: () => string[];
	name: string;
	getMembers: () => string[];
	getMembersOptionals: () => boolean[];
	getMemberRanges: () => [number, number][];
}

/**
 * Defines the callback callback.
 */
declare interface CallbackAsyncQueue<T> {
	(err?: null | WebpackError, result?: null | T): void;
}

/**
 * Creates a callback wrapper that waits for a fixed number of completions and
 * forwards the first error immediately.
 */
declare interface CallbackCacheCache<T> {
	/**
	 * Creates a callback wrapper that waits for a fixed number of completions and
	 * forwards the first error immediately.
	 */
	(err: null | Error, result?: T): void;
}

/**
 * Defines the callback cache callback.
 */
declare interface CallbackCacheCacheFacade<T> {
	(err?: null | Error, result?: null | T): void;
}

/**
 * Defines the callback normal error cache callback.
 */
declare interface CallbackNormalErrorCache<T> {
	(err?: null | Error, result?: T): void;
}

/**
 * Creates a multi compiler.
 */
declare interface CallbackWebpackFunction_1<T> {
	/**
	 * Creates a multi compiler.
	 */
	(err: null | Error, result?: T): void;
}

/**
 * Creates a multi compiler.
 */
declare interface CallbackWebpackFunction_2<T, R = void> {
	/**
	 * Creates a multi compiler.
	 */
	(err: null | Error, result?: T): R;
}

/**
 * A split `maxInitialRequests`/`maxAsyncRequests` refused, recorded for
 * `performance.splitChunksCapped`.
 */
declare interface CappedSplit {
	/**
	 * the cache group whose split was refused
	 */
	cacheGroup: string;

	/**
	 * the chunk it would have been taken out of
	 */
	chunk: Chunk;

	/**
	 * the option that refused it
	 */
	limit: "maxAsyncRequests" | "maxInitialRequests";

	/**
	 * the value that option had
	 */
	maxRequests: number;

	/**
	 * how many modules the split would have moved
	 */
	modules: number;
}
type Cell<T> = undefined | T;
type Child = string | Source | SourceLike;

/**
 * A Chunk is a unit of encapsulation for Modules.
 * Chunks are "rendered" into bundles that get emitted when the build completes.
 */
declare class Chunk {
	/**
	 * Creates an instance of Chunk.
	 */
	constructor(name?: null | string, backCompat?: boolean);
	id: null | string | number;
	ids: null | ChunkId[];
	debugId: number;
	name?: null | string;
	idNameHints: SortableSet<string>;
	preventIntegration: boolean;
	filenameTemplate?:
		string | ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string);
	cssFilenameTemplate?:
		string | ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string);
	runtime: RuntimeSpec;
	files: Set<string>;
	auxiliaryFiles: Set<string>;
	rendered: boolean;
	hash?: string;
	contentHash: Record<string, string>;
	contentHashFull: Record<string, string>;
	renderedHash?: string;
	chunkReason?: string;
	extraAsync: boolean;

	/**
	 * Returns entry module.
	 * @deprecated
	 */
	get entryModule(): Module;

	/**
	 * Checks whether this chunk has an entry module.
	 * @deprecated
	 */
	hasEntryModule(): boolean;

	/**
	 * Adds the provided module to the chunk.
	 * @deprecated
	 */
	addModule(module: Module): boolean;

	/**
	 * Removes the provided module from the chunk.
	 * @deprecated
	 */
	removeModule(module: Module): void;

	/**
	 * Gets the number of modules in this chunk.
	 * @deprecated
	 */
	getNumberOfModules(): number;

	/**
	 * @deprecated
	 */
	get modulesIterable(): Iterable<Module>;

	/**
	 * Compares this chunk with another chunk.
	 * @deprecated
	 */
	compareTo(otherChunk: Chunk): 0 | 1 | -1;

	/**
	 * Checks whether this chunk contains the module.
	 * @deprecated
	 */
	containsModule(module: Module): boolean;

	/**
	 * Returns the modules for this chunk.
	 * @deprecated
	 */
	getModules(): Module[];

	/**
	 * Removes this chunk from the chunk graph and chunk groups.
	 * @deprecated
	 */
	remove(): void;

	/**
	 * Moves a module from this chunk to another chunk.
	 * @deprecated
	 */
	moveModule(module: Module, otherChunk: Chunk): void;

	/**
	 * Integrates another chunk into this chunk when possible.
	 * @deprecated
	 */
	integrate(otherChunk: Chunk): boolean;

	/**
	 * Checks whether this chunk can be integrated with another chunk.
	 * @deprecated
	 */
	canBeIntegrated(otherChunk: Chunk): boolean;

	/**
	 * Checks whether this chunk is empty.
	 * @deprecated
	 */
	isEmpty(): boolean;

	/**
	 * Returns the total size of all modules in this chunk.
	 * @deprecated
	 */
	modulesSize(): number;

	/**
	 * Returns the estimated size for the requested source type.
	 * @deprecated
	 */
	size(options?: ChunkSizeOptions): number;

	/**
	 * Returns the integrated size with another chunk.
	 * @deprecated
	 */
	integratedSize(otherChunk: Chunk, options: ChunkSizeOptions): number;

	/**
	 * Gets chunk module maps.
	 * @deprecated
	 */
	getChunkModuleMaps(filterFn: (m: Module) => boolean): ChunkModuleMaps;

	/**
	 * Checks whether this chunk contains a matching module in the graph.
	 * @deprecated
	 */
	hasModuleInGraph(
		filterFn: (m: Module) => boolean,
		filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
	): boolean;

	/**
	 * Returns the chunk map information.
	 * @deprecated
	 */
	getChunkMaps(realHash: boolean): ChunkMaps;

	/**
	 * Checks whether this chunk has runtime.
	 */
	hasRuntime(): boolean;

	/**
	 * Returns whether this chunk carries a hot update rather than regular output.
	 */
	isHotUpdate(): boolean;

	/**
	 * Checks whether it can be initial.
	 */
	canBeInitial(): boolean;

	/**
	 * Checks whether this chunk is only initial.
	 */
	isOnlyInitial(): boolean;

	/**
	 * Gets entry options.
	 */
	getEntryOptions(): undefined | EntryOptions;

	/**
	 * Adds the provided chunk group to the chunk.
	 */
	addGroup(chunkGroup: ChunkGroup): void;

	/**
	 * Removes the provided chunk group from the chunk.
	 */
	removeGroup(chunkGroup: ChunkGroup): void;

	/**
	 * Checks whether this chunk is in group.
	 */
	isInGroup(chunkGroup: ChunkGroup): boolean;

	/**
	 * Gets number of groups.
	 */
	getNumberOfGroups(): number;

	/**
	 * Gets groups iterable.
	 */
	get groupsIterable(): SortableSet<ChunkGroup>;

	/**
	 * Disconnects from groups.
	 */
	disconnectFromGroups(): void;

	/**
	 * Processes the provided new chunk.
	 */
	split(newChunk: Chunk): void;

	/**
	 * Updates the hash with the data contributed by this instance.
	 */
	updateHash(hash: Hash, chunkGraph: ChunkGraph): void;

	/**
	 * Gets all async chunks.
	 */
	getAllAsyncChunks(): Set<Chunk>;

	/**
	 * Gets all initial chunks.
	 */
	getAllInitialChunks(): Set<Chunk>;

	/**
	 * Gets all referenced chunks.
	 */
	getAllReferencedChunks(): Set<Chunk>;

	/**
	 * Gets all referenced async entrypoints.
	 */
	getAllReferencedAsyncEntrypoints(): Set<Entrypoint>;

	/**
	 * Checks whether this chunk has async chunks.
	 */
	hasAsyncChunks(): boolean;

	/**
	 * Gets child ids by orders.
	 */
	getChildIdsByOrders(
		chunkGraph: ChunkGraph,
		filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
	): Record<string, ChunkId[]>;

	/**
	 * Gets children of type in order.
	 */
	getChildrenOfTypeInOrder(
		chunkGraph: ChunkGraph,
		type: string
	): undefined | ChunkChildOfTypeInOrder[];

	/**
	 * Gets child ids by orders map.
	 */
	getChildIdsByOrdersMap(
		chunkGraph: ChunkGraph,
		includeDirectChildren?: boolean,
		filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
	): ChunkChildIdsByOrdersMapByData;

	/**
	 * Checks whether this chunk contains the chunk graph.
	 */
	hasChildByOrder(
		chunkGraph: ChunkGraph,
		type: string,
		includeDirectChildren?: boolean,
		filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
	): boolean;
}
declare interface ChunkChildIdsByOrdersMap {
	[index: string]: ChunkId[];
}
declare interface ChunkChildIdsByOrdersMapByData {
	[index: string]: ChunkChildIdsByOrdersMap;
}
declare interface ChunkChildOfTypeInOrder {
	onChunks: Chunk[];
	chunks: Set<Chunk>;
}
declare interface ChunkConditionMap {
	[index: number]: boolean;
	[index: string]: boolean;
}
type ChunkFilenameTemplate =
	string | ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string);
declare class ChunkGraph {
	/**
	 * Creates an instance of ChunkGraph.
	 */
	constructor(moduleGraph: ModuleGraph, hashFunction?: HashFunction);
	moduleGraph: ModuleGraph;
	buildTimeExecution: boolean;

	/**
	 * Connects chunk and module.
	 */
	connectChunkAndModule(chunk: Chunk, module: Module): void;

	/**
	 * Disconnects chunk and module.
	 */
	disconnectChunkAndModule(chunk: Chunk, module: Module): void;

	/**
	 * Processes the provided chunk.
	 */
	disconnectChunk(chunk: Chunk): void;

	/**
	 * Processes the provided chunk.
	 */
	attachModules(chunk: Chunk, modules: Iterable<Module>): void;

	/**
	 * Attach runtime modules.
	 */
	attachRuntimeModules(chunk: Chunk, modules: Iterable<RuntimeModule>): void;

	/**
	 * Attach full hash modules.
	 */
	attachFullHashModules(chunk: Chunk, modules: Iterable<RuntimeModule>): void;

	/**
	 * Attach dependent hash modules.
	 */
	attachDependentHashModules(
		chunk: Chunk,
		modules: Iterable<RuntimeModule>
	): void;

	/**
	 * Processes the provided old module.
	 */
	replaceModule(oldModule: Module, newModule: Module): void;

	/**
	 * Checks whether this chunk graph is module in chunk.
	 */
	isModuleInChunk(module: Module, chunk: Chunk): boolean;

	/**
	 * Checks whether this chunk graph is module in chunk group.
	 */
	isModuleInChunkGroup(module: Module, chunkGroup: ChunkGroup): boolean;

	/**
	 * Checks whether this chunk graph is entry module.
	 */
	isEntryModule(module: Module): boolean;

	/**
	 * Gets module chunks iterable.
	 */
	getModuleChunksIterable(module: Module): Iterable<Chunk>;

	/**
	 * Gets ordered module chunks iterable.
	 */
	getOrderedModuleChunksIterable(
		module: Module,
		sortFn: (a: Chunk, b: Chunk) => 0 | 1 | -1
	): Iterable<Chunk>;

	/**
	 * Gets module chunks.
	 */
	getModuleChunks(module: Module): Chunk[];

	/**
	 * Gets number of module chunks.
	 */
	getNumberOfModuleChunks(module: Module): number;

	/**
	 * Gets module runtimes.
	 */
	getModuleRuntimes(module: Module): RuntimeSpecSet;

	/**
	 * Gets number of chunk modules.
	 */
	getNumberOfChunkModules(chunk: Chunk): number;

	/**
	 * Gets number of chunk full hash modules.
	 */
	getNumberOfChunkFullHashModules(chunk: Chunk): number;

	/**
	 * Gets chunk modules iterable.
	 */
	getChunkModulesIterable(chunk: Chunk): Iterable<Module>;

	/**
	 * Gets chunk modules iterable by source type.
	 */
	getChunkModulesIterableBySourceType(
		chunk: Chunk,
		sourceType: string
	): undefined | Iterable<Module>;

	/**
	 * Sets chunk module source types.
	 */
	setChunkModuleSourceTypes(
		chunk: Chunk,
		module: Module,
		sourceTypes: ReadonlySet<string>
	): void;

	/**
	 * Gets chunk module source types.
	 */
	getChunkModuleSourceTypes(chunk: Chunk, module: Module): ReadonlySet<string>;

	/**
	 * Gets module source types.
	 */
	getModuleSourceTypes(module: Module): ReadonlySet<string>;

	/**
	 * Gets ordered chunk modules iterable.
	 */
	getOrderedChunkModulesIterable(
		chunk: Chunk,
		comparator: (a: Module, b: Module) => 0 | 1 | -1
	): Iterable<Module>;

	/**
	 * Gets ordered chunk modules iterable by source type.
	 */
	getOrderedChunkModulesIterableBySourceType(
		chunk: Chunk,
		sourceType: string,
		comparator: (a: Module, b: Module) => 0 | 1 | -1
	): undefined | Iterable<Module>;

	/**
	 * Gets chunk modules.
	 */
	getChunkModules(chunk: Chunk): Module[];

	/**
	 * Gets ordered chunk modules.
	 */
	getOrderedChunkModules(
		chunk: Chunk,
		comparator: (a: Module, b: Module) => 0 | 1 | -1
	): Module[];

	/**
	 * Gets chunk module id map.
	 */
	getChunkModuleIdMap(
		chunk: Chunk,
		filterFn: (m: Module) => boolean,
		includeAllChunks?: boolean
	): ChunkModuleIdMapEs5Alias_2;

	/**
	 * Gets chunk module rendered hash map.
	 */
	getChunkModuleRenderedHashMap(
		chunk: Chunk,
		filterFn: (m: Module) => boolean,
		hashLength?: number,
		includeAllChunks?: boolean
	): ChunkModuleHashMap;

	/**
	 * Gets chunk condition map.
	 */
	getChunkConditionMap(
		chunk: Chunk,
		filterFn: (c: Chunk, chunkGraph: ChunkGraph) => boolean
	): ChunkConditionMap;

	/**
	 * Checks whether this chunk graph contains the chunk.
	 */
	hasModuleInGraph(
		chunk: Chunk,
		filterFn: (m: Module) => boolean,
		filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean
	): boolean;

	/**
	 * Compares the provided values and returns their ordering.
	 */
	compareChunks(chunkA: Chunk, chunkB: Chunk): 0 | 1 | -1;

	/**
	 * Gets chunk modules size.
	 */
	getChunkModulesSize(chunk: Chunk): number;

	/**
	 * Gets chunk modules sizes.
	 */
	getChunkModulesSizes(chunk: Chunk): Record<string, number>;

	/**
	 * Gets chunk root modules.
	 */
	getChunkRootModules(chunk: Chunk): Module[];

	/**
	 * Returns total size of the chunk.
	 */
	getChunkSize(chunk: Chunk, options?: ChunkSizeOptions): number;

	/**
	 * Gets integrated chunks size.
	 */
	getIntegratedChunksSize(
		chunkA: Chunk,
		chunkB: Chunk,
		options?: ChunkSizeOptions
	): number;

	/**
	 * Checks whether it can chunks be integrated.
	 */
	canChunksBeIntegrated(chunkA: Chunk, chunkB: Chunk): boolean;

	/**
	 * Processes the provided chunk a.
	 */
	integrateChunks(chunkA: Chunk, chunkB: Chunk): void;

	/**
	 * Upgrade dependent to full hash modules.
	 */
	upgradeDependentToFullHashModules(chunk: Chunk): void;

	/**
	 * Checks whether this chunk graph is entry module in chunk.
	 */
	isEntryModuleInChunk(module: Module, chunk: Chunk): boolean;

	/**
	 * Connects chunk and entry module.
	 */
	connectChunkAndEntryModule(
		chunk: Chunk,
		module: Module,
		entrypoint: Entrypoint
	): void;

	/**
	 * Connects chunk and runtime module.
	 */
	connectChunkAndRuntimeModule(chunk: Chunk, module: RuntimeModule): void;

	/**
	 * Adds full hash module to chunk.
	 */
	addFullHashModuleToChunk(chunk: Chunk, module: RuntimeModule): void;

	/**
	 * Adds dependent hash module to chunk.
	 */
	addDependentHashModuleToChunk(chunk: Chunk, module: RuntimeModule): void;

	/**
	 * Disconnects chunk and entry module.
	 */
	disconnectChunkAndEntryModule(chunk: Chunk, module: Module): void;

	/**
	 * Disconnects chunk and runtime module.
	 */
	disconnectChunkAndRuntimeModule(chunk: Chunk, module: RuntimeModule): void;

	/**
	 * Disconnects entry module.
	 */
	disconnectEntryModule(module: Module): void;

	/**
	 * Disconnects entries.
	 */
	disconnectEntries(chunk: Chunk): void;

	/**
	 * Gets number of entry modules.
	 */
	getNumberOfEntryModules(chunk: Chunk): number;

	/**
	 * Gets number of runtime modules.
	 */
	getNumberOfRuntimeModules(chunk: Chunk): number;

	/**
	 * Gets chunk entry modules iterable.
	 */
	getChunkEntryModulesIterable(chunk: Chunk): Iterable<Module>;

	/**
	 * Gets chunk entry dependent chunks iterable.
	 */
	getChunkEntryDependentChunksIterable(chunk: Chunk): Iterable<Chunk>;

	/**
	 * Gets runtime chunk dependent chunks iterable.
	 */
	getRuntimeChunkDependentChunksIterable(chunk: Chunk): Iterable<Chunk>;

	/**
	 * Checks whether this chunk graph contains the chunk.
	 */
	hasChunkEntryDependentChunks(chunk: Chunk): boolean;

	/**
	 * Gets chunk runtime modules iterable.
	 */
	getChunkRuntimeModulesIterable(chunk: Chunk): Iterable<RuntimeModule>;

	/**
	 * Gets chunk runtime modules in order.
	 */
	getChunkRuntimeModulesInOrder(chunk: Chunk): RuntimeModule[];

	/**
	 * Gets chunk full hash modules iterable.
	 */
	getChunkFullHashModulesIterable(
		chunk: Chunk
	): undefined | Iterable<RuntimeModule>;

	/**
	 * Gets chunk full hash modules set.
	 */
	getChunkFullHashModulesSet(
		chunk: Chunk
	): undefined | ReadonlySet<RuntimeModule>;

	/**
	 * Gets chunk dependent hash modules iterable.
	 */
	getChunkDependentHashModulesIterable(
		chunk: Chunk
	): undefined | Iterable<RuntimeModule>;

	/**
	 * Gets chunk entry modules with chunk group iterable.
	 */
	getChunkEntryModulesWithChunkGroupIterable(
		chunk: Chunk
	): Iterable<[Module, undefined | Entrypoint]>;

	/**
	 * Gets block chunk group.
	 */
	getBlockChunkGroup(depBlock: AsyncDependenciesBlock): undefined | ChunkGroup;

	/**
	 * Connects block and chunk group.
	 */
	connectBlockAndChunkGroup(
		depBlock: AsyncDependenciesBlock,
		chunkGroup: ChunkGroup
	): void;

	/**
	 * Disconnects chunk group.
	 */
	disconnectChunkGroup(chunkGroup: ChunkGroup): void;

	/**
	 * Returns the id of the module.
	 */
	getModuleId(module: Module): null | string | number;

	/**
	 * Updates module id using the provided module.
	 */
	setModuleId(module: Module, id: ModuleId): void;

	/**
	 * Returns the id of the runtime.
	 */
	getRuntimeId(runtime: string): RuntimeId;

	/**
	 * Updates runtime id using the provided runtime.
	 */
	setRuntimeId(runtime: string, id: RuntimeId): void;

	/**
	 * Checks whether this chunk graph contains the module.
	 */
	hasModuleHashes(module: Module, runtime: RuntimeSpec): boolean;

	/**
	 * Returns hash.
	 */
	getModuleHash(module: Module, runtime: RuntimeSpec): string;

	/**
	 * Gets rendered module hash.
	 */
	getRenderedModuleHash(module: Module, runtime: RuntimeSpec): string;

	/**
	 * Sets module hashes.
	 */
	setModuleHashes(
		module: Module,
		runtime: RuntimeSpec,
		hash: string,
		renderedHash: string
	): void;

	/**
	 * Adds module runtime requirements.
	 */
	addModuleRuntimeRequirements(
		module: Module,
		runtime: RuntimeSpec,
		items: Set<string>,
		transferOwnership?: boolean
	): void;

	/**
	 * Adds chunk runtime requirements.
	 */
	addChunkRuntimeRequirements(chunk: Chunk, items: Set<string>): void;

	/**
	 * Adds tree runtime requirements.
	 */
	addTreeRuntimeRequirements(chunk: Chunk, items: Iterable<string>): void;

	/**
	 * Gets module runtime requirements.
	 */
	getModuleRuntimeRequirements(
		module: Module,
		runtime: RuntimeSpec
	): ReadonlySet<string>;

	/**
	 * Gets chunk runtime requirements.
	 */
	getChunkRuntimeRequirements(chunk: Chunk): ReadonlySet<string>;

	/**
	 * Gets module graph hash.
	 */
	getModuleGraphHash(
		module: Module,
		runtime: RuntimeSpec,
		withConnections?: boolean
	): string;

	/**
	 * Gets module graph hash big int.
	 */
	getModuleGraphHashBigInt(
		module: Module,
		runtime: RuntimeSpec,
		withConnections?: boolean
	): bigint;

	/**
	 * Gets tree runtime requirements.
	 */
	getTreeRuntimeRequirements(chunk: Chunk): ReadonlySet<string>;

	/**
	 * Gets chunk graph for module.
	 * @deprecated
	 */
	static getChunkGraphForModule(
		module: Module,
		deprecateMessage: string,
		deprecationCode: string
	): ChunkGraph;

	/**
	 * Sets chunk graph for module.
	 * @deprecated
	 */
	static setChunkGraphForModule(module: Module, chunkGraph: ChunkGraph): void;

	/**
	 * Clear chunk graph for module.
	 * @deprecated
	 */
	static clearChunkGraphForModule(module: Module): void;

	/**
	 * Gets chunk graph for chunk.
	 * @deprecated
	 */
	static getChunkGraphForChunk(
		chunk: Chunk,
		deprecateMessage: string,
		deprecationCode: string
	): ChunkGraph;

	/**
	 * Sets chunk graph for chunk.
	 * @deprecated
	 */
	static setChunkGraphForChunk(chunk: Chunk, chunkGraph: ChunkGraph): void;

	/**
	 * Clear chunk graph for chunk.
	 * @deprecated
	 */
	static clearChunkGraphForChunk(chunk: Chunk): void;
}

/**
 * Represents a connected group of chunks along with the parent/child
 * relationships, async blocks, and traversal metadata webpack tracks for it.
 */
declare abstract class ChunkGroup {
	groupDebugId: number;
	options: ChunkGroupOptions;
	chunks: Chunk[];
	origins: OriginRecord[];
	index?: number;

	/**
	 * Merges additional options into the chunk group.
	 * Order-based options are combined by taking the higher priority, while
	 * unsupported conflicts surface as an explicit error.
	 */
	addOptions(options: ChunkGroupOptions): void;

	/**
	 * Returns the configured name of the chunk group, if one was assigned.
	 * Updates the configured name of the chunk group.
	 */
	name?: null | string;

	/**
	 * Returns a debug-only identifier derived from the group's member chunk
	 * debug ids. This is primarily useful in diagnostics and assertions.
	 */
	get debugId(): string;

	/**
	 * Returns an identifier derived from the ids of the chunks currently in
	 * the group.
	 */
	get id(): string;

	/**
	 * Moves a chunk to the front of the group or inserts it when it is not
	 * already present.
	 */
	unshiftChunk(chunk: Chunk): boolean;

	/**
	 * Inserts a chunk directly before another chunk that already belongs to the
	 * group, preserving the rest of the ordering.
	 */
	insertChunk(chunk: Chunk, before: Chunk): boolean;

	/**
	 * Appends a chunk to the group when it is not already a member.
	 */
	pushChunk(chunk: Chunk): boolean;

	/**
	 * Replaces one member chunk with another while preserving the group's
	 * ordering and avoiding duplicates.
	 */
	replaceChunk(oldChunk: Chunk, newChunk: Chunk): undefined | boolean;

	/**
	 * Removes a chunk from this group.
	 */
	removeChunk(chunk: Chunk): boolean;

	/**
	 * Indicates whether this chunk group is loaded as part of the initial page
	 * load instead of being created lazily.
	 */
	isInitial(): boolean;

	/**
	 * Returns whether this chunk group is an entrypoint, an async one (e.g. a worker) included.
	 */
	isEntrypoint(): boolean;

	/**
	 * Adds a child chunk group to the current group.
	 */
	addChild(group: ChunkGroup): boolean;

	/**
	 * Returns the child chunk groups reachable from this group.
	 */
	getChildren(): ChunkGroup[];
	getNumberOfChildren(): number;
	get childrenIterable(): SortableSet<ChunkGroup>;

	/**
	 * Removes a child chunk group and clears the corresponding parent link on
	 * the removed child.
	 */
	removeChild(group: ChunkGroup): boolean;

	/**
	 * Records a parent chunk group relationship.
	 */
	addParent(parentChunk: ChunkGroup): boolean;

	/**
	 * Returns the parent chunk groups that can lead to this group.
	 */
	getParents(): ChunkGroup[];
	getNumberOfParents(): number;

	/**
	 * Checks whether the provided group is registered as a parent.
	 */
	hasParent(parent: ChunkGroup): boolean;
	get parentsIterable(): SortableSet<ChunkGroup>;

	/**
	 * Removes a parent chunk group and clears the reverse child relationship.
	 */
	removeParent(chunkGroup: ChunkGroup): boolean;

	/**
	 * Registers an async entrypoint that is rooted in this chunk group.
	 */
	addAsyncEntrypoint(entrypoint: Entrypoint): boolean;
	get asyncEntrypointsIterable(): SortableSet<ChunkGroup>;

	/**
	 * Returns the async dependency blocks that create or reference this group.
	 */
	getBlocks(): AsyncDependenciesBlock[];
	getNumberOfBlocks(): number;

	/**
	 * Checks whether an async dependency block is associated with this group.
	 */
	hasBlock(block: AsyncDependenciesBlock): boolean;

	/**
	 * Exposes the group's async dependency blocks as an iterable.
	 */
	get blocksIterable(): Iterable<AsyncDependenciesBlock>;

	/**
	 * Associates an async dependency block with this chunk group.
	 */
	addBlock(block: AsyncDependenciesBlock): boolean;

	/**
	 * Records where this chunk group originated from in user code.
	 * The origin is used for diagnostics, ordering, and reporting.
	 */
	addOrigin(
		module: null | Module,
		loc: DependencyLocation,
		request: string
	): void;

	/**
	 * Collects the emitted files produced by every chunk in the group.
	 */
	getFiles(): string[];

	/**
	 * Disconnects this group from its parents, children, and chunks.
	 * Child groups are reconnected to this group's parents so the surrounding
	 * graph remains intact after removal.
	 */
	remove(): void;
	sortItems(): void;

	/**
	 * Sorting predicate which allows current ChunkGroup to be compared against another.
	 * Sorting values are based off of number of chunks in ChunkGroup.
	 */
	compareTo(chunkGraph: ChunkGraph, otherGroup: ChunkGroup): 0 | 1 | -1;

	/**
	 * Aggregates per-block `*Order` options for the blocks that bridge this
	 * chunk group to the given child chunk group. `*Order` options are tied to
	 * the originating `import()` call and must not be sourced from the child's
	 * shared options, otherwise a webpackPrefetch/Preload directive from one
	 * parent would leak into other parents that share the child by name.
	 */
	getChildOrderOptions(
		childGroup: ChunkGroup,
		chunkGraph: ChunkGraph
	): Record<string, number>;

	/**
	 * Groups child chunk groups by their `*Order` options and sorts each group
	 * by descending order and deterministic chunk-group comparison.
	 */
	getChildrenByOrders(
		moduleGraph: ModuleGraph,
		chunkGraph: ChunkGraph
	): Record<string, ChunkGroup[]>;

	/**
	 * Stores the module's top-down traversal index within this group.
	 */
	setModulePreOrderIndex(module: Module, index: number): void;

	/**
	 * Returns the module's top-down traversal index within this group.
	 */
	getModulePreOrderIndex(module: Module): undefined | number;

	/**
	 * Stores the module's bottom-up traversal index within this group.
	 */
	setModulePostOrderIndex(module: Module, index: number): void;

	/**
	 * Returns the module's bottom-up traversal index within this group.
	 */
	getModulePostOrderIndex(module: Module): undefined | number;
	checkConstraints(): void;
	getModuleIndex: (module: Module) => undefined | number;
	getModuleIndex2: (module: Module) => undefined | number;
}
declare interface ChunkGroupInfoWithName {
	name: string;
	chunkGroup: ChunkGroup;
}
type ChunkGroupOptions = RawChunkGroupOptions & { name?: null | string };

/**
 * Defines the chunk hash context type used by this module.
 */
declare interface ChunkHashContext {
	/**
	 * results of code generation
	 */
	codeGenerationResults: CodeGenerationResults;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;
}
declare interface ChunkHashes {
	[index: number]: string;
	[index: string]: string;
}
type ChunkId = string | number;

/**
 * Defines the chunk maps type used by this module.
 * @deprecated
 */
declare interface ChunkMaps {
	hash: Record<ChunkId, string>;
	contentHash: Record<ChunkId, Record<string, string>>;
	name: Record<ChunkId, string>;
}
declare interface ChunkModuleHashMap {
	[index: number]: IdToHashMap;
	[index: string]: IdToHashMap;
}
declare interface ChunkModuleHashes {
	[index: string]: string;
}

/**
 * Defines the chunk module id map type used by this module.
 */
declare interface ChunkModuleIdMapEs5Alias_1 {
	[index: number]: ChunkId[];
	[index: string]: ChunkId[];
}
declare interface ChunkModuleIdMapEs5Alias_2 {
	[index: number]: ModuleId[];
	[index: string]: ModuleId[];
}
declare class ChunkModuleIdRangePlugin {
	/**
	 * Creates an instance of ChunkModuleIdRangePlugin.
	 */
	constructor(options: ChunkModuleIdRangePluginOptions);
	options: ChunkModuleIdRangePluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the chunk module id range plugin options type used by this module.
 */
declare interface ChunkModuleIdRangePluginOptions {
	/**
	 * the chunk name
	 */
	name: string;

	/**
	 * order
	 */
	order?: "index" | "index2" | "preOrderIndex" | "postOrderIndex";

	/**
	 * start id
	 */
	start?: number;

	/**
	 * end id
	 */
	end?: number;
}
declare interface ChunkModuleIds {
	[index: number]: ModuleId[];
	[index: string]: ModuleId[];
}

/**
 * Defines the chunk module maps type used by this module.
 * @deprecated
 */
declare interface ChunkModuleMaps {
	id: ChunkModuleIdMapEs5Alias_1;
	hash: chunkModuleHashMap;
}
type ChunkName = null | string;

/**
 * Defines the chunk path data type used by this module.
 */
declare interface ChunkPathData {
	id: string | number;
	name?: string;
	hash: string;
	hashWithLength?: (length: number) => string;

	/**
	 * builds `[chunkhash:<digest>]` per chunk in the runtime chunk-filename map
	 */
	hashWithDigest?: (digest: string, length?: number) => string;
	contentHash?: Record<string, string>;
	contentHashWithLength?: Record<string, (length: number) => string>;

	/**
	 * builds `[contenthash:<digest>]` per chunk in the runtime chunk-filename map
	 */
	contentHashWithDigest?: Record<
		string,
		(digest: string, length?: number) => string
	>;
}

/**
 * Adds runtime support for chunk prefetch and preload relationships discovered
 * in the chunk graph.
 */
declare class ChunkPrefetchPreloadPlugin {
	constructor();

	/**
	 * Registers compilation hooks that emit the runtime modules responsible for
	 * scheduling chunk prefetch and preload requests.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the chunk render context type used by this module.
 */
declare interface ChunkRenderContextCssModulesPlugin {
	/**
	 * the chunk
	 */
	chunk?: Chunk;

	/**
	 * the chunk graph
	 */
	chunkGraph?: ChunkGraph;

	/**
	 * results of code generation
	 */
	codeGenerationResults?: CodeGenerationResults;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * undo path to css file
	 */
	undoPath: string;

	/**
	 * compilation hash
	 */
	hash?: string;

	/**
	 * moduleFactoryCache
	 */
	moduleFactoryCache: WeakMap<Source, ModuleFactoryCacheEntry>;

	/**
	 * content
	 */
	moduleSourceContent: Source;
}

/**
 * Defines the chunk render context type used by this module.
 */
declare interface ChunkRenderContextJavascriptModulesPlugin {
	/**
	 * the chunk
	 */
	chunk: Chunk;

	/**
	 * the dependency templates
	 */
	dependencyTemplates: DependencyTemplates;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * results of code generation
	 */
	codeGenerationResults: CodeGenerationResults;

	/**
	 * init fragments for the chunk
	 */
	chunkInitFragments: InitFragment<ChunkRenderContextJavascriptModulesPlugin>[];

	/**
	 * rendering in strict context
	 */
	strictMode?: boolean;

	/**
	 * entry module inlined at the chunk top level instead of the registry
	 */
	inlinedEntryModule?: Module;

	/**
	 * rendered body of the inlined entry module
	 */
	inlinedEntrySource?: Source;
}
declare interface ChunkRuntime {
	[index: number]: string;
	[index: string]: string;
}

/**
 * Represents the module hash info runtime component.
 */
declare interface ChunkSizeOptions {
	/**
	 * constant overhead for a chunk
	 */
	chunkOverhead?: number;

	/**
	 * multiplicator for initial chunks
	 */
	entryChunkMultiplicator?: number;
}
declare abstract class ChunkTemplate {
	hooks: Readonly<{
		renderManifest: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					renderManifestEntries: RenderManifestEntry[],
					renderManifestOptions: RenderManifestOptions
				) => RenderManifestEntry[]
			) => void;
		};
		modules: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					source: Source,
					moduleTemplate: ModuleTemplate,
					renderContext: RenderContextJavascriptModulesPlugin
				) => Source
			) => void;
		};
		render: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					source: Source,
					moduleTemplate: ModuleTemplate,
					renderContext: RenderContextJavascriptModulesPlugin
				) => Source
			) => void;
		};
		renderWithEntry: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (source: Source, chunk: Chunk) => Source
			) => void;
		};
		hash: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (hash: Hash) => void
			) => void;
		};
		hashForChunk: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					hash: Hash,
					chunk: Chunk,
					chunkHashContext: ChunkHashContext
				) => void
			) => void;
		};
	}>;
	get outputOptions(): OutputNormalizedWithDefaults;
}

/**
 * Advanced options for cleaning assets.
 */
declare interface CleanOptions {
	/**
	 * Log the assets that should be removed instead of deleting them.
	 */
	dry?: boolean;

	/**
	 * Keep these assets.
	 */
	keep?:
		string | RegExp | GlobCondition | ((path: string) => undefined | boolean);
}
declare class CleanPlugin {
	constructor(options?: CleanOptions);
	options: CleanOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
	static getCompilationHooks: (compilation: Compilation) => {
		/**
		 * When returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config.
		 * @since 5.20.0
		 */
		keep: SyncBailHook<[string], boolean | void>;
	};
}
declare interface ClearCacheOptions {
	/**
	 * drop cached source maps (default `true`)
	 */
	maps?: boolean;

	/**
	 * drop cached source/buffer copies (default `true`)
	 */
	source?: boolean;

	/**
	 * drop the parsed object form of cached source maps on `SourceMapSource` instances (default `false` — re-parsing JSON is significantly more expensive than `toString`). Only takes effect when a serialized form (buffer or string) is also retained, so the data remains recoverable.
	 */
	parsedMap?: boolean;
}

/**
 * Defines the code gen map overloads type used by this module.
 */
declare interface CodeGenMapOverloads {
	get: <K extends string>(key: K) => undefined | CodeGenValue<K>;
	set: <K extends string>(
		key: K,
		value: CodeGenValue<K>
	) => CodeGenerationResultData;
	has: <K extends string>(key: K) => boolean;
	delete: <K extends string>(key: K) => boolean;
}
type CodeGenValue<K extends string> = K extends
	| "filename"
	| "assetInfo"
	| "share-init"
	| "topLevelDeclarations"
	| "freeNames"
	| "chunkInitFragments"
	| "externalReexport"
	| "exportsSource"
	| "exportsBindingSource"
	| "exportsFinalName"
	| "url"
	| "fullContentHash"
	? AllCodeGenerationSchemas[K]
	: any;

/**
 * Defines the code generation context type used by this module.
 */
declare interface CodeGenerationContext {
	/**
	 * the dependency templates
	 */
	dependencyTemplates: DependencyTemplates;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * the runtimes code should be generated for
	 */
	runtime: RuntimeSpec;

	/**
	 * all runtimes code should be generated for
	 */
	runtimes: RuntimeSpec[];

	/**
	 * when in concatenated module, information about other concatenated modules
	 */
	concatenationScope?: ConcatenationScope;

	/**
	 * code generation results of other modules (need to have a codeGenerationDependency to use that)
	 */
	codeGenerationResults?: CodeGenerationResults;

	/**
	 * the compilation
	 */
	compilation?: Compilation;

	/**
	 * source types
	 */
	sourceTypes?: ReadonlySet<string>;
}
declare interface CodeGenerationJob {
	module: Module;
	hash: string;
	runtime: RuntimeSpec;
	runtimes: RuntimeSpec[];
}

/**
 * Defines the code generation result type used by this module.
 */
declare interface CodeGenerationResult {
	/**
	 * the resulting sources for all source types
	 */
	sources: Map<string, Source>;

	/**
	 * the resulting data for all source types
	 */
	data?: CodeGenerationResultData;

	/**
	 * the runtime requirements
	 */
	runtimeRequirements: null | ReadonlySet<string>;

	/**
	 * a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
	 */
	hash?: string;
}
type CodeGenerationResultData = Omit<
	Map<string, any>,
	"get" | "set" | "has" | "delete"
> &
	CodeGenMapOverloads;

/**
 * Stores code generation results keyed by module and runtime so later stages
 * can retrieve emitted sources, metadata, and derived hashes.
 */
declare abstract class CodeGenerationResults {
	map: Map<Module, RuntimeSpecMap<CodeGenerationResult, CodeGenerationResult>>;

	/**
	 * Returns the code generation result for a module/runtime pair, rejecting
	 * ambiguous lookups where no unique runtime-independent result exists.
	 */
	get(module: Module, runtime: RuntimeSpec): CodeGenerationResult;

	/**
	 * Reports whether a module has a stored result for the requested runtime, or
	 * a single unambiguous result when no runtime is specified.
	 */
	has(module: Module, runtime: RuntimeSpec): boolean;

	/**
	 * Returns a generated source of the requested source type from a stored code
	 * generation result.
	 */
	getSource(module: Module, runtime: RuntimeSpec, sourceType: string): Source;

	/**
	 * Returns the runtime requirements captured during code generation for the
	 * requested module/runtime pair.
	 */
	getRuntimeRequirements(
		module: Module,
		runtime: RuntimeSpec
	): null | ReadonlySet<string>;

	/**
	 * Returns an arbitrary metadata entry recorded during code generation.
	 */
	getData(module: Module, runtime: RuntimeSpec, key: string): any;

	/**
	 * Returns a stable hash for the generated sources and runtime requirements,
	 * computing and caching it on first access.
	 */
	getHash(module: Module, runtime: RuntimeSpec): string;

	/**
	 * Stores a code generation result for a module/runtime pair, creating the
	 * per-module runtime map when needed.
	 */
	add(module: Module, runtime: RuntimeSpec, result: CodeGenerationResult): void;
}
type CodeValue =
	| undefined
	| null
	| string
	| number
	| bigint
	| boolean
	| Function
	| RegExp
	| RuntimeValue
	| {
			[index: string]: RecursiveArrayOrRecord<
				| undefined
				| null
				| string
				| number
				| bigint
				| boolean
				| Function
				| RegExp
				| RuntimeValue
			>;
	  }
	| RecursiveArrayOrRecord<
			| undefined
			| null
			| string
			| number
			| bigint
			| boolean
			| Function
			| RegExp
			| RuntimeValue
	  >[];
type CodeValuePrimitive =
	undefined | null | string | number | bigint | boolean | Function | RegExp;
type CollectedComment = CommentImport & { start: number; end: number };
declare interface Colors {
	reset: (value?: any) => string;
	bold: (value?: any) => string;
	dim: (value?: any) => string;
	italic: (value?: any) => string;
	underline: (value?: any) => string;
	inverse: (value?: any) => string;
	hidden: (value?: any) => string;
	strikethrough: (value?: any) => string;
	black: (value?: any) => string;
	red: (value?: any) => string;
	green: (value?: any) => string;
	yellow: (value?: any) => string;
	blue: (value?: any) => string;
	magenta: (value?: any) => string;
	cyan: (value?: any) => string;
	white: (value?: any) => string;
	gray: (value?: any) => string;
	bgBlack: (value?: any) => string;
	bgRed: (value?: any) => string;
	bgGreen: (value?: any) => string;
	bgYellow: (value?: any) => string;
	bgBlue: (value?: any) => string;
	bgMagenta: (value?: any) => string;
	bgCyan: (value?: any) => string;
	bgWhite: (value?: any) => string;
	blackBright: (value?: any) => string;
	redBright: (value?: any) => string;
	greenBright: (value?: any) => string;
	yellowBright: (value?: any) => string;
	blueBright: (value?: any) => string;
	magentaBright: (value?: any) => string;
	cyanBright: (value?: any) => string;
	whiteBright: (value?: any) => string;
	bgBlackBright: (value?: any) => string;
	bgRedBright: (value?: any) => string;
	bgGreenBright: (value?: any) => string;
	bgYellowBright: (value?: any) => string;
	bgBlueBright: (value?: any) => string;
	bgMagentaBright: (value?: any) => string;
	bgCyanBright: (value?: any) => string;
	bgWhiteBright: (value?: any) => string;
}

/**
 * Defines the colors options type used by this module.
 */
declare interface ColorsOptions {
	/**
	 * force use colors
	 */
	useColor?: boolean;
}
type CommentJavascriptParser = CommentImport & {
	start: number;
	end: number;
	loc?: null | SourceLocation;
};

/**
 * How one language writes a comment, and which it keeps where nothing is extracted.
 */
declare interface CommentSyntax {
	/**
	 * what opens a comment, e.g. `/*`
	 */
	open: string;

	/**
	 * what closes it
	 */
	close: string;

	/**
	 * what the `comments: "some"` level keeps
	 */
	some: (comment: string) => boolean;

	/**
	 * what is kept when `comments` is unset
	 */
	unstated: (comment: string) => boolean;
}
type CommentsOption =
	string | boolean | RegExp | ((comment: string) => boolean);

/**
 * Defines the common js import settings type used by this module.
 */
declare interface CommonJsImportSettings {
	name?: string;
	context: string;
}

/**
 * Defines the comparator type used by this module.
 */
declare interface Comparator<T> {
	(a: T, b: T): 0 | 1 | -1;
}
declare class CompatSource extends Source {
	constructor(sourceLike: SourceLike);
	static from(sourceLike: SourceLike): Source;
}

/**
 * Stores the replacement variable name and the declaration metadata tracked
 * for a compatibility rewrite.
 */
declare interface CompatibilitySettings {
	name: string;
	declaration: CompatibilitySettingsDeclaration;
}

/**
 * Captures the source range of a renamed compatibility binding so it can be
 * rewritten exactly once.
 */
declare interface CompatibilitySettingsDeclaration {
	updated: boolean;
	loc: DependencyLocation;
	range: [number, number];
}
declare class Compilation {
	/**
	 * Creates an instance of Compilation.
	 */
	constructor(compiler: Compiler, params: CompilationParams);
	hooks: Readonly<{
		buildModule: SyncHook<[Module]>;
		rebuildModule: SyncHook<[Module]>;
		failedModule: SyncHook<[Module, WebpackError]>;
		succeedModule: SyncHook<[Module]>;
		stillValidModule: SyncHook<[Module]>;
		addEntry: SyncHook<[Dependency, EntryOptions]>;
		failedEntry: SyncHook<[Dependency, EntryOptions, Error]>;
		succeedEntry: SyncHook<[Dependency, EntryOptions, Module]>;
		dependencyReferencedExports: SyncWaterfallHook<
			[(string[] | ReferencedExport)[], Dependency, RuntimeSpec],
			(string[] | ReferencedExport)[]
		>;
		/**
		 * @since 5.32.0
		 */
		executeModule: SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>;
		/**
		 * @since 5.33.0
		 */
		prepareModuleExecution: AsyncParallelHook<
			[ExecuteModuleArgument, ExecuteModuleContext]
		>;
		finishModules: AsyncSeriesHook<[Iterable<Module>]>;
		finishRebuildingModule: AsyncSeriesHook<[Module]>;
		unseal: SyncHook<[]>;
		seal: SyncHook<[]>;
		beforeChunks: SyncHook<[]>;
		/**
		 * The `afterChunks` hook is called directly after the chunks and module graph have
		 * been created and before the chunks and modules have been optimized. This hook is useful to
		 * inspect, analyze, and/or modify the chunk graph.
		 */
		afterChunks: SyncHook<[Iterable<Chunk>]>;
		optimizeDependencies: SyncBailHook<[Iterable<Module>], boolean | void>;
		afterOptimizeDependencies: SyncHook<[Iterable<Module>]>;
		optimize: SyncHook<[]>;
		optimizeModules: SyncBailHook<[Iterable<Module>], boolean | void>;
		afterOptimizeModules: SyncHook<[Iterable<Module>]>;
		optimizeChunks: SyncBailHook<
			[Iterable<Chunk>, ChunkGroup[]],
			boolean | void
		>;
		afterOptimizeChunks: SyncHook<[Iterable<Chunk>, ChunkGroup[]]>;
		optimizeTree: AsyncSeriesHook<[Iterable<Chunk>, Iterable<Module>]>;
		afterOptimizeTree: SyncHook<[Iterable<Chunk>, Iterable<Module>]>;
		optimizeChunkModules: AsyncSeriesBailHook<
			[Iterable<Chunk>, Iterable<Module>],
			void
		>;
		afterOptimizeChunkModules: SyncHook<[Iterable<Chunk>, Iterable<Module>]>;
		shouldRecord: SyncBailHook<[], boolean | void>;
		additionalChunkRuntimeRequirements: SyncHook<
			[Chunk, Set<string>, RuntimeRequirementsContext]
		>;
		runtimeRequirementInChunk: HookMap<
			SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>
		>;
		additionalModuleRuntimeRequirements: SyncHook<
			[Module, Set<string>, RuntimeRequirementsContext]
		>;
		runtimeRequirementInModule: HookMap<
			SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext], void>
		>;
		additionalTreeRuntimeRequirements: SyncHook<
			[Chunk, Set<string>, RuntimeRequirementsContext]
		>;
		runtimeRequirementInTree: HookMap<
			SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>
		>;
		runtimeModule: SyncHook<[RuntimeModule, Chunk]>;
		reviveModules: SyncHook<[Iterable<Module>, Records]>;
		beforeModuleIds: SyncHook<[Iterable<Module>]>;
		moduleIds: SyncHook<[Iterable<Module>]>;
		optimizeModuleIds: SyncHook<[Iterable<Module>]>;
		afterOptimizeModuleIds: SyncHook<[Iterable<Module>]>;
		reviveChunks: SyncHook<[Iterable<Chunk>, Records]>;
		beforeChunkIds: SyncHook<[Iterable<Chunk>]>;
		chunkIds: SyncHook<[Iterable<Chunk>]>;
		optimizeChunkIds: SyncHook<[Iterable<Chunk>]>;
		afterOptimizeChunkIds: SyncHook<[Iterable<Chunk>]>;
		recordModules: SyncHook<[Iterable<Module>, Records]>;
		recordChunks: SyncHook<[Iterable<Chunk>, Records]>;
		optimizeCodeGeneration: SyncHook<[Iterable<Module>]>;
		beforeModuleHash: SyncHook<[]>;
		afterModuleHash: SyncHook<[]>;
		beforeCodeGeneration: SyncHook<[]>;
		afterCodeGeneration: SyncHook<[]>;
		beforeRuntimeRequirements: SyncHook<[]>;
		afterRuntimeRequirements: SyncHook<[]>;
		beforeHash: SyncHook<[]>;
		contentHash: SyncHook<[Chunk]>;
		afterHash: SyncHook<[]>;
		recordHash: SyncHook<[Records]>;
		record: SyncHook<[Compilation, Records]>;
		beforeModuleAssets: SyncHook<[]>;
		shouldGenerateChunkAssets: SyncBailHook<[], boolean | void>;
		beforeChunkAssets: SyncHook<[]>;
		/**
		 * @deprecated
		 */
		additionalChunkAssets: FakeHook<
			Pick<
				AsyncSeriesHook<[Set<Chunk>]>,
				"name" | "tap" | "tapAsync" | "tapPromise"
			>
		>;
		/**
		 * @deprecated
		 */
		additionalAssets: FakeHook<
			Pick<AsyncSeriesHook<[]>, "name" | "tap" | "tapAsync" | "tapPromise">
		>;
		/**
		 * @deprecated
		 */
		optimizeChunkAssets: FakeHook<
			Pick<
				AsyncSeriesHook<[Set<Chunk>]>,
				"name" | "tap" | "tapAsync" | "tapPromise"
			>
		>;
		/**
		 * @deprecated
		 */
		afterOptimizeChunkAssets: FakeHook<
			Pick<
				AsyncSeriesHook<[Set<Chunk>]>,
				"name" | "tap" | "tapAsync" | "tapPromise"
			>
		>;
		/**
		 * @deprecated
		 */
		optimizeAssets: AsyncSeriesHook<
			[CompilationAssets],
			ProcessAssetsAdditionalOptions
		>;
		/**
		 * @deprecated
		 */
		afterOptimizeAssets: SyncHook<[CompilationAssets]>;
		processAssets: AsyncSeriesHook<
			[CompilationAssets],
			ProcessAssetsAdditionalOptions
		>;
		afterProcessAssets: SyncHook<[CompilationAssets]>;
		/**
		 * @since 5.8.0
		 */
		processAdditionalAssets: AsyncSeriesHook<[CompilationAssets]>;
		needAdditionalSeal: SyncBailHook<[], boolean | void>;
		afterSeal: AsyncSeriesHook<[]>;
		renderManifest: SyncWaterfallHook<
			[RenderManifestEntry[], RenderManifestOptions],
			RenderManifestEntry[]
		>;
		/**
		 * Called with source written in one language that a module emits inside
		 * another — CSS or HTML reaching the bundle as a JavaScript string
		 * literal today — before it is embedded; return the (possibly
		 * transformed) source, e.g. a minified one. `info.type` says which
		 * language it is, so one tap serves every pair; no asset carries this
		 * source, so an asset-level minimizer cannot reach it.
		 * @since 5.110.0
		 */
		renderEmbeddedSource: AsyncSeriesWaterfallHook<
			[Source, EmbeddedSourceInfo],
			Source
		>;
		/**
		 * Called while hashing a module that embeds such a source. Module hashes
		 * are taken before code generation, so a `renderEmbeddedSource` tap must
		 * write whatever it varies on into the hash, or the codegen cache
		 * replays output from before its options changed.
		 * @since 5.110.0
		 */
		embeddedSourceHash: SyncHook<[Module, Hash]>;
		fullHash: SyncHook<[Hash]>;
		chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
		moduleAsset: SyncHook<[Module, string]>;
		chunkAsset: SyncHook<[Chunk, string]>;
		assetPath: SyncWaterfallHook<
			[string, PathData, undefined | AssetInfo],
			string
		>;
		needAdditionalPass: SyncBailHook<[], boolean | void>;
		childCompiler: SyncHook<[Compiler, string, number]>;
		log: SyncBailHook<[string, LogEntry], boolean | void>;
		processWarnings: SyncWaterfallHook<[Error[]], Error[]>;
		processErrors: SyncWaterfallHook<[Error[]], Error[]>;
		statsPreset: HookMap<
			SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>
		>;
		statsNormalize: SyncHook<
			[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]
		>;
		statsFactory: SyncHook<[StatsFactory, NormalizedStatsOptions]>;
		statsPrinter: SyncHook<[StatsPrinter, NormalizedStatsOptions]>;
		/**
		 * Gets normal module loader.
		 * @deprecated
		 */
		get normalModuleLoader(): SyncHook<[AnyLoaderContext, NormalModule]>;
	}>;
	name?: string;
	startTime?: number;
	endTime?: number;
	compiler: Compiler;
	resolverFactory: ResolverFactory;
	inputFileSystem: InputFileSystem;
	fileSystemInfo: FileSystemInfo;
	valueCacheVersions: Map<string, ValueCacheVersion>;
	requestShortener: RequestShortener;
	compilerPath: string;
	logger: Logger;
	options: WebpackOptionsNormalizedWithDefaults;
	outputOptions: OutputNormalizedWithDefaults;
	bail: boolean;
	profile: boolean;
	params: CompilationParams;
	mainTemplate: MainTemplate;
	chunkTemplate: ChunkTemplate;
	runtimeTemplate: RuntimeTemplate;
	moduleTemplates: ModuleTemplates;
	moduleMemCaches?: Map<Module, WeakTupleMap<any[], any>>;
	moduleMemCaches2?: Map<Module, WeakTupleMap<any[], any>>;
	moduleGraph: ModuleGraph;
	chunkGraph: ChunkGraph;
	codeGenerationResults?: CodeGenerationResults;
	processDependenciesQueue: AsyncQueue<Module, Module, Module>;
	addModuleQueue: AsyncQueue<Module, string, Module>;
	factorizeQueue: AsyncQueue<
		FactorizeModuleOptions,
		string,
		Module | ModuleFactoryResult
	>;
	buildQueue: AsyncQueue<Module, Module, Module>;
	rebuildQueue: AsyncQueue<Module, Module, Module>;

	/**
	 * Modules in value are building during the build of Module in key.
	 * Means value blocking key from finishing.
	 * Needed to detect build cycles.
	 */
	creatingModuleDuringBuild: WeakMap<Module, Set<Module>>;
	entries: Map<string, EntryData>;
	globalEntry: EntryData;
	entrypoints: Map<string, Entrypoint>;
	asyncEntrypoints: Entrypoint[];
	chunks: Set<Chunk>;
	chunkGroups: ChunkGroup[];
	namedChunkGroups: Map<string, ChunkGroup>;
	namedChunks: Map<string, Chunk>;
	modules: Set<Module>;
	records: null | Records;
	additionalChunkAssets: string[];
	assets: CompilationAssets;
	assetsInfo: Map<string, AssetInfo>;
	errors: Error[];
	warnings: Error[];
	hints: Error[];
	children: Compilation[];
	logging: Map<string, LogEntry[]>;
	dependencyFactories: Map<DependencyConstructor, ModuleFactory>;
	dependencyTemplates: DependencyTemplates;
	childrenCounters: Record<string, number>;
	usedChunkIds: null | Set<number>;
	usedModuleIds: null | Set<number>;
	needAdditionalPass: boolean;
	builtModules: WeakSet<Module>;
	codeGeneratedModules: WeakSet<Module>;
	buildTimeExecutedModules: WeakSet<Module>;
	emittedAssets: Set<string>;
	comparedForEmitAssets: Set<string>;
	fileDependencies: LazySet<string>;
	contextDependencies: LazySet<string>;
	missingDependencies: LazySet<string>;
	buildDependencies: LazySet<string>;
	optionalBuildDependencies: LazySet<string>;

	/**
	 * @deprecated
	 */
	compilationDependencies: { add: (item: string) => LazySet<string> };
	getStats(): Stats;

	/**
	 * Creates a stats options.
	 */
	createStatsOptions(
		optionsOrPreset?: string | boolean | StatsOptions,
		context?: CreateStatsOptionsContext
	): NormalizedStatsOptions;

	/**
	 * Creates a stats factory.
	 */
	createStatsFactory(options: NormalizedStatsOptions): StatsFactory;

	/**
	 * Creates a stats printer.
	 */
	createStatsPrinter(options: NormalizedStatsOptions): StatsPrinter;

	/**
	 * Returns the cache facade instance.
	 */
	getCache(name: string): CacheFacade;

	/**
	 * Returns a logger with that name.
	 */
	getLogger(name: string | (() => string)): Logger;

	/**
	 * Adds the provided module to the compilation.
	 */
	addModule(
		module: Module,
		callback: (err?: null | WebpackError, result?: null | Module) => void
	): void;

	/**
	 * Fetches a module from a compilation by its identifier
	 */
	getModule(module: Module): Module;

	/**
	 * Attempts to search for a module by its identifier
	 */
	findModule(identifier: string): undefined | Module;

	/**
	 * Schedules a build of the module object
	 */
	buildModule(
		module: Module,
		callback: (err?: null | WebpackError, result?: null | Module) => void
	): void;

	/**
	 * Process module dependencies.
	 */
	processModuleDependencies(
		module: Module,
		callback: (err?: null | WebpackError, result?: null | Module) => void
	): void;

	/**
	 * Process module dependencies non recursive.
	 */
	processModuleDependenciesNonRecursive(module: Module): void;

	/**
	 * Processes the provided |.
	 */

	/**
	 * Processes the provided module callback.
	 */
	factorizeModule(
		options: FactorizeModuleOptions & { factoryResult?: false },
		callback: (err?: null | WebpackError, result?: null | Module) => void
	): void;

	/**
	 * Processes the provided |.
	 */

	/**
	 * Processes the provided module factory result callback.
	 */
	factorizeModule(
		options: FactorizeModuleOptions & { factoryResult: true },
		callback: (
			err?: null | WebpackError,
			result?: null | ModuleFactoryResult
		) => void
	): void;

	/**
	 * Handle module creation.
	 */
	handleModuleCreation(
		__0: HandleModuleCreationOptions,
		callback: (err?: null | WebpackError, result?: null | Module) => void
	): void;

	/**
	 * Adds the provided string to the compilation.
	 */
	addModuleChain(
		context: string,
		dependency: Dependency,
		callback: (err?: null | WebpackError, result?: null | Module) => void
	): void;

	/**
	 * Adds the provided object to the compilation.
	 */
	addModuleTree(
		__0: {
			/**
			 * context string path
			 */
			context: string;
			/**
			 * dependency used to create Module chain
			 */
			dependency: Dependency;
			/**
			 * additional context info for the root module
			 */
			contextInfo?: Partial<ModuleFactoryCreateDataContextInfo>;
		},
		callback: (err?: null | WebpackError, result?: null | Module) => void
	): void;

	/**
	 * Adds the provided string to the compilation.
	 */
	addEntry(
		context: string,
		entry: Dependency,
		optionsOrName: string | EntryOptions,
		callback: (err?: null | WebpackError, result?: null | Module) => void
	): void;

	/**
	 * Adds the provided string to the compilation.
	 */
	addInclude(
		context: string,
		dependency: Dependency,
		options: EntryOptions,
		callback: (err?: null | WebpackError, result?: null | Module) => void
	): void;

	/**
	 * Processes the provided module.
	 */
	rebuildModule(
		module: Module,
		callback: (err?: null | WebpackError, result?: null | Module) => void
	): void;

	/**
	 * Processes the provided callback.
	 */
	finish(callback: (err?: null | WebpackError) => void): void;
	unseal(): void;

	/**
	 * Processes the provided callback.
	 */
	seal(callback: (err?: null | WebpackError) => void): void;

	/**
	 * Report dependency errors and warnings.
	 */
	reportDependencyErrorsAndWarnings(
		module: Module,
		blocks: DependenciesBlock[]
	): boolean;

	/**
	 * Generates code and runtime requirements for this module.
	 */
	codeGeneration(callback: (err?: null | WebpackError) => void): void;

	/**
	 * Process runtime requirements.
	 */
	processRuntimeRequirements(__0?: {
		/**
		 * the chunk graph
		 */
		chunkGraph?: ChunkGraph;
		/**
		 * modules
		 */
		modules?: Iterable<Module>;
		/**
		 * chunks
		 */
		chunks?: Iterable<Chunk>;
		/**
		 * codeGenerationResults
		 */
		codeGenerationResults?: CodeGenerationResults;
		/**
		 * chunkGraphEntries
		 */
		chunkGraphEntries?: Iterable<Chunk>;
	}): void;

	/**
	 * Queues a runtime module whose implementation is loaded on demand, for
	 * `_attachPendingRuntimeModules` to await and build once the requirement pass
	 * is over. `runtimeRequirementInTree` is a sync hook, so a tap cannot await
	 * the load itself; anything the tap reads off the requirement set must be
	 * captured before queueing, since `create` runs later.
	 */
	addLazyRuntimeModule<T extends object>(
		chunk: Chunk,
		load: () => Promise<T>,
		create: (loaded: T) => RuntimeModule,
		chunkGraph?: ChunkGraph
	): void;

	/**
	 * Adds runtime module.
	 */
	addRuntimeModule(
		chunk: Chunk,
		module: RuntimeModule,
		chunkGraph?: ChunkGraph
	): void;

	/**
	 * If `module` is passed, `loc` and `request` must also be passed.
	 */
	addChunkInGroup(
		groupOptions: string | ChunkGroupOptions,
		module?: Module,
		loc?: SyntheticDependencyLocation | RealDependencyLocation,
		request?: string
	): ChunkGroup;

	/**
	 * Adds the provided async entrypoint to this chunk group.
	 */
	addAsyncEntrypoint(
		options: EntryOptions,
		module: Module,
		loc: DependencyLocation,
		request: string
	): Entrypoint;

	/**
	 * This method first looks to see if a name is provided for a new chunk,
	 * and first looks to see if any named chunks already exist and reuse that chunk instead.
	 */
	addChunk(name?: null | string): Chunk;

	/**
	 * Processes the provided module.
	 * @deprecated
	 */
	assignDepth(module: Module): void;

	/**
	 * Assigns depth values to the provided modules.
	 */
	assignDepths(modules: Module[] | Set<Module>): void;

	/**
	 * Gets dependency referenced exports.
	 */
	getDependencyReferencedExports(
		dependency: Dependency,
		runtime: RuntimeSpec
	): (string[] | ReferencedExport)[];

	/**
	 * Removes reasons of dependency block.
	 */
	removeReasonsOfDependencyBlock(
		module: Module,
		block: DependenciesBlockLike
	): void;

	/**
	 * Patch chunks after reason removal.
	 */
	patchChunksAfterReasonRemoval(module: Module, chunk: Chunk): void;

	/**
	 * Removes chunk from dependencies.
	 */
	removeChunkFromDependencies(block: DependenciesBlock, chunk: Chunk): void;
	assignRuntimeIds(): void;
	sortItemsWithChunkIds(): void;
	summarizeDependencies(): void;
	createModuleHashes(): void;
	createHash(): CodeGenerationJob[];
	fullHash?: string;
	hash?: string;

	/**
	 * Processes the provided file.
	 */
	emitAsset(file: string, source: Source, assetInfo?: AssetInfo): void;

	/**
	 * Updates asset using the provided file.
	 */
	updateAsset(
		file: string,
		newSourceOrFunction: Source | ((source: Source) => Source),
		assetInfoUpdateOrFunction?:
			AssetInfo | ((assetInfo?: AssetInfo) => undefined | AssetInfo)
	): void;

	/**
	 * Processes the provided file.
	 */
	renameAsset(file: string, newFile: string): void;

	/**
	 * Processes the provided file.
	 */
	deleteAsset(file: string): void;
	getAssets(): Readonly<Asset>[];

	/**
	 * Returns the asset or undefined when not found.
	 */
	getAsset(name: string): undefined | Readonly<Asset>;
	clearAssets(): void;
	createModuleAssets(): void;

	/**
	 * Gets render manifest.
	 */
	getRenderManifest(options: RenderManifestOptions): RenderManifestEntry[];

	/**
	 * Creates a chunk assets.
	 */
	createChunkAssets(callback: (err?: null | WebpackError) => void): void;

	/**
	 * Returns interpolated path.
	 */
	getPath<T extends PathData = PathData>(
		filename: string | TemplatePathFn<T>,
		data?: T
	): string;

	/**
	 * Gets path with info.
	 */
	getPathWithInfo<T extends PathData = PathData>(
		filename: string | TemplatePathFn<T>,
		data?: T
	): InterpolatedPathAndAssetInfo;

	/**
	 * Returns interpolated path.
	 */
	getAssetPath<T extends PathData = PathData>(
		filename: string | TemplatePathFn<T>,
		data: T
	): string;

	/**
	 * Gets asset path with info.
	 */
	getAssetPathWithInfo<T extends PathData = PathData>(
		filename: string | TemplatePathFn<T>,
		data: T
	): InterpolatedPathAndAssetInfo;
	getWarnings(): Error[];
	getErrors(): Error[];

	/**
	 * This function allows you to run another instance of webpack inside of webpack however as
	 * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins
	 * from parent (or top level compiler) and creates a child Compilation
	 */
	createChildCompiler(
		name: string,
		outputOptions?: Partial<OutputNormalized>,
		plugins?: (
			| undefined
			| null
			| false
			| ""
			| 0
			| ((this: Compiler, compiler: Compiler) => void)
			| WebpackPluginInstance
		)[]
	): Compiler;

	/**
	 * Processes the provided module.
	 */
	executeModule(
		module: Module,
		options: ExecuteModuleOptions,
		callback: (
			err?: null | WebpackError,
			result?: null | ExecuteModuleResult
		) => void
	): void;
	checkConstraints(): void;

	/**
	 * Add additional assets to the compilation.
	 */
	static PROCESS_ASSETS_STAGE_ADDITIONAL: number;

	/**
	 * Basic preprocessing of assets.
	 */
	static PROCESS_ASSETS_STAGE_PRE_PROCESS: number;

	/**
	 * Derive new assets from existing assets.
	 * Existing assets should not be treated as complete.
	 */
	static PROCESS_ASSETS_STAGE_DERIVED: number;

	/**
	 * Add additional sections to existing assets, like a banner or initialization code.
	 */
	static PROCESS_ASSETS_STAGE_ADDITIONS: number;

	/**
	 * Optimize existing assets in a general way.
	 */
	static PROCESS_ASSETS_STAGE_OPTIMIZE: number;

	/**
	 * Optimize the count of existing assets, e. g. by merging them.
	 * Only assets of the same type should be merged.
	 * For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.
	 */
	static PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT: number;

	/**
	 * Optimize the compatibility of existing assets, e. g. add polyfills or vendor-prefixes.
	 */
	static PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY: number;

	/**
	 * Optimize the size of existing assets, e. g. by minimizing or omitting whitespace.
	 */
	static PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE: number;

	/**
	 * Add development tooling to assets, e. g. by extracting a SourceMap.
	 */
	static PROCESS_ASSETS_STAGE_DEV_TOOLING: number;

	/**
	 * Optimize the count of existing assets, e. g. by inlining assets of into other assets.
	 * Only assets of different types should be inlined.
	 * For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.
	 */
	static PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE: number;

	/**
	 * Summarize the list of existing assets
	 * e. g. creating an assets manifest of Service Workers.
	 */
	static PROCESS_ASSETS_STAGE_SUMMARIZE: number;

	/**
	 * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
	 */
	static PROCESS_ASSETS_STAGE_OPTIMIZE_HASH: number;

	/**
	 * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
	 */
	static PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER: number;

	/**
	 * Analyse existing assets.
	 */
	static PROCESS_ASSETS_STAGE_ANALYSE: number;

	/**
	 * Creating assets for reporting purposes.
	 */
	static PROCESS_ASSETS_STAGE_REPORT: number;
}
declare interface CompilationAssets {
	[index: string]: Source;
}

/**
 * Defines the compilation hooks type used by this module.
 */
declare interface CompilationHooks {
	renderModuleContent: SyncWaterfallHook<
		[Source, Module, WebAssemblyRenderContext],
		Source
	>;
}

/**
 * Defines the compilation params type used by this module.
 */
declare interface CompilationParams {
	normalModuleFactory: NormalModuleFactory;
	contextModuleFactory: ContextModuleFactory;
}

/**
 * Defines the compiled rule type used by this module.
 */
declare interface CompiledRule {
	path: string;
	raw: RuleSetRule;
	used: boolean;
	conditions: RuleCondition[];
	effects: (EffectUse | EffectBasic | ((effectData: EffectData) => Effect[]))[];
	rules?: CompiledRule[];
	oneOf?: CompiledRule[];
}
declare interface CompiledVisitorBucket<TPath> {
	enter: VisitorFn<TPath>[];
	exit: VisitorFn<TPath>[];
}
declare class Compiler {
	/**
	 * Creates an instance of Compiler.
	 */
	constructor(context: string, options?: WebpackOptionsNormalized);
	hooks: Readonly<{
		initialize: SyncHook<[]>;
		shouldEmit: SyncBailHook<[Compilation], boolean | void>;
		done: AsyncSeriesHook<[Stats]>;
		afterDone: SyncHook<[Stats]>;
		additionalPass: AsyncSeriesHook<[]>;
		beforeRun: AsyncSeriesHook<[Compiler]>;
		run: AsyncSeriesHook<[Compiler]>;
		emit: AsyncSeriesHook<[Compilation]>;
		assetEmitted: AsyncSeriesHook<[string, AssetEmittedInfo]>;
		afterEmit: AsyncSeriesHook<[Compilation]>;
		thisCompilation: SyncHook<[Compilation, CompilationParams]>;
		compilation: SyncHook<[Compilation, CompilationParams]>;
		normalModuleFactory: SyncHook<[NormalModuleFactory]>;
		contextModuleFactory: SyncHook<[ContextModuleFactory]>;
		beforeCompile: AsyncSeriesHook<[CompilationParams]>;
		compile: SyncHook<[CompilationParams]>;
		make: AsyncParallelHook<[Compilation]>;
		finishMake: AsyncParallelHook<[Compilation]>;
		afterCompile: AsyncSeriesHook<[Compilation]>;
		/**
		 * @since 5.67.0
		 */
		readRecords: AsyncSeriesHook<[]>;
		/**
		 * @since 5.67.0
		 */
		emitRecords: AsyncSeriesHook<[]>;
		watchRun: AsyncSeriesHook<[Compiler]>;
		failed: SyncHook<[Error]>;
		invalid: SyncHook<[null | string, number]>;
		watchClose: SyncHook<[]>;
		/**
		 * @since 5.17.0
		 */
		shutdown: AsyncSeriesHook<[]>;
		infrastructureLog: SyncBailHook<
			[string, string, undefined | any[]],
			true | void
		>;
		/**
		 * @since 5.106.0
		 */
		validate: SyncHook<[]>;
		environment: SyncHook<[]>;
		afterEnvironment: SyncHook<[]>;
		afterPlugins: SyncHook<[Compiler]>;
		afterResolvers: SyncHook<[Compiler]>;
		entryOption: SyncBailHook<[string, EntryNormalized], boolean | void>;
	}>;
	webpack: typeof exports;
	name?: string;
	parentCompilation?: Compilation;
	root: Compiler;
	outputPath: string;
	watching?: Watching;
	outputFileSystem: null | OutputFileSystem;
	intermediateFileSystem: null | IntermediateFileSystem;
	inputFileSystem: null | InputFileSystem;
	watchFileSystem: null | WatchFileSystem;
	recordsInputPath: null | string;
	recordsOutputPath: null | string;
	records: Records;
	managedPaths: Set<string | RegExp>;
	unmanagedPaths: Set<string | RegExp>;
	immutablePaths: Set<string | RegExp>;
	modifiedFiles?: ReadonlySet<string>;
	removedFiles?: ReadonlySet<string>;
	fileTimestamps?: Map<
		string,
		| null
		| "ignore"
		| EntryTypesIndex
		| OnlySafeTimeEntry
		| ExistenceOnlyTimeEntryTypesIndex
	>;
	contextTimestamps?: Map<
		string,
		| null
		| "ignore"
		| EntryTypesIndex
		| OnlySafeTimeEntry
		| ExistenceOnlyTimeEntryTypesIndex
	>;
	fsStartTime?: number;
	resolverFactory: ResolverFactory;
	infrastructureLogger?: (
		value: string,
		type: LogTypeEnum,
		args?: any[]
	) => void;
	platform: Readonly<PlatformTargetProperties>;
	options: WebpackOptionsNormalized;
	context: string;
	requestShortener: RequestShortener;
	cache: Cache;
	moduleMemCaches?: Map<Module, ModuleMemCachesItem>;
	compilerPath: string;
	running: boolean;
	idle: boolean;
	watchMode: boolean;

	/**
	 * Returns the cache facade instance.
	 */
	getCache(name: string): CacheFacade;

	/**
	 * Gets infrastructure logger.
	 */
	getInfrastructureLogger(name: string | (() => string)): Logger;

	/**
	 * Returns a compiler watcher.
	 */
	watch(
		watchOptions: WatchOptions,
		handler: CallbackWebpackFunction_2<Stats, void>
	): undefined | Watching;

	/**
	 * Processes the provided stat.
	 */
	run(callback: CallbackWebpackFunction_2<Stats, void>): void;

	/**
	 * Processes the provided run as child callback.
	 */
	runAsChild(
		callback: (
			err: null | Error,
			entries?: Chunk[],
			compilation?: Compilation
		) => void
	): void;
	purgeInputFileSystem(): void;

	/**
	 * Processes the provided compilation.
	 */
	emitAssets(
		compilation: Compilation,
		callback: (err: null | Error, result?: void) => void
	): void;

	/**
	 * Processes the provided error callback.
	 */
	emitRecords(callback: (err: null | Error, result?: void) => void): void;

	/**
	 * Processes the provided error callback.
	 */
	readRecords(callback: (err: null | Error, result?: void) => void): void;

	/**
	 * Creates a child compiler.
	 */
	createChildCompiler(
		compilation: Compilation,
		compilerName: string,
		compilerIndex: number,
		outputOptions?: Partial<OutputNormalized>,
		plugins?: (
			| undefined
			| null
			| false
			| ""
			| 0
			| ((this: Compiler, compiler: Compiler) => void)
			| WebpackPluginInstance
		)[]
	): Compiler;
	isChild(): boolean;

	/**
	 * Creates a compilation.
	 */
	createCompilation(params: CompilationParams): Compilation;

	/**
	 * Returns the created compilation.
	 */
	newCompilation(params: CompilationParams): Compilation;
	createNormalModuleFactory(): NormalModuleFactory;
	createContextModuleFactory(): ContextModuleFactory;
	newCompilationParams(): {
		normalModuleFactory: NormalModuleFactory;
		contextModuleFactory: ContextModuleFactory;
	};

	/**
	 * Processes the provided compilation.
	 */
	compile(callback: CallbackWebpackFunction_2<Compilation, void>): void;

	/**
	 * Processes the provided error callback.
	 */
	close(callback: (err: null | Error, result?: void) => void): void;

	/**
	 * Schema validation function with optional pre-compiled check
	 */
	validate<T extends Parameters<typeof validateFunction>[1] = object>(
		schema:
			| (JSONSchema4 & ExtendedSchema)
			| (JSONSchema6 & ExtendedSchema)
			| (JSONSchema7 & ExtendedSchema)
			| (() => Parameters<typeof validateFunction>[0]),
		value: T,
		options?: ValidationErrorConfiguration,
		check?: (value: T) => boolean
	): void;
}
type ComplexSerializableType =
	| undefined
	| null
	| string
	| number
	| bigint
	| boolean
	| object
	| Buffer
	| (() => ComplexSerializableType[] | Promise<ComplexSerializableType[]>);
type ComponentValue = TokenSyntaxParserObject | FunctionNode | SimpleBlock;

/**
 * The exports of terser's `compress/common.js`, `inference.js`,
 * `compressor-flags.js` and `utils/index.js` the phases read, ported.
 */
declare interface CompressHelpers {
	/**
	 * terser's `compress/common.js`
	 */
	common: Record<string, any>;

	/**
	 * the functions of terser's `compress/inference.js`
	 */
	inference: Record<string, any>;

	/**
	 * terser's `compress/compressor-flags.js`
	 */
	flags: Record<string, any>;

	/**
	 * terser's `utils/index.js`
	 */
	utils: Record<string, any>;
}

/**
 * terser's compressor: the methods the phases call typed, the rest open.
 */
declare interface CompressorShape {
	[index: string]: any;
	options: Partial<any>;
	stack: NodeShape[];
	option<
		K extends
			| "module"
			| "warnings"
			| "inline"
			| "arguments"
			| "expression"
			| "evaluate"
			| "unused"
			| "properties"
			| "arrows"
			| "booleans"
			| "booleans_as_integers"
			| "collapse_vars"
			| "comparisons"
			| "computed_props"
			| "conditionals"
			| "dead_code"
			| "defaults"
			| "directives"
			| "drop_console"
			| "drop_debugger"
			| "ecma"
			| "builtins_ecma"
			| "builtins_pure"
			| "global_defs"
			| "hoist_funs"
			| "hoist_props"
			| "hoist_vars"
			| "ie8"
			| "if_return"
			| "join_vars"
			| "keep_classnames"
			| "keep_fargs"
			| "keep_fnames"
			| "keep_infinity"
			| "lhs_constants"
			| "loops"
			| "negate_iife"
			| "passes"
			| "pure_getters"
			| "pure_funcs"
			| "pure_conversions"
			| "pure_heritage"
			| "pure_new"
			| "reduce_funcs"
			| "reduce_vars"
			| "sequences"
			| "side_effects"
			| "switches"
			| "top_retain"
			| "toplevel"
			| "typeofs"
			| "unsafe"
			| "unsafe_arrows"
			| "unsafe_comps"
			| "unsafe_Function"
			| "unsafe_math"
			| "unsafe_symbols"
			| "unsafe_methods"
			| "unsafe_proto"
			| "unsafe_regexp"
			| "unsafe_undefined"
	>(
		name: K
	): any[K];
	has_directive(directive: string): undefined | true | NodeShape;
	parent(level?: number): NodeShape;
	self(): NodeShape;
	find_parent(test: (value: unknown) => boolean): undefined | NodeShape;
	in_boolean_context(): undefined | boolean;
}
declare class ConcatSource extends Source {
	constructor(...args: Child[]);
	getChildren(): Source[];
	add(item: Child): void;
	addAllSkipOptimizing(items: Child[]): void;
	streamChunks(
		options: OptionsStreamChunks,
		onChunk: (
			chunk: undefined | string,
			generatedLine: number,
			generatedColumn: number,
			sourceIndex: number,
			originalLine: number,
			originalColumn: number,
			nameIndex: number
		) => void,
		onSource: (
			sourceIndex: number,
			source: null | string,
			sourceContent?: string,
			scopeBindings?: Map<string, string>
		) => void,
		onName: (nameIndex: number, name: string) => void
	): GeneratedSourceInfo;
}

/**
 * Advanced options for module concatenation.
 * @since 5.109.0
 */
declare interface ConcatenateModulesOptions {
	/**
	 * Also concatenate CommonJS modules with statically analyzable exports. Defaults to 'true'.
	 */
	commonjs?: boolean;
}
type ConcatenatedModuleBuildInfo = KnownBuildInfo &
	Record<string, any> &
	KnownConcatenatedModuleBuildInfo;
declare interface ConcatenatedModuleInfo {
	type: "concatenated";

	/**
	 * the body renders inside the lazy CJS wrapper with real module/exports instead of being scope-hoisted into the shared scope
	 */
	wrapped: boolean;

	/**
	 * a wrapped body reached by an eager import edge, so its accessor is called at its own slot in evaluation order
	 */
	eager: boolean;
	module: Module;
	index: number;

	/**
	 * where each shorthand property's identifier starts
	 */
	shorthandIdentifierStarts?: Set<number>;
	internalSource?: Source;
	source?: ReplaceSource;
	chunkInitFragments?: InitFragment<ChunkRenderContextJavascriptModulesPlugin>[];
	runtimeRequirements?: ReadonlySet<string>;
	globalScope?: Scope;

	/**
	 * the module's free references
	 */
	unresolvedReferences?: Reference[];
	moduleScope?: Scope;
	internalNames: Map<string, string>;
	exportMap?: Map<string, string>;
	rawExportMap?: Map<string, string>;
	namespaceExportSymbol?: string;

	/**
	 * name of the lazy wrapper accessor function (calling it evaluates the module and returns its exports)
	 */
	namespaceFnName?: string;
	namespaceObjectName?: string;

	/**
	 * decoupled namespace object that keeps original export names when the exports are mangled
	 */
	escapeNamespaceObjectName?: string;
	concatenationScope?: ConcatenationScope;

	/**
	 * "default-with-named" namespace
	 */
	interopNamespaceObjectUsed: boolean;

	/**
	 * "default-with-named" namespace
	 */
	interopNamespaceObjectName?: string;

	/**
	 * "default-only" namespace
	 */
	interopNamespaceObject2Used: boolean;

	/**
	 * "default-only" namespace
	 */
	interopNamespaceObject2Name?: string;

	/**
	 * runtime namespace object that detects "__esModule"
	 */
	interopDefaultAccessUsed: boolean;

	/**
	 * runtime namespace object that detects "__esModule"
	 */
	interopDefaultAccessName?: string;

	/**
	 * memoized getExportsType(strict=true)
	 */
	exportsTypeStrict?:
		"namespace" | "dynamic" | "default-only" | "default-with-named";

	/**
	 * memoized getExportsType(strict=false)
	 */
	exportsTypeNonStrict?:
		"namespace" | "dynamic" | "default-only" | "default-with-named";
}

/**
 * Defines the concatenation bailout reason context type used by this module.
 */
declare interface ConcatenationBailoutReasonContext {
	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * whether eligible CommonJS modules may be concatenated
	 */
	concatenateCommonJsModules?: boolean;
}

/**
 * Tracks the symbols and cross-module references needed while rendering a
 * concatenated module.
 */
declare class ConcatenationScope {
	/**
	 * Creates the mutable scope object used while rendering a concatenated
	 * module and its cross-module references.
	 */
	constructor(
		modulesMap: ModuleInfo[] | Map<Module, ModuleInfo>,
		currentModule: ConcatenatedModuleInfo,
		usedNames: Set<string>
	);
	usedNames: Set<string>;

	/**
	 * Checks whether a module participates in the current concatenation scope.
	 */
	isModuleInScope(module: Module): boolean;

	/**
	 * Whether an in-scope module's body renders inside the lazy wrapper.
	 */
	isModuleWrapped(module: Module): boolean;

	/**
	 * Marks a wrapped module as eagerly imported, so its accessor is called at its
	 * own slot in evaluation order instead of from inside the importing body.
	 */
	registerEagerModule(module: Module): void;

	/**
	 * Whether the current module runs inside the lazy wrapper. Exports then live
	 * on a real exports object, not hoisted bindings, so templates emit runtime
	 * code.
	 */
	isWrapped(): boolean;

	/**
	 * Records the symbol that should be used when the current module exports a
	 * named binding.
	 */
	registerExport(exportName: string, symbol: string): void;

	/**
	 * Records a raw expression that can be used to reference an export without
	 * going through the normal symbol map.
	 */
	registerRawExport(exportName: string, expression: string): void;

	/**
	 * Returns the raw expression registered for an export, if one exists.
	 */
	getRawExport(exportName: string): undefined | string;

	/**
	 * Replaces the raw expression for an export only when that export already
	 * has an entry in the raw export map.
	 */
	setRawExportMap(exportName: string, expression: string): void;

	/**
	 * Records the symbol that should be used for the synthetic namespace export.
	 */
	registerNamespaceExport(symbol: string): void;

	/**
	 * Encodes a reference to another concatenated module as a placeholder
	 * identifier that can be parsed later during code generation.
	 */
	createModuleReference(
		module: Module,
		__1: Partial<ModuleReferenceOptions>
	): string;

	/**
	 * Checks whether an identifier is one of webpack's encoded concatenation
	 * module references.
	 */
	static isModuleReference(name: string): boolean;

	/**
	 * Checks whether an identifier buries a reference token without being one,
	 * which nothing can resolve: it would reach the output as an undeclared global.
	 */
	static isLeakedModuleReference(name: string): boolean;

	/**
	 * Finds all encoded module references in a generated source. A match that
	 * continues an identifier is reported as `leaked`: it is a token a wider
	 * replacement swallowed, so substituting it would rewrite the middle of a name.
	 */
	static findModuleReferences(source: Source): ModuleReferenceMatch[];

	/**
	 * Parses an encoded module reference back into its module index and
	 * reference flags.
	 */
	static matchModuleReference(
		name: string
	): null | (ModuleReferenceOptions & { index: number });
	static DEFAULT_EXPORT: string;
	static NAMESPACE_OBJECT_EXPORT: string;
}

/**
 * Options object as provided by the user.
 */
declare interface Configuration {
	/**
	 * Set the value of `require.amd` and `define.amd`. Or disable AMD support.
	 */
	amd?: false | { [index: string]: any };

	/**
	 * Report the first error as a hard error instead of tolerating it.
	 */
	bail?: boolean;

	/**
	 * Cache generated modules and chunks to improve performance for multiple incremental builds.
	 */
	cache?: boolean | FileCacheOptions | MemoryCacheOptions;

	/**
	 * The base directory (absolute path!) for resolving the `entry` option. If `output.pathinfo` is set, the included pathinfo is shortened to this directory.
	 */
	context?: string;

	/**
	 * References to other configurations to depend on.
	 */
	dependencies?: string[];

	/**
	 * A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).
	 */
	devtool?:
		| string
		| false
		| {
				/**
				 * Which asset type should receive this devtool value.
				 */
				type: "all" | "css" | "javascript";
				/**
				 * A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).
				 */
				use: RawDevTool;
		  }[];

	/**
	 * Enable and configure the Dotenv plugin to load environment variables from .env files.
	 */
	dotenv?: boolean | DotenvPluginOptions;

	/**
	 * The entry point(s) of the compilation.
	 */
	entry?:
		| string
		| (() => string | EntryObject | string[] | Promise<EntryStatic>)
		| EntryObject
		| string[];

	/**
	 * Enables/Disables experiments (experimental features with relax SemVer compatibility).
	 */
	experiments?: Experiments;

	/**
	 * Extend configuration from another configuration (only works when using webpack-cli).
	 */
	extends?: string | string[];

	/**
	 * Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on `output.libraryTarget`.
	 */
	externals?:
		| string
		| RegExp
		| ExternalItemObject
		| ((
				data: ExternalItemFunctionData,
				callback: (
					err?: null | Error,
					result?:
						| string
						| boolean
						| string[]
						| ExternalItemValueObject
						| ExternalItemValueWithOptions
				) => void
		  ) => void)
		| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>)
		| ExternalItem[];

	/**
	 * Enable presets of externals for specific targets.
	 */
	externalsPresets?: ExternalsPresets;

	/**
	 * Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).
	 */
	externalsType?:
		| "import"
		| "var"
		| "module"
		| "assign"
		| "this"
		| "window"
		| "self"
		| "global"
		| "commonjs"
		| "commonjs2"
		| "commonjs-module"
		| "commonjs-static"
		| "amd"
		| "amd-require"
		| "umd"
		| "umd2"
		| "jsonp"
		| "system"
		| "amd-async"
		| "promise"
		| "module-import"
		| "script"
		| "node-commonjs"
		| "asset"
		| "asset-url"
		| "css-import"
		| "css-url";

	/**
	 * Ignore specific warnings.
	 */
	ignoreWarnings?: (
		| RegExp
		| {
				/**
				 * A RegExp or a glob to select the origin file for the warning.
				 */
				file?: string | RegExp;
				/**
				 * A RegExp to select the warning message.
				 */
				message?: RegExp;
				/**
				 * A RegExp to select the origin module for the warning.
				 */
				module?: RegExp;
		  }
		| ((warning: Error, compilation: Compilation) => boolean)
	)[];

	/**
	 * Options for infrastructure level logging.
	 */
	infrastructureLogging?: InfrastructureLogging;

	/**
	 * Custom values available in the loader context.
	 */
	loader?: Loader;

	/**
	 * Enable production optimizations or development hints.
	 */
	mode?: "none" | "development" | "production";

	/**
	 * Options affecting the normal modules (`NormalModuleFactory`).
	 */
	module?: ModuleOptions;

	/**
	 * Name of the configuration. Used when loading multiple configurations.
	 */
	name?: string;

	/**
	 * Include polyfills or mocks for various node stuff.
	 */
	node?: false | NodeOptions;

	/**
	 * Enables/Disables integrated optimizations.
	 */
	optimization?: Optimization;

	/**
	 * Options affecting the output of the compilation. `output` options tell webpack how to write the compiled files to disk.
	 */
	output?: Output;

	/**
	 * The number of parallel processed modules in the compilation.
	 */
	parallelism?: number;

	/**
	 * Configuration for web performance recommendations.
	 */
	performance?: false | PerformanceOptions;

	/**
	 * Add additional plugins to the compiler.
	 */
	plugins?: (
		| undefined
		| null
		| false
		| ""
		| 0
		| ((this: Compiler, compiler: Compiler) => void)
		| WebpackPluginInstance
	)[];

	/**
	 * Capture timing information for each module.
	 */
	profile?: boolean;

	/**
	 * Store compiler state to a json file.
	 */
	recordsInputPath?: string | false;

	/**
	 * Load compiler state from a json file.
	 */
	recordsOutputPath?: string | false;

	/**
	 * Store/Load compiler state from/to a json file. This will result in persistent ids of modules and chunks. An absolute path is expected. `recordsPath` is used for `recordsInputPath` and `recordsOutputPath` if they left undefined.
	 */
	recordsPath?: string | false;

	/**
	 * Options for the resolver.
	 */
	resolve?: ResolveOptionsWebpackOptions;

	/**
	 * Options for the resolver when resolving loaders.
	 */
	resolveLoader?: ResolveOptionsWebpackOptions;

	/**
	 * Options affecting how file system snapshots are created and validated.
	 */
	snapshot?: SnapshotOptionsWebpackOptions;

	/**
	 * Stats options object or preset name.
	 */
	stats?:
		| boolean
		| StatsOptions
		| "none"
		| "summary"
		| "errors-only"
		| "errors-warnings"
		| "minimal"
		| "normal"
		| "detailed"
		| "verbose";

	/**
	 * Environment to build for. An array of environments to build for all of them when possible.
	 */
	target?: string | false | string[];

	/**
	 * Enable validation of webpack configuration. Defaults to true in development mode. In production mode, defaults to true unless futureDefaults is enabled, then defaults to false.
	 */
	validate?: boolean;

	/**
	 * Enter watch mode, which rebuilds on file change.
	 */
	watch?: boolean;

	/**
	 * Options for the watcher.
	 */
	watchOptions?: WatchOptions;
}
type ConnectionState =
	boolean | typeof CIRCULAR_CONNECTION | typeof TRANSITIVE_ONLY;
declare class ConstDependency extends NullDependency {
	/**
	 * Creates an instance of ConstDependency.
	 */
	constructor(
		expression: string,
		range: number | [number, number],
		runtimeRequirements?: null | string[]
	);
	expression: string;
	range: number | [number, number];
	runtimeRequirements: null | Set<string>;
	static Template: typeof ConstDependencyTemplate;

	/**
	 * Compares two dependencies by source location for sorting a module's
	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
	 * its result, so comparing through it would retain a location object on every
	 * sorted dependency). These dependencies always carry a real source position,
	 * so only start (line, column) and the within-statement index are compared; a
	 * dependency without an index sorts after one that has an index at the same
	 * position.
	 */
	static compareLocations(a: Dependency, b: Dependency): 0 | 1 | -1;
	static NO_EXPORTS_REFERENCED: string[][];
	static EXPORTS_OBJECT_REFERENCED: string[][];
	static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];

	/**
	 * Returns true if the dependency is a low priority dependency.
	 */
	static isLowPriorityDependency(dependency: Dependency): boolean;

	/**
	 * Returns true if the dependency can be concatenated (scope hoisting).
	 */
	static canConcatenate(
		dependency: Dependency,
		concatenateCommonJsModules: boolean
	): boolean;
	static TRANSITIVE: symbol;
	static LAZY_LOCAL_EXPORT: "local";
	static LAZY_NAMED_REEXPORT: "id";
	static LAZY_STAR_REEXPORT: "*";
	static LAZY_REEXPORT_SIDE_EFFECT: "@";
	static LAZY_IMPORT_DECLARATION: "import";
	static ESM_CATEGORY: "esm";
	static KINDS: Set<
		| "worker"
		| "css-import"
		| "css-url"
		| "entry"
		| "url"
		| "module-dependency"
		| "esm-import"
		| "provided"
		| "dynamic-import"
		| "esm-reexport"
		| "esm-export-specifier"
		| "esm-live-export"
		| "esm-side-effect-import"
		| "context-element"
		| "esm-bare-side-effect-import"
		| "esm-import-specifier"
		| "esm-evaluated-import-specifier"
		| "esm-compatibility"
		| "commonjs-require"
		| "commonjs-export-require"
		| "html-source"
		| "html-entry"
		| "webassembly-import"
		| "webassembly-export-imported"
		| "sharing-request"
		| "local-module"
		| "static-exports"
		| "loader-import"
		| "css-icss-import"
		| "css-icss-export"
	>;
}
declare class ConstDependencyTemplate extends NullDependencyTemplate {
	constructor();
}
type Constructor = abstract new (...params: never[]) => object;
declare class ConsumeSharedPlugin {
	/**
	 * Creates an instance of ConsumeSharedPlugin.
	 */
	constructor(options: ConsumeSharedPluginOptions);
	options: ConsumeSharedPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Options for consuming shared modules.
 */
declare interface ConsumeSharedPluginOptions {
	consumes: Consumes;

	/**
	 * Share scope name used for all consumed modules (defaults to 'default').
	 */
	shareScope?: string;
}
type Consumes = ConsumesObject | ConsumesBranch1Item[];
type ConsumesBranch1Item = string | ConsumesObject;

/**
 * Advanced configuration for modules that should be consumed from share scope.
 */
declare interface ConsumesConfig {
	/**
	 * Include the fallback module directly instead behind an async request. This allows to use fallback module in initial load too. All possible shared modules need to be eager too.
	 */
	eager?: boolean;
	exclude?: SharedModuleFilter;

	/**
	 * Fallback module if no shared module is found in share scope. Defaults to the property name.
	 */
	import?: string | false;
	include?: SharedModuleFilter;

	/**
	 * Package name to determine required version from description file. This is only needed when package name can't be automatically determined from request.
	 */
	packageName?: string;

	/**
	 * Version requirement from module in share scope.
	 */
	requiredVersion?: string | false;

	/**
	 * Module is looked up under this key from the share scope.
	 */
	shareKey?: string;

	/**
	 * Share scope name.
	 */
	shareScope?: string;

	/**
	 * Allow only a single version of the shared module in share scope (disabled by default).
	 */
	singleton?: boolean;

	/**
	 * Do not accept shared module if version is not valid (defaults to yes, if local fallback module is available and shared module is not a singleton, otherwise no, has no effect if there is no required version specified).
	 */
	strictVersion?: boolean;
}

/**
 * Modules that should be consumed from share scope. Property names are used to match requested modules in this compilation. Relative requests are resolved, module requests are matched unresolved, absolute paths will match resolved requests. A trailing slash will match all requests with this prefix. In this case shareKey must also have a trailing slash.
 */
declare interface ConsumesObject {
	[index: string]: ConsumesObjectValue;
}
type ConsumesObjectValue = string | ConsumesConfig;
type ContainerOptionsFormat<T> = Item<T> | (string | Item<T>)[];
declare class ContainerPlugin {
	/**
	 * Creates an instance of ContainerPlugin.
	 */
	constructor(options: ContainerPluginOptions);
	options: ContainerPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface ContainerPluginOptions {
	exposes: Exposes;

	/**
	 * The filename for this container relative path inside the `output.path` directory.
	 */
	filename?: string;
	library?: LibraryOptions;

	/**
	 * The name for this container.
	 */
	name: string;
	runtime?: string | false;

	/**
	 * The name of the share scope which is shared with the host (defaults to 'default').
	 */
	shareScope?: string;
}
declare class ContainerReferencePlugin {
	/**
	 * Creates an instance of ContainerReferencePlugin.
	 */
	constructor(options: ContainerReferencePluginOptions);
	options: ContainerReferencePluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface ContainerReferencePluginOptions {
	/**
	 * The external type of the remote containers.
	 */
	remoteType: ExternalsType;
	remotes: Remotes;

	/**
	 * The name of the share scope shared with all remotes (defaults to 'default').
	 */
	shareScope?: string;
}
declare interface ContextAlternativeRequest {
	context: string;
	request: string;
}
declare abstract class ContextDependency extends Dependency {
	options: ContextDependencyOptions;
	userRequest: string;
	critical?: string | false;
	hadGlobalOrStickyRegExp: boolean;
	request?: string;
	range?: [number, number];
	valueRange?: [number, number];
	inShorthand?: string | boolean;
	replaces?: { value: string; range: [number, number] }[];
}
type ContextDependencyOptions = ContextOptions & { request: string };
declare abstract class ContextElementDependency extends ModuleDependency {
	referencedExports?: null | string[][];
	attributes?: ImportAttributes;
	phase: ImportPhaseType;

	/**
	 * The request as the user wrote it, e.g. `#configs/file.mjs` where `request`
	 * is the `./file.mjs` relative to the resolved `#configs` directory.
	 */
	get originalRequest(): string;
}
declare class ContextExclusionPlugin {
	/**
	 * Creates an instance of ContextExclusionPlugin.
	 */
	constructor(negativeMatcher: RegExp);
	negativeMatcher: RegExp;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the context file system info entry type used by this module.
 */
declare interface ContextFileSystemInfoEntry {
	safeTime: number;
	timestampHash?: string;
	resolved?: ResolvedContextFileSystemInfoEntry;
	symlinks?: Set<string>;
}

/**
 * Defines the context hash type used by this module.
 */
declare interface ContextHash {
	hash: string;
	resolved?: string;
	symlinks?: Set<string>;
}
type ContextMode =
	"eager" | "weak" | "lazy" | "lazy-once" | "sync" | "async-weak";
type ContextModuleBuildInfo = KnownBuildInfo &
	Record<string, any> &
	KnownContextModuleBuildInfo;
declare abstract class ContextModuleFactory extends ModuleFactory {
	hooks: Readonly<{
		beforeResolve: AsyncSeriesWaterfallHook<
			[BeforeContextResolveData],
			false | void | BeforeContextResolveData
		>;
		afterResolve: AsyncSeriesWaterfallHook<
			[AfterContextResolveData],
			false | void | AfterContextResolveData
		>;
		contextModuleFiles: SyncWaterfallHook<[string[]], string[]>;
		alternatives: FakeHook<
			Pick<
				AsyncSeriesWaterfallHook<
					[ContextAlternativeRequest[]],
					ContextAlternativeRequest[]
				>,
				"name" | "tap" | "tapAsync" | "tapPromise"
			>
		>;
		alternativeRequests: AsyncSeriesWaterfallHook<
			[ContextAlternativeRequest[], ContextModuleOptions],
			ContextAlternativeRequest[]
		>;
	}>;
	resolverFactory: ResolverFactory;

	/**
	 * Resolves dependencies.
	 */
	resolveDependencies(
		fs: InputFileSystem,
		options: ContextModuleOptions,
		callback: (
			err: null | Error,
			dependencies?: ContextElementDependency[]
		) => void
	): void;
}
type ContextModuleOptions = ContextOptions & ContextModuleOptionsExtras;
declare interface ContextModuleOptionsExtras {
	/**
	 * the request of the context as written by the user, before it was resolved
	 */
	request?: string;
	resource: string | false | string[];
	resourceQuery?: string;
	resourceFragment?: string;
	resolveOptions?: ResolveOptionsWebpackOptions;
}
declare interface ContextOptions {
	mode: ContextMode;
	recursive: boolean;
	regExp: null | false | RegExp;
	namespaceObject?: boolean | "strict";
	addon?: string;
	chunkName?: null | string;
	include?: null | RegExp;
	exclude?: null | RegExp;
	groupOptions?: RawChunkGroupOptions;
	typePrefix?: string;
	category?: string;

	/**
	 * exports referenced from modules (won't be mangled)
	 */
	referencedExports?: null | string[][];
	layer?: null | string;
	attributes?: ImportAttributes;
	phase?: 0 | 1 | 2;

	/**
	 * glob patterns for import.meta.glob
	 */
	patterns?: string[];

	/**
	 * importer context for import.meta.glob
	 */
	requestContext?: string;

	/**
	 * import selection for import.meta.glob
	 */
	importName?: string;

	/**
	 * exhaustive mode for import.meta.glob
	 */
	exhaustive?: boolean;

	/**
	 * case-sensitive matching for import.meta.glob
	 */
	caseSensitive?: boolean;
}
declare class ContextReplacementPlugin {
	/**
	 * Creates an instance of ContextReplacementPlugin.
	 */
	constructor(
		resourceRegExp: RegExp,
		newContentResource?:
			| string
			| boolean
			| RegExp
			| ((context: BeforeContextResolveData | AfterContextResolveData) => void),
		newContentRecursive?: boolean | RegExp | NewContentCreateContextMap,
		newContentRegExp?: RegExp
	);
	resourceRegExp: RegExp;
	newContentCallback?: (
		context: BeforeContextResolveData | AfterContextResolveData
	) => void;
	newContentResource?: string;

	/**
	 * Stores new content create context map.
	 */
	newContentCreateContextMap?: (
		fs: InputFileSystem,
		callback: (
			err: null | Error,
			newContentRecursive: NewContentCreateContextMap
		) => void
	) => void;
	newContentRecursive?: boolean;
	newContentRegExp?: RegExp;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the context resolve data type used by this module.
 */
declare interface ContextResolveData {
	context: string;
	request: string;
	resolveOptions?: ResolveOptionsWebpackOptions;
	fileDependencies: LazySet<string>;
	missingDependencies: LazySet<string>;
	contextDependencies: LazySet<string>;
	dependencies: ContextDependency[];
}
type ContextResolver = KnownContext & Record<any, any>;
type ContextTimestamp =
	| null
	| "ignore"
	| ContextFileSystemInfoEntry
	| ExistenceOnlyTimeEntryFileSystemInfo;

/**
 * Defines the context timestamp and hash type used by this module.
 */
declare interface ContextTimestampAndHash {
	safeTime: number;
	timestampHash?: string;
	hash: string;
	resolved?: ResolvedContextTimestampAndHash;
	symlinks?: Set<string>;
}

/**
 * What every callback of a pattern other than `filename` and `transform` reads
 * the file from. `filename` takes webpack's own `(pathData, assetInfo)` instead,
 * as it is a filename template like any other in the configuration.
 */
declare interface CopiedFileData {
	/**
	 * absolute path of the source file
	 */
	absoluteFilename: string;

	/**
	 * path of the source file, relative to the compiler context
	 */
	sourceFilename: string;

	/**
	 * path of the copied file, relative to `to`
	 */
	filename: string;
}

/**
 * Options of the glob in 'from'.
 */
declare interface CopyGlobOptions {
	/**
	 * Whether the glob matches the case of a file name. Defaults to 'true'.
	 */
	caseSensitive?: boolean;

	/**
	 * How many directory levels below the base of the glob are read, where '1' reads only the base itself. Defaults to no limit.
	 */
	deep?: number;

	/**
	 * Whether the glob reaches a file or a directory whose name starts with a dot without naming it. Defaults to 'true'.
	 */
	dot?: boolean;

	/**
	 * Whether a symbolic link is resolved and copied as what it points at. Defaults to 'true'; 'false' copies the link itself, pointing where it already points.
	 */
	followSymlinks?: boolean;

	/**
	 * Globs of the files which are not copied, resolved like 'from'. A directory one of them matches is skipped whole.
	 */
	ignore?: string[];
}

/**
 * A pattern of files which are copied to the output directory.
 */
declare interface CopyObjectPattern {
	/**
	 * Directory 'from' is resolved from and the copied paths are relative to. Defaults to the compiler context, and to what 'from' names when it is not a glob.
	 */
	context?: string;

	/**
	 * Filename template of a copied file inside 'to'. Defaults to '[path][base]', which keeps the name and the directory structure below 'from'.
	 */
	filename?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string);

	/**
	 * Glob or path from where the files are copied.
	 */
	from: string | string[];

	/**
	 * Options of the glob in 'from'.
	 */
	globOptions?: CopyGlobOptions;

	/**
	 * Asset info of a copied file.
	 */
	info?: AssetInfo | ((file: CopiedFileData) => AssetInfo);

	/**
	 * Whether a copied file keeps the permissions of the file it was copied from. Defaults to 'false', which gives it the ones a new file gets. Has no effect on Windows.
	 */
	preservePermissions?: boolean;

	/**
	 * Whether a copied file keeps the access and modification times of the file it was copied from. Defaults to 'false', which stamps it with the time it was written.
	 */
	preserveTimestamps?: boolean;

	/**
	 * Directory the files are copied to, relative to 'output.path', which is where they land by default.
	 */
	to?: string | ((file: CopiedFileData) => string);

	/**
	 * Modifies the content of a copied file.
	 */
	transform?:
		| {
				/**
				 * Whether the result of the transform is cached, and what it is cached under. Defaults to 'true'.
				 */
				cache?:
					| boolean
					| {
							/**
							 * Everything beside the content of the file the transform depends on, serialized into the cache key as JSON.
							 */
							keys?:
								| JsonObjectFs
								| ((
										defaultKeys: JsonObjectFs,
										absoluteFilename: string
								  ) => JsonObjectFs | Promise<JsonObjectFs>);
					  };
				/**
				 * Modifies the content of a copied file.
				 */
				transformer: (
					content: Buffer,
					absoluteFilename: string
				) => string | Buffer | Promise<string | Buffer>;
		  }
		| ((
				content: Buffer,
				absoluteFilename: string
		  ) => string | Buffer | Promise<string | Buffer>);
}

/**
 * Patterns of files which are copied to the output directory, and the options of the copying itself.
 */
declare interface CopyOptions {
	/**
	 * Maximum number of files which are read at the same time. Defaults to '100'.
	 */
	concurrency?: number;

	/**
	 * Patterns of files which are copied to the output directory.
	 */
	patterns: CopyPattern[];

	/**
	 * Stage of 'processAssets' the files are copied at. Defaults to 'Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL', where a copied file is still minimized and compressed like every other asset; a later stage leaves it as it is on disk.
	 */
	stage?: number;
}
type CopyPattern = string | CopyObjectPattern;
declare class CopyPlugin {
	constructor(options: CopyOptions);
	patterns: CopyPattern[];
	concurrency: number;
	stage: number;

	/**
	 * Apply the plugin
	 */
	apply(compiler: Compiler): void;
	static getCompilationHooks: (compilation: Compilation) => {
		/**
		 * Answers whether a path is copied, ahead of `globOptions.ignore`: true never copies it, false copies it whatever `globOptions.ignore` says, and nothing leaves the decision to webpack. A directory has to be answered as well as the files below it, because one that is ignored is never walked.
		 * @since 5.112.0
		 */
		ignore: SyncBailHook<[string], boolean | void>;
	};
}
type CreateData = NormalModuleCreateData & { settings: ModuleSettings };

/**
 * Defines the create read stream fs implementation type used by this module.
 */
declare interface CreateReadStreamFSImplementation {
	open?: (...args: any[]) => any;
	close?: (...args: any[]) => any;
	read: (...args: any[]) => any;
}
type CreateStatsOptionsContext = KnownCreateStatsOptionsContext &
	Record<string, any>;

/**
 * Defines the create write stream fs implementation type used by this module.
 */
declare interface CreateWriteStreamFSImplementation {
	open?: (...args: any[]) => any;
	close?: (...args: any[]) => any;
	write: (...args: any[]) => any;
	writev?: (...args: any[]) => any;
}
type CreatedObject<T, F> = T extends ChunkGroupInfoWithName[]
	? Record<string, StatsChunkGroup>
	: T extends (infer V)[]
		? StatsObject<V, F>[]
		: StatsObject<T, F>;

/**
 * Parser options for css/auto and css/module modules.
 */
declare interface CssAutoOrModuleParserOptions {
	/**
	 * Enable/disable renaming of `@keyframes`.
	 */
	animation?: boolean;

	/**
	 * Configure how the CSS source is parsed: as a full stylesheet (default) or as a block's contents (e.g. the content of an HTML `style` attribute).
	 */
	as?: "stylesheet" | "block-contents";

	/**
	 * Enable/disable renaming of `@container` names.
	 */
	container?: boolean;

	/**
	 * Enable/disable renaming of custom identifiers.
	 */
	customIdents?: boolean;

	/**
	 * Enable/disable resolution of `@custom-media` at-rules (file-local build-time substitution).
	 * @since 5.109.0
	 */
	customMedia?: boolean;

	/**
	 * Enable/disable resolution of `@custom-selector` at-rules (file-local build-time expansion to `:is(...)`).
	 * @since 5.109.0
	 */
	customSelectors?: boolean;

	/**
	 * Enable/disable renaming of dashed identifiers, e. g. custom properties.
	 */
	dashedIdents?: boolean;

	/**
	 * Configure how CSS content is exported as default.
	 */
	exportType?: "link" | "text" | "css-style-sheet" | "style";

	/**
	 * Auto-emit `<link rel="preload" as="font">` for the primary `src` URL of each `@font-face` reachable from an HTML entry's initial CSS. Only the first URL per `@font-face` is preloaded (preloading every format would double-download). Off by default; `parser.css.urlHints` rules and per-URL magic comments still override the seeded defaults. Set `output.crossOriginLoading` so the preload matches the font's CORS fetch.
	 * @since 5.109.0
	 */
	fontPreload?: boolean;

	/**
	 * Enable/disable renaming of `@function` names.
	 */
	function?: boolean;

	/**
	 * Enable/disable renaming of grid identifiers.
	 */
	grid?: boolean;

	/**
	 * Enable/disable `@import` at-rules handling.
	 */
	import?: boolean;

	/**
	 * Use ES modules named export for css exports.
	 */
	namedExports?: boolean;

	/**
	 * Enable strict pure mode: every selector must contain at least one local class or id selector.
	 */
	pure?: boolean;

	/**
	 * Enable/disable `url()`/`image-set()`/`src()`/`image()` functions handling.
	 */
	url?: boolean;

	/**
	 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
	 * @since 5.109.0
	 */
	urlHints?: UrlHintRule[];
}
type CssComponentValueType =
	| 1
	| 2
	| 3
	| 4
	| 5
	| 6
	| 7
	| 8
	| 9
	| 22
	| 10
	| 11
	| 12
	| 13
	| 14
	| 15
	| 16
	| 17
	| 18
	| 19
	| 20
	| 21;

/**
 * Defines the css data type used by this module.
 */
declare interface CssData {
	/**
	 * whether export __esModule
	 */
	esModule: boolean;

	/**
	 * the css exports
	 */
	exports: Map<string, string>;

	/**
	 * source position (line is 1-based, column is 0-based) of each export's defining identifier in the original CSS, used to emit fine-grained JS-to-CSS source mappings
	 */
	exportLocs?: Map<string, { line: number; column: number }>;
}

/**
 * The environment the stylesheet is built for. Every CSS ability the printer
 * reaches for is read off this selection, so nothing states one separately.
 */
declare interface CssEnvironment {
	/**
	 * the browserslist selection (`["chrome 100", "safari 15"]`), so vendor prefixes and every spelling a target has to be able to read are decided for exactly these browsers; absent leaves prefixes untouched and assumes every ability
	 */
	browsers?: string[];

	/**
	 * whether prefixes are written at all; false leaves them alone while the selection still decides which spellings a target reads
	 */
	vendorPrefixes?: boolean;
}
declare abstract class CssGenerator extends Generator<CssNormalModule> {
	options: CssModuleGeneratorOptions;

	/**
	 * Processes the provided module.
	 */
	sourceDependency(
		dependency: Dependency,
		source: ReplaceSource,
		templateContext: DependencyTemplateContext & {
			cssData: CssData;
			type: string;
		}
	): void;

	/**
	 * Processes the provided module.
	 */
	sourceModule(
		module: CssNormalModule,
		initFragments: InitFragment<GenerateContext>[],
		source: ReplaceSource,
		generateContext: GenerateContext & { cssData: CssData }
	): void;

	/**
	 * Generates fallback output for the provided error condition.
	 */
	generateError(
		error: Error,
		module: CssNormalModule,
		generateContext: GenerateContext
	): null | Source;
}

/**
 * Generator options for css modules.
 */
declare interface CssGeneratorOptions {
	/**
	 * Configure the generated JS modules that use the ES modules syntax.
	 */
	esModule?: boolean;

	/**
	 * Avoid generating and loading a stylesheet and only embed exports from css into output javascript files.
	 */
	exportsOnly?: boolean;
}
declare interface CssImportDependencyMeta {
	layer?: string;
	supports?: string;
	media?: string;
}
type CssLayer = undefined | string;
type CssListField = 1 | 2 | 3 | 4;
declare class CssLoadingRuntimeModule extends RuntimeModule {
	constructor(runtimeRequirements: ReadonlySet<string>);
	static getCompilationHooks: (compilation: Compilation) => {
		/**
		 * @since 5.66.0
		 */
		createStylesheet: SyncWaterfallHook<[string, Chunk], string>;
		/**
		 * @since 5.91.0
		 */
		linkPreload: SyncWaterfallHook<[string, Chunk], string>;
		/**
		 * @since 5.91.0
		 */
		linkPrefetch: SyncWaterfallHook<[string, Chunk], string>;
		/**
		 * @since 5.107.0
		 */
		linkInsert: SyncWaterfallHook<[string, Chunk], string>;
	};

	/**
	 * The answer a runtime module gives when it installs no chunk handler at all
	 */
	static NO_CHUNK_HANDLERS: [string, string][];

	/**
	 * Runtime modules without any dependencies to other runtime modules
	 */
	static STAGE_NORMAL: number;

	/**
	 * Runtime modules with simple dependencies on other runtime modules
	 */
	static STAGE_BASIC: number;

	/**
	 * Runtime modules which attach to handlers of other runtime modules
	 */
	static STAGE_ATTACH: number;

	/**
	 * Runtime modules which trigger actions on bootstrap
	 */
	static STAGE_TRIGGER: number;
	static KINDS: Set<
		| "html"
		| "runtime"
		| "normal"
		| "css"
		| "context"
		| "remote"
		| "consume-shared"
		| "external"
		| "concatenated"
	>;

	/**
	 * Gets source basic types.
	 * @deprecated In the next major release, call getSourceBasicTypes() directly on the module instance instead of using this static method.
	 */
	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
}
declare abstract class CssModule extends NormalModule {
	cssLayer: CssLayer;
	supports: Supports;
	media: Media;
	inheritance?: [CssLayer, Supports, Media][];
	exportType?: "link" | "text" | "css-style-sheet" | "style";
}
type CssModuleBuildInfo = KnownBuildInfo &
	Record<string, any> &
	KnownNormalModuleBuildInfo &
	KnownCssModuleBuildInfo;
type CssModuleBuildMeta = KnownBuildMeta &
	Record<string, any> &
	KnownCssModuleBuildMeta;

/**
 * Generator options for css/module modules.
 */
declare interface CssModuleGeneratorOptions {
	/**
	 * Configure the generated JS modules that use the ES modules syntax.
	 */
	esModule?: boolean;

	/**
	 * Configure how CSS content is exported as default.
	 */
	exportType?: "link" | "text" | "css-style-sheet" | "style";

	/**
	 * Specifies the convention of exported names.
	 */
	exportsConvention?:
		| "as-is"
		| "camel-case"
		| "camel-case-only"
		| "dashes"
		| "dashes-only"
		| ((name: string) => string | string[]);

	/**
	 * Avoid generating and loading a stylesheet and only embed exports from css into output javascript files.
	 */
	exportsOnly?: boolean;

	/**
	 * Digest types used for the hash.
	 */
	localIdentHashDigest?: string;

	/**
	 * Number of chars which are used for the hash.
	 */
	localIdentHashDigestLength?: number;

	/**
	 * Algorithm used for generation the hash (see node.js crypto package).
	 */
	localIdentHashFunction?: string | typeof Hash;

	/**
	 * Any string which is added to the hash to salt it.
	 */
	localIdentHashSalt?: string;

	/**
	 * Configure the generated local ident name.
	 */
	localIdentName?: string | TemplatePathFn<PathDataModule>;
}

/**
 * Parser options for css/global modules.
 */
declare interface CssModuleParserOptions {
	/**
	 * Enable/disable renaming of `@keyframes`.
	 */
	animation?: boolean;

	/**
	 * Configure how the CSS source is parsed: as a full stylesheet (default) or as a block's contents (e.g. the content of an HTML `style` attribute).
	 */
	as?: "stylesheet" | "block-contents";

	/**
	 * Enable/disable renaming of `@container` names.
	 */
	container?: boolean;

	/**
	 * Enable/disable renaming of custom identifiers.
	 */
	customIdents?: boolean;

	/**
	 * Enable/disable resolution of `@custom-media` at-rules (file-local build-time substitution).
	 * @since 5.109.0
	 */
	customMedia?: boolean;

	/**
	 * Enable/disable resolution of `@custom-selector` at-rules (file-local build-time expansion to `:is(...)`).
	 * @since 5.109.0
	 */
	customSelectors?: boolean;

	/**
	 * Enable/disable renaming of dashed identifiers, e. g. custom properties.
	 */
	dashedIdents?: boolean;

	/**
	 * Configure how CSS content is exported as default.
	 */
	exportType?: "link" | "text" | "css-style-sheet" | "style";

	/**
	 * Auto-emit `<link rel="preload" as="font">` for the primary `src` URL of each `@font-face` reachable from an HTML entry's initial CSS. Only the first URL per `@font-face` is preloaded (preloading every format would double-download). Off by default; `parser.css.urlHints` rules and per-URL magic comments still override the seeded defaults. Set `output.crossOriginLoading` so the preload matches the font's CORS fetch.
	 * @since 5.109.0
	 */
	fontPreload?: boolean;

	/**
	 * Enable/disable renaming of `@function` names.
	 */
	function?: boolean;

	/**
	 * Enable/disable renaming of grid identifiers.
	 */
	grid?: boolean;

	/**
	 * Enable/disable `@import` at-rules handling.
	 */
	import?: boolean;

	/**
	 * Use ES modules named export for css exports.
	 */
	namedExports?: boolean;

	/**
	 * Enable/disable `url()`/`image-set()`/`src()`/`image()` functions handling.
	 */
	url?: boolean;

	/**
	 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
	 * @since 5.109.0
	 */
	urlHints?: UrlHintRule[];
}
declare class CssModulesPlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Gets modules in order.
	 */
	getModulesInOrder(
		chunk: Chunk,
		modules: undefined | Iterable<Module>,
		compilation: Compilation
	): Module[];

	/**
	 * Gets ordered chunk css modules.
	 */
	getOrderedChunkCssModules(
		chunk: Chunk,
		chunkGraph: ChunkGraph,
		compilation: Compilation
	): CssModule[];

	/**
	 * Renders generated source.
	 */
	renderChunk(
		__0: RenderContextCssModulesPlugin,
		hooks: {
			/**
			 * @since 5.94.0
			 */
			renderModulePackage: SyncWaterfallHook<
				[Source, Module, ChunkRenderContextCssModulesPlugin],
				Source
			>;
			/**
			 * @since 5.94.0
			 */
			chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
			/**
			 * Called for each CSS source type (CSS_IMPORT_TYPE, CSS_TYPE) with the chunk's modules pre-sorted by full module name; return an ordered `Module[]` to override the default import-order topological sort, or return `undefined` to keep the default.
			 * @since 5.107.0
			 */
			orderModules: SyncBailHook<
				[Chunk, Module[], Compilation],
				undefined | void | Module[]
			>;
		}
	): Source;

	/**
	 * Renders css module source.
	 */
	static renderModule(
		module: CssModule,
		renderContext: ChunkRenderContextCssModulesPlugin,
		hooks: {
			/**
			 * @since 5.94.0
			 */
			renderModulePackage: SyncWaterfallHook<
				[Source, Module, ChunkRenderContextCssModulesPlugin],
				Source
			>;
			/**
			 * @since 5.94.0
			 */
			chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
			/**
			 * Called for each CSS source type (CSS_IMPORT_TYPE, CSS_TYPE) with the chunk's modules pre-sorted by full module name; return an ordered `Module[]` to override the default import-order topological sort, or return `undefined` to keep the default.
			 * @since 5.107.0
			 */
			orderModules: SyncBailHook<
				[Chunk, Module[], Compilation],
				undefined | void | Module[]
			>;
		}
	): null | Source;

	/**
	 * Gets chunk filename template.
	 */
	static getChunkFilenameTemplate(
		chunk: Chunk,
		outputOptions: OutputNormalizedWithDefaults
	): ChunkFilenameTemplate;

	/**
	 * Returns true, when the chunk has css.
	 */
	static chunkHasCss(chunk: Chunk, chunkGraph: ChunkGraph): boolean;

	/**
	 * The css-carrying chunks of `chunks`, in the order their rules cascade —
	 * the order a `<link rel="stylesheet">` per chunk has to be written in.
	 */
	static getCssChunksInCascadeOrder(
		chunks: Iterable<Chunk>,
		group: ChunkGroup,
		chunkGraph: ChunkGraph
	): Chunk[];
	static getCompilationHooks: (compilation: Compilation) => {
		/**
		 * @since 5.94.0
		 */
		renderModulePackage: SyncWaterfallHook<
			[Source, Module, ChunkRenderContextCssModulesPlugin],
			Source
		>;
		/**
		 * @since 5.94.0
		 */
		chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
		/**
		 * Called for each CSS source type (CSS_IMPORT_TYPE, CSS_TYPE) with the chunk's modules pre-sorted by full module name; return an ordered `Module[]` to override the default import-order topological sort, or return `undefined` to keep the default.
		 * @since 5.107.0
		 */
		orderModules: SyncBailHook<
			[Chunk, Module[], Compilation],
			undefined | void | Module[]
		>;
	};
}
type CssNodePath<T = number, S = unknown> = Omit<
	{
		state: unknown;
		get node(): NodeSyntaxParser;
		get parent(): null | NodeSyntaxParser;
		get index(): number;
		/**
		 * Stop the walk descending into the current node (enter only).
		 */
		skipChildren(): void;
		/**
		 * Stop the walk: no visitor fires after the current one returns.
		 */
		stop(): void;
		/**
		 * A top-level rule and a comment have none; a hash within a declaration is
		 * a color, elsewhere an id.
		 */
		within(type: number): boolean;
		type(n?: NodeSyntaxParser): number;
		range(n?: NodeSyntaxParser): [number, number];
		start(n?: NodeSyntaxParser): number;
		end(n?: NodeSyntaxParser): number;
		loc(n?: NodeSyntaxParser): [number, number, number, number];
		/**
		 * A node's text exactly as the input wrote it (`name` and `value` decode).
		 */
		source(n?: number | NodeSyntaxParser, end?: number): string;
		/**
		 * The token's value as CSS Syntax defines it: a number for a number,
		 * percentage or dimension, otherwise text with escapes resolved (a string
		 * without its quotes, a hash without its `#`, a `url()`'s contents, a
		 * comment's text); "" for a rule, declaration, function or block.
		 */
		value(n?: NodeSyntaxParser): string | number;
		name(n?: NodeSyntaxParser): string;
		/**
		 * A rule's children are its prelude; its block is read with {@link field }.
		 */
		childCount(n?: NodeSyntaxParser): number;
		child(i: number, n?: NodeSyntaxParser): ComponentValue;
		/**
		 * Every child as a new array, for a reader that keeps or searches them.
		 */
		children(n?: NodeSyntaxParser): ComponentValue[];
		/**
		 * A block big enough to stream hands its children to the visitors as each
		 * one finishes rather than collecting them, so its lists read as empty here.
		 */
		fieldCount(field: number, n?: NodeSyntaxParser): number;
		field(i: number, field: number, n?: NodeSyntaxParser): NodeSyntaxParser;
		fieldNamed(
			field: number,
			name: string,
			n?: NodeSyntaxParser
		): NodeSyntaxParser;
		/**
		 * `important` is a container's bit, cleared when its id is reused; a token's
		 * type flags are read off its text.
		 */
		flag(flag: number, n?: NodeSyntaxParser): boolean;
		rangeOf(part: number, n?: NodeSyntaxParser): null | [number, number];
		startOf(part: number, n?: NodeSyntaxParser): number;
		endOf(part: number, n?: NodeSyntaxParser): number;
		/**
		 * CSS has no text beyond a node's name and value, read with `name` and `value`.
		 */
		textOf(_part: number, _n?: NodeSyntaxParser): null;
	},
	| "flag"
	| "node"
	| "state"
	| "within"
	| "field"
	| "fieldCount"
	| "fieldNamed"
	| "rangeOf"
	| "startOf"
	| "endOf"
	| "textOf"
> & {
	readonly node: TypedNode<NodeSyntaxParser, T>;
	readonly state: S;
	within(type: CssNodeType): boolean;
	field<
		R extends NodeSyntaxParser = TypedNode<NodeSyntaxParser, T>,
		F extends number = number
	>(
		i: number,
		field: F &
			PartOf<
				R,
				{
					"1": never;
					"2": 2;
					"3": never;
					"4": never;
					"5": never;
					"6": never;
					"7": never;
					"8": never;
					"9": never;
					"10": never;
					"11": never;
					"12": never;
					"13": never;
					"14": never;
					"15": never;
					"16": never;
					"17": never;
					"18": never;
					"19": never;
					"20": never;
					"21": never;
					"22": 2;
					"23": 2;
					"24": 1 | 3 | 4;
					"25": 1 | 3 | 4;
					"26": 4;
					"27": never;
					"28": never;
				},
				CssListField
			>,
		n?: R
	): TypedNode<
		NodeSyntaxParser,
		{
			[index: number]: number;
			"1": CssComponentValueType;
			"2": CssComponentValueType;
			"3": 23;
			"4": 24 | 25;
		}[F]
	>;
	fieldCount<R extends NodeSyntaxParser = TypedNode<NodeSyntaxParser, T>>(
		field: PartOf<
			R,
			{
				"1": never;
				"2": 2;
				"3": never;
				"4": never;
				"5": never;
				"6": never;
				"7": never;
				"8": never;
				"9": never;
				"10": never;
				"11": never;
				"12": never;
				"13": never;
				"14": never;
				"15": never;
				"16": never;
				"17": never;
				"18": never;
				"19": never;
				"20": never;
				"21": never;
				"22": 2;
				"23": 2;
				"24": 1 | 3 | 4;
				"25": 1 | 3 | 4;
				"26": 4;
				"27": never;
				"28": never;
			},
			CssListField
		>,
		n?: R
	): number;
	fieldNamed<
		R extends NodeSyntaxParser = TypedNode<NodeSyntaxParser, T>,
		F extends number = number
	>(
		field: F &
			PartOf<
				R,
				{
					"1": never;
					"2": 2;
					"3": never;
					"4": never;
					"5": never;
					"6": never;
					"7": never;
					"8": never;
					"9": never;
					"10": never;
					"11": never;
					"12": never;
					"13": never;
					"14": never;
					"15": never;
					"16": never;
					"17": never;
					"18": never;
					"19": never;
					"20": never;
					"21": never;
					"22": 2;
					"23": 2;
					"24": 1 | 3 | 4;
					"25": 1 | 3 | 4;
					"26": 4;
					"27": never;
					"28": never;
				},
				CssListField
			>,
		name: string,
		n?: R
	): TypedNode<
		NodeSyntaxParser,
		{
			[index: number]: number;
			"1": CssComponentValueType;
			"2": CssComponentValueType;
			"3": 23;
			"4": 24 | 25;
		}[F]
	>;
	flag<R extends NodeSyntaxParser = TypedNode<NodeSyntaxParser, T>>(
		flag: PartOf<
			R,
			{
				"1": never;
				"2": never;
				"3": never;
				"4": 4;
				"5": never;
				"6": never;
				"7": never;
				"8": never;
				"9": never;
				"10": 2;
				"11": 2;
				"12": 2;
				"13": never;
				"14": never;
				"15": never;
				"16": never;
				"17": never;
				"18": never;
				"19": never;
				"20": never;
				"21": never;
				"22": never;
				"23": 1;
				"24": never;
				"25": never;
				"26": never;
				"27": never;
				"28": never;
			},
			1 | 2 | 4
		>,
		n?: R
	): boolean;
	rangeOf<R extends NodeSyntaxParser = TypedNode<NodeSyntaxParser, T>>(
		part: PartOf<
			R,
			{
				"1": never;
				"2": 1;
				"3": never;
				"4": never;
				"5": never;
				"6": never;
				"7": 2;
				"8": never;
				"9": never;
				"10": never;
				"11": never;
				"12": 1;
				"13": never;
				"14": never;
				"15": never;
				"16": never;
				"17": never;
				"18": never;
				"19": never;
				"20": never;
				"21": never;
				"22": never;
				"23": 1;
				"24": 1 | 3;
				"25": 3;
				"26": never;
				"27": never;
				"28": never;
			},
			1 | 2 | 3
		>,
		n?: R
	): null | [number, number];
	startOf<R extends NodeSyntaxParser = TypedNode<NodeSyntaxParser, T>>(
		part: PartOf<
			R,
			{
				"1": never;
				"2": 1;
				"3": never;
				"4": never;
				"5": never;
				"6": never;
				"7": 2;
				"8": never;
				"9": never;
				"10": never;
				"11": never;
				"12": 1;
				"13": never;
				"14": never;
				"15": never;
				"16": never;
				"17": never;
				"18": never;
				"19": never;
				"20": never;
				"21": never;
				"22": never;
				"23": 1;
				"24": 1 | 3;
				"25": 3;
				"26": never;
				"27": never;
				"28": never;
			},
			1 | 2 | 3
		>,
		n?: R
	): number;
	endOf<R extends NodeSyntaxParser = TypedNode<NodeSyntaxParser, T>>(
		part: PartOf<
			R,
			{
				"1": never;
				"2": 1;
				"3": never;
				"4": never;
				"5": never;
				"6": never;
				"7": 2;
				"8": never;
				"9": never;
				"10": never;
				"11": never;
				"12": 1;
				"13": never;
				"14": never;
				"15": never;
				"16": never;
				"17": never;
				"18": never;
				"19": never;
				"20": never;
				"21": never;
				"22": never;
				"23": 1;
				"24": 1 | 3;
				"25": 3;
				"26": never;
				"27": never;
				"28": never;
			},
			1 | 2 | 3
		>,
		n?: R
	): number;
	textOf<R extends NodeSyntaxParser = TypedNode<NodeSyntaxParser, T>>(
		part: PartOf<
			R,
			{
				"1": never;
				"2": never;
				"3": never;
				"4": never;
				"5": never;
				"6": never;
				"7": never;
				"8": never;
				"9": never;
				"10": never;
				"11": never;
				"12": never;
				"13": never;
				"14": never;
				"15": never;
				"16": never;
				"17": never;
				"18": never;
				"19": never;
				"20": never;
				"21": never;
				"22": never;
				"23": never;
				"24": never;
				"25": never;
				"26": never;
				"27": never;
				"28": never;
			},
			never
		>,
		n?: R
	): null | string;
};
type CssNodeType =
	| 1
	| 2
	| 3
	| 4
	| 5
	| 6
	| 7
	| 8
	| 9
	| 22
	| 10
	| 11
	| 12
	| 13
	| 14
	| 15
	| 16
	| 17
	| 18
	| 19
	| 20
	| 21
	| 23
	| 24
	| 25
	| 26
	| 27
	| 28;
type CssNormalModule = NormalModule & {
	buildInfo?: CssModuleBuildInfo;
	buildMeta?: CssModuleBuildMeta;
};
declare abstract class CssParser extends Parser<BuiltCssModule> {
	defaultMode: "global" | "auto" | "local" | "pure";
	options: {
		/**
		 * Enable/disable renaming of `@keyframes`.
		 */
		animation: boolean;
		/**
		 * Configure how the CSS source is parsed: as a full stylesheet (default) or as a block's contents (e.g. the content of an HTML `style` attribute).
		 */
		as: string;
		/**
		 * Enable/disable renaming of `@container` names.
		 */
		container: boolean;
		/**
		 * Enable/disable renaming of custom identifiers.
		 */
		customIdents: boolean;
		/**
		 * Enable/disable resolution of `@custom-media` at-rules (file-local build-time substitution).
		 * @since 5.109.0
		 */
		customMedia: boolean;
		/**
		 * Enable/disable resolution of `@custom-selector` at-rules (file-local build-time expansion to `:is(...)`).
		 * @since 5.109.0
		 */
		customSelectors: boolean;
		/**
		 * Enable/disable renaming of dashed identifiers, e. g. custom properties.
		 */
		dashedIdents: boolean;
		/**
		 * Configure how CSS content is exported as default.
		 */
		exportType?: "link" | "text" | "css-style-sheet" | "style";
		/**
		 * Auto-emit `<link rel="preload" as="font">` for the primary `src` URL of each `@font-face` reachable from an HTML entry's initial CSS. Only the first URL per `@font-face` is preloaded (preloading every format would double-download). Off by default; `parser.css.urlHints` rules and per-URL magic comments still override the seeded defaults. Set `output.crossOriginLoading` so the preload matches the font's CORS fetch.
		 * @since 5.109.0
		 */
		fontPreload?: boolean;
		/**
		 * Enable/disable renaming of `@function` names.
		 */
		function: boolean;
		/**
		 * Enable/disable renaming of grid identifiers.
		 */
		grid: boolean;
		/**
		 * Enable/disable `@import` at-rules handling.
		 */
		import: boolean;
		/**
		 * Use ES modules named export for css exports.
		 */
		namedExports: boolean;
		/**
		 * Enable strict pure mode: every selector must contain at least one local class or id selector.
		 */
		pure?: boolean;
		/**
		 * Enable/disable `url()`/`image-set()`/`src()`/`image()` functions handling.
		 */
		url: boolean;
		/**
		 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
		 * @since 5.109.0
		 */
		urlHints?: UrlHintRule[];
		/**
		 * default mode
		 */
		defaultMode?: "global" | "auto" | "local" | "pure";
	};
	magicCommentContext: ContextImport;
}

/**
 * Parser options for css modules.
 */
declare interface CssParserOptions {
	/**
	 * Configure how the CSS source is parsed: as a full stylesheet (default) or as a block's contents (e.g. the content of an HTML `style` attribute).
	 */
	as?: "stylesheet" | "block-contents";

	/**
	 * Enable/disable resolution of `@custom-media` at-rules (file-local build-time substitution).
	 * @since 5.109.0
	 */
	customMedia?: boolean;

	/**
	 * Enable/disable resolution of `@custom-selector` at-rules (file-local build-time expansion to `:is(...)`).
	 * @since 5.109.0
	 */
	customSelectors?: boolean;

	/**
	 * Configure how CSS content is exported as default.
	 */
	exportType?: "link" | "text" | "css-style-sheet" | "style";

	/**
	 * Auto-emit `<link rel="preload" as="font">` for the primary `src` URL of each `@font-face` reachable from an HTML entry's initial CSS. Only the first URL per `@font-face` is preloaded (preloading every format would double-download). Off by default; `parser.css.urlHints` rules and per-URL magic comments still override the seeded defaults. Set `output.crossOriginLoading` so the preload matches the font's CORS fetch.
	 * @since 5.109.0
	 */
	fontPreload?: boolean;

	/**
	 * Enable/disable `@import` at-rules handling.
	 */
	import?: boolean;

	/**
	 * Use ES modules named export for css exports.
	 */
	namedExports?: boolean;

	/**
	 * Enable/disable `url()`/`image-set()`/`src()`/`image()` functions handling.
	 */
	url?: boolean;

	/**
	 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
	 * @since 5.109.0
	 */
	urlHints?: UrlHintRule[];
}

/**
 * CSS's parts by node type, which type each visitor's path; every CSS `Field`
 * is a list.
 */
declare interface CssParts {
	types: CssNodeType;
	field: CssListField;
	flag: 1 | 2 | 4;
	part: 1 | 2 | 3;
	text: never;
	fields: {
		"1": never;
		"2": 2;
		"3": never;
		"4": never;
		"5": never;
		"6": never;
		"7": never;
		"8": never;
		"9": never;
		"10": never;
		"11": never;
		"12": never;
		"13": never;
		"14": never;
		"15": never;
		"16": never;
		"17": never;
		"18": never;
		"19": never;
		"20": never;
		"21": never;
		"22": 2;
		"23": 2;
		"24": 1 | 3 | 4;
		"25": 1 | 3 | 4;
		"26": 4;
		"27": never;
		"28": never;
	};
	flags: {
		"1": never;
		"2": never;
		"3": never;
		"4": 4;
		"5": never;
		"6": never;
		"7": never;
		"8": never;
		"9": never;
		"10": 2;
		"11": 2;
		"12": 2;
		"13": never;
		"14": never;
		"15": never;
		"16": never;
		"17": never;
		"18": never;
		"19": never;
		"20": never;
		"21": never;
		"22": never;
		"23": 1;
		"24": never;
		"25": never;
		"26": never;
		"27": never;
		"28": never;
	};
	parts: {
		"1": never;
		"2": 1;
		"3": never;
		"4": never;
		"5": never;
		"6": never;
		"7": 2;
		"8": never;
		"9": never;
		"10": never;
		"11": never;
		"12": 1;
		"13": never;
		"14": never;
		"15": never;
		"16": never;
		"17": never;
		"18": never;
		"19": never;
		"20": never;
		"21": never;
		"22": never;
		"23": 1;
		"24": 1 | 3;
		"25": 3;
		"26": never;
		"27": never;
		"28": never;
	};
	texts: {
		"1": never;
		"2": never;
		"3": never;
		"4": never;
		"5": never;
		"6": never;
		"7": never;
		"8": never;
		"9": never;
		"10": never;
		"11": never;
		"12": never;
		"13": never;
		"14": never;
		"15": never;
		"16": never;
		"17": never;
		"18": never;
		"19": never;
		"20": never;
		"21": never;
		"22": never;
		"23": never;
		"24": never;
		"25": never;
		"26": never;
		"27": never;
		"28": never;
	};
	items: {
		[index: number]: number;
		"1": CssComponentValueType;
		"2": CssComponentValueType;
		"3": 23;
		"4": 24 | 25;
	};
}

/**
 * What the CSS printer may be told, on top of the `mode` every language has —
 * the printing slice of `CssProcessOptions`, named once so nothing outside CSS
 * has to enumerate it.
 */
declare interface CssPrintOptions {
	/**
	 * `false` when the stylesheet is read as UTF-8 wherever it is served, so no `@charset` is written for it and a string's hex escape of a character past U+FFFF is written as the character, as `declareCharset` writes it. `"auto"` by default, and only read while printing
	 */
	charset?: false | "auto";

	/**
	 * what the target can read (the CSS entries of `output.environment`), so a spelling it would not understand is never reached for; only read while printing, and an absent entry means the modern spelling is available
	 */
	environment?: CssEnvironment;

	/**
	 * renders source this stylesheet embeds: the payload of a `url()` `data:` URL whose media type names a language webpack knows (SVG, CSS, HTML, JSON, JavaScript). Absent, a data URL is emitted exactly as written
	 */
	renderEmbeddedSource?: (
		source: string,
		info: { type: string; hostType: string }
	) => undefined | string;

	/**
	 * rewrite a length into a shorter unit it is exactly equal in (`16px` -> `1pc`); off by default because it earns nothing once the asset is compressed, and only read while printing. A time is always rewritten
	 */
	convertLengthUnits?: boolean;

	/**
	 * write a polar or Lab color as the nearest hex even where that hex only approximates it: a channel too near a `.5` boundary for two engines to round it alike, and a color outside the sRGB gamut, which hex can only clip. Off by default, and only read while printing; a space engines read through transfers of their own (`a98-rgb`, `prophoto-rgb`) is left alone either way
	 */
	convertApproximateColors?: boolean;

	/**
	 * drop a declaration a later one in the same block overrides even where no target is selected, wherever Chromium, Gecko and WebKit each read the later value; off by default, and only read while printing. With a `browserslist` selection the drop is already made wherever every browser it names is known to read the later value, so this widens the case where no target is selected — a selection naming a browser the tables do not cover still answers for the whole of it
	 */
	dropOverriddenDeclarations?: boolean;

	/**
	 * shorten a custom property's value the way any other value is shortened (`--x:#ffffff` -> `#fff`); off by default because `getPropertyValue()` hands that text back, and only read while printing. What it may rewrite is what any other value's tokens may be, a color in a substitution's fallback included — that being the property's value rather than the function's own argument
	 */
	rewriteCustomProperties?: boolean;

	/**
	 * which of the meaning-preserving rewrites the minifying print makes; each is on unless it is `false`
	 */
	transforms?: CssTransformOptions;

	/**
	 * names a whole-project analysis found unused, which the print takes out: a bare name is a class, an id and an `@keyframes` name, and a `--`-prefixed one is a custom property. Only read while printing
	 */
	unusedSymbols?: string[];

	/**
	 * each pseudo-class to write as a class instead (`{ "focus-visible": "focus-visible" }`), so a script can apply it where the engine does not. Only read while printing
	 */
	pseudoClasses?: { [index: string]: string };

	/**
	 * collects what `renderEmbeddedSource` would be offered instead of offering it, for a caller whose renderer is asynchronous: the print leaves a marker for each and `finish` puts the answers in their place, so one parse serves both. Takes precedence over `renderEmbeddedSource`
	 */
	deferEmbeddedSource?: DeferredEmbeddedSource[];

	/**
	 * open the stylesheet with `@charset "UTF-8"` exactly when its output holds a non-ASCII character, so it is read as UTF-8 wherever it is served, and write a string's hex escape of a character past U+FFFF as the character, which costs fewer bytes once compressed; for a stylesheet that is a file of its own, as `@charset` is read only as one's opening bytes. Off by default, and only read while printing
	 */
	declareCharset?: boolean;

	/**
	 * give a rule the selectors of a later one printing the same block, and an at-rule the block of a later one stating the same condition, past the rules between them; off by default, since it reorders the cascade and is sound only where nothing between declares what the block being moved does for an element it can match — a condition between counting for what its own rules declare
	 */
	mergeDistantRules?: boolean;
}
declare interface CssProcessOptions {
	/**
	 * shared loc converter (default a fresh one over the input)
	 */
	locConverter?: LocConverter;

	/**
	 * walk into block bodies' nested rules (default true); ignored while printing, as `skip` is, since a block is printed from the children it would leave unread
	 */
	recurseBlocks?: boolean;

	/**
	 * which top-level production to consume the source as (see `TOP_LEVEL_CONSUMERS`): `"stylesheet"` (default) or `"block-contents"` (a block's contents, e.g. an HTML `style` attribute)
	 */
	as?: "stylesheet" | "block-contents";

	/**
	 * what the grammar may leave un-materialized to go faster — safe only for parts nothing reads in the active parse; default skip nothing. Ignored while printing (`minimize`), which needs every node
	 */
	skip?: SkipOptions;

	/**
	 * print the safely-minified serialization (collapsed whitespace, dropped redundant separators, the `printer`'s value transforms) as `process` walks and return `{ code, map }` (default false = walk only, return `undefined`)
	 */
	minimize?: boolean;

	/**
	 * name of the input in the emitted source map (`sources[0]` / `file`); only read while printing
	 */
	source?: string;

	/**
	 * the input's contents for the map's `sourcesContent`; only read while printing
	 */
	content?: string;

	/**
	 * what the target can read (the CSS entries of `output.environment`), so a spelling it would not understand is never reached for; only read while printing, and an absent entry means the modern spelling is available
	 */
	environment?: CssEnvironment;

	/**
	 * open the stylesheet with `@charset "UTF-8"` exactly when its output holds a non-ASCII character, so it is read as UTF-8 wherever it is served, and write a string's hex escape of a character past U+FFFF as the character, which costs fewer bytes once compressed; for a stylesheet that is a file of its own, as `@charset` is read only as one's opening bytes. Off by default, and only read while printing
	 */
	declareCharset?: boolean;

	/**
	 * `false` when the stylesheet is read as UTF-8 wherever it is served, so no `@charset` is written for it and a string's hex escape of a character past U+FFFF is written as the character, as `declareCharset` writes it. `"auto"` by default, and only read while printing
	 */
	charset?: false | "auto";

	/**
	 * rewrite a length into a shorter unit it is exactly equal in (`16px` -> `1pc`); off by default because it earns nothing once the asset is compressed, and only read while printing. A time is always rewritten
	 */
	convertLengthUnits?: boolean;

	/**
	 * write a polar or Lab color as the nearest hex even where that hex only approximates it: a channel too near a `.5` boundary for two engines to round it alike, and a color outside the sRGB gamut, which hex can only clip. Off by default, and only read while printing; a space engines read through transfers of their own (`a98-rgb`, `prophoto-rgb`) is left alone either way
	 */
	convertApproximateColors?: boolean;

	/**
	 * give a rule the selectors of a later one printing the same block, and an at-rule the block of a later one stating the same condition, past the rules between them; off by default, since it reorders the cascade and is sound only where nothing between declares what the block being moved does for an element it can match — a condition between counting for what its own rules declare
	 */
	mergeDistantRules?: boolean;

	/**
	 * drop a declaration a later one in the same block overrides even where no target is selected, wherever Chromium, Gecko and WebKit each read the later value; off by default, and only read while printing. With a `browserslist` selection the drop is already made wherever every browser it names is known to read the later value, so this widens the case where no target is selected — a selection naming a browser the tables do not cover still answers for the whole of it
	 */
	dropOverriddenDeclarations?: boolean;

	/**
	 * shorten a custom property's value the way any other value is shortened (`--x:#ffffff` -> `#fff`); off by default because `getPropertyValue()` hands that text back, and only read while printing. What it may rewrite is what any other value's tokens may be, a color in a substitution's fallback included — that being the property's value rather than the function's own argument
	 */
	rewriteCustomProperties?: boolean;

	/**
	 * renders source this stylesheet embeds: the payload of a `url()` `data:` URL whose media type names a language webpack knows (SVG, CSS, HTML, JSON, JavaScript). Absent, a data URL is emitted exactly as written
	 */
	renderEmbeddedSource?: (
		source: string,
		info: { type: string; hostType: string }
	) => undefined | string;

	/**
	 * each pseudo-class to write as a class instead (`{ "focus-visible": "focus-visible" }`), so a script can apply it where the engine does not. Only read while printing
	 */
	pseudoClasses?: { [index: string]: string };

	/**
	 * names a whole-project analysis found unused, which the print takes out: a bare name is a class, an id and an `@keyframes` name, and a `--`-prefixed one is a custom property. Only read while printing
	 */
	unusedSymbols?: string[];

	/**
	 * which of the meaning-preserving rewrites the minifying print makes; each is on unless it is `false`
	 */
	transforms?: CssTransformOptions;

	/**
	 * collects what `renderEmbeddedSource` would be offered instead of offering it, for a caller whose renderer is asynchronous: the print leaves a marker for each and `finish` puts the answers in their place, so one parse serves both. Takes precedence over `renderEmbeddedSource`
	 */
	deferEmbeddedSource?: DeferredEmbeddedSource[];
}

/**
 * The generic visitor coordinator (`util/SourceProcessor`) bound to the CSS
 * `grammar`. All configuration is per `process` call. `process(src, { minimize:
 * true })` returns `{ code, map }` — the safely-minified serialization (built by
 * the same walk that fires visitors) and its source map; without `minimize` it
 * just walks and returns `undefined`. Usage:
 * ```
 * new CssSourceProcessor().use({ [NodeType.AtRule]: (path) => {} }).process(source, { skip });
 * ```
 * @experimental exposed as `webpack.css.syntax.SourceProcessor`; unstable API
 */
declare class CssSourceProcessor<TState = unknown> extends SourceProcessor<
	{
		state: unknown;
		get node(): NodeSyntaxParser;
		get parent(): null | NodeSyntaxParser;
		get index(): number;
		/**
		 * Stop the walk descending into the current node (enter only).
		 */
		skipChildren(): void;
		/**
		 * Stop the walk: no visitor fires after the current one returns.
		 */
		stop(): void;
		/**
		 * A top-level rule and a comment have none; a hash within a declaration is
		 * a color, elsewhere an id.
		 */
		within(type: number): boolean;
		type(n?: NodeSyntaxParser): number;
		range(n?: NodeSyntaxParser): [number, number];
		start(n?: NodeSyntaxParser): number;
		end(n?: NodeSyntaxParser): number;
		loc(n?: NodeSyntaxParser): [number, number, number, number];
		/**
		 * A node's text exactly as the input wrote it (`name` and `value` decode).
		 */
		source(n?: number | NodeSyntaxParser, end?: number): string;
		/**
		 * The token's value as CSS Syntax defines it: a number for a number,
		 * percentage or dimension, otherwise text with escapes resolved (a string
		 * without its quotes, a hash without its `#`, a `url()`'s contents, a
		 * comment's text); "" for a rule, declaration, function or block.
		 */
		value(n?: NodeSyntaxParser): string | number;
		name(n?: NodeSyntaxParser): string;
		/**
		 * A rule's children are its prelude; its block is read with {@link field }.
		 */
		childCount(n?: NodeSyntaxParser): number;
		child(i: number, n?: NodeSyntaxParser): ComponentValue;
		/**
		 * Every child as a new array, for a reader that keeps or searches them.
		 */
		children(n?: NodeSyntaxParser): ComponentValue[];
		/**
		 * A block big enough to stream hands its children to the visitors as each
		 * one finishes rather than collecting them, so its lists read as empty here.
		 */
		fieldCount(field: number, n?: NodeSyntaxParser): number;
		field(i: number, field: number, n?: NodeSyntaxParser): NodeSyntaxParser;
		fieldNamed(
			field: number,
			name: string,
			n?: NodeSyntaxParser
		): NodeSyntaxParser;
		/**
		 * `important` is a container's bit, cleared when its id is reused; a token's
		 * type flags are read off its text.
		 */
		flag(flag: number, n?: NodeSyntaxParser): boolean;
		rangeOf(part: number, n?: NodeSyntaxParser): null | [number, number];
		startOf(part: number, n?: NodeSyntaxParser): number;
		endOf(part: number, n?: NodeSyntaxParser): number;
		/**
		 * CSS has no text beyond a node's name and value, read with `name` and `value`.
		 */
		textOf(_part: number, _n?: NodeSyntaxParser): null;
	},
	NodeSyntaxParser,
	CssProcessOptions,
	CssPrintOptions,
	CssParts,
	TState,
	CssVisitorMap<TState>
> {
	constructor();
	static PrintContext: typeof PrintContext;
	static declineDeferredWrites: (
		text: string,
		writes: DeferredWrite[]
	) => string;
	static deferredWrite: (id: number) => string;
}

/**
 * What the minifying printer may rewrite. Every entry is on unless it is
 * `false`, so a document one transform breaks can still be minified by the rest.
 */
declare interface CssTransformOptions {
	/**
	 * write a color the target cannot read as an extra declaration before it, in a spelling it does read
	 */
	colorFallbacks?: boolean;

	/**
	 * write a spelling the target cannot read as one it can — the same value, said another way
	 */
	lowerUnsupported?: boolean;

	/**
	 * write a name that matches ASCII case-insensitively — an at-rule, property, pseudo, function, unit or keyword — in lowercase
	 */
	foldCase?: boolean;

	/**
	 * write an escaped identifier the shortest way that names it, wherever it stands
	 */
	rewriteEscapes?: boolean;

	/**
	 * which comments survive: `"some"` (the default) the ones that carry something, `true` / `"all"` every one, `false` none, or the ones a pattern matches / a predicate accepts, over the comment's own text
	 */
	comments?: string | boolean | RegExp | ((comment: string) => boolean);

	/**
	 * write the query a `@custom-media` names wherever a condition asks for it, and drop the rule that named it
	 */
	customMedia?: boolean;

	/**
	 * write the selector list a `@custom-selector` names as `:is(…)` wherever a selector asks for it, and drop the rule that named it
	 */
	customSelectors?: boolean;

	/**
	 * write a family of longhands as the one shorthand that sets them
	 */
	mergeLonghands?: boolean;

	/**
	 * join rules that print the same block, at-rules that share a prelude, and a named `@layer` block a later sibling opens again
	 */
	mergeRules?: boolean;

	/**
	 * normalize a string's, `url()`'s, font family's and attribute value's quoting
	 */
	normalizeQuotes?: boolean;

	/**
	 * compute a call into the shorter call naming the same value (`calc()` and the math functions, transforms, gradients, easing functions, filters)
	 */
	reduceFunctions?: boolean;

	/**
	 * drop a rule or declaration nothing can read: an empty rule, and one an identical later one supersedes
	 */
	removeDeadRules?: boolean;

	/**
	 * print a style rule's declarations in one order by family, so blocks setting the same things read alike; only declarations whose order nothing can see move
	 */
	reorderDeclarations?: boolean;

	/**
	 * write a `:dir()` the target cannot read as the `[dir]` attribute selector, which reads the attribute rather than the directionality an element may inherit
	 */
	rewriteDirSelector?: boolean;

	/**
	 * write each color in the shortest spelling of the same value
	 */
	shortenColors?: boolean;

	/**
	 * write a media feature in its range spelling and collapse an `and` of two into the interval
	 */
	shortenMediaQueries?: boolean;

	/**
	 * write each number in its shortest equal spelling
	 */
	shortenNumbers?: boolean;

	/**
	 * rewrite a selector into a shorter equal one
	 */
	shortenSelectors?: boolean;

	/**
	 * write a value the shortest way its property's own grammar allows
	 */
	shortenValues?: boolean;
}
declare interface CssVisitorMap<S = unknown> {
	"1"?:
		| VisitorFn<CssNodePath<1, S>>
		| {
				enter?: VisitorFn<CssNodePath<1, S>>;
				exit?: VisitorFn<CssNodePath<1, S>>;
		  };
	"2"?:
		| VisitorFn<CssNodePath<2, S>>
		| {
				enter?: VisitorFn<CssNodePath<2, S>>;
				exit?: VisitorFn<CssNodePath<2, S>>;
		  };
	"3"?:
		| VisitorFn<CssNodePath<3, S>>
		| {
				enter?: VisitorFn<CssNodePath<3, S>>;
				exit?: VisitorFn<CssNodePath<3, S>>;
		  };
	"4"?:
		| VisitorFn<CssNodePath<4, S>>
		| {
				enter?: VisitorFn<CssNodePath<4, S>>;
				exit?: VisitorFn<CssNodePath<4, S>>;
		  };
	"5"?:
		| VisitorFn<CssNodePath<5, S>>
		| {
				enter?: VisitorFn<CssNodePath<5, S>>;
				exit?: VisitorFn<CssNodePath<5, S>>;
		  };
	"6"?:
		| VisitorFn<CssNodePath<6, S>>
		| {
				enter?: VisitorFn<CssNodePath<6, S>>;
				exit?: VisitorFn<CssNodePath<6, S>>;
		  };
	"7"?:
		| VisitorFn<CssNodePath<7, S>>
		| {
				enter?: VisitorFn<CssNodePath<7, S>>;
				exit?: VisitorFn<CssNodePath<7, S>>;
		  };
	"8"?:
		| VisitorFn<CssNodePath<8, S>>
		| {
				enter?: VisitorFn<CssNodePath<8, S>>;
				exit?: VisitorFn<CssNodePath<8, S>>;
		  };
	"9"?:
		| VisitorFn<CssNodePath<9, S>>
		| {
				enter?: VisitorFn<CssNodePath<9, S>>;
				exit?: VisitorFn<CssNodePath<9, S>>;
		  };
	"10"?:
		| VisitorFn<CssNodePath<10, S>>
		| {
				enter?: VisitorFn<CssNodePath<10, S>>;
				exit?: VisitorFn<CssNodePath<10, S>>;
		  };
	"11"?:
		| VisitorFn<CssNodePath<11, S>>
		| {
				enter?: VisitorFn<CssNodePath<11, S>>;
				exit?: VisitorFn<CssNodePath<11, S>>;
		  };
	"12"?:
		| VisitorFn<CssNodePath<12, S>>
		| {
				enter?: VisitorFn<CssNodePath<12, S>>;
				exit?: VisitorFn<CssNodePath<12, S>>;
		  };
	"13"?:
		| VisitorFn<CssNodePath<13, S>>
		| {
				enter?: VisitorFn<CssNodePath<13, S>>;
				exit?: VisitorFn<CssNodePath<13, S>>;
		  };
	"14"?:
		| VisitorFn<CssNodePath<14, S>>
		| {
				enter?: VisitorFn<CssNodePath<14, S>>;
				exit?: VisitorFn<CssNodePath<14, S>>;
		  };
	"15"?:
		| VisitorFn<CssNodePath<15, S>>
		| {
				enter?: VisitorFn<CssNodePath<15, S>>;
				exit?: VisitorFn<CssNodePath<15, S>>;
		  };
	"16"?:
		| VisitorFn<CssNodePath<16, S>>
		| {
				enter?: VisitorFn<CssNodePath<16, S>>;
				exit?: VisitorFn<CssNodePath<16, S>>;
		  };
	"17"?:
		| VisitorFn<CssNodePath<17, S>>
		| {
				enter?: VisitorFn<CssNodePath<17, S>>;
				exit?: VisitorFn<CssNodePath<17, S>>;
		  };
	"18"?:
		| VisitorFn<CssNodePath<18, S>>
		| {
				enter?: VisitorFn<CssNodePath<18, S>>;
				exit?: VisitorFn<CssNodePath<18, S>>;
		  };
	"19"?:
		| VisitorFn<CssNodePath<19, S>>
		| {
				enter?: VisitorFn<CssNodePath<19, S>>;
				exit?: VisitorFn<CssNodePath<19, S>>;
		  };
	"20"?:
		| VisitorFn<CssNodePath<20, S>>
		| {
				enter?: VisitorFn<CssNodePath<20, S>>;
				exit?: VisitorFn<CssNodePath<20, S>>;
		  };
	"21"?:
		| VisitorFn<CssNodePath<21, S>>
		| {
				enter?: VisitorFn<CssNodePath<21, S>>;
				exit?: VisitorFn<CssNodePath<21, S>>;
		  };
	"22"?:
		| VisitorFn<CssNodePath<22, S>>
		| {
				enter?: VisitorFn<CssNodePath<22, S>>;
				exit?: VisitorFn<CssNodePath<22, S>>;
		  };
	"23"?:
		| VisitorFn<CssNodePath<23, S>>
		| {
				enter?: VisitorFn<CssNodePath<23, S>>;
				exit?: VisitorFn<CssNodePath<23, S>>;
		  };
	"24"?:
		| VisitorFn<CssNodePath<24, S>>
		| {
				enter?: VisitorFn<CssNodePath<24, S>>;
				exit?: VisitorFn<CssNodePath<24, S>>;
		  };
	"25"?:
		| VisitorFn<CssNodePath<25, S>>
		| {
				enter?: VisitorFn<CssNodePath<25, S>>;
				exit?: VisitorFn<CssNodePath<25, S>>;
		  };
	"26"?:
		| VisitorFn<CssNodePath<26, S>>
		| {
				enter?: VisitorFn<CssNodePath<26, S>>;
				exit?: VisitorFn<CssNodePath<26, S>>;
		  };
	"27"?:
		| VisitorFn<CssNodePath<27, S>>
		| {
				enter?: VisitorFn<CssNodePath<27, S>>;
				exit?: VisitorFn<CssNodePath<27, S>>;
		  };
	"28"?:
		| VisitorFn<CssNodePath<28, S>>
		| {
				enter?: VisitorFn<CssNodePath<28, S>>;
				exit?: VisitorFn<CssNodePath<28, S>>;
		  };
}
type DeclarationEstreeIndex =
	FunctionDeclaration | VariableDeclaration | ClassDeclaration;
type DeclarationSyntaxParser = NodeSyntaxParser & {
	name: string;
	nameStart: number;
	nameEnd: number;
	value: ComponentValue[];
	important: boolean;
};
declare interface DecodedEntitiesWithMap {
	text: string;
	map?: number[];
}
type DecodedSegment =
	| [number, number, number, number]
	| [number]
	| [number, number, number, number, number];
type DecodedSourceMap = Omit<RawSourceMap, "mappings"> & {
	mappings: DecodedSegment[][];
};
declare interface DefaultHandlerOptions {
	progressBar?: false | Required<ProgressPluginOptionsProgressBarBranch3Object>;
	estimatedTime?: boolean;
	phaseTimings?: boolean;
}
type DeferredEmbeddedSource = DeferredWrite & {
	type: string;
	hostType: string;
	as?: string;
};

/**
 * One write the print left a marker for, collected into the `deferEmbeddedSource`
 * print option by whichever grammar offered it — the other half of
 * {@link deferredWrite}. `source` is the text offered, `build` spells what is
 * printed around the answer (an untapped run's spelling where there is none), and
 * `decides` says whether the answer overturns a choice the print made without it.
 * A grammar carries whatever else describes the offer (`type`, `hostType`, `as`,
 * …) on the same object.
 */
declare interface DeferredWrite {
	source: string;
	build: (answer?: string) => string;
	decides?: (answer?: string) => boolean;
}
type DefineConfigInput =
	| Configuration
	| MultiConfiguration
	| ((
			env: Record<string, any>,
			argv: Record<string, any>
	  ) => MaybePromise<Configuration | MultiConfiguration>)
	| ((
			env: Record<string, any>,
			argv: Record<string, any>
	  ) => MaybePromise<Configuration | MultiConfiguration>)[]
	| Promise<
			| Configuration
			| MultiConfiguration
			| ((
					env: Record<string, any>,
					argv: Record<string, any>
			  ) => MaybePromise<Configuration | MultiConfiguration>)
			| ((
					env: Record<string, any>,
					argv: Record<string, any>
			  ) => MaybePromise<Configuration | MultiConfiguration>)[]
	  >;
declare class DefinePlugin {
	/**
	 * Create a new define plugin
	 */
	constructor(definitions: Definitions);
	definitions: Definitions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Creates a runtime value. Async generators resolve once per module and key
	 * before parsing; promise-returning functions require the `async` option.
	 */
	static runtimeValue(
		fn: (value: {
			module: NormalModule;
			key: string;
			readonly version: ValueCacheVersion;
		}) => GeneratedValue,
		options?: true | string[] | RuntimeValueOptions
	): RuntimeValue;
	static getCompilationHooks: (compilation: Compilation) => {
		/**
		 * @since 5.104.0
		 */
		definitions: SyncWaterfallHook<
			[Record<string, CodeValue>],
			Record<string, CodeValue>
		>;
	};
	static VALUE_DEP_MAIN: string;
	static VALUE_DEP_PREFIX: string;
	static getDeclaredKeys: (compilation: Compilation) => undefined | Set<string>;
	static getMergedDefinitionNode: (
		compilation: Compilation,
		key: string
	) => MergedDefinitionNode;
	static getRuntimeRequirements: (code: string) => undefined | string[];
	static markInternal: (plugin: DefinePlugin) => DefinePlugin;
	static stringifyMergedDefinition: (
		compilation: Compilation,
		parser: JavascriptParser,
		node: MergedDefinitionNode,
		key: string,
		objKeys?: null | Set<string>
	) => string;
	static toPropertyKey: (key: string) => string;
}
declare interface Definitions {
	[index: string]: CodeValue;
}
declare class DelegatedPlugin {
	/**
	 * Creates an instance of DelegatedPlugin.
	 */
	constructor(options: OptionsDelegatedModuleFactoryPlugin);
	options: OptionsDelegatedModuleFactoryPlugin;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare class DenoTargetPlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * DependenciesBlock is the base class for all Module classes in webpack. It describes a
 * "block" of dependencies which are pointers to other DependenciesBlock instances. For example
 * when a Module has a CommonJs require statement, the DependencyBlock for the CommonJs module
 * would be added as a dependency to the Module. DependenciesBlock is inherited by two types of classes:
 * Module subclasses and AsyncDependenciesBlock subclasses. The only difference between the two is that
 * AsyncDependenciesBlock subclasses are used for code-splitting (async boundary) and Module subclasses are not.
 */
declare abstract class DependenciesBlock {
	dependencies: Dependency[];
	blocks: AsyncDependenciesBlock[];
	parent?: DependenciesBlock;

	/**
	 * Returns whether this block is an async block, loaded on demand in its own chunk group.
	 */
	isAsyncBlock(): boolean;
	getRootBlock(): DependenciesBlock;

	/**
	 * Adds a DependencyBlock to DependencyBlock relationship.
	 * This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting)
	 */
	addBlock(block: AsyncDependenciesBlock): void;

	/**
	 * Adds the provided dependency to the dependencies block.
	 */
	addDependency(dependency: Dependency): void;

	/**
	 * Removes dependency.
	 */
	removeDependency(dependency: Dependency): void;

	/**
	 * Clear dependencies and blocks.
	 */
	clearDependenciesAndBlocks(): void;

	/**
	 * Updates the hash with the data contributed by this instance.
	 */
	updateHash(hash: Hash, context: UpdateHashContextDependency): void;

	/**
	 * Serializes this instance into the provided serializer context.
	 */
	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;

	/**
	 * Restores this instance from the provided deserializer context.
	 */
	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;
}

/**
 * Defines the dependencies block like type used by this module.
 */
declare interface DependenciesBlockLike {
	dependencies: Dependency[];
	blocks: AsyncDependenciesBlock[];
}
declare class Dependency {
	constructor();
	optional?: boolean;

	/**
	 * Returns a display name for the type of dependency.
	 */
	get type(): string;

	/**
	 * Returns a dependency category, typical categories are "commonjs", "amd", "esm".
	 */
	get category(): string;

	/**
	 * Returns the source type this dependency reads from the module it references:
	 * `javascript` for anything going through the module wrapper, `asset-url` for a
	 * bare url embedded into non-javascript output (css, html, a manifest).
	 */
	get referencedSourceType(): string;

	/**
	 * Returns location.
	 */
	loc: DependencyLocation;

	/**
	 * Updates loc using the provided start line.
	 */
	setLoc(
		startLine: number,
		startColumn: number,
		endLine: number,
		endColumn: number
	): void;

	/**
	 * Updates loc from a source location plus an explicit index, without
	 * materializing the `loc` object (keeps `get loc` lazy). Replaces the
	 * `dep.loc = Object.create(loc); dep.loc.index = i` pattern, which both
	 * allocated a copy and stored the index outside the serialized fields.
	 */
	setLocWithIndex(loc: DependencyLocation, index: number): void;

	/**
	 * Returns a request context.
	 */
	getContext(): undefined | string;

	/**
	 * Returns whether this dependency is of the given kind; a subclass is every kind its parent is.
	 */
	is<
		K extends
			| "worker"
			| "css-import"
			| "css-url"
			| "entry"
			| "url"
			| "module-dependency"
			| "esm-import"
			| "provided"
			| "dynamic-import"
			| "esm-reexport"
			| "esm-export-specifier"
			| "esm-live-export"
			| "esm-side-effect-import"
			| "context-element"
			| "esm-bare-side-effect-import"
			| "esm-import-specifier"
			| "esm-evaluated-import-specifier"
			| "esm-compatibility"
			| "commonjs-require"
			| "commonjs-export-require"
			| "html-source"
			| "html-entry"
			| "webassembly-import"
			| "webassembly-export-imported"
			| "sharing-request"
			| "local-module"
			| "static-exports"
			| "loader-import"
			| "css-icss-import"
			| "css-icss-export"
	>(kind: K): boolean;

	/**
	 * Returns an identifier to merge equal requests.
	 */
	getResourceIdentifier(): null | string;

	/**
	 * Could affect referencing module.
	 */
	couldAffectReferencingModule(): boolean | symbol;

	/**
	 * Returns the export name this dependency requests from its target module (lazy barrel optimization).
	 */
	get forwardId(): null | string | true;

	/**
	 * Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).
	 */
	get lazyRole(): null | "import" | "local" | "id" | "*" | "@";

	/**
	 * Returns the export name for a `LAZY_LOCAL_EXPORT`/`LAZY_NAMED_REEXPORT` classification (lazy barrel optimization).
	 */
	get lazyName(): null | string;

	/**
	 * Returns the referenced module and export
	 * @deprecated
	 */
	getReference(moduleGraph: ModuleGraph): never;

	/**
	 * Returns list of exports referenced by this dependency
	 */
	getReferencedExports(
		moduleGraph: ModuleGraph,
		runtime: RuntimeSpec
	): (string[] | ReferencedExport)[];

	/**
	 * Returns function to determine if the connection is active.
	 */
	getCondition(
		moduleGraph: ModuleGraph
	):
		| null
		| false
		| ((
				moduleGraphConnection: ModuleGraphConnection,
				runtime: RuntimeSpec
		  ) => ConnectionState);

	/**
	 * Returns the exported names
	 */
	getExports(moduleGraph: ModuleGraph): undefined | ExportsSpec;

	/**
	 * Returns warnings.
	 */
	getWarnings(moduleGraph: ModuleGraph): undefined | null | WebpackError[];

	/**
	 * Returns errors.
	 */
	getErrors(moduleGraph: ModuleGraph): undefined | null | WebpackError[];

	/**
	 * Updates the hash with the data contributed by this instance.
	 */
	updateHash(hash: Hash, context: UpdateHashContextDependency): void;

	/**
	 * implement this method to allow the occurrence order plugin to count correctly
	 */
	getNumberOfIdOccurrences(): number;

	/**
	 * Gets module evaluation side effects state.
	 */
	getModuleEvaluationSideEffectsState(
		moduleGraph: ModuleGraph
	): ConnectionState;

	/**
	 * Creates an ignored module.
	 */
	createIgnoredModule(context: string): Module;

	/**
	 * Returns true if this dependency can be concatenated
	 */
	canConcatenate(concatenateCommonJsModules: boolean): boolean;

	/**
	 * Serializes this instance into the provided serializer context.
	 */
	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;

	/**
	 * Restores this instance from the provided deserializer context.
	 */
	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;
	module: void;
	get disconnect(): void;

	/**
	 * Compares two dependencies by source location for sorting a module's
	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
	 * its result, so comparing through it would retain a location object on every
	 * sorted dependency). These dependencies always carry a real source position,
	 * so only start (line, column) and the within-statement index are compared; a
	 * dependency without an index sorts after one that has an index at the same
	 * position.
	 */
	static compareLocations(a: Dependency, b: Dependency): 0 | 1 | -1;
	static NO_EXPORTS_REFERENCED: string[][];
	static EXPORTS_OBJECT_REFERENCED: string[][];
	static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];

	/**
	 * Returns true if the dependency is a low priority dependency.
	 */
	static isLowPriorityDependency(dependency: Dependency): boolean;

	/**
	 * Returns true if the dependency can be concatenated (scope hoisting).
	 */
	static canConcatenate(
		dependency: Dependency,
		concatenateCommonJsModules: boolean
	): boolean;
	static TRANSITIVE: symbol;
	static LAZY_LOCAL_EXPORT: "local";
	static LAZY_NAMED_REEXPORT: "id";
	static LAZY_STAR_REEXPORT: "*";
	static LAZY_REEXPORT_SIDE_EFFECT: "@";
	static LAZY_IMPORT_DECLARATION: "import";
	static ESM_CATEGORY: "esm";
	static KINDS: Set<
		| "worker"
		| "css-import"
		| "css-url"
		| "entry"
		| "url"
		| "module-dependency"
		| "esm-import"
		| "provided"
		| "dynamic-import"
		| "esm-reexport"
		| "esm-export-specifier"
		| "esm-live-export"
		| "esm-side-effect-import"
		| "context-element"
		| "esm-bare-side-effect-import"
		| "esm-import-specifier"
		| "esm-evaluated-import-specifier"
		| "esm-compatibility"
		| "commonjs-require"
		| "commonjs-export-require"
		| "html-source"
		| "html-entry"
		| "webassembly-import"
		| "webassembly-export-imported"
		| "sharing-request"
		| "local-module"
		| "static-exports"
		| "loader-import"
		| "css-icss-import"
		| "css-icss-export"
	>;
}
type DependencyConstructor = abstract new (...args: never[]) => Dependency;

/**
 * branch guard: the dependency is live only when the formula evaluates to `value`
 */
declare interface DependencyGuard {
	formula: GuardFormula;
	value: boolean;
}
type DependencyLocation = SyntheticDependencyLocation | RealDependencyLocation;

/**
 * Defines the dependency source order type used by this module.
 */
declare interface DependencySourceOrder {
	/**
	 * the main source order
	 */
	main: number;

	/**
	 * the sub source order
	 */
	sub: number;
}
declare class DependencyTemplate {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(
		dependency: Dependency,
		source: ReplaceSource,
		templateContext: DependencyTemplateContext
	): void;
}

/**
 * Defines the dependency template context type used by this module.
 */
declare interface DependencyTemplateContext {
	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the dependency templates
	 */
	dependencyTemplates: DependencyTemplates;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * the requirements for runtime
	 */
	runtimeRequirements: Set<string>;

	/**
	 * current module
	 */
	module: Module;

	/**
	 * current runtimes, for which code is generated
	 */
	runtime: RuntimeSpec;

	/**
	 * mutable array of init fragments for the current module
	 */
	initFragments: InitFragment<GenerateContext>[];

	/**
	 * when in a concatenated module, information about other concatenated modules
	 */
	concatenationScope?: ConcatenationScope;

	/**
	 * the code generation results
	 */
	codeGenerationResults: CodeGenerationResults;

	/**
	 * init fragments for the chunk, rendered with its render context
	 */
	chunkInitFragments: InitFragment<ChunkRenderContextJavascriptModulesPlugin>[];

	/**
	 * get access to the code generation data
	 */
	getData?: () => CodeGenerationResultData;
}
declare abstract class DependencyTemplates {
	importBindingScopes: boolean;

	/**
	 * Returns template for this dependency.
	 */
	get(dependency: DependencyConstructor): undefined | DependencyTemplate;

	/**
	 * Updates value using the provided dependency.
	 */
	set(
		dependency: DependencyConstructor,
		dependencyTemplate: DependencyTemplate
	): void;

	/**
	 * Updates the hash with the data contributed by this instance.
	 */
	updateHash(part: string): void;
	getHash(): string;
	clone(): DependencyTemplates;
}

/**
 * Defines the destructuring assignment property type used by this module.
 * Carries only the range — consumers derive line/column via `getLocation`.
 */
declare interface DestructuringAssignmentProperty {
	id: string;
	range: [number, number];
	pattern?: Set<DestructuringAssignmentProperty>;
	shorthand: string | boolean;
}

/**
 * Where a shorthand assignment, trailing comma or parenthesized pattern was
 * seen, so the expression parser can raise once it knows whether it is
 * parsing an expression or a binding pattern.
 */
declare class DestructuringErrors {
	constructor();
	shorthandAssign: number;
	trailingComma: number;
	parenthesizedAssign: number;
	parenthesizedBind: number;
	doubleProto: number;
}
declare class DeterministicChunkIdsPlugin {
	/**
	 * Creates an instance of DeterministicChunkIdsPlugin.
	 */
	constructor(options?: DeterministicChunkIdsPluginOptions);
	options: DeterministicChunkIdsPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the deterministic chunk ids plugin options type used by this module.
 */
declare interface DeterministicChunkIdsPluginOptions {
	/**
	 * context for ids
	 */
	context?: string;

	/**
	 * maximum length of ids
	 */
	maxLength?: number;
}
declare class DeterministicModuleIdsPlugin {
	/**
	 * Creates an instance of DeterministicModuleIdsPlugin.
	 */
	constructor(options?: DeterministicModuleIdsPluginOptions);
	options: DeterministicModuleIdsPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the deterministic module ids plugin options type used by this module.
 */
declare interface DeterministicModuleIdsPluginOptions {
	/**
	 * context relative to which module identifiers are computed
	 */
	context?: string;

	/**
	 * selector function for modules
	 */
	test?: (module: Module) => boolean;

	/**
	 * maximum id length in digits (used as starting point)
	 */
	maxLength?: number;

	/**
	 * hash salt for ids
	 */
	salt?: number;

	/**
	 * do not increase the maxLength to find an optimal id space size
	 */
	fixedLength?: boolean;

	/**
	 * throw an error when id conflicts occur (instead of rehashing)
	 */
	failOnConflict?: boolean;
}
type DevtoolFallbackModuleFilenameTemplate =
	string | ((context: ModuleFilenameTemplateContext) => string);
type DevtoolModuleFilenameTemplate =
	string | ((context: ModuleFilenameTemplateContext) => string);

/**
 * Defines the dirent type used by this module.
 */
declare interface DirentFs<T extends string | Buffer = string> {
	/**
	 * true when is file, otherwise false
	 */
	isFile: () => boolean;

	/**
	 * true when is directory, otherwise false
	 */
	isDirectory: () => boolean;

	/**
	 * true when is block device, otherwise false
	 */
	isBlockDevice: () => boolean;

	/**
	 * true when is character device, otherwise false
	 */
	isCharacterDevice: () => boolean;

	/**
	 * true when is symbolic link, otherwise false
	 */
	isSymbolicLink: () => boolean;

	/**
	 * true when is FIFO, otherwise false
	 */
	isFIFO: () => boolean;

	/**
	 * true when is socket, otherwise false
	 */
	isSocket: () => boolean;

	/**
	 * name
	 */
	name: T;

	/**
	 * path
	 */
	parentPath: string;

	/**
	 * path
	 */
	path?: string;
}
declare interface DirentResolver<T extends string | Buffer = string> {
	/**
	 * true when is file, otherwise false
	 */
	isFile: () => boolean;

	/**
	 * true when is directory, otherwise false
	 */
	isDirectory: () => boolean;

	/**
	 * true when is block device, otherwise false
	 */
	isBlockDevice: () => boolean;

	/**
	 * true when is character device, otherwise false
	 */
	isCharacterDevice: () => boolean;

	/**
	 * true when is symbolic link, otherwise false
	 */
	isSymbolicLink: () => boolean;

	/**
	 * true when is FIFO, otherwise false
	 */
	isFIFO: () => boolean;

	/**
	 * true when is socket, otherwise false
	 */
	isSocket: () => boolean;

	/**
	 * name
	 */
	name: T;

	/**
	 * path
	 */
	parentPath: string;

	/**
	 * path
	 */
	path?: string;
}
declare interface DirnameCacheEntry {
	/**
	 * cached dirname function
	 */
	fn: (maybePath: string) => string;

	/**
	 * the underlying cache map
	 */
	cache: Map<string, string>;
}
declare interface Disposable {
	[Symbol.dispose](): void;
}
declare class DllPlugin {
	/**
	 * Creates an instance of DllPlugin.
	 */
	constructor(options: DllPluginOptions);
	options: DllPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface DllPluginOptions {
	/**
	 * Context of requests in the manifest file (defaults to the webpack context).
	 */
	context?: string;

	/**
	 * If true, only entry points will be exposed (default: true).
	 */
	entryOnly?: boolean;

	/**
	 * If true, manifest json file (output) will be formatted.
	 */
	format?: boolean;

	/**
	 * Name of the exposed dll function (external name, use value of 'output.library').
	 */
	name?: string;

	/**
	 * Absolute path to the manifest json file (output).
	 */
	path: string;

	/**
	 * Type of the dll bundle (external type, use value of 'output.libraryTarget').
	 */
	type?: string;
}
declare class DllReferencePlugin {
	/**
	 * Creates an instance of DllReferencePlugin.
	 */
	constructor(options: DllReferencePluginOptions);
	options: DllReferencePluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
type DllReferencePluginOptions =
	| DllReferencePluginOptionsBranch1Object
	| DllReferencePluginOptionsBranch2Object;
declare interface DllReferencePluginOptionsBranch1Object {
	/**
	 * Context of requests in the manifest (or content property) as absolute path.
	 */
	context?: string;

	/**
	 * Extensions used to resolve modules in the dll bundle (only used when using 'scope').
	 */
	extensions?: string[];

	/**
	 * An object containing content and name or a string to the absolute path of the JSON manifest to be loaded upon compilation.
	 */
	manifest: string | DllReferencePluginOptionsManifest;

	/**
	 * The name where the dll is exposed (external name, defaults to manifest.name).
	 */
	name?: string;

	/**
	 * Prefix which is used for accessing the content of the dll.
	 */
	scope?: string;

	/**
	 * How the dll is exposed (libraryTarget, defaults to manifest.type).
	 */
	sourceType?:
		| "var"
		| "assign"
		| "this"
		| "window"
		| "global"
		| "commonjs"
		| "commonjs2"
		| "commonjs-module"
		| "amd"
		| "amd-require"
		| "umd"
		| "umd2"
		| "jsonp"
		| "system";

	/**
	 * The way how the export of the dll bundle is used.
	 */
	type?: "object" | "require";
}
declare interface DllReferencePluginOptionsBranch2Object {
	content: DllReferencePluginOptionsContent;

	/**
	 * Context of requests in the manifest (or content property) as absolute path.
	 */
	context?: string;

	/**
	 * Extensions used to resolve modules in the dll bundle (only used when using 'scope').
	 */
	extensions?: string[];

	/**
	 * The name where the dll is exposed (external name).
	 */
	name: string;

	/**
	 * Prefix which is used for accessing the content of the dll.
	 */
	scope?: string;

	/**
	 * How the dll is exposed (libraryTarget).
	 */
	sourceType?:
		| "var"
		| "assign"
		| "this"
		| "window"
		| "global"
		| "commonjs"
		| "commonjs2"
		| "commonjs-module"
		| "amd"
		| "amd-require"
		| "umd"
		| "umd2"
		| "jsonp"
		| "system";

	/**
	 * The way how the export of the dll bundle is used.
	 */
	type?: "object" | "require";
}

/**
 * The mappings from request to module info.
 */
declare interface DllReferencePluginOptionsContent {
	[index: string]: DllReferencePluginOptionsContentValue;
}

/**
 * Module info.
 */
declare interface DllReferencePluginOptionsContentValue {
	/**
	 * Meta information about the module.
	 */
	buildMeta?: { [index: string]: any };

	/**
	 * Information about the provided exports of the module.
	 */
	exports?: true | string[];

	/**
	 * Module ID.
	 */
	id: string | number;
}

/**
 * An object containing content, name and type.
 */
declare interface DllReferencePluginOptionsManifest {
	content: DllReferencePluginOptionsContent;

	/**
	 * The name where the dll is exposed (external name).
	 */
	name?: string;
	type?:
		| "var"
		| "assign"
		| "this"
		| "window"
		| "global"
		| "commonjs"
		| "commonjs2"
		| "commonjs-module"
		| "amd"
		| "amd-require"
		| "umd"
		| "umd2"
		| "jsonp"
		| "system";
}
declare class DotenvPlugin {
	/**
	 * Creates an instance of DotenvPlugin.
	 */
	constructor(options?: DotenvPluginOptions);
	options: DotenvPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Options for Dotenv plugin.
 */
declare interface DotenvPluginOptions {
	/**
	 * The directory from which .env files are loaded. Can be an absolute path, false will disable the .env file loading.
	 */
	dir?: string | false;

	/**
	 * Only expose environment variables that start with these prefixes. Defaults to 'WEBPACK_'.
	 */
	prefix?: string | string[];

	/**
	 * Template patterns for .env file names. Use [mode] as placeholder for the webpack mode. Defaults to ['.env', '.env.local', '.env.[mode]', '.env.[mode].local'].
	 */
	template?: string[];
}

declare interface DualModeResolve {
	(
		context: string,
		request: string,
		callback: (
			err: null | ErrorWithDetail,
			res?: string | false,
			req?: ResolveRequest
		) => void
	): void;
	(context: string, request: string): Promise<string>;
}
declare class DynamicEntryPlugin {
	/**
	 * Creates an instance of DynamicEntryPlugin.
	 */
	constructor(context: string, entry: () => Promise<EntryStaticNormalized>);
	context: string;
	entry: () => Promise<EntryStaticNormalized>;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Dependency for static evaluating import specifier. e.g.
 */
declare abstract class ESMEvaluatedImportSpecifierDependency extends ESMImportSpecifierDependency {
	operator: string;
}
declare abstract class ESMExportImportedSpecifierDependency extends ESMImportDependency {
	ids: string[];
	name: null | string;
	activeExports: Set<string>;
	otherStarExports: null | ReadonlyArray<ESMExportImportedSpecifierDependency>;
	exportPresenceMode: ExportPresenceMode;
	allStarExports: null | ESMStarExportsList;

	/**
	 * Returns id.
	 * @deprecated
	 */
	get id(): void;

	/**
	 * Returns id.
	 * @deprecated
	 */
	getId(): void;

	/**
	 * Updates id.
	 * @deprecated
	 */
	setId(): void;

	/**
	 * Returns the imported id.
	 */
	getIds(moduleGraph: ModuleGraph): string[];

	/**
	 * Updates ids using the provided module graph.
	 */
	setIds(moduleGraph: ModuleGraph, ids: string[]): void;

	/**
	 * Returns the export mode.
	 */
	getMode(moduleGraph: ModuleGraph, runtime: RuntimeSpec): ExportMode;

	/**
	 * Gets star reexports.
	 */
	getStarReexports(
		moduleGraph: ModuleGraph,
		runtime: RuntimeSpec,
		exportsInfo?: ExportsInfo,
		importedModule?: Module
	): {
		exports?: Set<string>;
		checked?: Set<string>;
		ignoredExports: Set<string>;
		hidden?: Set<string>;
	};
}
declare class ESMImportDependency extends ModuleDependency {
	/**
	 * Creates an instance of ESMImportDependency.
	 */
	constructor(
		request: string,
		sourceOrder: number,
		phase?: 0 | 1 | 2,
		attributes?: ImportAttributes
	);
	phase: ImportPhaseType;
	attributes?: ImportAttributes;

	/**
	 * Returns name of the variable for the import.
	 */
	getImportVar(moduleGraph: ModuleGraph): string;

	/**
	 * Gets module exports.
	 */
	getModuleExports(__0: DependencyTemplateContext): string;

	/**
	 * Gets import statement.
	 */
	getImportStatement(
		update: boolean,
		__1: DependencyTemplateContext
	): [string, string];

	/**
	 * Gets linking errors.
	 */
	getLinkingErrors(
		moduleGraph: ModuleGraph,
		ids: string[],
		additionalMessage: string
	): undefined | WebpackError[];
	static Template: typeof ESMImportDependencyTemplate;
	static ExportPresenceModes: {
		NONE: ExportPresenceMode;
		WARN: ExportPresenceMode;
		AUTO: ExportPresenceMode;
		ERROR: ExportPresenceMode;
		/**
		 * Returns result.
		 */
		fromUserOption(str: string | false): ExportPresenceMode;
		/**
		 * Resolve export presence mode from parser options with a specific key and shared fallbacks.
		 */
		resolveFromOptions(
			specificValue: undefined | string | false,
			options: JavascriptParserOptions
		): ExportPresenceMode;
	};
	static getNonOptionalPart: (
		members: string[],
		membersOptionals: boolean[]
	) => string[];
	static KINDS: Set<
		| "worker"
		| "css-import"
		| "css-url"
		| "entry"
		| "url"
		| "module-dependency"
		| "esm-import"
		| "provided"
		| "dynamic-import"
		| "esm-reexport"
		| "esm-export-specifier"
		| "esm-live-export"
		| "esm-side-effect-import"
		| "context-element"
		| "esm-bare-side-effect-import"
		| "esm-import-specifier"
		| "esm-evaluated-import-specifier"
		| "esm-compatibility"
		| "commonjs-require"
		| "commonjs-export-require"
		| "html-source"
		| "html-entry"
		| "webassembly-import"
		| "webassembly-export-imported"
		| "sharing-request"
		| "local-module"
		| "static-exports"
		| "loader-import"
		| "css-icss-import"
		| "css-icss-export"
	>;

	/**
	 * Compares two dependencies by source location for sorting a module's
	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
	 * its result, so comparing through it would retain a location object on every
	 * sorted dependency). These dependencies always carry a real source position,
	 * so only start (line, column) and the within-statement index are compared; a
	 * dependency without an index sorts after one that has an index at the same
	 * position.
	 */
	static compareLocations(a: Dependency, b: Dependency): 0 | 1 | -1;
	static NO_EXPORTS_REFERENCED: string[][];
	static EXPORTS_OBJECT_REFERENCED: string[][];
	static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];

	/**
	 * Returns true if the dependency is a low priority dependency.
	 */
	static isLowPriorityDependency(dependency: Dependency): boolean;

	/**
	 * Returns true if the dependency can be concatenated (scope hoisting).
	 */
	static canConcatenate(
		dependency: Dependency,
		concatenateCommonJsModules: boolean
	): boolean;
	static TRANSITIVE: symbol;
	static LAZY_LOCAL_EXPORT: "local";
	static LAZY_NAMED_REEXPORT: "id";
	static LAZY_STAR_REEXPORT: "*";
	static LAZY_REEXPORT_SIDE_EFFECT: "@";
	static LAZY_IMPORT_DECLARATION: "import";
	static ESM_CATEGORY: "esm";
}
declare class ESMImportDependencyTemplate extends DependencyTemplate {
	constructor();

	/**
	 * Gets import emitted runtime.
	 */
	static getImportEmittedRuntime(
		module: Module,
		referencedModule: Module
	): undefined | string | boolean | SortableSet<string>;
}
declare abstract class ESMImportSideEffectDependency extends ESMImportDependency {
	unusedSpecifiers?: UnusedSpecifiers;
	namespaceSpecifiers?: string[];
}
declare abstract class ESMImportSpecifierDependency extends ESMImportDependency {
	ids: string[];
	name: string;
	idRanges?: [number, number][];
	exportPresenceMode: ExportPresenceMode;
	namespaceObjectAsContext?: boolean;
	call?: boolean;
	directImport?: boolean;
	shorthand?: string | boolean;
	asiSafe?: boolean;
	usedByExports?: boolean | Set<string>;
	referencedPropertiesInDestructuring?: Set<DestructuringAssignmentProperty>;
	branchGuards?: DependencyGuard[];
	assignment?: boolean;

	/**
	 * Returns id.
	 * @deprecated
	 */
	get id(): void;

	/**
	 * Returns id.
	 * @deprecated
	 */
	getId(): void;

	/**
	 * Updates id.
	 * @deprecated
	 */
	setId(): void;

	/**
	 * Returns the imported ids.
	 */
	getIds(moduleGraph: ModuleGraph): string[];

	/**
	 * Updates ids using the provided module graph.
	 */
	setIds(moduleGraph: ModuleGraph, ids: string[]): void;
}

/**
 * Defines the harmony settings type used by this module.
 */
declare interface ESMSettings {
	ids: string[];
	source: string;
	sourceOrder: number;
	name: string;
	await: boolean;
	attributes?: ImportAttributes;
	phase: ImportPhaseType;

	/**
	 * whether the binding is referenced anywhere
	 */
	used: boolean;

	/**
	 * the statement's own dependency
	 */
	dependency?: ESMImportSideEffectDependency;
}
declare abstract class ESMStarExportsList {
	dependencies: ESMExportImportedSpecifierDependency[];

	/**
	 * Processes the provided dep.
	 */
	push(dep: ESMExportImportedSpecifierDependency): void;
	slice(): ESMExportImportedSpecifierDependency[];

	/**
	 * Serializes this instance into the provided serializer context.
	 */
	serialize(__0: StarListSerializerContext): void;

	/**
	 * Restores this instance from the provided deserializer context.
	 */
	deserialize(__0: StarListDeserializerContext): void;
}
type EcmaVersion =
	| 3
	| 5
	| 6
	| 7
	| 8
	| 9
	| 10
	| 11
	| 12
	| 13
	| 14
	| 15
	| 16
	| 17
	| 2015
	| 2016
	| 2017
	| 2018
	| 2019
	| 2020
	| 2021
	| 2022
	| 2023
	| 2024
	| 2025
	| 2026
	| "latest";
type Effect = EffectUse | EffectBasic;

/**
 * Defines the effect basic type used by this module.
 */
declare interface EffectBasic {
	type: string;
	value: any;
}

/**
 * Defines the effect data type used by this module.
 */
declare interface EffectData {
	resource?: string;
	realResource?: string;
	resourceQuery?: string;
	resourceFragment?: string;
	scheme?: string;
	attributes?: ImportAttributes;
	mimetype?: string;
	dependency: string;
	descriptionData?: JsonObjectResolver;
	descriptionRelativePath?: string;
	compiler?: string;
	issuer: string;
	issuerLayer: string;
	phase?: string;
}

/**
 * Defines the effect use type used by this module.
 */
declare interface EffectUse {
	type: EffectUseType;
	value: {
		loader: string;
		options?: null | string | { [index: string]: any };
		ident?: string;
	};
}
type EffectUseType = "use" | "use-pre" | "use-post";
declare class ElectronTargetPlugin {
	constructor(
		context?: "preload" | "main" | "renderer",
		type?:
			| "import"
			| "var"
			| "module"
			| "assign"
			| "this"
			| "window"
			| "self"
			| "global"
			| "commonjs"
			| "commonjs2"
			| "commonjs-module"
			| "commonjs-static"
			| "amd"
			| "amd-require"
			| "umd"
			| "umd2"
			| "jsonp"
			| "system"
			| "amd-async"
			| "promise"
			| "module-import"
			| "script"
			| "node-commonjs"
			| "asset"
			| "asset-url"
			| "css-import"
			| "css-url"
	);
	type: ExternalsType;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * One language's source embedded in another's output.
 */
declare interface EmbeddedSourceInfo {
	/**
	 * the embedded source's type, e.g. `"css"` / `"html"`
	 */
	type: string;

	/**
	 * the type of the source it is embedded in, e.g. `"javascript"`
	 */
	hostType: string;

	/**
	 * the module being generated
	 */
	module: Module;

	/**
	 * which of that language's productions this is, where more than one can be embedded — a `style=""` holds `"block-contents"`, an inline `<style>` a whole `"stylesheet"`. Absent where the language has only one
	 */
	as?: string;
}

/**
 * What a renderer made of one embedded body: the minified text, and anything it
 * has to report about it. A bare string is the text alone.
 */
declare interface EmbeddedSourceResult {
	code?: string;
	warnings?: (string | Error)[];
	errors?: (string | Error)[];
}

/**
 * No generator options are supported for this module type.
 */
declare interface EmptyGeneratorOptions {}

/**
 * No parser options are supported for this module type.
 */
declare interface EmptyParserOptions {}
declare class EnableChunkLoadingPlugin {
	/**
	 * Creates an instance of EnableChunkLoadingPlugin.
	 */
	constructor(type: string);
	type: string;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Updates enabled using the provided compiler.
	 */
	static setEnabled(compiler: Compiler, type: string): void;

	/**
	 * Checks enabled.
	 */
	static checkEnabled(compiler: Compiler, type: string): void;
}
declare class EnableLibraryPlugin {
	/**
	 * Creates an instance of EnableLibraryPlugin.
	 */
	constructor(type: string, options?: EnableLibraryPluginOptions);
	type: string;
	options: EnableLibraryPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Updates enabled using the provided compiler.
	 */
	static setEnabled(compiler: Compiler, type: string): void;

	/**
	 * Checks enabled.
	 */
	static checkEnabled(compiler: Compiler, type: string): void;
}

/**
 * Defines the enable library plugin options type used by this module.
 */
declare interface EnableLibraryPluginOptions {
	/**
	 * function that runs when applying the current plugin.
	 */
	additionalApply?: () => void;
}

/**
 * Validates and enables named wasm loading backends by applying the plugin
 * implementations that provide their runtime support.
 */
declare class EnableWasmLoadingPlugin {
	/**
	 * Stores the wasm loading backend name that should be enabled for the
	 * compiler.
	 */
	constructor(type: string);
	type: string;

	/**
	 * Enables the requested wasm loading backend once and applies the
	 * environment-specific plugins that provide its parser, generator, and
	 * runtime support.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Marks a custom or built-in wasm loading type as enabled for the compiler
	 * without applying additional built-in behavior.
	 */
	static setEnabled(compiler: Compiler, type: string): void;

	/**
	 * Verifies that a wasm loading type has been enabled before code generation
	 * attempts to use it.
	 */
	static checkEnabled(compiler: Compiler, type: string): void;
}
type EncodedSourceMap = Omit<BuiltSourceMap, "mappings"> & { mappings: string };
type EncodingOptionFs =
	| undefined
	| null
	| "ascii"
	| "utf8"
	| "utf-8"
	| "utf16le"
	| "utf-16le"
	| "ucs2"
	| "ucs-2"
	| "base64"
	| "base64url"
	| "latin1"
	| "binary"
	| "hex"
	| ObjectEncodingOptionsFs;
type EncodingOptionResolver =
	| undefined
	| null
	| "ascii"
	| "utf8"
	| "utf-8"
	| "utf16le"
	| "utf-16le"
	| "ucs2"
	| "ucs-2"
	| "base64"
	| "base64url"
	| "latin1"
	| "binary"
	| "hex"
	| ObjectEncodingOptionsResolver;

/**
 * Defines the entry data type used by this module.
 */
declare interface EntryData {
	/**
	 * dependencies of the entrypoint that should be evaluated at startup
	 */
	dependencies: Dependency[];

	/**
	 * dependencies of the entrypoint that should be included but not evaluated
	 */
	includeDependencies: Dependency[];

	/**
	 * options of the entrypoint
	 */
	options: EntryOptions;
}
declare abstract class EntryDependency extends ModuleDependency {}

/**
 * An object with entry point description.
 */
declare interface EntryDescription {
	/**
	 * Enable/disable creating async chunks that are loaded on demand.
	 */
	asyncChunks?: boolean;

	/**
	 * Base uri for this entry.
	 */
	baseUri?: string;

	/**
	 * The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
	 */
	chunkLoading?: string | false;

	/**
	 * The entrypoints that the current entrypoint depend on. They must be loaded when this entrypoint is loaded.
	 */
	dependOn?: string | string[];

	/**
	 * Specifies the filename of the output file on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	filename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Generate an HTML file for this entrypoint with its JS and CSS output chunks injected. An object overrides `output.html` option by option for this entry; `inline` is resolved once per generated page and can only be set on `output.html`.
	 */
	html?: boolean | OutputHtmlOptions;

	/**
	 * Module(s) that are loaded upon startup.
	 */
	import: EntryItem;

	/**
	 * Specifies the layer in which modules of this entrypoint are placed.
	 */
	layer?: null | string;

	/**
	 * Options for library.
	 */
	library?: LibraryOptions;

	/**
	 * The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
	 */
	publicPath?: string | TemplatePathFn<PathData>;

	/**
	 * The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
	 */
	runtime?: string | false;

	/**
	 * The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
	 */
	wasmLoading?: string | false;

	/**
	 * Mark this entry as a worker so its output file uses 'output.workerChunkFilename'.
	 */
	worker?: boolean;
}

/**
 * An object with entry point description.
 */
declare interface EntryDescriptionNormalized {
	/**
	 * Enable/disable creating async chunks that are loaded on demand.
	 */
	asyncChunks?: boolean;

	/**
	 * Base uri for this entry.
	 */
	baseUri?: string;

	/**
	 * The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
	 */
	chunkLoading?: string | false;

	/**
	 * The entrypoints that the current entrypoint depend on. They must be loaded when this entrypoint is loaded.
	 */
	dependOn?: string[];

	/**
	 * Specifies the filename of output files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	filename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Generate an HTML file for this entrypoint with its JS and CSS output chunks injected. An object overrides `output.html` option by option for this entry; `inline` is resolved once per generated page and can only be set on `output.html`.
	 */
	html?: boolean | OutputHtmlOptions;

	/**
	 * Module(s) that are loaded upon startup. The last one is exported.
	 */
	import?: string[];

	/**
	 * Specifies the layer in which modules of this entrypoint are placed.
	 */
	layer?: null | string;

	/**
	 * Options for library.
	 */
	library?: LibraryOptions;

	/**
	 * The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
	 */
	publicPath?: string | TemplatePathFn<PathData>;

	/**
	 * The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
	 */
	runtime?: string | false;

	/**
	 * The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
	 */
	wasmLoading?: string | false;

	/**
	 * Mark this entry as a worker so its output file uses 'output.workerChunkFilename'.
	 */
	worker?: boolean;
}
type EntryItem = string | string[];
type EntryLibIndex =
	| string
	| (() => string | EntryObject | string[] | Promise<EntryStatic>)
	| EntryObject
	| string[];
type EntryNormalized =
	(() => Promise<EntryStaticNormalized>) | EntryStaticNormalized;
declare interface EntryObject {
	[index: string]: string | string[] | EntryDescription;
}
declare class EntryOptionPlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
	static getHooks(compiler: Compiler): EntryOptionPluginHooks;

	/**
	 * Apply entry option.
	 */
	static applyEntryOption(
		compiler: Compiler,
		context: string,
		entry: EntryNormalized
	): void;

	/**
	 * Entry description to options.
	 */
	static entryDescriptionToOptions(
		compiler: Compiler,
		name: string,
		desc: EntryDescriptionNormalized
	): EntryOptions;
}
declare interface EntryOptionPluginHooks {
	/**
	 * transform an entry into a different request (e.g. wrap a non-HTML entry in a synthetic HTML module); return `undefined` to keep the default behavior
	 */
	entry: SyncBailHook<
		[string, string, EntryDescriptionNormalized],
		undefined | string
	>;
}
type EntryOptions = { name?: string; worklet?: boolean } & Omit<
	EntryDescriptionNormalized,
	"import"
>;
declare class EntryPlugin {
	/**
	 * An entry plugin which will handle creation of the EntryDependency
	 */
	constructor(context: string, entry: string, options?: string | EntryOptions);
	context: string;
	entry: string;
	options: string | EntryOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Creates a dependency.
	 */
	static createDependency(
		entry: string,
		options: string | EntryOptions
	): EntryDependency;
}
type EntryStatic = string | EntryObject | string[];

/**
 * Multiple entry bundles are created. The key is the entry name. The value is an entry description object.
 */
declare interface EntryStaticNormalized {
	[index: string]: EntryDescriptionNormalized;
}
declare interface EntryTypesIndex {
	safeTime: number;
	timestamp: number;
	accuracy: number;
}

/**
 * Entrypoint serves as an encapsulation primitive for chunks that are
 * a part of a single ChunkGroup. They represent all bundles that need to be loaded for a
 * single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects
 * inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks.
 */
declare abstract class Entrypoint extends ChunkGroup {
	/**
	 * Sets the runtimeChunk for an entrypoint.
	 */
	setRuntimeChunk(chunk: Chunk): void;

	/**
	 * Fetches the chunk reference containing the webpack bootstrap code
	 */
	getRuntimeChunk(): null | Chunk;

	/**
	 * Sets the chunk with the entrypoint modules for an entrypoint.
	 */
	setEntrypointChunk(chunk: Chunk): void;

	/**
	 * Returns the chunk which contains the entrypoint modules
	 * (or at least the execution of them)
	 */
	getEntrypointChunk(): Chunk;
	addDependOn(entrypoint: Entrypoint): void;
	dependOn(entrypoint: Entrypoint): boolean;
}
type EnumValue =
	null | string | number | boolean | EnumValueObject | EnumValue[];
declare interface EnumValueObject {
	[index: string]: EnumValue;
}

/**
 * The abilities of the environment where the webpack generated code should run.
 */
declare interface Environment {
	/**
	 * The environment supports arrow functions ('() => { ... }').
	 */
	arrowFunction?: boolean;

	/**
	 * The environment supports async function and await ('async function () { await ... }').
	 */
	asyncFunction?: boolean;

	/**
	 * The environment supports BigInt as literal (123n).
	 */
	bigIntLiteral?: boolean;

	/**
	 * The environment supports const and let for variable declarations.
	 */
	const?: boolean;

	/**
	 * The environment supports deferred module evaluation ('import defer * as ns from "..."', 'import.defer("...")').
	 * @since 5.110.0
	 * @experimental
	 */
	deferImport?: boolean;

	/**
	 * The environment supports destructuring ('{ a, b } = obj').
	 */
	destructuring?: boolean;

	/**
	 * The environment supports 'document'.
	 */
	document?: boolean;

	/**
	 * The environment supports an async import() function to import EcmaScript modules.
	 */
	dynamicImport?: boolean;

	/**
	 * The environment supports an async import() is available when creating a worker.
	 */
	dynamicImportInWorker?: boolean;

	/**
	 * The environment supports 'for of' iteration ('for (const x of array) { ... }').
	 */
	forOf?: boolean;

	/**
	 * The environment supports generator functions and yield ('function* () { yield ... }').
	 * @since 5.109.0
	 */
	generator?: boolean;

	/**
	 * The environment supports 'globalThis'.
	 */
	globalThis?: boolean;

	/**
	 * The environment supports 'Object.hasOwn'.
	 */
	hasOwn?: boolean;

	/**
	 * The environment supports `import.meta.dirname` and `import.meta.filename`.
	 */
	importMetaDirnameAndFilename?: boolean;

	/**
	 * The environment supports let for variable declarations.
	 */
	let?: boolean;

	/**
	 * The environment supports logical assignment operators ('a ||= b', 'a &&= b', 'a ??= b').
	 */
	logicalAssignment?: boolean;

	/**
	 * The environment supports object method shorthand ('{ module() {} }').
	 */
	methodShorthand?: boolean;

	/**
	 * The environment supports EcmaScript Module syntax to import EcmaScript modules (import ... from '...').
	 */
	module?: boolean;

	/**
	 * The environment supports `<link rel="modulepreload">` to preload EcmaScript modules.
	 * @since 5.109.0
	 */
	modulePreload?: boolean;

	/**
	 * The environment supports `process.getBuiltinModule()` to synchronously load Node.js core modules.
	 */
	nodeBuiltinModuleGetter?: boolean;

	/**
	 * The environment supports `node:` prefix for Node.js core modules.
	 */
	nodePrefixForCoreModules?: boolean;

	/**
	 * The environment supports optional chaining ('obj?.a' or 'obj?.()').
	 */
	optionalChaining?: boolean;

	/**
	 * The environment supports source phase imports ('import source m from "..."', 'import.source("...")').
	 * @since 5.110.0
	 * @experimental
	 */
	sourceImport?: boolean;

	/**
	 * The environment supports spread and rest in array/object literals and calls ('{ ...obj }', 'fn(...args)').
	 */
	spread?: boolean;

	/**
	 * The environment supports 'Symbol' (and well-known symbols like 'Symbol.toStringTag').
	 */
	symbol?: boolean;

	/**
	 * The environment supports template literals.
	 */
	templateLiteral?: boolean;

	/**
	 * The environment supports top-level await ('await x' at the top level of a module).
	 * @since 5.111.0
	 */
	topLevelAwait?: boolean;
}
declare class EnvironmentPlugin {
	/**
	 * Creates an instance of EnvironmentPlugin.
	 */
	constructor(...keys: (string | string[] | JsonObjectFs)[]);
	keys: string[];
	defaultValues: JsonObjectFs;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
type ErrorWithDetail = Error & { details?: string };

/**
 * Cache validation token whose string representation identifies the build
 * inputs associated with a cached value.
 */
declare interface Etag {
	toString: () => string;
}
declare class EvalDevToolModulePlugin {
	/**
	 * Creates an instance of EvalDevToolModulePlugin.
	 */
	constructor(options?: EvalDevToolModulePluginOptions);
	namespace: string;
	sourceUrlComment: string;
	moduleFilenameTemplate: DevtoolModuleFilenameTemplate;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the eval dev tool module plugin options type used by this module.
 */
declare interface EvalDevToolModulePluginOptions {
	/**
	 * namespace
	 */
	namespace?: string;

	/**
	 * source url comment
	 */
	sourceUrlComment?: string;

	/**
	 * module filename template
	 */
	moduleFilenameTemplate?:
		string | ((context: ModuleFilenameTemplateContext) => string);
}
declare class EvalSourceMapDevToolPlugin {
	/**
	 * Creates an instance of EvalSourceMapDevToolPlugin.
	 */
	constructor(inputOptions?: string | SourceMapDevToolPluginOptions);
	sourceMapComment: string;
	moduleFilenameTemplate: DevtoolModuleFilenameTemplate;
	namespace: string;
	options: SourceMapDevToolPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
type ExcludeModulesType = "module" | "chunk" | "root-of-chunk" | "nested";

/**
 * Defines the execute module argument type used by this module.
 */
declare interface ExecuteModuleArgument {
	module: Module;
	moduleObject?: ExecuteModuleObject;
	codeGenerationResult: CodeGenerationResult;
}

/**
 * Defines the execute module context type used by this module.
 */
declare interface ExecuteModuleContext {
	assets: Map<string, { source: Source; info?: AssetInfo }>;
	chunk: Chunk;
	chunkGraph: ChunkGraph;
	__webpack_require__?: WebpackRequire;
}

/**
 * Defines the execute module object type used by this module.
 */
declare interface ExecuteModuleObject {
	/**
	 * module id
	 */
	id?: string;

	/**
	 * exports
	 */
	exports: any;

	/**
	 * is loaded
	 */
	loaded: boolean;

	/**
	 * error
	 */
	error?: Error;
}

/**
 * Defines the execute module options type used by this module.
 */
declare interface ExecuteModuleOptions {
	entryOptions?: EntryOptions;
}

/**
 * Defines the execute module result type used by this module.
 */
declare interface ExecuteModuleResult {
	exports: any;
	cacheable: boolean;

	/**
	 * reasons why the executed modules are not cacheable
	 */
	notCacheableReasons: string[];
	assets: Map<string, { source: Source; info?: AssetInfo }>;
	fileDependencies: LazySet<string>;
	contextDependencies: LazySet<string>;
	missingDependencies: LazySet<string>;
	buildDependencies: LazySet<string>;
}

/**
 * Defines the execute options type used by this module.
 */
declare interface ExecuteOptions {
	/**
	 * module id
	 */
	id?: string;

	/**
	 * module
	 */
	module: ExecuteModuleObject;

	/**
	 * require function
	 */
	require: WebpackRequire;
}
declare interface ExistenceOnlyTimeEntryFileSystemInfo {}
declare interface ExistenceOnlyTimeEntryTypesIndex {}

/**
 * Enables/Disables experiments (experimental features with relax SemVer compatibility).
 */
declare interface Experiments {
	[index: string]: any;

	/**
	 * Support WebAssembly as asynchronous EcmaScript Module. `"auto"` (the default) enables it unless a loader is registered for WebAssembly files.
	 * @since 5.0.0
	 * @experimental
	 */
	asyncWebAssembly?: boolean | "auto";

	/**
	 * Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.
	 * @since 5.62.0
	 * @experimental
	 */
	backCompat?: boolean;

	/**
	 * Build http(s): urls using a lockfile and resource content cache.
	 * @since 5.49.0
	 * @experimental
	 */
	buildHttp?: HttpUriOptions | HttpUriOptionsAllowedUrisItem[];

	/**
	 * Enable additional in memory caching of modules that are unchanged and reference only unchanged modules.
	 * @since 5.54.0
	 * @experimental
	 */
	cacheUnaffected?: boolean;

	/**
	 * Enable css support. `"auto"` (the default) enables the built-in CSS support unless a loader is registered for CSS files.
	 * @since 5.66.0
	 * @experimental
	 */
	css?: boolean | "auto";

	/**
	 * Enable experimental tc39 proposal https://github.com/tc39/proposal-defer-import-eval. This allows to defer execution of a module until it's first use.
	 * @since 5.100.0
	 * @experimental
	 */
	deferImport?: boolean;

	/**
	 * Apply defaults of next major version.
	 * @since 5.53.0
	 * @experimental
	 */
	futureDefaults?: boolean;

	/**
	 * Enable HTML entry support. Treats `.html` files as a first-class module type so they can be used directly as entry points. `"auto"` (the default) enables it unless a loader is registered for HTML files.
	 * @since 5.107.0
	 * @experimental
	 */
	html?: boolean | "auto";

	/**
	 * Compile entrypoints and import()s only when they are accessed.
	 * @since 5.17.0
	 * @experimental
	 */
	lazyCompilation?: boolean | LazyCompilationOptions;

	/**
	 * Enable experimental tc39 proposal https://github.com/tc39/proposal-source-phase-imports. This allows importing modules at source phase.
	 * @since 5.106.0
	 * @experimental
	 */
	sourceImport?: boolean;

	/**
	 * Support WebAssembly as synchronous EcmaScript Module (outdated).
	 * @since 5.0.0
	 * @experimental
	 */
	syncWebAssembly?: boolean;

	/**
	 * Enable typescript support. `"auto"` (the default) enables the built-in TypeScript support when Node.js supports it (>= 22.6) and no loader is registered for TypeScript files.
	 * @since 5.107.0
	 * @experimental
	 */
	typescript?: boolean | "auto";
}

/**
 * Enables/Disables experiments (experimental features with relax SemVer compatibility).
 */
declare interface ExperimentsNormalized {
	/**
	 * Support WebAssembly as asynchronous EcmaScript Module. `"auto"` (the default) enables it unless a loader is registered for WebAssembly files.
	 * @since 5.0.0
	 * @experimental
	 */
	asyncWebAssembly?: boolean | "auto";

	/**
	 * Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.
	 * @since 5.62.0
	 * @experimental
	 */
	backCompat?: boolean;

	/**
	 * Build http(s): urls using a lockfile and resource content cache.
	 * @since 5.49.0
	 * @experimental
	 */
	buildHttp?: HttpUriOptions;

	/**
	 * Enable additional in memory caching of modules that are unchanged and reference only unchanged modules.
	 * @since 5.54.0
	 * @experimental
	 */
	cacheUnaffected?: boolean;

	/**
	 * Enable css support. `"auto"` (the default) enables the built-in CSS support unless a loader is registered for CSS files.
	 * @since 5.66.0
	 * @experimental
	 */
	css?: boolean | "auto";

	/**
	 * Enable experimental tc39 proposal https://github.com/tc39/proposal-defer-import-eval. This allows to defer execution of a module until it's first use.
	 * @since 5.100.0
	 * @experimental
	 */
	deferImport?: boolean;

	/**
	 * Apply defaults of next major version.
	 * @since 5.53.0
	 * @experimental
	 */
	futureDefaults?: boolean;

	/**
	 * Enable HTML entry support. Treats `.html` files as a first-class module type so they can be used directly as entry points. `"auto"` (the default) enables it unless a loader is registered for HTML files.
	 * @since 5.107.0
	 * @experimental
	 */
	html?: boolean | "auto";

	/**
	 * Compile entrypoints and import()s only when they are accessed.
	 * @since 5.17.0
	 * @experimental
	 */
	lazyCompilation?: false | LazyCompilationOptions;

	/**
	 * Enable experimental tc39 proposal https://github.com/tc39/proposal-source-phase-imports. This allows importing modules at source phase.
	 * @since 5.106.0
	 * @experimental
	 */
	sourceImport?: boolean;

	/**
	 * Support WebAssembly as synchronous EcmaScript Module (outdated).
	 * @since 5.0.0
	 * @experimental
	 */
	syncWebAssembly?: boolean;

	/**
	 * Enable typescript support. `"auto"` (the default) enables the built-in TypeScript support when Node.js supports it (>= 22.6) and no loader is registered for TypeScript files.
	 * @since 5.107.0
	 * @experimental
	 */
	typescript?: boolean | "auto";
}
declare abstract class ExportInfo {
	name: string;

	/**
	 * true: it is provided
	 * false: it is not provided
	 * null: only the runtime knows if it is provided
	 * undefined: it was not determined if it is provided
	 */
	provided?: null | boolean;

	/**
	 * is the export a terminal binding that should be checked for export star conflicts
	 */
	terminalBinding: boolean;

	/**
	 * true: it can be mangled
	 * false: is can not be mangled
	 * undefined: it was not determined if it can be mangled
	 */
	canMangleProvide?: boolean;

	/**
	 * true: it can be mangled
	 * false: is can not be mangled
	 * undefined: it was not determined if it can be mangled
	 */
	canMangleUse?: boolean;
	exportsInfoOwned: boolean;
	exportsInfo?: ExportsInfo;

	/**
	 * defined: the export binds to a small primitive constant and may be inlined
	 * undefined: not an inlined constant export
	 */
	canInlineProvide?: InlinedValue;

	/**
	 * true: at least one consumer accepts inlining, none rejected
	 * false: at least one consumer rejected inlining
	 * undefined: collecting; no consumer has decided yet
	 */
	canInlineUse?: boolean;

	/**
	 * Only specific export info can be pure, so other_export_info.pure is always undefined.
	 * true: calling the export has no observable side effects
	 * undefined: it was not determined whether the export is pure
	 */
	pureProvide?: boolean;
	get canMangle(): boolean;
	canInline(): undefined | InlinedValue;

	/**
	 * Sets used in unknown way.
	 */
	setUsedInUnknownWay(runtime: RuntimeSpec): boolean;

	/**
	 * Sets used without info.
	 */
	setUsedWithoutInfo(runtime: RuntimeSpec): boolean;
	setHasProvideInfo(): void;
	setHasUseInfo(): void;

	/**
	 * Sets used conditionally.
	 */
	setUsedConditionally(
		condition: (condition: UsageStateType) => boolean,
		newValue: UsageStateType,
		runtime: RuntimeSpec
	): boolean;

	/**
	 * Updates used using the provided new value.
	 */
	setUsed(newValue: UsageStateType, runtime: RuntimeSpec): boolean;

	/**
	 * Returns true, if something has changed.
	 */
	unsetTarget(key: Dependency): boolean;

	/**
	 * Updates target using the provided key.
	 */
	setTarget(
		key: Dependency,
		connection: ModuleGraphConnection,
		exportName?: null | string[],
		priority?: number
	): boolean;

	/**
	 * Returns usage state.
	 */
	getUsed(runtime: RuntimeSpec): UsageStateType;

	/**
	 * Returns used name. May return InlinedUsedName when the export is inlined to a primitive.
	 */
	getUsedName(
		fallbackName: undefined | string,
		runtime: RuntimeSpec
	): string | false | InlinedUsedName;

	/**
	 * Checks whether this export info has used name.
	 */
	hasUsedName(): boolean;

	/**
	 * Updates used name using the provided name.
	 */
	setUsedName(name: string | InlinedUsedName): void;

	/**
	 * Gets terminal binding.
	 */
	getTerminalBinding(
		moduleGraph: ModuleGraph,
		resolveTargetFilter?: (target: TargetItemWithConnection) => boolean
	): undefined | ExportsInfo | ExportInfo;
	isReexport(): undefined | boolean;

	/**
	 * Walks the reexport chain and returns the first target whose module passes
	 * `validTargetModuleFilter`. Returns undefined when there is no target, false
	 * when the chain ends without a valid module.
	 */
	findTarget(
		moduleGraph: ModuleGraph,
		validTargetModuleFilter: (module: Module) => boolean
	): undefined | null | false | FoundTargetItem;

	/**
	 * Resolves the reexport chain as far as `resolveTargetFilter` allows and
	 * returns where it ends. Returns undefined when there is no target, the
	 * targets disagree, or the chain is circular.
	 */
	getTarget(
		moduleGraph: ModuleGraph,
		resolveTargetFilter?: (target: TargetItemWithConnection) => boolean
	): undefined | TargetItemWithConnection;

	/**
	 * Returns whether resolving the target leads back to this export, which
	 * `getTarget` cannot express as it reports a cycle as "no target".
	 */
	hasCircularTarget(moduleGraph: ModuleGraph): boolean;

	/**
	 * Move the target forward as long resolveTargetFilter is fulfilled
	 */
	moveTarget(
		moduleGraph: ModuleGraph,
		resolveTargetFilter: (target: TargetItemWithConnection) => boolean,
		updateOriginalConnection?: (
			target: TargetItemWithConnection
		) => undefined | ModuleGraphConnection
	): undefined | TargetItemWithConnection;

	/**
	 * Creates a nested exports info.
	 */
	createNestedExportsInfo(): ExportsInfo;
	getNestedExportsInfo(): undefined | ExportsInfo;

	/**
	 * Checks whether this export info contains the base info.
	 */
	hasInfo(baseInfo: ExportInfo, runtime: RuntimeSpec): boolean;

	/**
	 * Updates the hash with the data contributed by this instance.
	 */
	updateHash(hash: Hash, runtime: RuntimeSpec): void;
	getUsedInfo(): string;
	getProvidedInfo():
		| "no provided info"
		| "maybe provided (runtime-defined)"
		| "provided"
		| "not provided";
	getRenameInfo(): string;
}
declare abstract class ExportMode {
	type: ExportModeType;
	items: null | NormalReexportItem[];
	name: null | string;
	partialNamespaceExportInfo: null | ExportInfo;
	circular: boolean;
	ignored: null | Set<string>;
	hidden?: null | Set<string>;
	userRequest: null | string;
	fakeType: number;
}
type ExportModeType =
	| "unused"
	| "missing"
	| "empty-star"
	| "reexport-dynamic-default"
	| "reexport-named-default"
	| "reexport-namespace-object"
	| "reexport-fake-namespace-object"
	| "reexport-undefined"
	| "normal-reexport"
	| "dynamic-reexport";
type ExportPresenceMode = 0 | 1 | 2 | 3;

/**
 * Defines the export spec type used by this module.
 */
declare interface ExportSpec {
	/**
	 * the name of the export
	 */
	name: string;

	/**
	 * can the export be renamed (defaults to true)
	 */
	canMangle?: boolean;

	/**
	 * is the export a terminal binding that should be checked for export star conflicts
	 */
	terminalBinding?: boolean;

	/**
	 * calling this export has no observable side effects
	 */
	isPure?: boolean;

	/**
	 * nested exports
	 */
	exports?: (string | ExportSpec)[];

	/**
	 * when reexported: from which module
	 */
	from?: ModuleGraphConnection;

	/**
	 * when reexported: from which export
	 */
	export?: null | string[];

	/**
	 * when reexported: with which priority
	 */
	priority?: number;

	/**
	 * export is not visible, because another export blends over it
	 */
	hidden?: boolean;

	/**
	 * when set: the export binds to a small primitive constant eligible for inlining
	 */
	inlined?: InlinedValue;
}
type ExportedVariableInfo = string | VariableInfo | ScopeInfo;
declare abstract class ExportsInfo {
	/**
	 * Records that an owned export got an inlined used name.
	 */
	markInlinedExports(): void;

	/**
	 * Gets owned exports.
	 */
	get ownedExports(): Iterable<ExportInfo>;

	/**
	 * Gets ordered owned exports.
	 */
	get orderedOwnedExports(): Iterable<ExportInfo>;

	/**
	 * Returns all exports in any order.
	 */
	get exports(): Iterable<ExportInfo>;

	/**
	 * Gets ordered exports.
	 */
	get orderedExports(): Iterable<ExportInfo>;

	/**
	 * Gets other exports info.
	 */
	get otherExportsInfo(): ExportInfo;

	/**
	 * Sets redirect named to.
	 */
	setRedirectNamedTo(exportsInfo?: ExportsInfo): boolean;
	setHasProvideInfo(): void;
	setHasUseInfo(): void;

	/**
	 * Gets own export info.
	 */
	getOwnExportInfo(name: string): ExportInfo;

	/**
	 * Returns export info for this name.
	 */
	getExportInfo(name: string): ExportInfo;

	/**
	 * Gets read only export info.
	 */
	getReadOnlyExportInfo(name: string): any;

	/**
	 * Gets read only export info recursive.
	 */
	getReadOnlyExportInfoRecursive(name: string[]): undefined | ExportInfo;

	/**
	 * Gets nested exports info.
	 */
	getNestedExportsInfo(name?: string[]): undefined | ExportsInfo;

	/**
	 * Sets unknown exports provided.
	 */
	setUnknownExportsProvided(
		canMangle?: boolean,
		excludeExports?: Set<string>,
		targetKey?: Dependency,
		targetModule?: ModuleGraphConnection,
		priority?: number
	): boolean;

	/**
	 * Sets used in unknown way.
	 */
	setUsedInUnknownWay(runtime: RuntimeSpec): boolean;

	/**
	 * Sets used without info.
	 */
	setUsedWithoutInfo(runtime: RuntimeSpec): boolean;

	/**
	 * Sets all known exports used.
	 */
	setAllKnownExportsUsed(runtime: RuntimeSpec): boolean;

	/**
	 * Sets used for side effects only.
	 */
	setUsedForSideEffectsOnly(runtime: RuntimeSpec): boolean;

	/**
	 * Checks whether this exports info is used.
	 */
	isUsed(runtime: RuntimeSpec): boolean;

	/**
	 * Checks whether this exports info is module used.
	 */
	isModuleUsed(runtime: RuntimeSpec): boolean;

	/**
	 * Returns set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown).
	 */
	getUsedExports(runtime: RuntimeSpec): null | boolean | SortableSet<string>;

	/**
	 * Gets provided exports.
	 */
	getProvidedExports(): null | true | string[];

	/**
	 * Gets relevant exports.
	 */
	getRelevantExports(runtime: RuntimeSpec): ExportInfo[];

	/**
	 * Checks whether this exports info is export provided.
	 */
	isExportProvided(name: string | string[]): undefined | null | boolean;

	/**
	 * Returns key representing the usage.
	 */
	getUsageKey(runtime: RuntimeSpec): string;

	/**
	 * Checks whether this exports info is equally used.
	 */
	isEquallyUsed(runtimeA: RuntimeSpec, runtimeB: RuntimeSpec): boolean;

	/**
	 * Returns usage status.
	 */
	getUsed(name: string | string[], runtime: RuntimeSpec): UsageStateType;

	/**
	 * Returns the used name.
	 */
	getUsedName(name: string | string[], runtime: RuntimeSpec): UsedName;

	/**
	 * Checks whether `getUsedName(name, runtime)` would return an `InlinedUsedName`,
	 * without allocating intermediate used-name arrays (hot path for connection conditions).
	 */
	hasInlinedUsedName(name: string[], runtime: RuntimeSpec): boolean;

	/**
	 * Updates the hash with the data contributed by this instance.
	 */
	updateHash(hash: Hash, runtime: RuntimeSpec): void;

	/**
	 * Gets restore provided data.
	 */
	getRestoreProvidedData(): RestoreProvidedData;

	/**
	 * Processes the provided data.
	 */
	restoreProvided(__0: RestoreProvidedData): void;
}

/**
 * Defines the exports spec type used by this module.
 */
declare interface ExportsSpec {
	/**
	 * exported names, true for unknown exports or null for no exports
	 */
	exports: null | true | (string | ExportSpec)[];

	/**
	 * when exports = true, list of unaffected exports
	 */
	excludeExports?: Set<string>;

	/**
	 * list of maybe prior exposed, but now hidden exports
	 */
	hideExports?: null | Set<string>;

	/**
	 * when reexported: from which module
	 */
	from?: ModuleGraphConnection;

	/**
	 * when reexported: with which priority
	 */
	priority?: number;

	/**
	 * can the export be renamed (defaults to true)
	 */
	canMangle?: boolean;

	/**
	 * are the exports terminal bindings that should be checked for export star conflicts
	 */
	terminalBinding?: boolean;

	/**
	 * calling these exports has no observable side effects
	 */
	isPure?: boolean;

	/**
	 * module on which the result depends on
	 */
	dependencies?: Module[];
}
type ExportsType =
	"namespace" | "dynamic" | "default-only" | "default-with-named";
type Exposes = ExposesObject | ExposesBranch1Item[];
type ExposesBranch1Item = string | ExposesObject;

/**
 * Advanced configuration for modules that should be exposed by this container.
 */
declare interface ExposesConfig {
	/**
	 * Request to a module that should be exposed by this container.
	 */
	import: string | string[];

	/**
	 * Custom chunk name for the exposed module.
	 */
	name?: string;
}

/**
 * Modules that should be exposed by this container. Property names are used as public paths.
 */
declare interface ExposesObject {
	[index: string]: ExposesObjectValue;
}
type ExposesObjectValue = string | ExposesConfig | string[];
type Expression =
	| ImportExpressionImport
	| UnaryExpression
	| ArrayExpression
	| ArrowFunctionExpression
	| AssignmentExpression
	| AwaitExpression
	| BinaryExpression
	| SimpleCallExpression
	| NewExpression
	| ChainExpression
	| ClassExpression
	| ConditionalExpression
	| FunctionExpression
	| Identifier
	| SimpleLiteral
	| RegExpLiteral
	| BigIntLiteral
	| LogicalExpression
	| MemberExpression
	| MetaProperty
	| ObjectExpression
	| SequenceExpression
	| TaggedTemplateExpression
	| TemplateLiteral
	| ThisExpression
	| UpdateExpression
	| YieldExpression;
declare interface ExpressionExpressionInfo {
	type: "expression";
	rootInfo: string | VariableInfo;
	name: string;
	getMembers: () => string[];
	getMembersOptionals: () => boolean[];
	getMemberRanges: () => [number, number][];
}
type ExternalItem =
	| string
	| RegExp
	| ExternalItemObject
	| ((
			data: ExternalItemFunctionData,
			callback: (
				err?: null | Error,
				result?:
					| string
					| boolean
					| string[]
					| ExternalItemValueObject
					| ExternalItemValueWithOptions
			) => void
	  ) => void)
	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);
type ExternalItemFunction =
	| ((
			data: ExternalItemFunctionData,
			callback: (
				err?: null | Error,
				result?:
					| string
					| boolean
					| string[]
					| ExternalItemValueObject
					| ExternalItemValueWithOptions
			) => void
	  ) => void)
	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>);

/**
 * Defines the external item function data type used by this module.
 */
declare interface ExternalItemFunctionData {
	/**
	 * the directory in which the request is placed
	 */
	context: string;

	/**
	 * contextual information
	 */
	contextInfo: ModuleFactoryCreateDataContextInfo;

	/**
	 * the category of the referencing dependency
	 */
	dependencyType: string;

	/**
	 * get a resolve function with the current resolver options
	 */
	getResolve: (
		options?: ResolveOptionsWebpackOptions
	) =>
		| ((
				context: string,
				request: string,
				callback: (
					err?: null | Error,
					result?: string | false,
					resolveRequest?: ResolveRequest
				) => void
		  ) => void)
		| ((context: string, request: string) => Promise<string>);

	/**
	 * the request as written by the user in the require/import expression/statement
	 */
	request: string;

	/**
	 * same as `request`, except for an element of a context module (a request containing an expression), where it is the request as written by the user instead of the one relative to the resolved context directory
	 */
	originalRequest: string;
}
type ExternalItemObject = ExternalItemObjectKnown & ExternalItemObjectUnknown;

/**
 * If an dependency matches exactly a property of the object, the property value is used as dependency.
 */
declare interface ExternalItemObjectKnown {
	/**
	 * Specify externals depending on the layer.
	 */
	byLayer?:
		| { [index: string]: ExternalItem }
		| ((layer: null | string) => ExternalItem);
}

/**
 * If an dependency matches exactly a property of the object, the property value is used as dependency.
 */
declare interface ExternalItemObjectUnknown {
	[index: string]: ExternalItemValue;
}
type ExternalItemValue =
	| string
	| boolean
	| string[]
	| ExternalItemValueObject
	| ExternalItemValueWithOptions;
type ExternalItemValueObject = ExternalItemValueObjectKnown &
	ExternalItemValueObjectUnknown;

/**
 * The target of the external with a type, optionally with an 'interop' hint describing how its exports interoperate with ES module imports.
 */
declare interface ExternalItemValueObjectKnown {
	/**
	 * How an external's exports interoperate with ES module imports, independent of the importing module's strictness (similar to Rollup's `output.interop`). 'default': treat as CommonJS, the default import is the whole exports (Node.js semantics). 'esModule': treat as an ES module namespace, the default import is unboxed to `.default`.
	 * @since 5.109.0
	 */
	interop?: "default" | "esModule";
}

/**
 * The target of the external with a type, optionally with an 'interop' hint describing how its exports interoperate with ES module imports.
 */
declare interface ExternalItemValueObjectUnknown {
	[index: string]: string | string[];
}
type ExternalItemValueTarget =
	string | boolean | string[] | ExternalItemValueObject;

/**
 * The target of the external together with options describing how webpack should treat it.
 * @since 5.110.0
 */
declare interface ExternalItemValueWithOptions {
	/**
	 * The target of the external.
	 */
	external: ExternalItemValueTarget;

	/**
	 * Whether importing the external has side effects (like the `sideEffects` flag in a package.json). `false` allows webpack to drop the external when none of its exports are used. Defaults to `true`, as webpack can't analyze an external.
	 * @since 5.110.0
	 */
	sideEffects?: boolean;
}
declare class ExternalModule extends Module {
	/**
	 * Creates an instance of ExternalModule.
	 */
	constructor(
		request: ExternalModuleRequest,
		type: ExternalsType,
		userRequest: string,
		dependencyMeta?:
			ImportDependencyMeta | CssImportDependencyMeta | AssetDependencyMeta,
		interop?: "default" | "esModule",
		sideEffects?: boolean
	);
	request: ExternalModuleRequest;
	externalType: ExternalsType;
	userRequest: string;
	dependencyMeta?:
		ImportDependencyMeta | CssImportDependencyMeta | AssetDependencyMeta;
	interop?: "default" | "esModule";
	sideEffects?: boolean;

	/**
	 * restore unsafe cache data
	 */
	restoreFromUnsafeCache(
		unsafeCacheData: UnsafeCacheData,
		normalModuleFactory: NormalModuleFactory
	): void;

	/**
	 * The request this external resolves to for its own type, with the record form
	 * narrowed to its entry. An array is a module specifier plus a property path.
	 */
	getResolvedRequest(): undefined | string | string[];
	static getCompilationHooks: (compilation: Compilation) => {
		/**
		 * @since 5.106.0
		 */
		chunkCondition: SyncBailHook<[Chunk, Compilation], boolean>;
	};
	static ModuleExternalInitFragment: typeof ModuleExternalInitFragment;
	static getExternalModuleNodeCommonjsInitFragment: (
		runtimeTemplate: RuntimeTemplate,
		universal?: boolean
	) => InitFragment<ChunkRenderContextJavascriptModulesPlugin>;
	static KINDS: Set<
		| "html"
		| "runtime"
		| "normal"
		| "css"
		| "context"
		| "remote"
		| "consume-shared"
		| "external"
		| "concatenated"
	>;

	/**
	 * Gets source basic types.
	 * @deprecated In the next major release, call getSourceBasicTypes() directly on the module instance instead of using this static method.
	 */
	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
}
type ExternalModuleBuildInfo = KnownBuildInfo &
	Record<string, any> &
	KnownExternalModuleBuildInfo;
declare interface ExternalModuleInfo {
	type: "external";

	/**
	 * the module's `require()` call is deferred behind an accessor instead of running at its own slot; unlike a wrapped concatenated member there is no body and no CJS wrapper, so any external may be wrapped
	 */
	wrapped: boolean;

	/**
	 * a wrapped module reached by an eager import edge, so its accessor is called at its own slot in evaluation order
	 */
	eager: boolean;
	module: Module;
	runtimeCondition?: string | boolean | SortableSet<string>;
	nonDeferAccess: boolean;
	index: number;

	/**
	 * module.exports / harmony namespace object
	 */
	name?: string;

	/**
	 * lazy module accessor
	 */
	namespaceFnName?: string;

	/**
	 * decoupled namespace object that keeps original export names when the exports are mangled
	 */
	escapeNamespaceObjectName?: string;

	/**
	 * deferred module.exports / harmony namespace object
	 */
	deferredName?: string;

	/**
	 * the module is deferred at least once
	 */
	deferred: boolean;

	/**
	 * deferred namespace object that being used in a not-analyzable way so it must be materialized
	 */
	deferredNamespaceObjectUsed: boolean;

	/**
	 * deferred namespace object that being used in a not-analyzable way so it must be materialized
	 */
	deferredNamespaceObjectName?: string;

	/**
	 * an import reads the spec namespace object the module hands out
	 */
	specNamespaceObjectUsed: boolean;

	/**
	 * "default-with-named" namespace
	 */
	interopNamespaceObjectUsed: boolean;

	/**
	 * "default-with-named" namespace
	 */
	interopNamespaceObjectName?: string;

	/**
	 * "default-only" namespace
	 */
	interopNamespaceObject2Used: boolean;

	/**
	 * "default-only" namespace
	 */
	interopNamespaceObject2Name?: string;

	/**
	 * runtime namespace object that detects "__esModule"
	 */
	interopDefaultAccessUsed: boolean;

	/**
	 * runtime namespace object that detects "__esModule"
	 */
	interopDefaultAccessName?: string;

	/**
	 * memoized getExportsType(strict=true)
	 */
	exportsTypeStrict?:
		"namespace" | "dynamic" | "default-only" | "default-with-named";

	/**
	 * memoized getExportsType(strict=false)
	 */
	exportsTypeNonStrict?:
		"namespace" | "dynamic" | "default-only" | "default-with-named";
}
type ExternalModuleRequest = string | string[] | RequestRecord;
type Externals =
	| string
	| RegExp
	| ExternalItemObject
	| ((
			data: ExternalItemFunctionData,
			callback: (
				err?: null | Error,
				result?:
					| string
					| boolean
					| string[]
					| ExternalItemValueObject
					| ExternalItemValueWithOptions
			) => void
	  ) => void)
	| ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>)
	| ExternalItem[];
declare class ExternalsPlugin {
	/**
	 * Creates an instance of ExternalsPlugin.
	 */
	constructor(
		type:
			| "import"
			| "var"
			| "module"
			| "assign"
			| "this"
			| "window"
			| "self"
			| "global"
			| "commonjs"
			| "commonjs2"
			| "commonjs-module"
			| "commonjs-static"
			| "amd"
			| "amd-require"
			| "umd"
			| "umd2"
			| "jsonp"
			| "system"
			| "amd-async"
			| "promise"
			| "module-import"
			| "script"
			| "node-commonjs"
			| "asset"
			| "asset-url"
			| "css-import"
			| "css-url"
			| ((dependency: Dependency) => ExternalsType),
		externals: Externals
	);
	type:
		| "import"
		| "var"
		| "module"
		| "assign"
		| "this"
		| "window"
		| "self"
		| "global"
		| "commonjs"
		| "commonjs2"
		| "commonjs-module"
		| "commonjs-static"
		| "amd"
		| "amd-require"
		| "umd"
		| "umd2"
		| "jsonp"
		| "system"
		| "amd-async"
		| "promise"
		| "module-import"
		| "script"
		| "node-commonjs"
		| "asset"
		| "asset-url"
		| "css-import"
		| "css-url"
		| ((dependency: Dependency) => ExternalsType);
	externals: Externals;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Enable presets of externals for specific targets.
 */
declare interface ExternalsPresets {
	/**
	 * Treat bun built-in modules like 'bun', 'bun:sqlite' or 'bun:ffi' and node.js built-in modules as external and load them via import when used (for the Bun runtime).
	 */
	bun?: boolean;

	/**
	 * Treat node.js built-in modules like fs, path or vm as external and load them via the required 'node:' specifier when used (for the Deno runtime).
	 */
	deno?: boolean;

	/**
	 * Treat common electron built-in modules in main and preload context like 'electron', 'ipc' or 'shell' as external and load them via require() when used.
	 */
	electron?: boolean;

	/**
	 * Treat electron built-in modules in the main context like 'app', 'ipc-main' or 'shell' as external and load them via require() when used.
	 */
	electronMain?: boolean;

	/**
	 * Treat electron built-in modules in the preload context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them via require() when used.
	 */
	electronPreload?: boolean;

	/**
	 * Treat electron built-in modules in the renderer context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them via require() when used.
	 */
	electronRenderer?: boolean;

	/**
	 * Treat node.js built-in modules like fs, path or vm as external and load them via require() when used.
	 */
	node?: boolean;

	/**
	 * Treat installed packages (requests resolving into a 'node_modules' directory) as external and load them via require()/import at runtime instead of bundling them (useful for server-side rendering builds).
	 */
	nodeModules?:
		| boolean
		| {
				/**
				 * Keep these requests bundled instead of externalizing them.
				 */
				allowlist?: (string | RegExp | ((request: string) => boolean))[];
		  };

	/**
	 * Treat NW.js legacy nw.gui module as external and load it via require() when used.
	 */
	nwjs?: boolean;

	/**
	 * Treat references to 'http(s)://...' and 'std:...' as external and load them via import when used (Note that this changes execution order as externals are executed before any other code in the chunk).
	 */
	web?: boolean;

	/**
	 * Treat references to 'http(s)://...' and 'std:...' as external and load them via async import() when used (Note that this external type is an async module, which has various effects on the execution).
	 */
	webAsync?: boolean;
}
type ExternalsPresetsNormalizedWithDefaults = ExternalsPresets & {
	web: NonNullable<undefined | boolean>;
	node: NonNullable<undefined | boolean>;
	nwjs: NonNullable<undefined | boolean>;
	electron: NonNullable<undefined | boolean>;
	electronMain: NonNullable<undefined | boolean>;
	electronPreload: NonNullable<undefined | boolean>;
	electronRenderer: NonNullable<undefined | boolean>;
};
type ExternalsType =
	| "import"
	| "var"
	| "module"
	| "assign"
	| "this"
	| "window"
	| "self"
	| "global"
	| "commonjs"
	| "commonjs2"
	| "commonjs-module"
	| "commonjs-static"
	| "amd"
	| "amd-require"
	| "umd"
	| "umd2"
	| "jsonp"
	| "system"
	| "amd-async"
	| "promise"
	| "module-import"
	| "script"
	| "node-commonjs"
	| "asset"
	| "asset-url"
	| "css-import"
	| "css-url";

/**
 * Defines the factorize module options type used by this module.
 */
declare interface FactorizeModuleOptions {
	currentProfile?: ModuleProfile;
	factory: ModuleFactory;
	dependencies: Dependency[];

	/**
	 * return full ModuleFactoryResult instead of only module
	 */
	factoryResult?: boolean;
	originModule: null | Module;
	contextInfo?: Partial<ModuleFactoryCreateDataContextInfo>;
	context?: string;
}

/**
 * Defines the factory meta type used by this module.
 */
declare interface FactoryMeta {
	sideEffectFree?: boolean;
}
type FakeHook<T> = T & FakeHookMarker;

/**
 * Defines the fake hook marker type used by this module.
 */
declare interface FakeHookMarker {}

/**
 * Defines the fallback cache group type used by this module.
 */
declare interface FallbackCacheGroup {
	chunksFilter: (chunk: Chunk) => undefined | boolean;
	minSize: SplitChunksSizes;
	maxAsyncSize: SplitChunksSizes;
	maxInitialSize: SplitChunksSizes;
	automaticNameDelimiter: string;
}

/**
 * Enables asynchronous WebAssembly loading through `fetch` for environments
 * that can instantiate fetched binaries at runtime.
 */
declare class FetchCompileAsyncWasmPlugin {
	constructor();

	/**
	 * Registers compilation hooks that attach the async fetch-based wasm runtime
	 * to chunks containing async WebAssembly modules.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Enables synchronous WebAssembly chunk loading that fetches `.wasm` files and
 * compiles them in browser-like environments.
 */
declare class FetchCompileWasmPlugin {
	/**
	 * Stores options that affect generated synchronous WebAssembly runtime code.
	 */
	constructor(options?: FetchCompileWasmPluginOptions);
	options: FetchCompileWasmPluginOptions;

	/**
	 * Registers compilation hooks that attach the fetch-based synchronous wasm
	 * runtime module to chunks containing sync WebAssembly modules.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Options that influence how synchronous WebAssembly modules are emitted for
 * the fetch-based wasm loading runtime.
 */
declare interface FetchCompileWasmPluginOptions {
	/**
	 * mangle imports
	 */
	mangleImports?: boolean;
}

/**
 * Options object for persistent file-based caching.
 */
declare interface FileCacheOptions {
	/**
	 * Allows to collect unused memory allocated during deserialization. This requires copying data into smaller buffers and has a performance cost.
	 */
	allowCollectingMemory?: boolean;

	/**
	 * Dependencies the build depends on (in multiple categories, default categories: 'defaultWebpack').
	 */
	buildDependencies?: { [index: string]: BuildDependencyItem[] };

	/**
	 * Base directory for the cache (defaults to node_modules/.cache/webpack).
	 */
	cacheDirectory?: string;

	/**
	 * Locations for the cache (defaults to cacheDirectory / name).
	 */
	cacheLocation?: string;

	/**
	 * Compression type used for the cache files.
	 */
	compression?: false | "gzip" | "brotli" | "zstd";

	/**
	 * Algorithm used for generation the hash (see node.js crypto package).
	 */
	hashAlgorithm?: string;

	/**
	 * Time in ms after which idle period the cache storing should happen.
	 */
	idleTimeout?: number;

	/**
	 * Time in ms after which idle period the cache storing should happen when larger changes has been detected (cumulative build time > 2 x avg cache store time).
	 */
	idleTimeoutAfterLargeChanges?: number;

	/**
	 * Time in ms after which idle period the initial cache storing should happen.
	 */
	idleTimeoutForInitialStore?: number;

	/**
	 * List of paths that are managed by a package manager and contain a version or hash in its path so all files are immutable.
	 */
	immutablePaths?: (string | RegExp)[];

	/**
	 * List of paths that are managed by a package manager and can be trusted to not be modified otherwise.
	 */
	managedPaths?: (string | RegExp)[];

	/**
	 * Time for which unused cache entries stay in the filesystem cache at minimum (in milliseconds).
	 */
	maxAge?: number;

	/**
	 * Number of generations unused cache entries stay in memory cache at minimum (0 = no memory cache used, 1 = may be removed after unused for a single compilation, ..., Infinity: kept forever). Cache entries will be deserialized from disk when removed from memory cache.
	 */
	maxMemoryGenerations?: number;

	/**
	 * Additionally cache computation of modules that are unchanged and reference only unchanged modules in memory.
	 */
	memoryCacheUnaffected?: boolean;

	/**
	 * Name for the cache. Different names will lead to different coexisting caches.
	 */
	name?: string;

	/**
	 * Track and log detailed timing information for individual cache items.
	 */
	profile?: boolean;

	/**
	 * Enable/disable readonly mode.
	 */
	readonly?: boolean;

	/**
	 * When to store data to the filesystem. (pack: Store data when compiler is idle in a single file).
	 */
	store?: "pack";

	/**
	 * Filesystem caching.
	 */
	type: "filesystem";

	/**
	 * Version of the cache data. Different versions won't allow to reuse the cache and override existing content. Update the version when config changed in a way which doesn't allow to reuse cache. This will invalidate the cache.
	 */
	version?: string;
}
declare interface FileSystem {
	/**
	 * read file method
	 */
	readFile: ReadFileResolver;

	/**
	 * readdir method
	 */
	readdir: ReaddirResolver;

	/**
	 * read json method
	 */
	readJson?: (
		pathOrFileDescription: PathOrFileDescriptorResolver,
		callback: (
			err: null | Error | NodeJS.ErrnoException,
			result?: JsonObjectResolver
		) => void
	) => void;

	/**
	 * read link method
	 */
	readlink: ReadlinkResolver;

	/**
	 * lstat method
	 */
	lstat?: LStatResolver;

	/**
	 * stat method
	 */
	stat: StatResolver;

	/**
	 * realpath method
	 */
	realpath?: RealPathResolver;
}

/**
 * Used to access information about the filesystem in a cached way
 */
declare abstract class FileSystemInfo {
	fs: InputFileSystem;
	logger?: Logger;
	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[];
	managedPaths: (string | RegExp)[];
	managedPathsWithSlash: string[];
	managedPathsRegExps: RegExp[];
	immutablePaths: (string | RegExp)[];
	immutablePathsWithSlash: string[];
	immutablePathsRegExps: RegExp[];
	logStatistics(): void;
	clear(): void;

	/**
	 * Adds file timestamps.
	 */
	addFileTimestamps(
		map: ReadonlyMap<string, FileTimestamp>,
		immutable?: boolean
	): void;

	/**
	 * Adds context timestamps.
	 */
	addContextTimestamps(
		map: ReadonlyMap<string, ContextTimestamp>,
		immutable?: boolean
	): void;

	/**
	 * Gets file timestamp.
	 */
	getFileTimestamp(
		path: string,
		callback: (
			err?: null | WebpackError,
			fileTimestamp?: null | "ignore" | FileSystemInfoEntry
		) => void
	): void;

	/**
	 * Gets context timestamp.
	 */
	getContextTimestamp(
		path: string,
		callback: (
			err?: null | WebpackError,
			resolvedContextTimestamp?:
				null | "ignore" | ResolvedContextFileSystemInfoEntry
		) => void
	): void;

	/**
	 * Returns file hash.
	 */
	getFileHash(
		path: string,
		callback: (err?: null | WebpackError, hash?: null | string) => void
	): void;

	/**
	 * Returns context hash.
	 */
	getContextHash(
		path: string,
		callback: (err?: null | WebpackError, contextHash?: string) => void
	): void;

	/**
	 * Returns context tsh.
	 */
	getContextTsh(
		path: string,
		callback: (
			err?: null | WebpackError,
			resolvedContextTimestampAndHash?: null | ResolvedContextTimestampAndHash
		) => void
	): void;

	/**
	 * Resolves build dependencies.
	 */
	resolveBuildDependencies(
		context: string,
		deps: Iterable<string>,
		optionalDeps: undefined | Iterable<string>,
		callback: (
			err?: null | Error,
			resolveBuildDependenciesResult?: ResolveBuildDependenciesResult
		) => void
	): void;

	/**
	 * Checks resolve results valid.
	 */
	checkResolveResultsValid(
		resolveResults: Map<string, undefined | string | false>,
		callback: (err?: null | Error, result?: boolean) => void
	): void;

	/**
	 * Creates a snapshot.
	 */
	createSnapshot(
		startTime: undefined | null | number,
		files: undefined | null | Iterable<string>,
		directories: undefined | null | Iterable<string>,
		missing: undefined | null | Iterable<string>,
		options: undefined | null | SnapshotOptionsFileSystemInfo,
		callback: (err: null | WebpackError, snapshot: null | Snapshot) => void
	): void;

	/**
	 * Merges the provided values into a single result.
	 */
	mergeSnapshots(snapshot1: Snapshot, snapshot2: Snapshot): Snapshot;

	/**
	 * Checks snapshot valid.
	 */
	checkSnapshotValid(
		snapshot: Snapshot,
		callback: (err?: null | WebpackError, result?: boolean) => void
	): void;
	getDeprecatedFileTimestamps(): Map<string, null | number>;
	getDeprecatedContextTimestamps(): Map<string, null | number>;
}

/**
 * Defines the file system info entry type used by this module.
 */
declare interface FileSystemInfoEntry {
	safeTime: number;
	timestamp?: number;
}
type FileTimestamp =
	null | "ignore" | FileSystemInfoEntry | ExistenceOnlyTimeEntryFileSystemInfo;
type FilterItemTypes = string | RegExp | ((value: string) => boolean);
declare interface Flags {
	[index: string]: Argument;
}
declare interface FoundTargetItem {
	module: Module;
	connection: ModuleGraphConnection;
	export: string[];
	deferred: boolean;
}
declare interface FullHashChunkModuleHashes {
	[index: string]: string;
}
type FunctionNode = NodeSyntaxParser & {
	name: string;
	nameStart: number;
	nameEnd: number;
	value: ComponentValue[];
};

/**
 * Defines the generate context type used by this module.
 */
declare interface GenerateContext {
	/**
	 * mapping from dependencies to templates
	 */
	dependencyTemplates: DependencyTemplates;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * the requirements for runtime
	 */
	runtimeRequirements: Set<string>;

	/**
	 * the runtime
	 */
	runtime: RuntimeSpec;

	/**
	 * when in concatenated module, information about other concatenated modules
	 */
	concatenationScope?: ConcatenationScope;

	/**
	 * code generation results of other modules (need to have a codeGenerationDependency to use that)
	 */
	codeGenerationResults?: CodeGenerationResults;

	/**
	 * which kind of code should be generated
	 */
	type: string;

	/**
	 * get access to the code generation data
	 */
	getData?: () => CodeGenerationResultData;
}
declare interface GeneratedSourceInfo {
	/**
	 * generated line
	 */
	generatedLine?: number;

	/**
	 * generated column
	 */
	generatedColumn?: number;

	/**
	 * source
	 */
	source?: string;
}
type GeneratedValue =
	| undefined
	| null
	| string
	| number
	| bigint
	| boolean
	| Function
	| RegExp
	| PromiseLike<CodeValuePrimitive>;
declare class Generator<TModule extends NormalModule = NormalModule> {
	constructor();

	/**
	 * Returns the source types available for this module.
	 */
	getTypes(module: TModule): ReadonlySet<string>;
	getTypesDependOnIncomingConnections(): boolean;

	/**
	 * Returns the estimated size for the requested source type.
	 */
	getSize(module: TModule, type?: string): number;

	/**
	 * Generates generated code for this runtime module.
	 */
	generate(module: TModule, __1: GenerateContext): null | Source;

	/**
	 * Returns the reason this module cannot be concatenated, when one exists.
	 */
	getConcatenationBailoutReason(
		module: TModule,
		context: ConcatenationBailoutReasonContext
	): undefined | string;

	/**
	 * Updates the hash with the data contributed by this instance.
	 */
	updateHash(hash: Hash, __1: UpdateHashContextGenerator<TModule>): void;

	/**
	 * Returns generator by type.
	 */
	static byType(map: {
		[index: string]: undefined | Generator;
	}): ByTypeGenerator;

	/**
	 * Returns what a module that failed to build says about it in the output.
	 * The stack it carries is written relative to the context, keeping a
	 * position only where a second build names the same one.
	 */
	static buildErrorMessage(
		error: Error,
		requestShortener?: RequestShortener
	): string;

	/**
	 * Returns the statement a module that failed to build throws when executed.
	 */
	static throwBuildErrorCode(
		error: Error,
		parseErrorConstructor?: string,
		requestShortener?: RequestShortener
	): string;
}
declare interface GeneratorOptions {
	[index: string]: any;
}
type GeneratorOptionsByModuleType = GeneratorOptionsByModuleTypeKnown &
	GeneratorOptionsByModuleTypeUnknown;

/**
 * Specify options for each generator.
 */
declare interface GeneratorOptionsByModuleTypeKnown {
	/**
	 * Generator options for asset modules.
	 */
	asset?: AssetGeneratorOptions;

	/**
	 * No generator options are supported for this module type.
	 */
	"asset/bytes"?: EmptyGeneratorOptions;

	/**
	 * Generator options for asset/inline modules.
	 */
	"asset/inline"?: AssetInlineGeneratorOptions;

	/**
	 * Generator options for asset/resource modules.
	 */
	"asset/resource"?: AssetResourceGeneratorOptions;

	/**
	 * No generator options are supported for this module type.
	 */
	"asset/source"?: EmptyGeneratorOptions;

	/**
	 * Generator options for css modules.
	 */
	css?: CssGeneratorOptions;

	/**
	 * Generator options for css/module modules.
	 */
	"css/auto"?: CssModuleGeneratorOptions;

	/**
	 * Generator options for css/module modules.
	 */
	"css/global"?: CssModuleGeneratorOptions;

	/**
	 * Generator options for css/module modules.
	 */
	"css/module"?: CssModuleGeneratorOptions;

	/**
	 * Generator options for html modules.
	 */
	html?: HtmlGeneratorOptions;

	/**
	 * No generator options are supported for this module type.
	 */
	javascript?: EmptyGeneratorOptions;

	/**
	 * No generator options are supported for this module type.
	 */
	"javascript/auto"?: EmptyGeneratorOptions;

	/**
	 * No generator options are supported for this module type.
	 */
	"javascript/dynamic"?: EmptyGeneratorOptions;

	/**
	 * No generator options are supported for this module type.
	 */
	"javascript/esm"?: EmptyGeneratorOptions;

	/**
	 * Generator options for json modules.
	 */
	json?: JsonGeneratorOptions;
}

/**
 * Specify options for each generator.
 */
declare interface GeneratorOptionsByModuleTypeUnknown {
	[index: string]: { [index: string]: any };
}
declare class GetChunkFilenameRuntimeModule extends RuntimeModule {
	constructor(
		contentType: string,
		name: string,
		global: string,
		getFilenameForChunk: (
			chunk: Chunk
		) =>
			| string
			| false
			| ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string),
		allChunks: boolean,
		usesFullHashDigest?: boolean
	);
	contentType: string;
	global: string;
	getFilenameForChunk: (
		chunk: Chunk
	) =>
		| string
		| false
		| ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string);
	allChunks: boolean;

	/**
	 * The answer a runtime module gives when it installs no chunk handler at all
	 */
	static NO_CHUNK_HANDLERS: [string, string][];

	/**
	 * Runtime modules without any dependencies to other runtime modules
	 */
	static STAGE_NORMAL: number;

	/**
	 * Runtime modules with simple dependencies on other runtime modules
	 */
	static STAGE_BASIC: number;

	/**
	 * Runtime modules which attach to handlers of other runtime modules
	 */
	static STAGE_ATTACH: number;

	/**
	 * Runtime modules which trigger actions on bootstrap
	 */
	static STAGE_TRIGGER: number;
	static KINDS: Set<
		| "html"
		| "runtime"
		| "normal"
		| "css"
		| "context"
		| "remote"
		| "consume-shared"
		| "external"
		| "concatenated"
	>;

	/**
	 * Gets source basic types.
	 * @deprecated In the next major release, call getSourceBasicTypes() directly on the module instance instead of using this static method.
	 */
	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
}

declare interface GetOptionsMethod<OptionsType> {
	(): OptionsType;
	(schema: Parameters<typeof validateFunction>[0]): OptionsType;
}
type GivenCompressOptions = Omit<Partial<any>, "global_defs" | "pure_funcs"> & {
	global_defs?: false | object;
	pure_funcs?: null | string[] | ((node: PureCallView) => boolean);
};

/**
 * terser's `format` options as a caller gives them; `source_map` is left out,
 * as the minify writes it from `sourceMap`.
 */
declare interface GivenFormatOptions {
	code?: boolean;
	ast?: boolean;

	/**
	 * which comments are kept
	 */
	comments?:
		string | boolean | RegExp | ((node: any, comment: KeptComment) => boolean);

	/**
	 * whether the output is laid out to read, always false here
	 */
	beautify?: boolean;

	/**
	 * whether every body is braced, always false here
	 */
	braces?: boolean;

	/**
	 * how far a level indents, unread here
	 */
	indent_level?: number;

	/**
	 * how far the output indents, unread here
	 */
	indent_start?: number;

	/**
	 * how long a line may be, unread here
	 */
	max_line_len?: number | false;

	/**
	 * how wide a line may be, unread here
	 */
	width?: number;

	/**
	 * whether properties are written in shorthand, undefined until read from `ecma`
	 */
	shorthand?: boolean;

	/**
	 * which edition the output may use
	 */
	ecma?: number;

	/**
	 * whether the output works around that engine
	 */
	ie8?: boolean;

	/**
	 * whether the output works around that engine
	 */
	safari10?: boolean;

	/**
	 * whether only ASCII is written
	 */
	ascii_only?: boolean;

	/**
	 * whether `</script` is escaped
	 */
	inline_script?: boolean;

	/**
	 * whether numbers are written as read
	 */
	keep_numbers?: boolean;

	/**
	 * whether quoted keys stay quoted
	 */
	keep_quoted_props?: boolean;

	/**
	 * text written first
	 */
	preamble?: null | string;

	/**
	 * whether annotation comments are kept
	 */
	preserve_annotations?: boolean;

	/**
	 * whether every key is quoted
	 */
	quote_keys?: boolean;

	/**
	 * which quote strings are written with
	 */
	quote_style?: number;

	/**
	 * whether statements end in semicolons rather than line breaks
	 */
	semicolons?: boolean;

	/**
	 * whether a shebang is kept
	 */
	shebang?: boolean;

	/**
	 * whether the output works around that engine
	 */
	webkit?: boolean;

	/**
	 * whether an immediately called function is parenthesized
	 */
	wrap_iife?: boolean;

	/**
	 * whether a function passed as an argument is parenthesized
	 */
	wrap_func_args?: boolean;
	spidermonkey?: boolean;
}
type GivenMangleOptions = Omit<Partial<any>, "properties"> & {
	properties?: boolean | any;
};
type GivenSourceMapOptions = Omit<Partial<any>, "content"> & {
	content?:
		null | string | object | RawSourceMap | DecodedSourceMap | IndexSourceMap;
};

/**
 * Match glob patterns against the value, `!` in front of a pattern excludes it. Path separators are normalized to `/` on every OS, and a relative pattern matches at any depth.
 * @since 5.112.0
 */
declare interface GlobCondition {
	/**
	 * Glob patterns to match.
	 */
	glob: string | string[];
}

/**
 * Creates a callback wrapper that waits for a fixed number of completions and
 * forwards the first error immediately.
 */
declare interface GotHandler<T> {
	/**
	 * Creates a callback wrapper that waits for a fixed number of completions and
	 * forwards the first error immediately.
	 */
	(result: T, callback: () => void): void;
}

/**
 * Defines the group config type used by this module.
 */
declare interface GroupConfig<T, R> {
	getKeys: (item: T) => undefined | string[];
	getOptions?: (name: string, items: T[]) => GroupOptionsSmartGrouping;
	createGroup: (key: string, children: T[], items: T[]) => R;
}
declare interface GroupNames {
	[index: string]: true | BranchID[];
}
type GroupOptionsAsyncDependenciesBlock = RawChunkGroupOptions & {
	name?: null | string;
} & { entryOptions?: EntryOptions } & { circular?: boolean };

/**
 * Defines the group options type used by this module.
 */
declare interface GroupOptionsSmartGrouping {
	groupChildren?: boolean;
	force?: boolean;
	targetGroupCount?: number;
}

/**
 * per-branch guard frames pushed onto the parser state guard stack
 */
declare interface GuardCollection {
	consequent?: GuardFrame;
	alternate?: GuardFrame;
}
type GuardFormula =
	| ["v", Dependency]
	| ["p", ESMEvaluatedImportSpecifierDependency]
	| ["?"]
	| ["!", GuardFormula]
	| ["||" | "&&" | "??", GuardFormula, GuardFormula];

/**
 * A guard frame pushed onto `parser.state.guardStack` for the duration of one
 * conditional branch body. Carries the `"x" in ns` presence guards and/or the
 * dead-branch dependency guard for that branch.
 */
declare interface GuardFrame {
	/**
	 * the conditional test (for the lazily built formula)
	 */
	test?:
		| ImportExpressionImport
		| UnaryExpression
		| ArrayExpression
		| ArrowFunctionExpression
		| AssignmentExpression
		| AwaitExpression
		| BinaryExpression
		| SimpleCallExpression
		| NewExpression
		| ChainExpression
		| ClassExpression
		| ConditionalExpression
		| FunctionExpression
		| Identifier
		| SimpleLiteral
		| RegExpLiteral
		| BigIntLiteral
		| LogicalExpression
		| MemberExpression
		| MetaProperty
		| ObjectExpression
		| SequenceExpression
		| TaggedTemplateExpression
		| TemplateLiteral
		| ThisExpression
		| UpdateExpression
		| YieldExpression;

	/**
	 * dependency count before the test was walked
	 */
	depStart?: number;

	/**
	 * branch truthiness the dependency guard is live for
	 */
	condition?: boolean;

	/**
	 * memoized dependency-guard formula (null = no knowable atom)
	 */
	formula?:
		| null
		| ["v", Dependency]
		| ["p", ESMEvaluatedImportSpecifierDependency]
		| ["?"]
		| ["!", GuardFormula]
		| ["||" | "&&" | "??", GuardFormula, GuardFormula];

	/**
	 * memoized presence formula (null = no presence atom)
	 */
	presenceFormula?:
		| null
		| ["v", Dependency]
		| ["p", ESMEvaluatedImportSpecifierDependency]
		| ["?"]
		| ["!", GuardFormula]
		| ["||" | "&&" | "??", GuardFormula, GuardFormula];
}

/**
 * Defines the hmr javascript parser hooks type used by this module.
 */
declare interface HMRJavascriptParserHooks {
	hotAcceptCallback: SyncBailHook<
		[
			(
				| ImportExpressionImport
				| UnaryExpression
				| ArrayExpression
				| ArrowFunctionExpression
				| AssignmentExpression
				| AwaitExpression
				| BinaryExpression
				| SimpleCallExpression
				| NewExpression
				| ChainExpression
				| ClassExpression
				| ConditionalExpression
				| FunctionExpression
				| Identifier
				| SimpleLiteral
				| RegExpLiteral
				| BigIntLiteral
				| LogicalExpression
				| MemberExpression
				| MetaProperty
				| ObjectExpression
				| SequenceExpression
				| TaggedTemplateExpression
				| TemplateLiteral
				| ThisExpression
				| UpdateExpression
				| YieldExpression
				| SpreadElement
			),
			string[]
		],
		void
	>;
	hotAcceptWithoutCallback: SyncBailHook<[CallExpression, string[]], void>;
}
declare const HOISTED_DECLARATIONS: unique symbol;

/**
 * Defines the handle module creation options type used by this module.
 */
declare interface HandleModuleCreationOptions {
	factory: ModuleFactory;
	dependencies: Dependency[];
	originModule: null | Module;
	contextInfo?: Partial<ModuleFactoryCreateDataContextInfo>;
	context?: string;

	/**
	 * recurse into dependencies of the created module
	 */
	recursive?: boolean;

	/**
	 * connect the resolved module with the origin module
	 */
	connectOrigin?: boolean;

	/**
	 * check the cycle dependencies of the created module
	 */
	checkCycle?: boolean;
}
declare class Hash {
	constructor();

	/**
	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
	 */
	update(data: string | Buffer): Hash;

	/**
	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
	 */
	update(data: string, inputEncoding: string): Hash;

	/**
	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
	 */
	digest(): Buffer;

	/**
	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
	 */
	digest(encoding: string): string;
}
type HashFunction = string | typeof Hash;
declare interface HashLike {
	/**
	 * make hash update
	 */
	update: (data: string | Buffer, inputEncoding?: string) => HashLike;

	/**
	 * get hash digest
	 */
	digest: (encoding?: string) => string | Buffer;
}

/**
 * Represents the lazy hashed etag runtime component.
 */
declare interface HashableObject {
	updateHash: (hash: Hash) => void;
}
declare class HashedModuleIdsPlugin {
	/**
	 * Creates an instance of HashedModuleIdsPlugin.
	 */
	constructor(options?: HashedModuleIdsPluginOptions);
	options: HashedModuleIdsPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface HashedModuleIdsPluginOptions {
	/**
	 * The context directory for creating names.
	 */
	context?: string;

	/**
	 * The encoding to use when generating the hash, defaults to 'base64'. All encodings from Node.JS' hash.digest are supported.
	 */
	hashDigest?:
		| "ascii"
		| "utf8"
		| "utf-8"
		| "utf16le"
		| "utf-16le"
		| "ucs2"
		| "ucs-2"
		| "base64"
		| "base64url"
		| "latin1"
		| "binary"
		| "hex";

	/**
	 * The prefix length of the hash digest to use, defaults to 4.
	 */
	hashDigestLength?: number;

	/**
	 * The hashing algorithm to use, defaults to 'md4'. All functions from Node.JS' crypto.createHash are supported.
	 */
	hashFunction?: string | typeof Hash;
}
type Head<T> = T extends readonly [infer H, ...infer _Rest]
	? H
	: T extends readonly []
		? never
		: T extends readonly (infer E)[]
			? E
			: never;

/**
 * Base class for runtime modules that only emit helper functions and do not
 * need special staging or attachment behavior beyond `RuntimeModule`.
 */
declare abstract class HelperRuntimeModule extends RuntimeModule {
	/**
	 * Whether a hot update can deliver this helper, which then runs outside the
	 * bootstrap scope and reaches its state only through `__webpack_require__`.
	 */
	receivesHotUpdates(): boolean;
}
declare class HotModuleReplacementPlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Returns the attached hooks.
	 */
	static getParserHooks(parser: JavascriptParser): HMRJavascriptParserHooks;
}
declare interface HotModuleReplacementPluginLoaderContext {
	hot?: boolean;
}
declare class HotUpdateChunk extends Chunk {
	constructor();
}

/**
 * Optional node kinds a consumer can drop from the AST for speed/memory. Each
 * is a pure output reduction — tree construction (and quirks detection) runs
 * unchanged, so element structure and offsets are identical either way.
 */
declare interface HtmlAstSkip {
	/**
	 * drop every `Text` node. Raw-text element bodies (`<script>`/`<style>`/…) aren't emitted either — their content span is recorded as the element's `contentEnd` (see `RAW_TEXT_ELEMENTS`) so a consumer can read `[tagEnd, contentEnd]` by offset. For consumers that read text by offset (e.g. `HtmlParser`), never the html5lib serializer.
	 */
	text?: boolean;

	/**
	 * drop comment nodes entirely. Not for consumers that read comments (e.g. webpack magic comments).
	 */
	comments?: boolean;

	/**
	 * drop the doctype node; quirks-mode detection is unaffected.
	 */
	doctype?: boolean;
}
declare interface HtmlChunkNameData {
	/**
	 * the page's path, escaped for use in a name
	 */
	page: string;

	/**
	 * the tag's own basename, empty for an inline body
	 */
	name: string;

	/**
	 * the tag's position in the page, across all kinds
	 */
	index: number;

	/**
	 * what the tag is extracted as
	 */
	type:
		| "html"
		| "script"
		| "stylesheet"
		| "prefetch"
		| "preload"
		| "script-module"
		| "modulepreload";
}
declare interface HtmlEmittedContext {
	outputName: string;
}
declare interface HtmlEntryInfo {
	request: string;
	entryName: string;
	index: number;
	type:
		| "html"
		| "script"
		| "stylesheet"
		| "prefetch"
		| "preload"
		| "script-module"
		| "modulepreload";
	css?: boolean;
	chunkName?: string;
}
type HtmlFaviconIcon =
	| string
	| {
			/**
			 * Value for the `color` attribute (used by `rel="mask-icon"`).
			 */
			color?: string;
			/**
			 * Value for the `crossorigin` attribute.
			 */
			crossorigin?: "anonymous" | "use-credentials";
			/**
			 * Path to the icon file, emitted as a hashed asset.
			 */
			href: string;
			/**
			 * Value for the `media` attribute (e.g. `"(prefers-color-scheme: dark)"`).
			 */
			media?: string;
			/**
			 * Value for the `sizes` attribute (e.g. `"180x180"` or `"any"`).
			 */
			sizes?: string;
			/**
			 * Value for the `type` attribute; inferred from the file extension when omitted.
			 */
			type?: string;
	  };
declare abstract class HtmlGenerator extends Generator<HtmlNormalModule> {
	options: HtmlGeneratorOptions;

	/**
	 * Processes the provided module.
	 */
	sourceDependency(
		dependency: Dependency,
		source: ReplaceSource,
		templateContext: DependencyTemplateContext
	): void;

	/**
	 * Processes the provided dependencies block.
	 */
	sourceBlock(
		block: DependenciesBlock,
		source: ReplaceSource,
		templateContext: DependencyTemplateContext
	): void;

	/**
	 * Processes the provided module.
	 */
	sourceModule(
		module: HtmlNormalModule,
		initFragments: InitFragment<GenerateContext>[],
		source: ReplaceSource,
		generateContext: GenerateContext
	): void;

	/**
	 * Generates fallback output for the provided error condition.
	 */
	generateError(
		error: Error,
		module: HtmlNormalModule,
		generateContext: GenerateContext
	): null | Source;
}

/**
 * Generator options for html modules.
 */
declare interface HtmlGeneratorOptions {
	/**
	 * Emit the parsed and URL-rewritten HTML as a standalone `.html` output file alongside the module's JavaScript export. `true` always emits the file; `false` never does; `"inline"` exposes the processed HTML for inline write-back (e.g. `<iframe srcdoc>`) without emitting a standalone file. When unset, extraction defaults to `true` for HTML modules used as compilation entries (HTML entry points) and `false` for HTML modules imported from JavaScript. Filenames follow `output.htmlFilename` / `output.htmlChunkFilename`.
	 */
	extract?: boolean | "inline";
}
declare interface HtmlInjectTagsContext {
	outputName: string;
	html: string;
}
type HtmlModuleBuildInfo = KnownBuildInfo &
	Record<string, any> &
	KnownNormalModuleBuildInfo &
	KnownHtmlModuleBuildInfo;
declare class HtmlModulesPlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * `output.hashFunction`/`hashSalt`/`hashDigest`/`hashDigestLength`
	 * digest of `content`, with `nonNumericOnlyHash` applied — webpack's
	 * standard `[contenthash]` recipe.
	 */
	static computeContentHash(
		content: string | Buffer,
		outputOptions: OutputNormalizedWithDefaults
	): string;

	/**
	 * Filename template for an extracted HTML page: `output.htmlFilename` for
	 * initial chunks, `output.htmlChunkFilename` otherwise — the HTML counterpart
	 * of `CssModulesPlugin.getChunkFilenameTemplate`.
	 */
	static getChunkFilenameTemplate(
		chunk: Chunk,
		outputOptions: OutputNormalizedWithDefaults
	): ChunkFilenameTemplate;

	/**
	 * Returns true, when the chunk has html.
	 */
	static chunkHasHtml(chunk: Chunk, chunkGraph: ChunkGraph): boolean;

	/**
	 * Per-compilation hooks for the experimental HTML support.
	 */
	static getCompilationHooks: (compilation: Compilation) => {
		/**
		 * Called with the list of extra tags to inject into each page (initially empty) plus the current HTML; push `HtmlTagDescriptor`s and return the list — webpack serializes and places them by `injectTo`. A structured alternative to the string-level `transformHtml` for adding tags; runs before CSP so injected inline tags are hashed.
		 * @since 5.109.0
		 */
		injectTags: AsyncSeriesWaterfallHook<
			[HtmlTagDescriptor[], HtmlInjectTagsContext],
			HtmlTagDescriptor[]
		>;
		/**
		 * Called with the page's `<script>`/`<link>`/`<style>`/`<meta>` tags (webpack's own and any injected) as mutable descriptors; mutate `attrs` (add a `nonce`/`data-*`, switch `defer`↔`async`, …), set `remove: true`, or change `injectTo` to move a tag between `<head>` and `<body>`, and webpack rewrites the changed tags. Add new tags with `injectTags` instead.
		 * @since 5.109.0
		 */
		transformTags: AsyncSeriesHook<
			[HtmlMutableTag[], HtmlTransformTagsContext]
		>;
		/**
		 * Called with each emitted page's final HTML (all sentinels resolved) just before it is written; return the (possibly transformed) HTML — e.g. to minify, inject a CSP meta, or rewrite tags.
		 * @since 5.109.0
		 */
		transformHtml: AsyncSeriesWaterfallHook<
			[string, HtmlTransformHtmlContext],
			string
		>;
		/**
		 * Called once each page's HTML asset has been finalized — a post-emit notification (nothing to return).
		 * @since 5.109.0
		 */
		htmlEmitted: AsyncSeriesHook<[HtmlEmittedContext]>;
	};
}

/**
 * A `<script>`/`<link>`/`<style>`/`<meta>` tag already present in an emitted
 * page, exposed for in-place mutation by `transformTags`. Mutate `attrs`, set
 * `remove`, or change `injectTo` to move it; don't reorder the array itself.
 */
declare interface HtmlMutableTag {
	/**
	 * the (lowercased) tag name
	 */
	tag: string;

	/**
	 * mutable attributes; a string value renders `name="value"`, `true` a bare attribute, `false`/`undefined`/deleting the key drops it
	 */
	attrs: Record<string, undefined | string | boolean>;

	/**
	 * the tag's current region (`"head"`/`"body"`); set a different value to move it there (`*-prepend` to the region's start)
	 */
	injectTo?: "body" | "head" | "head-prepend" | "body-prepend";

	/**
	 * set true to delete the whole element
	 */
	remove?: boolean;
}
type HtmlNodePath<T = number, S = unknown> = Omit<
	{
		state: unknown;
		get node(): number;
		get parent(): null | number;
		/**
		 * Counted along the sibling links when asked, so the walk stores nothing for it.
		 */
		get index(): number;
		/**
		 * Stop the walk descending into the current node (enter only).
		 */
		skipChildren(): void;
		/**
		 * Stop the walk: no visitor fires after the current one returns.
		 */
		stop(): void;
		/**
		 * Walks the parent links, so a `<template>`'s content ends at its fragment.
		 */
		within(type: number): boolean;
		type(n?: number): number;
		range(n?: number): [number, number];
		start(n?: number): number;
		end(n?: number): number;
		/**
		 * Line / column are converted only when asked, by a converter made on the
		 * first call of a parse. Valid during the walk, as {@link source } is.
		 */
		loc(n?: number): [number, number, number, number];
		/**
		 * A node's text as written; valid during the walk, before `parseHtml` releases the source.
		 */
		source(n?: number, end?: number): string;
		/**
		 * An element's or attribute's name (lowercased, adjusted in foreign content),
		 * a doctype's name, a processing instruction's target; "" for other nodes.
		 */
		name(n?: number): string;
		fieldCount(field: number, n?: number): number;
		/**
		 * An attribute item is a node the shared reads take.
		 */
		field(i: number, field: number, n?: number): number;
		/**
		 * Attribute names are stored lowercased, so `name` is compared as written.
		 */
		fieldNamed(field: number, name: string, n?: number): number;
		flag(flag: number, n?: number): boolean;
		/**
		 * A parser-inserted element has no name, tags or content in the source.
		 */
		rangeOf(part: number, n?: number): null | [number, number];
		startOf(part: number, n?: number): number;
		endOf(part: number, n?: number): number;
		/**
		 * Name and value are read with `name` and `value`; this reads a node's
		 * other text, such as a doctype's identifiers, which are stored decoded.
		 */
		textOf(part: number, n?: number): null | string;
		/**
		 * A text's, comment's, processing instruction's or attribute's data,
		 * character references decoded; "" for other nodes.
		 */
		value(n?: number): string;
		/**
		 * Counted along the sibling links once per node and visitor call.
		 */
		childCount(n?: number): number;
		/**
		 * Reached along the sibling links from the last child read under `n`, so a
		 * loop over a node's children takes one step per child.
		 */
		child(i: number, n?: number): number;
		/**
		 * Every child as a new array, for a reader that keeps or searches them.
		 */
		children(n?: number): number[];
	},
	| "flag"
	| "node"
	| "state"
	| "within"
	| "field"
	| "fieldCount"
	| "fieldNamed"
	| "rangeOf"
	| "startOf"
	| "endOf"
	| "textOf"
> & {
	readonly node: TypedNode<number, T>;
	readonly state: S;
	within(type: HtmlNodeType): boolean;
	field<R extends number = TypedNode<number, T>, F extends number = number>(
		i: number,
		field: F &
			PartOf<
				R,
				{
					"1": never;
					"2": never;
					"3": 1 | 2;
					"4": never;
					"5": never;
					"6": never;
					"7": never;
					"8": never;
				},
				1 | 2
			>,
		n?: R
	): TypedNode<number, { [index: number]: number; "1": 8; "2": 2 }[F]>;
	fieldCount<R extends number = TypedNode<number, T>>(
		field: PartOf<
			R,
			{
				"1": never;
				"2": never;
				"3": 1 | 2;
				"4": never;
				"5": never;
				"6": never;
				"7": never;
				"8": never;
			},
			1 | 2
		>,
		n?: R
	): number;
	fieldNamed<
		R extends number = TypedNode<number, T>,
		F extends number = number
	>(
		field: F &
			PartOf<
				R,
				{
					"1": never;
					"2": never;
					"3": 1 | 2;
					"4": never;
					"5": never;
					"6": never;
					"7": never;
					"8": never;
				},
				1 | 2
			>,
		name: string,
		n?: R
	): TypedNode<number, { [index: number]: number; "1": 8; "2": 2 }[F]>;
	flag<R extends number = TypedNode<number, T>>(
		flag: PartOf<
			R,
			{
				"1": never;
				"2": never;
				"3": 1 | 2 | 4;
				"4": never;
				"5": never;
				"6": never;
				"7": never;
				"8": never;
			},
			1 | 2 | 4
		>,
		n?: R
	): boolean;
	rangeOf<R extends number = TypedNode<number, T>>(
		part: PartOf<
			R,
			{
				"1": never;
				"2": never;
				"3": 1 | 3 | 4 | 5;
				"4": never;
				"5": never;
				"6": 6 | 7;
				"7": never;
				"8": 1 | 2;
			},
			1 | 2 | 3 | 4 | 5 | 6 | 7
		>,
		n?: R
	): null | [number, number];
	startOf<R extends number = TypedNode<number, T>>(
		part: PartOf<
			R,
			{
				"1": never;
				"2": never;
				"3": 1 | 3 | 4 | 5;
				"4": never;
				"5": never;
				"6": 6 | 7;
				"7": never;
				"8": 1 | 2;
			},
			1 | 2 | 3 | 4 | 5 | 6 | 7
		>,
		n?: R
	): number;
	endOf<R extends number = TypedNode<number, T>>(
		part: PartOf<
			R,
			{
				"1": never;
				"2": never;
				"3": 1 | 3 | 4 | 5;
				"4": never;
				"5": never;
				"6": 6 | 7;
				"7": never;
				"8": 1 | 2;
			},
			1 | 2 | 3 | 4 | 5 | 6 | 7
		>,
		n?: R
	): number;
	textOf<R extends number = TypedNode<number, T>>(
		part: PartOf<
			R,
			{
				"1": never;
				"2": never;
				"3": never;
				"4": never;
				"5": never;
				"6": 6 | 7;
				"7": never;
				"8": never;
			},
			6 | 7
		>,
		n?: R
	): null | string;
};
type HtmlNodeType = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
type HtmlNormalModule = NormalModule & { buildInfo?: HtmlModuleBuildInfo };
declare interface HtmlParseOptions {
	/**
	 * context element name for fragment parsing (e.g. `td`, `svg path`); omit for a full document
	 */
	fragmentContext?: string;

	/**
	 * parse as XML instead of applying the HTML tree-construction rules
	 */
	xml?: boolean;

	/**
	 * node kinds to omit from the AST (see `HtmlAstSkip`); omit to build the full tree
	 */
	skip?: HtmlAstSkip;

	/**
	 * parse as a browser with scripting on does, where a `noscript` holds raw text; off by default, so what it holds is read as markup
	 */
	scripting?: boolean;
}
declare abstract class HtmlParser extends Parser<BuiltHtmlModule> {
	magicCommentContext: ContextImport;
	template?: (source: string, context: HtmlTemplateContext) => string;
	fragmentContext?: string;
	sourcesByTag: SourceTable;

	/**
	 * Runs the `template` option over the source and returns the transformed
	 * html. Called from HtmlModulesPlugin's `processResult`, where the return
	 * value becomes the module's stored source so the parser (which records
	 * dependency offsets against it) and the generator (which renders from
	 * `module.originalSource()`) stay in agreement.
	 */
	applyTemplate(
		source: string | Buffer,
		module: HtmlNormalModule
	): string | Buffer;
}

/**
 * Parser options for html modules.
 */
declare interface HtmlParserOptions {
	/**
	 * Configure how the HTML source is parsed: `"document"` (the default) parses a full page; any other value is the tag name of the context element to parse the source as that element's inner HTML (a fragment) — e.g. `"template"` for a neutral fragment, or `"tbody"` so context-sensitive tags like a bare `<tr>`/`<td>` are kept instead of dropped.
	 * @since 5.109.0
	 */
	as?: string;

	/**
	 * Name the chunk an extracted `<script>`/`<link>` tag becomes, in place of the page and the tag's position. A string may carry `[page]` (the page's path, escaped for a name), `[name]` (the tag's own basename, empty for an inline body), `[index]` (the tag's position in the page) and `[type]`; a function is called with the same values and returns the name. A `<!-- webpackChunkName: "..." -->` comment before a tag wins over it, and either way the name is also the stem the chunk's file is emitted under.
	 * @since 5.112.0
	 */
	chunkName?: string | ((data: HtmlChunkNameData) => string);

	/**
	 * Configure extraction of URL-like attribute values (e.g. `<img src>`, `<link href>`, `<script src>`) as webpack dependencies. `true` (default) uses the built-in source list; `false` disables extraction entirely so attributes are left untouched and `<script src>` / `<link rel="modulepreload">` / `<link rel="stylesheet">` no longer become compilation entries; an array lets you customize which `tag`/`attribute` pairs are treated as URLs and how they are bundled. Use the string `"..."` inside the array to inline the defaults. Inline `<script>` and `<style>` bodies are always processed. Use `webpackIgnore` comments or `IgnorePlugin` to skip individual URLs.
	 */
	sources?:
		| boolean
		| (
				| "..."
				| {
						/**
						 * Attribute name whose value is treated as a URL.
						 */
						attribute: string;
						/**
						 * Called with the element's decoded attribute map and the decoded attribute value; return false to skip this source entry for that element.
						 */
						filter?: (
							attributes: Map<string, string>,
							value: string
						) => boolean;
						/**
						 * Tag name to match. Omit to match any tag.
						 */
						tag?: string;
						/**
						 * How the attribute value should be parsed and bundled, or `false` to disable a built-in source for this `tag`/`attribute` (use together with `"..."` to drop a default, e.g. stop treating `<img src>` as a URL). `src` extracts a single URL as a plain asset; `srcset` parses a `srcset`-style list of candidate URLs as plain assets; `css-url` extracts `url(...)` references from a CSS value (like an SVG presentation attribute such as `fill`) as plain assets; `script` and `script-module` emit a classic / ES-module chunk entry like `<script src>` and `<script type="module" src>`; `stylesheet` emits a CSS chunk entry like `<link rel="stylesheet">`; `html` treats the URL as a link to another HTML file that is bundled as its own emitted page (its assets extracted) and rewrites the attribute to the page's output filename (like Parcel's `<a href="page.html">`); `stylesheet-style` treats the attribute value as a full stylesheet (like a `<style>` body) and `stylesheet-style-attribute` as a CSS block's contents (a declaration list, like a `style` attribute) — both bundle it through the CSS pipeline and replace the attribute's content with the processed CSS at render time; `srcdoc` treats the attribute value as an entity-encoded HTML document (like `<iframe srcdoc>`), bundling it through the HTML pipeline and replacing the attribute's content with the processed HTML at render time.
						 */
						type:
							| false
							| "html"
							| "script"
							| "css-url"
							| "stylesheet"
							| "script-module"
							| "src"
							| "srcset"
							| "stylesheet-style"
							| "stylesheet-style-attribute"
							| "srcdoc";
				  }
		  )[];

	/**
	 * Transform the raw source before the html parser extracts dependencies. Receives the source string and a context (`{ module, resource }`) and must return the html string to parse. Useful for compiling a templating language (Handlebars, EJS, Eta, …) to html so that URLs the template emits are still picked up as webpack dependencies. Runs synchronously.
	 */
	template?: (source: string, context: HtmlTemplateContext) => string;

	/**
	 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
	 * @since 5.109.0
	 */
	urlHints?: UrlHintRule[];
}

/**
 * HTML's parts by node type, which type each visitor's path.
 */
declare interface HtmlParts {
	types: HtmlNodeType;
	field: 1 | 2;
	flag: 1 | 2 | 4;
	part: 1 | 2 | 3 | 4 | 5 | 6 | 7;
	text: 6 | 7;
	fields: {
		"1": never;
		"2": never;
		"3": 1 | 2;
		"4": never;
		"5": never;
		"6": never;
		"7": never;
		"8": never;
	};
	flags: {
		"1": never;
		"2": never;
		"3": 1 | 2 | 4;
		"4": never;
		"5": never;
		"6": never;
		"7": never;
		"8": never;
	};
	parts: {
		"1": never;
		"2": never;
		"3": 1 | 3 | 4 | 5;
		"4": never;
		"5": never;
		"6": 6 | 7;
		"7": never;
		"8": 1 | 2;
	};
	texts: {
		"1": never;
		"2": never;
		"3": never;
		"4": never;
		"5": never;
		"6": 6 | 7;
		"7": never;
		"8": never;
	};
	items: { [index: number]: number; "1": 8; "2": 2 };
}

/**
 * What the HTML printer may be told, on top of the `mode` every language has:
 * `optimization.minimize.html`, and the renderer every nested body goes through.
 * `optimization.minimize.css` reaches inline CSS through `builtinEmbeddedRenderer`,
 * which `htmlMinify` passes (see `lib/config/defaults.js`).
 */
declare interface HtmlPrintOptions {
	transforms?: HtmlTransformOptions;
	collapseWhitespace?: boolean | "all" | "conservative" | "smart";
	mergeStyles?: boolean;
	mergeScripts?: boolean;
	removeEmptyAttributes?: boolean;
	removeEmptyElements?: boolean;
	removeRedundantAttributes?: boolean | "all" | "smart";
	sortAttributes?: boolean;
	sortTokenLists?: boolean;
	removeImpliedTags?: boolean | "all" | "smart";
	renderEmbeddedSource?: (
		source: string,
		info: { type: string; hostType: string; as?: string }
	) => undefined | string;
	deferEmbeddedSource?: DeferredEmbeddedSource[];
	embeddedAnswers?: (
		offer: Omit<DeferredEmbeddedSource, "build">
	) => undefined | string;
	deferSrcdoc?: boolean;
	xmlQuote?: '"' | "'";
}
declare interface HtmlProcessOptions {
	/**
	 * context element tag name for fragment parsing (see `parseHtml`); the HTML analog of the CSS parser's `as` parse-mode option
	 */
	fragmentContext?: string;

	/**
	 * parse as XML instead of applying the HTML tree-construction rules
	 */
	xml?: boolean;

	/**
	 * the quote an XML minifying print gives an attribute whose value costs the same in either (default `"`); `'` for a document bound for a `"`-quoted string, such as a CSS `url("data:…")`
	 */
	xmlQuote?: '"' | "'";

	/**
	 * node kinds to omit from the AST for speed/memory (see `HtmlAstSkip`)
	 */
	skip?: HtmlAstSkip;

	/**
	 * print the safely-minified serialization (nodes rebuilt from source, inert comments dropped, opening-tag whitespace collapsed) as `process` walks, and return it (default false = walk only, return `""`)
	 */
	minimize?: boolean;

	/**
	 * which of the meaning-preserving rewrites the minifying print makes; each is on unless it is `false`
	 */
	transforms?: HtmlTransformOptions;

	/**
	 * collapse each run of whitespace in text to a single space, except where an ancestor renders it verbatim; `"smart"` also drops what sits against a block edge and `"all"` drops every edge (default false)
	 */
	collapseWhitespace?: boolean | "all" | "conservative" | "smart";

	/**
	 * drop an attribute whose empty value leaves it in the state its absence gives (default false)
	 */
	removeEmptyAttributes?: boolean;

	/**
	 * drop an element with no children and no attributes where its bare form renders nothing and nothing reads it (default false)
	 */
	removeEmptyElements?: boolean;

	/**
	 * print a run of adjacent `<style>` elements as one sheet, which removes elements (default false)
	 */
	mergeStyles?: boolean;

	/**
	 * print a run of adjacent bare `<script>` elements whose bodies this print writes itself as one, which removes elements, hoists a later body's declarations into the ones before it, and lets a failing body end the whole run (default false)
	 */
	mergeScripts?: boolean;

	/**
	 * print an HTML or XML element's attributes commonest name first, ties by name (default false)
	 */
	sortAttributes?: boolean;

	/**
	 * print every token list the DOM reads as a set (`class`, `rel`, `part`, …) in token order (default false)
	 */
	sortTokenLists?: boolean;

	/**
	 * drop an attribute whose value is the element's own default; `true` is `"smart"`, and `"all"` also drops the spec defaults a selector can match, and with them a value naming no keyword where that says the same (default false)
	 */
	removeRedundantAttributes?: boolean | "all" | "smart";

	/**
	 * how much of the `<html>` / `<head>` / `<body>` shell §13.1.2.4 lets the parser imply may be left out: `"smart"` leaves out only the `<html>` start tag, `true` (or `"all"`) all six, `false` none (default `"smart"`)
	 */
	removeImpliedTags?: boolean | "all" | "smart";

	/**
	 * whether an `<iframe srcdoc>` is among what `deferEmbeddedSource` collects (default true); false for a caller that minifies them itself, which keeps the attribute on the normal path and its shorter delimiter
	 */
	deferSrcdoc?: boolean;

	/**
	 * what a print before this one was answered for each offer, which `processAsync` passes where an answer overturned a choice made without it: a body it answers is written from it rather than deferred
	 */
	embeddedAnswers?: (
		offer: Omit<DeferredEmbeddedSource, "build">
	) => undefined | string;

	/**
	 * collects what `renderEmbeddedSource` would be offered instead of offering it, for a caller whose renderer is asynchronous: the print leaves a marker for each and `finish` puts the answers in their place, so one parse serves both. Takes precedence over `renderEmbeddedSource`
	 */
	deferEmbeddedSource?: DeferredEmbeddedSource[];

	/**
	 * renders each nested body this document embeds — an inline `<style>`, every `style=""` (as the block's contents it is, SVG's and MathML's included), a `<script>` holding JSON or JavaScript (with `as` naming which production of it the body is — `"module"` for a `<script type=module>`, `"script"` for a classic one), every event handler attribute, with `as: "event-handler"` saying it is a function body rather than a script — the production a `return` at its top level is in, which a renderer whose engine takes only whole scripts wraps before it reads — an `<svg>` subtree, with `as: "foreign-element"` saying it is an element of this document rather than a standalone `.svg`, and the document an `<iframe srcdoc>` holds (decoded, and written back escaped). The only way any of them is minified: webpack minifies nothing here itself, and `builtinEmbeddedRenderer` is its own CSS and JSON minifiers for a caller to pass; returning anything but text leaves a body as written
	 */
	renderEmbeddedSource?: (
		source: string,
		info: { type: string; hostType: string; as?: string }
	) => undefined | string;
}

/**
 * A custom resource-hint `<link>` (`output.html.resourceHints`). Exactly one of
 * `href` / `chunk` / `entry` names the target; `chunk`/`entry` URLs (hash and
 * public path) are resolved by webpack, `href` is used verbatim.
 */
declare interface HtmlResourceHintHtmlEntryDependency {
	/**
	 * hint relationship
	 */
	rel: HtmlResourceHintRel;

	/**
	 * literal URL (external, `preconnect`, or an already-hashed asset)
	 */
	href?: string;

	/**
	 * chunk name to hint
	 */
	chunk?: string;

	/**
	 * entrypoint name to hint (expands to one hint per initial chunk)
	 */
	entry?: string;

	/**
	 * the `as` attribute; defaults to `script` for chunk/entry refs
	 */
	as?: string;

	/**
	 * the `type` attribute (MIME)
	 */
	type?: string;

	/**
	 * CORS mode (`true` → `anonymous`)
	 */
	crossorigin?: boolean | "anonymous" | "use-credentials";

	/**
	 * the `media` attribute
	 */
	media?: string;

	/**
	 * SRI for a chunk/entry ref; follows `output.html.integrity` by default, `false` opts out
	 */
	integrity?: boolean;

	/**
	 * the `fetchpriority` attribute (allowed on `preload`/`modulepreload`/`prefetch`)
	 */
	fetchPriority?: "auto" | "low" | "high";
}
type HtmlResourceHintRel =
	"prefetch" | "preload" | "modulepreload" | "preconnect" | "dns-prefetch";

/**
 * A custom resource-hint `<link>` for `output.html.resourceHints`. Exactly one of `href` / `chunk` / `entry` names the target.
 * @since 5.109.0
 */
declare interface HtmlResourceHintWebpackOptions {
	/**
	 * The `as` attribute (`script`, `style`, `font`, …); defaults to `script` for chunk/entry references.
	 */
	as?: string;

	/**
	 * Name of a chunk to hint; its emitted URL is resolved automatically.
	 */
	chunk?: string;

	/**
	 * The CORS mode; `true` maps to `anonymous`.
	 */
	crossorigin?: boolean | "anonymous" | "use-credentials";

	/**
	 * Name of an entrypoint to hint; expands to one hint per initial chunk.
	 */
	entry?: string;

	/**
	 * The `fetchpriority` attribute. Emitted on `preload` / `modulepreload` and on `prefetch` (the spec now permits it there).
	 */
	fetchPriority?: "auto" | "low" | "high";

	/**
	 * A literal URL used verbatim (external resource, `preconnect` origin, or an already-hashed asset).
	 */
	href?: string;

	/**
	 * Subresource Integrity for a chunk/entry reference. Follows `output.html.integrity` by default; set `false` to opt this hint out.
	 */
	integrity?: boolean;

	/**
	 * The `media` attribute.
	 */
	media?: string;

	/**
	 * The `rel` of the resource hint.
	 */
	rel: "prefetch" | "preload" | "modulepreload" | "preconnect" | "dns-prefetch";

	/**
	 * The `type` attribute (MIME type).
	 */
	type?: string;
}

/**
 * The generic visitor coordinator (`util/SourceProcessor`) bound to the HTML
 * `grammar`. Usage:
 * ```
 * new HtmlSourceProcessor().use({ [NodeType.Element]: (path) => {}, [NodeType.Comment]: { enter, exit } }).process(source, { skip });
 * ```
 * @experimental exposed as `webpack.html.syntax.SourceProcessor`; unstable API
 */
declare class HtmlSourceProcessor<TState = unknown> extends SourceProcessor<
	{
		state: unknown;
		get node(): number;
		get parent(): null | number;
		/**
		 * Counted along the sibling links when asked, so the walk stores nothing for it.
		 */
		get index(): number;
		/**
		 * Stop the walk descending into the current node (enter only).
		 */
		skipChildren(): void;
		/**
		 * Stop the walk: no visitor fires after the current one returns.
		 */
		stop(): void;
		/**
		 * Walks the parent links, so a `<template>`'s content ends at its fragment.
		 */
		within(type: number): boolean;
		type(n?: number): number;
		range(n?: number): [number, number];
		start(n?: number): number;
		end(n?: number): number;
		/**
		 * Line / column are converted only when asked, by a converter made on the
		 * first call of a parse. Valid during the walk, as {@link source } is.
		 */
		loc(n?: number): [number, number, number, number];
		/**
		 * A node's text as written; valid during the walk, before `parseHtml` releases the source.
		 */
		source(n?: number, end?: number): string;
		/**
		 * An element's or attribute's name (lowercased, adjusted in foreign content),
		 * a doctype's name, a processing instruction's target; "" for other nodes.
		 */
		name(n?: number): string;
		fieldCount(field: number, n?: number): number;
		/**
		 * An attribute item is a node the shared reads take.
		 */
		field(i: number, field: number, n?: number): number;
		/**
		 * Attribute names are stored lowercased, so `name` is compared as written.
		 */
		fieldNamed(field: number, name: string, n?: number): number;
		flag(flag: number, n?: number): boolean;
		/**
		 * A parser-inserted element has no name, tags or content in the source.
		 */
		rangeOf(part: number, n?: number): null | [number, number];
		startOf(part: number, n?: number): number;
		endOf(part: number, n?: number): number;
		/**
		 * Name and value are read with `name` and `value`; this reads a node's
		 * other text, such as a doctype's identifiers, which are stored decoded.
		 */
		textOf(part: number, n?: number): null | string;
		/**
		 * A text's, comment's, processing instruction's or attribute's data,
		 * character references decoded; "" for other nodes.
		 */
		value(n?: number): string;
		/**
		 * Counted along the sibling links once per node and visitor call.
		 */
		childCount(n?: number): number;
		/**
		 * Reached along the sibling links from the last child read under `n`, so a
		 * loop over a node's children takes one step per child.
		 */
		child(i: number, n?: number): number;
		/**
		 * Every child as a new array, for a reader that keeps or searches them.
		 */
		children(n?: number): number[];
	},
	number,
	HtmlProcessOptions,
	HtmlPrintOptions,
	HtmlParts,
	TState,
	HtmlVisitorMap<TState>
> {
	constructor();
	static PrintContext: typeof PrintContext;
	static declineDeferredWrites: (
		text: string,
		writes: DeferredWrite[]
	) => string;
	static deferredWrite: (id: number) => string;
}

/**
 * A tag to inject into an emitted page as a structured descriptor. Injected
 * verbatim (not re-bundled) at the `injectTo` position.
 */
declare interface HtmlTagDescriptor {
	/**
	 * tag name, e.g. `"script"` / `"link"` / `"meta"`
	 */
	tag: string;

	/**
	 * attributes; `true` renders a bare boolean attribute, `false`/`undefined` is omitted
	 */
	attrs?: Record<string, undefined | string | boolean>;

	/**
	 * inner content (ignored for void elements like `<link>`/`<meta>`)
	 */
	children?: string;

	/**
	 * placement; defaults to `"head"`
	 */
	injectTo?: "body" | "head" | "head-prepend" | "body-prepend";

	/**
	 * force a void element (no closing tag); inferred from the tag name when omitted
	 */
	voidTag?: boolean;
}
declare interface HtmlTemplateContext {
	/**
	 * the html module being transformed
	 */
	module: Module;

	/**
	 * absolute path of the module's resource
	 */
	resource: string;

	/**
	 * register a file (e.g. a template partial) as a build dependency so editing it triggers a rebuild
	 */
	addDependency: (dependency: string) => void;

	/**
	 * register a directory as a build dependency
	 */
	addContextDependency: (dependency: string) => void;

	/**
	 * register a not-yet-existing path as a build dependency so creating it triggers a rebuild
	 */
	addMissingDependency: (dependency: string) => void;

	/**
	 * register a build dependency (e.g. a template engine config) so changing it invalidates the cache
	 */
	addBuildDependency: (dependency: string) => void;

	/**
	 * report a non-fatal warning on the module
	 */
	emitWarning: (warning: string | Error) => void;

	/**
	 * report an error on the module
	 */
	emitError: (error: string | Error) => void;
}
declare interface HtmlTokenCallbacks {
	openTag?: (
		input: string,
		start: number,
		end: number,
		nameStart: number,
		nameEnd: number,
		selfClosing: boolean
	) => number;
	closeTag?: (
		input: string,
		start: number,
		end: number,
		nameStart: number,
		nameEnd: number
	) => number;
	text?: (input: string, start: number, end: number) => number;
	attribute?: (
		input: string,
		nameStart: number,
		nameEnd: number,
		valueStart: number,
		valueEnd: number,
		quoteType: number
	) => number;
	comment?: (
		input: string,
		start: number,
		end: number,
		dataStart: number,
		dataEnd: number
	) => number;

	/**
	 * `subsetStart` / `subsetEnd` delimit an XML internal subset (`tokenizeXml` only; -1 when absent)
	 */
	doctype?: (
		input: string,
		start: number,
		end: number,
		nameStart: number,
		nameEnd: number,
		publicStart: number,
		publicEnd: number,
		systemStart: number,
		systemEnd: number,
		forceQuirks: boolean,
		subsetStart?: number,
		subsetEnd?: number
	) => number;
	parseError?: (
		input: string,
		code: string,
		start: number,
		end: number,
		severity: ParseErrorSeverity
	) => void;

	/**
	 * returns true when the adjusted current node is in a foreign (SVG/MathML) namespace, which is where a `<![CDATA[` opens a CDATA section
	 */
	isForeign?: () => boolean;

	/**
	 * returns true when the tree builder will not run the algorithm that switches the tokenizer for this start tag, so it stays in the data state
	 */
	vetoesContentMode?: (name: string) => boolean;

	/**
	 * context element tag name for fragment parsing; seeds the initial content mode
	 */
	fragmentContext?: string;

	/**
	 * read a `noscript` as raw text, as a document with scripting on does
	 */
	scripting?: boolean;
}
declare interface HtmlTransformHtmlContext {
	outputName: string;
}

/**
 * What the minifying printer may rewrite. Every entry is on unless it is
 * `false`, so a document one transform breaks can still be minified by the rest.
 */
declare interface HtmlTransformOptions {
	/**
	 * write a boolean attribute as the bare name its presence already means; `true` only the spellings the spec canonicalizes, `"all"` any value
	 */
	collapseBooleanAttributes?: boolean | "all";

	/**
	 * which comments survive: `"some"` (the default) the ones that carry something, `true` / `"all"` every one, `false` none, or the ones a pattern matches / a predicate accepts, over the comment's own text. A comment a parser or a server reads is kept whatever this says
	 */
	comments?: string | boolean | RegExp | ((comment: string) => boolean);

	/**
	 * drop or re-pick an attribute value's quotes
	 */
	normalizeAttributeQuotes?: boolean;

	/**
	 * fold an enumerated value to the keyword it names
	 */
	normalizeEnumeratedAttributes?: boolean;

	/**
	 * normalize a space-, comma- or descriptor-separated list value (`class`, `rel`, `srcset`, `sizes`, the viewport `content`)
	 */
	normalizeListAttributes?: boolean;

	/**
	 * write an integer attribute the one way its rules read it
	 */
	normalizeNumericAttributes?: boolean;

	/**
	 * drop the whitespace around a URL value (`href`, `src`, `action`, …), which resolving the URL skips over
	 */
	normalizeUrlAttributes?: boolean;

	/**
	 * leave out an optional tag other than the `<html>` / `<head>` / `<body>` shell, which is `removeImpliedTags`
	 */
	removeOptionalTags?: boolean;
}
declare interface HtmlTransformTagsContext {
	outputName: string;
	html: string;
}
declare interface HtmlVisitorMap<S = unknown> {
	"1"?:
		| VisitorFn<HtmlNodePath<1, S>>
		| {
				enter?: VisitorFn<HtmlNodePath<1, S>>;
				exit?: VisitorFn<HtmlNodePath<1, S>>;
		  };
	"2"?:
		| VisitorFn<HtmlNodePath<2, S>>
		| {
				enter?: VisitorFn<HtmlNodePath<2, S>>;
				exit?: VisitorFn<HtmlNodePath<2, S>>;
		  };
	"3"?:
		| VisitorFn<HtmlNodePath<3, S>>
		| {
				enter?: VisitorFn<HtmlNodePath<3, S>>;
				exit?: VisitorFn<HtmlNodePath<3, S>>;
		  };
	"4"?:
		| VisitorFn<HtmlNodePath<4, S>>
		| {
				enter?: VisitorFn<HtmlNodePath<4, S>>;
				exit?: VisitorFn<HtmlNodePath<4, S>>;
		  };
	"5"?:
		| VisitorFn<HtmlNodePath<5, S>>
		| {
				enter?: VisitorFn<HtmlNodePath<5, S>>;
				exit?: VisitorFn<HtmlNodePath<5, S>>;
		  };
	"6"?:
		| VisitorFn<HtmlNodePath<6, S>>
		| {
				enter?: VisitorFn<HtmlNodePath<6, S>>;
				exit?: VisitorFn<HtmlNodePath<6, S>>;
		  };
	"7"?:
		| VisitorFn<HtmlNodePath<7, S>>
		| {
				enter?: VisitorFn<HtmlNodePath<7, S>>;
				exit?: VisitorFn<HtmlNodePath<7, S>>;
		  };
	"8"?:
		| VisitorFn<HtmlNodePath<8, S>>
		| {
				enter?: VisitorFn<HtmlNodePath<8, S>>;
				exit?: VisitorFn<HtmlNodePath<8, S>>;
		  };
}

/**
 * Options for building http resources.
 */
declare interface HttpUriOptions {
	/**
	 * List of allowed URIs (resp. the beginning of them).
	 */
	allowedUris: HttpUriOptionsAllowedUrisItem[];

	/**
	 * Location where resource content is stored for lockfile entries. It's also possible to disable storing by passing false.
	 */
	cacheLocation?: string | false;

	/**
	 * When set, anything that would lead to a modification of the lockfile or any resource content, will result in an error.
	 */
	frozen?: boolean;

	/**
	 * Location of the lockfile.
	 */
	lockfileLocation?: string;

	/**
	 * Proxy configuration, which can be used to specify a proxy server to use for HTTP requests.
	 */
	proxy?: string;

	/**
	 * When set, resources of existing lockfile entries will be fetched and entries will be upgraded when resource content has changed.
	 */
	upgrade?: boolean;
}
type HttpUriOptionsAllowedUrisItem =
	string | RegExp | ((uri: string) => boolean);
declare class HttpUriPlugin {
	/**
	 * Creates an instance of HttpUriPlugin.
	 */
	constructor(options: HttpUriOptions);
	options: HttpUriOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
type IBigIntStatsFs = IStatsBaseFs<bigint> & {
	atimeNs: bigint;
	mtimeNs: bigint;
	ctimeNs: bigint;
	birthtimeNs: bigint;
};
type IBigIntStatsResolver = IStatsBaseResolver<bigint> & {
	atimeNs: bigint;
	mtimeNs: bigint;
	ctimeNs: bigint;
	birthtimeNs: bigint;
};

/**
 * Defines the i stats base type used by this module.
 */
declare interface IStatsBaseFs<T> {
	isFile: () => boolean;
	isDirectory: () => boolean;
	isBlockDevice: () => boolean;
	isCharacterDevice: () => boolean;
	isSymbolicLink: () => boolean;
	isFIFO: () => boolean;
	isSocket: () => boolean;
	dev: T;
	ino: T;
	mode: T;
	nlink: T;
	uid: T;
	gid: T;
	rdev: T;
	size: T;
	blksize: T;
	blocks: T;
	atimeMs: T;
	mtimeMs: T;
	ctimeMs: T;
	birthtimeMs: T;
	atime: Date;
	mtime: Date;
	ctime: Date;
	birthtime: Date;
}
declare interface IStatsBaseResolver<T> {
	/**
	 * is file
	 */
	isFile: () => boolean;

	/**
	 * is directory
	 */
	isDirectory: () => boolean;

	/**
	 * is block device
	 */
	isBlockDevice: () => boolean;

	/**
	 * is character device
	 */
	isCharacterDevice: () => boolean;

	/**
	 * is symbolic link
	 */
	isSymbolicLink: () => boolean;

	/**
	 * is FIFO
	 */
	isFIFO: () => boolean;

	/**
	 * is socket
	 */
	isSocket: () => boolean;

	/**
	 * dev
	 */
	dev: T;

	/**
	 * ino
	 */
	ino: T;

	/**
	 * mode
	 */
	mode: T;

	/**
	 * nlink
	 */
	nlink: T;

	/**
	 * uid
	 */
	uid: T;

	/**
	 * gid
	 */
	gid: T;

	/**
	 * rdev
	 */
	rdev: T;

	/**
	 * size
	 */
	size: T;

	/**
	 * blksize
	 */
	blksize: T;

	/**
	 * blocks
	 */
	blocks: T;

	/**
	 * atime ms
	 */
	atimeMs: T;

	/**
	 * mtime ms
	 */
	mtimeMs: T;

	/**
	 * ctime ms
	 */
	ctimeMs: T;

	/**
	 * birthtime ms
	 */
	birthtimeMs: T;

	/**
	 * atime
	 */
	atime: Date;

	/**
	 * mtime
	 */
	mtime: Date;

	/**
	 * ctime
	 */
	ctime: Date;

	/**
	 * birthtime
	 */
	birthtime: Date;
}

/**
 * Defines the i stats base type used by this module.
 */
declare interface IStatsFs {
	isFile: () => boolean;
	isDirectory: () => boolean;
	isBlockDevice: () => boolean;
	isCharacterDevice: () => boolean;
	isSymbolicLink: () => boolean;
	isFIFO: () => boolean;
	isSocket: () => boolean;
	dev: number;
	ino: number;
	mode: number;
	nlink: number;
	uid: number;
	gid: number;
	rdev: number;
	size: number;
	blksize: number;
	blocks: number;
	atimeMs: number;
	mtimeMs: number;
	ctimeMs: number;
	birthtimeMs: number;
	atime: Date;
	mtime: Date;
	ctime: Date;
	birthtime: Date;
}
declare interface IStatsResolver {
	/**
	 * is file
	 */
	isFile: () => boolean;

	/**
	 * is directory
	 */
	isDirectory: () => boolean;

	/**
	 * is block device
	 */
	isBlockDevice: () => boolean;

	/**
	 * is character device
	 */
	isCharacterDevice: () => boolean;

	/**
	 * is symbolic link
	 */
	isSymbolicLink: () => boolean;

	/**
	 * is FIFO
	 */
	isFIFO: () => boolean;

	/**
	 * is socket
	 */
	isSocket: () => boolean;

	/**
	 * dev
	 */
	dev: number;

	/**
	 * ino
	 */
	ino: number;

	/**
	 * mode
	 */
	mode: number;

	/**
	 * nlink
	 */
	nlink: number;

	/**
	 * uid
	 */
	uid: number;

	/**
	 * gid
	 */
	gid: number;

	/**
	 * rdev
	 */
	rdev: number;

	/**
	 * size
	 */
	size: number;

	/**
	 * blksize
	 */
	blksize: number;

	/**
	 * blocks
	 */
	blocks: number;

	/**
	 * atime ms
	 */
	atimeMs: number;

	/**
	 * mtime ms
	 */
	mtimeMs: number;

	/**
	 * ctime ms
	 */
	ctimeMs: number;

	/**
	 * birthtime ms
	 */
	birthtimeMs: number;

	/**
	 * atime
	 */
	atime: Date;

	/**
	 * mtime
	 */
	mtime: Date;

	/**
	 * ctime
	 */
	ctime: Date;

	/**
	 * birthtime
	 */
	birthtime: Date;
}
declare interface IdToHashMap {
	[index: number]: string;
	[index: string]: string;
}
declare class IgnorePlugin {
	/**
	 * Creates an instance of IgnorePlugin.
	 */
	constructor(options: IgnorePluginOptions);
	options: IgnorePluginOptions;

	/**
	 * Note that if "contextRegExp" is given, both the "resourceRegExp" and "contextRegExp" have to match.
	 */
	checkIgnore(
		resolveData: ResolveData | BeforeContextResolveData
	): undefined | false;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface IgnorePluginCheckOptions {
	/**
	 * A filter function for resource and context.
	 */
	checkResource: (resource: string, context: string) => boolean;
}
type IgnorePluginOptions =
	IgnorePluginPatternOptions | IgnorePluginCheckOptions;
declare interface IgnorePluginPatternOptions {
	/**
	 * A RegExp to test the context (directory) against.
	 */
	contextRegExp?: RegExp;

	/**
	 * A RegExp to test the request against.
	 */
	resourceRegExp: RegExp;
}
type ImportAttributes = Record<string, string> & {};
declare interface ImportDependencyMeta {
	attributes?: ImportAttributes;
	phase?: 0 | 1 | 2;
	externalType?: "import" | "module";
}
type ImportExpressionJavascriptParser = ImportExpressionImport & {
	phase?: "defer" | "source";
};
type ImportMetaParserOptions = ImportMetaParserOptionsKnown &
	ImportMetaParserOptionsUnknown;

/**
 * Enable/disable evaluating import.meta fields. Omitted fields are enabled and unknown fields are preserved. Custom fields are allowed.
 * @since 5.109.0
 */
declare interface ImportMetaParserOptionsKnown {
	/**
	 * Enable/disable evaluating import.meta.dirname.
	 */
	dirname?: boolean;

	/**
	 * Enable/disable evaluating import.meta.env.
	 */
	env?: boolean;

	/**
	 * Enable/disable evaluating import.meta.filename.
	 */
	filename?: boolean;

	/**
	 * Enable/disable evaluating import.meta.main.
	 */
	main?: boolean;

	/**
	 * Enable/disable evaluating import.meta.resolve.
	 */
	resolve?: boolean;

	/**
	 * Enable/disable evaluating import.meta.url.
	 */
	url?: boolean;

	/**
	 * Enable/disable evaluating import.meta.webpack.
	 */
	webpack?: boolean;

	/**
	 * Enable/disable evaluating import.meta.webpackContext.
	 */
	webpackContext?: boolean;

	/**
	 * Enable/disable evaluating import.meta.webpackHot.
	 */
	webpackHot?: boolean;
}

/**
 * Enable/disable evaluating import.meta fields. Omitted fields are enabled and unknown fields are preserved. Custom fields are allowed.
 * @since 5.109.0
 */
declare interface ImportMetaParserOptionsUnknown {
	[index: string]: boolean;
}

declare interface ImportModuleMethod {
	(
		request: string,
		options: undefined | ImportModuleOptions,
		callback: (err?: null | Error, exports?: any) => void
	): void;
	(request: string, options?: ImportModuleOptions): Promise<any>;
}

/**
 * Defines the import module options type used by this module.
 */
declare interface ImportModuleOptions {
	/**
	 * the target layer
	 */
	layer?: string;

	/**
	 * the target public path
	 */
	publicPath?: string;

	/**
	 * target base uri
	 */
	baseUri?: string;
}
type ImportPhaseType = 0 | 1 | 2;
declare interface ImportSettings {
	references: string[][];
	expression: ImportExpressionJavascriptParser;
}
type ImportSource =
	undefined | null | string | SimpleLiteral | RegExpLiteral | BigIntLiteral;
type Imported = true | [string, string][];

/**
 * a map made of sections, each a map of its own, or its JSON
 */
declare interface IndexSourceMap {
	version: number;
	file?: string;
	sections: {
		offset: { line: number; column: number };
		map: string | RawSourceMap | DecodedSourceMap | IndexSourceMap;
	}[];
}

/**
 * Options for infrastructure level logging.
 */
declare interface InfrastructureLogging {
	/**
	 * Only appends lines to the output. Avoids updating existing output e. g. for status messages. This option is only used when no custom console is provided.
	 */
	appendOnly?: boolean;

	/**
	 * Enables/Disables colorful output. This option is only used when no custom console is provided.
	 */
	colors?: boolean;

	/**
	 * Custom console used for logging.
	 */
	console?: Console;

	/**
	 * Enable debug logging for specific loggers.
	 */
	debug?:
		| string
		| boolean
		| RegExp
		| FilterItemTypes[]
		| ((value: string) => boolean);

	/**
	 * Log level.
	 */
	level?: "none" | "verbose" | "error" | "warn" | "info" | "log";

	/**
	 * Show build progress. `"auto"` shows it only for interactive terminals. This option is only used when no custom console is provided.
	 * @since 5.109.0
	 */
	progress?: boolean | "auto";

	/**
	 * Stream used for logging output. Defaults to process.stderr. This option is only used when no custom console is provided.
	 */
	stream?: NodeJS.WritableStream & {
		isTTY?: boolean;
		columns?: number;
		rows?: number;
	};
}
type InfrastructureLoggingNormalizedWithDefaults = InfrastructureLogging & {
	stream: NodeJS.WritableStream & {
		isTTY?: boolean;
		columns?: number;
		rows?: number;
	};
	level: NonNullable<
		undefined | "none" | "verbose" | "error" | "warn" | "info" | "log"
	>;
	debug: NonNullable<
		| undefined
		| string
		| boolean
		| RegExp
		| FilterItemTypes[]
		| ((value: string) => boolean)
	>;
	colors: NonNullable<undefined | boolean>;
	appendOnly: NonNullable<undefined | boolean>;
};

/**
 * Represents InitFragment.
 */
declare class InitFragment<GenerateContext> {
	/**
	 * Creates an instance of InitFragment.
	 */
	constructor(
		content: undefined | string | Source,
		stage: number,
		position: number,
		key?: string,
		endContent?: string | Source
	);
	content?: string | Source;
	stage: number;
	position: number;
	key?: string;
	endContent?: string | Source;

	/**
	 * Returns the source code that will be included as initialization code.
	 */
	getContent(context: GenerateContext): undefined | string | Source;

	/**
	 * Returns the source code that will be included at the end of the module.
	 */
	getEndContent(context: GenerateContext): undefined | string | Source;

	/**
	 * Serializes this instance into the provided serializer context.
	 */
	serialize(context: ObjectSerializerContextObjectMiddlewareObject_3): void;

	/**
	 * Restores this instance from the provided deserializer context.
	 */
	deserialize(context: ObjectDeserializerContextObjectMiddlewareObject_2): void;

	/**
	 * Adds the provided source to the init fragment.
	 */
	static addToSource<Context>(
		source: Source,
		initFragments: MaybeMergeableInitFragment<Context>[],
		context: Context
	): Source;
	static STAGE_CONSTANTS: number;
	static STAGE_ASYNC_BOUNDARY: number;
	static STAGE_ESM_EXPORTS: number;
	static STAGE_ESM_IMPORTS: number;
	static STAGE_PROVIDES: number;
	static STAGE_ASYNC_DEPENDENCIES: number;
	static STAGE_ASYNC_ESM_IMPORTS: number;

	/**
	 * use `STAGE_ESM_EXPORTS` — TODO in the next major release: remove
	 * @deprecated
	 */
	static STAGE_HARMONY_EXPORTS: number;

	/**
	 * use `STAGE_ESM_IMPORTS` — TODO in the next major release: remove
	 * @deprecated
	 */
	static STAGE_HARMONY_IMPORTS: number;

	/**
	 * use `STAGE_ASYNC_ESM_IMPORTS` — TODO in the next major release: remove
	 * @deprecated
	 */
	static STAGE_ASYNC_HARMONY_IMPORTS: number;
}
declare abstract class InlinedUsedName {
	value: InlinedValue;
	suffix: string[];
	render(comment?: string): string;

	/**
	 * Updates the hash with the data contributed by this instance.
	 */
	updateHash(hash: Hash): void;
}
declare abstract class InlinedValue {
	kind: InlinedValueKind;
	value?: null | string | number | boolean;
	renderLiteral(): string;
	render(comment: string): string;
	equals(other: InlinedValue): boolean;
	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;
	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;
}
type InlinedValueKind = "string" | "number" | "boolean" | "undefined" | "null";
declare interface InnerGraphUtils {
	enable: (parserState: ParserState) => void;
	bailout: (parserState: ParserState) => void;
	isEnabled: (parserState: ParserState) => boolean;
	addUsage: (
		parserState: ParserState,
		symbol: null | TopLevelSymbol,
		usage: Usage
	) => void;
	onUsage: (
		parserState: ParserState,
		onUsageCallback: (
			value: undefined | boolean | Set<string>,
			module: Module
		) => void
	) => void;
	setTopLevelSymbol: (
		parserState: ParserState,
		symbol?: TopLevelSymbol
	) => void;
	getTopLevelSymbol: (parserState: ParserState) => void | TopLevelSymbol;
	tagTopLevelSymbol: (
		parser: JavascriptParser,
		name: string,
		pure?: boolean | ((compilation: Compilation, module: Module) => boolean)
	) => undefined | TopLevelSymbol;
	addVariableUsage: (
		parser: JavascriptParser,
		name: string,
		usage: Usage
	) => void;
	inferDependencyUsage: (module: Module) => void;
	release: (module: Module) => void;
}

/**
 * Defines the input file system type used by this module.
 */
declare interface InputFileSystem {
	readFile: ReadFileFs;
	readFileSync?: ReadFileSync;
	readlink: ReadlinkFs;
	readlinkSync?: ReadlinkSync;
	readdir: ReaddirFs;
	readdirSync?: ReaddirSync;
	stat: StatFs;
	statSync?: StatSync;
	lstat?: LStatFs;
	lstatSync?: LStatSync;
	realpath?: RealPathFs;
	realpathSync?: RealPathSync;
	readJson?: (
		pathOrFileDescriptor: PathOrFileDescriptorFs,
		callback: (
			err: null | Error | NodeJS.ErrnoException,
			result?: JsonObjectFs
		) => void
	) => void;
	readJsonSync?: (pathOrFileDescriptor: PathOrFileDescriptorFs) => JsonObjectFs;
	purge?: (
		value?: string | string[] | Set<string>,
		options?: { exact?: boolean }
	) => void;
	join?: (path1: string, path2: string) => string;
	relative?: (from: string, to: string) => string;
	dirname?: (dirname: string) => string;
}
declare interface Inspector {
	Session: typeof SessionImportInspectorClass_1;
}
type IntermediateFileSystem = InputFileSystem &
	OutputFileSystem &
	IntermediateFileSystemExtras;

/**
 * Defines the intermediate file system extras type used by this module.
 */
declare interface IntermediateFileSystemExtras {
	mkdirSync: MkdirSync;
	createWriteStream: (
		pathLike: PathLikeFs,
		result?:
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| WriteStreamOptions
	) => NodeJS.WritableStream;
	open: Open;
	read: Read<NodeJS.ArrayBufferView>;
	close: (
		df: number,
		callback: (err: null | NodeJS.ErrnoException) => void
	) => void;
	rename: (
		a: PathLikeFs,
		b: PathLikeFs,
		callback: (err: null | NodeJS.ErrnoException) => void
	) => void;
}
type InternalCell<T> = T | typeof TOMBSTONE | typeof UNDEFINED_MARKER;
declare interface InterpolatedPathAndAssetInfo {
	path: string;
	info: AssetInfo;
}
type Issuer = undefined | null | Module;
type IssuerLayer = null | string;

/**
 * Defines the item type used by this module.
 */
declare interface Item<T> {
	[index: string]: string | string[] | T;
}
declare abstract class ItemCacheFacade {
	/**
	 * Returns value.
	 */
	get<T>(callback: CallbackCacheCacheFacade<T>): void;

	/**
	 * Returns promise with the data.
	 */
	getPromise<T>(): Promise<T>;

	/**
	 * Processes the provided data.
	 */
	store<T>(data: T, callback: CallbackCacheCacheFacade<void>): void;

	/**
	 * Stores the provided data.
	 */
	storePromise<T>(data: T): Promise<void>;

	/**
	 * Processes the provided computer.
	 */
	provide<T>(
		computer: (callback: CallbackNormalErrorCache<T>) => void,
		callback: CallbackNormalErrorCache<T>
	): void;

	/**
	 * Returns promise with the data.
	 */
	providePromise<T>(computer: () => T | Promise<T>): Promise<T>;
}
declare interface IteratorObject<T, TReturn = unknown, TNext = unknown>
	extends Iterator<T, TReturn, TNext>, Disposable {
	[Symbol.iterator](): IteratorObject<T, TReturn, TNext>;
	[Symbol.dispose](): void;
}
declare abstract class JavascriptGenerator extends Generator<JavascriptNormalModule> {
	/**
	 * Processes the provided dependency.
	 */
	sourceDependency(
		dependency: Dependency,
		source: ReplaceSource,
		templateContext: DependencyTemplateContext,
		generateContext: GenerateContext
	): void;

	/**
	 * Processes the provided dependencies block.
	 */
	sourceBlock(
		module: Module,
		block: DependenciesBlock,
		templateContext: DependencyTemplateContext,
		source: ReplaceSource,
		generateContext: GenerateContext
	): void;

	/**
	 * Processes the provided module.
	 */
	sourceModule(
		module: Module,
		initFragments: InitFragment<GenerateContext>[],
		source: ReplaceSource,
		generateContext: GenerateContext
	): void;

	/**
	 * Generates fallback output for the provided error condition.
	 */
	generateError(
		error: Error,
		module: JavascriptNormalModule,
		generateContext: GenerateContext
	): null | Source;
}
type JavascriptModuleBuildInfo = KnownBuildInfo &
	Record<string, any> &
	KnownNormalModuleBuildInfo &
	KnownJavascriptModuleBuildInfo;
type JavascriptModuleBuildMeta = KnownBuildMeta &
	Record<string, any> &
	KnownJavascriptModuleBuildMeta;
declare class JavascriptModulesPlugin {
	constructor(options?: object);
	options: object;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Renders the newly generated source from rendering.
	 */
	renderModule(
		module: Module,
		renderContext: ModuleRenderContext,
		hooks: {
			renderModuleContent: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModuleContainer: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModulePackage: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			render: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.41.0
			 */
			renderContent: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.22.0
			 */
			renderStartup: SyncWaterfallHook<
				[Source, Module, StartupRenderContext],
				Source
			>;
			renderChunk: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderMain: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderRequire: SyncWaterfallHook<
				[string, RenderBootstrapContext],
				string
			>;
			/**
			 * @since 5.22.0
			 */
			inlineInRuntimeBailout: SyncBailHook<
				[Module, Partial<RenderBootstrapContext>],
				string | void
			>;
			/**
			 * @since 5.22.0
			 */
			embedInRuntimeBailout: SyncBailHook<
				[Module, RenderContextJavascriptModulesPlugin],
				string | void
			>;
			/**
			 * @since 5.26.1
			 */
			strictRuntimeBailout: SyncBailHook<
				[RenderContextJavascriptModulesPlugin],
				string | void
			>;
			chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
			/**
			 * @since 5.2.1
			 */
			useSourceMap: SyncBailHook<
				[Chunk, RenderContextJavascriptModulesPlugin],
				boolean | void
			>;
		}
	): null | Source;

	/**
	 * Renders the rendered source.
	 */
	renderChunk(
		renderContext: RenderContextJavascriptModulesPlugin,
		hooks: {
			renderModuleContent: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModuleContainer: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModulePackage: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			render: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.41.0
			 */
			renderContent: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.22.0
			 */
			renderStartup: SyncWaterfallHook<
				[Source, Module, StartupRenderContext],
				Source
			>;
			renderChunk: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderMain: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderRequire: SyncWaterfallHook<
				[string, RenderBootstrapContext],
				string
			>;
			/**
			 * @since 5.22.0
			 */
			inlineInRuntimeBailout: SyncBailHook<
				[Module, Partial<RenderBootstrapContext>],
				string | void
			>;
			/**
			 * @since 5.22.0
			 */
			embedInRuntimeBailout: SyncBailHook<
				[Module, RenderContextJavascriptModulesPlugin],
				string | void
			>;
			/**
			 * @since 5.26.1
			 */
			strictRuntimeBailout: SyncBailHook<
				[RenderContextJavascriptModulesPlugin],
				string | void
			>;
			chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
			/**
			 * @since 5.2.1
			 */
			useSourceMap: SyncBailHook<
				[Chunk, RenderContextJavascriptModulesPlugin],
				boolean | void
			>;
		}
	): Source;

	/**
	 * Renders the newly generated source from rendering.
	 */
	renderMain(
		renderContext: MainRenderContext,
		hooks: {
			renderModuleContent: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModuleContainer: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModulePackage: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			render: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.41.0
			 */
			renderContent: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.22.0
			 */
			renderStartup: SyncWaterfallHook<
				[Source, Module, StartupRenderContext],
				Source
			>;
			renderChunk: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderMain: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderRequire: SyncWaterfallHook<
				[string, RenderBootstrapContext],
				string
			>;
			/**
			 * @since 5.22.0
			 */
			inlineInRuntimeBailout: SyncBailHook<
				[Module, Partial<RenderBootstrapContext>],
				string | void
			>;
			/**
			 * @since 5.22.0
			 */
			embedInRuntimeBailout: SyncBailHook<
				[Module, RenderContextJavascriptModulesPlugin],
				string | void
			>;
			/**
			 * @since 5.26.1
			 */
			strictRuntimeBailout: SyncBailHook<
				[RenderContextJavascriptModulesPlugin],
				string | void
			>;
			chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
			/**
			 * @since 5.2.1
			 */
			useSourceMap: SyncBailHook<
				[Chunk, RenderContextJavascriptModulesPlugin],
				boolean | void
			>;
		},
		compilation: Compilation
	): Source;

	/**
	 * Updates hash with bootstrap.
	 */
	updateHashWithBootstrap(
		hash: Hash,
		renderContext: RenderBootstrapContext,
		hooks: {
			renderModuleContent: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModuleContainer: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModulePackage: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			render: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.41.0
			 */
			renderContent: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.22.0
			 */
			renderStartup: SyncWaterfallHook<
				[Source, Module, StartupRenderContext],
				Source
			>;
			renderChunk: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderMain: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderRequire: SyncWaterfallHook<
				[string, RenderBootstrapContext],
				string
			>;
			/**
			 * @since 5.22.0
			 */
			inlineInRuntimeBailout: SyncBailHook<
				[Module, Partial<RenderBootstrapContext>],
				string | void
			>;
			/**
			 * @since 5.22.0
			 */
			embedInRuntimeBailout: SyncBailHook<
				[Module, RenderContextJavascriptModulesPlugin],
				string | void
			>;
			/**
			 * @since 5.26.1
			 */
			strictRuntimeBailout: SyncBailHook<
				[RenderContextJavascriptModulesPlugin],
				string | void
			>;
			chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
			/**
			 * @since 5.2.1
			 */
			useSourceMap: SyncBailHook<
				[Chunk, RenderContextJavascriptModulesPlugin],
				boolean | void
			>;
		}
	): void;

	/**
	 * Renders the generated source of the bootstrap code.
	 */
	renderBootstrap(
		renderContext: RenderBootstrapContext,
		hooks: {
			renderModuleContent: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModuleContainer: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModulePackage: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			render: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.41.0
			 */
			renderContent: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.22.0
			 */
			renderStartup: SyncWaterfallHook<
				[Source, Module, StartupRenderContext],
				Source
			>;
			renderChunk: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderMain: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderRequire: SyncWaterfallHook<
				[string, RenderBootstrapContext],
				string
			>;
			/**
			 * @since 5.22.0
			 */
			inlineInRuntimeBailout: SyncBailHook<
				[Module, Partial<RenderBootstrapContext>],
				string | void
			>;
			/**
			 * @since 5.22.0
			 */
			embedInRuntimeBailout: SyncBailHook<
				[Module, RenderContextJavascriptModulesPlugin],
				string | void
			>;
			/**
			 * @since 5.26.1
			 */
			strictRuntimeBailout: SyncBailHook<
				[RenderContextJavascriptModulesPlugin],
				string | void
			>;
			chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
			/**
			 * @since 5.2.1
			 */
			useSourceMap: SyncBailHook<
				[Chunk, RenderContextJavascriptModulesPlugin],
				boolean | void
			>;
		}
	): Bootstrap;

	/**
	 * Renders the generated source of the require function.
	 */
	renderRequire(
		renderContext: RenderBootstrapContext,
		hooks: {
			renderModuleContent: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModuleContainer: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			renderModulePackage: SyncWaterfallHook<
				[Source, Module, ModuleRenderContext],
				Source
			>;
			render: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.41.0
			 */
			renderContent: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			/**
			 * @since 5.22.0
			 */
			renderStartup: SyncWaterfallHook<
				[Source, Module, StartupRenderContext],
				Source
			>;
			renderChunk: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderMain: SyncWaterfallHook<
				[Source, RenderContextJavascriptModulesPlugin],
				Source
			>;
			renderRequire: SyncWaterfallHook<
				[string, RenderBootstrapContext],
				string
			>;
			/**
			 * @since 5.22.0
			 */
			inlineInRuntimeBailout: SyncBailHook<
				[Module, Partial<RenderBootstrapContext>],
				string | void
			>;
			/**
			 * @since 5.22.0
			 */
			embedInRuntimeBailout: SyncBailHook<
				[Module, RenderContextJavascriptModulesPlugin],
				string | void
			>;
			/**
			 * @since 5.26.1
			 */
			strictRuntimeBailout: SyncBailHook<
				[RenderContextJavascriptModulesPlugin],
				string | void
			>;
			chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
			/**
			 * @since 5.2.1
			 */
			useSourceMap: SyncBailHook<
				[Chunk, RenderContextJavascriptModulesPlugin],
				boolean | void
			>;
		}
	): string;

	/**
	 * Gets chunk filename template.
	 */
	static getChunkFilenameTemplate(
		chunk: Chunk,
		outputOptions: OutputNormalizedWithDefaults
	): ChunkFilenameTemplate;
	static getCompilationHooks: (compilation: Compilation) => {
		renderModuleContent: SyncWaterfallHook<
			[Source, Module, ModuleRenderContext],
			Source
		>;
		renderModuleContainer: SyncWaterfallHook<
			[Source, Module, ModuleRenderContext],
			Source
		>;
		renderModulePackage: SyncWaterfallHook<
			[Source, Module, ModuleRenderContext],
			Source
		>;
		render: SyncWaterfallHook<
			[Source, RenderContextJavascriptModulesPlugin],
			Source
		>;
		/**
		 * @since 5.41.0
		 */
		renderContent: SyncWaterfallHook<
			[Source, RenderContextJavascriptModulesPlugin],
			Source
		>;
		/**
		 * @since 5.22.0
		 */
		renderStartup: SyncWaterfallHook<
			[Source, Module, StartupRenderContext],
			Source
		>;
		renderChunk: SyncWaterfallHook<
			[Source, RenderContextJavascriptModulesPlugin],
			Source
		>;
		renderMain: SyncWaterfallHook<
			[Source, RenderContextJavascriptModulesPlugin],
			Source
		>;
		renderRequire: SyncWaterfallHook<[string, RenderBootstrapContext], string>;
		/**
		 * @since 5.22.0
		 */
		inlineInRuntimeBailout: SyncBailHook<
			[Module, Partial<RenderBootstrapContext>],
			string | void
		>;
		/**
		 * @since 5.22.0
		 */
		embedInRuntimeBailout: SyncBailHook<
			[Module, RenderContextJavascriptModulesPlugin],
			string | void
		>;
		/**
		 * @since 5.26.1
		 */
		strictRuntimeBailout: SyncBailHook<
			[RenderContextJavascriptModulesPlugin],
			string | void
		>;
		chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>;
		/**
		 * @since 5.2.1
		 */
		useSourceMap: SyncBailHook<
			[Chunk, RenderContextJavascriptModulesPlugin],
			boolean | void
		>;
	};
	static chunkHasJs: (chunk: Chunk, chunkGraph: ChunkGraph) => boolean;
}
type JavascriptNormalModule = NormalModule & {
	buildInfo?: JavascriptModuleBuildInfo;
	buildMeta?: JavascriptModuleBuildMeta;
};
declare class JavascriptParser extends Parser<BuiltJavascriptModule> {
	/**
	 * Creates an instance of JavascriptParser.
	 */
	constructor(
		sourceType?: "module" | "auto" | "script",
		options?: {
			parse?: (
				code: string,
				options: ParseOptionsJavascriptParser
			) => ParseResult;
			typescript?: boolean;
			importPhases?: boolean;
			strictModeViolations?: false | "error" | "warn";
		}
	);
	hooks: Readonly<{
		evaluateTypeof: HookMap<
			SyncBailHook<
				[UnaryExpression],
				undefined | null | BasicEvaluatedExpression
			>
		>;
		evaluate: HookMap<
			SyncBailHook<
				[
					| ImportExpressionImport
					| UnaryExpression
					| ArrayExpression
					| ArrowFunctionExpression
					| AssignmentExpression
					| AwaitExpression
					| BinaryExpression
					| SimpleCallExpression
					| NewExpression
					| ChainExpression
					| ClassExpression
					| ConditionalExpression
					| FunctionExpression
					| Identifier
					| SimpleLiteral
					| RegExpLiteral
					| BigIntLiteral
					| LogicalExpression
					| MemberExpression
					| MetaProperty
					| ObjectExpression
					| SequenceExpression
					| TaggedTemplateExpression
					| TemplateLiteral
					| ThisExpression
					| UpdateExpression
					| YieldExpression
					| SpreadElement
					| PrivateIdentifier
					| Super
				],
				undefined | null | BasicEvaluatedExpression
			>
		>;
		evaluateIdentifier: HookMap<
			SyncBailHook<
				[Identifier | MemberExpression | MetaProperty | ThisExpression],
				undefined | null | BasicEvaluatedExpression
			>
		>;
		evaluateDefinedIdentifier: HookMap<
			SyncBailHook<
				[Identifier | MemberExpression | ThisExpression],
				undefined | null | BasicEvaluatedExpression
			>
		>;
		/**
		 * @since 5.73.0
		 */
		evaluateNewExpression: HookMap<
			SyncBailHook<[NewExpression], undefined | null | BasicEvaluatedExpression>
		>;
		/**
		 * @since 5.73.0
		 */
		evaluateCallExpression: HookMap<
			SyncBailHook<
				[CallExpression],
				undefined | null | BasicEvaluatedExpression
			>
		>;
		evaluateCallExpressionMember: HookMap<
			SyncBailHook<
				[CallExpression, BasicEvaluatedExpression],
				undefined | null | BasicEvaluatedExpression
			>
		>;
		isPure: HookMap<
			SyncBailHook<
				[
					(
						| ImportExpressionImport
						| UnaryExpression
						| ArrayExpression
						| ArrowFunctionExpression
						| AssignmentExpression
						| AwaitExpression
						| BinaryExpression
						| SimpleCallExpression
						| NewExpression
						| ChainExpression
						| ClassExpression
						| ConditionalExpression
						| FunctionExpression
						| Identifier
						| SimpleLiteral
						| RegExpLiteral
						| BigIntLiteral
						| LogicalExpression
						| MemberExpression
						| MetaProperty
						| ObjectExpression
						| SequenceExpression
						| TaggedTemplateExpression
						| TemplateLiteral
						| ThisExpression
						| UpdateExpression
						| YieldExpression
						| PrivateIdentifier
						| FunctionDeclaration
						| MaybeNamedFunctionDeclaration
						| VariableDeclaration
						| ClassDeclaration
						| MaybeNamedClassDeclaration
					),
					number
				],
				boolean | void
			>
		>;
		/**
		 * Every statement the hoisting pass reads, which a tap on this turns
		 * back into a walk of them all. Tap `preStatementByType` instead.
		 * @deprecated TODO in the next major release: remove, with the statement walk it turns on
		 */
		preStatement: SyncBailHook<
			[
				| ImportDeclaration
				| ExportNamedDeclaration
				| ExportAllDeclaration
				| FunctionDeclaration
				| MaybeNamedFunctionDeclaration
				| VariableDeclaration
				| ClassDeclaration
				| MaybeNamedClassDeclaration
				| ExpressionStatement
				| BlockStatement
				| StaticBlock
				| EmptyStatement
				| DebuggerStatement
				| WithStatement
				| ReturnStatement
				| LabeledStatement
				| BreakStatement
				| ContinueStatement
				| IfStatement
				| SwitchStatement
				| ThrowStatement
				| TryStatement
				| WhileStatement
				| DoWhileStatement
				| ForStatement
				| ForInStatement
				| ForOfStatement
				| ExportDefaultDeclaration
			],
			boolean | void
		>;
		/**
		 * Each declaration the parser records: a variable, function or class
		 * one. Any other type turns the pass back into a walk of every
		 * statement, and goes away with that walk in the next major release.
		 * @since 5.109.0
		 */
		preStatementByType: HookMap<
			SyncBailHook<
				[
					| ImportDeclaration
					| ExportNamedDeclaration
					| ExportAllDeclaration
					| FunctionDeclaration
					| MaybeNamedFunctionDeclaration
					| VariableDeclaration
					| ClassDeclaration
					| MaybeNamedClassDeclaration
					| ExpressionStatement
					| BlockStatement
					| StaticBlock
					| EmptyStatement
					| DebuggerStatement
					| WithStatement
					| ReturnStatement
					| LabeledStatement
					| BreakStatement
					| ContinueStatement
					| IfStatement
					| SwitchStatement
					| ThrowStatement
					| TryStatement
					| WhileStatement
					| DoWhileStatement
					| ForStatement
					| ForInStatement
					| ForOfStatement
					| ExportDefaultDeclaration
				],
				boolean | void
			>
		>;
		/**
		 * Every statement the block pass reads, which a tap on this turns back
		 * into a walk of them all. Tap `blockPreStatementByType` instead.
		 * @deprecated TODO in the next major release: remove, with the statement walk it turns on
		 */
		blockPreStatement: SyncBailHook<
			[
				| ImportDeclaration
				| ExportNamedDeclaration
				| ExportAllDeclaration
				| FunctionDeclaration
				| MaybeNamedFunctionDeclaration
				| VariableDeclaration
				| ClassDeclaration
				| MaybeNamedClassDeclaration
				| ExpressionStatement
				| BlockStatement
				| StaticBlock
				| EmptyStatement
				| DebuggerStatement
				| WithStatement
				| ReturnStatement
				| LabeledStatement
				| BreakStatement
				| ContinueStatement
				| IfStatement
				| SwitchStatement
				| ThrowStatement
				| TryStatement
				| WhileStatement
				| DoWhileStatement
				| ForStatement
				| ForInStatement
				| ForOfStatement
				| ExportDefaultDeclaration
			],
			boolean | void
		>;
		/**
		 * Each statement the parser records for the block pass: a variable, class
		 * or export declaration. Any other type turns the pass back into a walk
		 * of every statement, and goes away with that walk in the next major release.
		 * @since 5.109.0
		 */
		blockPreStatementByType: HookMap<
			SyncBailHook<
				[
					| ImportDeclaration
					| ExportNamedDeclaration
					| ExportAllDeclaration
					| FunctionDeclaration
					| MaybeNamedFunctionDeclaration
					| VariableDeclaration
					| ClassDeclaration
					| MaybeNamedClassDeclaration
					| ExpressionStatement
					| BlockStatement
					| StaticBlock
					| EmptyStatement
					| DebuggerStatement
					| WithStatement
					| ReturnStatement
					| LabeledStatement
					| BreakStatement
					| ContinueStatement
					| IfStatement
					| SwitchStatement
					| ThrowStatement
					| TryStatement
					| WhileStatement
					| DoWhileStatement
					| ForStatement
					| ForInStatement
					| ForOfStatement
					| ExportDefaultDeclaration
				],
				boolean | void
			>
		>;
		statement: SyncBailHook<
			[
				| ImportDeclaration
				| ExportNamedDeclaration
				| ExportAllDeclaration
				| FunctionDeclaration
				| MaybeNamedFunctionDeclaration
				| VariableDeclaration
				| ClassDeclaration
				| MaybeNamedClassDeclaration
				| ExpressionStatement
				| BlockStatement
				| StaticBlock
				| EmptyStatement
				| DebuggerStatement
				| WithStatement
				| ReturnStatement
				| LabeledStatement
				| BreakStatement
				| ContinueStatement
				| IfStatement
				| SwitchStatement
				| ThrowStatement
				| TryStatement
				| WhileStatement
				| DoWhileStatement
				| ForStatement
				| ForInStatement
				| ForOfStatement
				| ExportDefaultDeclaration
			],
			boolean | void
		>;
		statementIf: SyncBailHook<[IfStatement], boolean | void>;
		/**
		 * @since 5.105.0
		 */
		collectGuards: SyncBailHook<[Expression], void | GuardCollection>;
		classExtendsExpression: SyncBailHook<
			[
				Expression,
				ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration
			],
			boolean | void
		>;
		classBodyElement: SyncBailHook<
			[
				StaticBlock | MethodDefinition | PropertyDefinition,
				ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration
			],
			boolean | void
		>;
		/**
		 * @since 5.36.0
		 */
		classBodyValue: SyncBailHook<
			[
				Expression,
				MethodDefinition | PropertyDefinition,
				ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration
			],
			boolean | void
		>;
		label: HookMap<SyncBailHook<[LabeledStatement], boolean | void>>;
		import: SyncBailHook<[ImportDeclaration, ImportSource], boolean | void>;
		importSpecifier: SyncBailHook<
			[ImportDeclaration, ImportSource, null | string, string],
			boolean | void
		>;
		export: SyncBailHook<
			[ExportNamedDeclaration | ExportDefaultDeclaration],
			boolean | void
		>;
		exportImport: SyncBailHook<
			[ExportNamedDeclaration | ExportAllDeclaration, ImportSource],
			boolean | void
		>;
		exportDeclaration: SyncBailHook<
			[
				(
					| ExportNamedDeclaration
					| ExportAllDeclaration
					| ExportDefaultDeclaration
				),
				DeclarationEstreeIndex
			],
			boolean | void
		>;
		exportExpression: SyncBailHook<
			[
				ExportDefaultDeclaration,
				(
					| ImportExpressionImport
					| UnaryExpression
					| ArrayExpression
					| ArrowFunctionExpression
					| AssignmentExpression
					| AwaitExpression
					| BinaryExpression
					| SimpleCallExpression
					| NewExpression
					| ChainExpression
					| ClassExpression
					| ConditionalExpression
					| FunctionExpression
					| Identifier
					| SimpleLiteral
					| RegExpLiteral
					| BigIntLiteral
					| LogicalExpression
					| MemberExpression
					| MetaProperty
					| ObjectExpression
					| SequenceExpression
					| TaggedTemplateExpression
					| TemplateLiteral
					| ThisExpression
					| UpdateExpression
					| YieldExpression
					| MaybeNamedFunctionDeclaration
					| MaybeNamedClassDeclaration
				)
			],
			boolean | void
		>;
		exportSpecifier: SyncBailHook<
			[
				(
					| ExportNamedDeclaration
					| ExportAllDeclaration
					| ExportDefaultDeclaration
				),
				string,
				string,
				undefined | number
			],
			boolean | void
		>;
		exportImportSpecifier: SyncBailHook<
			[
				ExportNamedDeclaration | ExportAllDeclaration,
				ImportSource,
				null | string,
				null | string,
				undefined | number
			],
			boolean | void
		>;
		preDeclarator: SyncBailHook<
			[VariableDeclarator, VariableDeclaration],
			boolean | void
		>;
		declarator: SyncBailHook<[VariableDeclarator, Statement], boolean | void>;
		varDeclaration: HookMap<SyncBailHook<[Identifier], boolean | void>>;
		varDeclarationLet: HookMap<SyncBailHook<[Identifier], boolean | void>>;
		varDeclarationConst: HookMap<SyncBailHook<[Identifier], boolean | void>>;
		/**
		 * @since 5.100.0
		 */
		varDeclarationUsing: HookMap<SyncBailHook<[Identifier], boolean | void>>;
		varDeclarationVar: HookMap<SyncBailHook<[Identifier], boolean | void>>;
		pattern: HookMap<SyncBailHook<[Identifier], boolean | void>>;
		/**
		 * @since 5.101.3
		 */
		collectDestructuringAssignmentProperties: SyncBailHook<
			[Expression],
			boolean | void
		>;
		canRename: HookMap<SyncBailHook<[Expression], boolean | void>>;
		rename: HookMap<SyncBailHook<[Expression], boolean | void>>;
		assign: HookMap<SyncBailHook<[AssignmentExpression], boolean | void>>;
		write: HookMap<SyncBailHook<[WriteStatement], boolean | void>>;
		writeMemberChain: HookMap<
			SyncBailHook<[WriteStatement, string[]], boolean | void>
		>;
		assignMemberChain: HookMap<
			SyncBailHook<[AssignmentExpression, string[]], boolean | void>
		>;
		typeof: HookMap<SyncBailHook<[Expression], boolean | void>>;
		importCall: SyncBailHook<
			[
				ImportExpressionJavascriptParser,
				undefined | SimpleCallExpression | NewExpression
			],
			boolean | void
		>;
		topLevelAwait: SyncBailHook<
			[
				| ImportExpressionImport
				| UnaryExpression
				| ArrayExpression
				| ArrowFunctionExpression
				| AssignmentExpression
				| AwaitExpression
				| BinaryExpression
				| SimpleCallExpression
				| NewExpression
				| ChainExpression
				| ClassExpression
				| ConditionalExpression
				| FunctionExpression
				| Identifier
				| SimpleLiteral
				| RegExpLiteral
				| BigIntLiteral
				| LogicalExpression
				| MemberExpression
				| MetaProperty
				| ObjectExpression
				| SequenceExpression
				| TaggedTemplateExpression
				| TemplateLiteral
				| ThisExpression
				| UpdateExpression
				| YieldExpression
				| VariableDeclaration
				| ForOfStatement
			],
			boolean | void
		>;
		call: HookMap<SyncBailHook<[CallExpression], boolean | void>>;
		callMemberChain: HookMap<
			SyncBailHook<
				[CallExpression, string[], boolean[], [number, number][]],
				boolean | void
			>
		>;
		memberChainOfCallMemberChain: HookMap<
			SyncBailHook<
				[Expression, string[], CallExpression, string[], [number, number][]],
				boolean | void
			>
		>;
		callMemberChainOfCallMemberChain: HookMap<
			SyncBailHook<
				[
					CallExpression,
					string[],
					CallExpression,
					string[],
					[number, number][]
				],
				boolean | void
			>
		>;
		optionalChaining: SyncBailHook<[ChainExpression], boolean | void>;
		new: HookMap<SyncBailHook<[NewExpression], boolean | void>>;
		/**
		 * @since 5.71.0
		 */
		binaryExpression: SyncBailHook<[BinaryExpression], boolean | void>;
		expression: HookMap<SyncBailHook<[Expression], boolean | void>>;
		expressionMemberChain: HookMap<
			SyncBailHook<
				[MemberExpression, string[], boolean[], [number, number][]],
				boolean | void
			>
		>;
		unhandledExpressionMemberChain: HookMap<
			SyncBailHook<[MemberExpression, string[]], boolean | void>
		>;
		expressionConditionalOperator: SyncBailHook<
			[ConditionalExpression],
			boolean | void
		>;
		expressionLogicalOperator: SyncBailHook<
			[LogicalExpression],
			boolean | void
		>;
		program: SyncBailHook<[Program, CommentJavascriptParser[]], boolean | void>;
		/**
		 * @since 5.99.0
		 */
		terminate: SyncBailHook<[ReturnStatement | ThrowStatement], boolean | void>;
		finish: SyncBailHook<[Program, CommentJavascriptParser[]], boolean | void>;
		/**
		 * @since 5.99.9
		 */
		unusedStatement: SyncBailHook<[Statement], boolean | void>;
	}>;
	sourceType: "module" | "auto" | "script";
	options: {
		parse?: (
			code: string,
			options: ParseOptionsJavascriptParser
		) => ParseResult;
		typescript?: boolean;
		importPhases?: boolean;
		strictModeViolations?: false | "error" | "warn";
	};
	scope: ScopeInfo;
	state: JavascriptParserState;
	comments?: CommentJavascriptParser[];
	semicolons?: Map<number, boolean>;
	statementPath?: StatementPathItem[];
	prevStatement?:
		| ImportDeclaration
		| ExportNamedDeclaration
		| ExportAllDeclaration
		| ImportExpressionImport
		| UnaryExpression
		| ArrayExpression
		| ArrowFunctionExpression
		| AssignmentExpression
		| AwaitExpression
		| BinaryExpression
		| SimpleCallExpression
		| NewExpression
		| ChainExpression
		| ClassExpression
		| ConditionalExpression
		| FunctionExpression
		| Identifier
		| SimpleLiteral
		| RegExpLiteral
		| BigIntLiteral
		| LogicalExpression
		| MemberExpression
		| MetaProperty
		| ObjectExpression
		| SequenceExpression
		| TaggedTemplateExpression
		| TemplateLiteral
		| ThisExpression
		| UpdateExpression
		| YieldExpression
		| FunctionDeclaration
		| MaybeNamedFunctionDeclaration
		| VariableDeclaration
		| ClassDeclaration
		| MaybeNamedClassDeclaration
		| ExpressionStatement
		| BlockStatement
		| StaticBlock
		| EmptyStatement
		| DebuggerStatement
		| WithStatement
		| ReturnStatement
		| LabeledStatement
		| BreakStatement
		| ContinueStatement
		| IfStatement
		| SwitchStatement
		| ThrowStatement
		| TryStatement
		| WhileStatement
		| DoWhileStatement
		| ForStatement
		| ForInStatement
		| ForOfStatement
		| ExportDefaultDeclaration;
	destructuringAssignmentProperties?: WeakMap<
		Expression,
		Set<DestructuringAssignmentProperty>
	>;
	currentTagData?:
		| object
		| TopLevelSymbol
		| ESMSettings
		| ImportSettings
		| CommonJsImportSettings
		| CompatibilitySettings;
	magicCommentContext: ContextImport;

	/**
	 * Destructuring assignment properties for.
	 */
	destructuringAssignmentPropertiesFor(
		node: Expression
	): undefined | Set<DestructuringAssignmentProperty>;

	/**
	 * Gets rename identifier.
	 */
	getRenameIdentifier(
		expr:
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| SpreadElement
	): undefined | string | VariableInfo;

	/**
	 * Processes the provided classy.
	 */
	walkClass(
		classy: ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration
	): void;

	/**
	 * Walk every statement of a scope to declare what hoists to it. Only a tap
	 * on the deprecated `preStatement` hook asks for this.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkStatements(
		statements: (
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| FunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| ExpressionStatement
			| BlockStatement
			| StaticBlock
			| EmptyStatement
			| DebuggerStatement
			| WithStatement
			| ReturnStatement
			| LabeledStatement
			| BreakStatement
			| ContinueStatement
			| IfStatement
			| SwitchStatement
			| ThrowStatement
			| TryStatement
			| WhileStatement
			| DoWhileStatement
			| ForStatement
			| ForInStatement
			| ForOfStatement
			| ExportDefaultDeclaration
		)[]
	): void;

	/**
	 * Pre walk block statement.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkBlockStatement(statement: BlockStatement): void;

	/**
	 * Pre walk if statement.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkIfStatement(statement: IfStatement): void;

	/**
	 * Pre walk labeled statement.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkLabeledStatement(statement: LabeledStatement): void;

	/**
	 * Pre walk with statement.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkWithStatement(statement: WithStatement): void;

	/**
	 * Pre walk switch statement.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkSwitchStatement(statement: SwitchStatement): void;

	/**
	 * Pre walk switch cases.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkSwitchCases(switchCases: SwitchCase[]): void;

	/**
	 * Pre walk try statement.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkTryStatement(statement: TryStatement): void;

	/**
	 * Pre walk catch clause.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkCatchClause(catchClause: CatchClause): void;

	/**
	 * Pre walk while statement.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkWhileStatement(statement: WhileStatement): void;

	/**
	 * Pre walk do while statement.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkDoWhileStatement(statement: DoWhileStatement): void;

	/**
	 * Pre walk for statement.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkForStatement(statement: ForStatement): void;

	/**
	 * Pre walk for in statement.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkForInStatement(statement: ForInStatement): void;

	/**
	 * Pre walk for of statement. `for await` is reported by the walk, not here.
	 * @deprecated TODO in the next major release: remove, with the `preStatement` hook
	 */
	preWalkForOfStatement(statement: ForOfStatement): void;

	/**
	 * Scan every top-level statement for the program's module declarations.
	 * The parser records them now, so nothing inside webpack scans for them.
	 * @deprecated TODO in the next major release: remove
	 */
	modulePreWalkStatements(
		statements: (
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| FunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| ExpressionStatement
			| BlockStatement
			| StaticBlock
			| EmptyStatement
			| DebuggerStatement
			| WithStatement
			| ReturnStatement
			| LabeledStatement
			| BreakStatement
			| ContinueStatement
			| IfStatement
			| SwitchStatement
			| ThrowStatement
			| TryStatement
			| WhileStatement
			| DoWhileStatement
			| ForStatement
			| ForInStatement
			| ForOfStatement
			| ExportDefaultDeclaration
		)[]
	): void;

	/**
	 * Walk every statement of a list to declare what it binds. Only a tap on the
	 * deprecated `blockPreStatement` hook asks for this.
	 * @deprecated TODO in the next major release: remove, with the `blockPreStatement` hook
	 */
	blockPreWalkStatements(
		statements: (
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| FunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| ExpressionStatement
			| BlockStatement
			| StaticBlock
			| EmptyStatement
			| DebuggerStatement
			| WithStatement
			| ReturnStatement
			| LabeledStatement
			| BreakStatement
			| ContinueStatement
			| IfStatement
			| SwitchStatement
			| ThrowStatement
			| TryStatement
			| WhileStatement
			| DoWhileStatement
			| ForStatement
			| ForInStatement
			| ForOfStatement
			| ExportDefaultDeclaration
		)[]
	): void;

	/**
	 * Walking iterates the statements and expressions and processes them
	 */
	walkStatements(
		statements: (
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| FunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| ExpressionStatement
			| BlockStatement
			| StaticBlock
			| EmptyStatement
			| DebuggerStatement
			| WithStatement
			| ReturnStatement
			| LabeledStatement
			| BreakStatement
			| ContinueStatement
			| IfStatement
			| SwitchStatement
			| ThrowStatement
			| TryStatement
			| WhileStatement
			| DoWhileStatement
			| ForStatement
			| ForInStatement
			| ForOfStatement
			| ExportDefaultDeclaration
		)[]
	): void;

	/**
	 * Walking iterates the statements and expressions and processes them
	 */
	preWalkStatement(
		statement:
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| FunctionDeclaration
			| MaybeNamedFunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| MaybeNamedClassDeclaration
			| ExpressionStatement
			| BlockStatement
			| StaticBlock
			| EmptyStatement
			| DebuggerStatement
			| WithStatement
			| ReturnStatement
			| LabeledStatement
			| BreakStatement
			| ContinueStatement
			| IfStatement
			| SwitchStatement
			| ThrowStatement
			| TryStatement
			| WhileStatement
			| DoWhileStatement
			| ForStatement
			| ForInStatement
			| ForOfStatement
			| ExportDefaultDeclaration
	): void;

	/**
	 * Block pre walk statement.
	 */
	blockPreWalkStatement(
		statement:
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| FunctionDeclaration
			| MaybeNamedFunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| MaybeNamedClassDeclaration
			| ExpressionStatement
			| BlockStatement
			| StaticBlock
			| EmptyStatement
			| DebuggerStatement
			| WithStatement
			| ReturnStatement
			| LabeledStatement
			| BreakStatement
			| ContinueStatement
			| IfStatement
			| SwitchStatement
			| ThrowStatement
			| TryStatement
			| WhileStatement
			| DoWhileStatement
			| ForStatement
			| ForInStatement
			| ForOfStatement
			| ExportDefaultDeclaration
	): void;

	/**
	 * Processes the provided statement.
	 */
	walkStatement(
		statement:
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| FunctionDeclaration
			| MaybeNamedFunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| MaybeNamedClassDeclaration
			| ExpressionStatement
			| BlockStatement
			| StaticBlock
			| EmptyStatement
			| DebuggerStatement
			| WithStatement
			| ReturnStatement
			| LabeledStatement
			| BreakStatement
			| ContinueStatement
			| IfStatement
			| SwitchStatement
			| ThrowStatement
			| TryStatement
			| WhileStatement
			| DoWhileStatement
			| ForStatement
			| ForInStatement
			| ForOfStatement
			| ExportDefaultDeclaration
	): void;

	/**
	 * Walks a statements that is nested within a parent statement
	 * and can potentially be a non-block statement.
	 * This enforces the nested statement to never be in ASI position.
	 */
	walkNestedStatement(statement: Statement): void;

	/**
	 * Walk block statement.
	 */
	walkBlockStatement(statement: BlockStatement | StaticBlock): void;

	/**
	 * Walk expression statement.
	 */
	walkExpressionStatement(statement: ExpressionStatement): void;

	/**
	 * Walks a conditional branch with its guard frame (if any) pushed onto the
	 * parser-state guard stack for the duration of the branch body.
	 */
	walkGuardedBranch(
		frame: undefined | null | GuardFrame,
		walk: () => void
	): void;

	/**
	 * Processes the provided statement.
	 */
	walkIfStatement(statement: IfStatement): void;

	/**
	 * Walk labeled statement.
	 */
	walkLabeledStatement(statement: LabeledStatement): void;

	/**
	 * Walk with statement.
	 */
	walkWithStatement(statement: WithStatement): void;

	/**
	 * Walk switch statement.
	 */
	walkSwitchStatement(statement: SwitchStatement): void;

	/**
	 * Walk terminating statement.
	 */
	walkTerminatingStatement(statement: ReturnStatement | ThrowStatement): void;

	/**
	 * Walk return statement.
	 */
	walkReturnStatement(statement: ReturnStatement): void;

	/**
	 * Walk throw statement.
	 */
	walkThrowStatement(statement: ThrowStatement): void;

	/**
	 * Walk try statement.
	 */
	walkTryStatement(statement: TryStatement): void;

	/**
	 * Walk while statement.
	 */
	walkWhileStatement(statement: WhileStatement): void;

	/**
	 * Walk do while statement.
	 */
	walkDoWhileStatement(statement: DoWhileStatement): void;

	/**
	 * Walk for statement.
	 */
	walkForStatement(statement: ForStatement): void;

	/**
	 * Walk for in statement.
	 */
	walkForInStatement(statement: ForInStatement): void;

	/**
	 * Walk for of statement.
	 */
	walkForOfStatement(statement: ForOfStatement): void;

	/**
	 * Pre walk function declaration.
	 */
	preWalkFunctionDeclaration(
		statement: FunctionDeclaration | MaybeNamedFunctionDeclaration
	): void;

	/**
	 * Bind a function declaration in the block holding it, when it does not
	 * hoist to the enclosing scope.
	 */
	blockPreWalkFunctionDeclaration(
		statement: FunctionDeclaration | MaybeNamedFunctionDeclaration
	): void;

	/**
	 * Walk function declaration.
	 */
	walkFunctionDeclaration(
		statement: FunctionDeclaration | MaybeNamedFunctionDeclaration
	): void;

	/**
	 * Block pre walk expression statement.
	 */
	blockPreWalkExpressionStatement(statement: ExpressionStatement): void;

	/**
	 * Pre walk assignment expression.
	 */
	preWalkAssignmentExpression(expression: AssignmentExpression): void;

	/**
	 * Enter destructuring assignment.
	 */
	enterDestructuringAssignment(
		pattern: Pattern,
		expression: Expression
	):
		| undefined
		| ImportExpressionImport
		| UnaryExpression
		| ArrayExpression
		| ArrowFunctionExpression
		| AssignmentExpression
		| AwaitExpression
		| BinaryExpression
		| SimpleCallExpression
		| NewExpression
		| ChainExpression
		| ClassExpression
		| ConditionalExpression
		| FunctionExpression
		| Identifier
		| SimpleLiteral
		| RegExpLiteral
		| BigIntLiteral
		| LogicalExpression
		| MemberExpression
		| MetaProperty
		| ObjectExpression
		| SequenceExpression
		| TaggedTemplateExpression
		| TemplateLiteral
		| ThisExpression
		| UpdateExpression
		| YieldExpression;

	/**
	 * Module pre walk import declaration.
	 */
	modulePreWalkImportDeclaration(statement: ImportDeclaration): void;

	/**
	 * Processes the provided declaration.
	 */
	enterDeclaration(
		declaration: DeclarationEstreeIndex,
		onIdent: (ident: string, identifier: Identifier) => void
	): void;

	/**
	 * Module pre walk export named declaration.
	 */
	modulePreWalkExportNamedDeclaration(statement: ExportNamedDeclaration): void;

	/**
	 * Block pre walk export named declaration.
	 */
	blockPreWalkExportNamedDeclaration(statement: ExportNamedDeclaration): void;

	/**
	 * Walk export named declaration.
	 */
	walkExportNamedDeclaration(statement: ExportNamedDeclaration): void;

	/**
	 * Block pre walk export default declaration.
	 */
	blockPreWalkExportDefaultDeclaration(
		statement: ExportDefaultDeclaration
	): void;

	/**
	 * Walk export default declaration.
	 */
	walkExportDefaultDeclaration(statement: ExportDefaultDeclaration): void;

	/**
	 * Module pre walk export all declaration.
	 */
	modulePreWalkExportAllDeclaration(statement: ExportAllDeclaration): void;

	/**
	 * Pre walk variable declaration.
	 */
	preWalkVariableDeclaration(statement: VariableDeclaration): void;

	/**
	 * Block pre walk variable declaration.
	 */
	blockPreWalkVariableDeclaration(statement: VariableDeclaration): void;

	/**
	 * Pre walk variable declarator.
	 */
	preWalkVariableDeclarator(declarator: VariableDeclarator): void;

	/**
	 * Walk variable declaration.
	 */
	walkVariableDeclaration(statement: VariableDeclaration): void;

	/**
	 * Block pre walk class declaration.
	 */
	blockPreWalkClassDeclaration(
		statement: ClassDeclaration | MaybeNamedClassDeclaration
	): void;

	/**
	 * Walk class declaration.
	 */
	walkClassDeclaration(
		statement: ClassDeclaration | MaybeNamedClassDeclaration
	): void;

	/**
	 * Processes the provided switch case.
	 */
	walkSwitchCases(switchCases: SwitchCase[]): void;

	/**
	 * Processes the provided catch clause.
	 */
	walkCatchClause(catchClause: CatchClause): void;

	/**
	 * Processes the provided pattern.
	 */
	walkPattern(pattern: Pattern): void;

	/**
	 * Walk assignment pattern.
	 */
	walkAssignmentPattern(pattern: AssignmentPattern): void;

	/**
	 * Walk object pattern.
	 */
	walkObjectPattern(pattern: ObjectPattern): void;

	/**
	 * Walk array pattern.
	 */
	walkArrayPattern(pattern: ArrayPattern): void;

	/**
	 * Processes the provided pattern.
	 */
	walkRestElement(pattern: RestElement): void;

	/**
	 * Processes the provided expression.
	 */
	walkExpressions(
		expressions: (
			| null
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| SpreadElement
		)[]
	): void;

	/**
	 * Processes the provided expression.
	 */
	walkExpression(
		expression:
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| SpreadElement
			| PrivateIdentifier
			| Super
	): void;

	/**
	 * Walk await expression.
	 */
	walkAwaitExpression(expression: AwaitExpression): void;

	/**
	 * Walk array expression.
	 */
	walkArrayExpression(expression: ArrayExpression): void;

	/**
	 * Walk spread element.
	 */
	walkSpreadElement(expression: SpreadElement): void;

	/**
	 * Walk object expression.
	 */
	walkObjectExpression(expression: ObjectExpression): void;

	/**
	 * Processes the provided prop.
	 */
	walkProperty(prop: SpreadElement | Property): void;

	/**
	 * Walk function expression.
	 */
	walkFunctionExpression(expression: FunctionExpression): void;

	/**
	 * Walk arrow function expression.
	 */
	walkArrowFunctionExpression(expression: ArrowFunctionExpression): void;

	/**
	 * Walk sequence expression.
	 */
	walkSequenceExpression(expression: SequenceExpression): void;

	/**
	 * Walk update expression.
	 */
	walkUpdateExpression(expression: UpdateExpression): void;

	/**
	 * Walk unary expression.
	 */
	walkUnaryExpression(expression: UnaryExpression): void;

	/**
	 * Walk left right expression.
	 */
	walkLeftRightExpression(
		expression: BinaryExpression | LogicalExpression
	): void;

	/**
	 * Walk binary expression.
	 */
	walkBinaryExpression(expression: BinaryExpression): void;

	/**
	 * Walk logical expression.
	 */
	walkLogicalExpression(expression: LogicalExpression): void;

	/**
	 * Walk assignment expression.
	 */
	walkAssignmentExpression(expression: AssignmentExpression): void;

	/**
	 * Walk conditional expression.
	 */
	walkConditionalExpression(expression: ConditionalExpression): void;

	/**
	 * Walk new expression.
	 */
	walkNewExpression(expression: NewExpression): void;

	/**
	 * Walk yield expression.
	 */
	walkYieldExpression(expression: YieldExpression): void;

	/**
	 * Walk template literal.
	 */
	walkTemplateLiteral(expression: TemplateLiteral): void;

	/**
	 * Walk tagged template expression.
	 */
	walkTaggedTemplateExpression(expression: TaggedTemplateExpression): void;

	/**
	 * Walk class expression.
	 */
	walkClassExpression(expression: ClassExpression): void;

	/**
	 * Walk chain expression.
	 */
	walkChainExpression(expression: ChainExpression): void;

	/**
	 * Walk import expression.
	 */
	walkImportExpression(expression: ImportExpressionJavascriptParser): void;

	/**
	 * Walk call expression.
	 */
	walkCallExpression(expression: CallExpression): void;

	/**
	 * Walk member expression.
	 */
	walkMemberExpression(expression: MemberExpression): void;

	/**
	 * Walk member expression with expression name.
	 */
	walkMemberExpressionWithExpressionName<R>(
		expression: MemberExpression,
		name: string,
		rootInfo: string | VariableInfo,
		members: string[],
		onUnhandled: () => undefined | R
	): void;

	/**
	 * Walk this expression.
	 */
	walkThisExpression(expression: ThisExpression): void;

	/**
	 * Processes the provided expression.
	 */
	walkIdentifier(expression: Identifier): void;

	/**
	 * Walk meta property.
	 */
	walkMetaProperty(metaProperty: MetaProperty): void;

	/**
	 * Call hooks for expression.
	 */
	callHooksForExpression<T, R>(
		hookMap: HookMap<SyncBailHook<T, R>>,
		expr:
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| Super,
		...args: AsArray<T>
	): undefined | R;

	/**
	 * Call hooks for expression with fallback.
	 */
	callHooksForExpressionWithFallback<T, R>(
		hookMap: HookMap<SyncBailHook<T, R>>,
		expr:
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| Super,
		fallback:
			| undefined
			| ((
					name: string,
					rootInfo: string | VariableInfo | ScopeInfo,
					getMembers: () => string[]
			  ) => R),
		defined: undefined | ((result?: string) => undefined | R),
		...args: AsArray<T>
	): undefined | R;

	/**
	 * Call hooks for name.
	 */
	callHooksForName<T, R>(
		hookMap: HookMap<SyncBailHook<T, R>>,
		name: string,
		...args: AsArray<T>
	): undefined | R;

	/**
	 * Call hooks for info.
	 */
	callHooksForInfo<T, R>(
		hookMap: HookMap<SyncBailHook<T, R>>,
		info: ExportedVariableInfo,
		...args: AsArray<T>
	): undefined | R;

	/**
	 * Call hooks for info with fallback.
	 */
	callHooksForInfoWithFallback<T, R>(
		hookMap: HookMap<SyncBailHook<T, R>>,
		info: ExportedVariableInfo,
		fallback: undefined | ((name: string) => undefined | R),
		defined: undefined | ((result?: string) => undefined | R),
		...args: AsArray<T>
	): undefined | R;

	/**
	 * Call hooks for name with fallback.
	 */
	callHooksForNameWithFallback<T, R>(
		hookMap: HookMap<SyncBailHook<T, R>>,
		name: string,
		fallback: undefined | ((value: string) => undefined | R),
		defined: undefined | (() => R),
		...args: AsArray<T>
	): undefined | R;

	/**
	 * Processes the provided param.
	 * @deprecated
	 */
	inScope(
		params: (
			| string
			| Identifier
			| MemberExpression
			| Property
			| ObjectPattern
			| ArrayPattern
			| RestElement
			| AssignmentPattern
		)[],
		fn: () => void
	): void;

	/**
	 * Processes the provided has thi.
	 */
	inClassScope(hasThis: boolean, params: Identifier[], fn: () => void): void;

	/**
	 * Processes the provided has thi.
	 */
	inFunctionScope(
		hasThis: boolean,
		params: (
			| string
			| Identifier
			| MemberExpression
			| ObjectPattern
			| ArrayPattern
			| RestElement
			| AssignmentPattern
		)[],
		fn: () => void
	): void;

	/**
	 * Processes the provided fn.
	 */
	inBlockScope(fn: () => void, inExecutedPath?: boolean): void;

	/**
	 * The directive a statement spells, or `undefined` when it is not one. An
	 * AST webpack did not parse may leave the metadata off a directive, so the
	 * spelling is recovered from the literal itself there.
	 */
	getDirective(
		statement:
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| FunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| ExpressionStatement
			| BlockStatement
			| StaticBlock
			| EmptyStatement
			| DebuggerStatement
			| WithStatement
			| ReturnStatement
			| LabeledStatement
			| BreakStatement
			| ContinueStatement
			| IfStatement
			| SwitchStatement
			| ThrowStatement
			| TryStatement
			| WhileStatement
			| DoWhileStatement
			| ForStatement
			| ForInStatement
			| ForOfStatement
			| ExportDefaultDeclaration
			| Directive
	): undefined | string;

	/**
	 * Processes the provided statement.
	 */
	detectMode(
		statements: (
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| FunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| ExpressionStatement
			| BlockStatement
			| StaticBlock
			| EmptyStatement
			| DebuggerStatement
			| WithStatement
			| ReturnStatement
			| LabeledStatement
			| BreakStatement
			| ContinueStatement
			| IfStatement
			| SwitchStatement
			| ThrowStatement
			| TryStatement
			| WhileStatement
			| DoWhileStatement
			| ForStatement
			| ForInStatement
			| ForOfStatement
			| ExportDefaultDeclaration
			| Directive
		)[]
	): void;

	/**
	 * Processes the provided pattern.
	 */
	enterPatterns(
		patterns: (
			| string
			| Identifier
			| MemberExpression
			| Property
			| ObjectPattern
			| ArrayPattern
			| RestElement
			| AssignmentPattern
		)[],
		onIdent: (ident: string) => void
	): void;

	/**
	 * Processes the provided pattern.
	 */
	enterPattern(
		pattern:
			| Identifier
			| MemberExpression
			| Property
			| ObjectPattern
			| ArrayPattern
			| RestElement
			| AssignmentPattern,
		onIdent: (ident: string, identifier: Identifier) => void
	): void;

	/**
	 * Processes the provided pattern.
	 */
	enterIdentifier(
		pattern: Identifier,
		onIdent: (ident: string, identifier: Identifier) => void
	): void;

	/**
	 * Enter object pattern.
	 */
	enterObjectPattern(
		pattern: ObjectPattern,
		onIdent: (ident: string, identifier: Identifier) => void
	): void;

	/**
	 * Enter array pattern.
	 */
	enterArrayPattern(
		pattern: ArrayPattern,
		onIdent: (ident: string, identifier: Identifier) => void
	): void;

	/**
	 * Enter rest element.
	 */
	enterRestElement(
		pattern: RestElement,
		onIdent: (ident: string, identifier: Identifier) => void
	): void;

	/**
	 * Enter assignment pattern.
	 */
	enterAssignmentPattern(
		pattern: AssignmentPattern,
		onIdent: (ident: string, identifier: Identifier) => void
	): void;

	/**
	 * Evaluate expression.
	 */
	evaluateExpression(
		expression:
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| SpreadElement
			| PrivateIdentifier
			| Super
	): BasicEvaluatedExpression;

	/**
	 * Returns parsed string.
	 */
	parseString(expression: Expression): string;

	/**
	 * Parses calculated string.
	 */
	parseCalculatedString(expression: Expression): CalculatedStringResult;

	/**
	 * Returns evaluation result.
	 */
	evaluate(source: string): BasicEvaluatedExpression;

	/**
	 * Checks whether this javascript parser is pure.
	 */
	isPure(
		expr:
			| undefined
			| null
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| PrivateIdentifier
			| FunctionDeclaration
			| MaybeNamedFunctionDeclaration
			| VariableDeclaration
			| ClassDeclaration
			| MaybeNamedClassDeclaration,
		commentsStartPos: number
	): boolean;

	/**
	 * Returns the location of a node or comment, computed from its offsets so
	 * ASTs from parsers without location support work too. Falls back to the
	 * node's own `loc` only when no source text is available (preparsed ASTs).
	 * Offsets can only be mapped while parsing — callbacks deferred past the
	 * `parse()` call must take the location upfront.
	 */
	getLocation(node: {
		start?: number;
		end?: number;
		range?: [number, number];
		loc?: null | SourceLocation;
	}): DependencyLocation;

	/**
	 * Returns comments in the range.
	 */
	getComments(range: [number, number]): CommentJavascriptParser[];

	/**
	 * Where the comments written for `statement` begin: the run of comments
	 * before it that whitespace alone separates from it and from each other.
	 */
	getAttachedCommentsStart(statement: StatementPathItem): number;

	/**
	 * Reports whether `identifier` may occur as a word in the source text of
	 * `range`. A conservative pre-filter for expensive AST scans: `false` means
	 * it certainly does not occur, while a match inside a comment or a string
	 * yields `true`. Also `true` when no source text is available (preparsed
	 * AST), so callers must stay correct without the filter.
	 */
	sourceMayContainIdentifier(
		range: [number, number],
		identifier: string
	): boolean;

	/**
	 * Checks whether this javascript parser is asi position.
	 */
	isAsiPosition(pos: number): boolean;

	/**
	 * Updates asi position using the provided po.
	 */
	setAsiPosition(pos: number): void;

	/**
	 * Unset asi position.
	 */
	unsetAsiPosition(pos: number): void;

	/**
	 * Checks whether this javascript parser is statement level expression.
	 */
	isStatementLevelExpression(expr: Expression): boolean;

	/**
	 * Returns tag data.
	 */
	getTagData(
		name: string,
		tag: symbol
	):
		| undefined
		| object
		| TopLevelSymbol
		| ESMSettings
		| ImportSettings
		| CommonJsImportSettings
		| CompatibilitySettings;

	/**
	 * Processes the provided name.
	 */
	tagVariable(
		name: string,
		tag: symbol,
		data?:
			| object
			| TopLevelSymbol
			| ESMSettings
			| ImportSettings
			| CommonJsImportSettings
			| CompatibilitySettings,
		flags?: 0 | 1 | 2 | 4
	): void;

	/**
	 * Processes the provided name.
	 */
	defineVariable(name: string): void;

	/**
	 * Processes the provided name.
	 */
	undefineVariable(name: string): void;

	/**
	 * Checks whether this javascript parser is variable defined.
	 */
	isVariableDefined(name: string): boolean;

	/**
	 * Gets variable info.
	 */
	getVariableInfo(name: string): ExportedVariableInfo;

	/**
	 * Updates variable using the provided name.
	 */
	setVariable(name: string, variableInfo: ExportedVariableInfo): void;

	/**
	 * Evaluated variable.
	 */
	evaluatedVariable(tagInfo: TagInfo): VariableInfo;

	/**
	 * Parses comment options.
	 */
	parseCommentOptions(range: [number, number]): {
		options: null | MagicCommentOptions;
		errors: null | (Error & { comment: CommentJavascriptParser })[];
	};

	/**
	 * Finds the root object of a member expression chain without allocating the
	 * member arrays. The traversal/break logic must stay in sync with
	 * `extractMemberExpressionChain`; it lets `getMemberExpressionInfo` reject
	 * unrecognized roots (~77% of calls) before paying for the arrays.
	 */
	getMemberExpressionRoot(
		expression:
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| Super
	):
		| ImportExpressionImport
		| UnaryExpression
		| ArrayExpression
		| ArrowFunctionExpression
		| AssignmentExpression
		| AwaitExpression
		| BinaryExpression
		| SimpleCallExpression
		| NewExpression
		| ChainExpression
		| ClassExpression
		| ConditionalExpression
		| FunctionExpression
		| Identifier
		| SimpleLiteral
		| RegExpLiteral
		| BigIntLiteral
		| LogicalExpression
		| MemberExpression
		| MetaProperty
		| ObjectExpression
		| SequenceExpression
		| TaggedTemplateExpression
		| TemplateLiteral
		| ThisExpression
		| UpdateExpression
		| YieldExpression
		| Super;

	/**
	 * Extract member expression chain.
	 */
	extractMemberExpressionChain(
		expression:
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| Super
	): {
		members: string[];
		object:
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| Super;
		membersOptionals: boolean[];
		memberRanges: [number, number][];
	};

	/**
	 * Gets free info from variable.
	 */
	getFreeInfoFromVariable(
		varName: string
	): undefined | { name: string; info: string | VariableInfo };

	/**
	 * Gets name info from variable.
	 */
	getNameInfoFromVariable(
		varName: string
	): undefined | { name: string; info: string | VariableInfo };

	/**
	 * Gets member expression info.
	 */
	getMemberExpressionInfo(
		expression:
			| ImportExpressionImport
			| UnaryExpression
			| ArrayExpression
			| ArrowFunctionExpression
			| AssignmentExpression
			| AwaitExpression
			| BinaryExpression
			| SimpleCallExpression
			| NewExpression
			| ChainExpression
			| ClassExpression
			| ConditionalExpression
			| FunctionExpression
			| Identifier
			| SimpleLiteral
			| RegExpLiteral
			| BigIntLiteral
			| LogicalExpression
			| MemberExpression
			| MetaProperty
			| ObjectExpression
			| SequenceExpression
			| TaggedTemplateExpression
			| TemplateLiteral
			| ThisExpression
			| UpdateExpression
			| YieldExpression
			| Super,
		allowedTypes: number
	): undefined | CallExpressionInfo | ExpressionExpressionInfo;

	/**
	 * Gets name for expression.
	 */
	getNameForExpression(
		expression: Expression
	):
		| undefined
		| {
				name: string;
				rootInfo: ExportedVariableInfo;
				getMembers: () => string[];
		  };

	/**
	 * Whether a definition is a variable rather than a free name or a scope.
	 */
	static isVariableInfo(value?: string | VariableInfo | ScopeInfo): boolean;

	/**
	 * Returns parser.
	 */
	static extend(
		...plugins: ((BaseParser: typeof SyntaxParser) => typeof SyntaxParser)[]
	): typeof JavascriptParser;
	static ALLOWED_MEMBER_TYPES_ALL: number;
	static ALLOWED_MEMBER_TYPES_CALL_EXPRESSION: number;
	static ALLOWED_MEMBER_TYPES_EXPRESSION: number;
	static VariableInfo: typeof VariableInfo;
	static VariableInfoFlags: Readonly<{
		Evaluated: 0;
		Free: 1;
		Normal: 2;
		Tagged: 4;
	}>;
	static getImportAttributes: (
		node:
			| ImportDeclaration
			| ExportNamedDeclaration
			| ExportAllDeclaration
			| ImportExpressionJavascriptParser
	) => undefined | ImportAttributes;
}

/**
 * Parser options for javascript modules.
 */
declare interface JavascriptParserOptions {
	/**
	 * Set the value of `require.amd` and `define.amd`. Or disable AMD support.
	 */
	amd?: false | { [index: string]: any };

	/**
	 * Set .name to "default" for anonymous default export functions and classes per ES spec. Disable to reduce output size when .name is not needed.
	 */
	anonymousDefaultExportName?: boolean;

	/**
	 * Enable/disable special handling for browserify bundles.
	 */
	browserify?: boolean;

	/**
	 * Enable/disable parsing of CommonJs syntax.
	 */
	commonjs?: boolean;

	/**
	 * Enable/disable parsing of magic comments in CommonJs syntax.
	 */
	commonjsMagicComments?: boolean;

	/**
	 * Enable/disable parsing "import { createRequire } from "module"" and evaluating createRequire().
	 */
	createRequire?: string | boolean;

	/**
	 * Enable experimental tc39 proposal https://github.com/tc39/proposal-defer-import-eval. This allows to defer execution of a module until it's first use.
	 * @since 5.100.0
	 */
	deferImport?: boolean;

	/**
	 * Auto-emit `<link rel="preload" as="style">` for the CSS of every dynamically imported (`import()`) chunk, so the stylesheet fetches in parallel with the chunk's JavaScript instead of after it parses. Unlike `dynamicImportPreload`, the JavaScript itself is not preloaded. `true` uses the default order; a number sets the preload order.
	 * @since 5.109.0
	 */
	dynamicImportCssPreload?: number | boolean;

	/**
	 * Specifies global fetchPriority for dynamic import.
	 */
	dynamicImportFetchPriority?: false | "auto" | "low" | "high";

	/**
	 * Specifies global mode for dynamic import.
	 */
	dynamicImportMode?: "eager" | "weak" | "lazy" | "lazy-once";

	/**
	 * Specifies global prefetch for dynamic import.
	 */
	dynamicImportPrefetch?: number | boolean;

	/**
	 * Specifies global preload for dynamic import.
	 */
	dynamicImportPreload?: number | boolean;

	/**
	 * Enable/disable parsing of dynamic URL.
	 */
	dynamicUrl?: boolean;

	/**
	 * Enable/disable parsing of EcmaScript Modules syntax.
	 * @since 5.112.0
	 */
	esm?: boolean;

	/**
	 * Specifies the behavior of invalid export names in "import ... from ..." and "export ... from ...".
	 */
	exportsPresence?: false | "auto" | "error" | "warn";

	/**
	 * Enable warnings for full dynamic dependencies.
	 */
	exprContextCritical?: boolean;

	/**
	 * Enable recursive directory lookup for full dynamic dependencies.
	 */
	exprContextRecursive?: boolean;

	/**
	 * Sets the default regular expression for full dynamic dependencies.
	 */
	exprContextRegExp?: boolean | RegExp;

	/**
	 * Set the default request for full dynamic dependencies.
	 */
	exprContextRequest?: string;

	/**
	 * Deprecated in favor of "esm". Enable/disable parsing of EcmaScript Modules syntax.
	 * @deprecated
	 */
	harmony?: boolean;

	/**
	 * Enable/disable parsing of import() syntax.
	 */
	import?: boolean;

	/**
	 * Specifies the behavior of invalid export names in "import ... from ...".
	 */
	importExportsPresence?: false | "auto" | "error" | "warn";

	/**
	 * Enable/disable evaluating import.meta. Set to 'preserve-unknown' or an object to preserve unknown properties for runtime evaluation.
	 */
	importMeta?: boolean | "preserve-unknown" | ImportMetaParserOptions;

	/**
	 * Deprecated in favor of "importMeta" object option with a "webpackContext" field. Enable/disable evaluating import.meta.webpackContext.
	 * @deprecated
	 */
	importMetaContext?: boolean;

	/**
	 * Include polyfills or mocks for various node stuff.
	 */
	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";

	/**
	 * Function to parser source code.
	 */
	parse?: (code: string, options: ParseOptionsJavascriptParser) => ParseResult;

	/**
	 * Mark the listed top-level function names for pure-function-based tree shaking.
	 */
	pureFunctions?: string[];

	/**
	 * 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.
	 */
	reexportExportsPresence?: false | "auto" | "error" | "warn";

	/**
	 * Enable/disable parsing of require.context syntax.
	 */
	requireContext?: boolean;

	/**
	 * Enable/disable parsing of require.ensure syntax.
	 */
	requireEnsure?: boolean;

	/**
	 * Enable/disable parsing of require.include syntax.
	 */
	requireInclude?: boolean;

	/**
	 * Enable/disable parsing of require.js special syntax like require.config, requirejs.config, require.version and requirejs.onError.
	 */
	requireJs?: boolean;

	/**
	 * Enable experimental tc39 proposal https://github.com/tc39/proposal-source-phase-imports. This allows importing modules at source phase.
	 */
	sourceImport?: boolean;

	/**
	 * Hand out a spec-compliant Module Namespace Exotic Object for 'import * as ns' and 'import()' of this module instead of the plain exports object. Requires 'Proxy' in the target environment, keeps every exported name, and costs runtime code, so enable it per module. Set it on the imported module, not on the importer.
	 * @since 5.111.0
	 */
	specNamespaceObject?: boolean;

	/**
	 * Deprecated in favor of "exportsPresence". Emit errors instead of warnings when imported names don't exist in imported module.
	 * @deprecated
	 */
	strictExportPresence?: boolean;

	/**
	 * Specifies the behavior of constructs that break at runtime in strict mode (e.g. 'with', 'arguments.callee', assigning to read-only globals) when modules are emitted as ES module output.
	 * @since 5.109.0
	 */
	strictModeViolations?: false | "error" | "warn";

	/**
	 * Handle the this context correctly according to the spec for namespace objects.
	 */
	strictThisContextOnImports?: boolean;

	/**
	 * Enable/disable parsing of System.js special syntax like System.import, System.get, System.set and System.register.
	 */
	system?: boolean;

	/**
	 * Set what top-level "this" refers to in a non-ES module: "exports" (the exports object, as in Node.js) or "global" (the global object, as in a classic script).
	 * @since 5.112.0
	 */
	topLevelThis?: "global" | "exports";

	/**
	 * Enable typescript support.
	 * @experimental
	 */
	typescript?: boolean;

	/**
	 * Enable warnings when using the require function in a not statically analyse-able way.
	 */
	unknownContextCritical?: boolean;

	/**
	 * Enable recursive directory lookup when using the require function in a not statically analyse-able way.
	 */
	unknownContextRecursive?: boolean;

	/**
	 * Sets the regular expression when using the require function in a not statically analyse-able way.
	 */
	unknownContextRegExp?: boolean | RegExp;

	/**
	 * Sets the request when using the require function in a not statically analyse-able way.
	 */
	unknownContextRequest?: string;

	/**
	 * Enable/disable parsing of new URL() syntax.
	 */
	url?: boolean | "relative";

	/**
	 * URL-referenced-asset default hint rules for this parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`).
	 * @since 5.109.0
	 */
	urlHints?: UrlHintRule[];

	/**
	 * Disable or configure parsing of WebWorker syntax like new Worker() or navigator.serviceWorker.register().
	 */
	worker?: boolean | string[];

	/**
	 * Disable or configure parsing of Worklet syntax like context.audioWorklet.addModule() or CSS.paintWorklet.addModule().
	 * @since 5.109.0
	 */
	worklet?: boolean | string[];

	/**
	 * Enable warnings for partial dynamic dependencies.
	 */
	wrappedContextCritical?: boolean;

	/**
	 * Enable recursive directory lookup for partial dynamic dependencies.
	 */
	wrappedContextRecursive?: boolean;

	/**
	 * Set the inner regular expression for partial dynamic dependencies.
	 */
	wrappedContextRegExp?: RegExp;
}
type JavascriptParserState = ParserStateBase<BuiltJavascriptModule> &
	Record<string, any> &
	KnownJavascriptParserState;
declare interface JoinCacheEntry {
	/**
	 * cached join function
	 */
	fn: (rootPath: string, request: string) => string;

	/**
	 * the underlying cache map
	 */
	cache: Map<string, Map<string, undefined | string>>;
}
declare abstract class JsonData {
	/**
	 * Returns raw JSON data.
	 */
	get():
		undefined | null | string | number | boolean | JsonObjectFs | JsonValueFs[];

	/**
	 * Updates the hash with the data contributed by this instance.
	 */
	updateHash(hash: Hash): void;
}
declare abstract class JsonGenerator extends Generator<JsonNormalModule> {
	options: JsonGeneratorOptions;

	/**
	 * Generates fallback output for the provided error condition.
	 */
	generateError(
		error: Error,
		module: JsonNormalModule,
		generateContext: GenerateContext
	): null | Source;
}

/**
 * Generator options for json modules.
 */
declare interface JsonGeneratorOptions {
	/**
	 * Use `JSON.parse` when the JSON string is longer than 20 characters.
	 */
	JSONParse?: boolean;
}
type JsonModuleBuildInfo = KnownBuildInfo &
	Record<string, any> &
	KnownNormalModuleBuildInfo &
	KnownJsonModuleBuildInfo;

/**
 * The JsonModulesPlugin is the entrypoint plugin for the json modules feature.
 * It adds the json module type to the compiler and registers the json parser and generator.
 */
declare class JsonModulesPlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
type JsonNormalModule = NormalModule & { buildInfo?: JsonModuleBuildInfo };
declare interface JsonObjectFs {
	[index: string]:
		undefined | null | string | number | boolean | JsonObjectFs | JsonValueFs[];
}
declare interface JsonObjectResolver {
	[index: string]:
		| undefined
		| null
		| string
		| number
		| boolean
		| JsonObjectResolver
		| JsonValueResolver[];
}
declare abstract class JsonParser extends Parser<BuiltJsonModule> {
	options: JsonParserOptions;
}

/**
 * Parser options for JSON modules.
 */
declare interface JsonParserOptions {
	/**
	 * The depth of json dependency flagged as `exportInfo`.
	 */
	exportsDepth?: number;

	/**
	 * Allow named exports for json of object type.
	 */
	namedExports?: boolean;

	/**
	 * Function to parser content and return JSON.
	 */
	parse?: (
		input: string
	) => null | string | number | boolean | Buffer | JsonObjectFs | JsonValueFs[];
}
type JsonValueFs =
	null | string | number | boolean | JsonObjectFs | JsonValueFs[];
type JsonValueResolver =
	null | string | number | boolean | JsonObjectResolver | JsonValueResolver[];
declare class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
	constructor(runtimeRequirements: ReadonlySet<string>);
	static getCompilationHooks: (
		compilation: Compilation
	) => JsonpCompilationPluginHooks;

	/**
	 * The answer a runtime module gives when it installs no chunk handler at all
	 */
	static NO_CHUNK_HANDLERS: [string, string][];

	/**
	 * Runtime modules without any dependencies to other runtime modules
	 */
	static STAGE_NORMAL: number;

	/**
	 * Runtime modules with simple dependencies on other runtime modules
	 */
	static STAGE_BASIC: number;

	/**
	 * Runtime modules which attach to handlers of other runtime modules
	 */
	static STAGE_ATTACH: number;

	/**
	 * Runtime modules which trigger actions on bootstrap
	 */
	static STAGE_TRIGGER: number;
	static KINDS: Set<
		| "html"
		| "runtime"
		| "normal"
		| "css"
		| "context"
		| "remote"
		| "consume-shared"
		| "external"
		| "concatenated"
	>;

	/**
	 * Gets source basic types.
	 * @deprecated In the next major release, call getSourceBasicTypes() directly on the module instance instead of using this static method.
	 */
	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
}
declare interface JsonpCompilationPluginHooks {
	linkPreload: SyncWaterfallHook<[string, Chunk], string>;
	linkPrefetch: SyncWaterfallHook<[string, Chunk], string>;
}
declare class JsonpTemplatePlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Returns hooks.
	 * @deprecated use JsonpChunkLoadingRuntimeModule.getCompilationHooks instead
	 */
	static getCompilationHooks(
		compilation: Compilation
	): JsonpCompilationPluginHooks;
}

/**
 * a comment as a `comments` callback is handed it: terser's comment token, its offset, line from 1 and column from 0, and the file it was read from
 */
declare interface KeptComment {
	type: "comment1" | "comment2" | "comment3" | "comment4";
	value: string;
	pos: number;
	line: number;
	col: number;
	file?: string;
}

/**
 * Defines the known asset info type used by this module.
 */
declare interface KnownAssetInfo {
	/**
	 * true, if the asset can be long term cached forever (contains a hash)
	 */
	immutable?: boolean;

	/**
	 * whether the asset is minimized
	 */
	minimized?: boolean;

	/**
	 * the value(s) of the full hash used for this asset
	 */
	fullhash?: string | string[];

	/**
	 * the value(s) of the chunk hash used for this asset
	 */
	chunkhash?: string | string[];

	/**
	 * the value(s) of the module hash used for this asset
	 */
	modulehash?: string | string[];

	/**
	 * the value(s) of the content hash used for this asset
	 */
	contenthash?: string | string[];

	/**
	 * maps a `[contenthash:<digest>]` value to its digest, so `RealContentHashPlugin` re-encodes the recomputed hash in it
	 */
	contenthashDigest?: Record<string, string>;

	/**
	 * when asset was created from a source file (potentially transformed), the original filename relative to compilation context
	 */
	sourceFilename?: string;

	/**
	 * true, when the asset was copied from a file by `output.copy`
	 */
	copied?: boolean;

	/**
	 * when set, the asset is emitted as a symbolic link rather than as its content
	 */
	symlink?: AssetSymlink;

	/**
	 * when set, the file the asset is written to is given these permissions
	 */
	mode?: number;

	/**
	 * when set, the file the asset is written to is stamped with these times
	 */
	timestamps?: AssetTimestamps;

	/**
	 * size in bytes, only set after asset has been emitted
	 */
	size?: number;

	/**
	 * true, when asset is only used for development and doesn't count towards user-facing assets
	 */
	development?: boolean;

	/**
	 * true, when asset ships data for updating an existing application (HMR)
	 */
	hotModuleReplacement?: boolean;

	/**
	 * true, when asset is javascript and an ESM
	 */
	javascriptModule?: boolean;

	/**
	 * true, when file is a manifest
	 */
	manifest?: boolean;

	/**
	 * object of pointers to other assets, keyed by type of relation (only points from parent to child)
	 */
	related?: Record<string, null | string | string[]>;
}

/**
 * Defines the build info properties specific to asset modules.
 */
declare interface KnownAssetModuleBuildInfo {
	/**
	 * whether the asset is inlined as a data url
	 */
	dataUrl?: boolean;
	filename?: string;
	assetInfo?: AssetInfo;
	fullContentHash?: string;

	/**
	 * the resource this asset is named after, when
	 * something re-encoded it. Unlike `matchResource` this is serialized, so a
	 * rename set while building survives the persistent cache
	 */
	assetResource?: string;
}

/**
 * Defines the build info properties common to all module types.
 * Module type specific properties live in the `Known*BuildInfo` typedef of the dedicated module class.
 */
declare interface KnownBuildInfo {
	/**
	 * the module hands out a spec Module Namespace Exotic Object
	 */
	specNamespaceObject?: boolean;
	cacheable?: boolean;
	strict?: boolean;
	moduleArgument?: string;
	exportsArgument?: string;

	/**
	 * assets added by loaders or plugins
	 */
	assets?: Record<string, Source>;
	assetsInfo?: Map<string, undefined | AssetInfo>;

	/**
	 * top level declaration names
	 */
	topLevelDeclarations?: Set<string>;

	/**
	 * true when the module is in a synchronous circular dependency chain
	 */
	isCircular?: boolean;

	/**
	 * CircularKind bit flags from CircularModulesPlugin; unset when the plugin did not run
	 */
	circularKind?: number;

	/**
	 * module uses top-level `for await…of` or `await using`, which can't be lowered to a generator
	 */
	usesTopLevelAwaitForOf?: boolean;

	/**
	 * what the build recorded for stats and the performance hints to report
	 */
	diagnostics?: BuildDiagnostics;
}

/**
 * Defines the build meta properties common to all module types.
 * Module type specific properties live in the `Known*BuildMeta` typedef of the dedicated module class.
 */
declare interface KnownBuildMeta {
	exportsType?: "default" | "namespace" | "flagged" | "dynamic";
	defaultObject?: false | "redirect" | "redirect-warn";
	async?: boolean;
	sideEffectFree?: boolean;
}

/**
 * Defines the build info properties specific to concatenated modules.
 */
declare interface KnownConcatenatedModuleBuildInfo {
	fileDependencies?: LazySet<string>;
	contextDependencies?: LazySet<string>;
	missingDependencies?: LazySet<string>;

	/**
	 * collected from the inner modules
	 */
	needCreateRequire?: boolean;

	/**
	 * taken over from the root module
	 */
	inlineExports?: boolean;
}
declare interface KnownContext {
	/**
	 * environments
	 */
	environments?: string[];

	/**
	 * package id of the importing file in the package map, propagated from a previous result to disambiguate package entries that share a location (`@experimental`, see the `packageMap` option)
	 */
	packageId?: string;
}

/**
 * Defines the build info properties specific to context modules.
 */
declare interface KnownContextModuleBuildInfo {
	snapshot?: null | Snapshot;
}

/**
 * Defines the known create stats options context type used by this module.
 */
declare interface KnownCreateStatsOptionsContext {
	forToString?: boolean;
}

/**
 * Defines the build info properties specific to css modules.
 */
declare interface KnownCssModuleBuildInfo {
	cssData?: CssData;

	/**
	 * charset at-rule
	 */
	charset?: string;
}

/**
 * Defines the build meta properties specific to css modules.
 */
declare interface KnownCssModuleBuildMeta {
	isCssModule?: boolean;
	needIdInConcatenation?: boolean;
}

/**
 * Defines the build info properties specific to external modules.
 */
declare interface KnownExternalModuleBuildInfo {
	/**
	 * true when emitting an ESM external (`output.module`)
	 */
	javascriptModule?: boolean;
}
declare interface KnownHooks {
	/**
	 * resolve step hook
	 */
	resolveStep: SyncHook<
		[
			AsyncSeriesBailHook<
				[ResolveRequest, ResolveContext],
				null | ResolveRequest
			>,
			ResolveRequest
		]
	>;

	/**
	 * no resolve hook
	 */
	noResolve: SyncHook<[ResolveRequest, Error]>;

	/**
	 * resolve hook
	 */
	resolve: AsyncSeriesBailHook<
		[ResolveRequest, ResolveContext],
		null | ResolveRequest
	>;

	/**
	 * result hook
	 */
	result: AsyncSeriesHook<[ResolveRequest, ResolveContext]>;
}

/**
 * Defines the build info properties specific to html modules.
 */
declare interface KnownHtmlModuleBuildInfo {
	/**
	 * entries collected from the document, grouped by kind
	 */
	htmlEntries?: Record<string, HtmlEntryInfo[]>;

	/**
	 * `../` per `<base href>` path segment, prepended to the auto-public-path undo path so a relative base doesn't misdirect bundled URLs
	 */
	baseUrlPrefix?: string;
}

/**
 * Defines the build info properties specific to javascript modules.
 */
declare interface KnownJavascriptModuleBuildInfo {
	/**
	 * using in CommonJs
	 */
	moduleConcatenationBailout?: string;

	/**
	 * what rules the module out as a concatenation root, while it may still be an inner module
	 */
	moduleConcatenationRootBailout?: string;

	/**
	 * using in APIPlugin
	 */
	needCreateRequire?: boolean;

	/**
	 * module reassigns `__webpack_public_path__` at runtime, using in APIPlugin
	 */
	usingPublicPathOverride?: boolean;

	/**
	 * names of locally declared functions known to be free of side effects
	 */
	pureFunctions?: Set<string>;

	/**
	 * whether this module was parsed with `optimization.inlineExports` enabled (gates inlining of its exports)
	 */
	inlineExports?: boolean;

	/**
	 * module scope holds a `using`/`await using` declaration, so its resources must be disposed when the module finished evaluating
	 */
	usesTopLevelUsingDeclaration?: boolean;
}

/**
 * Defines the build meta properties specific to javascript modules.
 */
declare interface KnownJavascriptModuleBuildMeta {
	strictHarmonyModule?: boolean;
	treatAsCommonJs?: boolean;
}

/**
 * Defines the known javascript parser state type used by this module.
 * The `harmony*` properties forward to their `esm*` namesake.
 */
declare interface KnownJavascriptParserState {
	esmNamedExports?: Set<string>;
	esmStarExports?: ESMStarExportsList;
	lastESMImportOrder?: number;
	localModules?: LocalModule[];

	/**
	 * deprecated, use `esmNamedExports`
	 */
	harmonyNamedExports?: Set<string>;

	/**
	 * deprecated, use `esmStarExports`
	 */
	harmonyStarExports?: ESMStarExportsList;

	/**
	 * deprecated, use `lastESMImportOrder`
	 */
	lastHarmonyImportOrder?: number;
}

/**
 * Defines the build info properties specific to json modules.
 */
declare interface KnownJsonModuleBuildInfo {
	jsonData?: JsonData;
}

/**
 * Defines the known meta type used by this module.
 */
declare interface KnownMeta {
	importVarMap?: Map<Module, string>;
	deferredImportVarMap?: Map<Module, string>;

	/**
	 * generate export definitions on demand
	 */
	onDemandExports?: boolean;

	/**
	 * module-level `let` names a module library declares in the chunk's scope instead
	 */
	liveBindings?: Map<string, LiveBinding>;

	/**
	 * module-level names a module keeps declared and mirrors to the chunk's scope on each write
	 */
	liveSetters?: Map<string, LiveBinding>;
}

/**
 * Defines the build info properties of normal modules (filesystem-backed, loader-processed).
 */
declare interface KnownNormalModuleBuildInfo {
	parsed?: boolean;
	hash?: string;
	fileDependencies?: LazySet<string>;
	contextDependencies?: LazySet<string>;
	missingDependencies?: LazySet<string>;
	buildDependencies?: LazySet<string>;
	valueDependencies?: Map<string, ValueCacheVersion>;
	snapshot?: null | Snapshot;

	/**
	 * using in HttpUriPlugin
	 */
	resourceIntegrity?: string;
}

/**
 * Defines the known normalized stats options type used by this module.
 */
declare interface KnownNormalizedStatsOptions {
	context: string;
	requestShortener: RequestShortener;
	chunksSort: string | false;
	modulesSort: string | false;
	chunkModulesSort: string | false;
	nestedModulesSort: string | false;
	assetsSort: string | false;
	ids: boolean;
	cachedAssets: boolean;
	groupAssetsByEmitStatus: boolean;
	groupAssetsByPath: boolean;
	groupAssetsByExtension: boolean;
	assetsSpace: number;
	excludeAssets: ((value: string, asset: StatsAsset) => boolean)[];
	excludeModules: ((
		name: string,
		module: StatsModule,
		type: ExcludeModulesType
	) => boolean)[];
	warningsFilter: ((warning: StatsError, textValue: string) => boolean)[];
	cachedModules: boolean;
	orphanModules: boolean;
	dependentModules: boolean;
	runtimeModules: boolean;
	groupModulesByCacheStatus: boolean;
	groupModulesByLayer: boolean;
	groupModulesByAttributes: boolean;
	groupModulesByPath: boolean;
	groupModulesByExtension: boolean;
	groupModulesByType: boolean;
	entrypoints: boolean | "auto";
	chunkGroups: boolean;
	chunkGroupAuxiliary: boolean;
	chunkGroupChildren: boolean;
	chunkGroupMaxAssets: number;
	modulesSpace: number;
	chunkModulesSpace: number;
	nestedModulesSpace: number;
	logging: false | "none" | "verbose" | "error" | "warn" | "info" | "log";
	loggingDebug: ((value: string) => boolean)[];
	loggingTrace: boolean;
}

/**
 * Defines the known records type used by this module.
 */
declare interface KnownRecords {
	aggressiveSplits?: SplitData[];
	chunks?: RecordsChunks;
	modules?: RecordsModules;
	hash?: string;
	hotIndex?: number;
	fullHashChunkModuleHashes?: FullHashChunkModuleHashes;
	chunkModuleHashes?: ChunkModuleHashes;
	chunkHashes?: ChunkHashes;
	chunkRuntime?: ChunkRuntime;
	chunkModuleIds?: ChunkModuleIds;
}

/**
 * Defines the known stats asset type used by this module.
 */
declare interface KnownStatsAsset {
	type: string;
	name: string;
	info: AssetInfo;
	size: number;
	emitted: boolean;
	comparedForEmit: boolean;
	cached: boolean;
	related?: StatsAsset[];
	chunks?: ChunkId[];
	chunkNames?: ChunkName[];
	chunkIdHints?: string[];
	auxiliaryChunks?: ChunkId[];
	auxiliaryChunkNames?: ChunkName[];
	auxiliaryChunkIdHints?: string[];
	filteredRelated?: number;
	isOverSizeLimit?: boolean;
}

/**
 * Defines the known stats chunk type used by this module.
 */
declare interface KnownStatsChunk {
	rendered: boolean;
	initial: boolean;
	entry: boolean;
	recorded: boolean;
	reason?: string;
	size: number;
	sizes: Record<string, number>;
	names: string[];
	idHints: string[];
	runtime?: string[];
	files: string[];
	auxiliaryFiles: string[];
	hash: string;
	childrenByOrder: Record<string, ChunkId[]>;
	id?: string | number;
	siblings?: ChunkId[];
	parents?: ChunkId[];
	children?: ChunkId[];
	modules?: StatsModule[];
	filteredModules?: number;
	origins?: StatsChunkOrigin[];
}

/**
 * Defines the known stats chunk group type used by this module.
 */
declare interface KnownStatsChunkGroup {
	name?: null | string;
	chunks?: ChunkId[];
	assets?: { name: string; size?: number }[];
	filteredAssets?: number;
	assetsSize?: number;
	auxiliaryAssets?: { name: string; size?: number }[];
	filteredAuxiliaryAssets?: number;
	auxiliaryAssetsSize?: number;
	children?: Record<string, StatsChunkGroup[]>;
	childAssets?: Record<string, string[]>;
	isOverSizeLimit?: boolean;
}

/**
 * Defines the known stats chunk origin type used by this module.
 */
declare interface KnownStatsChunkOrigin {
	module: string;
	moduleIdentifier: string;
	moduleName: string;
	loc: string;
	request: string;
	moduleId?: string | number;
}

/**
 * Defines the known stats compilation type used by this module.
 */
declare interface KnownStatsCompilation {
	env?: StatsJsonValue;
	name?: string;
	hash?: string;
	version?: string;
	time?: number;
	builtAt?: number;
	needAdditionalPass?: boolean;
	publicPath?: string;
	outputPath?: string;
	assetsByChunkName?: Record<string, string[]>;
	assets?: StatsAsset[];
	filteredAssets?: number;
	chunks?: StatsChunk[];
	modules?: StatsModule[];
	filteredModules?: number;
	entrypoints?: Record<string, StatsChunkGroup>;
	namedChunkGroups?: Record<string, StatsChunkGroup>;
	errors?: StatsError[];
	errorsCount?: number;
	warnings?: StatsError[];
	warningsCount?: number;
	hints?: StatsError[];
	hintsCount?: number;
	children?: StatsCompilation[];
	logging?: Record<string, StatsLogging>;
	filteredWarningDetailsCount?: number;
	filteredErrorDetailsCount?: number;
}

/**
 * Defines the known stats error type used by this module.
 */
declare interface KnownStatsError {
	message: string;
	chunkName?: string;
	chunkEntry?: boolean;
	chunkInitial?: boolean;
	file?: string;
	moduleIdentifier?: string;
	moduleName?: string;
	loc?: string;
	chunkId?: string | number;
	moduleId?: string | number;
	moduleTrace?: StatsModuleTraceItem[];
	details?: string;
	stack?: string;
	cause?: KnownStatsError;
	errors?: KnownStatsError[];
	compilerPath?: string;
}

/**
 * Defines the known stats factory context type used by this module.
 */
declare interface KnownStatsFactoryContext {
	type: string;
	compilation: Compilation;
	makePathsRelative: (path: string) => string;
	rootModules: Set<Module>;
	compilationFileToChunks: Map<string, Chunk[]>;
	compilationAuxiliaryFileToChunks: Map<string, Chunk[]>;
	runtime: RuntimeSpec;
	cachedGetErrors: (compilation: Compilation) => Error[];
	cachedGetWarnings: (compilation: Compilation) => Error[];
}

/**
 * The `[object, data]` each `extract` key webpack registers receives.
 */
declare interface KnownStatsFactoryExtract {
	compilation: [StatsCompilation, Compilation];
	asset: [StatsAsset, PreprocessedAsset];
	asset$visible: [StatsAsset, PreprocessedAsset];
	chunkGroup: [StatsChunkGroup, ChunkGroupInfoWithName];
	module: [StatsModule, Module];
	module$visible: [StatsModule, Module];
	moduleIssuer: [StatsModuleIssuer, Module];
	profile: [StatsProfile, ModuleProfile];
	moduleReason: [StatsModuleReason, ModuleGraphConnection];
	chunk: [StatsChunk, Chunk];
	chunkOrigin: [StatsChunkOrigin, OriginRecord];
	error: [StatsError, WebpackError];
	warning: [StatsError, WebpackError];
	cause: [StatsError, WebpackError];
	moduleTraceItem: [StatsModuleTraceItem, ModuleTrace];
	moduleTraceDependency: [StatsModuleTraceDependency, Dependency];
}

declare interface KnownStatsFactoryItemFactories {
	compilation: Compilation;
	asset: PreprocessedAsset;
	asset$visible: PreprocessedAsset;
	chunkGroup: ChunkGroupInfoWithName;
	module: Module;
	module$visible: Module;
	moduleIssuer: Module;
	profile: ModuleProfile;
	moduleReason: ModuleGraphConnection;
	chunk: Chunk;
	chunkOrigin: OriginRecord;
	error: WebpackError;
	warning: WebpackError;
	cause: WebpackError;
	moduleTraceItem: ModuleTrace;
	moduleTraceDependency: Dependency;
	"compilation.children[].compilation": Compilation;
}

/**
 * The item `getItemName` receives for each `<array path>[]` key webpack registers.
 */
declare interface KnownStatsFactoryItemNames {
	"compilation.assets[]": PreprocessedAsset;
	"compilation.chunks[]": Chunk;
	"compilation.modules[]": Module;
	"compilation.entrypoints[]": ChunkGroupInfoWithName;
	"compilation.namedChunkGroups[]": ChunkGroupInfoWithName;
	"compilation.errors[]": Error;
	"compilation.warnings[]": Error;
	"compilation.hints[]": Error;
	"compilation.children[]": Compilation;
	"asset.related[]": PreprocessedAsset;
	"error.errors[]": Error;
	"warning.errors[]": Error;
	"chunk.modules[]": Module;
	"chunk.rootModules[]": Module;
	"chunk.origins[]": OriginRecord;
	"module.issuerPath[]": Module;
	"module.reasons[]": ModuleGraphConnection;
	"module.modules[]": Module;
	"module.children[]": Module;
	"moduleTrace[]": ModuleTrace;
	"moduleTraceItem.dependencies[]": Dependency;
}
declare interface KnownStatsFactoryRawItems {
	"compilation.assets": PreprocessedAsset;
	"compilation.chunks": Chunk;
	"compilation.modules": Module;
	"compilation.entrypoints": ChunkGroupInfoWithName;
	"compilation.namedChunkGroups": ChunkGroupInfoWithName;
	"compilation.errors": Error;
	"compilation.warnings": Error;
	"compilation.hints": Error;
	"compilation.children": Compilation;
	"asset.related": PreprocessedAsset;
	"error.errors": Error;
	"warning.errors": Error;
	"chunk.modules": Module;
	"chunk.rootModules": Module;
	"chunk.origins": OriginRecord;
	"module.issuerPath": Module;
	"module.reasons": ModuleGraphConnection;
	"module.modules": Module;
	"module.children": Module;
	moduleTrace: ModuleTrace;
	"moduleTraceItem.dependencies": Dependency;
}
declare interface KnownStatsFactoryResultItems {
	"compilation.assets": StatsAsset;
	"compilation.chunks": StatsChunk;
	"compilation.modules": StatsModule;
	"compilation.entrypoints": StatsChunkGroup;
	"compilation.namedChunkGroups": StatsChunkGroup;
	"compilation.errors": StatsError;
	"compilation.warnings": StatsError;
	"compilation.hints": StatsError;
	"compilation.children": StatsCompilation;
	"asset.related": StatsAsset;
	"error.errors": StatsError;
	"warning.errors": StatsError;
	"chunk.modules": StatsModule;
	"chunk.rootModules": StatsModule;
	"chunk.origins": StatsChunkOrigin;
	"module.issuerPath": StatsModuleIssuer;
	"module.reasons": StatsModuleReason;
	"module.modules": StatsModule;
	"module.children": StatsModule;
	moduleTrace: StatsModuleTraceItem;
	"moduleTraceItem.dependencies": StatsModuleTraceDependency;
}

declare interface KnownStatsFactoryResults {
	compilation: StatsCompilation;
	asset: StatsAsset;
	asset$visible: StatsAsset;
	chunkGroup: StatsChunkGroup;
	module: StatsModule;
	module$visible: StatsModule;
	moduleIssuer: StatsModuleIssuer;
	profile: StatsProfile;
	moduleReason: StatsModuleReason;
	chunk: StatsChunk;
	chunkOrigin: StatsChunkOrigin;
	error: StatsError;
	warning: StatsError;
	cause: StatsError;
	moduleTraceItem: StatsModuleTraceItem;
	moduleTraceDependency: StatsModuleTraceDependency;
	moduleTrace: StatsModuleTraceItem[];
	"compilation.assets": StatsAsset[];
	"compilation.chunks": StatsChunk[];
	"compilation.modules": StatsModule[];
	"compilation.errors": StatsError[];
	"compilation.warnings": StatsError[];
	"compilation.hints": StatsError[];
	"compilation.children": StatsCompilation[];
	"asset.related": StatsAsset[];
	"error.errors": StatsError[];
	"warning.errors": StatsError[];
	"chunk.modules": StatsModule[];
	"chunk.rootModules": StatsModule[];
	"chunk.origins": StatsChunkOrigin[];
	"module.issuerPath": StatsModuleIssuer[];
	"module.reasons": StatsModuleReason[];
	"module.modules": StatsModule[];
	"module.children": StatsModule[];
	"moduleTraceItem.dependencies": StatsModuleTraceDependency[];
	"compilation.entrypoints": Record<string, StatsChunkGroup>;
	"compilation.namedChunkGroups": Record<string, StatsChunkGroup>;
}

/**
 * Defines the known stats logging type used by this module.
 */
declare interface KnownStatsLogging {
	entries: StatsLoggingEntry[];
	filteredEntries: number;
	debug: boolean;
}

/**
 * Defines the known stats logging entry type used by this module.
 */
declare interface KnownStatsLoggingEntry {
	type: string;
	message?: string;
	trace?: string[];
	children?: StatsLoggingEntry[];
	args?: any[];
	time?: number;
}

/**
 * Defines the known stats module type used by this module.
 */
declare interface KnownStatsModule {
	type?: string;
	moduleType?: string;
	layer?: null | string;
	identifier?: string;
	name?: string;
	nameForCondition?: null | string;
	index?: number;
	preOrderIndex?: number;
	index2?: number;
	postOrderIndex?: number;
	size?: number;
	sizes?: Record<string, number>;
	cacheable?: boolean;
	notCacheableReasons?: string[];
	built?: boolean;
	codeGenerated?: boolean;
	buildTimeExecuted?: boolean;
	cached?: boolean;
	optional?: boolean;
	orphan?: boolean;
	id?: string | number;
	issuerId?: null | string | number;
	chunks?: ChunkId[];
	assets?: string[];
	dependent?: boolean;
	issuer?: null | string;
	issuerName?: null | string;
	issuerPath?: null | StatsModuleIssuer[];
	failed?: boolean;
	errors?: number;
	warnings?: number;
	profile?: StatsProfile;
	reasons?: StatsModuleReason[];
	usedExports?: null | boolean | string[];
	providedExports?: null | string[];
	optimizationBailout?: string[];
	depth?: null | number;
	modules?: StatsModule[];
	filteredModules?: number;
	source?: string | Buffer;
}

/**
 * Defines the known stats module issuer type used by this module.
 */
declare interface KnownStatsModuleIssuer {
	identifier: string;
	name: string;
	id?: string | number;
	profile: StatsProfile;
}

/**
 * Defines the known stats module reason type used by this module.
 */
declare interface KnownStatsModuleReason {
	moduleIdentifier: null | string;
	module: null | string;
	moduleName: null | string;
	resolvedModuleIdentifier: null | string;
	resolvedModule: null | string;
	type: null | string;
	active: boolean;
	explanation: null | string;
	userRequest: null | string;
	loc?: null | string;
	moduleId?: null | string | number;
	resolvedModuleId?: null | string | number;
}

/**
 * Defines the known stats module trace dependency type used by this module.
 */
declare interface KnownStatsModuleTraceDependency {
	loc?: string;
}

/**
 * Defines the known stats module trace item type used by this module.
 */
declare interface KnownStatsModuleTraceItem {
	originIdentifier?: string;
	originName?: string;
	moduleIdentifier?: string;
	moduleName?: string;
	dependencies?: StatsModuleTraceDependency[];
	originId?: string | number;
	moduleId?: string | number;
}

/**
 * The item `getItemName` receives for each `<array path>[]` key of `KnownStatsPrintItems`.
 */
declare interface KnownStatsPrintItemNames {
	"compilation.assets[]": StatsAsset;
	"compilation.modules[]": StatsModule;
	"compilation.chunks[]": StatsChunk;
	"compilation.entrypoints[]": StatsChunkGroup;
	"compilation.namedChunkGroups[]": StatsChunkGroup;
	"compilation.errors[]": StatsError;
	"compilation.warnings[]": StatsError;
	"compilation.hints[]": StatsError;
	"compilation.logging[]": KnownStatsLogging &
		Record<string, StatsJsonValue> & { name: string };
	"compilation.children[]": StatsCompilation;
	"asset.related[]": StatsAsset;
	"asset.children[]": StatsAsset;
	"module.modules[]": StatsModule;
	"module.children[]": StatsModule;
	"module.reasons[]": StatsModuleReason;
	"moduleReason.children[]": StatsModuleReason;
	"module.issuerPath[]": StatsModuleIssuer;
	"chunk.origins[]": StatsChunkOrigin;
	"chunk.modules[]": StatsModule;
	"loggingGroup.entries[]": StatsLoggingEntry;
	"loggingEntry.children[]": StatsLoggingEntry;
	"error.moduleTrace[]": StatsModuleTraceItem;
	"error.errors[]": StatsError;
	"moduleTraceItem.dependencies[]": StatsModuleTraceDependency;
}

/**
 * The item of each array path webpack prints stats objects for.
 */
declare interface KnownStatsPrintItems {
	"compilation.assets": StatsAsset;
	"compilation.modules": StatsModule;
	"compilation.chunks": StatsChunk;
	"compilation.entrypoints": StatsChunkGroup;
	"compilation.namedChunkGroups": StatsChunkGroup;
	"compilation.errors": StatsError;
	"compilation.warnings": StatsError;
	"compilation.hints": StatsError;
	"compilation.logging": KnownStatsLogging &
		Record<string, StatsJsonValue> & { name: string };
	"compilation.children": StatsCompilation;
	"asset.related": StatsAsset;
	"asset.children": StatsAsset;
	"module.modules": StatsModule;
	"module.children": StatsModule;
	"module.reasons": StatsModuleReason;
	"moduleReason.children": StatsModuleReason;
	"module.issuerPath": StatsModuleIssuer;
	"chunk.origins": StatsChunkOrigin;
	"chunk.modules": StatsModule;
	"loggingGroup.entries": StatsLoggingEntry;
	"loggingEntry.children": StatsLoggingEntry;
	"error.moduleTrace": StatsModuleTraceItem;
	"error.errors": StatsError;
	"moduleTraceItem.dependencies": StatsModuleTraceDependency;
}

/**
 * The value `print` receives for each object key webpack prints; the key also matches same-named fields.
 */
declare interface KnownStatsPrintObjects {
	compilation: StatsCompilation;
	asset: StatsAsset;
	chunk: StatsChunk;
	chunkGroup: StatsChunkGroup;
	module: null | string | StatsModule;
	moduleReason: StatsModuleReason;
	moduleIssuer: StatsModuleIssuer;
	chunkOrigin: StatsChunkOrigin;
	error: StatsError;
	profile: StatsProfile;
	loggingGroup: KnownStatsLogging &
		Record<string, StatsJsonValue> & { name: string };
	moduleTraceItem: StatsModuleTraceItem;
	moduleTraceDependency: StatsModuleTraceDependency;
}

/**
 * Defines the known stats printer color functions type used by this module.
 */
declare interface KnownStatsPrinterColorFunctions {
	bold?: (value: string | number) => string;
	yellow?: (value: string | number) => string;
	red?: (value: string | number) => string;
	green?: (value: string | number) => string;
	magenta?: (value: string | number) => string;
	cyan?: (value: string | number) => string;
}

/**
 * Defines the known stats printer context type used by this module.
 */
declare interface KnownStatsPrinterContext {
	type?: string;
	compilation?: StatsCompilation;
	chunkGroup?: StatsChunkGroup;
	chunkGroupKind?: string;
	asset?: StatsAsset;
	module?: StatsModule;
	chunk?: StatsChunk;
	moduleReason?: StatsModuleReason;
	moduleIssuer?: StatsModuleIssuer;
	error?: StatsError;
	profile?: StatsProfile;
	logging?: StatsLogging;
	moduleTraceItem?: StatsModuleTraceItem;
	moduleTraceDependency?: StatsModuleTraceDependency;
}

/**
 * Defines the known stats printer formatters type used by this module.
 */
declare interface KnownStatsPrinterFormatters {
	formatFilename?: (file: string, oversize?: boolean) => string;
	formatModuleId?: (id: string | number) => string;
	formatChunkId?: (
		id: string | number,
		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;
	formatError?: (message: string) => string;
}

/**
 * Defines the known stats profile type used by this module.
 */
declare interface KnownStatsProfile {
	total: number;
	resolving: number;
	restoring: number;
	building: number;
	integration: number;
	storing: number;
	additionalResolving: number;
	additionalIntegration: number;
	factory: number;
	dependencies: number;
}

/**
 * Defines the build meta properties specific to sync wasm modules.
 */
declare interface KnownSyncWasmModuleBuildMeta {
	jsIncompatibleExports?: Record<string, string>;
}

/**
 * Defines the known unsafe cache data type used by this module.
 */
declare interface KnownUnsafeCacheData {
	/**
	 * factory meta
	 */
	factoryMeta?: FactoryMeta;

	/**
	 * resolve options
	 */
	resolveOptions?: ResolveOptionsWebpackOptions;
	parserOptions?: ParserOptionsNormalModule;
	generatorOptions?: GeneratorOptions;
}
declare const LEGACY_ASSERT_ATTRIBUTES: unique symbol;

/**
 * Describes the l stat shape.
 */
declare interface LStatFs {
	(
		path: PathLikeFs,
		callback: (err: null | NodeJS.ErrnoException, result?: IStatsFs) => void
	): void;
	(
		path: PathLikeFs,
		options: undefined | (StatOptionsFs & { bigint?: false }),
		callback: (err: null | NodeJS.ErrnoException, result?: IStatsFs) => void
	): void;
	(
		path: PathLikeFs,
		options: StatOptionsFs & { bigint: true },
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IBigIntStatsFs
		) => void
	): void;
	(
		path: PathLikeFs,
		options: undefined | StatOptionsFs,
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IStatsFs | IBigIntStatsFs
		) => void
	): void;
}
declare interface LStatResolver {
	(
		path: PathLikeResolver,
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IStatsResolver
		) => void
	): void;
	(
		path: PathLikeResolver,
		options: undefined | (StatOptionsResolver & { bigint?: false }),
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IStatsResolver
		) => void
	): void;
	(
		path: PathLikeResolver,
		options: StatOptionsResolver & { bigint: true },
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IBigIntStatsResolver
		) => void
	): void;
	(
		path: PathLikeResolver,
		options: undefined | StatOptionsResolver,
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IStatsResolver | IBigIntStatsResolver
		) => void
	): void;
}

/**
 * Describes the l stat sync shape.
 */
declare interface LStatSync {
	(path: PathLikeFs): IStatsFs;
	(
		path: PathLikeFs,
		options?: StatSyncOptions & { bigint?: false; throwIfNoEntry?: true }
	): IStatsFs;
	(
		path: PathLikeFs,
		options: StatSyncOptions & { bigint: true; throwIfNoEntry?: true }
	): IBigIntStatsFs;
	(
		path: PathLikeFs,
		options?: StatSyncOptions & { bigint?: false; throwIfNoEntry: false }
	): undefined | IStatsFs;
	(
		path: PathLikeFs,
		options: StatSyncOptions & { bigint: true; throwIfNoEntry: false }
	): undefined | IBigIntStatsFs;
	(
		path: PathLikeFs,
		options: StatSyncOptions & { bigint: boolean; throwIfNoEntry?: true }
	): IStatsFs | IBigIntStatsFs;
	(
		path: PathLikeFs,
		options?: StatSyncOptions
	): undefined | IStatsFs | IBigIntStatsFs;
}

/**
 * A label in scope, and what may jump to it.
 */
declare class Label {
	constructor(kind: null | string, name?: string, statementStart?: number);
	kind?: null | string;
	name?: string;
	statementStart?: number;
}

/**
 * a label in scope, as any caller may hold one
 */
declare interface LabelLike {
	kind?: null | string;
	name?: string;
	statementStart?: number;
}

/**
 * Options for the default backend.
 */
declare interface LazyCompilationDefaultBackendOptions {
	/**
	 * A custom client.
	 */
	client?: string;

	/**
	 * Specifies where to listen to from the server.
	 */
	listen?:
		number | ListenOptions | ((server: ServerLazyCompilationBackend) => void);

	/**
	 * Specifies the protocol the client should use to connect to the server.
	 */
	protocol?: "http" | "https";

	/**
	 * Specifies how to create the server handling the EventSource requests.
	 */
	server?:
		| ServerOptionsImportHttps
		| ServerOptionsImportHttp
		| (() => ServerLazyCompilationBackend);
}

/**
 * Options for compiling entrypoints and import()s only when they are accessed.
 */
declare interface LazyCompilationOptions {
	/**
	 * Specifies the backend that should be used for handling client keep alive.
	 */
	backend?:
		| ((
				compiler: Compiler,
				callback: (err: null | Error, backendApi?: BackendApi) => void
		  ) => void)
		| ((compiler: Compiler) => Promise<BackendApi>)
		| LazyCompilationDefaultBackendOptions;

	/**
	 * Enable/disable lazy compilation for entries.
	 */
	entries?: boolean;

	/**
	 * Enable/disable lazy compilation for import() modules.
	 */
	imports?: boolean;

	/**
	 * Specify which entrypoints or import()ed modules should be lazily compiled. This is matched with the imported module and not the entrypoint name.
	 */
	test?: string | RegExp | GlobCondition | ((module: Module) => boolean);
}
type LazyFunction<
	InputValue,
	OutputValue,
	InternalLazyTarget extends SerializerMiddleware,
	InternalLazyOptions extends undefined | LazyOptions
> = (() => InputValue | Promise<InputValue>) &
	Partial<{ options: InternalLazyOptions }>;
declare interface LazyOptions {
	name?: string;
	size?: number;
}

/**
 * Like Set but with an addAll method to eventually add items from another iterable.
 * Access methods make sure that all delayed operations are executed.
 * Iteration methods deopts to normal Set performance until clear is called again (because of the chance of modifications during iteration).
 */
declare class LazySet<T> {
	/**
	 * Seeds the set with an optional iterable while preparing internal queues for
	 * deferred merges.
	 */
	constructor(iterable?: Iterable<T>);

	/**
	 * Returns the number of items after applying any deferred merges.
	 */
	get size(): number;

	/**
	 * Adds a single item immediately to the concrete backing set.
	 */
	add(item: T): LazySet<T>;

	/**
	 * Queues another iterable or lazy set for later merging so large bulk adds
	 * can stay cheap until the set is read.
	 */
	addAll(iterable: LazySet<T> | Iterable<T>): LazySet<T>;

	/**
	 * Removes all items and clears every deferred merge queue.
	 */
	clear(): void;

	/**
	 * Deletes an item after first materializing any deferred additions that may
	 * contain it.
	 */
	delete(value: T): boolean;

	/**
	 * Returns the set's entry iterator and permanently switches future
	 * operations to eager merge mode to preserve iterator correctness.
	 */
	entries(): SetIterator<[T, T]>;

	/**
	 * Iterates over every item after forcing pending merges and switching to
	 * eager mode for correctness during iteration.
	 */
	forEach<K>(
		callbackFn: (value: T, value2: T, set: Set<T>) => void,
		thisArg: K
	): void;

	/**
	 * Checks whether an item is present after applying any deferred merges.
	 */
	has(item: T): boolean;

	/**
	 * Returns the key iterator, eagerly materializing pending merges first.
	 */
	keys(): SetIterator<T>;

	/**
	 * Returns the value iterator, eagerly materializing pending merges first.
	 */
	values(): SetIterator<T>;

	/**
	 * Serializes the fully materialized set contents into webpack's object
	 * serialization stream.
	 */
	serialize(
		__0: ObjectSerializerContextObjectMiddlewareObject_3<(number | T)[]>
	): void;

	/**
	 * Returns the default iterator over values after forcing pending merges.
	 */
	[Symbol.iterator](): SetIterator<T>;

	/**
	 * Restores a `LazySet` from serialized item data.
	 */
	static deserialize<T>(
		__0: ObjectDeserializerContextObjectMiddlewareObject_2<(number | T)[]>
	): LazySet<T>;
}

/**
 * Defines the lib ident options type used by this module.
 */
declare interface LibIdentOptions {
	/**
	 * absolute context path to which lib ident is relative to
	 */
	context: string;

	/**
	 * object for caching
	 */
	associatedObjectForCache?: object;
}
declare class LibManifestPlugin {
	/**
	 * Creates an instance of LibManifestPlugin.
	 */
	constructor(options: LibManifestPluginOptions);
	options: LibManifestPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the lib manifest plugin options type used by this module.
 */
declare interface LibManifestPluginOptions {
	/**
	 * Context of requests in the manifest file (defaults to the webpack context).
	 */
	context?: string;

	/**
	 * If true, only entry points will be exposed (default: true).
	 */
	entryOnly?: boolean;

	/**
	 * If true, manifest json file (output) will be formatted.
	 */
	format?: boolean;

	/**
	 * Name of the exposed dll function (external name, use value of 'output.library').
	 */
	name?: string;

	/**
	 * Absolute path to the manifest json file (output).
	 */
	path: string;

	/**
	 * Type of the dll bundle (external type, use value of 'output.libraryTarget').
	 */
	type?: string;
}

/**
 * Defines the library context type used by this module.
 */
declare interface LibraryContext<T> {
	compilation: Compilation;
	chunkGraph: ChunkGraph;
	options: T;
}

/**
 * Set explicit comments for `commonjs`, `commonjs2`, `amd`, and `root`.
 */
declare interface LibraryCustomUmdCommentObject {
	/**
	 * Set comment for `amd` section in UMD.
	 */
	amd?: string;

	/**
	 * Set comment for `commonjs` (exports) section in UMD.
	 */
	commonjs?: string;

	/**
	 * Set comment for `commonjs2` (module.exports) section in UMD.
	 */
	commonjs2?: string;

	/**
	 * Set comment for `root` (global variable) section in UMD.
	 */
	root?: string;
}

/**
 * Description object for all UMD variants of the library name.
 */
declare interface LibraryCustomUmdObject {
	/**
	 * Name of the exposed AMD library in the UMD.
	 */
	amd?: string;

	/**
	 * Name of the exposed commonjs export in the UMD.
	 */
	commonjs?: string;

	/**
	 * Name of the property exposed globally by a UMD library.
	 */
	root?: string | string[];
}
type LibraryExport = string | string[];
type LibraryName = string | string[] | LibraryCustomUmdObject;

/**
 * Options for library.
 */
declare interface LibraryOptions {
	/**
	 * Add a container for define/require functions in the AMD module.
	 */
	amdContainer?: string;

	/**
	 * Add a comment in the UMD wrapper.
	 */
	auxiliaryComment?: string | LibraryCustomUmdCommentObject;

	/**
	 * Which modules of an entry the library exposes the exports of: only the last one, or all of them, where a name more than one module binds differently is left out, as 'export *' does.
	 * @since 5.112.0
	 */
	entryExports?: "last" | "all";

	/**
	 * Specify which export should be exposed as library.
	 */
	export?: string | string[];

	/**
	 * The name of the library (some types allow unnamed libraries too).
	 */
	name?: string | string[] | LibraryCustomUmdObject;

	/**
	 * Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'commonjs-static', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).
	 */
	type: string;

	/**
	 * Add a branch to the UMD wrapper for an AMD-style loader exposing `define` on a container object, given as a dot-separated path, after the `define.amd` branch.
	 * @since 5.110.0
	 */
	umdAmdContainer?: string;

	/**
	 * If `output.libraryTarget` is set to umd and `output.library` is set, setting this to true will name the AMD module.
	 */
	umdNamedDefine?: boolean;
}
declare class LibraryTemplatePlugin {
	/**
	 * Creates an instance of LibraryTemplatePlugin.
	 */
	constructor(
		name: LibraryName,
		target: string,
		umdNamedDefine: boolean,
		auxiliaryComment: AuxiliaryComment,
		exportProperty: LibraryExport
	);
	library: {
		type: string;
		name: LibraryName;
		umdNamedDefine: boolean;
		auxiliaryComment: AuxiliaryComment;
		export: LibraryExport;
	};

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare class LimitChunkCountPlugin {
	/**
	 * Creates an instance of LimitChunkCountPlugin.
	 */
	constructor(options?: LimitChunkCountPluginOptions);
	options: LimitChunkCountPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface LimitChunkCountPluginOptions {
	/**
	 * Constant overhead for a chunk.
	 */
	chunkOverhead?: number;

	/**
	 * Multiplicator for initial chunks.
	 */
	entryChunkMultiplicator?: number;

	/**
	 * Limit the maximum number of chunks using a value greater than or equal to 1.
	 */
	maxChunks: number;
}

/**
 * A module-level `let` a module library declares in the chunk's scope instead.
 */
declare interface LiveBinding {
	/**
	 * the name the chunk's scope declares
	 */
	name: string;

	/**
	 * the keys of the runtimes declaring it
	 */
	runtimes: Set<string>;

	/**
	 * the keys of the runtimes where a module mirrors it through the setters a module library registers, not by name
	 */
	registered: Set<string>;
}
declare interface LoadScriptCompilationHooks {
	createScript: SyncWaterfallHook<[string, Chunk], string>;
}
declare class LoadScriptRuntimeModule extends HelperRuntimeModule {
	constructor(withCreateScriptUrl?: boolean, withFetchPriority?: boolean);
	static getCompilationHooks: (
		compilation: Compilation
	) => LoadScriptCompilationHooks;

	/**
	 * The answer a runtime module gives when it installs no chunk handler at all
	 */
	static NO_CHUNK_HANDLERS: [string, string][];

	/**
	 * Runtime modules without any dependencies to other runtime modules
	 */
	static STAGE_NORMAL: number;

	/**
	 * Runtime modules with simple dependencies on other runtime modules
	 */
	static STAGE_BASIC: number;

	/**
	 * Runtime modules which attach to handlers of other runtime modules
	 */
	static STAGE_ATTACH: number;

	/**
	 * Runtime modules which trigger actions on bootstrap
	 */
	static STAGE_TRIGGER: number;
	static KINDS: Set<
		| "html"
		| "runtime"
		| "normal"
		| "css"
		| "context"
		| "remote"
		| "consume-shared"
		| "external"
		| "concatenated"
	>;

	/**
	 * Gets source basic types.
	 * @deprecated In the next major release, call getSourceBasicTypes() directly on the module instance instead of using this static method.
	 */
	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
}

/**
 * Custom values available in the loader context.
 */
declare interface Loader {
	[index: string]: any;
}
type LoaderContextLibIndex<OptionsType> =
	NormalModuleLoaderContext<OptionsType> &
		LoaderRunnerMutableContext<OptionsType> &
		LoaderRunnerReadonlyContext<OptionsType, LoaderData> &
		LoaderPluginLoaderContext &
		HotModuleReplacementPluginLoaderContext;
type LoaderContextNormalModule<
	T,
	DataType = LoaderData
> = NormalModuleLoaderContext<T> &
	LoaderRunnerMutableContext<T> &
	LoaderRunnerReadonlyContext<T, DataType> &
	LoaderPluginLoaderContext &
	HotModuleReplacementPluginLoaderContext;
declare interface LoaderContextUtils {
	/**
	 * returns a new request string using absolute paths when possible
	 */
	absolutify: (context: string, request: string) => string;

	/**
	 * returns a new request string avoiding absolute paths when possible
	 */
	contextify: (context: string, request: string) => string;

	/**
	 * creates a hash with the compilation's function
	 */
	createHash: (algorithm?: string | typeof Hash) => Hash;
}

/**
 * What a loader keeps between its pitch and normal phase. Open by default: a
 * loader stores whatever it likes, and reads it back without narrowing.
 */
declare interface LoaderData {
	[index: string]: any;
}
type LoaderDefinition<
	OptionsType = {},
	ContextAdditions = {}
> = LoaderDefinitionFunction<OptionsType, ContextAdditions> & {
	raw?: false;
	pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
};
declare interface LoaderDefinitionFunction<
	OptionsType = {},
	ContextAdditions = {}
> {
	(
		this: NormalModuleLoaderContext<OptionsType> &
			LoaderRunnerMutableContext<OptionsType> &
			LoaderRunnerReadonlyContext<OptionsType, LoaderData> &
			LoaderPluginLoaderContext &
			HotModuleReplacementPluginLoaderContext &
			ContextAdditions,
		content: string,
		sourceMap?: string | RawSourceMap,
		additionalData?: AdditionalData
	): string | void | Buffer | Promise<string | Buffer>;
}
declare interface LoaderEntry<
	OptionsType = Record<string, any>,
	DataType = LoaderData
> {
	request: string;
	path: string;
	query: string;
	fragment: string;
	options?: null | string | OptionsType;
	ident: string;
	normal?:
		| LoaderDefinitionFunction<OptionsType, {}>
		| RawLoaderDefinitionFunction<OptionsType, {}>;
	pitch?: PitchLoaderDefinitionFunction<OptionsType, {}>;
	raw?: boolean;
	data?: DataType;
	pitchExecuted: boolean;
	normalExecuted: boolean;
	type?: "module" | "commonjs";
}
declare interface LoaderItem {
	loader: string;
	options?: null | string | Record<string, any>;
	ident?: null | string;
	type?: null | string;
}

/**
 * The loader-authoring types, re-exported here because this file is what
 * `generate-types.js` reads webpack's public type surface from
 */
declare interface LoaderModule<OptionsType = {}, ContextAdditions = {}> {
	default?:
		| RawLoaderDefinitionFunction<OptionsType, ContextAdditions>
		| LoaderDefinitionFunction<OptionsType, ContextAdditions>;
	raw?: false;
	pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
}
declare class LoaderOptionsPlugin {
	/**
	 * Creates an instance of LoaderOptionsPlugin.
	 */
	constructor(
		options?: LoaderOptionsPluginOptions & MatchObject & Record<string, any>
	);
	options: LoaderOptionsPluginOptions & MatchObject & Record<string, any>;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * A configuration object that can be used to configure older loaders.
 */
declare interface LoaderOptionsPluginLoaderOptions {
	/**
	 * The context that can be used to configure older loaders.
	 */
	context?: string;
}
declare interface LoaderOptionsPluginOptions {
	/**
	 * Whether loaders should be in debug mode or not. debug will be removed as of webpack 3.
	 */
	debug?: boolean;

	/**
	 * Where loaders can be switched to minimize mode.
	 */
	minimize?: boolean;
	options?: LoaderOptionsPluginLoaderOptions & Record<string, any>;
}

/**
 * These properties are added by the LoaderPlugin
 */
declare interface LoaderPluginLoaderContext {
	/**
	 * Resolves the given request to a module, applies all configured loaders and calls
	 * back with the generated source, the sourceMap and the module instance (usually an
	 * instance of NormalModule). Use this function if you need to know the source code
	 * of another module to generate the result.
	 */
	loadModule: (
		request: string,
		callback: (
			err: null | Error,
			source?: string | Buffer,
			sourceMap?: null | object,
			module?: Module
		) => void
	) => void;
	importModule: ImportModuleMethod;
}
declare interface LoaderRunnerMutableContext<OptionsType> {
	/**
	 * Add a directory as dependency of the loader result.
	 */
	addContextDependency: (context: string) => void;

	/**
	 * Adds a file as dependency of the loader result in order to make them watchable.
	 * For example, html-loader uses this technique as it finds src and src-set attributes.
	 * Then, it sets the url's for those attributes as dependencies of the html file that is parsed.
	 */
	addDependency: (file: string) => void;
	addMissingDependency: (context: string) => void;

	/**
	 * Make this loader async.
	 */
	async: () => (
		err?: null | Error,
		content?: string | Buffer,
		sourceMap?: null | string | RawSourceMap,
		additionalData?: AdditionalData
	) => void;

	/**
	 * Make this loader result cacheable. By default it's cacheable.
	 * A cacheable loader must have a deterministic result, when inputs and dependencies haven't changed.
	 * This means the loader shouldn't have other dependencies than specified with this.addDependency.
	 * Most loaders are deterministic and cacheable.
	 */
	cacheable: (flag?: boolean) => void;
	callback: (
		err?: null | Error,
		content?: string | Buffer,
		sourceMap?: null | string | RawSourceMap,
		additionalData?: AdditionalData
	) => void;

	/**
	 * Remove all dependencies of the loader result. Even initial dependencies and these of other loaders.
	 */
	clearDependencies: () => void;

	/**
	 * The directory of the module. Can be used as context for resolving other stuff.
	 * eg '/workspaces/ts-loader/examples/vanilla/src'
	 */
	context: string;

	/**
	 * alias of addDependency
	 * Adds a file as dependency of the loader result in order to make them watchable.
	 * For example, html-loader uses this technique as it finds src and src-set attributes.
	 * Then, it sets the url's for those attributes as dependencies of the html file that is parsed.
	 */
	dependency: (file: string) => void;
	getContextDependencies: () => string[];
	getDependencies: () => string[];
	getMissingDependencies: () => string[];

	/**
	 * The index in the loaders array of the current loader.
	 * In the example: in loader1: 0, in loader2: 1
	 */
	loaderIndex: number;

	/**
	 * An array of all the loaders. It is writeable in the pitch phase.
	 * loaders = [{request: string, path: string, query: string, module: function}]
	 */
	loaders: LoaderEntry<Record<string, any>, LoaderData>[];

	/**
	 * The resource path.
	 * In the example: "/abc/resource.js"
	 */
	resourcePath: string;

	/**
	 * The resource query string.
	 * Example: "?query"
	 */
	resourceQuery: string;

	/**
	 * The resource fragment.
	 * Example: "#frag"
	 */
	resourceFragment: string;

	/**
	 * The resource inclusive query and fragment.
	 * Example: "/abc/resource.js?query#frag"
	 */
	resource: string;

	/**
	 * Target of compilation.
	 * Example: "web"
	 */
	target: string;

	/**
	 * Tell what kind of ES-features may be used in the generated runtime-code.
	 * Example: { arrowFunction: true }
	 */
	environment: Environment;
}

/**
 * The members the runner never lets a loader assign. They carry no
 * documentation, so a type literal loses nothing and keeps `readonly`
 */
declare interface LoaderRunnerReadonlyContext<
	OptionsType,
	DataType = LoaderData
> {
	readonly currentRequest: string;
	readonly data: DataType;
	readonly previousRequest: string;
	readonly query: string | OptionsType;
	readonly remainingRequest: string;
	readonly request: string;
}
declare class LoaderTargetPlugin {
	/**
	 * Creates an instance of LoaderTargetPlugin.
	 */
	constructor(target: string);
	target: string;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare abstract class LocConverter {
	line: number;
	column: number;
	pos: number;

	/**
	 * Returns location converter.
	 */
	get(pos: number): LocConverter;
}
declare abstract class LocalModule {
	name: string;
	idx: number;
	used: boolean;
	flagUsed(): void;

	/**
	 * Returns variable name.
	 */
	variableName(): string;

	/**
	 * Serializes this instance into the provided serializer context.
	 */
	serialize(context: ObjectSerializerContextObjectMiddlewareObject_1): void;

	/**
	 * Restores this instance from the provided deserializer context.
	 */
	deserialize(context: ObjectDeserializerContextObjectMiddlewareObject_3): void;
}

/**
 * Defines the log entry type used by this module.
 */
declare interface LogEntry {
	type:
		| "error"
		| "warn"
		| "info"
		| "log"
		| "debug"
		| "clear"
		| "profile"
		| "trace"
		| "group"
		| "groupCollapsed"
		| "groupEnd"
		| "profileEnd"
		| "time"
		| "status";
	args?: any[];
	time: number;
	trace?: string[];
}
type LogTypeEnum =
	| "error"
	| "warn"
	| "info"
	| "log"
	| "debug"
	| "clear"
	| "profile"
	| "trace"
	| "group"
	| "groupCollapsed"
	| "groupEnd"
	| "profileEnd"
	| "time"
	| "status";
declare abstract class Logger {
	getChildLogger: (name: string | (() => string)) => Logger;

	/**
	 * Processes the provided arg.
	 */
	error(...args: any[]): void;

	/**
	 * Processes the provided arg.
	 */
	warn(...args: any[]): void;

	/**
	 * Processes the provided arg.
	 */
	info(...args: any[]): void;

	/**
	 * Processes the provided arg.
	 */
	log(...args: any[]): void;

	/**
	 * Processes the provided arg.
	 */
	debug(...args: any[]): void;

	/**
	 * Processes the provided condition.
	 */
	assert(condition: undefined | boolean, ...args: any[]): void;
	trace(): void;
	clear(): void;

	/**
	 * Processes the provided arg.
	 */
	status(...args: any[]): void;

	/**
	 * Processes the provided arg.
	 */
	group(...args: any[]): void;

	/**
	 * Processes the provided arg.
	 */
	groupCollapsed(...args: any[]): void;
	groupEnd(): void;

	/**
	 * Processes the provided label.
	 */
	profile(label?: string): void;

	/**
	 * Processes the provided label.
	 */
	profileEnd(label?: string): void;

	/**
	 * Processes the provided label.
	 */
	time(label: string): void;

	/**
	 * Processes the provided label.
	 */
	timeLog(label?: string): void;

	/**
	 * Processes the provided label.
	 */
	timeEnd(label?: string): void;

	/**
	 * Processes the provided label.
	 */
	timeAggregate(label?: string): void;

	/**
	 * Time aggregate end.
	 */
	timeAggregateEnd(label?: string): void;
}
declare const MEASURE_END_OPERATION: unique symbol;
declare const MEASURE_START_OPERATION: unique symbol;
declare const MODULE_DECLARATIONS: unique symbol;

/**
 * Magic comment options by name; each value is whatever the user's comment evaluates to.
 */
declare interface MagicCommentOptions {
	[index: string]: any;
}

/**
 * Defines the main render context type used by this module.
 */
declare interface MainRenderContext {
	/**
	 * the chunk
	 */
	chunk: Chunk;

	/**
	 * the dependency templates
	 */
	dependencyTemplates: DependencyTemplates;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * results of code generation
	 */
	codeGenerationResults: CodeGenerationResults;

	/**
	 * hash to be used for render call
	 */
	hash: string;

	/**
	 * rendering in strict context
	 */
	strictMode?: boolean;
}
declare abstract class MainTemplate {
	hooks: Readonly<{
		renderManifest: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					renderManifestEntries: RenderManifestEntry[],
					renderManifestOptions: RenderManifestOptions
				) => RenderManifestEntry[]
			) => void;
		};
		modules: { tap: () => never };
		moduleObj: { tap: () => never };
		require: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					value: string,
					renderBootstrapContext: RenderBootstrapContext
				) => string
			) => void;
		};
		beforeStartup: { tap: () => never };
		startup: { tap: () => never };
		afterStartup: { tap: () => never };
		render: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					source: Source,
					chunk: Chunk,
					hash: undefined | string,
					moduleTemplate: ModuleTemplate,
					dependencyTemplates: DependencyTemplates
				) => Source
			) => void;
		};
		renderWithEntry: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (source: Source, chunk: Chunk, hash?: string) => Source
			) => void;
		};
		assetPath: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (value: string, path: PathData, assetInfo?: AssetInfo) => string
			) => void;
			call: (filename: TemplatePath, options: PathData) => string;
		};
		hash: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (hash: Hash) => void
			) => void;
		};
		hashForChunk: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (hash: Hash, chunk: Chunk) => void
			) => void;
		};
		globalHashPaths: { tap: () => void };
		globalHash: { tap: () => void };
		hotBootstrap: { tap: () => never };
		bootstrap: SyncWaterfallHook<
			[string, Chunk, string, ModuleTemplate, DependencyTemplates],
			string
		>;
		localVars: SyncWaterfallHook<[string, Chunk, string], string>;
		requireExtensions: SyncWaterfallHook<[string, Chunk, string], string>;
		requireEnsure: SyncWaterfallHook<[string, Chunk, string, string], string>;
		get jsonpScript(): SyncWaterfallHook<[string, Chunk], string>;
		get linkPrefetch(): SyncWaterfallHook<[string, Chunk], string>;
		get linkPreload(): SyncWaterfallHook<[string, Chunk], string>;
	}>;
	renderCurrentHashCode: (hash: string, length?: number) => string;
	getPublicPath: (options: PathData) => string;
	getAssetPath: (path: TemplatePath, options: PathData) => string;
	getAssetPathWithInfo: (
		path: TemplatePath,
		options: PathData
	) => InterpolatedPathAndAssetInfo;
	get requireFn(): "__webpack_require__";
	get outputOptions(): OutputNormalizedWithDefaults;
}

/**
 * Defines the make cacheable result type used by this module.
 */
declare interface MakeCacheableResult<T> {
	(value: string, cache?: object): T;
}

/**
 * Defines the make directory options type used by this module.
 */
declare interface MakeDirectoryOptions {
	recursive?: boolean;
	mode?: string | number;
}

/**
 * Describes a manifest entrypoint.
 */
declare interface ManifestEntrypoint {
	/**
	 * Contains the names of entrypoints.
	 */
	imports: string[];

	/**
	 * Contains the names of parent entrypoints.
	 */
	parents?: string[];
}

/**
 * Describes a manifest asset that links the emitted path to the producing asset.
 */
declare interface ManifestItem {
	/**
	 * The path absolute URL (this indicates that the path is absolute from the server's root directory) to file.
	 */
	file: string;

	/**
	 * The source path relative to the context.
	 */
	src?: string;
}
type ManifestObject = ManifestObjectKnown & ManifestObjectUnknown;

/**
 * The manifest object.
 */
declare interface ManifestObjectKnown {
	/**
	 * Contains the names of assets.
	 */
	assets: Record<string, ManifestItem>;

	/**
	 * Contains the names of entrypoints.
	 */
	entrypoints: Record<string, ManifestEntrypoint>;
}
declare interface ManifestObjectUnknown {
	[index: string]: any;
}
declare class ManifestPlugin {
	/**
	 * Creates an instance of ManifestPlugin.
	 */
	constructor(options?: ManifestPluginOptions);
	options: ManifestPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface ManifestPluginOptions {
	/**
	 * Enables/disables generation of the entrypoints manifest section.
	 */
	entrypoints?: boolean;

	/**
	 * Specifies the filename of the output file on disk. By default the plugin will emit `manifest.json` inside the 'output.path' directory.
	 */
	filename?: string;

	/**
	 * Allows filtering the files which make up the manifest.
	 */
	filter?: (item: ManifestItem) => boolean;

	/**
	 * A function that receives the manifest object, modifies it, and returns the modified manifest.
	 */
	generate?: (manifest: ManifestObject) => ManifestObject;

	/**
	 * Specifies a path prefix for all keys in the manifest.
	 */
	prefix?: string;

	/**
	 * A function that receives the manifest object and returns the manifest string.
	 */
	serialize?: (manifest: ManifestObject) => string;
}
declare interface MapOptions {
	/**
	 * need columns?
	 */
	columns?: boolean;

	/**
	 * is module
	 */
	module?: boolean;

	/**
	 * emit the `scopes` field from the bindings the sources declare
	 */
	scopes?: boolean;
}
declare interface MatchObject {
	test?:
		| string
		| RegExp
		| ((str: string) => boolean)
		| GlobCondition
		| (string | RegExp | ((str: string) => boolean) | GlobCondition)[];
	include?:
		| string
		| RegExp
		| ((str: string) => boolean)
		| GlobCondition
		| (string | RegExp | ((str: string) => boolean) | GlobCondition)[];
	exclude?:
		| string
		| RegExp
		| ((str: string) => boolean)
		| GlobCondition
		| (string | RegExp | ((str: string) => boolean) | GlobCondition)[];
}
type Matcher =
	| string
	| RegExp
	| ((str: string) => boolean)
	| GlobCondition
	| (string | RegExp | ((str: string) => boolean) | GlobCondition)[];

/**
 * Defines the maybe mergeable init fragment type used by this module.
 */
declare interface MaybeMergeableInitFragment<GenerateContext> {
	key?: string;
	stage: number;
	position: number;
	getContent: (context: GenerateContext) => undefined | string | Source;
	getEndContent: (context: GenerateContext) => undefined | string | Source;
	merge?: (
		fragments: MaybeMergeableInitFragment<GenerateContext>
	) => MaybeMergeableInitFragment<GenerateContext>;
	mergeAll?: (
		fragments: MaybeMergeableInitFragment<GenerateContext>[]
	) => MaybeMergeableInitFragment<GenerateContext>[];
}
type MaybePromise<T> = T | Promise<T>;
type Media = undefined | string;

/**
 * Options object for in-memory caching.
 */
declare interface MemoryCacheOptions {
	/**
	 * Additionally cache computation of modules that are unchanged and reference only unchanged modules.
	 */
	cacheUnaffected?: boolean;

	/**
	 * Number of generations unused cache entries stay in memory cache at minimum (1 = may be removed after unused for a single compilation, ..., Infinity: kept forever).
	 */
	maxGenerations?: number;

	/**
	 * In memory caching.
	 */
	type: "memory";
}
declare class MemoryCachePlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare class MergeDuplicateChunksPlugin {
	/**
	 * Creates an instance of MergeDuplicateChunksPlugin.
	 */
	constructor(options?: MergeDuplicateChunksPluginOptions);
	options: MergeDuplicateChunksPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface MergeDuplicateChunksPluginOptions {
	/**
	 * Specifies the stage for merging duplicate chunks.
	 */
	stage?: number;
}
type MergedDefinitionNode =
	| undefined
	| null
	| string
	| number
	| bigint
	| boolean
	| Function
	| RegExp
	| RuntimeValue
	| {
			[index: string]: RecursiveArrayOrRecord<
				| undefined
				| null
				| string
				| number
				| bigint
				| boolean
				| Function
				| RegExp
				| RuntimeValue
			>;
	  }
	| RecursiveArrayOrRecord<
			| undefined
			| null
			| string
			| number
			| bigint
			| boolean
			| Function
			| RegExp
			| RuntimeValue
	  >[]
	| Map<string, MergedDefinitionNode>;
type Meta = KnownMeta & Record<symbol, string[]> & Record<string, any>;
declare class MinChunkSizePlugin {
	/**
	 * Creates an instance of MinChunkSizePlugin.
	 */
	constructor(options: MinChunkSizePluginOptions);
	options: MinChunkSizePluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface MinChunkSizePluginOptions {
	/**
	 * Constant overhead for a chunk.
	 */
	chunkOverhead?: number;

	/**
	 * Multiplicator for initial chunks.
	 */
	entryChunkMultiplicator?: number;

	/**
	 * Minimum number of characters.
	 */
	minChunkSize: number;
}

/**
 * what a caller minifies with, the switches of its corrections and improvements, and the modules it is built from
 */
declare interface Minifier {
	minify: (
		sources: MinifySources,
		options?: MinifyOptions
	) => Promise<MinifyOutput>;
	phases: string[];
	corrections?: { enabled: boolean };
	improvements?: {
		enabled: boolean;
		lets: { enabled: boolean };
		literalsLast: { enabled: boolean };
	};
	modules: MinifierModules;
}

/**
 * terser's own modules
 */
declare interface MinifierModules {
	[index: string]: any;
	ast: Ast;
}

/**
 * What a source is minified with. The keys the minifier reads are named; the
 * rest are open, so an option a caller passes through is not refused here.
 */
declare interface MinifyOptions {
	/**
	 * what the compressor does, or false to leave the tree as read
	 */
	compress?: boolean | GivenCompressOptions;

	/**
	 * which names are renamed, or false to keep them
	 */
	mangle?: boolean | GivenMangleOptions;

	/**
	 * how the output is written
	 */
	format?: GivenFormatOptions;

	/**
	 * the older spelling of `format`, which may not be named beside it
	 */
	output?: GivenFormatOptions;

	/**
	 * how the source is read
	 */
	parse?: {
		bare_returns?: boolean;
		ecma?: null | number;
		filename?: null | string;
		html5_comments?: boolean;
		module?: boolean;
		shebang?: boolean;
		toplevel?: any;
		spidermonkey?: boolean;
	};

	/**
	 * whether a source map is written, and how
	 */
	sourceMap?: boolean | GivenSourceMapOptions;

	/**
	 * whether the source is a module
	 */
	module?: boolean;

	/**
	 * which edition the output may use
	 */
	ecma?: number;

	/**
	 * whether top-level names may be renamed or dropped
	 */
	toplevel?: boolean;

	/**
	 * names held across assets, which this writes into
	 */
	nameCache?: null | { vars?: any; props?: any };

	/**
	 * which class names survive
	 */
	keep_classnames?: boolean | RegExp;

	/**
	 * which function names survive
	 */
	keep_fnames?: boolean | RegExp;

	/**
	 * whether the output works around that engine
	 */
	ie8?: boolean;

	/**
	 * whether the output works around that engine
	 */
	safari10?: boolean;
}

/**
 * What a minify answers with: the code it wrote, the map it was asked for, and
 * the tree where the format options asked for one instead of code.
 */
declare interface MinifyOutput {
	/**
	 * the minified source
	 */
	code?: string;

	/**
	 * the source map, as a string or an object
	 */
	map?: string | EncodedSourceMap;

	/**
	 * the map with its mappings read
	 */
	decoded_map?: null | BuiltSourceMap;

	/**
	 * the tree, where `format.ast` asked for it
	 */
	ast?: NodeShape;
}
type MinifySources = string | string[] | Record<string, string> | NodeShape;

/**
 * Describes the mkdir shape.
 */
declare interface Mkdir {
	(
		file: PathLikeFs,
		options: MakeDirectoryOptions & { recursive: true },
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
	(
		file: PathLikeFs,
		options:
			| undefined
			| null
			| string
			| number
			| (MakeDirectoryOptions & { recursive?: false }),
		callback: (err: null | NodeJS.ErrnoException) => void
	): void;
	(
		file: PathLikeFs,
		options: undefined | null | string | number | MakeDirectoryOptions,
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
	(
		file: PathLikeFs,
		callback: (err: null | NodeJS.ErrnoException) => void
	): void;
}

/**
 * Describes the mkdir sync shape.
 */
declare interface MkdirSync {
	(
		path: PathLikeFs,
		options: MakeDirectoryOptions & { recursive: true }
	): undefined | string;
	(
		path: PathLikeFs,
		options?:
			null | string | number | (MakeDirectoryOptions & { recursive?: false })
	): void;
	(
		path: PathLikeFs,
		options?: null | string | number | MakeDirectoryOptions
	): undefined | string;
}
declare class Module extends DependenciesBlock {
	/**
	 * Creates an instance of Module.
	 */
	constructor(type: string, context?: null | string, layer?: null | string);
	type: string;
	context: null | string;
	layer: null | string;
	needId: boolean;
	debugId: number;
	resolveOptions?: ResolveOptionsWebpackOptions;
	factoryMeta?: FactoryMeta;
	useSourceMap: boolean;
	useSimpleSourceMap: boolean;
	buildMeta?: BuildMeta;
	buildInfo?: BuildInfo;
	presentationalDependencies?: Dependency[];
	codeGenerationDependencies?: Dependency[];

	/**
	 * Returns the module id assigned by the chunk graph.
	 * Updates the module id using the provided value.
	 * @deprecated
	 * @deprecated
	 */
	id: null | string | number;

	/**
	 * Returns the hash of the module.
	 * @deprecated
	 */
	get hash(): string;

	/**
	 * Returns the rendered hash of the module.
	 * @deprecated
	 */
	get renderedHash(): string;

	/**
	 * @deprecated
	 * @deprecated
	 */
	profile?: ModuleProfile;

	/**
	 * Returns the pre-order index.
	 * Updates the pre-order index using the provided value.
	 * @deprecated
	 * @deprecated
	 */
	index: null | number;

	/**
	 * Returns the post-order index.
	 * Updates the post-order index using the provided value.
	 * @deprecated
	 * @deprecated
	 */
	index2: null | number;

	/**
	 * Returns the depth.
	 * Updates the depth using the provided value.
	 * @deprecated
	 * @deprecated
	 */
	depth: null | number;

	/**
	 * Returns the issuer.
	 * Updates the issuer using the provided value.
	 * @deprecated
	 * @deprecated
	 */
	issuer?: null | Module;

	/**
	 * @deprecated
	 */
	get usedExports(): null | boolean | SortableSet<string>;

	/**
	 * Gets optimization bailout.
	 * @deprecated
	 */
	get optimizationBailout(): (
		string | ((requestShortener: RequestShortener) => string)
	)[];

	/**
	 * @deprecated
	 */
	get optional(): boolean;

	/**
	 * Adds the provided chunk to the module.
	 * @deprecated
	 */
	addChunk(chunk: Chunk): boolean;

	/**
	 * Removes the provided chunk from the module.
	 * @deprecated
	 */
	removeChunk(chunk: Chunk): void;

	/**
	 * Checks whether this module is in the provided chunk.
	 * @deprecated
	 */
	isInChunk(chunk: Chunk): boolean;

	/**
	 * @deprecated
	 */
	isEntryModule(): boolean;

	/**
	 * @deprecated
	 */
	getChunks(): Chunk[];

	/**
	 * @deprecated
	 */
	getNumberOfChunks(): number;

	/**
	 * @deprecated
	 */
	get chunksIterable(): Iterable<Chunk>;

	/**
	 * Checks whether this module provides the specified export.
	 * @deprecated
	 */
	isProvided(exportName: string): null | boolean;

	/**
	 * Gets exports argument.
	 */
	get exportsArgument(): string;

	/**
	 * Gets module argument.
	 */
	get moduleArgument(): string;

	/**
	 * Returns export type.
	 */
	getExportsType(moduleGraph: ModuleGraph, strict?: boolean): ExportsType;

	/**
	 * Adds presentational dependency.
	 */
	addPresentationalDependency(presentationalDependency: Dependency): void;

	/**
	 * Adds code generation dependency.
	 */
	addCodeGenerationDependency(codeGenerationDependency: Dependency): void;

	/**
	 * Adds the provided warning to the module.
	 */
	addWarning(warning: Error): void;

	/**
	 * Returns list of warnings if any.
	 */
	getWarnings(): undefined | Error[];

	/**
	 * Gets number of warnings.
	 */
	getNumberOfWarnings(): number;

	/**
	 * Adds the provided error to the module.
	 */
	addError(error: Error): void;

	/**
	 * Returns list of errors if any.
	 */
	getErrors(): undefined | Error[];

	/**
	 * Gets number of errors.
	 */
	getNumberOfErrors(): number;

	/**
	 * removes all warnings and errors
	 */
	clearWarningsAndErrors(): void;

	/**
	 * Checks whether this module is optional.
	 */
	isOptional(moduleGraph: ModuleGraph): boolean;

	/**
	 * Checks whether this module is accessible in chunk.
	 */
	isAccessibleInChunk(
		chunkGraph: ChunkGraph,
		chunk: Chunk,
		ignoreChunk?: Chunk
	): boolean;

	/**
	 * Checks whether this module is accessible in chunk group.
	 */
	isAccessibleInChunkGroup(
		chunkGraph: ChunkGraph,
		chunkGroup: ChunkGroup,
		ignoreChunk?: Chunk
	): boolean;

	/**
	 * Checks whether this module contains the chunk.
	 */
	hasReasonForChunk(
		chunk: Chunk,
		moduleGraph: ModuleGraph,
		chunkGraph: ChunkGraph
	): boolean;

	/**
	 * Checks whether this module contains the module graph.
	 */
	hasReasons(moduleGraph: ModuleGraph, runtime: RuntimeSpec): boolean;

	/**
	 * Checks whether the module needs to be rebuilt for the current build state.
	 */
	needBuild(
		context: NeedBuildContext,
		callback: (err?: null | WebpackError, needBuild?: boolean) => void
	): void;

	/**
	 * Checks whether it needs rebuild.
	 * @deprecated Use needBuild instead
	 */
	needRebuild(
		fileTimestamps: Map<string, null | number>,
		contextTimestamps: Map<string, null | number>
	): boolean;

	/**
	 * Invalidates the cached state associated with this value.
	 */
	invalidateBuild(): void;

	/**
	 * Returns the unique identifier used to reference this module.
	 */
	identifier(): string;

	/**
	 * Returns a human-readable identifier for this module.
	 */
	readableIdentifier(requestShortener: RequestShortener): string;

	/**
	 * Builds the module using the provided compilation context.
	 */
	build(
		options: WebpackOptionsNormalizedWithDefaults,
		compilation: Compilation,
		resolver: ResolverWithOptions,
		fs: InputFileSystem,
		callback: (err?: WebpackError) => void
	): void;

	/**
	 * Returns the source types this module can generate.
	 */
	getSourceTypes(): ReadonlySet<string>;

	/**
	 * Freshly recomputed source types when they depend on incoming connections, for chunk-graph cache invalidation; undefined otherwise. #20800
	 */
	getReferencedSourceTypes(): undefined | ReadonlySet<string>;

	/**
	 * Returns whether this module is of the given kind; a subclass is every kind its parent is.
	 */
	is<
		K extends
			| "html"
			| "runtime"
			| "normal"
			| "css"
			| "context"
			| "remote"
			| "consume-shared"
			| "external"
			| "concatenated"
	>(kind: K): boolean;

	/**
	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
	 * added or changed over time by generators and do not need to be handled or detected here.
	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
	 */
	getSourceBasicTypes(): ReadonlySet<string>;

	/**
	 * Returns generated source.
	 * @deprecated Use codeGeneration() instead
	 */
	source(
		dependencyTemplates: DependencyTemplates,
		runtimeTemplate: RuntimeTemplate,
		type?: string
	): Source;

	/**
	 * Returns the estimated size for the requested source type.
	 */
	size(type?: string): number;

	/**
	 * Gets the library identifier.
	 */
	libIdent(options: LibIdentOptions): null | string;

	/**
	 * Returns the path used when matching this module against rule conditions.
	 */
	nameForCondition(): null | string;

	/**
	 * Returns the module this one was built around: itself, or the root of a scope-hoisted concatenation.
	 */
	getRootModule(): Module;

	/**
	 * Returns the modules this one was built from: itself, or every module merged by scope hoisting.
	 */
	getSourceModules(): Iterable<Module>;

	/**
	 * Returns the reason this module cannot be concatenated, when one exists.
	 */
	getConcatenationBailoutReason(
		context: ConcatenationBailoutReasonContext
	): undefined | string;

	/**
	 * Whether a concatenation may defer this module behind its lazy CommonJS
	 * accessor. A generator ignoring `ConcatenationScope#isWrapped` answers false.
	 */
	canBeWrappedInConcatenation(): boolean;

	/**
	 * Gets side effects connection state.
	 */
	getSideEffectsConnectionState(moduleGraph: ModuleGraph): ConnectionState;

	/**
	 * Generates code and runtime requirements for this module.
	 */
	codeGeneration(context: CodeGenerationContext): CodeGenerationResult;

	/**
	 * Returns true if the module can be placed in the chunk.
	 */
	chunkCondition(chunk: Chunk, compilation: Compilation): boolean;
	hasChunkCondition(): boolean;

	/**
	 * Assuming this module is in the cache. Update the (cached) module with
	 * the fresh module from the factory. Usually updates internal references
	 * and properties.
	 */
	updateCacheModule(module: Module): void;

	/**
	 * Module should be unsafe cached. Get data that's needed for that.
	 * This data will be passed to restoreFromUnsafeCache later.
	 */
	getUnsafeCacheData(): UnsafeCacheData;

	/**
	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
	 */
	cleanupForCache(): void;

	/**
	 * Gets the original source.
	 */
	originalSource(): null | Source;

	/**
	 * Adds the provided file dependencies to the module.
	 */
	addCacheDependencies(
		fileDependencies: LazySet<string>,
		contextDependencies: LazySet<string>,
		missingDependencies: LazySet<string>,
		buildDependencies: LazySet<string>
	): void;
	get hasEqualsChunks(): any;
	get isUsed(): any;
	get errors(): any;
	get warnings(): any;
	used: any;

	/**
	 * Gets source basic types.
	 * @deprecated In the next major release, call getSourceBasicTypes() directly on the module instance instead of using this static method.
	 */
	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
	static KINDS: Set<
		| "html"
		| "runtime"
		| "normal"
		| "css"
		| "context"
		| "remote"
		| "consume-shared"
		| "external"
		| "concatenated"
	>;
}
declare class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
	/**
	 * Creates an instance of ModuleChunkLoadingRuntimeModule.
	 */
	constructor(runtimeRequirements: ReadonlySet<string>);
	static getCompilationHooks: (compilation: Compilation) => {
		/**
		 * @since 5.41.0
		 */
		linkPreload: SyncWaterfallHook<[string, Chunk], string>;
		/**
		 * @since 5.41.0
		 */
		linkPrefetch: SyncWaterfallHook<[string, Chunk], string>;
	};

	/**
	 * The answer a runtime module gives when it installs no chunk handler at all
	 */
	static NO_CHUNK_HANDLERS: [string, string][];

	/**
	 * Runtime modules without any dependencies to other runtime modules
	 */
	static STAGE_NORMAL: number;

	/**
	 * Runtime modules with simple dependencies on other runtime modules
	 */
	static STAGE_BASIC: number;

	/**
	 * Runtime modules which attach to handlers of other runtime modules
	 */
	static STAGE_ATTACH: number;

	/**
	 * Runtime modules which trigger actions on bootstrap
	 */
	static STAGE_TRIGGER: number;
	static KINDS: Set<
		| "html"
		| "runtime"
		| "normal"
		| "css"
		| "context"
		| "remote"
		| "consume-shared"
		| "external"
		| "concatenated"
	>;

	/**
	 * Gets source basic types.
	 * @deprecated In the next major release, call getSourceBasicTypes() directly on the module instance instead of using this static method.
	 */
	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
}
declare class ModuleConcatenationPlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
	static BAILOUT_PREFIX: string;
	static REJECTED_PREFIX: string;
}
declare class ModuleDependency extends Dependency {
	/**
	 * Creates an instance of ModuleDependency.
	 */
	constructor(request: string, sourceOrder?: number);
	request: string;
	userRequest: string;
	sourceOrder?: number;
	range?: [number, number];
	weak: boolean;
	static Template: typeof DependencyTemplate;
	static KINDS: Set<
		| "worker"
		| "css-import"
		| "css-url"
		| "entry"
		| "url"
		| "module-dependency"
		| "esm-import"
		| "provided"
		| "dynamic-import"
		| "esm-reexport"
		| "esm-export-specifier"
		| "esm-live-export"
		| "esm-side-effect-import"
		| "context-element"
		| "esm-bare-side-effect-import"
		| "esm-import-specifier"
		| "esm-evaluated-import-specifier"
		| "esm-compatibility"
		| "commonjs-require"
		| "commonjs-export-require"
		| "html-source"
		| "html-entry"
		| "webassembly-import"
		| "webassembly-export-imported"
		| "sharing-request"
		| "local-module"
		| "static-exports"
		| "loader-import"
		| "css-icss-import"
		| "css-icss-export"
	>;

	/**
	 * Compares two dependencies by source location for sorting a module's
	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
	 * its result, so comparing through it would retain a location object on every
	 * sorted dependency). These dependencies always carry a real source position,
	 * so only start (line, column) and the within-statement index are compared; a
	 * dependency without an index sorts after one that has an index at the same
	 * position.
	 */
	static compareLocations(a: Dependency, b: Dependency): 0 | 1 | -1;
	static NO_EXPORTS_REFERENCED: string[][];
	static EXPORTS_OBJECT_REFERENCED: string[][];
	static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];

	/**
	 * Returns true if the dependency is a low priority dependency.
	 */
	static isLowPriorityDependency(dependency: Dependency): boolean;

	/**
	 * Returns true if the dependency can be concatenated (scope hoisting).
	 */
	static canConcatenate(
		dependency: Dependency,
		concatenateCommonJsModules: boolean
	): boolean;
	static TRANSITIVE: symbol;
	static LAZY_LOCAL_EXPORT: "local";
	static LAZY_NAMED_REEXPORT: "id";
	static LAZY_STAR_REEXPORT: "*";
	static LAZY_REEXPORT_SIDE_EFFECT: "@";
	static LAZY_IMPORT_DECLARATION: "import";
	static ESM_CATEGORY: "esm";
}

/**
 * Represents ModuleExternalInitFragment.
 */
declare class ModuleExternalInitFragment extends InitFragment<ChunkRenderContextJavascriptModulesPlugin> {
	/**
	 * Creates an instance of ModuleExternalInitFragment.
	 */
	constructor(
		request: string,
		imported: Imported,
		ident?: string,
		dependencyMeta?: ImportDependencyMeta,
		hashFunction?: string | typeof Hash
	);

	/**
	 * Returns imported.
	 */
	getImported(): Imported;

	/**
	 * Updates imported using the provided imported.
	 */
	setImported(imported: Imported): void;
	getNamespaceIdentifier(): string;

	/**
	 * Returns identifier.
	 */
	buildIdentifier(ident: string): string;

	/**
	 * Returns normalized imported.
	 */
	buildImported(imported: Imported): Imported;

	/**
	 * Adds the provided source to the init fragment.
	 */
	static addToSource<Context>(
		source: Source,
		initFragments: MaybeMergeableInitFragment<Context>[],
		context: Context
	): Source;
	static STAGE_CONSTANTS: number;
	static STAGE_ASYNC_BOUNDARY: number;
	static STAGE_ESM_EXPORTS: number;
	static STAGE_ESM_IMPORTS: number;
	static STAGE_PROVIDES: number;
	static STAGE_ASYNC_DEPENDENCIES: number;
	static STAGE_ASYNC_ESM_IMPORTS: number;

	/**
	 * use `STAGE_ESM_EXPORTS` — TODO in the next major release: remove
	 * @deprecated
	 */
	static STAGE_HARMONY_EXPORTS: number;

	/**
	 * use `STAGE_ESM_IMPORTS` — TODO in the next major release: remove
	 * @deprecated
	 */
	static STAGE_HARMONY_IMPORTS: number;

	/**
	 * use `STAGE_ASYNC_ESM_IMPORTS` — TODO in the next major release: remove
	 * @deprecated
	 */
	static STAGE_ASYNC_HARMONY_IMPORTS: number;
}
declare class ModuleFactory {
	constructor();

	/**
	 * Processes the provided data.
	 */
	create(
		data: ModuleFactoryCreateData,
		callback: (err?: null | Error, result?: ModuleFactoryResult) => void
	): void;
}

/**
 * Defines the module factory cache entry type used by this module.
 */
declare interface ModuleFactoryCacheEntry {
	/**
	 * - The undo path to the CSS file
	 */
	undoPath: string;

	/**
	 * - The compilation hash
	 */
	hash?: string;

	/**
	 * - The inheritance chain
	 */
	inheritance: [CssLayer, Supports, Media][];

	/**
	 * - The cached source
	 */
	source: CachedSource;
}

/**
 * Defines the module factory create data type used by this module.
 */
declare interface ModuleFactoryCreateData {
	contextInfo: ModuleFactoryCreateDataContextInfo;
	resolveOptions?: ResolveOptionsWebpackOptions;
	context: string;
	dependencies: Dependency[];
}

/**
 * Defines the module factory create data context info type used by this module.
 */
declare interface ModuleFactoryCreateDataContextInfo {
	issuer: string;
	issuerLayer: IssuerLayer;
	compiler?: string;
}

/**
 * Defines the module factory result type used by this module.
 */
declare interface ModuleFactoryResult {
	/**
	 * the created module or unset if no module was created
	 */
	module?: Module;
	fileDependencies?: Set<string>;
	contextDependencies?: Set<string>;
	missingDependencies?: Set<string>;

	/**
	 * allow to use the unsafe cache
	 */
	cacheable?: boolean;
}
declare class ModuleFederationPlugin {
	/**
	 * Creates an instance of ModuleFederationPlugin.
	 */
	constructor(options: ModuleFederationPluginOptions);
	options: ModuleFederationPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
	static getCompilationHooks: (compilation: Compilation) => {
		/**
		 * @since 5.96.0
		 */
		addContainerEntryDependency: SyncHook<Dependency>;
		/**
		 * @since 5.96.0
		 */
		addFederationRuntimeDependency: SyncHook<Dependency>;
	};
}
declare interface ModuleFederationPluginOptions {
	exposes?: ExposesObject | ExposesBranch1Item[];

	/**
	 * The filename of the container as relative path inside the `output.path` directory.
	 */
	filename?: string;
	library?: LibraryOptions;

	/**
	 * The name of the container.
	 */
	name?: string;

	/**
	 * The external type of the remote containers.
	 */
	remoteType?:
		| "import"
		| "var"
		| "module"
		| "assign"
		| "this"
		| "window"
		| "self"
		| "global"
		| "commonjs"
		| "commonjs2"
		| "commonjs-module"
		| "commonjs-static"
		| "amd"
		| "amd-require"
		| "umd"
		| "umd2"
		| "jsonp"
		| "system"
		| "amd-async"
		| "promise"
		| "module-import"
		| "script"
		| "node-commonjs"
		| "asset"
		| "asset-url"
		| "css-import"
		| "css-url";
	remotes?: RemotesObject | RemotesBranch1Item[];
	runtime?: string | false;

	/**
	 * Share scope name used for all shared modules (defaults to 'default').
	 */
	shareScope?: string;
	shared?: SharedObject | SharedBranch1Item[];
}

/**
 * Defines the module filename template context type used by this module.
 */
declare interface ModuleFilenameTemplateContext {
	/**
	 * the identifier of the module
	 */
	identifier: string;

	/**
	 * the shortened identifier of the module
	 */
	shortIdentifier: string;

	/**
	 * the resource of the module request
	 */
	resource: string;

	/**
	 * the resource path of the module request
	 */
	resourcePath: string;

	/**
	 * the absolute resource path of the module request
	 */
	absoluteResourcePath: string;

	/**
	 * the loaders of the module request
	 */
	loaders: string;

	/**
	 * the all loaders of the module request
	 */
	allLoaders: string;

	/**
	 * the query of the module identifier
	 */
	query: string;

	/**
	 * the module id of the module
	 */
	moduleId: string;

	/**
	 * the hash of the module identifier
	 */
	hash: string;

	/**
	 * the module namespace
	 */
	namespace: string;
}
type ModuleFilterItemTypes =
	| string
	| RegExp
	| ((
			name: string,
			module: StatsModule,
			type: "module" | "chunk" | "root-of-chunk" | "nested"
	  ) => boolean);
declare class ModuleGraph {
	constructor();

	/**
	 * Updates parents using the provided dependency.
	 */
	setParents(
		dependency: Dependency,
		block: DependenciesBlock,
		module: Module,
		indexInBlock?: number
	): void;

	/**
	 * Sets parent dependencies block index.
	 */
	setParentDependenciesBlockIndex(dependency: Dependency, index: number): void;

	/**
	 * Gets parent module.
	 */
	getParentModule(dependency: Dependency): undefined | Module;

	/**
	 * Returns parent block.
	 */
	getParentBlock(dependency: Dependency): undefined | DependenciesBlock;

	/**
	 * Gets parent block index.
	 */
	getParentBlockIndex(dependency: Dependency): number;

	/**
	 * Sets resolved module.
	 */
	setResolvedModule(
		originModule: null | Module,
		dependency: Dependency,
		module: Module
	): void;

	/**
	 * Updates module using the provided dependency.
	 */
	updateModule(dependency: Dependency, module: Module): void;

	/**
	 * Updates parent using the provided dependency.
	 */
	updateParent(
		dependency: Dependency,
		connection?: ModuleGraphConnection,
		parentModule?: Module
	): void;

	/**
	 * Finish update parent.
	 */
	finishUpdateParent(): void;

	/**
	 * Removes connection.
	 */
	removeConnection(dependency: Dependency): void;

	/**
	 * Adds the provided dependency to the module graph.
	 */
	addExplanation(dependency: Dependency, explanation: string): void;

	/**
	 * Clones module attributes.
	 */
	cloneModuleAttributes(sourceModule: Module, targetModule: Module): void;

	/**
	 * Removes module attributes.
	 */
	removeModuleAttributes(module: Module): void;

	/**
	 * Removes all module attributes.
	 */
	removeAllModuleAttributes(): void;

	/**
	 * Move module connections.
	 */
	moveModuleConnections(
		oldModule: Module,
		newModule: Module,
		filterConnection: (moduleGraphConnection: ModuleGraphConnection) => boolean
	): void;

	/**
	 * Copies outgoing module connections.
	 */
	copyOutgoingModuleConnections(
		oldModule: Module,
		newModule: Module,
		filterConnection: (moduleGraphConnection: ModuleGraphConnection) => boolean
	): void;

	/**
	 * Adds the provided module to the module graph.
	 */
	addExtraReason(module: Module, explanation: string): void;

	/**
	 * Gets resolved module.
	 */
	getResolvedModule(dependency: Dependency): null | Module;

	/**
	 * Returns the connection.
	 */
	getConnection(dependency: Dependency): undefined | ModuleGraphConnection;

	/**
	 * Returns the referenced module.
	 */
	getModule(dependency: Dependency): null | Module;

	/**
	 * Returns the referencing module.
	 */
	getOrigin(dependency: Dependency): null | Module;

	/**
	 * Gets resolved origin.
	 */
	getResolvedOrigin(dependency: Dependency): null | Module;

	/**
	 * Gets incoming connections.
	 */
	getIncomingConnections(module: Module): Iterable<ModuleGraphConnection>;

	/**
	 * Gets outgoing connections.
	 */
	getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;

	/**
	 * Gets incoming connections by origin module.
	 */
	getIncomingConnectionsByOriginModule(
		module: Module
	): ReadonlyMap<
		undefined | null | Module,
		ReadonlyArray<ModuleGraphConnection>
	>;

	/**
	 * Gets outgoing connections by module.
	 */
	getOutgoingConnectionsByModule(
		module: Module
	):
		| undefined
		| ReadonlyMap<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;

	/**
	 * Returns the module profile.
	 */
	getProfile(module: Module): undefined | ModuleProfile;

	/**
	 * Updates profile using the provided module.
	 */
	setProfile(module: Module, profile?: ModuleProfile): void;

	/**
	 * Returns the issuer module.
	 */
	getIssuer(module: Module): Issuer;

	/**
	 * Updates issuer using the provided module.
	 */
	setIssuer(module: Module, issuer: null | Module): void;

	/**
	 * Sets issuer if unset.
	 */
	setIssuerIfUnset(module: Module, issuer: null | Module): void;

	/**
	 * Gets optimization bailout.
	 */
	getOptimizationBailout(
		module: Module
	): (string | ((requestShortener: RequestShortener) => string))[];

	/**
	 * Gets provided exports.
	 */
	getProvidedExports(module: Module): null | true | string[];

	/**
	 * Checks whether this module graph is export provided.
	 */
	isExportProvided(
		module: Module,
		exportName: string | string[]
	): null | boolean;

	/**
	 * Returns info about the exports.
	 */
	getExportsInfo(module: Module): ExportsInfo;

	/**
	 * Returns info about the export.
	 */
	getExportInfo(module: Module, exportName: string): ExportInfo;

	/**
	 * Gets read only export info.
	 */
	getReadOnlyExportInfo(module: Module, exportName: string): ExportInfo;

	/**
	 * Returns the used exports.
	 */
	getUsedExports(
		module: Module,
		runtime: RuntimeSpec
	): null | boolean | SortableSet<string>;

	/**
	 * Gets pre order index.
	 */
	getPreOrderIndex(module: Module): null | number;

	/**
	 * Gets post order index.
	 */
	getPostOrderIndex(module: Module): null | number;

	/**
	 * Sets pre order index.
	 */
	setPreOrderIndex(module: Module, index: number): void;

	/**
	 * Sets pre order index if unset.
	 */
	setPreOrderIndexIfUnset(module: Module, index: number): boolean;

	/**
	 * Sets post order index.
	 */
	setPostOrderIndex(module: Module, index: number): void;

	/**
	 * Sets post order index if unset.
	 */
	setPostOrderIndexIfUnset(module: Module, index: number): boolean;

	/**
	 * Returns the depth of the module.
	 */
	getDepth(module: Module): null | number;

	/**
	 * Updates depth using the provided module.
	 */
	setDepth(module: Module, depth: number): void;

	/**
	 * Sets depth if lower.
	 */
	setDepthIfLower(module: Module, depth: number): boolean;

	/**
	 * Checks whether this module graph is async.
	 */
	isAsync(module: Module): boolean;

	/**
	 * Checks whether this module graph is deferred.
	 */
	isDeferred(module: Module): boolean;

	/**
	 * Updates async using the provided module.
	 */
	setAsync(module: Module): void;

	/**
	 * Returns metadata.
	 */
	getMeta(thing: object): Meta;

	/**
	 * Gets meta if existing.
	 */
	getMetaIfExisting(thing: object): undefined | Meta;

	/**
	 * Processes the provided cache stage.
	 */
	freeze(cacheStage?: string): void;
	unfreeze(): void;

	/**
	 * Returns computed value or cached.
	 */
	cached<T extends TupleElement[], R>(
		fn: (moduleGraph: ModuleGraph, ...args: T) => R,
		...args: T
	): R;

	/**
	 * Sets module mem caches.
	 */
	setModuleMemCaches(
		moduleMemCaches: Map<Module, WeakTupleMap<any[], any>>
	): void;

	/**
	 * Dependency cache provide.
	 */
	dependencyCacheProvide<D extends Dependency, ARGS extends TupleElement[], R>(
		dependency: D,
		...args: [
			ARGS,
			...((moduleGraph: ModuleGraph, dependency: D, ...args: ARGS) => R)[]
		]
	): R;

	/**
	 * Gets module graph for module.
	 * @deprecated
	 */
	static getModuleGraphForModule(
		module: Module,
		deprecateMessage: string,
		deprecationCode: string
	): ModuleGraph;

	/**
	 * Sets module graph for module.
	 * @deprecated
	 */
	static setModuleGraphForModule(
		module: Module,
		moduleGraph: ModuleGraph
	): void;

	/**
	 * Clear module graph for module.
	 * @deprecated
	 */
	static clearModuleGraphForModule(module: Module): void;
	static ModuleGraphConnection: typeof ModuleGraphConnection;
}
declare class ModuleGraphConnection {
	/**
	 * Creates an instance of ModuleGraphConnection.
	 */
	constructor(
		originModule: null | Module,
		dependency: null | Dependency,
		module: Module,
		explanation?: string,
		weak?: boolean,
		condition?:
			| null
			| false
			| ((
					moduleGraphConnection: ModuleGraphConnection,
					runtime: RuntimeSpec
			  ) => ConnectionState)
	);
	originModule: null | Module;
	resolvedOriginModule: null | Module;
	dependency: null | Dependency;
	resolvedModule: Module;
	module: Module;
	weak?: boolean;
	conditional: boolean;
	condition?:
		| null
		| false
		| ((
				moduleGraphConnection: ModuleGraphConnection,
				runtime: RuntimeSpec
		  ) => ConnectionState);
	explanations?: Set<string>;
	clone(): ModuleGraphConnection;

	/**
	 * Adds the provided condition to the module graph connection.
	 */
	addCondition(
		condition: (
			moduleGraphConnection: ModuleGraphConnection,
			runtime: RuntimeSpec
		) => ConnectionState
	): void;

	/**
	 * Adds the provided explanation to the module graph connection.
	 */
	addExplanation(explanation: string): void;
	get explanation(): string;

	/**
	 * Checks whether this module graph connection is active.
	 */
	isActive(runtime: RuntimeSpec): boolean;

	/**
	 * Checks whether this module graph connection is target active.
	 */
	isTargetActive(runtime: RuntimeSpec): boolean;

	/**
	 * Returns true: fully active, false: inactive, TRANSITIVE: direct module inactive, but transitive connection maybe active.
	 */
	getActiveState(runtime: RuntimeSpec): ConnectionState;

	/**
	 * Updates active using the provided value.
	 */
	setActive(value: boolean): void;
	static CIRCULAR_CONNECTION: typeof CIRCULAR_CONNECTION;
	static TRANSITIVE_ONLY: typeof TRANSITIVE_ONLY;
	static addConnectionStates: (
		a: ConnectionState,
		b: ConnectionState
	) => ConnectionState;
}
type ModuleId = string | number;
type ModuleInfo = ConcatenatedModuleInfo | ExternalModuleInfo;
declare interface ModuleMemCachesItem {
	buildInfo: BuildInfo;
	references?: WeakMap<Dependency, Module>;
	lazyRequests?: string;
	memCache: WeakTupleMap<any[], any>;
}

/**
 * Options affecting the normal modules (`NormalModuleFactory`).
 */
declare interface ModuleOptions {
	/**
	 * An array of rules applied by default for modules.
	 */
	defaultRules?: (undefined | null | false | "" | 0 | RuleSetRule | "...")[];

	/**
	 * Enable warnings for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextCritical'.
	 * @deprecated
	 */
	exprContextCritical?: boolean;

	/**
	 * Enable recursive directory lookup for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRecursive'.
	 * @deprecated
	 */
	exprContextRecursive?: boolean;

	/**
	 * Sets the default regular expression for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRegExp'.
	 * @deprecated
	 */
	exprContextRegExp?: boolean | RegExp;

	/**
	 * Set the default request for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRequest'.
	 * @deprecated
	 */
	exprContextRequest?: string;

	/**
	 * Specify options for each generator.
	 */
	generator?: GeneratorOptionsByModuleType;

	/**
	 * Don't parse files matching. It's matched against the full resolved request.
	 */
	noParse?:
		| string
		| RegExp
		| (string | RegExp | ((content: string) => boolean))[]
		| ((content: string) => boolean);

	/**
	 * Specify options for each parser.
	 */
	parser?: ParserOptionsByModuleType;

	/**
	 * An array of rules applied for modules.
	 */
	rules?: (undefined | null | false | "" | 0 | RuleSetRule | "...")[];

	/**
	 * Emit errors instead of warnings when imported names don't exist in imported module. Deprecated: This option has moved to 'module.parser.javascript.strictExportPresence'.
	 * @deprecated
	 */
	strictExportPresence?: boolean;

	/**
	 * Handle the this context correctly according to the spec for namespace objects. Deprecated: This option has moved to 'module.parser.javascript.strictThisContextOnImports'.
	 * @deprecated
	 */
	strictThisContextOnImports?: boolean;

	/**
	 * Enable warnings when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextCritical'.
	 * @deprecated
	 */
	unknownContextCritical?: boolean;

	/**
	 * Enable recursive directory lookup when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRecursive'.
	 * @deprecated
	 */
	unknownContextRecursive?: boolean;

	/**
	 * Sets the regular expression when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRegExp'.
	 * @deprecated
	 */
	unknownContextRegExp?: boolean | RegExp;

	/**
	 * Sets the request when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRequest'.
	 * @deprecated
	 */
	unknownContextRequest?: string;

	/**
	 * Cache the resolving of module requests.
	 */
	unsafeCache?: boolean | ((module: Module) => boolean);

	/**
	 * Enable warnings for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextCritical'.
	 * @deprecated
	 */
	wrappedContextCritical?: boolean;

	/**
	 * Enable recursive directory lookup for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextRecursive'.
	 * @deprecated
	 */
	wrappedContextRecursive?: boolean;

	/**
	 * Set the inner regular expression for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextRegExp'.
	 * @deprecated
	 */
	wrappedContextRegExp?: RegExp;
}

/**
 * Options affecting the normal modules (`NormalModuleFactory`).
 */
declare interface ModuleOptionsNormalized {
	/**
	 * An array of rules applied by default for modules.
	 */
	defaultRules: (undefined | null | false | "" | 0 | RuleSetRule | "...")[];

	/**
	 * Specify options for each generator.
	 */
	generator: GeneratorOptionsByModuleType;

	/**
	 * Don't parse files matching. It's matched against the full resolved request.
	 */
	noParse?:
		| string
		| RegExp
		| (string | RegExp | ((content: string) => boolean))[]
		| ((content: string) => boolean);

	/**
	 * Specify options for each parser.
	 */
	parser: ParserOptionsByModuleType;

	/**
	 * An array of rules applied for modules.
	 */
	rules: (undefined | null | false | "" | 0 | RuleSetRule | "...")[];

	/**
	 * Cache the resolving of module requests.
	 */
	unsafeCache?: boolean | ((module: Module) => boolean);
}

/**
 * Defines the module path data type used by this module.
 */
declare interface ModulePathData {
	id: string | number;
	hash: string;
	hashWithLength?: (length: number) => string;
}
declare abstract class ModuleProfile {
	startTime: number;
	factoryStartTime: number;
	factoryEndTime: number;
	factory: number;
	factoryParallelismFactor: number;
	restoringStartTime: number;
	restoringEndTime: number;
	restoring: number;
	restoringParallelismFactor: number;
	integrationStartTime: number;
	integrationEndTime: number;
	integration: number;
	integrationParallelismFactor: number;
	buildingStartTime: number;
	buildingEndTime: number;
	building: number;
	buildingParallelismFactor: number;
	storingStartTime: number;
	storingEndTime: number;
	storing: number;
	storingParallelismFactor: number;
	additionalFactoryTimes?: { start: number; end: number }[];
	additionalFactories: number;
	additionalFactoriesParallelismFactor: number;

	/**
	 * @deprecated
	 */
	additionalIntegration: number;
	markFactoryStart(): void;
	markFactoryEnd(): void;
	markRestoringStart(): void;
	markRestoringEnd(): void;
	markIntegrationStart(): void;
	markIntegrationEnd(): void;
	markBuildingStart(): void;
	markBuildingEnd(): void;
	markStoringStart(): void;
	markStoringEnd(): void;

	/**
	 * Merge this profile into another one
	 */
	mergeInto(realProfile: ModuleProfile): void;
}
declare interface ModuleReferenceMatch {
	start: number;
	end: number;
	name: string;
	leaked: boolean;
}

/**
 * Encodes how a concatenated module reference should be interpreted when it is
 * later reconstructed from its placeholder identifier.
 */
declare interface ModuleReferenceOptions {
	/**
	 * the properties or exports selected from the referenced module
	 */
	ids: string[];

	/**
	 * true, when this referenced export is called
	 */
	call: boolean;

	/**
	 * true, when this referenced export is directly imported (not via property access)
	 */
	directImport: boolean;

	/**
	 * true, when this referenced export is deferred
	 */
	deferredImport: boolean;

	/**
	 * true, when a whole-namespace reference may use a decoupled namespace object that keeps the original export names
	 */
	mangleableNamespace: boolean;

	/**
	 * true, when the reference resolves to the module's own exports value with plain property access, skipping ESM interop (how `require()` and a wrapped module's side-effect init see it)
	 */
	moduleExportsAccess: boolean;

	/**
	 * if the position is ASI safe or unknown
	 */
	asiSafe?: boolean;
}

/**
 * Defines the module render context type used by this module.
 */
declare interface ModuleRenderContext {
	/**
	 * the chunk
	 */
	chunk: Chunk;

	/**
	 * the dependency templates
	 */
	dependencyTemplates: DependencyTemplates;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * results of code generation
	 */
	codeGenerationResults: CodeGenerationResults;

	/**
	 * init fragments for the chunk
	 */
	chunkInitFragments: InitFragment<ChunkRenderContextJavascriptModulesPlugin>[];

	/**
	 * rendering in strict context
	 */
	strictMode?: boolean;

	/**
	 * true: renders as factory method, false: pure module content
	 */
	factory: boolean;

	/**
	 * the inlined entry module is wrapped in an IIFE, existing only when `factory` is set to false
	 */
	inlinedInIIFE?: boolean;

	/**
	 * render module in object container
	 */
	renderInObject?: boolean;
}
declare interface ModuleResult {
	client: string;
	data: string;
	active: boolean;
}
declare interface ModuleSettings {
	/**
	 * Specifies the layer in which the module should be placed in.
	 */
	layer?: string;

	/**
	 * Module type to use for the module.
	 */
	type?: string;

	/**
	 * Options for parsing.
	 */
	parser?: { [index: string]: any };

	/**
	 * The options for the module generator.
	 */
	generator?: { [index: string]: any };

	/**
	 * Enable/Disable extracting source map.
	 */
	extractSourceMap?: boolean;

	/**
	 * Options for the resolver.
	 */
	resolve?: ResolveOptionsWebpackOptions;

	/**
	 * Flags a module as with or without side effects.
	 */
	sideEffects?: boolean;
}
declare abstract class ModuleTemplate {
	type: string;
	hooks: Readonly<{
		content: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					source: Source,
					module: Module,
					moduleRenderContext: ModuleRenderContext,
					dependencyTemplates: DependencyTemplates
				) => Source
			) => void;
		};
		module: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					source: Source,
					module: Module,
					moduleRenderContext: ModuleRenderContext,
					dependencyTemplates: DependencyTemplates
				) => Source
			) => void;
		};
		render: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					source: Source,
					module: Module,
					chunkRenderContext: ChunkRenderContextJavascriptModulesPlugin,
					dependencyTemplates: DependencyTemplates
				) => Source
			) => void;
		};
		package: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (
					source: Source,
					module: Module,
					chunkRenderContext: ChunkRenderContextJavascriptModulesPlugin,
					dependencyTemplates: DependencyTemplates
				) => Source
			) => void;
		};
		hash: {
			tap: <AdditionalOptions>(
				options:
					string | (TapOptions & { name: string } & IfSet<AdditionalOptions>),
				fn: (hash: Hash) => void
			) => void;
		};
	}>;
	get runtimeTemplate(): RuntimeTemplate;
}
declare interface ModuleTemplates {
	javascript: ModuleTemplate;
}
declare interface ModuleTrace {
	origin: Module;
	module: Module;
}
declare class MultiCompiler {
	/**
	 * Creates an instance of MultiCompiler.
	 */
	constructor(
		compilers: Compiler[] | Record<string, Compiler>,
		options: MultiCompilerOptions
	);
	hooks: Readonly<{
		done: SyncHook<[MultiStats, Compiler[]]>;
		invalid: MultiHook<SyncHook<[null | string, number]>>;
		run: MultiHook<AsyncSeriesHook<[Compiler]>>;
		watchClose: SyncHook<[]>;
		shutdown: MultiHook<AsyncSeriesHook<[]>>;
		watchRun: MultiHook<AsyncSeriesHook<[Compiler]>>;
		infrastructureLog: MultiHook<
			SyncBailHook<[string, string, undefined | any[]], true | void>
		>;
	}>;
	compilers: Compiler[];
	dependencies: WeakMap<Compiler, string[]>;
	running: boolean;
	watching?: MultiWatching;
	get options(): WebpackOptionsNormalized[] & MultiCompilerOptions;
	get outputPath(): string;

	/**
	 * Sets input file system.
	 */
	inputFileSystem: InputFileSystem;

	/**
	 * Sets output file system.
	 */
	outputFileSystem: OutputFileSystem;

	/**
	 * Sets watch file system.
	 */
	watchFileSystem: WatchFileSystem;

	/**
	 * Sets intermediate file system.
	 */
	intermediateFileSystem: IntermediateFileSystem;

	/**
	 * Gets infrastructure logger.
	 */
	getInfrastructureLogger(name: string | (() => string)): Logger;

	/**
	 * Updates dependencies using the provided compiler.
	 */
	setDependencies(compiler: Compiler, dependencies: string[]): void;

	/**
	 * Validate dependencies.
	 */
	validateDependencies(
		callback: CallbackWebpackFunction_2<MultiStats, void>
	): boolean;

	/**
	 * Run with dependencies.
	 * @deprecated This method should have been private
	 */
	runWithDependencies(
		compilers: Compiler[],
		fn: (
			compiler: Compiler,
			callback: CallbackWebpackFunction_2<MultiStats, void>
		) => void,
		callback: CallbackWebpackFunction_2<Stats[], void>
	): void;

	/**
	 * Returns a compiler watcher.
	 */
	watch(
		watchOptions: WatchOptions | WatchOptions[],
		handler: CallbackWebpackFunction_2<MultiStats, void>
	): undefined | MultiWatching;

	/**
	 * Processes the provided multi stat.
	 */
	run(callback: CallbackWebpackFunction_2<MultiStats, void>): void;
	purgeInputFileSystem(): void;

	/**
	 * Processes the provided error callback.
	 */
	close(callback: (err: null | Error, result?: void) => void): void;
}

/**
 * Defines the multi compiler options type used by this module.
 */
declare interface MultiCompilerOptions {
	/**
	 * how many Compilers are allows to run at the same time in parallel
	 */
	parallelism?: number;

	/**
	 * plugins applied once to the MultiCompiler when it is created
	 */
	plugins?: (
		| undefined
		| null
		| false
		| ""
		| 0
		| ((this: MultiCompiler, compiler: MultiCompiler) => void)
		| MultiCompilerPluginInstance
	)[];
}

/**
 * A plugin applied to the MultiCompiler itself rather than to each child.
 */
declare interface MultiCompilerPluginInstance {
	/**
	 * called once with the MultiCompiler
	 */
	apply: (compiler: MultiCompiler) => void;
}
type MultiConfiguration = ReadonlyArray<Configuration> & MultiCompilerOptions;
declare abstract class MultiStats {
	stats: Stats[];
	get hash(): string;

	/**
	 * Checks whether this multi stats has errors.
	 */
	hasErrors(): boolean;

	/**
	 * Checks whether this multi stats has warnings.
	 */
	hasWarnings(): boolean;

	/**
	 * Returns json output.
	 */
	toJson(
		options?:
			| boolean
			| StatsOptions
			| "none"
			| "summary"
			| "errors-only"
			| "errors-warnings"
			| "minimal"
			| "normal"
			| "detailed"
			| "verbose"
	): StatsCompilation;

	/**
	 * Returns a string representation.
	 */
	toString(
		options?:
			| boolean
			| StatsOptions
			| "none"
			| "summary"
			| "errors-only"
			| "errors-warnings"
			| "minimal"
			| "normal"
			| "detailed"
			| "verbose"
	): string;
}
declare abstract class MultiWatching {
	watchings: Watching[];
	compiler: MultiCompiler;

	/**
	 * Processes the provided error callback.
	 */
	invalidate(callback?: (err: null | Error, result?: void) => void): void;
	suspend(): void;
	resume(): void;

	/**
	 * Processes the provided error callback.
	 */
	close(callback: (err: null | Error, result?: void) => void): void;
}

/**
 * A mutable lexer token. The `next` / `consume` hot path reuses a single
 * instance per `TokenStream` (the lexer writes into it instead of allocating
 * one object per token), which also keeps the parser's `t.type` reads
 * monomorphic. All fields are present from construction so the shape never
 * transitions; type-specific fields (`isId` / `contentStart` / `contentEnd` /
 * `unitStart`) carry stale values for unrelated token types and are only read
 * by `tokenToNode` for the matching type. Pass a fresh one per `readToken` call
 * to collect the raw token list (e.g. tests).
 */
declare interface MutableToken {
	/**
	 * a `TokenType`
	 */
	type: number;

	/**
	 * byte offset of the token's first code point
	 */
	start: number;

	/**
	 * byte offset just past the token's last code point
	 */
	end: number;

	/**
	 * hash tokens: starts an ident sequence
	 */
	isId: boolean;

	/**
	 * url tokens: first content code point
	 */
	contentStart: number;

	/**
	 * url tokens: just past the last content code point
	 */
	contentEnd: number;

	/**
	 * dimension tokens: first unit-ident code point
	 */
	unitStart: number;
}
declare class NamedChunkIdsPlugin {
	/**
	 * Creates an instance of NamedChunkIdsPlugin.
	 */
	constructor(options?: NamedChunkIdsPluginOptions);
	options: NamedChunkIdsPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the named chunk ids plugin options type used by this module.
 */
declare interface NamedChunkIdsPluginOptions {
	/**
	 * context
	 */
	context?: string;

	/**
	 * delimiter
	 */
	delimiter?: string;
}
declare class NamedModuleIdsPlugin {
	/**
	 * Creates an instance of NamedModuleIdsPlugin.
	 */
	constructor(options?: NamedModuleIdsPluginOptions);
	options: NamedModuleIdsPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the named module ids plugin options type used by this module.
 */
declare interface NamedModuleIdsPluginOptions {
	/**
	 * context
	 */
	context?: string;
}
declare class NaturalModuleIdsPlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the need build context type used by this module.
 */
declare interface NeedBuildContext {
	compilation: Compilation;
	fileSystemInfo: FileSystemInfo;
	valueCacheVersions: Map<string, ValueCacheVersion>;
}
declare interface NewContentCreateContextMap {
	[index: string]: string;
}
declare class NoEmitOnErrorsPlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare class NodeEnvironmentPlugin {
	/**
	 * Creates an instance of NodeEnvironmentPlugin.
	 */
	constructor(options: NodeEnvironmentPluginOptions);
	options: NodeEnvironmentPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the node environment plugin options type used by this module.
 */
declare interface NodeEnvironmentPluginOptions {
	/**
	 * infrastructure logging options
	 */
	infrastructureLogging: InfrastructureLogging;
}
type NodeEstreeIndex =
	| Program
	| ImportDeclaration
	| ExportNamedDeclaration
	| ExportAllDeclaration
	| ImportExpressionImport
	| UnaryExpression
	| ArrayExpression
	| ArrowFunctionExpression
	| AssignmentExpression
	| AwaitExpression
	| BinaryExpression
	| SimpleCallExpression
	| NewExpression
	| ChainExpression
	| ClassExpression
	| ConditionalExpression
	| FunctionExpression
	| Identifier
	| SimpleLiteral
	| RegExpLiteral
	| BigIntLiteral
	| LogicalExpression
	| MemberExpression
	| MetaProperty
	| ObjectExpression
	| SequenceExpression
	| TaggedTemplateExpression
	| TemplateLiteral
	| ThisExpression
	| UpdateExpression
	| YieldExpression
	| SpreadElement
	| PrivateIdentifier
	| Super
	| FunctionDeclaration
	| VariableDeclaration
	| ClassDeclaration
	| ExpressionStatement
	| BlockStatement
	| StaticBlock
	| EmptyStatement
	| DebuggerStatement
	| WithStatement
	| ReturnStatement
	| LabeledStatement
	| BreakStatement
	| ContinueStatement
	| IfStatement
	| SwitchStatement
	| ThrowStatement
	| TryStatement
	| WhileStatement
	| DoWhileStatement
	| ForStatement
	| ForInStatement
	| ForOfStatement
	| ExportDefaultDeclaration
	| MethodDefinition
	| PropertyDefinition
	| VariableDeclarator
	| Property
	| CatchClause
	| ClassBody
	| SwitchCase
	| TemplateElement
	| AssignmentProperty
	| ImportSpecifier
	| ImportDefaultSpecifier
	| ImportNamespaceSpecifier
	| ExportSpecifier
	| ObjectPattern
	| ArrayPattern
	| RestElement
	| AssignmentPattern;

/**
 * a node as this parser builds one, whichever fields the options asked for
 */
declare interface NodeLike {
	type: string;
	start: number;
	end: number;
	loc?: null | SourceLocation;
	sourceFile?: string;
	range?: [number, number];
}

/**
 * Options object for node compatibility features.
 */
declare interface NodeOptions {
	/**
	 * Include a polyfill for the '__dirname' variable.
	 */
	__dirname?: boolean | "warn-mock" | "mock" | "node-module" | "eval-only";

	/**
	 * Include a polyfill for the '__filename' variable.
	 */
	__filename?: boolean | "warn-mock" | "mock" | "node-module" | "eval-only";

	/**
	 * Include a polyfill for the 'global' variable.
	 */
	global?: boolean | "warn";
}

/**
 * A language's parts, by node type: what its `Field`s and `Flag`s apply to.
 */
declare interface NodeParts {
	/**
	 * every `NodeType` member
	 */
	types: number;

	/**
	 * every `Field`
	 */
	field: number;

	/**
	 * every `Flag`
	 */
	flag: number;

	/**
	 * every `Part` with a position
	 */
	part: number;

	/**
	 * every `Part` with text beyond the name and value
	 */
	text: number;

	/**
	 * the `Field`s of each node type
	 */
	fields: Record<number, number>;

	/**
	 * the `Flag`s of each node type
	 */
	flags: Record<number, number>;

	/**
	 * the `Part`s with a position, by node type
	 */
	parts: Record<number, number>;

	/**
	 * the `Part`s with text, by node type
	 */
	texts: Record<number, number>;

	/**
	 * the node type of each `Field`'s items
	 */
	items: Record<number, number>;
}
type NodePath<TNode, TValue = unknown> = NodePathReads<TNode, TValue> &
	NodePathFields<TNode>;

/**
 * Structure read through a language's `Field`, `Flag` and `Part`. Declared as
 * methods so a language's path may accept only the parts each node type has.
 */
declare interface NodePathFields<TNode> {
	field(i: number, field: number, n?: TNode): TNode;
	fieldCount(field: number, n?: TNode): number;
	fieldNamed(field: number, name: string, n?: TNode): TNode;
	flag(flag: number, n?: TNode): boolean;
	rangeOf(part: number, n?: TNode): null | [number, number];
	startOf(part: number, n?: TNode): number;
	endOf(part: number, n?: TNode): number;
	textOf(part: number, n?: TNode): null | string;
	within(type: number): boolean;
}
declare interface NodePathReads<TNode, TValue = unknown> {
	/**
	 * the current node
	 */
	node: TNode;

	/**
	 * the enclosing node (null at a root)
	 */
	parent: null | TNode;

	/**
	 * the current node's index among its siblings
	 */
	index: number;

	/**
	 * stop the walk descending into the current node (enter only)
	 */
	skipChildren: () => void;

	/**
	 * end the walk: no visitor fires after the current one returns, and a print still completes
	 */
	stop: () => void;

	/**
	 * the run's state, as `process` was given it
	 */
	state: unknown;

	/**
	 * the node's `NodeType`
	 */
	type: (n?: TNode) => number;

	/**
	 * start and end offsets in the input
	 */
	range: (n?: TNode) => [number, number];

	/**
	 * where the node starts in the input
	 */
	start: (n?: TNode) => number;

	/**
	 * where the node ends in the input
	 */
	end: (n?: TNode) => number;

	/**
	 * start line and column, end line and column (lines from 1, columns from 0)
	 */
	loc: (n?: TNode) => [number, number, number, number];

	/**
	 * the node's source text, or the input between two offsets
	 */
	source: (n?: number | TNode, end?: number) => string;

	/**
	 * the node's name as the language defines it, decoded ("" when it has none)
	 */
	name: (n?: TNode) => string;

	/**
	 * the node's value as the language defines it, decoded
	 */
	value: (n?: TNode) => TValue;

	/**
	 * number of children
	 */
	childCount: (n?: TNode) => number;

	/**
	 * the i-th child
	 */
	child: (i: number, n?: TNode) => TNode;

	/**
	 * every child as a new array
	 */
	children: (n?: TNode) => TNode[];
}

/**
 * A language node printer, fired for one node once all its visitors have run and
 * its children are printed. It takes the same `path` a visitor gets plus the
 * print context as its `writer`; it switches on `path.type()` and **returns** the
 * node's serialized text, reading its children's text from `writer.get` — knowing
 * nothing of the walk. Returning (rather than writing to a buffer) is what lets a
 * parent compose / transform its text from its finished children.
 */
declare interface NodePrinter<TPath, TNode, TPrintOptions = object> {
	(path: TPath, writer: PrintContext<TPath, TNode, TPrintOptions>): string;
}

/**
 * One of terser's AST nodes: the fields and methods the phases share typed, the
 * rest open.
 */
declare interface NodeShape {
	[index: string]: any;
	TYPE: string;
	type: string;
	mapName?: null | string;
	shorthand: boolean;
	name: string;
	kind: string;
	role: string;
	computed: boolean;
	label: NodeShape;
	property: NodeShape;
	flags: number;
	startToken: any;
	endToken: any;
	expression: NodeShape;
	callee: NodeShape;
	object: NodeShape;
	argument: NodeShape;
	discriminant: NodeShape;
	left: NodeShape;
	right: NodeShape;
	operator: string;
	test: NodeShape;
	alternate: NodeShape;
	arguments: NodeShape[];
	elements: (null | NodeShape)[];
	properties: NodeShape[];
	declarations: NodeShape[];
	expressions: NodeShape[];
	segments: NodeShape[];
	params: NodeShape[];
	quote?: string;
	raw?: string;
	optional: boolean;
	tag: NodeShape;
	superClass: NodeShape;
	scope: NodeShape;
	definition: SymbolDefinition;
	fixed_value(): undefined | null | false | NodeShape;
	tail_node(): NodeShape;
	clone(deep?: boolean): NodeShape;
	transform(walker: CompressorShape, inList?: boolean): NodeShape;
	optimize(compressor: CompressorShape): NodeShape;
	has_side_effects(compressor: CompressorShape): boolean;
	may_throw(compressor: CompressorShape): boolean;
	drop_side_effect_free(
		compressor: CompressorShape,
		firstInStatement?: boolean
	): null | NodeShape;
	is_constant_expression(scope?: NodeShape): boolean | "f";
	evaluate(
		compressor: CompressorShape
	):
		| undefined
		| null
		| string
		| number
		| bigint
		| boolean
		| symbol
		| RegExp
		| NodeShape
		| any
		| { [index: string]: any }
		| ((...args: any[]) => any);
	negate(compressor: CompressorShape, firstInStatement?: boolean): NodeShape;
	size(compressor?: CompressorShape, stack?: NodeShape[]): number;
}
declare class NodeSourcePlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Base AST node — the property-accessor view the `parseA*` entry points return
 * (see `_makeReader`). Every concrete node carries the `[start, end)` byte
 * `range` of the source slice it covers; `loc` is computed on demand from the
 * shared `LocConverter`, so line/column conversion is only paid when a consumer
 * needs it. The concrete node typedefs below extend this via `&`.
 * Inside the parser a node ref is an integer id into the columns; the reader
 * exposes this property shape over a retained snapshot of those columns.
 */
declare interface NodeSyntaxParser {
	/**
	 * node-type discriminator
	 */
	type: number;

	/**
	 * byte offset of the node's first code point
	 */
	start: number;

	/**
	 * byte offset just past the node's last code point
	 */
	end: number;

	/**
	 * the `[start, end)` byte range
	 */
	range: [number, number];

	/**
	 * source location (1-based line, 0-based column)
	 */
	loc: {
		start: { line: number; column: number };
		end: { line: number; column: number };
	};

	/**
	 * source slice for this node
	 */
	toString: () => string;

	/**
	 * name with CSS escapes resolved (name-bearing nodes only)
	 */
	unescapedName: string;
}
declare class NodeTargetPlugin {
	/**
	 * Creates an instance of NodeTargetPlugin.
	 */
	constructor(type?: ExternalsType);
	type: ExternalsType;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
	static builtins: (string | RegExp)[];
}
declare class NodeTemplatePlugin {
	/**
	 * Creates an instance of NodeTemplatePlugin.
	 */
	constructor(options?: NodeTemplatePluginOptions);

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Represents the node template plugin runtime component.
 */
declare interface NodeTemplatePluginOptions {
	/**
	 * enable async chunk loading
	 */
	asyncChunkLoading?: boolean;
}
type NodeWebpackOptions = false | NodeOptions;
type NonNullable<T> = T & {};
declare class NormalModule extends Module {
	constructor(__0: NormalModuleCreateData<string>);
	request: string;
	userRequest: string;
	rawRequest: string;
	binary: boolean;
	parser?: Parser;
	parserOptions?: ParserOptionsNormalModule;
	generator?: Generator;
	generatorOptions?: GeneratorOptions;
	resource: string;
	resourceResolveData?: ResourceSchemeData & Partial<ResolveRequest>;
	matchResource?: string;
	loaders: LoaderItem[];
	extractSourceMap: boolean;
	hot: boolean;
	error: null | Error;
	getResource(): null | string;

	/**
	 * restore unsafe cache data
	 */
	restoreFromUnsafeCache(
		unsafeCacheData: UnsafeCacheData,
		normalModuleFactory: NormalModuleFactory
	): void;
	createSourceForAsset(
		context: string,
		name: string,
		content: string | Buffer,
		sourceMap?: string | RawSourceMap,
		associatedObjectForCache?: object
	): Source;
	getCurrentLoader(
		loaderContext: AnyLoaderContext,
		index?: number
	): null | LoaderItem;
	createSource(
		context: string,
		content: string | Buffer,
		sourceMap?: null | string | RawSourceMap,
		associatedObjectForCache?: object
	): Source;

	/**
	 * Marks the module as failed, so what it generates says so. A tap or a
	 * loader may fail with anything, and what reads the failure expects an error.
	 */
	markModuleAsErrored(error?: any): void;

	/**
	 * An absolute path string is a prefix of `content`; a relative one is a glob
	 * matched against the resource path, without loaders and query.
	 */
	applyNoParseRule(
		rule: string | RegExp | ((content: string) => boolean),
		content: string
	): boolean;
	shouldPreventParsing(
		noParseRule:
			| undefined
			| string
			| RegExp
			| (string | RegExp | ((content: string) => boolean))[]
			| ((content: string) => boolean),
		request: string
	): boolean;
	static getCompilationHooks(compilation: Compilation): {
		/**
		 * Use the `readResource` hook instead.
		 * @deprecated
		 */
		readResourceForScheme: HookMap<
			FakeHook<
				AsyncSeriesBailHook<[string, NormalModule], null | string | Buffer>
			>
		>;
		/**
		 * @since 5.58.0
		 */
		readResource: HookMap<
			AsyncSeriesBailHook<[AnyLoaderContext], null | string | Buffer>
		>;
		loader: SyncHook<[AnyLoaderContext, NormalModule]>;
		beforeLoaders: SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>;
		/**
		 * Async since 5.112.0, so a tap can resolve values a module needs
		 * before it is parsed. `tap` keeps working.
		 * @since 5.59.0
		 */
		beforeParse: AsyncSeriesHook<[NormalModule]>;
		/**
		 * @since 5.59.0
		 */
		beforeSnapshot: SyncHook<[NormalModule]>;
		/**
		 * Async since 5.111.0, so a tap can await work of its own — minifying an
		 * asset, say, which before only a loader could do. `tap` keeps working.
		 * @since 5.99.0
		 */
		processResult: AsyncSeriesWaterfallHook<
			[
				[
					string | Buffer,
					undefined | string | RawSourceMap,
					undefined | PreparsedAst
				],
				NormalModule
			],
			[
				string | Buffer,
				undefined | string | RawSourceMap,
				undefined | PreparsedAst
			]
		>;
		/**
		 * @since 5.49.0
		 */
		needBuild: AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>;
	};
	static deserialize(
		context: ObjectDeserializerContextObjectMiddlewareObject_2
	): NormalModule;
	static KINDS: Set<
		| "html"
		| "runtime"
		| "normal"
		| "css"
		| "context"
		| "remote"
		| "consume-shared"
		| "external"
		| "concatenated"
	>;

	/**
	 * Gets source basic types.
	 * @deprecated In the next major release, call getSourceBasicTypes() directly on the module instance instead of using this static method.
	 */
	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
}
type NormalModuleBuildInfo = KnownBuildInfo &
	Record<string, any> &
	KnownNormalModuleBuildInfo;
declare interface NormalModuleCreateData<T extends string = string> {
	/**
	 * an optional layer in which the module is
	 */
	layer?: string;

	/**
	 * module type. When deserializing, this is set to an empty string "".
	 */
	type: T;

	/**
	 * request string
	 */
	request: string;

	/**
	 * request intended by user (without loaders from config)
	 */
	userRequest: string;

	/**
	 * request without resolving
	 */
	rawRequest: string;

	/**
	 * list of loaders
	 */
	loaders: LoaderItem[];

	/**
	 * path + query of the real resource
	 */
	resource: string;

	/**
	 * resource resolve data
	 */
	resourceResolveData?: ResourceSchemeData & Partial<ResolveRequest>;

	/**
	 * context directory for resolving
	 */
	context: string;

	/**
	 * path + query of the matched resource (virtual)
	 */
	matchResource?: string;

	/**
	 * the parser used
	 */
	parser: (Record<"javascript/auto", JavascriptParser> &
		Record<"javascript/dynamic", JavascriptParser> &
		Record<"javascript/esm", JavascriptParser> &
		Record<"json", JsonParser> &
		Record<"asset", AssetParser> &
		Record<"asset/inline", AssetParser> &
		Record<"asset/resource", AssetParser> &
		Record<"asset/source", AssetSourceParser> &
		Record<"asset/bytes", AssetBytesParser> &
		Record<"webassembly/async", AsyncWebAssemblyParser> &
		Record<"webassembly/sync", WebAssemblyParser> &
		Record<"css", CssParser> &
		Record<"css/auto", CssParser> &
		Record<"css/module", CssParser> &
		Record<"css/global", CssParser> &
		Record<"html", HtmlParser> &
		Record<string, Parser>)[T];

	/**
	 * the options of the parser used
	 */
	parserOptions?: (Record<"javascript/auto", JavascriptParserOptions> &
		Record<"javascript/dynamic", JavascriptParserOptions> &
		Record<"javascript/esm", JavascriptParserOptions> &
		Record<"json", JsonParserOptions> &
		Record<"asset", AssetParserOptions> &
		Record<"asset/inline", EmptyParserOptions> &
		Record<"asset/resource", EmptyParserOptions> &
		Record<"asset/source", EmptyParserOptions> &
		Record<"asset/bytes", EmptyParserOptions> &
		Record<"webassembly/async", EmptyParserOptions> &
		Record<"webassembly/sync", EmptyParserOptions> &
		Record<"css", CssParserOptions> &
		Record<"css/auto", CssModuleParserOptions> &
		Record<"css/module", CssModuleParserOptions> &
		Record<"css/global", CssModuleParserOptions> &
		Record<"html", EmptyParserOptions> &
		Record<string, ParserOptionsNormalModule>)[T];

	/**
	 * the generator used
	 */
	generator: (Record<"javascript/auto", JavascriptGenerator> &
		Record<"javascript/dynamic", JavascriptGenerator> &
		Record<"javascript/esm", JavascriptGenerator> &
		Record<"json", JsonGenerator> &
		Record<"asset", AssetGenerator> &
		Record<"asset/inline", AssetGenerator> &
		Record<"asset/resource", AssetGenerator> &
		Record<"asset/source", AssetSourceGenerator> &
		Record<"asset/bytes", AssetBytesGenerator> &
		Record<"webassembly/async", Generator> &
		Record<"webassembly/sync", Generator> &
		Record<"css", CssGenerator> &
		Record<"css/auto", CssGenerator> &
		Record<"css/module", CssGenerator> &
		Record<"css/global", CssGenerator> &
		Record<"html", HtmlGenerator> &
		Record<string, Generator>)[T];

	/**
	 * the options of the generator used
	 */
	generatorOptions?: (Record<"javascript/auto", EmptyGeneratorOptions> &
		Record<"javascript/dynamic", EmptyGeneratorOptions> &
		Record<"javascript/esm", EmptyGeneratorOptions> &
		Record<"json", JsonGeneratorOptions> &
		Record<"asset", AssetGeneratorOptions> &
		Record<"asset/inline", AssetGeneratorOptions> &
		Record<"asset/resource", AssetGeneratorOptions> &
		Record<"asset/source", EmptyGeneratorOptions> &
		Record<"asset/bytes", EmptyGeneratorOptions> &
		Record<"webassembly/async", EmptyGeneratorOptions> &
		Record<"webassembly/sync", EmptyGeneratorOptions> &
		Record<"css", CssGeneratorOptions> &
		Record<"css/auto", CssModuleGeneratorOptions> &
		Record<"css/module", CssModuleGeneratorOptions> &
		Record<"css/global", CssModuleGeneratorOptions> &
		Record<"html", HtmlGeneratorOptions> &
		Record<string, GeneratorOptions>)[T];

	/**
	 * options used for resolving requests from this module
	 */
	resolveOptions?: ResolveOptionsWebpackOptions;

	/**
	 * enable/disable extracting source map
	 */
	extractSourceMap: boolean;
}
declare abstract class NormalModuleFactory extends ModuleFactory {
	hooks: Readonly<{
		resolve: AsyncSeriesBailHook<[ResolveData], false | void | Module>;
		resolveForScheme: HookMap<
			AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>
		>;
		/**
		 * @since 5.49.0
		 */
		resolveInScheme: HookMap<
			AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>
		>;
		factorize: AsyncSeriesBailHook<[ResolveData], undefined | Module>;
		beforeResolve: AsyncSeriesBailHook<[ResolveData], false | void>;
		afterResolve: AsyncSeriesBailHook<[ResolveData], false | void>;
		createModule: AsyncSeriesBailHook<[CreateData, ResolveData], void | Module>;
		module: SyncWaterfallHook<[Module, CreateData, ResolveData], Module>;
		/**
		 * @since 5.110.0
		 */
		prepareModuleType: HookMap<AsyncSeriesHook<[]>>;
		createParser: TypedHookMap<
			Record<
				"javascript/auto",
				SyncBailHook<[JavascriptParserOptions], JavascriptParser>
			> &
				Record<
					"javascript/dynamic",
					SyncBailHook<[JavascriptParserOptions], JavascriptParser>
				> &
				Record<
					"javascript/esm",
					SyncBailHook<[JavascriptParserOptions], JavascriptParser>
				> &
				Record<"json", SyncBailHook<[JsonParserOptions], JsonParser>> &
				Record<"asset", SyncBailHook<[AssetParserOptions], AssetParser>> &
				Record<
					"asset/inline",
					SyncBailHook<[EmptyParserOptions], AssetParser>
				> &
				Record<
					"asset/resource",
					SyncBailHook<[EmptyParserOptions], AssetParser>
				> &
				Record<
					"asset/source",
					SyncBailHook<[EmptyParserOptions], AssetSourceParser>
				> &
				Record<
					"asset/bytes",
					SyncBailHook<[EmptyParserOptions], AssetBytesParser>
				> &
				Record<
					"webassembly/async",
					SyncBailHook<[EmptyParserOptions], AsyncWebAssemblyParser>
				> &
				Record<
					"webassembly/sync",
					SyncBailHook<[EmptyParserOptions], WebAssemblyParser>
				> &
				Record<"css", SyncBailHook<[CssParserOptions], CssParser>> &
				Record<"css/auto", SyncBailHook<[CssModuleParserOptions], CssParser>> &
				Record<
					"css/module",
					SyncBailHook<[CssModuleParserOptions], CssParser>
				> &
				Record<
					"css/global",
					SyncBailHook<[CssModuleParserOptions], CssParser>
				> &
				Record<"html", SyncBailHook<[EmptyParserOptions], HtmlParser>> &
				Record<string, SyncBailHook<[ParserOptionsNormalModule], Parser>>
		>;
		parser: TypedHookMap<
			Record<
				"javascript/auto",
				SyncBailHook<[JavascriptParser, JavascriptParserOptions], void>
			> &
				Record<
					"javascript/dynamic",
					SyncBailHook<[JavascriptParser, JavascriptParserOptions], void>
				> &
				Record<
					"javascript/esm",
					SyncBailHook<[JavascriptParser, JavascriptParserOptions], void>
				> &
				Record<"json", SyncBailHook<[JsonParser, JsonParserOptions], void>> &
				Record<"asset", SyncBailHook<[AssetParser, AssetParserOptions], void>> &
				Record<
					"asset/inline",
					SyncBailHook<[AssetParser, EmptyParserOptions], void>
				> &
				Record<
					"asset/resource",
					SyncBailHook<[AssetParser, EmptyParserOptions], void>
				> &
				Record<
					"asset/source",
					SyncBailHook<[AssetSourceParser, EmptyParserOptions], void>
				> &
				Record<
					"asset/bytes",
					SyncBailHook<[AssetBytesParser, EmptyParserOptions], void>
				> &
				Record<
					"webassembly/async",
					SyncBailHook<[AsyncWebAssemblyParser, EmptyParserOptions], void>
				> &
				Record<
					"webassembly/sync",
					SyncBailHook<[WebAssemblyParser, EmptyParserOptions], void>
				> &
				Record<"css", SyncBailHook<[CssParser, CssParserOptions], void>> &
				Record<
					"css/auto",
					SyncBailHook<[CssParser, CssModuleParserOptions], void>
				> &
				Record<
					"css/module",
					SyncBailHook<[CssParser, CssModuleParserOptions], void>
				> &
				Record<
					"css/global",
					SyncBailHook<[CssParser, CssModuleParserOptions], void>
				> &
				Record<"html", SyncBailHook<[HtmlParser, EmptyParserOptions], void>> &
				Record<string, SyncBailHook<[Parser, ParserOptionsNormalModule], void>>
		>;
		createGenerator: TypedHookMap<
			Record<
				"javascript/auto",
				SyncBailHook<[EmptyGeneratorOptions], JavascriptGenerator>
			> &
				Record<
					"javascript/dynamic",
					SyncBailHook<[EmptyGeneratorOptions], JavascriptGenerator>
				> &
				Record<
					"javascript/esm",
					SyncBailHook<[EmptyGeneratorOptions], JavascriptGenerator>
				> &
				Record<"json", SyncBailHook<[JsonGeneratorOptions], JsonGenerator>> &
				Record<"asset", SyncBailHook<[AssetGeneratorOptions], AssetGenerator>> &
				Record<
					"asset/inline",
					SyncBailHook<[AssetGeneratorOptions], AssetGenerator>
				> &
				Record<
					"asset/resource",
					SyncBailHook<[AssetGeneratorOptions], AssetGenerator>
				> &
				Record<
					"asset/source",
					SyncBailHook<[EmptyGeneratorOptions], AssetSourceGenerator>
				> &
				Record<
					"asset/bytes",
					SyncBailHook<[EmptyGeneratorOptions], AssetBytesGenerator>
				> &
				Record<
					"webassembly/async",
					SyncBailHook<[EmptyGeneratorOptions], Generator>
				> &
				Record<
					"webassembly/sync",
					SyncBailHook<[EmptyGeneratorOptions], Generator>
				> &
				Record<"css", SyncBailHook<[CssGeneratorOptions], CssGenerator>> &
				Record<
					"css/auto",
					SyncBailHook<[CssModuleGeneratorOptions], CssGenerator>
				> &
				Record<
					"css/module",
					SyncBailHook<[CssModuleGeneratorOptions], CssGenerator>
				> &
				Record<
					"css/global",
					SyncBailHook<[CssModuleGeneratorOptions], CssGenerator>
				> &
				Record<"html", SyncBailHook<[HtmlGeneratorOptions], HtmlGenerator>> &
				Record<string, SyncBailHook<[GeneratorOptions], Generator>>
		>;
		generator: TypedHookMap<
			Record<
				"javascript/auto",
				SyncBailHook<[JavascriptGenerator, EmptyGeneratorOptions], void>
			> &
				Record<
					"javascript/dynamic",
					SyncBailHook<[JavascriptGenerator, EmptyGeneratorOptions], void>
				> &
				Record<
					"javascript/esm",
					SyncBailHook<[JavascriptGenerator, EmptyGeneratorOptions], void>
				> &
				Record<
					"json",
					SyncBailHook<[JsonGenerator, JsonGeneratorOptions], void>
				> &
				Record<
					"asset",
					SyncBailHook<[AssetGenerator, AssetGeneratorOptions], void>
				> &
				Record<
					"asset/inline",
					SyncBailHook<[AssetGenerator, AssetGeneratorOptions], void>
				> &
				Record<
					"asset/resource",
					SyncBailHook<[AssetGenerator, AssetGeneratorOptions], void>
				> &
				Record<
					"asset/source",
					SyncBailHook<[AssetSourceGenerator, EmptyGeneratorOptions], void>
				> &
				Record<
					"asset/bytes",
					SyncBailHook<[AssetBytesGenerator, EmptyGeneratorOptions], void>
				> &
				Record<
					"webassembly/async",
					SyncBailHook<[Generator, EmptyGeneratorOptions], void>
				> &
				Record<
					"webassembly/sync",
					SyncBailHook<[Generator, EmptyGeneratorOptions], void>
				> &
				Record<"css", SyncBailHook<[CssGenerator, CssGeneratorOptions], void>> &
				Record<
					"css/auto",
					SyncBailHook<[CssGenerator, CssModuleGeneratorOptions], void>
				> &
				Record<
					"css/module",
					SyncBailHook<[CssGenerator, CssModuleGeneratorOptions], void>
				> &
				Record<
					"css/global",
					SyncBailHook<[CssGenerator, CssModuleGeneratorOptions], void>
				> &
				Record<
					"html",
					SyncBailHook<[HtmlGenerator, HtmlGeneratorOptions], void>
				> &
				Record<string, SyncBailHook<[Generator, GeneratorOptions], void>>
		>;
		/**
		 * @since 5.81.0
		 */
		createModuleClass: HookMap<
			SyncBailHook<[CreateData, ResolveData], void | Module>
		>;
	}>;
	resolverFactory: ResolverFactory;
	ruleSet: RuleSet;
	context: string;
	fs: InputFileSystem;
	parserCache: Map<string, WeakMap<ParserOptionsNormalModule, Parser>>;
	generatorCache: Map<string, WeakMap<GeneratorOptions, Generator>>;
	cleanupForCache(): void;

	/**
	 * Processes the provided context info.
	 */
	resolveResource(
		contextInfo: ModuleFactoryCreateDataContextInfo,
		context: string,
		unresolvedResource: string,
		resolver: ResolverWithOptions,
		resolveContext: ResolveContext,
		callback: (
			err: null | Error,
			res?: string | false,
			req?: ResolveRequest
		) => void
	): void;

	/**
	 * Resolves request array.
	 */
	resolveRequestArray(
		contextInfo: ModuleFactoryCreateDataContextInfo,
		context: string,
		array: LoaderItem[],
		resolver: ResolverWithOptions,
		resolveContext: ResolveContext,
		callback: CallbackWebpackFunction_1<LoaderItem[]>
	): void;

	/**
	 * Returns parser.
	 */
	getParser<T extends string>(
		type: T,
		parserOptions?: ParserOptionsNormalModule
	): (Record<"javascript/auto", JavascriptParser> &
		Record<"javascript/dynamic", JavascriptParser> &
		Record<"javascript/esm", JavascriptParser> &
		Record<"json", JsonParser> &
		Record<"asset", AssetParser> &
		Record<"asset/inline", AssetParser> &
		Record<"asset/resource", AssetParser> &
		Record<"asset/source", AssetSourceParser> &
		Record<"asset/bytes", AssetBytesParser> &
		Record<"webassembly/async", AsyncWebAssemblyParser> &
		Record<"webassembly/sync", WebAssemblyParser> &
		Record<"css", CssParser> &
		Record<"css/auto", CssParser> &
		Record<"css/module", CssParser> &
		Record<"css/global", CssParser> &
		Record<"html", HtmlParser> &
		Record<string, Parser>)[T];

	/**
	 * Creates a parser from the provided type.
	 */
	createParser<T extends string>(
		type: T,
		parserOptions?: ParserOptionsNormalModule
	): (Record<"javascript/auto", JavascriptParser> &
		Record<"javascript/dynamic", JavascriptParser> &
		Record<"javascript/esm", JavascriptParser> &
		Record<"json", JsonParser> &
		Record<"asset", AssetParser> &
		Record<"asset/inline", AssetParser> &
		Record<"asset/resource", AssetParser> &
		Record<"asset/source", AssetSourceParser> &
		Record<"asset/bytes", AssetBytesParser> &
		Record<"webassembly/async", AsyncWebAssemblyParser> &
		Record<"webassembly/sync", WebAssemblyParser> &
		Record<"css", CssParser> &
		Record<"css/auto", CssParser> &
		Record<"css/module", CssParser> &
		Record<"css/global", CssParser> &
		Record<"html", HtmlParser> &
		Record<string, Parser>)[T];

	/**
	 * Returns generator.
	 */
	getGenerator<T extends string>(
		type: T,
		generatorOptions?: GeneratorOptions
	): (Record<"javascript/auto", JavascriptGenerator> &
		Record<"javascript/dynamic", JavascriptGenerator> &
		Record<"javascript/esm", JavascriptGenerator> &
		Record<"json", JsonGenerator> &
		Record<"asset", AssetGenerator> &
		Record<"asset/inline", AssetGenerator> &
		Record<"asset/resource", AssetGenerator> &
		Record<"asset/source", AssetSourceGenerator> &
		Record<"asset/bytes", AssetBytesGenerator> &
		Record<"webassembly/async", Generator> &
		Record<"webassembly/sync", Generator> &
		Record<"css", CssGenerator> &
		Record<"css/auto", CssGenerator> &
		Record<"css/module", CssGenerator> &
		Record<"css/global", CssGenerator> &
		Record<"html", HtmlGenerator> &
		Record<string, Generator>)[T];

	/**
	 * Creates a generator.
	 */
	createGenerator<T extends string>(
		type: T,
		generatorOptions?: GeneratorOptions
	): (Record<"javascript/auto", JavascriptGenerator> &
		Record<"javascript/dynamic", JavascriptGenerator> &
		Record<"javascript/esm", JavascriptGenerator> &
		Record<"json", JsonGenerator> &
		Record<"asset", AssetGenerator> &
		Record<"asset/inline", AssetGenerator> &
		Record<"asset/resource", AssetGenerator> &
		Record<"asset/source", AssetSourceGenerator> &
		Record<"asset/bytes", AssetBytesGenerator> &
		Record<"webassembly/async", Generator> &
		Record<"webassembly/sync", Generator> &
		Record<"css", CssGenerator> &
		Record<"css/auto", CssGenerator> &
		Record<"css/module", CssGenerator> &
		Record<"css/global", CssGenerator> &
		Record<"html", HtmlGenerator> &
		Record<string, Generator>)[T];

	/**
	 * Returns the resolver.
	 */
	getResolver(
		type: string,
		resolveOptions?: ResolveOptionsWithDependencyType
	): ResolverWithOptions;
}

/**
 * These properties are added by the NormalModule
 */
declare interface NormalModuleLoaderContext<OptionsType> {
	version: number;

	/**
	 * Extracts and parses the options of the current loader.
	 * Parses string options as JSON or a query string.
	 */
	getOptions: GetOptionsMethod<OptionsType>;

	/**
	 * Emits a warning for this module.
	 * The warning will be displayed to the user during compilation.
	 */
	emitWarning: (warning: string | Error) => void;

	/**
	 * Emits an error for this module.
	 * The error will be displayed to the user and typically causes the compilation to fail.
	 */
	emitError: (error: string | Error) => void;

	/**
	 * Gets a logger instance scoped to this loader and module.
	 * Useful for emitting debug or compilation information in a structured way.
	 */
	getLogger: (name?: string) => Logger;

	/**
	 * Resolves a module request (e.g., a relative path or module name) to an absolute file path.
	 * It uses Webpack's internal resolver, taking into account configured aliases and extensions.
	 */
	resolve: (
		context: string,
		request: string,
		callback: (
			err: null | ErrorWithDetail,
			res?: string | false,
			req?: ResolveRequest
		) => void
	) => void;

	/**
	 * Creates a resolve function with specific options.
	 * The returned function can be used as a Promise-based resolver or a callback-based resolver.
	 */
	getResolve: (options?: ResolveOptionsWithDependencyType) => DualModeResolve;

	/**
	 * Emits a new file (asset) to the compilation output directory.
	 * This allows loaders to generate additional files alongside the main module output.
	 */
	emitFile: (
		name: string,
		content: string | Buffer,
		sourceMap?: string,
		assetInfo?: AssetInfo
	) => void;
	addBuildDependency: (dep: string) => void;
	utils: LoaderContextUtils;
	rootContext: string;
	fs: InputFileSystem;
	sourceMap?: boolean;
	mode: "none" | "development" | "production";
	webpack?: boolean;
	hashFunction: HashFunction;
	hashDigest: string;
	hashDigestLength: number;
	hashSalt?: string;
	_module?: NormalModule;
	_compilation?: Compilation;
	_compiler?: Compiler;
}
declare class NormalModuleReplacementPlugin {
	/**
	 * Create an instance of the plugin
	 */
	constructor(
		resourceRegExp: RegExp,
		newResource: string | ((resolveData: ResolveData) => void)
	);
	resourceRegExp: RegExp;
	newResource: string | ((resolveData: ResolveData) => void);

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare abstract class NormalReexportItem {
	name: string;
	ids: string[];
	exportInfo: ExportInfo;
	checked: boolean;
	hidden: boolean;
}
declare interface NormalizedModules {
	[index: string]: VirtualModule;
}
type NormalizedStatsOptions = KnownNormalizedStatsOptions &
	Omit<
		StatsOptions,
		| "context"
		| "chunkGroups"
		| "requestShortener"
		| "chunksSort"
		| "modulesSort"
		| "chunkModulesSort"
		| "nestedModulesSort"
		| "assetsSort"
		| "ids"
		| "cachedAssets"
		| "groupAssetsByEmitStatus"
		| "groupAssetsByPath"
		| "groupAssetsByExtension"
		| "assetsSpace"
		| "excludeAssets"
		| "excludeModules"
		| "warningsFilter"
		| "cachedModules"
		| "orphanModules"
		| "dependentModules"
		| "runtimeModules"
		| "groupModulesByCacheStatus"
		| "groupModulesByLayer"
		| "groupModulesByAttributes"
		| "groupModulesByPath"
		| "groupModulesByExtension"
		| "groupModulesByType"
		| "entrypoints"
		| "chunkGroupAuxiliary"
		| "chunkGroupChildren"
		| "chunkGroupMaxAssets"
		| "modulesSpace"
		| "chunkModulesSpace"
		| "nestedModulesSpace"
		| "logging"
		| "loggingDebug"
		| "loggingTrace"
		| "_env"
	> &
	Record<string, any>;
declare class NullDependency extends Dependency {
	constructor();
	static Template: typeof NullDependencyTemplate;

	/**
	 * Compares two dependencies by source location for sorting a module's
	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
	 * its result, so comparing through it would retain a location object on every
	 * sorted dependency). These dependencies always carry a real source position,
	 * so only start (line, column) and the within-statement index are compared; a
	 * dependency without an index sorts after one that has an index at the same
	 * position.
	 */
	static compareLocations(a: Dependency, b: Dependency): 0 | 1 | -1;
	static NO_EXPORTS_REFERENCED: string[][];
	static EXPORTS_OBJECT_REFERENCED: string[][];
	static EXPORTS_OBJECT_REFERENCED_MANGLEABLE: string[][];

	/**
	 * Returns true if the dependency is a low priority dependency.
	 */
	static isLowPriorityDependency(dependency: Dependency): boolean;

	/**
	 * Returns true if the dependency can be concatenated (scope hoisting).
	 */
	static canConcatenate(
		dependency: Dependency,
		concatenateCommonJsModules: boolean
	): boolean;
	static TRANSITIVE: symbol;
	static LAZY_LOCAL_EXPORT: "local";
	static LAZY_NAMED_REEXPORT: "id";
	static LAZY_STAR_REEXPORT: "*";
	static LAZY_REEXPORT_SIDE_EFFECT: "@";
	static LAZY_IMPORT_DECLARATION: "import";
	static ESM_CATEGORY: "esm";
	static KINDS: Set<
		| "worker"
		| "css-import"
		| "css-url"
		| "entry"
		| "url"
		| "module-dependency"
		| "esm-import"
		| "provided"
		| "dynamic-import"
		| "esm-reexport"
		| "esm-export-specifier"
		| "esm-live-export"
		| "esm-side-effect-import"
		| "context-element"
		| "esm-bare-side-effect-import"
		| "esm-import-specifier"
		| "esm-evaluated-import-specifier"
		| "esm-compatibility"
		| "commonjs-require"
		| "commonjs-export-require"
		| "html-source"
		| "html-entry"
		| "webassembly-import"
		| "webassembly-export-imported"
		| "sharing-request"
		| "local-module"
		| "static-exports"
		| "loader-import"
		| "css-icss-import"
		| "css-icss-export"
	>;
}
declare class NullDependencyTemplate extends DependencyTemplate {
	constructor();
}
declare class NullFactory extends ModuleFactory {
	constructor();
}
declare interface ObjectConfiguration {
	[index: string]: any;
}
declare namespace ObjectDeserializerContextObjectMiddlewareObject_1 {
	export let read: () => any;
	export let rest: ObjectDeserializerContextObjectMiddlewareObject_2<
		ReadonlyArray<any>
	>;
	export let setCircularReference: (value: ReferenceableItem) => void;
}

/**
 * Defines the object deserializer context type used by this module.
 * `T` is the tuple of values read in order: `read` returns the head, and `rest`
 * re-types the same context to `Tail<T>` so successive reads stay positional.
 */
declare interface ObjectDeserializerContextObjectMiddlewareObject_2<
	T = ReadonlyArray<any>
> {
	read: () => Head<T>;
	rest: ObjectDeserializerContextObjectMiddlewareObject_2<Tail<T>>;
	setCircularReference: (value: ReferenceableItem) => void;
}

/**
 * Defines the object deserializer context type used by this module.
 * `T` is the tuple of values read in order: `read` returns the head, and `rest`
 * re-types the same context to `Tail<T>` so successive reads stay positional.
 */
declare interface ObjectDeserializerContextObjectMiddlewareObject_3 {
	read: () => string;
	rest: ObjectDeserializerContextObjectMiddlewareObject_2<[number, boolean]>;
	setCircularReference: (value: ReferenceableItem) => void;
}

/**
 * Defines the object encoding options type used by this module.
 */
declare interface ObjectEncodingOptionsFs {
	encoding?:
		| null
		| "ascii"
		| "utf8"
		| "utf-8"
		| "utf16le"
		| "utf-16le"
		| "ucs2"
		| "ucs-2"
		| "base64"
		| "base64url"
		| "latin1"
		| "binary"
		| "hex";
}
declare interface ObjectEncodingOptionsResolver {
	/**
	 * encoding
	 */
	encoding?:
		| null
		| "ascii"
		| "utf8"
		| "utf-8"
		| "utf16le"
		| "utf-16le"
		| "ucs2"
		| "ucs-2"
		| "base64"
		| "base64url"
		| "latin1"
		| "binary"
		| "hex";
}

/**
 * Defines the object serializer type used by this module.
 * Methods, so a serializer may narrow `value` to the class it is registered for.
 */
declare interface ObjectSerializer<T extends object = object> {
	serialize(
		value: T,
		context: ObjectSerializerContextObjectMiddlewareObject_3<ReadonlyArray<any>>
	): void;
	deserialize(
		context: ObjectDeserializerContextObjectMiddlewareObject_2<
			ReadonlyArray<any>
		>
	): object;
}

/**
 * Defines the object serializer context type used by this module.
 * `T` is the tuple of values written in order; each `write` consumes the head.
 */
declare interface ObjectSerializerContextObjectMiddlewareObject_1 {
	write: (
		value: string
	) => ObjectSerializerContextObjectMiddlewareObject_3<[number, boolean]>;
	setCircularReference: (value: ReferenceableItem) => void;
	snapshot: () => ObjectSerializerSnapshot;
	rollback: (snapshot: ObjectSerializerSnapshot) => void;
	writeLazy?: (item: ComplexSerializableType) => void;
	writeSeparate?: (
		item: ComplexSerializableType,
		obj?: LazyOptions
	) => LazyFunction<
		any,
		PrimitiveSerializableType[],
		SerializerMiddleware,
		LazyOptions
	>;
}
declare namespace ObjectSerializerContextObjectMiddlewareObject_2 {
	export let write: (
		value?: any
	) => ObjectSerializerContextObjectMiddlewareObject_3<ReadonlyArray<any>>;
	export let setCircularReference: (value: ReferenceableItem) => void;
	export let snapshot: () => ObjectSerializerSnapshot;
	export let rollback: (snapshot: ObjectSerializerSnapshot) => void;
	export let writeLazy: undefined | ((item: ComplexSerializableType) => void);
	export let writeSeparate:
		| undefined
		| ((
				item: ComplexSerializableType,
				obj?: LazyOptions
		  ) => LazyFunction<
				any,
				PrimitiveSerializableType[],
				SerializerMiddleware,
				LazyOptions
		  >);
}

/**
 * Defines the object serializer context type used by this module.
 * `T` is the tuple of values written in order; each `write` consumes the head.
 */
declare interface ObjectSerializerContextObjectMiddlewareObject_3<
	T = ReadonlyArray<any>
> {
	write: (
		value: Head<T>
	) => ObjectSerializerContextObjectMiddlewareObject_3<Tail<T>>;
	setCircularReference: (value: ReferenceableItem) => void;
	snapshot: () => ObjectSerializerSnapshot;
	rollback: (snapshot: ObjectSerializerSnapshot) => void;
	writeLazy?: (item: ComplexSerializableType) => void;
	writeSeparate?: (
		item: ComplexSerializableType,
		obj?: LazyOptions
	) => LazyFunction<
		any,
		PrimitiveSerializableType[],
		SerializerMiddleware,
		LazyOptions
	>;
}

/**
 * Defines the object serializer context type used by this module.
 * `T` is the tuple of values written in order; each `write` consumes the head.
 */
declare interface ObjectSerializerContextObjectMiddlewareObject_4 {
	write: (
		value: RestoreProvidedDataExports[]
	) => ObjectSerializerContextObjectMiddlewareObject_3<
		[undefined | null | boolean, undefined | boolean, boolean]
	>;
	setCircularReference: (value: ReferenceableItem) => void;
	snapshot: () => ObjectSerializerSnapshot;
	rollback: (snapshot: ObjectSerializerSnapshot) => void;
	writeLazy?: (item: ComplexSerializableType) => void;
	writeSeparate?: (
		item: ComplexSerializableType,
		obj?: LazyOptions
	) => LazyFunction<
		any,
		PrimitiveSerializableType[],
		SerializerMiddleware,
		LazyOptions
	>;
}

/**
 * Defines the object serializer snapshot type used by this module.
 */
declare interface ObjectSerializerSnapshot {
	length: number;
	cycleStackSize: number;
	referenceableSize: number;
	currentPos: number;
	objectTypeLookupSize: number;
	currentPosTypeLookup: number;
}
declare class OccurrenceChunkIdsPlugin {
	/**
	 * Creates an instance of OccurrenceChunkIdsPlugin.
	 */
	constructor(options?: OccurrenceChunkIdsPluginOptions);
	options: OccurrenceChunkIdsPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface OccurrenceChunkIdsPluginOptions {
	/**
	 * Prioritise initial size over total size.
	 */
	prioritiseInitial?: boolean;
}
declare class OccurrenceModuleIdsPlugin {
	/**
	 * Creates an instance of OccurrenceModuleIdsPlugin.
	 */
	constructor(options?: OccurrenceModuleIdsPluginOptions);
	options: OccurrenceModuleIdsPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface OccurrenceModuleIdsPluginOptions {
	/**
	 * Prioritise initial size over total size.
	 */
	prioritiseInitial?: boolean;
}
declare interface OnlySafeTimeEntry {
	safeTime: number;
}

/**
 * Describes the open shape.
 */
declare interface Open {
	(
		file: PathLikeFs,
		flags: undefined | string | number,
		mode: undefined | null | string | number,
		callback: (err: null | NodeJS.ErrnoException, result?: number) => void
	): void;
	(
		file: PathLikeFs,
		flags: undefined | string | number,
		callback: (err: null | NodeJS.ErrnoException, result?: number) => void
	): void;
	(
		file: PathLikeFs,
		callback: (err: null | NodeJS.ErrnoException, result?: number) => void
	): void;
}

/**
 * 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.
	 */
	checkWasmTypes?: boolean;

	/**
	 * Define the algorithm to choose chunk ids (named: readable ids for better debugging, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, total-size: numeric ids focused on minimal total download size, false: no algorithm used, as custom one can be provided via plugin).
	 */
	chunkIds?:
		false | "natural" | "named" | "deterministic" | "size" | "total-size";

	/**
	 * Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer. An options object implies 'true'.
	 */
	concatenateModules?: boolean | ConcatenateModulesOptions;

	/**
	 * Emit assets even when errors occur. Critical errors are emitted into the generated code and will cause errors at runtime.
	 */
	emitOnErrors?: boolean;

	/**
	 * Also flag chunks as loaded which contain a subset of the modules.
	 */
	flagIncludedChunks?: boolean;

	/**
	 * Inline ESM exports that bind to small primitive constants (≤6-byte null/undefined/boolean/number/string). Inlining makes the import dependency inactive so DCE can drop the export and possibly the module.
	 */
	inlineExports?: boolean;

	/**
	 * Creates a module-internal dependency graph for top level symbols, exports and imports, to improve unused exports detection.
	 */
	innerGraph?: boolean;

	/**
	 * Rename exports when possible to generate shorter code (depends on optimization.usedExports and optimization.providedExports, true/"deterministic": generate short deterministic names optimized for caching, "size": generate the shortest possible names).
	 */
	mangleExports?: boolean | "deterministic" | "size";

	/**
	 * Reduce size of WASM by changing imports to shorter strings.
	 */
	mangleWasmImports?: boolean;

	/**
	 * Merge chunks which contain the same modules.
	 */
	mergeDuplicateChunks?: boolean;

	/**
	 * Enable minimizing the output. Uses optimization.minimizer. An options object implies 'true' and sets optimization.minimizeOptions.
	 */
	minimize?: boolean | OptimizationMinimizeOptions;

	/**
	 * Enable minimizing the output, configured per asset type. An absent type is minimized with the defaults; `false` disables minimizing it.
	 * @since 5.110.0
	 */
	minimizeOptions?: OptimizationMinimizeOptions;

	/**
	 * Minimizer(s) to use for minimizing the output.
	 */
	minimizer?: (
		| undefined
		| null
		| false
		| ""
		| 0
		| ((this: Compiler, compiler: Compiler) => void)
		| WebpackPluginInstance
		| "..."
	)[];

	/**
	 * Define the algorithm to choose module ids (natural: numeric ids in order of usage, named: readable ids for better debugging, hashed: (deprecated) short hashes as ids for better long term caching, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, false: no algorithm used, as custom one can be provided via plugin).
	 */
	moduleIds?: false | "natural" | "named" | "deterministic" | "size" | "hashed";

	/**
	 * Avoid emitting assets when errors occur (deprecated: use 'emitOnErrors' instead).
	 * @deprecated
	 */
	noEmitOnErrors?: boolean;

	/**
	 * Set process.env.NODE_ENV to a specific value.
	 */
	nodeEnv?: string | false;

	/**
	 * Generate records with relative paths to be able to move the context folder.
	 */
	portableRecords?: boolean;

	/**
	 * Figure out which exports are provided by modules to generate more efficient code.
	 */
	providedExports?: boolean;

	/**
	 * Use real [contenthash] based on final content of the assets.
	 */
	realContentHash?: boolean;

	/**
	 * Removes modules from chunks when these modules are already included in all parents.
	 */
	removeAvailableModules?: boolean;

	/**
	 * Remove chunks which are empty.
	 */
	removeEmptyChunks?: boolean;

	/**
	 * Create an additional chunk which contains only the webpack runtime and chunk hash maps.
	 */
	runtimeChunk?:
		| boolean
		| "single"
		| "multiple"
		| {
				/**
				 * The name or name factory for the runtime chunks.
				 */
				name?: string | ((entrypoint: { name: string }) => string);
		  };

	/**
	 * Skip over modules which contain no side effects when exports are not used (false: disabled, 'flag': only use manually placed side effects flag, true: also analyse source code for side effects).
	 */
	sideEffects?: boolean | "flag";

	/**
	 * Optimize duplication and caching by splitting chunks by shared modules and cache group.
	 */
	splitChunks?: false | OptimizationSplitChunksOptions;

	/**
	 * Figure out which exports are used by modules to mangle export names, omit unused exports and generate more efficient code (true: analyse used exports for each runtime, "global": analyse exports globally for all runtimes combined).
	 */
	usedExports?: boolean | "global";
}

/**
 * What the CSS minimizer does. Applies wherever it runs: on `.css` assets and on the inline `<style>` / `style=""` the HTML minimizer hands it. Every transform that keeps the stylesheet's meaning is on by default and may be turned off on its own, so a document a rewrite breaks can be minimized without it while the rest still applies; the two that change what the CSSOM hands back (`convertLengthUnits`, `rewriteCustomProperties`) are off until asked for.
 * @since 5.110.0
 */
declare interface OptimizationMinimizeCss {
	/**
	 * How the minimizer states a `.css` asset's encoding. `"auto"` (the default) opens it with `@charset "UTF-8"` only when its output holds a non-ASCII character, so it is read as UTF-8 wherever the server's `Content-Type` names no other charset, which `@charset` cannot override. `false` writes no `@charset` at all, and writes an escaped character past U+FFFF (an icon font's `content: "\F0A86"`) as the character itself, as `"auto"` does once that `@charset` is written. Set `false` only where the asset is read as UTF-8 anyway: a stylesheet with no `@charset` is read in the encoding the server's `Content-Type` names, else in the encoding of the page linking it, so it holds wherever the server names UTF-8 or the page is UTF-8 — and anywhere else every such character reads as other characters.
	 * @since 5.112.0
	 */
	charset?: false | "auto";

	/**
	 * Write a color the `browserslist` target cannot read as an extra declaration before the one naming it, in a spelling it does read: `color: oklch(59.686% 0.15619 49.7694)` is written as `color: #c65d06` and then the `oklch()` itself, so an engine reading neither the Lab family nor `hwb()` is left with a color rather than with nothing. The fallback is that color clipped into the sRGB gamut and rounded, which the declaration standing after it corrects wherever it is read. Nothing is written where the author already set the property earlier in the same block, where the color holds a substitution or a relative reference this cannot fold, or where the fallback would still name a function the target cannot read. On by default, and only in effect for a `browserslist` target — any other target names no browsers to answer for.
	 * @since 5.111.0
	 */
	colorFallbacks?: boolean;

	/**
	 * Which comments survive. `"some"`, the default, keeps a `/*!` banner and a comment annotated `@license` or `@preserve`; `true` (or `"all"`) keeps every comment and `false` keeps none; a string is read as a regular expression source, and it, a `RegExp` or a `(comment) => boolean` predicate is asked about each comment's own text and keeps the ones it accepts — standing in for the default rule rather than beside it, as terser's `format.comments` does, so a pattern that names nothing else drops the ones `"some"` would have kept. A `/*#` source-map pragma is a link rather than a comment, so `"some"` and `"all"` keep it; `false`, a pattern or a predicate decides it like any other. A predicate is handed to the minimizer's worker pool as source, so it must not close over anything.
	 * @since 5.110.0
	 */
	comments?: string | boolean | RegExp | ((comment: string) => boolean);

	/**
	 * Write a polar or Lab color as the nearest hex even where that hex only approximates it. `shortenColors` converts one only where webpack can prove an engine's own conversion lands on the same bytes, and keeps the function in the two places it cannot: a channel sitting too near a `.5` boundary for two implementations to round it alike (it is why esbuild and lightningcss emit different bytes for `hwb(194 0% 0%)`), and a color outside the sRGB gamut, which hex can only clip to a different color. Off by default, for those two reasons, and the two are not the same trade: on the boundary this writes the byte esbuild, lightningcss and cssnano write anyway, while outside the gamut it goes further than any of them — lightningcss keeps the function there and writes a fallback before it, which is what `colorFallbacks` does. A space engines read through transfers of their own (`a98-rgb`, `prophoto-rgb`) is left alone either way, the hex there naming a color no engine paints rather than a near one. This is about replacing the function: a fallback stands before it rather than in its place, so it already clips and rounds this way.
	 * @since 5.112.0
	 */
	convertApproximateColors?: boolean;

	/**
	 * Rewrite a length into a shorter unit it is exactly equal in (`16px` -> `1pc`). Off by default: the authored unit is lost, and once the asset is compressed the rewrite rarely earns anything.
	 * @since 5.110.0
	 */
	convertLengthUnits?: boolean;

	/**
	 * Resolve the `@custom-media` at-rule: write the query a name stands for wherever a condition asks for it, and drop the rule that named it. `@custom-media --wide (width>400px)` with `@media (--wide)` becomes `@media (width>400px)`. Off by default: `module.parser.css.customMedia` already resolves it in every stylesheet webpack parses, so this is for a `.css` asset that reached the minimizer without being parsed — one emitted by `asset/resource` or copied in. Every rule is read first, so a name resolves wherever its rule stands, the last rule stating it holds, and one name may be read through another; names that read each other in a cycle stand for nothing and are left as written.
	 * @since 5.112.0
	 */
	customMedia?: boolean;

	/**
	 * Resolve the `@custom-selector` at-rule: write the selector list a name stands for as `:is(…)` wherever a selector asks for it, and drop the rule that named it. `@custom-selector :--heading h1, h2` with `:--heading` becomes `:is(h1, h2)`. Off by default, for the reason `customMedia` is: `module.parser.css.customSelectors` already resolves it in every stylesheet webpack parses. Rules are read as `customMedia` reads them, and a name is written out only where the target reads `:is()`.
	 * @since 5.112.0
	 */
	customSelectors?: boolean;

	/**
	 * Drop a declaration a later one in the same block overrides even where no target is selected, assuming the engines shipping today: wherever Chromium, Gecko and WebKit each read the later value. Off by default. With a `browserslist` target this is already done wherever every browser it names is known to read the later value, so the option only widens the case where no target is selected and there are no engines to name — which is what csso and cssnano do unconditionally. What it gives up is the fallback pair: `color:#c65d06;color:lab(50% 100 -100)` loses the hex, so an engine that cannot read `lab()` is left with nothing. A selection naming a browser the compat tables do not cover is still answered for the whole of it rather than by this option, since naming a browser states a target the option does not override.
	 * @since 5.112.0
	 */
	dropOverriddenDeclarations?: boolean;

	/**
	 * Move comments out of a `.css` asset into the `[file].LICENSE.txt` the minimizer plugin writes for JavaScript, leaving a one-line banner pointing at it. Takes terser's values: `true` or `"some"` (the default) a `/*!` banner and a comment annotated `@preserve` or `@lic` — terser's `some` bar IE's `@cc_on`, which is left alone, `"all"` every comment, a RegExp or a string read as one the comments it matches, and a function the comments it returns `true` for, asked with the comment's `value` (its text without the delimiters), `line` (from 1) and `col` (from 0). `false` leaves them in the stylesheet, where `comments` decides which survive. A stylesheet webpack minifies inside another document — an inline `<style>`, a `style=""` — keeps them, having no file of its own to point from.
	 * @since 5.112.0
	 */
	extractComments?:
		| string
		| boolean
		| RegExp
		| ((comment: { value: string; line: number; col: number }) => boolean);

	/**
	 * Write a name that matches ASCII case-insensitively in lowercase: an at-rule name, a property name, a pseudo-class or pseudo-element name, a function name, a unit, and a keyword standing in a value whose grammar takes keywords alone. `@MEDIA`, `COLOR`, `:NTH-CHILD`, `URL(`, `1PX` and `currentColor` become `@media`, `color`, `:nth-child`, `url(`, `1px` and `currentcolor`. On by default, and exact: CSS matches every one of these ASCII case-insensitively, so the fold names the same thing. What it never touches is a name the author chose — a custom property, a custom ident such as an animation or grid-area name, an id, a class, a type selector, an attribute's value, or anything inside a substituted value. `@charset` is left as written, being read as bytes rather than matched, and `!important` is always written in lowercase because the printer writes the keyword rather than copying it.
	 * @since 5.111.0
	 */
	foldCase?: boolean;

	/**
	 * Write a spelling the `browserslist` target cannot read as one it can — the same value said another way, rather than left for an engine that will drop it: a 4-/8-digit hex as `rgba()`, a double-position gradient stop as the two stops it names, `inset` / `overflow` / `place-*` as the longhands they set, `text-decoration` as its own longhands where a slot is newer than the shorthand, `system-ui` as the stack of platform font names it stands for, a `:lang()` or `:not()` holding a list as the `:is()` that means it, a media feature range as the `min-`/`max-` pair, and `light-dark()` as the custom-property pair a color scheme switches. On by default, and only in effect for a `browserslist` target — any other target names no browsers to answer for. Off leaves every such spelling as written, which is how a stylesheet one of these rewrites gets wrong is minified; it never makes the minifier write a spelling the target cannot read.
	 * @since 5.111.0
	 */
	lowerUnsupported?: boolean;

	/**
	 * Give a rule the selectors of a later one printing the same block, and an at-rule the block of a later one stating the same condition, past the rules standing between them. Off by default because it reorders the cascade, so it holds only where nothing between the two declares a property the block being moved does for an element its selectors can match (a rule whose selectors all name other element types, `h3` between two rules for `h1` and `h2`, never can) — a condition between counts for what its own rules declare, while `@layer` and anything else whose declarations cannot be read stands in the way whatever it says. A block repeated at a distance already compresses on its own, so a selector join is taken only where the copy of the block it drops is worth more than twice the selector it writes instead; an at-rule join writes no selector and drops the repeated prelude outright. A named `@layer` is not joined this way — its place in the cascade is where its name is first written, not what its prelude states. `mergeRules` is the safe half of this, joining only what nothing stands between.
	 * @since 5.111.0
	 */
	mergeDistantRules?: boolean;

	/**
	 * Write a family of longhands as the one shorthand that sets them — four sides or corners, the two a pair shorthand sets, or the slots of an order-free one — even where unrelated declarations stand between them. On by default.
	 * @since 5.110.0
	 */
	mergeLonghands?: boolean;

	/**
	 * Join rules nothing stands between: adjacent rules that print the same block become one selector list, at-rules that share a prelude become one rule, and a named `@layer` block a later sibling opens again is folded into the first. On by default.
	 * @since 5.110.0
	 */
	mergeRules?: boolean;

	/**
	 * Normalize quoting: a string takes whichever quote needs fewer escapes, a `url()` and an attribute selector's value drop theirs where the content is still one token, and a font family whose name is a run of identifiers is written unquoted. On by default.
	 * @since 5.110.0
	 */
	normalizeQuotes?: boolean;

	/**
	 * Each pseudo-class to write as an ordinary class instead, as `{ "focus-visible": "focus-visible" }` — so a script can apply the class where the engine reads no such pseudo. Only a plain pseudo-class is rewritten, wherever it stands in a selector: a pseudo-element (`::hover`) and a functional pseudo of the same name (`:hover(…)`) are not what a class stands in for, and a `:name` inside a quoted attribute value is nobody's pseudo. Nothing applies the class — that is the script's part.
	 * @since 5.111.0
	 */
	pseudoClasses?: { [index: string]: string };

	/**
	 * Compute a call into the shorter call naming the same value: `calc()` and every math function over constants, a transform naming one axis or an identity, a gradient's default direction and its implied stops, an easing function that has a keyword, and a filter function given the amount an omitted argument already means. On by default.
	 * @since 5.110.0
	 */
	reduceFunctions?: boolean;

	/**
	 * Drop a rule or declaration nothing can read: a rule whose block ends up empty, a declaration a later one in the same block overrides, a rule an identical later sibling makes dead, and the `@charset` naming an encoding the output is not written in. On by default. Joining rules that are not dead is `mergeRules`.
	 * @since 5.110.0
	 */
	removeDeadRules?: boolean;

	/**
	 * Print a style rule's declarations in one order by property family, the properties no family names first where they were written, so blocks setting the same things read alike and compress smaller. Only declarations whose order nothing can see move: two spellings of one property, a shorthand and what it sets, two shorthands sharing a longhand, and a flow-relative side and a physical one keep theirs, and a block holding a property no dataset names or a nested rule is printed as written. On by default.
	 * @since 5.112.0
	 */
	reorderDeclarations?: boolean;

	/**
	 * Shorten the values of custom properties (`--x: #ffffff` -> `#fff`, `--y: 0.5rem` -> `.5rem`), which are otherwise written back exactly as authored. Off by default: `getComputedStyle().getPropertyValue()` hands this text back, so a rewritten value is a different CSSOM — the one place a declaration's authored text survives. What it may rewrite is exactly what any other value's tokens may be, a color in a substitution's fallback included — that fallback being the property's value rather than the function's own argument.
	 * @since 5.110.0
	 */
	rewriteCustomProperties?: boolean;

	/**
	 * Write a `:dir()` the `browserslist` target cannot read as the `[dir]` attribute selector it approximates: `a:dir(rtl)` becomes `a[dir=rtl]`. Off until asked for, because the two are not the same question — `:dir()` reads the directionality an element resolves to, which it may inherit from an ancestor, while `[dir=rtl]` reads the attribute on the element itself, so an element inside a `dir="rtl"` ancestor matches the first and not the second. Only in effect for a `browserslist` target that reads no `:dir()`; any other target names no browsers to answer for.
	 * @since 5.111.0
	 */
	rewriteDirSelector?: boolean;

	/**
	 * Write an escaped identifier the shortest way that names the same thing, wherever it stands — a selector, a property, at-rule or function name, or a value: `grid-area:\66oot` becomes `grid-area:foot`, `#\41 x` becomes `#Ax`, `col\6f r:red` becomes `color:red` and `c\61 lc(` becomes `calc(`. On by default, and exact: the escape and what replaces it are the same identifier. Off leaves every escape as the author wrote it, which is what a consumer comparing the text rather than reading the identifier needs.
	 * @since 5.111.0
	 */
	rewriteEscapes?: boolean;

	/**
	 * Write each color in the shortest spelling of the same value: `#ffffff` -> `#fff`, `rgb(1 2 3)` -> `#010203`, a named color where the property takes no identifier of the author's own, and every polar and Lab function the target agrees with hex on. On by default.
	 * @since 5.110.0
	 */
	shortenColors?: boolean;

	/**
	 * Shorten a rule's condition prelude: a media feature in its range spelling where the target reads one (`(min-width:100px)` -> `(width>=100px)`), an `and` of two one-sided ranges collapsed into the interval it describes, the `all` a query states before an `and` (which matches what the condition alone matches), and an operand a condition already states — in `@supports` and `@container` as well as `@media`. On by default.
	 * @since 5.110.0
	 */
	shortenMediaQueries?: boolean;

	/**
	 * Write each number in its shortest equal spelling — dropping a leading zero, a trailing fraction and a `+`, rounding to the six significant digits a stylesheet can observe, dropping the unit a zero does not need, and writing an alpha and a ratio the one way its grammar spells them. On by default.
	 * @since 5.110.0
	 */
	shortenNumbers?: boolean;

	/**
	 * Rewrite a selector into an equal one: a selector list deduplicated and ordered, a CSS2 pseudo-element's second colon dropped, the universal a compound already implies dropped, an `An+B` written the shortest way its microsyntax allows, and a `from` / `100%` keyframe selector written as the shorter of the pair. On by default.
	 * @since 5.110.0
	 */
	shortenSelectors?: boolean;

	/**
	 * Write a value the shortest way its property's own grammar allows: a `{1,4}` box or corner notation collapsed, a slot holding its own initial dropped, and `flex` / `font-weight` / `display` / `transition` / `<position>` / `<repeat-style>` written the short way. On by default. Merging separate longhand declarations is `mergeLonghands`.
	 * @since 5.110.0
	 */
	shortenValues?: boolean;

	/**
	 * Names a whole-project analysis found nothing uses, which the minimizer then takes out: a bare name is matched against every class and id a selector names and against every `@keyframes` name, and a `--`-prefixed one against every custom property a declaration sets. A selector list keeps the selectors that do not name one, and a rule left with none goes; a name inside a functional pseudo (`:not(.gone)`, `:is(.gone, .kept)`) is not one the rule needs, so it is left alone. Nothing is derived here — the list is the caller's, and a name on it that something does use takes working CSS out.
	 * @since 5.111.0
	 */
	unusedSymbols?: string[];

	/**
	 * Maintain vendor prefixes for the `browserslist` target: add the `-webkit-` / `-moz-` / `-ms-` spelling of a property, at-rule or pseudo-selector that a selected browser still needs, and drop one none of them does. On by default, and only in effect for a `browserslist` target — any other target names no browsers to prefix for. A browserslist name no compat dataset covers (`op_mini`, `and_uc`, `and_qq`, `baidu`, `kaios`, `bb`) is skipped, and a selection of nothing but those prefixes for no one.
	 * @since 5.110.0
	 */
	vendorPrefixes?: boolean;
}

/**
 * What the HTML minimizer does. Every transform that keeps the document's DOM is on by default and may be turned off on its own, so a page a rewrite breaks can be minimized without it while the rest still applies; the ones that change what a script or a selector reads back are off until asked for.
 * @since 5.110.0
 */
declare interface OptimizationMinimizeHtml {
	/**
	 * Write a boolean attribute as the bare name its presence already means. The DOM reads `checked` from the attribute being there and never from its value, so `checked="checked"` and `checked=""` are the same element — but `getAttribute` hands back what was written. `true`, the default, rewrites only the spelling the spec itself canonicalizes, the attribute's own name; `"all"` rewrites any value, including the `checked="false"` that already means checked.
	 * @since 5.110.0
	 */
	collapseBooleanAttributes?: boolean | "all";

	/**
	 * Collapse each run of whitespace in text to a single space. Left alone inside `pre`, `textarea` and `listing`, where whitespace renders verbatim. `true` (or `"conservative"`) never removes whitespace entirely — dropping it would join two inline elements that render apart. `"smart"` also drops the whitespace that sits against a block element's edge, where no line box reaches it. `"all"` drops the whitespace at every text node's edges, which does change how adjacent inline elements render.
	 * @since 5.110.0
	 */
	collapseWhitespace?: boolean | "all" | "conservative" | "smart";

	/**
	 * Which comments survive. `"some"`, the default, keeps nothing: every comment an HTML parser reads is inert; `true` (or `"all"`) keeps every comment and `false` keeps none; a string is read as a regular expression source, and it, a `RegExp` or a `(comment) => boolean` predicate is asked about each comment's own text and keeps the ones it accepts — standing in for the default rule rather than beside it, as terser's `format.comments` does, so a pattern that names nothing else drops the ones `"some"` would have kept. A downlevel conditional comment, a server-side include and a `<?…?>` template directive are code rather than comments and stay whatever this says. A predicate is handed to the minimizer's worker pool as source, so it must not close over anything.
	 * @since 5.110.0
	 */
	comments?: string | boolean | RegExp | ((comment: string) => boolean);

	/**
	 * Move comments out of an `.html` asset into the `[file].LICENSE.txt` the minimizer plugin writes for JavaScript, leaving a `<!-- … -->` banner at the end of the document pointing at it, so the doctype stays first. Takes the values `minimize.css.extractComments` takes: `true` or `"some"` (the default) a comment opening with `!` or annotated `@preserve` or `@lic` — terser's `some` bar IE's `@cc_on`, which is left alone, `"all"` every comment, a RegExp or a string read as one the comments it matches, and a function the comments it returns `true` for, asked with the comment's `value` (its text without the delimiters), `line` (from 1) and `col` (from 0). `false` leaves them in the document, where `comments` decides which survive. A conditional comment, a server-side include and a `<?…?>` template directive are code and are never taken, and a document nested in another — an `<iframe srcdoc>`, a conditional comment's body — keeps its comments.
	 * @since 5.112.0
	 */
	extractComments?:
		| string
		| boolean
		| RegExp
		| ((comment: { value: string; line: number; col: number }) => boolean);

	/**
	 * Print a run of adjacent `<script>` elements as one, joined by a newline and a `;`. Only bare ones fold — any attribute at all, a `src`, `type`, `nonce`, `async` or `id` among them, says the two are not interchangeable with one — and only where the print writes the bodies itself, so a `<script>` that `output.html.inline` fills in after the print is left alone. A body is left alone too wherever appending it would change what it means: one still inside a string, template or block comment would swallow the next, and a directive prologue, a hashbang or a leading `-->` mean what they do only at a start the appended body no longer has. Off by default: it removes elements, so `document.scripts`, a `script:nth-child()` selector and `querySelectorAll("script").length` all read a different document; a later body's `var` and `function` declarations become visible to the bodies before it; and a body that throws takes the rest of its run with it rather than only itself, while one that does not parse takes the whole run, its own code included.
	 * @since 5.111.0
	 */
	mergeScripts?: boolean;

	/**
	 * Print a run of adjacent `<style>` elements as one sheet. Off by default: it removes elements, so `document.styleSheets`, a `style:nth-child()` selector and `querySelectorAll("style").length` all read a different document. A sheet the CSS minifier does not accept is never folded — appending to one that may be unterminated would make the next sheet part of its last rule — and neither is one led by `@import` / `@charset` / `@namespace`, which apply only at the top of a sheet.
	 * @since 5.110.0
	 */
	mergeStyles?: boolean;

	/**
	 * Minify the markup inside a downlevel-hidden conditional comment (`<!--[if IE]> … <![endif]-->`). Off by default: the body is minified on its own, so a context-sensitive decision inside it — which end tags are optional, where a table cell may sit — is taken as though it started a document rather than where the comment sits. Only browsers older than IE10 read these at all.
	 * @since 5.110.0
	 */
	minifyConditionalComments?: boolean;

	/**
	 * Write an attribute value with whichever delimiters cost least — bare where the grammar allows it, else under the quote that needs fewer character references. On by default: the DOM reads the same value either way.
	 * @since 5.110.0
	 */
	normalizeAttributeQuotes?: boolean;

	/**
	 * Fold an enumerated attribute's value to the keyword it names (`type="TEXT"` -> `type=text`), which the DOM matches ASCII case-insensitively. A value the spec does not enumerate is left as written. On by default.
	 * @since 5.110.0
	 */
	normalizeEnumeratedAttributes?: boolean;

	/**
	 * Normalize a list-shaped attribute value: a space-separated token list (`class`, `rel`, `part`, …), a comma-separated one (`accept`, `sizes`, …), a `srcset` and the viewport `<meta content>`. On by default. A list is read as the set the DOM reflects, so a repeat folds away, only where every token of it is a word: one holding a delimiter another language wrote a statement in is text, and keeps every token it names. Reordering a token list is `sortTokenLists`, which is separate and off by default.
	 * @since 5.110.0
	 */
	normalizeListAttributes?: boolean;

	/**
	 * Write an integer attribute (`tabindex`, `colspan`, `width`, …) the one way its own rules read it — leading whitespace, a `+` and leading zeros all go. On by default.
	 * @since 5.110.0
	 */
	normalizeNumericAttributes?: boolean;

	/**
	 * Drop the ASCII whitespace around a URL value (`href`, `src`, `action`, `poster`, …), which resolving the URL skips over, so the request goes to the same place either way. On by default: `getAttribute` hands back the attribute as written, so a script comparing those bytes is the one this is turned off for.
	 * @since 5.111.0
	 */
	normalizeUrlAttributes?: boolean;

	/**
	 * Drop an attribute whose empty or all-whitespace value leaves it in the state its absence gives: the globals `class`, `id`, `style`, `dir`, `accesskey`, `itemprop`, `itemref`, `itemtype` and `part`, and every attribute reflecting a token list on the elements the spec defines it for — `rel` on `<a>`, `<area>`, `<form>` and `<link>`, `ping` on `<a>` and `<area>`, `headers` on `<td>` and `<th>`, `blocking` on `<link>`, `<script>` and `<style>`, `sizes` on `<link>`, `for` on `<output>` — where an empty list is no tokens. Anywhere else that spelling is an author attribute whose meaning is a script's, so `<x-foo rel="">` and `<label for="">` keep it. Off by default: an attribute selector matches on presence, so `[class]` stops matching. Never dropped: `title` and `lang`, whose empty value means what absence does not; `sandbox`, whose empty list is the most restrictive state an `<iframe>` has; and an event handler, whose empty body still compiles to a function where absence reads null.
	 * @since 5.110.0
	 */
	removeEmptyAttributes?: boolean;

	/**
	 * Drop an element that has no children and no attributes, where its bare form renders nothing and nothing reads it: a generic container such as `div`, `span` or `section`, an inline phrase element, an empty `title`, `script` or `style`, or an attribute-less `meta`, `link` or `base`. Every other element is kept, including widgets, list items, elements with margins and custom elements. Off by default: CSS can give an empty element a size or a `::before`, and the minifier cannot see the stylesheet. Emptiness is read off the output rather than the source, so a run of nested empties goes together and an element left empty only by a dropped comment or by whitespace `collapseWhitespace` deletes goes with them.
	 * @since 5.110.0
	 */
	removeEmptyElements?: boolean;

	/**
	 * How much of the `<html>` / `<head>` / `<body>` shell §13.1.2.4 lets the parser imply may be left out. Every other optional tag goes unconditionally — nothing can observe that — but these six are what a consumer reading the page with a regexp rather than a parser looks for. `"smart"`, the default, leaves out the one such a reader never matches: the `<html>` start tag, which is omittable only when it carries no attribute at all, so the `<html lang=en>` anyone greps for keeps its tag anyway. `</html>` stays with it, since a truncation check reads a page as complete by finding one. `true` (or `"all"`) leaves out all six, which is where a crawler matching on `<body>` stops finding one; `false` leaves out none. A tag also stays wherever the spec keeps it: an attribute to carry, a comment minifying does not drop, whitespace opening the element, or a `meta` / `noscript` / `link` / `script` / `style` / `template` element opening the body.
	 * @since 5.110.0
	 */
	removeImpliedTags?: boolean | "all" | "smart";

	/**
	 * Leave out a tag §13.1.2.4 lets the parser imply, other than the `<html>` / `<head>` / `<body>` shell, which `removeImpliedTags` decides on its own. On by default: nothing can observe the difference, the tree parses the same either way. A tag still stays wherever the spec keeps it — a comment or whitespace behind it, or a following element the insertion mode does not close it through.
	 * @since 5.110.0
	 */
	removeOptionalTags?: boolean;

	/**
	 * Drop an attribute whose value is the one the element already defaults to. Off by default: an attribute a page no longer carries is one `getAttribute` and every attribute selector read differently, whichever tier dropped it. `true` (or `"smart"`) drops only markers on elements that render nothing — `<script type=text/javascript>`, `<script language=javascript>`, `<script charset=utf-8>`, `<style type=text/css>`, `<link type=text/css>`, `<link media=all>` — so no rule that styles the page stops applying, which is what `@swc/html` does by default. `"all"` also drops spec defaults such as `<input type=text>` and `<form method=get>`, which reaches further still: an attribute selector matches the content attribute, not the reflected default, so `input[type=text]` stops matching.
	 * @since 5.110.0
	 */
	removeRedundantAttributes?: boolean | "all" | "smart";

	/**
	 * Print an element's attributes in a fixed order: the document's commonest attribute names first, ties by name. Nothing in HTML reads attribute order, so this only makes the same markup compress better across pages — the run of attributes two elements share becomes the same run of bytes. Off by default: a script reading `element.attributes` back, or a snapshot of the emitted HTML, sees the new order.
	 * @since 5.110.0
	 */
	sortAttributes?: boolean;

	/**
	 * Print every space-separated token list the DOM reads as a set — `class`, `rel`, `part`, `sandbox`, `blocking`, `itemprop` / `itemref` / `itemtype`, `<output for>` and `<link sizes>` — in token order. Nothing matching those reads order, so this only makes the same markup compress better across pages. Off by default: a script reading `className` or `rel` back sees the new order. Asked for on its own: a list this reorders is rewritten whether or not `normalizeListAttributes` is on, since another order is another spelling. The lists the DOM does not read as a set are left alone whatever this says — `ping` is the order its requests go out in and `accesskey` the order its keys are tried.
	 * @since 5.110.0
	 */
	sortTokenLists?: boolean;
}

/**
 * Options handed as-is to the JavaScript minimizer (terser-compatible). Defaults to `{ compress: { passes: 2 } }`.
 * @since 5.110.0
 */
declare interface OptimizationMinimizeJavascript {
	[index: string]: any;
}

/**
 * Enable minimizing the output, configured per asset type. An absent type is minimized with the defaults; `false` disables minimizing it.
 * @since 5.110.0
 */
declare interface OptimizationMinimizeOptions {
	/**
	 * Minimize CSS assets: `false` disables it, an object configures what the built-in minimizer may do beyond the transforms that always apply.
	 */
	css?: false | OptimizationMinimizeCss;

	/**
	 * Minimize HTML assets: `false` disables it, an object configures what the built-in minimizer may do beyond the transforms that always apply.
	 */
	html?: false | OptimizationMinimizeHtml;

	/**
	 * Minimize JavaScript assets: `false` disables it, an object is handed as-is to the JavaScript minimizer.
	 */
	javascript?: false | OptimizationMinimizeJavascript;

	/**
	 * Minimize JSON assets by re-serializing them without whitespace (defaults to `true` with `experiments.futureDefaults`, otherwise `false`).
	 * @since 5.112.0
	 */
	json?: boolean;

	/**
	 * Minimize `.svg` and `.xml` assets: `false` disables it, an object enables it. Absent means off unless `experiments.futureDefaults` is set.
	 * @since 5.112.0
	 * @experimental
	 */
	xml?: false | OptimizationMinimizeXml;
}

/**
 * What the XML minimizer does. The stylesheets an SVG or XHTML element holds are minified with `optimization.minimizeOptions.css` for the target's browsers.
 * @since 5.112.0
 * @experimental
 */
declare interface OptimizationMinimizeXml {
	/**
	 * Print attributes with the document's commonest names first, breaking ties by case-sensitive name. Off by default: consumers observing attribute order see the new order.
	 * @since 5.112.0
	 */
	sortAttributes?: boolean;
}

/**
 * Enables/Disables integrated optimizations.
 */
declare interface OptimizationNormalized {
	/**
	 * Avoid wrapping the entry module in an IIFE.
	 */
	avoidEntryIife?: boolean;

	/**
	 * Check for incompatible wasm types when importing/exporting from/to ESM.
	 */
	checkWasmTypes?: boolean;

	/**
	 * Define the algorithm to choose chunk ids (named: readable ids for better debugging, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, total-size: numeric ids focused on minimal total download size, false: no algorithm used, as custom one can be provided via plugin).
	 */
	chunkIds?:
		false | "natural" | "named" | "deterministic" | "size" | "total-size";

	/**
	 * Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer. An options object implies 'true'.
	 */
	concatenateModules?: boolean | ConcatenateModulesOptions;

	/**
	 * Emit assets even when errors occur. Critical errors are emitted into the generated code and will cause errors at runtime.
	 */
	emitOnErrors?: boolean;

	/**
	 * Also flag chunks as loaded which contain a subset of the modules.
	 */
	flagIncludedChunks?: boolean;

	/**
	 * Inline ESM exports that bind to small primitive constants (≤6-byte null/undefined/boolean/number/string). Inlining makes the import dependency inactive so DCE can drop the export and possibly the module.
	 */
	inlineExports?: boolean;

	/**
	 * Creates a module-internal dependency graph for top level symbols, exports and imports, to improve unused exports detection.
	 */
	innerGraph?: boolean;

	/**
	 * Rename exports when possible to generate shorter code (depends on optimization.usedExports and optimization.providedExports, true/"deterministic": generate short deterministic names optimized for caching, "size": generate the shortest possible names).
	 */
	mangleExports?: boolean | "deterministic" | "size";

	/**
	 * Reduce size of WASM by changing imports to shorter strings.
	 */
	mangleWasmImports?: boolean;

	/**
	 * Merge chunks which contain the same modules.
	 */
	mergeDuplicateChunks?: boolean;

	/**
	 * Enable minimizing the output. Uses optimization.minimizer.
	 */
	minimize?: boolean;

	/**
	 * Enable minimizing the output, configured per asset type. An absent type is minimized with the defaults; `false` disables minimizing it.
	 * @since 5.110.0
	 */
	minimizeOptions?: OptimizationMinimizeOptions;

	/**
	 * Minimizer(s) to use for minimizing the output.
	 */
	minimizer?: (
		| ((this: Compiler, compiler: Compiler) => void)
		| WebpackPluginInstance
		| "..."
	)[];

	/**
	 * Define the algorithm to choose module ids (natural: numeric ids in order of usage, named: readable ids for better debugging, hashed: (deprecated) short hashes as ids for better long term caching, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, false: no algorithm used, as custom one can be provided via plugin).
	 */
	moduleIds?: false | "natural" | "named" | "deterministic" | "size" | "hashed";

	/**
	 * Avoid emitting assets when errors occur (deprecated: use 'emitOnErrors' instead).
	 * @deprecated
	 */
	noEmitOnErrors?: boolean;

	/**
	 * Set process.env.NODE_ENV to a specific value.
	 */
	nodeEnv?: string | false;

	/**
	 * Generate records with relative paths to be able to move the context folder.
	 */
	portableRecords?: boolean;

	/**
	 * Figure out which exports are provided by modules to generate more efficient code.
	 */
	providedExports?: boolean;

	/**
	 * Use real [contenthash] based on final content of the assets.
	 */
	realContentHash?: boolean;

	/**
	 * Removes modules from chunks when these modules are already included in all parents.
	 */
	removeAvailableModules?: boolean;

	/**
	 * Remove chunks which are empty.
	 */
	removeEmptyChunks?: boolean;

	/**
	 * Create an additional chunk which contains only the webpack runtime and chunk hash maps.
	 */
	runtimeChunk?:
		| false
		| {
				/**
				 * The name factory for the runtime chunks.
				 */
				name?: (entrypoint: { name: string }) => string;
		  };

	/**
	 * Skip over modules which contain no side effects when exports are not used (false: disabled, 'flag': only use manually placed side effects flag, true: also analyse source code for side effects).
	 */
	sideEffects?: boolean | "flag";

	/**
	 * Optimize duplication and caching by splitting chunks by shared modules and cache group.
	 */
	splitChunks?: false | OptimizationSplitChunksOptions;

	/**
	 * Figure out which exports are used by modules to mangle export names, omit unused exports and generate more efficient code (true: analyse used exports for each runtime, "global": analyse exports globally for all runtimes combined).
	 */
	usedExports?: boolean | "global";
}
type OptimizationNormalizedWithDefaults = OptimizationNormalized & {
	runtimeChunk: NonNullable<
		| undefined
		| false
		| {
				/**
				 * The name factory for the runtime chunks.
				 */
				name?: (entrypoint: { name: string }) => string;
		  }
	>;
	splitChunks: NonNullable<undefined | false | OptimizationSplitChunksOptions>;
	mergeDuplicateChunks: NonNullable<undefined | boolean>;
	removeAvailableModules: NonNullable<undefined | boolean>;
	removeEmptyChunks: NonNullable<undefined | boolean>;
	flagIncludedChunks: NonNullable<undefined | boolean>;
	moduleIds: NonNullable<
		| undefined
		| false
		| "natural"
		| "named"
		| "deterministic"
		| "size"
		| "hashed"
	>;
	chunkIds: NonNullable<
		| undefined
		| false
		| "natural"
		| "named"
		| "deterministic"
		| "size"
		| "total-size"
	>;
	sideEffects: NonNullable<undefined | boolean | "flag">;
	providedExports: NonNullable<undefined | boolean>;
	usedExports: NonNullable<undefined | boolean | "global">;
	mangleExports: NonNullable<undefined | boolean | "deterministic" | "size">;
	innerGraph: NonNullable<undefined | boolean>;
	inlineExports: NonNullable<undefined | boolean>;
	concatenateModules: NonNullable<
		undefined | boolean | ConcatenateModulesOptions
	>;
	avoidEntryIife: NonNullable<undefined | boolean>;
	emitOnErrors: NonNullable<undefined | boolean>;
	checkWasmTypes: NonNullable<undefined | boolean>;
	mangleWasmImports: NonNullable<undefined | boolean>;
	portableRecords: NonNullable<undefined | boolean>;
	realContentHash: NonNullable<undefined | boolean>;
	minimize: NonNullable<undefined | boolean>;
	minimizeOptions: OptimizationMinimizeOptions;
	minimizer: (
		| ((this: Compiler, compiler: Compiler) => void)
		| WebpackPluginInstance
		| "..."
	)[];
	nodeEnv: NonNullable<undefined | string | false>;
};

/**
 * Options object for describing behavior of a cache group selecting modules that should be cached together.
 */
declare interface OptimizationSplitChunksCacheGroup {
	/**
	 * Sets the name delimiter for created chunks.
	 */
	automaticNameDelimiter?: string;

	/**
	 * Select chunks for determining cache group content (defaults to "initial", "initial" and "all" requires adding these chunks to the HTML).
	 */
	chunks?:
		| RegExp
		| "all"
		| "initial"
		| "async"
		| ((chunk: Chunk) => undefined | boolean);

	/**
	 * Ignore minimum size, minimum chunks and maximum requests and always create chunks for this cache group.
	 */
	enforce?: boolean;

	/**
	 * Size threshold at which splitting is enforced and other restrictions (minRemainingSize, maxAsyncRequests, maxInitialRequests) are ignored.
	 */
	enforceSizeThreshold?: number | { [index: string]: number };

	/**
	 * Sets the template for the filename for created chunks.
	 */
	filename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Sets the hint for chunk id.
	 */
	idHint?: string;

	/**
	 * Assign modules to a cache group by module layer.
	 */
	layer?: string | RegExp | ((layer: null | string) => boolean);

	/**
	 * Maximum number of requests which are accepted for on-demand loading.
	 */
	maxAsyncRequests?: number;

	/**
	 * Maximal size hint for the on-demand chunks.
	 */
	maxAsyncSize?: number | { [index: string]: number };

	/**
	 * Maximum number of initial chunks which are accepted for an entry point.
	 */
	maxInitialRequests?: number;

	/**
	 * Maximal size hint for the initial chunks.
	 */
	maxInitialSize?: number | { [index: string]: number };

	/**
	 * Maximal size hint for the created chunks.
	 */
	maxSize?: number | { [index: string]: number };

	/**
	 * Minimum number of times a module has to be duplicated until it's considered for splitting.
	 */
	minChunks?: number;

	/**
	 * Minimal size for the chunks the stay after moving the modules to a new chunk.
	 */
	minRemainingSize?: number | { [index: string]: number };

	/**
	 * Minimal size for the created chunk.
	 */
	minSize?: number | { [index: string]: number };

	/**
	 * Minimum size reduction due to the created chunk.
	 */
	minSizeReduction?: number | { [index: string]: number };

	/**
	 * Give chunks for this cache group a name (chunks with equal name are merged).
	 */
	name?:
		| string
		| false
		| ((module: Module, chunks: Chunk[], key: string) => undefined | string);

	/**
	 * Priority of this cache group.
	 */
	priority?: number;

	/**
	 * Try to reuse existing chunk (with name) when it has matching modules.
	 */
	reuseExistingChunk?: boolean;

	/**
	 * Assign modules to a cache group by module name.
	 */
	test?:
		| string
		| RegExp
		| GlobCondition
		| ((module: Module, context: CacheGroupsContext) => boolean);

	/**
	 * Assign modules to a cache group by module type.
	 */
	type?: string | RegExp | ((type: string) => boolean);

	/**
	 * Compare used exports when checking common modules. Modules will only be put in the same chunk when exports are equal.
	 */
	usedExports?: boolean;
}

/**
 * Options object for splitting chunks into smaller chunks.
 */
declare interface OptimizationSplitChunksOptions {
	/**
	 * Sets the name delimiter for created chunks.
	 */
	automaticNameDelimiter?: string;

	/**
	 * Assign modules to a cache group (modules from different cache groups are tried to keep in separate chunks, default categories: 'default', 'defaultVendors').
	 */
	cacheGroups?: {
		[index: string]:
			| string
			| false
			| RegExp
			| ((
					module: Module
			  ) =>
					| void
					| OptimizationSplitChunksCacheGroup
					| OptimizationSplitChunksCacheGroup[])
			| OptimizationSplitChunksCacheGroup;
	};

	/**
	 * Select chunks for determining shared modules (defaults to "async", "initial" and "all" requires adding these chunks to the HTML).
	 */
	chunks?:
		| RegExp
		| "all"
		| "initial"
		| "async"
		| ((chunk: Chunk) => undefined | boolean);

	/**
	 * Rounds of intersections of the chunk sets to look through for modules shared by chunks no single chunk set holds together (0 looks through the chunk sets alone; every round costs more computation).
	 * @since 5.112.0
	 */
	dedupDepth?: number;

	/**
	 * Sets the size types which are used when a number is used for sizes.
	 */
	defaultSizeTypes?: string[];

	/**
	 * Size threshold at which splitting is enforced and other restrictions (minRemainingSize, maxAsyncRequests, maxInitialRequests) are ignored.
	 */
	enforceSizeThreshold?: number | { [index: string]: number };

	/**
	 * Options for modules not selected by any other cache group.
	 */
	fallbackCacheGroup?: {
		/**
		 * Sets the name delimiter for created chunks.
		 */
		automaticNameDelimiter?: string;
		/**
		 * Select chunks for determining shared modules (defaults to "async", "initial" and "all" requires adding these chunks to the HTML).
		 */
		chunks?:
			| RegExp
			| "all"
			| "initial"
			| "async"
			| ((chunk: Chunk) => undefined | boolean);
		/**
		 * Maximal size hint for the on-demand chunks.
		 */
		maxAsyncSize?: number | { [index: string]: number };
		/**
		 * Maximal size hint for the initial chunks.
		 */
		maxInitialSize?: number | { [index: string]: number };
		/**
		 * Maximal size hint for the created chunks.
		 */
		maxSize?: number | { [index: string]: number };
		/**
		 * Minimal size for the created chunk.
		 */
		minSize?: number | { [index: string]: number };
		/**
		 * Minimum size reduction due to the created chunk.
		 */
		minSizeReduction?: number | { [index: string]: number };
	};

	/**
	 * Sets the template for the filename for created chunks.
	 */
	filename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Prevents exposing path info when creating names for parts splitted by maxSize.
	 */
	hidePathInfo?: boolean;

	/**
	 * Maximum number of requests which are accepted for on-demand loading.
	 */
	maxAsyncRequests?: number;

	/**
	 * Maximal size hint for the on-demand chunks.
	 */
	maxAsyncSize?: number | { [index: string]: number };

	/**
	 * Maximum number of initial chunks which are accepted for an entry point.
	 */
	maxInitialRequests?: number;

	/**
	 * Maximal size hint for the initial chunks.
	 */
	maxInitialSize?: number | { [index: string]: number };

	/**
	 * Maximal size hint for the created chunks.
	 */
	maxSize?: number | { [index: string]: number };

	/**
	 * Minimum number of times a module has to be duplicated until it's considered for splitting.
	 */
	minChunks?: number;

	/**
	 * Minimal size for the chunks the stay after moving the modules to a new chunk.
	 */
	minRemainingSize?: number | { [index: string]: number };

	/**
	 * Minimal size for the created chunks.
	 */
	minSize?: number | { [index: string]: number };

	/**
	 * Minimum size reduction due to the created chunk.
	 */
	minSizeReduction?: number | { [index: string]: number };

	/**
	 * Give chunks created a name (chunks with equal name are merged).
	 */
	name?:
		| string
		| false
		| ((module: Module, chunks: Chunk[], key: string) => undefined | string);

	/**
	 * Compare used exports when checking common modules. Modules will only be put in the same chunk when exports are equal.
	 */
	usedExports?: boolean;
}
declare abstract class OptionsApply {
	/**
	 * Returns options object.
	 */
	process(
		options: WebpackOptionsNormalizedWithDefaults,
		compiler: Compiler,
		interception?: WebpackOptionsInterception
	): WebpackOptionsNormalizedWithDefaults;
}

/**
 * Defines the options type used by this module.
 */
declare interface OptionsDelegatedModuleFactoryPlugin {
	/**
	 * 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 interface OptionsStreamChunks {
	source?: boolean;
	finalSource?: boolean;
	columns?: boolean;
	scopes?: boolean;
}

/**
 * what a caller may ask the parser for
 */
declare interface OptionsSyntaxParser {
	/**
	 * which edition to parse
	 */
	ecmaVersion: EcmaVersion;

	/**
	 * the goal symbol
	 */
	sourceType?: "module" | "commonjs" | "script";

	/**
	 * whether the code is strict whatever it says
	 */
	strict?: boolean;

	/**
	 * called where a semicolon was inserted
	 */
	onInsertedSemicolon?: (
		lastTokEnd: number,
		lastTokEndLoc?: null | Position
	) => void;

	/**
	 * called at a trailing comma
	 */
	onTrailingComma?: (
		lastTokEnd: number,
		lastTokEndLoc?: null | Position
	) => void;

	/**
	 * whether reserved words may name things
	 */
	allowReserved?: boolean | "never";

	/**
	 * whether `return` may sit at the top level
	 */
	allowReturnOutsideFunction?: boolean;

	/**
	 * whether module syntax may sit anywhere
	 */
	allowImportExportEverywhere?: boolean;

	/**
	 * whether `await` may sit outside a function
	 */
	allowAwaitOutsideFunction?: boolean;

	/**
	 * whether `super` may sit outside a method
	 */
	allowSuperOutsideMethod?: boolean;

	/**
	 * whether a leading `#!` line is skipped
	 */
	allowHashBang?: boolean;

	/**
	 * whether private names must be declared
	 */
	checkPrivateFields?: boolean;

	/**
	 * whether nodes carry `loc`
	 */
	locations?: boolean;

	/**
	 * where the first offset falls
	 */
	startLocation?: { line: number; column: number };

	/**
	 * where tokens are reported
	 */
	onToken?:
		((token: TokenSyntaxParserClass) => void) | TokenSyntaxParserClass[];

	/**
	 * the parser itself at each token, for a reader that copies what it needs rather than taking a token of its own
	 */
	onTokenRead?: (parser: SyntaxParser) => void;

	/**
	 * where comments are reported
	 */
	onComment?:
		| ((
				isBlock: boolean,
				text: string,
				start: number,
				end: number,
				startLoc?: null | Position,
				endLoc?: null | Position
		  ) => void)
		| CollectedComment[];

	/**
	 * whether nodes carry `range`
	 */
	ranges?: boolean;

	/**
	 * a program node to append to
	 */
	program?: NodeLike;

	/**
	 * the name errors and locations carry
	 */
	sourceFile?: string;

	/**
	 * the name every node carries
	 */
	directSourceFile?: string;

	/**
	 * whether parentheses become nodes
	 */
	preserveParens?: boolean;
}
declare interface OriginRecord {
	module: null | Module;
	loc: DependencyLocation;
	request: string;
}
declare class OriginalSource extends Source {
	constructor(
		value: string | Buffer,
		name: string,
		scopeBindings?: Map<string, string>
	);
	getName(): string;
	streamChunks(
		options: OptionsStreamChunks,
		onChunk: (
			chunk: undefined | string,
			generatedLine: number,
			generatedColumn: number,
			sourceIndex: number,
			originalLine: number,
			originalColumn: number,
			nameIndex: number
		) => void,
		onSource: (
			sourceIndex: number,
			source: null | string,
			sourceContent?: string,
			scopeBindings?: Map<string, string>
		) => void,
		_onName: (nameIndex: number, name: string) => void
	): GeneratedSourceInfo;
}

/**
 * Options affecting the output of the compilation. `output` options tell webpack how to write the compiled files to disk.
 */
declare interface Output {
	/**
	 * Add a container for define/require functions in the AMD module.
	 */
	amdContainer?: string;

	/**
	 * The filename of asset modules as relative path inside the 'output.path' directory.
	 */
	assetModuleFilename?: string | TemplatePathFn<PathDataModule>;

	/**
	 * Enable/disable creating async chunks that are loaded on demand.
	 */
	asyncChunks?: boolean;

	/**
	 * Add a comment in the UMD wrapper.
	 */
	auxiliaryComment?: string | LibraryCustomUmdCommentObject;

	/**
	 * Add charset attribute for script tag.
	 */
	charset?: boolean;

	/**
	 * Specifies the filename template of output files of non-initial chunks on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	chunkFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * The format of chunks (formats included by default are 'array-push' (web/WebWorker), 'commonjs' (node.js), 'module' (ESM), but others might be added by plugins).
	 */
	chunkFormat?: string | false;

	/**
	 * Number of milliseconds before chunk request expires.
	 */
	chunkLoadTimeout?: number;

	/**
	 * The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
	 */
	chunkLoading?: string | false;

	/**
	 * The global variable used by webpack for loading of chunks.
	 */
	chunkLoadingGlobal?: string;

	/**
	 * Clean the output directory before emit.
	 */
	clean?: boolean | CleanOptions;

	/**
	 * Check if to be emitted file already exists and have the same content before writing to output filesystem.
	 */
	compareBeforeEmit?: boolean;

	/**
	 * Copy files and directories to the output directory.
	 * @since 5.111.0
	 */
	copy?: string | CopyPattern[];

	/**
	 * This option enables cross-origin loading of chunks.
	 */
	crossOriginLoading?: false | "anonymous" | "use-credentials";

	/**
	 * Specifies the filename template of non-initial output css files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	cssChunkFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Specifies the filename template of output css files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	cssFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Similar to `output.devtoolModuleFilenameTemplate`, but used in the case of duplicate module identifiers.
	 */
	devtoolFallbackModuleFilenameTemplate?:
		string | ((context: ModuleFilenameTemplateContext) => string);

	/**
	 * Filename template string of function for the sources array in a generated SourceMap.
	 */
	devtoolModuleFilenameTemplate?:
		string | ((context: ModuleFilenameTemplateContext) => string);

	/**
	 * Module namespace to use when interpolating filename template string for the sources array in a generated SourceMap. Defaults to `output.library` if not set. It's useful for avoiding runtime collisions in sourcemaps from multiple webpack projects built as libraries.
	 */
	devtoolNamespace?: string;

	/**
	 * List of chunk loading types enabled for use by entry points.
	 */
	enabledChunkLoadingTypes?: string[];

	/**
	 * List of library types enabled for use by entry points.
	 */
	enabledLibraryTypes?: string[];

	/**
	 * List of wasm loading types enabled for use by entry points.
	 */
	enabledWasmLoadingTypes?: string[];

	/**
	 * The abilities of the environment where the webpack generated code should run.
	 */
	environment?: Environment;

	/**
	 * Specifies the filename of output files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	filename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * An expression which is used to address the global object/scope in runtime code.
	 */
	globalObject?: string;

	/**
	 * Digest types used for the hash.
	 */
	hashDigest?: string;

	/**
	 * Number of chars which are used for the hash.
	 */
	hashDigestLength?: number;

	/**
	 * Algorithm used for generation the hash (see node.js crypto package).
	 */
	hashFunction?: string | typeof Hash;

	/**
	 * Any string which is added to the hash to salt it.
	 */
	hashSalt?: string;

	/**
	 * The filename of the Hot Update Chunks. They are inside the output.path directory.
	 */
	hotUpdateChunkFilename?: string;

	/**
	 * The global variable used by webpack for loading of hot update chunks.
	 */
	hotUpdateGlobal?: string;

	/**
	 * The filename of the Hot Update Main File. It is inside the 'output.path' directory.
	 */
	hotUpdateMainFilename?: string;

	/**
	 * Generate an HTML file for each non-HTML entrypoint with its JS and CSS output chunks injected. Can be overridden per entry via the entry descriptor `html` option.
	 */
	html?: boolean | OutputHtmlOptions;

	/**
	 * Specifies the filename template of non-initial output html files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	htmlChunkFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Specifies the filename template of output html files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	htmlFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Ignore warnings in the browser.
	 */
	ignoreBrowserWarnings?: boolean;

	/**
	 * Wrap javascript code into IIFE's to avoid leaking into global scope.
	 */
	iife?: boolean;

	/**
	 * The name of the native import() function (can be exchanged for a polyfill).
	 */
	importFunctionName?: string;

	/**
	 * The name of the native import.meta object (can be exchanged for a polyfill).
	 */
	importMetaName?: string;

	/**
	 * Make the output files a library, exporting the exports of the entry point.
	 */
	library?: string | LibraryOptions | string[] | LibraryCustomUmdObject;

	/**
	 * Specify which export should be exposed as library.
	 */
	libraryExport?: string | string[];

	/**
	 * Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'commonjs-static', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).
	 */
	libraryTarget?: string;

	/**
	 * Output javascript files as module source type.
	 */
	module?: boolean;

	/**
	 * The output directory as **absolute path** (required).
	 */
	path?: string;

	/**
	 * Include comments with information about the modules.
	 */
	pathinfo?: boolean | "verbose";

	/**
	 * The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
	 */
	publicPath?: string | TemplatePathFn<PathData>;

	/**
	 * Resource-hint (`<link rel="prefetch">` / `<link rel="preload">` / `<link rel="modulepreload">` / `<link rel="preconnect">`) emission for extracted HTML entries and URL-referenced assets. Accepts the initial-graph shorthand (boolean / `"prefetch"` / `"preload"` / `"none"` / `HtmlResourceHint[]` / function — equivalent to `{ initial: <value> }`) or the full object form `{ initial, urlHints, preconnect, modulePreloadPolyfill, manifest }`. `initial` defaults on for ESM output (`output.module`), where native `import()` would otherwise waterfall; classic output stays opt-in.
	 * @since 5.109.0
	 */
	resourceHints?:
		| boolean
		| "none"
		| ResourceHintsOptions
		| HtmlResourceHintWebpackOptions[]
		| "prefetch"
		| "preload"
		| ((context: {
				entryName: string;
				entrypoint: Entrypoint;
				hostType: "html" | "js";
				compilation: Compilation;
				defaultHints: (HtmlResourceHintHtmlEntryDependency & {
					hostChunks: string[];
				})[];
		  }) => HtmlResourceHintHtmlEntryDependency[]);

	/**
	 * This option enables loading async chunks via a custom script type, such as script type="module".
	 */
	scriptType?: false | "module" | "text/javascript";

	/**
	 * The filename of the SourceMaps for the JavaScript files. They are inside the 'output.path' directory.
	 */
	sourceMapFilename?: string;

	/**
	 * Prefixes every line of the source in the bundle with this string.
	 */
	sourcePrefix?: string;

	/**
	 * Handles error in module loading correctly at a performance cost. This will handle module error compatible with the EcmaScript Modules spec.
	 */
	strictModuleErrorHandling?: boolean;

	/**
	 * Handles exceptions in module loading correctly at a performance cost (Deprecated). This will handle module error compatible with the Node.js CommonJS way.
	 * @deprecated
	 */
	strictModuleExceptionHandling?: boolean;

	/**
	 * Emit a runtime check that throws a 'MODULE_NOT_FOUND' error when a required module id is missing from the bundle.
	 */
	strictModuleResolution?: boolean;

	/**
	 * Use a Trusted Types policy to create urls for chunks. 'output.uniqueName' is used a default policy name. Passing a string sets a custom policy name.
	 */
	trustedTypes?: string | true | TrustedTypes;

	/**
	 * If `output.libraryTarget` is set to umd and `output.library` is set, setting this to true will name the AMD module.
	 */
	umdNamedDefine?: boolean;

	/**
	 * A unique name of the webpack build to avoid multiple webpack runtimes to conflict when using globals.
	 */
	uniqueName?: string;

	/**
	 * The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
	 */
	wasmLoading?: string | false;

	/**
	 * Fall back to non-streaming WebAssembly instantiation when streaming compilation fails because the server does not serve `.wasm` files with the `application/wasm` MIME type.
	 * @since 5.109.0
	 */
	wasmStreamingFallback?: boolean;

	/**
	 * The filename of WebAssembly modules as relative path inside the 'output.path' directory.
	 */
	webassemblyModuleFilename?: string;

	/**
	 * Specifies the filename template of non-initial output worker's files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	workerChunkFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
	 */
	workerChunkLoading?: string | false;

	/**
	 * Worker public path. Much like the public path, this sets the location where the worker script file is intended to be found. If not set, webpack will use the publicPath. Don't set this option unless your worker scripts are located at a different path from your other script files.
	 */
	workerPublicPath?: string;

	/**
	 * The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
	 */
	workerWasmLoading?: string | false;
}

/**
 * Defines the output file system type used by this module.
 */
declare interface OutputFileSystem {
	mkdir: Mkdir;
	readdir?: ReaddirFs;
	rmdir?: (
		file: PathLikeFs,
		callback: (err: null | NodeJS.ErrnoException) => void
	) => void;
	writeFile: WriteFile;
	unlink?: (
		pathLike: PathLikeFs,
		callback: (err: null | NodeJS.ErrnoException) => void
	) => void;
	symlink?: (
		target: PathLikeFs,
		path: PathLikeFs,
		type: undefined | null | "file" | "dir" | "junction",
		callback: (err: null | NodeJS.ErrnoException) => void
	) => void;
	readlink?: ReadlinkFs;
	chmod?: (
		path: PathLikeFs,
		mode: string | number,
		callback: (err: null | NodeJS.ErrnoException) => void
	) => void;
	utimes?: (
		path: PathLikeFs,
		atime: string | number | Date,
		mtime: string | number | Date,
		callback: (err: null | NodeJS.ErrnoException) => void
	) => void;
	stat: StatFs;
	lstat?: LStatFs;
	readFile: ReadFileFs;
	createReadStream?: (
		path: PathLikeFs,
		options?:
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| ReadStreamOptions
	) => NodeJS.ReadableStream;
	join?: (path1: string, path2: string) => string;
	relative?: (from: string, to: string) => string;
	dirname?: (dirname: string) => string;
}

/**
 * Options for the generated HTML files.
 */
declare interface OutputHtmlOptions {
	/**
	 * Inject a `<base>` element into the page `<head>`. A string sets `href`; an object sets both `href` and optionally `target`. Skipped if the HTML already contains a `<base>` element.
	 * @since 5.109.0
	 */
	base?:
		| string
		| {
				/**
				 * Value for the `href` attribute of the `<base>` element.
				 */
				href: string;
				/**
				 * Value for the `target` attribute of the `<base>` element (e.g. `"_blank"`).
				 */
				target?: string;
		  };

	/**
	 * Inject a `<meta http-equiv="Content-Security-Policy">` into every webpack-emitted HTML page. `false` (default) does nothing; `true` uses a strict baseline (`script-src 'self'`, `style-src 'self'`, `object-src 'none'`, `base-uri 'self'`) and appends a `sha256` hash of every inline `<script>`/`<style>` to `script-src`/`style-src`. An object customizes it. Skipped when the page already declares a CSP.
	 */
	csp?:
		| boolean
		| {
				/**
				 * Hash algorithm used for inline `<script>`/`<style>` sources.
				 */
				hashFunction?: "sha256" | "sha384" | "sha512";
				/**
				 * Placeholder nonce added to injected `<script>`/`<style>` tags and as a `'nonce-…'` source; rewrite it per request server-side.
				 */
				nonce?: string;
				/**
				 * CSP directives merged over the baseline. Each key is a directive (e.g. `"script-src"`); the value is a source string or list. Inline hashes and any `nonce` are still appended to `script-src`/`style-src`.
				 */
				policy?: { [index: string]: string | string[] };
		  };

	/**
	 * Favicon(s) for webpack-generated HTML (authored pages are left untouched). `false` (default) injects nothing; `true` injects the webpack logo; a string is a path to an icon; an object maps each `<link rel>` to an icon — a path string, an object with the icon `href` plus extra link attributes (`sizes`, `media`, `color`, `type`, `crossorigin`), or an array of these for multiple icons under the same `rel` (e.g. several `sizes`, or light/dark `media` variants); a function receives the page name and returns one of these. Every icon is emitted as a hashed asset.
	 * @since 5.109.0
	 */
	favicon?:
		| string
		| boolean
		| {
				[index: string]:
					| string
					| {
							/**
							 * Value for the `color` attribute (used by `rel="mask-icon"`).
							 */
							color?: string;
							/**
							 * Value for the `crossorigin` attribute.
							 */
							crossorigin?: "anonymous" | "use-credentials";
							/**
							 * Path to the icon file, emitted as a hashed asset.
							 */
							href: string;
							/**
							 * Value for the `media` attribute (e.g. `"(prefers-color-scheme: dark)"`).
							 */
							media?: string;
							/**
							 * Value for the `sizes` attribute (e.g. `"180x180"` or `"any"`).
							 */
							sizes?: string;
							/**
							 * Value for the `type` attribute; inferred from the file extension when omitted.
							 */
							type?: string;
					  }
					| HtmlFaviconIcon[];
		  }
		| ((name: string) =>
				| string
				| boolean
				| {
						[index: string]:
							| string
							| {
									/**
									 * Value for the `color` attribute (used by `rel="mask-icon"`).
									 */
									color?: string;
									/**
									 * Value for the `crossorigin` attribute.
									 */
									crossorigin?: "anonymous" | "use-credentials";
									/**
									 * Path to the icon file, emitted as a hashed asset.
									 */
									href: string;
									/**
									 * Value for the `media` attribute (e.g. `"(prefers-color-scheme: dark)"`).
									 */
									media?: string;
									/**
									 * Value for the `sizes` attribute (e.g. `"180x180"` or `"any"`).
									 */
									sizes?: string;
									/**
									 * Value for the `type` attribute; inferred from the file extension when omitted.
									 */
									type?: string;
							  }
							| HtmlFaviconIcon[];
				  });

	/**
	 * Where to place injected chunk `<script>`/`<link>` tags. `"body"` (default; `"head"` with `output.module`) keeps them next to the entry tag — end of `<body>` on generated pages; `"head"` moves them into `<head>`; `false` suppresses sibling-chunk injection (entry tags and resource hints remain).
	 * @since 5.109.0
	 */
	inject?: false | "body" | "head";

	/**
	 * Inline the content of matching chunks directly into the HTML instead of emitting a separate `<script>`/`<link>` tag. `true` inlines every chunk; `"script"` inlines only JavaScript, `"style"` only CSS; an array of `RegExp` patterns matches against the chunk name and the filename template it is emitted under. A chunk another entry loads its runtime from by url stays a separate file.
	 * @since 5.109.0
	 */
	inline?: boolean | "script" | "style" | RegExp[];

	/**
	 * Add Subresource Integrity (SRI) `integrity` attributes to injected `<script>`/`<link>` tags. `true` uses `['sha384']`; an array sets the hash algorithms; a function receives each referenced asset and returns the algorithms to use or `false` to skip it.
	 * @since 5.109.0
	 */
	integrity?:
		| boolean
		| string[]
		| ((asset: { chunk: Chunk; filename: string }) => false | string[]);

	/**
	 * Web app manifest for webpack-generated HTML (authored pages are left untouched). `false` (default) injects nothing. A string is a path to an existing `.webmanifest` file to link. An object is the manifest contents — serialized, emitted as a hashed `.webmanifest` and linked with `<link rel="manifest">`; its `icons`/`screenshots` `src` paths resolve like any request and are emitted as hashed assets. A function receives the page name and returns one of these.
	 */
	manifest?:
		| string
		| false
		| { [index: string]: any }
		| ((name: string) => string | false | { [index: string]: any });

	/**
	 * Inject `<meta>` tags into the page `<head>`. Each key is the `name` attribute (or `"charset"` for a charset declaration); the value is the `content` string. Keys beginning with `og:` use the `property` attribute instead of `name`. A tag is skipped if the HTML already contains a meta with the same name.
	 * @since 5.109.0
	 */
	meta?: { [index: string]: string };

	/**
	 * How injected `<script>` tags load. `auto` (default) emits a module script for ES module output and `defer` otherwise; `defer` forces a deferred script; `blocking` emits a plain blocking script.
	 */
	scriptLoading?: "auto" | "defer" | "blocking";

	/**
	 * Sets the `<title>` of the generated HTML page. Skipped if the HTML already contains a `<title>` element.
	 * @since 5.109.0
	 */
	title?: string;
}

/**
 * Normalized options affecting the output of the compilation. `output` options tell webpack how to write the compiled files to disk.
 */
declare interface OutputNormalized {
	/**
	 * The filename of asset modules as relative path inside the 'output.path' directory.
	 */
	assetModuleFilename?: string | TemplatePathFn<PathDataModule>;

	/**
	 * Enable/disable creating async chunks that are loaded on demand.
	 */
	asyncChunks?: boolean;

	/**
	 * Add charset attribute for script tag.
	 */
	charset?: boolean;

	/**
	 * Specifies the filename template of output files of non-initial chunks on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	chunkFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * The format of chunks (formats included by default are 'array-push' (web/WebWorker), 'commonjs' (node.js), 'module' (ESM), but others might be added by plugins).
	 */
	chunkFormat?: string | false;

	/**
	 * Number of milliseconds before chunk request expires.
	 */
	chunkLoadTimeout?: number;

	/**
	 * The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
	 */
	chunkLoading?: string | false;

	/**
	 * The global variable used by webpack for loading of chunks.
	 */
	chunkLoadingGlobal?: string;

	/**
	 * Clean the output directory before emit.
	 */
	clean?: boolean | CleanOptions;

	/**
	 * Check if to be emitted file already exists and have the same content before writing to output filesystem.
	 */
	compareBeforeEmit?: boolean;

	/**
	 * Patterns of files which are copied to the output directory, and the options of the copying itself.
	 */
	copy?: CopyOptions;

	/**
	 * This option enables cross-origin loading of chunks.
	 */
	crossOriginLoading?: false | "anonymous" | "use-credentials";

	/**
	 * Specifies the filename template of non-initial output css files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	cssChunkFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Specifies the filename template of output css files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	cssFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Similar to `output.devtoolModuleFilenameTemplate`, but used in the case of duplicate module identifiers.
	 */
	devtoolFallbackModuleFilenameTemplate?:
		string | ((context: ModuleFilenameTemplateContext) => string);

	/**
	 * Filename template string of function for the sources array in a generated SourceMap.
	 */
	devtoolModuleFilenameTemplate?:
		string | ((context: ModuleFilenameTemplateContext) => string);

	/**
	 * Module namespace to use when interpolating filename template string for the sources array in a generated SourceMap. Defaults to `output.library` if not set. It's useful for avoiding runtime collisions in sourcemaps from multiple webpack projects built as libraries.
	 */
	devtoolNamespace?: string;

	/**
	 * List of chunk loading types enabled for use by entry points.
	 */
	enabledChunkLoadingTypes: string[];

	/**
	 * List of library types enabled for use by entry points.
	 */
	enabledLibraryTypes: string[];

	/**
	 * List of wasm loading types enabled for use by entry points.
	 */
	enabledWasmLoadingTypes: string[];

	/**
	 * The abilities of the environment where the webpack generated code should run.
	 */
	environment: Environment;

	/**
	 * Specifies the filename of output files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	filename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * An expression which is used to address the global object/scope in runtime code.
	 */
	globalObject?: string;

	/**
	 * Digest types used for the hash.
	 */
	hashDigest?: string;

	/**
	 * Number of chars which are used for the hash.
	 */
	hashDigestLength?: number;

	/**
	 * Algorithm used for generation the hash (see node.js crypto package).
	 */
	hashFunction?: string | typeof Hash;

	/**
	 * Any string which is added to the hash to salt it.
	 */
	hashSalt?: string;

	/**
	 * The filename of the Hot Update Chunks. They are inside the output.path directory.
	 */
	hotUpdateChunkFilename?: string;

	/**
	 * The global variable used by webpack for loading of hot update chunks.
	 */
	hotUpdateGlobal?: string;

	/**
	 * The filename of the Hot Update Main File. It is inside the 'output.path' directory.
	 */
	hotUpdateMainFilename?: string;

	/**
	 * Generate an HTML file for each non-HTML entrypoint with its JS and CSS output chunks injected. Can be overridden per entry via the entry descriptor `html` option.
	 */
	html?: boolean | OutputHtmlOptions;

	/**
	 * Specifies the filename template of non-initial output html files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	htmlChunkFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Specifies the filename template of output html files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	htmlFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * Ignore warnings in the browser.
	 */
	ignoreBrowserWarnings?: boolean;

	/**
	 * Wrap javascript code into IIFE's to avoid leaking into global scope.
	 */
	iife?: boolean;

	/**
	 * The name of the native import() function (can be exchanged for a polyfill).
	 */
	importFunctionName?: string;

	/**
	 * The name of the native import.meta object (can be exchanged for a polyfill).
	 */
	importMetaName?: string;

	/**
	 * Options for library.
	 */
	library?: LibraryOptions;

	/**
	 * Output javascript files as module source type.
	 */
	module?: boolean;

	/**
	 * The output directory as **absolute path** (required).
	 */
	path?: string;

	/**
	 * Include comments with information about the modules.
	 */
	pathinfo?: boolean | "verbose";

	/**
	 * The 'publicPath' specifies the public URL address of the output files when referenced in a browser.
	 */
	publicPath?: string | TemplatePathFn<PathData>;

	/**
	 * Full resource-hint configuration.
	 * @since 5.109.0
	 */
	resourceHints?: ResourceHintsOptions;

	/**
	 * This option enables loading async chunks via a custom script type, such as script type="module".
	 */
	scriptType?: false | "module" | "text/javascript";

	/**
	 * The filename of the SourceMaps for the JavaScript files. They are inside the 'output.path' directory.
	 */
	sourceMapFilename?: string;

	/**
	 * Prefixes every line of the source in the bundle with this string.
	 */
	sourcePrefix?: string;

	/**
	 * Handles error in module loading correctly at a performance cost. This will handle module error compatible with the EcmaScript Modules spec.
	 */
	strictModuleErrorHandling?: boolean;

	/**
	 * Handles exceptions in module loading correctly at a performance cost (Deprecated). This will handle module error compatible with the Node.js CommonJS way.
	 * @deprecated
	 */
	strictModuleExceptionHandling?: boolean;

	/**
	 * Emit a runtime check that throws a 'MODULE_NOT_FOUND' error when a required module id is missing from the bundle.
	 */
	strictModuleResolution?: boolean;

	/**
	 * Use a Trusted Types policy to create urls for chunks.
	 */
	trustedTypes?: TrustedTypes;

	/**
	 * A unique name of the webpack build to avoid multiple webpack runtimes to conflict when using globals.
	 */
	uniqueName?: string;

	/**
	 * The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
	 */
	wasmLoading?: string | false;

	/**
	 * Fall back to non-streaming WebAssembly instantiation when streaming compilation fails because the server does not serve `.wasm` files with the `application/wasm` MIME type.
	 * @since 5.109.0
	 */
	wasmStreamingFallback?: boolean;

	/**
	 * The filename of WebAssembly modules as relative path inside the 'output.path' directory.
	 */
	webassemblyModuleFilename?: string;

	/**
	 * Specifies the filename template of non-initial output worker's files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.
	 */
	workerChunkFilename?: string | TemplatePathFn<PathDataChunk>;

	/**
	 * The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).
	 */
	workerChunkLoading?: string | false;

	/**
	 * Worker public path. Much like the public path, this sets the location where the worker script file is intended to be found. If not set, webpack will use the publicPath. Don't set this option unless your worker scripts are located at a different path from your other script files.
	 */
	workerPublicPath?: string;

	/**
	 * The method of loading WebAssembly Modules (methods included by default are 'fetch' (web/WebWorker), 'async-node' (node.js), but others might be added by plugins).
	 */
	workerWasmLoading?: string | false;
}
type OutputNormalizedWithDefaults = OutputNormalized & {
	uniqueName: string;
	filename: NonNullable<undefined | string | TemplatePathFn<PathDataChunk>>;
	cssFilename: NonNullable<undefined | string | TemplatePathFn<PathDataChunk>>;
	chunkFilename: NonNullable<
		undefined | string | TemplatePathFn<PathDataChunk>
	>;
	cssChunkFilename: NonNullable<
		undefined | string | TemplatePathFn<PathDataChunk>
	>;
	hotUpdateChunkFilename: string;
	hotUpdateGlobal: string;
	assetModuleFilename: NonNullable<
		undefined | string | TemplatePathFn<PathDataModule>
	>;
	webassemblyModuleFilename: string;
	sourceMapFilename: string;
	hotUpdateMainFilename: string;
	devtoolNamespace: string;
	publicPath: NonNullable<undefined | string | TemplatePathFn<PathData>>;
	workerPublicPath: string;
	workerChunkFilename: NonNullable<
		undefined | string | TemplatePathFn<PathDataChunk>
	>;
	workerWasmLoading: NonNullable<undefined | string | false>;
	workerChunkLoading: NonNullable<undefined | string | false>;
	chunkFormat: NonNullable<undefined | string | false>;
	module: NonNullable<undefined | boolean>;
	asyncChunks: NonNullable<undefined | boolean>;
	charset: NonNullable<undefined | boolean>;
	iife: NonNullable<undefined | boolean>;
	globalObject: string;
	scriptType: NonNullable<undefined | false | "module" | "text/javascript">;
	path: string;
	pathinfo: NonNullable<undefined | boolean | "verbose">;
	hashFunction: NonNullable<undefined | string | typeof Hash>;
	hashDigest: string;
	hashDigestLength: number;
	chunkLoadTimeout: number;
	chunkLoading: NonNullable<undefined | string | false>;
	chunkLoadingGlobal: string;
	compareBeforeEmit: NonNullable<undefined | boolean>;
	strictModuleErrorHandling: NonNullable<undefined | boolean>;
	strictModuleExceptionHandling: NonNullable<undefined | boolean>;
	strictModuleResolution: NonNullable<undefined | boolean>;
	importFunctionName: string;
	importMetaName: string;
	environment: RecursiveNonNullable<Environment>;
	crossOriginLoading: NonNullable<
		undefined | false | "anonymous" | "use-credentials"
	>;
	wasmLoading: NonNullable<undefined | string | false>;
};

/**
 * Defines the parameterized comparator type used by this module.
 */
declare interface ParameterizedComparator<TArg extends object, T> {
	(tArg: TArg): Comparator<T>;
}
type ParseErrorSeverity = "error" | "warning";

/**
 * Defines the parse options type used by this module.
 */
declare interface ParseOptionsJavascriptParser {
	sourceType: "module" | "script";
	ecmaVersion: EcmaVersion;
	locations?: boolean;
	comments?: boolean;
	ranges?: boolean;
	allowHashBang?: boolean;
	allowReturnOutsideFunction?: boolean;

	/**
	 * internal: serve `range` lazily and skip the parser's location/range tracking
	 */
	lazyNodes?: boolean;

	/**
	 * internal: collect comments here without slicing their text eagerly
	 */
	lazyComments?: CommentJavascriptParser[];

	/**
	 * enable parsing of the import phase proposals (import defer / import source)
	 */
	importPhases?: boolean;

	/**
	 * internal: for `auto`, let the parser downgrade module->script in place instead of re-parsing
	 */
	moduleFallback?: boolean;
}
declare interface ParseOptionsSyntaxParser {
	/**
	 * optional comment-token callback; the public `parse*` entry points use it to build the `TokenStream` so the outer parser's comment tracker still sees magic comments inside the consumed range
	 */
	comment?: (input: string, start: number, end: number) => number;
}

/**
 * Defines the parse result type used by this module.
 */
declare interface ParseResult {
	ast: Program;
	comments: CommentJavascriptParser[];
}

/**
 * A `data:` URI split into the parts a caller has to put back together.
 * `parameters` is every `;…` after the media type (`;base64` included) and
 * `payload` the text after the comma, both in the form they were written.
 */
declare interface ParsedDataURI {
	mediaType: string;
	parameters: string;
	base64: boolean;
	payload: string;
}
type ParsedExpression =
	| (ImportExpressionImport & NodeLike)
	| (UnaryExpression & NodeLike)
	| (ArrayExpression & NodeLike)
	| (ArrowFunctionExpression & NodeLike)
	| (AssignmentExpression & NodeLike)
	| (AwaitExpression & NodeLike)
	| (BinaryExpression & NodeLike)
	| (SimpleCallExpression & NodeLike)
	| (NewExpression & NodeLike)
	| (ChainExpression & NodeLike)
	| (ClassExpression & NodeLike)
	| (ConditionalExpression & NodeLike)
	| (FunctionExpression & NodeLike)
	| (Identifier & NodeLike)
	| (SimpleLiteral & NodeLike)
	| (RegExpLiteral & NodeLike)
	| (BigIntLiteral & NodeLike)
	| (LogicalExpression & NodeLike)
	| (MemberExpression & NodeLike)
	| (MetaProperty & NodeLike)
	| (ObjectExpression & NodeLike)
	| (SequenceExpression & NodeLike)
	| (TaggedTemplateExpression & NodeLike)
	| (TemplateLiteral & NodeLike)
	| (ThisExpression & NodeLike)
	| (UpdateExpression & NodeLike)
	| (YieldExpression & NodeLike)
	| (NodeLike & {
			type: "ParenthesizedExpression";
			expression: ParsedExpression;
	  });
declare interface ParsedIdentifier {
	/**
	 * request
	 */
	request: string;

	/**
	 * query
	 */
	query: string;

	/**
	 * fragment
	 */
	fragment: string;

	/**
	 * is directory
	 */
	directory: boolean;

	/**
	 * is module
	 */
	module: boolean;

	/**
	 * is file
	 */
	file: boolean;

	/**
	 * is internal
	 */
	internal: boolean;
}
type ParsedProgram = Program & NodeLike;
declare class Parser<TModule extends NormalModule = NormalModule> {
	constructor();

	/**
	 * Parses the provided source and updates the parser state.
	 */
	parse(
		source: string | Buffer | PreparsedAst,
		state: ParserState<NormalModule>
	): ParserState<NormalModule>;
}

/**
 * An ESTree node, as this parser builds one.
 */
declare class ParserNode {
	constructor(parser: SyntaxParser, pos: number, loc?: Position);
	type: string;
	start: number;
	end: number;
	loc?: ParserSourceLocation;
	sourceFile?: string;
	range?: number[];
}
type ParserOptionsByModuleType = ParserOptionsByModuleTypeKnown &
	ParserOptionsByModuleTypeUnknown;

/**
 * Specify options for each parser.
 */
declare interface ParserOptionsByModuleTypeKnown {
	/**
	 * Parser options for asset modules.
	 */
	asset?: AssetParserOptions;

	/**
	 * No parser options are supported for this module type.
	 */
	"asset/bytes"?: EmptyParserOptions;

	/**
	 * No parser options are supported for this module type.
	 */
	"asset/inline"?: EmptyParserOptions;

	/**
	 * No parser options are supported for this module type.
	 */
	"asset/resource"?: EmptyParserOptions;

	/**
	 * No parser options are supported for this module type.
	 */
	"asset/source"?: EmptyParserOptions;

	/**
	 * Parser options for css modules.
	 */
	css?: CssParserOptions;

	/**
	 * Parser options for css/auto and css/module modules.
	 */
	"css/auto"?: CssAutoOrModuleParserOptions;

	/**
	 * Parser options for css/global modules.
	 */
	"css/global"?: CssModuleParserOptions;

	/**
	 * Parser options for css/auto and css/module modules.
	 */
	"css/module"?: CssAutoOrModuleParserOptions;

	/**
	 * Parser options for html modules.
	 */
	html?: HtmlParserOptions;

	/**
	 * Parser options for javascript modules.
	 */
	javascript?: JavascriptParserOptions;

	/**
	 * Parser options for javascript modules.
	 */
	"javascript/auto"?: JavascriptParserOptions;

	/**
	 * Parser options for javascript modules.
	 */
	"javascript/dynamic"?: JavascriptParserOptions;

	/**
	 * Parser options for javascript modules.
	 */
	"javascript/esm"?: JavascriptParserOptions;

	/**
	 * Parser options for JSON modules.
	 */
	json?: JsonParserOptions;
}

/**
 * Specify options for each parser.
 */
declare interface ParserOptionsByModuleTypeUnknown {
	[index: string]: { [index: string]: any };
}
declare interface ParserOptionsNormalModule {
	[index: string]: any;
}
type ParserOptionsSyntaxParser = Omit<OptionsSyntaxParser, "onComment"> & {
	onComment?:
		| CollectedComment[]
		| ((isBlock: boolean, text: string, start: number, end: number) => void);
	lazyNodes?: boolean;
	lazyComments?: CollectedComment[];
	importPhases?: boolean;
	moduleFallback?: boolean;
};

/**
 * Mirror of acorn's `Position` (line/column pair with its `offset` helper),
 * served by the owned `raise`/`curPosition`.
 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/locutil.js
 */
declare class ParserPosition {
	constructor(line: number, col: number);
	line: number;
	column: number;
	offset(n: number): ParserPosition;
}

/**
 * One lexical scope, holding the names declared directly in it. Each set is
 * built only once a name goes into it, which most scopes never do.
 */
declare class ParserScope {
	constructor(flags: number);
	flags: number;
	var?: Set<string>;
	lexical?: Set<string>;
	functions?: Set<string>;
	firstLexical?: string;
	hoisted?: (number | NodeLike)[];
}

/**
 * The `loc` a node carries when `options.locations` is on.
 */
declare class ParserSourceLocation {
	constructor(
		p: { sourceFile: null | string },
		start?: null | PositionLike,
		end?: null | PositionLike
	);
	start?: null | PositionLike;
	end?: null | PositionLike;
	source?: string;
}
type ParserState<TModule extends NormalModule = NormalModule> =
	ParserStateBase<TModule> & Record<string, any>;

/**
 * Defines the parser state base type used by this module.
 */
declare interface ParserStateBase<TModule extends NormalModule = NormalModule> {
	source: string | Buffer;
	current: NormalModule;

	/**
	 * the module being parsed
	 */
	module: TModule;
	compilation: Compilation;
	options: WebpackOptionsNormalizedWithDefaults;
}
type PartOf<R, M extends Record<number, number>, D> = number extends (R & {
	readonly __nodeType: number;
})["__nodeType"]
	? D
	: M[(R & { readonly __nodeType: number })["__nodeType"]];
declare interface PathCacheFunctions {
	/**
	 * cached join
	 */
	join: JoinCacheEntry;

	/**
	 * cached dirname
	 */
	dirname: DirnameCacheEntry;

	/**
	 * cached basename
	 */
	basename: BasenameCacheEntry;
}

/**
 * Defines the path data type used by this module.
 */
declare interface PathData {
	chunkGraph?: ChunkGraph;
	hash?: string;

	/**
	 * untruncated compilation hash, for re-encoding `[fullhash:<digest>]`
	 */
	fullHash?: string;

	/**
	 * digest `fullHash` is encoded in (defaults to `hashDigest`)
	 */
	fullHashDigest?: string;
	hashWithLength?: (length: number) => string;

	/**
	 * builds `[fullhash:<digest>]`/`[hash:<digest>]` in the runtime chunk-filename context, where it throws because a runtime `getFullHash()` expression cannot be re-encoded
	 */
	hashWithDigest?: (digest: string, length?: number) => string;
	chunk?: Chunk | ChunkPathData;
	module?: Module | ModulePathData;
	runtime?: RuntimeSpec;
	filename?: string;
	basename?: string;
	query?: string;
	contentHashType?: string;
	contentHash?: string;

	/**
	 * untruncated module/asset content hash, for re-encoding `[contenthash:<digest>]` from full entropy
	 */
	contentHashFull?: string;
	contentHashWithLength?: (length: number) => string;

	/**
	 * digest the stored hashes are encoded in (for `[hash:<digest>]`)
	 */
	hashDigest?: string;

	/**
	 * whether `optimization.realContentHash` recomputes content hashes (records an inline `[contenthash:<digest>]` so it re-encodes in that digest)
	 */
	realContentHash?: boolean;

	/**
	 * treat `[hash]` as `[fullhash]` rather than the module hash (CSS local idents)
	 */
	hashAsFullHash?: boolean;
	noChunkHash?: boolean;
	url?: string;
	local?: string;
	uniqueName?: string;
	prepareId?: (id: string | number) => string | number;
}
type PathDataChunk = PathData & { chunk: Chunk | ChunkPathData };
type PathDataModule = PathData & {
	module: Module | ModulePathData;
	chunkGraph: ChunkGraph;
};
type PathLikeFs = string | Buffer | URL;
type PathLikeResolver = string | URL | Buffer;
type PathOrFileDescriptorFs = string | number | Buffer | URL;
type PathOrFileDescriptorResolver = string | number | URL | Buffer;
type Pattern =
	| Identifier
	| MemberExpression
	| ObjectPattern
	| ArrayPattern
	| RestElement
	| AssignmentPattern;

/**
 * Configuration object for web performance recommendations.
 */
declare interface PerformanceOptions {
	/**
	 * Fallback value for the performance checks that are not set individually (has precedence over local webpack defaults). Does not apply to 'hints', 'maxAssetSize' or 'maxEntrypointSize'.
	 * @since 5.110.0
	 */
	all?: boolean;

	/**
	 * Report references in ESM output that keep webpack's runtime form, naming what stops each from being written as a literal 'import()' or 'new URL()' another bundler can follow (requires 'hints' to be enabled).
	 * @since 5.111.0
	 */
	analyzableBailouts?: boolean;

	/**
	 * Filter function to select assets that are checked.
	 */
	assetFilter?: (name: string, source: Source, assetInfo: AssetInfo) => boolean;

	/**
	 * Report chains of 'import()' calls where each chunk can only be requested once the one before it has arrived, so the levels cost round trips in series (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	asyncChunkWaterfalls?: boolean;

	/**
	 * Report 'require.context' calls with no filter, which bundle every file under a directory (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	broadContexts?: boolean;

	/**
	 * Report how much of the module graph the cache reused, and the modules that can never be reused (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	cacheEffectiveness?: boolean;

	/**
	 * Report groups of modules that import each other synchronously (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	circularDependencies?: boolean;

	/**
	 * Report chunks asked for as both prefetch and preload from the same place, where the two directives contradict each other.
	 * @since 5.110.0
	 */
	conflictingResourceHints?: boolean;

	/**
	 * Report modules emitted into more than one chunk, and the bytes the extra copies cost (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	duplicateModules?: boolean;

	/**
	 * Report packages which are included more than once, in different versions or as multiple copies of the same version (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	duplicatePackages?: boolean;

	/**
	 * Report modules whose exports cannot be read statically, which stops anything importing them from being tree-shaken (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	dynamicExports?: boolean;

	/**
	 * Report modules that call 'eval' directly, which stops minification, scope hoisting and tree shaking (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	evalUsage?: boolean;

	/**
	 * Sets the format of the hints: warnings, errors, stats-only or nothing at all.
	 */
	hints?: false | "error" | "stats" | "warning";

	/**
	 * Report the loaders, plugins and hooks that hold the main thread, timing each one's own code rather than what it waited for (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	hotspots?: boolean;

	/**
	 * Report assets inlined as data urls that are large enough for the base64 cost and the lost caching to outweigh the request they save (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	inlinedAssets?: boolean;

	/**
	 * Report a single module that makes up most of the chunk it is in (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	largeModules?: boolean;

	/**
	 * Report polyfill packages that emulate language features the target already supports natively (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	legacyJavascript?: boolean;

	/**
	 * File size limit (in bytes) when exceeded, that webpack will provide performance hints.
	 */
	maxAssetSize?: number;

	/**
	 * Total size of an entry point (in bytes).
	 */
	maxEntrypointSize?: number;

	/**
	 * Report packages that keep unused code in the bundle because their package.json does not declare 'sideEffects' (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	missingSideEffects?: boolean;

	/**
	 * Report an entry that exports a default beside named exports for a CommonJS library, where a consumer receives the namespace object (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	mixedExports?: boolean;

	/**
	 * Report conditions in 'module.rules' that hardcode a path separator, so they only match on one operating system.
	 * @since 5.110.0
	 */
	osDependentRules?: boolean;

	/**
	 * Report '/*#__PURE__*\/' annotations that sit somewhere the parser does not read them (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	pureAnnotations?: boolean;

	/**
	 * Report 'import()' calls whose module is already loaded where the call runs, so they defer nothing (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	redundantDynamicImports?: boolean;

	/**
	 * Report modules that could not be merged into their importer's scope, and why (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	scopeHoistingBailouts?: boolean;

	/**
	 * Report source maps that cost more than they give: a production 'devtool' that writes the map into the JavaScript, and modules a loader transformed without returning a map, which leaves positions pointing at the loader's output (requires 'hints' to be enabled).
	 * @since 5.111.0
	 */
	sourceMaps?: boolean;

	/**
	 * Report splits 'optimization.splitChunks' refused because 'maxInitialRequests' or 'maxAsyncRequests' was already reached (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	splitChunksCapped?: boolean;

	/**
	 * Report chunks loaded on demand that carry less than 'optimization.splitChunks.minSize' (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	tinyChunks?: boolean;

	/**
	 * Report modules that read 'this' at the top level of an ES module, where it is 'undefined' rather than the module object or the global one (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	topLevelThis?: boolean;

	/**
	 * Report initial chunks that mix 'node_modules' code with application code, so every application change re-downloads the dependencies too (requires 'hints' to be enabled).
	 * @since 5.110.0
	 */
	unsplitVendors?: boolean;

	/**
	 * Report asset files emitted for an import whose binding nothing reads, so the bytes ship for nothing (requires 'hints' to be enabled).
	 * @since 5.111.0
	 */
	unusedAssets?: boolean;

	/**
	 * Report configuration that no build used: 'resolve.alias' entries nothing matched, 'DefinePlugin' keys nothing referenced, 'externals' nothing imported, 'module.rules' that never matched, and Module Federation 'shared' keys or 'remotes' nothing imported.
	 * @since 5.111.0
	 */
	unusedConfig?: boolean;

	/**
	 * Report modules bundled although nothing uses what they export, naming the re-export or the side-effect statement that kept each one (requires 'hints' to be enabled).
	 * @since 5.111.0
	 */
	unusedModules?: boolean;
}

/**
 * One step building webpack's minifier, installing what it implements onto
 * the modules.
 */
declare interface Phase {
	name: string;
	install: (modules: MinifierModules) => void;
}
declare interface PitchLoaderDefinitionFunction<
	OptionsType = {},
	ContextAdditions = {}
> {
	(
		this: NormalModuleLoaderContext<OptionsType> &
			LoaderRunnerMutableContext<OptionsType> &
			LoaderRunnerReadonlyContext<OptionsType, LoaderData> &
			LoaderPluginLoaderContext &
			HotModuleReplacementPluginLoaderContext &
			ContextAdditions,
		remainingRequest: string,
		previousRequest: string,
		data: LoaderData
	): string | void | Buffer | Promise<string | Buffer>;
}

/**
 * Should be used only for "target === false" or
 * when you want to overwrite platform target properties
 */
declare class PlatformPlugin {
	/**
	 * Creates an instance of PlatformPlugin.
	 */
	constructor(platform: Partial<PlatformTargetProperties>);
	platform: Partial<PlatformTargetProperties>;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the platform target properties type used by this module.
 */
declare interface PlatformTargetProperties {
	/**
	 * web platform, importing of http(s) and std: is available
	 */
	web?: null | boolean;

	/**
	 * browser platform, running in a normal web browser
	 */
	browser?: null | boolean;

	/**
	 * (Web)Worker platform, running in a web/shared/service worker
	 */
	webworker?: null | boolean;

	/**
	 * node platform, require of node built-in modules is available
	 */
	node?: null | boolean;

	/**
	 * deno platform, node built-in modules (via the `node:` specifier) and web APIs are available
	 */
	deno?: null | boolean;

	/**
	 * bun platform, bun and node built-in modules are available
	 */
	bun?: null | boolean;

	/**
	 * nwjs platform, require of legacy nw.gui is available
	 */
	nwjs?: null | boolean;

	/**
	 * electron platform, require of some electron built-in modules is available
	 */
	electron?: null | boolean;

	/**
	 * universal ESM target spanning both web and node (target `"universal"` or `["web", "node"]`)
	 */
	universal?: null | boolean;
}

/**
 * A `{ line, column }` pair, as `options.locations` reports one.
 */
declare class Position {
	constructor(line: number, col: number);
	line: number;
	column: number;
	offset(n: number): Position;
}

/**
 * a position as any caller may state one
 */
declare interface PositionLike {
	line: number;
	column: number;
}
declare class PrefetchPlugin {
	/**
	 * Creates an instance of PrefetchPlugin.
	 */
	constructor(context: string, request?: string);
	context: null | string;
	request: string;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare class PrefixSource extends Source {
	constructor(prefix: string, source: string | Buffer | Source);
	getPrefix(): string;
	original(): Source;
	streamChunks(
		options: OptionsStreamChunks,
		onChunk: (
			chunk: undefined | string,
			generatedLine: number,
			generatedColumn: number,
			sourceIndex: number,
			originalLine: number,
			originalColumn: number,
			nameIndex: number
		) => void,
		onSource: (
			sourceIndex: number,
			source: null | string,
			sourceContent?: string,
			scopeBindings?: Map<string, string>
		) => void,
		onName: (nameIndex: number, name: string) => void
	): GeneratedSourceInfo;
}
declare interface PreparsedAst {
	[index: string]: any;
}
type PreprocessedAsset = Asset & {
	type: string;
	related?: PreprocessedAsset[];
};
type PrimitiveSerializableType =
	| undefined
	| null
	| string
	| number
	| bigint
	| boolean
	| Buffer
	| (() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>);

/**
 * The per-node output store handed to a language node printer as its `writer`. It
 * carries the print `options` (today just `mode`) and one map: a finished node ->
 * its printed text. A printer *returns* its text (`printNode` stores it) and reads
 * a child's with `get`, so a parent composes its own text from its children's —
 * the map is what makes that composition (and the CSS value transforms built on
 * it) possible. `take` flushes a finished top-level node into the output and drops
 * the map, so a streaming grammar never holds more than one top-level subtree.
 */
declare class PrintContext<TPath, TNode, TPrintOptions = object> {
	constructor(
		options: PrintOptions & TPrintOptions,
		printer: NodePrinter<TPath, TNode, TPrintOptions>
	);
	options: PrintOptions & TPrintOptions;
	mapWanted: boolean;

	/**
	 * Hold `text` back as the opener of a node being printed in pieces. Nothing
	 * reaches the output until {@link flushPending}, so {@link dropPending} can
	 * still take it back if the node turns out to be empty.
	 */
	pushPending(text: string): number;

	/**
	 * Rewrite a held-back opener — an opener whose text depends on what turns out
	 * to follow it can only be settled once something does.
	 */
	setPending(depth: number, text: string): void;

	/**
	 * Emit every held-back opener, outermost first — something inside the
	 * innermost one has content, so all of them do.
	 */
	flushPending(): void;

	/**
	 * Anchor the outermost held-back opener, applied when it is flushed. Openers
	 * are flushed together, so only the outermost carries one.
	 */
	anchorPending(srcOffset?: number, srcLine?: number, srcCol?: number): void;
	isPending(depth: number): boolean;

	/**
	 * Drop the innermost held-back opener — its node printed to nothing.
	 */
	dropPending(): void;

	/**
	 * Close off what has been emitted so far and return the index the next piece
	 * will take. Cutting is the point: a caller bounding a later edit by this
	 * (see {@link dropTrailing}) must not be able to reach output from before it,
	 * which a mark taken while the tail was still open would sit in the middle of.
	 */
	markCut(): number;

	/**
	 * Append a piece of a node that is being printed in pieces. Nothing takes it
	 * back, so it only extends the output.
	 */
	emitStreamed(text: string): void;

	/**
	 * Forget every node's printed text. A node printed in pieces does this once
	 * each child is emitted, so the store never holds more than one of them —
	 * which is also what keeps a recycled node id from reading as an earlier
	 * node's text.
	 */
	dropStore(): void;

	/**
	 * Drop trailing `charCode`s from the end of the output at or after `from` —
	 * the separator the piece before a terminator no longer needs. Walks back over
	 * pieces emptied by {@link retract}, so it sees what the output reads as.
	 */
	dropTrailing(from: number, charCode: number): void;

	/**
	 * Stand `text` in place of the output's end, where that is `printed` followed
	 * only by `closer`s — what the printer wrote after a value the input ran out in.
	 */
	replaceEnd(printed: string, text: string, closer: number): boolean;

	/**
	 * Run the node printer for `node` and store what it returns (the grammar calls
	 * this once the node's visitors and children are done). `path` is on `node`.
	 */
	printNode(node: TNode, path: TPath): void;

	/**
	 * Store `text` as what `node` printed, where the grammar already knows what
	 * the node printer would return and so does not call it.
	 */
	printedAs(node: TNode, text: string): void;

	/**
	 * Store that `node` printed as its source, which `sourceText` reads only once
	 * something asks for its text.
	 */
	printedSource(node: TNode, sourceText: (node: TNode) => string): void;

	/**
	 * Print one node and hand its text straight back — for a node inside one being
	 * printed in pieces, whose text is emitted as it is printed, so the store
	 * would only ever be written and read once.
	 */
	printPiece(path: TPath): string;
	get(node: TNode): string;

	/**
	 * Append `text` as a piece of its own, so {@link retract} can still take it
	 * back once a later sibling turns out to override it. Cuts the accumulating
	 * tail off in front of it, so it is for the text that may actually be taken
	 * back and not for output at large.
	 */
	emitRetractable(text: string): number;

	/**
	 * Take back an already-emitted piece — the printer has since found that a
	 * later one overrides it. Pieces after it keep their place. A piece emitted by
	 * {@link takeRetractable} takes the mapping anchored to it back as well; any
	 * other anchor into the piece would be left pointing at what follows it, so
	 * this must not be used on one (see {@link take}).
	 */
	retract(index: number): void;

	/**
	 * Whether the output after a piece holds a character outside ASCII, the
	 * comments still waiting to be placed included.
	 */
	writesNonAscii(index: number): boolean;

	/**
	 * Fold `text` into an already-emitted piece, in front of the character it ends
	 * with — a later sibling whose body belongs inside that piece, as a repeated
	 * named `@layer` block's does. Mappings are piece-relative and this only grows
	 * the piece past everything already anchored in it, so they keep their
	 * positions; the folded text carries none of its own.
	 */
	foldIntoRetractable(index: number, text: string): void;

	/**
	 * Write an already-emitted piece again, shorter — a rule inside it a later
	 * copy makes dead. Mappings anchored in the piece keep the offsets they were
	 * given, so one inside what was cut names what now follows it.
	 */
	rewriteRetractable(index: number, text: string): void;

	/**
	 * {@link rewriteRetractable} with text that is asked for only once the output
	 * is read: a piece rewritten many times over is then built once, not each time.
	 */
	deferRetractable(index: number, source: { readonly text: string }): void;

	/**
	 * {@link take} for a top-level node a later sibling may still make dead — the
	 * unprefixed twin of a vendor-prefixed rule, which can stand anywhere after
	 * it. The node is emitted as a piece of its own, with its mapping recorded
	 * against that piece, so {@link retract} takes both back.
	 */
	takeRetractable(
		node: TNode,
		srcOffset?: number,
		srcLine?: number,
		srcCol?: number,
		text?: string
	): number;

	/**
	 * Emit one finished top-level node: first any kept comments that precede it,
	 * then a source mapping anchoring its output start to `[srcLine, srcCol]`, then
	 * its text — and drop the per-node store so the next top-level node starts
	 * clean. `srcOffset` / `srcLine` / `srcCol` are the node's source position; a
	 * grammar that doesn't map positions (e.g. HTML) omits them (no comments, no
	 * mapping — the map ends up empty).
	 */
	take(
		node?: TNode,
		srcOffset?: number,
		srcLine?: number,
		srcCol?: number,
		text?: string
	): void;

	/**
	 * Tie whatever is emitted next to a source position: flush the kept comments
	 * that precede it, then record the mapping. Split out of {@link take} for a
	 * node printed in pieces, whose first piece is emitted well after the printer
	 * for it began.
	 */
	anchor(srcOffset?: number, srcLine?: number, srcCol?: number): void;

	/**
	 * Whether a kept literal is queued to land before `pos`. A printer folding two
	 * top-level nodes together asks first: the literal belongs between them, so
	 * the fold would move it past what it was written above.
	 */
	hasInsertBefore(pos: number): boolean;

	/**
	 * Emit the kept literals landing before `pos`. A printer holding a node back
	 * calls this at hold time, so what was written above it is still emitted
	 * above it — and {@link hasInsertBefore} then answers about the gap to the
	 * next node rather than the whole span since the last node taken.
	 */
	flushInsertsBefore(pos: number): void;

	/**
	 * Queue a literal to carry through to the output at source offset `pos` — a
	 * comment the printer chose to keep (e.g. a `/*!` license banner). Calls
	 * arrive in source order; each lands just before the first top-level node
	 * starting after `pos` (or at the end, via {@link result}).
	 */
	insert(pos: number, text: string): void;

	/**
	 * Take the queued inserts sitting in `[start, end)` — a printer that writes
	 * that source range out itself places them, so the writer must not flush
	 * them ahead of the next top-level node as well.
	 */
	takeInserts(start: number, end: number): string;
	sourceMap(options: SourceMapOptions, code?: string): SourceMap;

	/**
	 * Stand the text `resolve` gives back in place of every deferred write left
	 * in the output, and move the mappings that follow one in the same piece by
	 * what its text changed in length. Runs before {@link result} and
	 * {@link sourceMap}, so both read the substituted output rather than
	 * correcting for it.
	 * The marker is `NUL id NUL`. A NUL mostly cannot reach printed output on its
	 * own account — both preprocessors turn one into U+FFFD — but an RCDATA
	 * element and an attribute value keep the one they were written with, so a
	 * pair of them is read as a write only where what stands between spells an id
	 * this answers for. Anything else is the source's own text and is left alone.
	 */
	substitute(resolve: (id: number) => undefined | string, infix: string): void;

	/**
	 * Throw away everything printed and stand `text` in its place. For the one
	 * caller that can only tell its output is wrong once it has all of it.
	 */
	replaceAll(text: string): void;
	result(): string;
}

/**
 * What every language's print options carry, read by the node printer via
 * `writer.options`. Only `mode` is here: what else a printer may be told is the
 * language's own business, and a language names it by instantiating
 * {@link PrintContext} with its own type — nothing CSS reads belongs in a
 * typedef HTML also depends on.
 */
declare interface PrintOptions {
	mode: "beautify" | "minify";
}

/**
 * Defines the printed element type used by this module.
 */
declare interface PrintedElement {
	element: string;
	content?: string;
}

/**
 * Defines the problem type used by this module.
 */
declare interface Problem {
	type: ProblemType;
	path: string;
	argument: string;
	value?: string | number | boolean | RegExp;
	index?: number;
	expected?: string;
}
type ProblemType =
	| "unknown-argument"
	| "unexpected-non-array-in-path"
	| "unexpected-non-object-in-path"
	| "prototype-pollution-in-path"
	| "multiple-values-unexpected"
	| "invalid-value";
declare interface ProcessAssetsAdditionalOptions {
	additionalAssets?: boolean | ((assets: CompilationAssets) => void);
}
declare class Profiler {
	/**
	 * Creates an instance of Profiler.
	 */
	constructor(inspector: Inspector);
	session?: SessionImportInspectorClass_2;
	inspector: Inspector;
	hasSession(): boolean;
	startProfiling():
		| Promise<void>
		| Promise<
				[
					void | Partial<StopReturnType>,
					void | Partial<StopReturnType>,
					void | Partial<StopReturnType>
				]
		  >;

	/**
	 * Returns promise for the result.
	 */
	sendCommand(
		method: string,
		params?: SetSamplingIntervalParameterType
	): Promise<void | Partial<StopReturnType>>;
	destroy(): Promise<void>;

	/**
	 * Returns }>} profile result.
	 */
	stopProfiling(): Promise<{ profile: { startTime: number; endTime: number } }>;
}
declare class ProfilingPlugin {
	/**
	 * Creates an instance of ProfilingPlugin.
	 */
	constructor(options?: ProfilingPluginOptions);
	options: ProfilingPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
	static Profiler: typeof Profiler;
}
declare interface ProfilingPluginOptions {
	/**
	 * Path to the output file e.g. `path.resolve(__dirname, 'profiling/events.json')`. Defaults to `events.json`.
	 */
	outputPath?: string;
}
declare class ProgressPlugin {
	/**
	 * Creates an instance of ProgressPlugin.
	 */
	constructor(options?: ProgressPluginArgument);
	options: ProgressPluginOptions;
	profile: null | boolean;
	handler?: (percentage: number, msg: string, ...args: string[]) => void;
	modulesCount: number;
	dependenciesCount: number;
	showEntries: boolean;
	showModules: boolean;
	showDependencies: boolean;
	showActiveModules: boolean;
	percentBy: null | "entries" | "modules" | "dependencies";
	progressBar:
		false | "auto" | Required<ProgressPluginOptionsProgressBarBranch3Object>;
	estimatedTime: boolean;
	phaseTimings: boolean;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: MultiCompiler | Compiler): void;

	/**
	 * Returns a progress reporter, if any.
	 */
	static getReporter(
		compiler: Compiler
	): undefined | ((p: number, ...args: string[]) => void);
	static defaultOptions: Required<Omit<ProgressPluginOptions, "handler">>;
	static createDefaultHandler: (
		profile: undefined | null | boolean,
		logger: Logger,
		options?: DefaultHandlerOptions
	) => (percentage: number, msg: string, ...args: string[]) => void;
}
type ProgressPluginArgument =
	| ProgressPluginOptions
	| ((percentage: number, msg: string, ...args: string[]) => void);

/**
 * Options object for the ProgressPlugin.
 */
declare interface ProgressPluginOptions {
	/**
	 * Show active modules count and one active module in progress message.
	 */
	activeModules?: boolean;

	/**
	 * Show dependencies count in progress message.
	 */
	dependencies?: boolean;

	/**
	 * Minimum dependencies count to start with. For better progress calculation. Default: 10000.
	 */
	dependenciesCount?: number;

	/**
	 * Show entries count in progress message.
	 */
	entries?: boolean;

	/**
	 * Show estimated time remaining based on build progress. Default: false.
	 */
	estimatedTime?: boolean;
	handler?: (percentage: number, msg: string, ...args: string[]) => void;

	/**
	 * Show modules count in progress message.
	 */
	modules?: boolean;

	/**
	 * Minimum modules count to start with. For better progress calculation. Default: 5000.
	 */
	modulesCount?: number;

	/**
	 * Collect percent algorithm. By default it calculates by a median from modules, entries and dependencies percent.
	 */
	percentBy?: null | "entries" | "modules" | "dependencies";

	/**
	 * Show a timing breakdown for each build phase when the build completes. Default: false.
	 */
	phaseTimings?: boolean;

	/**
	 * Collect profile data for progress steps. Default: false.
	 */
	profile?: null | boolean;

	/**
	 * Generate progress bar. `"auto"` enables it only for interactive terminals. Default: false.
	 */
	progressBar?:
		boolean | "auto" | ProgressPluginOptionsProgressBarBranch3Object;
}
declare interface ProgressPluginOptionsProgressBarBranch3Object {
	/**
	 * Color used for the filled portion of the bar.
	 */
	color?: string;

	/**
	 * Name shown before the progress bar.
	 */
	name?: string;

	/**
	 * Width of the progress bar in characters. Default: 25.
	 */
	width?: number;
}
declare class ProvidePlugin {
	/**
	 * Creates an instance of ProvidePlugin.
	 */
	constructor(definitions: Record<string, string | string[]>);
	definitions: Record<string, string | string[]>;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare class ProvideSharedPlugin {
	/**
	 * Creates an instance of ProvideSharedPlugin.
	 */
	constructor(options: ProvideSharedPluginOptions);
	options: ProvideSharedPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface ProvideSharedPluginOptions {
	provides: Provides;

	/**
	 * Share scope name used for all provided modules (defaults to 'default').
	 */
	shareScope?: string;
}
type Provides = ProvidesObject | ProvidesBranch1Item[];
type ProvidesBranch1Item = string | ProvidesObject;

/**
 * Advanced configuration for modules that should be provided as shared modules to the share scope.
 */
declare interface ProvidesConfig {
	/**
	 * Include the provided module directly instead behind an async request. This allows to use this shared module in initial load too. All possible shared modules need to be eager too.
	 */
	eager?: boolean;
	exclude?: SharedModuleFilter;
	include?: SharedModuleFilter;

	/**
	 * Key in the share scope under which the shared modules should be stored.
	 */
	shareKey?: string;

	/**
	 * Share scope name.
	 */
	shareScope?: string;

	/**
	 * Version of the provided module. Will replace lower matching versions, but not higher.
	 */
	version?: string | false;
}

/**
 * Modules that should be provided as shared modules to the share scope. Property names are used as share keys.
 */
declare interface ProvidesObject {
	[index: string]: ProvidesObjectValue;
}
type ProvidesObjectValue = string | ProvidesConfig;
type PureCallView = NodeShape & {
	print_to_string(given?: Partial<any>): string;
};
type PureCondition =
	boolean | ((compilation: Compilation, module: Module) => boolean);
type QualifiedRule = NodeSyntaxParser & {
	prelude: ComponentValue[];
	declarations: null | DeclarationSyntaxParser[];
	childRules: null | RuleSyntaxParser[];
	blockStart: number;
	blockEnd: number;
};

/**
 * Describes the scheduling hints that can be attached to a chunk group.
 * These values influence how child groups are ordered for preload/prefetch
 * and how their fetch priority is exposed to runtime code.
 */
declare interface RawChunkGroupOptions {
	preloadOrder?: number;
	prefetchOrder?: number;

	/**
	 * preload only the chunk's CSS (`as="style"`), not its JS
	 */
	cssPreloadOrder?: number;
	fetchPriority?: "auto" | "low" | "high";
}
type RawDevTool = string | false;
type RawLoaderDefinition<
	OptionsType = {},
	ContextAdditions = {}
> = RawLoaderDefinitionFunction<OptionsType, ContextAdditions> & {
	raw: true;
	pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
};
declare interface RawLoaderDefinitionFunction<
	OptionsType = {},
	ContextAdditions = {}
> {
	(
		this: NormalModuleLoaderContext<OptionsType> &
			LoaderRunnerMutableContext<OptionsType> &
			LoaderRunnerReadonlyContext<OptionsType, LoaderData> &
			LoaderPluginLoaderContext &
			HotModuleReplacementPluginLoaderContext &
			ContextAdditions,
		content: Buffer,
		sourceMap?: string | RawSourceMap,
		additionalData?: AdditionalData
	): string | void | Buffer | Promise<string | Buffer>;
}
declare class RawSource extends Source {
	constructor(value: string | Buffer, convertToString?: boolean);
	isBuffer(): boolean;
	streamChunks(
		options: OptionsStreamChunks,
		onChunk: (
			chunk: undefined | string,
			generatedLine: number,
			generatedColumn: number,
			sourceIndex: number,
			originalLine: number,
			originalColumn: number,
			nameIndex: number
		) => void,
		onSource: (
			sourceIndex: number,
			source: null | string,
			sourceContent?: string,
			scopeBindings?: Map<string, string>
		) => void,
		onName: (nameIndex: number, name: string) => void
	): GeneratedSourceInfo;
}
declare interface RawSourceMap {
	/**
	 * version
	 */
	version: number;

	/**
	 * sources
	 */
	sources: string[];

	/**
	 * names
	 */
	names: string[];

	/**
	 * source root
	 */
	sourceRoot?: string;

	/**
	 * sources content
	 */
	sourcesContent?: string[];

	/**
	 * mappings
	 */
	mappings: string;

	/**
	 * file
	 */
	file: string;

	/**
	 * debug id
	 */
	debugId?: string;

	/**
	 * ignore list
	 */
	ignoreList?: number[];

	/**
	 * encoded `scopes` field of the "Scopes" proposal
	 */
	scopes?: string;
}

/**
 * Defines the shared type used by this module.
 */
declare interface Read<
	TBuffer extends NodeJS.ArrayBufferView = NodeJS.ArrayBufferView
> {
	(
		fd: number,
		buffer: TBuffer,
		offset: number,
		length: number,
		position: null | number | bigint,
		callback: (
			err: null | NodeJS.ErrnoException,
			bytesRead: number,
			buffer: TBuffer
		) => void
	): void;
	(
		fd: number,
		options: ReadAsyncOptions<TBuffer>,
		callback: (
			err: null | NodeJS.ErrnoException,
			bytesRead: number,
			buffer: TBuffer
		) => void
	): void;
	(
		fd: number,
		callback: (
			err: null | NodeJS.ErrnoException,
			bytesRead: number,
			buffer: NodeJS.ArrayBufferView
		) => void
	): void;
}

/**
 * Defines the read async options type used by this module.
 */
declare interface ReadAsyncOptions<TBuffer extends NodeJS.ArrayBufferView> {
	offset?: number;
	length?: number;
	position?: null | number | bigint;
	buffer?: TBuffer;
}
declare class ReadFileCompileAsyncWasmPlugin {
	/**
	 * Creates an instance of ReadFileCompileAsyncWasmPlugin.
	 */
	constructor(__0?: ReadFileCompileAsyncWasmPluginOptions);

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the read file compile async wasm plugin options type used by this module.
 */
declare interface ReadFileCompileAsyncWasmPluginOptions {
	/**
	 * use import?
	 */
	import?: boolean;
}
declare class ReadFileCompileWasmPlugin {
	/**
	 * Creates an instance of ReadFileCompileWasmPlugin.
	 */
	constructor(options?: ReadFileCompileWasmPluginOptions);
	options: ReadFileCompileWasmPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Defines the read file compile wasm plugin options type used by this module.
 */
declare interface ReadFileCompileWasmPluginOptions {
	/**
	 * mangle imports
	 */
	mangleImports?: boolean;

	/**
	 * use import?
	 */
	import?: boolean;
}

/**
 * Describes the read file shape.
 */
declare interface ReadFileFs {
	(
		path: PathOrFileDescriptorFs,
		options:
			undefined | null | ({ encoding?: null; flag?: string } & Abortable),
		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
	): void;
	(
		path: PathOrFileDescriptorFs,
		options:
			| ({ encoding: BufferEncoding; flag?: string } & Abortable)
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex",
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
	(
		path: PathOrFileDescriptorFs,
		options:
			| undefined
			| null
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| (ObjectEncodingOptionsFs & { flag?: string } & Abortable),
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: string | Buffer
		) => void
	): void;
	(
		path: PathOrFileDescriptorFs,
		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
	): void;
}
declare interface ReadFileResolver {
	(
		path: PathOrFileDescriptorResolver,
		options:
			undefined | null | ({ encoding?: null; flag?: string } & Abortable),
		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
	): void;
	(
		path: PathOrFileDescriptorResolver,
		options:
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| ({ encoding: BufferEncoding; flag?: string } & Abortable),
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
	(
		path: PathOrFileDescriptorResolver,
		options:
			| undefined
			| null
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| (ObjectEncodingOptionsResolver & { flag?: string } & Abortable),
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: string | Buffer
		) => void
	): void;
	(
		path: PathOrFileDescriptorResolver,
		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
	): void;
}

/**
 * Describes the read file sync shape.
 */
declare interface ReadFileSync {
	(
		path: PathOrFileDescriptorFs,
		options?: null | { encoding?: null; flag?: string }
	): Buffer;
	(
		path: PathOrFileDescriptorFs,
		options:
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| { encoding: BufferEncoding; flag?: string }
	): string;
	(
		path: PathOrFileDescriptorFs,
		options: ObjectEncodingOptionsFs & { flag?: string }
	): string | Buffer;
}
type ReadStreamOptions = StreamOptions & {
	fs?: null | CreateReadStreamFSImplementation;
	end?: number;
};

/**
 * Describes the readdir shape.
 */
declare interface ReaddirFs {
	(
		path: PathLikeFs,
		options:
			| undefined
			| null
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| {
					encoding:
						| null
						| "ascii"
						| "utf8"
						| "utf-8"
						| "utf16le"
						| "utf-16le"
						| "ucs2"
						| "ucs-2"
						| "base64"
						| "base64url"
						| "latin1"
						| "binary"
						| "hex";
					withFileTypes?: false;
					recursive?: boolean;
			  },
		callback: (err: null | NodeJS.ErrnoException, files?: string[]) => void
	): void;
	(
		path: PathLikeFs,
		options:
			| "buffer"
			| { encoding: "buffer"; withFileTypes?: false; recursive?: boolean },
		callback: (err: null | NodeJS.ErrnoException, files?: Buffer[]) => void
	): void;
	(
		path: PathLikeFs,
		options:
			| undefined
			| null
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| (ObjectEncodingOptionsFs & {
					withFileTypes?: false;
					recursive?: boolean;
			  }),
		callback: (
			err: null | NodeJS.ErrnoException,
			files?: string[] | Buffer[]
		) => void
	): void;
	(
		path: PathLikeFs,
		callback: (err: null | NodeJS.ErrnoException, files?: string[]) => void
	): void;
	(
		path: PathLikeFs,
		options: ObjectEncodingOptionsFs & {
			withFileTypes: true;
			recursive?: boolean;
		},
		callback: (
			err: null | NodeJS.ErrnoException,
			files?: DirentFs<string>[]
		) => void
	): void;
	(
		path: PathLikeFs,
		options: { encoding: "buffer"; withFileTypes: true; recursive?: boolean },
		callback: (
			err: null | NodeJS.ErrnoException,
			files: DirentFs<Buffer>[]
		) => void
	): void;
}
declare interface ReaddirResolver {
	(
		path: PathLikeResolver,
		options:
			| undefined
			| null
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| {
					encoding:
						| null
						| "ascii"
						| "utf8"
						| "utf-8"
						| "utf16le"
						| "utf-16le"
						| "ucs2"
						| "ucs-2"
						| "base64"
						| "base64url"
						| "latin1"
						| "binary"
						| "hex";
					withFileTypes?: false;
					recursive?: boolean;
			  },
		callback: (err: null | NodeJS.ErrnoException, files?: string[]) => void
	): void;
	(
		path: PathLikeResolver,
		options:
			| "buffer"
			| { encoding: "buffer"; withFileTypes?: false; recursive?: boolean },
		callback: (err: null | NodeJS.ErrnoException, files?: Buffer[]) => void
	): void;
	(
		path: PathLikeResolver,
		options:
			| undefined
			| null
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| (ObjectEncodingOptionsResolver & {
					withFileTypes?: false;
					recursive?: boolean;
			  }),
		callback: (
			err: null | NodeJS.ErrnoException,
			files?: string[] | Buffer[]
		) => void
	): void;
	(
		path: PathLikeResolver,
		callback: (err: null | NodeJS.ErrnoException, files?: string[]) => void
	): void;
	(
		path: PathLikeResolver,
		options: ObjectEncodingOptionsResolver & {
			withFileTypes: true;
			recursive?: boolean;
		},
		callback: (
			err: null | NodeJS.ErrnoException,
			files?: DirentResolver<string>[]
		) => void
	): void;
	(
		path: PathLikeResolver,
		options: { encoding: "buffer"; withFileTypes: true; recursive?: boolean },
		callback: (
			err: null | NodeJS.ErrnoException,
			files: DirentResolver<Buffer>[]
		) => void
	): void;
}

/**
 * Describes the readdir sync shape.
 */
declare interface ReaddirSync {
	(
		path: PathLikeFs,
		options?:
			| null
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| {
					encoding:
						| null
						| "ascii"
						| "utf8"
						| "utf-8"
						| "utf16le"
						| "utf-16le"
						| "ucs2"
						| "ucs-2"
						| "base64"
						| "base64url"
						| "latin1"
						| "binary"
						| "hex";
					withFileTypes?: false;
					recursive?: boolean;
			  }
	): string[];
	(
		path: PathLikeFs,
		options:
			| "buffer"
			| { encoding: "buffer"; withFileTypes?: false; recursive?: boolean }
	): Buffer[];
	(
		path: PathLikeFs,
		options?:
			| null
			| "ascii"
			| "utf8"
			| "utf-8"
			| "utf16le"
			| "utf-16le"
			| "ucs2"
			| "ucs-2"
			| "base64"
			| "base64url"
			| "latin1"
			| "binary"
			| "hex"
			| (ObjectEncodingOptionsFs & {
					withFileTypes?: false;
					recursive?: boolean;
			  })
	): string[] | Buffer[];
	(
		path: PathLikeFs,
		options: ObjectEncodingOptionsFs & {
			withFileTypes: true;
			recursive?: boolean;
		}
	): DirentFs<string>[];
	(
		path: PathLikeFs,
		options: { encoding: "buffer"; withFileTypes: true; recursive?: boolean }
	): DirentFs<Buffer>[];
}

/**
 * Describes the readlink shape.
 */
declare interface ReadlinkFs {
	(
		path: PathLikeFs,
		options: EncodingOptionFs,
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
	(
		path: PathLikeFs,
		options: BufferEncodingOption,
		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
	): void;
	(
		path: PathLikeFs,
		options: EncodingOptionFs,
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: string | Buffer
		) => void
	): void;
	(
		path: PathLikeFs,
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
}
declare interface ReadlinkResolver {
	(
		path: PathLikeResolver,
		options: EncodingOptionResolver,
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
	(
		path: PathLikeResolver,
		options: BufferEncodingOption,
		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
	): void;
	(
		path: PathLikeResolver,
		options: EncodingOptionResolver,
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: string | Buffer
		) => void
	): void;
	(
		path: PathLikeResolver,
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
}

/**
 * Describes the readlink sync shape.
 */
declare interface ReadlinkSync {
	(path: PathLikeFs, options?: EncodingOptionFs): string;
	(path: PathLikeFs, options: BufferEncodingOption): Buffer;
	(path: PathLikeFs, options?: EncodingOptionFs): string | Buffer;
}
declare class RealContentHashPlugin {
	/**
	 * Creates an instance of RealContentHashPlugin.
	 */
	constructor(__0: RealContentHashPluginOptions);

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
	static getCompilationHooks: (compilation: Compilation) => {
		/**
		 * @since 5.8.0
		 */
		updateHash: SyncBailHook<[Buffer[], string], string | void>;
	};
}

/**
 * Defines the real content hash plugin options type used by this module.
 */
declare interface RealContentHashPluginOptions {
	/**
	 * the hash function to use
	 */
	hashFunction: HashFunction;

	/**
	 * the hash digest to use
	 */
	hashDigest: string;

	/**
	 * run only where analyzable output marked a name for repair
	 */
	onDemand?: boolean;
}

/**
 * Defines the real dependency location type used by this module.
 */
declare interface RealDependencyLocation {
	start: SourcePosition;
	end?: SourcePosition;
	index?: number;
}

/**
 * Describes the real path shape.
 */
declare interface RealPathFs {
	(
		path: PathLikeFs,
		options: EncodingOptionFs,
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
	(
		path: PathLikeFs,
		options: BufferEncodingOption,
		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
	): void;
	(
		path: PathLikeFs,
		options: EncodingOptionFs,
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: string | Buffer
		) => void
	): void;
	(
		path: PathLikeFs,
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
}
declare interface RealPathResolver {
	(
		path: PathLikeResolver,
		options: EncodingOptionResolver,
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
	(
		path: PathLikeResolver,
		options: BufferEncodingOption,
		callback: (err: null | NodeJS.ErrnoException, result?: Buffer) => void
	): void;
	(
		path: PathLikeResolver,
		options: EncodingOptionResolver,
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: string | Buffer
		) => void
	): void;
	(
		path: PathLikeResolver,
		callback: (err: null | NodeJS.ErrnoException, result?: string) => void
	): void;
}

/**
 * Describes the real path sync shape.
 */
declare interface RealPathSync {
	(path: PathLikeFs, options?: EncodingOptionFs): string;
	(path: PathLikeFs, options: BufferEncodingOption): Buffer;
	(path: PathLikeFs, options?: EncodingOptionFs): string | Buffer;
}
type Records = KnownRecords &
	Record<string, KnownRecords[]> &
	Record<string, any>;

/**
 * Defines the records chunks type used by this module.
 */
declare interface RecordsChunks {
	byName?: Record<string, number>;
	bySource?: Record<string, number>;
	usedIds?: number[];
}

/**
 * Defines the records modules type used by this module.
 */
declare interface RecordsModules {
	byIdentifier?: Record<string, number>;
	usedIds?: number[];
}
type RecursiveArrayOrRecord<T> =
	| { [index: string]: RecursiveArrayOrRecord<T> }
	| RecursiveArrayOrRecord<T>[]
	| T;

/**
 * Defines the recursive non nullable type used by this module.
 */
declare interface RecursiveNonNullable<T> {}

/**
 * One identifier occurrence that refers to a binding.
 */
declare abstract class Reference {
	identifier: Identifier;
	from: Scope;
	resolved?: Variable;
}
type ReferenceableItem = string | object;

/**
 * Defines the referenced export type used by this module.
 */
declare interface ReferencedExport {
	/**
	 * name of the referenced export
	 */
	name: string[];

	/**
	 * when false, referenced export can not be mangled, defaults to true
	 */
	canMangle?: boolean;

	/**
	 * when false, the referenced export can not be substituted with an inlined literal at this site, defaults to true
	 */
	canInline?: boolean;
}

/**
 * The cursor a regexp literal is validated through.
 */
declare abstract class RegExpValidationState {
	parser: SyntaxParser;
	validFlags: string;
	unicodeProperties: UnicodePropertyTables;
	source: string;
	flags: string;
	start: number;
	switchU: boolean;
	switchV: boolean;
	switchN: boolean;
	pos: number;
	lastIntValue: number;
	lastStringValue: string;
	lastAssertionIsQuantifiable: boolean;
	numCapturingParens: number;
	maxBackReference: number;
	groupNames: GroupNames;
	backReferenceNames: string[];
	branchID: null | BranchID;
	reset(start: number, pattern: string, flags: string): void;
	raise(message: string): void;

	/**
	 * The code point at an index, joining a surrogate pair where the `u` flag
	 * asks for code points rather than units.
	 */
	at(i: number, forceU?: boolean): number;
	nextIndex(i: number, forceU?: boolean): number;
	current(forceU?: boolean): number;
	lookahead(forceU?: boolean): number;
	advance(forceU?: boolean): void;
	eat(ch: number, forceU?: boolean): boolean;
	eatChars(chs: number[], forceU?: boolean): boolean;
}
type Remotes = RemotesObject | RemotesBranch1Item[];
type RemotesBranch1Item = string | RemotesObject;

/**
 * Advanced configuration for container locations from which modules should be resolved and loaded at runtime.
 */
declare interface RemotesConfig {
	/**
	 * Container locations from which modules should be resolved and loaded at runtime.
	 */
	external: string | string[];

	/**
	 * The name of the share scope shared with this remote.
	 */
	shareScope?: string;
}

/**
 * Container locations from which modules should be resolved and loaded at runtime. Property names are used as request scopes.
 */
declare interface RemotesObject {
	[index: string]: RemotesObjectValue;
}
type RemotesObjectValue = string | RemotesConfig | string[];

/**
 * Defines the render bootstrap context type used by this module.
 */
declare interface RenderBootstrapContext {
	/**
	 * the chunk
	 */
	chunk: Chunk;

	/**
	 * results of code generation
	 */
	codeGenerationResults: CodeGenerationResults;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * hash to be used for render call
	 */
	hash: string;
}

/**
 * Defines the render context type used by this module.
 */
declare interface RenderContextCssModulesPlugin {
	/**
	 * the chunk
	 */
	chunk: Chunk;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * results of code generation
	 */
	codeGenerationResults: CodeGenerationResults;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the unique name
	 */
	uniqueName: string;

	/**
	 * undo path to css file
	 */
	undoPath: string;

	/**
	 * compilation hash
	 */
	hash?: string;

	/**
	 * modules
	 */
	modules: CssModule[];
}

/**
 * Defines the render context type used by this module.
 */
declare interface RenderContextJavascriptModulesPlugin {
	/**
	 * the chunk
	 */
	chunk: Chunk;

	/**
	 * the dependency templates
	 */
	dependencyTemplates: DependencyTemplates;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * results of code generation
	 */
	codeGenerationResults: CodeGenerationResults;

	/**
	 * rendering in strict context
	 */
	strictMode?: boolean;
}
type RenderManifestEntry =
	RenderManifestEntryTemplated | RenderManifestEntryStatic;

/**
 * Defines the render manifest entry static type used by this module.
 */
declare interface RenderManifestEntryStatic {
	render: () => Source;
	filename: string;
	info: AssetInfo;
	identifier: string;
	hash?: string;
	auxiliary?: boolean;
}

/**
 * Defines the render manifest entry templated type used by this module.
 */
declare interface RenderManifestEntryTemplated {
	render: () => Source;
	filenameTemplate: string | TemplatePathFn<any>;
	pathOptions?: PathData;
	info?: AssetInfo;
	identifier: string;
	hash?: string;
	auxiliary?: boolean;
}

/**
 * Defines the render manifest options type used by this module.
 */
declare interface RenderManifestOptions {
	/**
	 * the chunk used to render
	 */
	chunk: Chunk;
	hash: string;
	fullHash: string;
	outputOptions: OutputNormalizedWithDefaults;
	codeGenerationResults: CodeGenerationResults;
	moduleTemplates: { javascript: ModuleTemplate };
	dependencyTemplates: DependencyTemplates;
	runtimeTemplate: RuntimeTemplate;
	moduleGraph: ModuleGraph;
	chunkGraph: ChunkGraph;
}
declare class ReplaceSource extends Source {
	constructor(source: Source, name?: string);
	getName(): undefined | string;
	getReplacements(): Replacement[];
	replace(start: number, end: number, newValue: string, name?: string): void;
	insert(pos: number, newValue: string, name?: string): void;
	original(): Source;
	streamChunks(
		options: OptionsStreamChunks,
		onChunk: (
			chunk: undefined | string,
			generatedLine: number,
			generatedColumn: number,
			sourceIndex: number,
			originalLine: number,
			originalColumn: number,
			nameIndex: number
		) => void,
		onSource: (
			sourceIndex: number,
			source: null | string,
			sourceContent?: string,
			scopeBindings?: Map<string, string>
		) => void,
		onName: (nameIndex: number, name: string) => void
	): GeneratedSourceInfo;
	static Replacement: typeof Replacement;
}
declare class Replacement {
	constructor(start: number, end: number, content: string, name?: string);
	start: number;
	end: number;
	content: string;
	name?: string;
	index?: number;
}
declare interface RequestRecord {
	[index: string]: string | string[];
}

/**
 * Shortens absolute or verbose request strings so diagnostics and stats output
 * can be rendered relative to a chosen base directory.
 */
declare class RequestShortener {
	/**
	 * Binds a context-aware shortening function to the provided directory and
	 * optional cache owner.
	 */
	constructor(dir: string, associatedObjectForCache?: object);
	contextify: (value: string) => string;

	/**
	 * Returns a request string rewritten relative to the configured directory
	 * when one is provided.
	 */
	shorten(request?: null | string): undefined | null | string;
}

/**
 * Defines the resolve build dependencies result type used by this module.
 */
declare interface ResolveBuildDependenciesResult {
	/**
	 * list of files
	 */
	files: Set<string>;

	/**
	 * list of directories
	 */
	directories: Set<string>;

	/**
	 * list of missing entries
	 */
	missing: Set<string>;

	/**
	 * stored resolve results
	 */
	resolveResults: Map<string, undefined | string | false>;

	/**
	 * dependencies of the resolving
	 */
	resolveDependencies: ResolveDependencies;
}

/**
 * Resolve context
 */
declare interface ResolveContext {
	/**
	 * directories that was found on file system
	 */
	contextDependencies?: WriteOnlySet<string>;

	/**
	 * files that was found on file system
	 */
	fileDependencies?: WriteOnlySet<string>;

	/**
	 * dependencies that was not found on file system
	 */
	missingDependencies?: WriteOnlySet<string>;

	/**
	 * tip of the resolver call stack (a singly-linked list with Set-like API). For instance, `resolve → parsedResolve → describedResolve`. Accepts a legacy `Set<string>` for back-compat with older callers; it is normalized internally without a hot-path branch.
	 */
	stack?: Set<string> | StackEntry;

	/**
	 * log function
	 */
	log?: (str: string) => void;

	/**
	 * yield result, if provided plugins can return several results
	 */
	yield?: (request: ResolveRequest) => void;
}

/**
 * Defines the resolve data type used by this module.
 */
declare interface ResolveData {
	contextInfo: ModuleFactoryCreateDataContextInfo;
	resolveOptions?: ResolveOptionsWebpackOptions;
	context: string;
	request: string;
	phase?: "defer" | "source" | "evaluation";
	attributes?: ImportAttributes;
	dependencies: ModuleDependency[];
	dependencyType: string;
	createData: Partial<CreateData>;
	fileDependencies: LazySet<string>;
	missingDependencies: LazySet<string>;
	contextDependencies: LazySet<string>;
	ignoredModule?: Module;

	/**
	 * allow to use the unsafe cache
	 */
	cacheable: boolean;
}

/**
 * Defines the resolve dependencies type used by this module.
 */
declare interface ResolveDependencies {
	/**
	 * list of files
	 */
	files: Set<string>;

	/**
	 * list of directories
	 */
	directories: Set<string>;

	/**
	 * list of missing entries
	 */
	missing: Set<string>;
}

/**
 * Options object for resolving requests.
 */
declare interface ResolveOptionsWebpackOptions {
	/**
	 * Redirect module requests.
	 */
	alias?:
		| {
				/**
				 * New request.
				 */
				alias: string | false | string[];
				/**
				 * Request to be redirected.
				 */
				name: string;
				/**
				 * Redirect only exact matching request.
				 */
				onlyModule?: boolean;
		  }[]
		| { [index: string]: string | false | string[] };

	/**
	 * Fields in the description file (usually package.json) which are used to redirect requests inside the module.
	 */
	aliasFields?: (string | string[])[];

	/**
	 * Extra resolve options per dependency category. Typical categories are "commonjs", "amd", "esm".
	 */
	byDependency?: { [index: string]: ResolveOptionsWebpackOptions };

	/**
	 * Enable caching of successfully resolved requests (cache entries are revalidated).
	 */
	cache?: boolean;

	/**
	 * Predicate function to decide which requests should be cached.
	 */
	cachePredicate?: (request: ResolveRequest) => boolean;

	/**
	 * Include the context information in the cache identifier when caching.
	 */
	cacheWithContext?: boolean;

	/**
	 * Condition names for exports field entry point.
	 */
	conditionNames?: string[];

	/**
	 * Filenames used to find a description file (like a package.json).
	 */
	descriptionFiles?: string[];

	/**
	 * Enforce the resolver to use one of the extensions from the extensions option (User must specify requests without extension).
	 */
	enforceExtension?: boolean;

	/**
	 * Field names from the description file (usually package.json) which are used to provide entry points of a package.
	 */
	exportsFields?: string[];

	/**
	 * An object which maps extension to extension aliases.
	 */
	extensionAlias?: { [index: string]: string | string[] };

	/**
	 * Extensions added to the request when trying to find the file.
	 */
	extensions?: string[];

	/**
	 * Redirect module requests when normal resolving fails.
	 */
	fallback?:
		| {
				/**
				 * New request.
				 */
				alias: string | false | string[];
				/**
				 * Request to be redirected.
				 */
				name: string;
				/**
				 * Redirect only exact matching request.
				 */
				onlyModule?: boolean;
		  }[]
		| { [index: string]: string | false | string[] };

	/**
	 * Filesystem for the resolver.
	 */
	fileSystem?: InputFileSystem;

	/**
	 * Treats the request specified by the user as fully specified, meaning no extensions are added and the mainFiles in directories are not resolved (This doesn't affect requests from mainFields, aliasFields or aliases).
	 */
	fullySpecified?: boolean;

	/**
	 * Field names from the description file (usually package.json) which are used to provide internal request of a package (requests starting with # are considered as internal).
	 */
	importsFields?: string[];

	/**
	 * Field names from the description file (package.json) which are used to find the default entry point.
	 */
	mainFields?: (string | string[])[];

	/**
	 * Filenames used to find the default entry point if there is no description file or main field.
	 */
	mainFiles?: string[];

	/**
	 * Folder names or directory paths where to find modules.
	 */
	modules?: string[];

	/**
	 * Plugins for the resolver.
	 */
	plugins?: (
		| undefined
		| null
		| false
		| ""
		| 0
		| {
				[index: string]: any;
				/**
				 * The run point of the plugin, required method.
				 */
				apply: (arg0: Resolver) => void;
		  }
		| ((this: Resolver, arg1: Resolver) => void)
		| "..."
	)[];

	/**
	 * Prefer to resolve server-relative URLs (starting with '/') as absolute paths before falling back to resolve in 'resolve.roots'.
	 */
	preferAbsolute?: boolean;

	/**
	 * Prefer to resolve module requests as relative request and fallback to resolving as module.
	 */
	preferRelative?: boolean;

	/**
	 * Custom resolver.
	 */
	resolver?: Resolver;

	/**
	 * A list of resolve restrictions. Resolve results must fulfill all of these restrictions to resolve successfully. Other resolve paths are taken when restrictions are not met.
	 */
	restrictions?: (string | RegExp)[];

	/**
	 * A list of directories in which requests that are server-relative URLs (starting with '/') are resolved.
	 */
	roots?: string[];

	/**
	 * Enable resolving symlinks to the original location.
	 */
	symlinks?: boolean;

	/**
	 * TypeScript config for paths mapping. Can be `false` (disabled), `true` (use default `tsconfig.json`), a string path to `tsconfig.json`, or an object with `configFile` and `references` options.
	 */
	tsconfig?:
		| string
		| boolean
		| {
				/**
				 * A path to the tsconfig file.
				 */
				configFile?: string;
				/**
				 * References to other tsconfig files. 'auto' inherits from TypeScript config, or an array of relative/absolute paths.
				 */
				references?: string;
		  };

	/**
	 * Enable caching of successfully resolved requests (cache entries are not revalidated).
	 */
	unsafeCache?: boolean | { [index: string]: any };

	/**
	 * Use synchronous filesystem calls for the resolver.
	 */
	useSyncFileSystemCalls?: boolean;
}
type ResolveOptionsWithDependencyType = ResolveOptionsWebpackOptions & {
	dependencyType?: string;
	resolveToContext?: boolean;
};
type ResolvePluginInstance =
	| {
			[index: string]: any;
			/**
			 * The run point of the plugin, required method.
			 */
			apply: (arg0: Resolver) => void;
	  }
	| ((this: Resolver, arg1: Resolver) => void);
type ResolveRequest = BaseResolveRequest & Partial<ParsedIdentifier>;

/**
 * Defines the resolved context file system info entry type used by this module.
 */
declare interface ResolvedContextFileSystemInfoEntry {
	safeTime: number;
	timestampHash?: string;
}

/**
 * Defines the resolved context timestamp and hash type used by this module.
 */
declare interface ResolvedContextTimestampAndHash {
	safeTime: number;
	timestampHash?: string;
	hash: string;
}

/**
 * Defines the resolved options type used by this module.
 */
declare interface ResolvedOptionsDefaults {
	/**
	 * - platform target properties
	 */
	platform: false | PlatformTargetProperties;
}

/**
 * the options once every default is filled in and every alternative spelling is normalized
 */
declare interface ResolvedOptionsSyntaxParser {
	/**
	 * the edition, as the number the parser compares against
	 */
	ecmaVersion: number;

	/**
	 * the goal symbol
	 */
	sourceType: "module" | "commonjs" | "script";

	/**
	 * whether the code is strict whatever it says
	 */
	strict: boolean;

	/**
	 * called where a semicolon was inserted
	 */
	onInsertedSemicolon:
		null | ((lastTokEnd: number, lastTokEndLoc?: null | Position) => void);

	/**
	 * called at a trailing comma
	 */
	onTrailingComma:
		null | ((lastTokEnd: number, lastTokEndLoc?: null | Position) => void);

	/**
	 * whether reserved words may name things
	 */
	allowReserved: boolean | "never";

	/**
	 * whether `return` may sit at the top level
	 */
	allowReturnOutsideFunction: boolean;

	/**
	 * whether module syntax may sit anywhere
	 */
	allowImportExportEverywhere: boolean;

	/**
	 * whether `await` may sit outside a function
	 */
	allowAwaitOutsideFunction: boolean;

	/**
	 * whether `super` may sit outside a method
	 */
	allowSuperOutsideMethod: boolean;

	/**
	 * whether a leading `#!` line is skipped
	 */
	allowHashBang: boolean;

	/**
	 * whether private names must be declared
	 */
	checkPrivateFields: boolean;

	/**
	 * whether nodes carry `loc`
	 */
	locations: boolean;

	/**
	 * where the first offset falls
	 */
	startLocation: null | { line: number; column: number };

	/**
	 * where tokens are reported
	 */
	onToken: null | ((token: TokenSyntaxParserClass) => void);

	/**
	 * the parser itself at each token
	 */
	onTokenRead: null | ((parser: SyntaxParser) => void);

	/**
	 * where comments are reported
	 */
	onComment:
		| null
		| ((
				isBlock: boolean,
				text: string,
				start: number,
				end: number,
				startLoc?: null | Position,
				endLoc?: null | Position
		  ) => void);

	/**
	 * whether nodes carry `range`
	 */
	ranges: boolean;

	/**
	 * a program node to append to
	 */
	program: null | NodeLike;

	/**
	 * the name errors and locations carry
	 */
	sourceFile: null | string;

	/**
	 * the name every node carries
	 */
	directSourceFile: null | string;

	/**
	 * whether parentheses become nodes
	 */
	preserveParens: boolean;
}
declare abstract class Resolver {
	fileSystem: FileSystem;
	options: ResolveOptionsImport;
	pathCache: PathCacheFunctions;
	hooks: KnownHooks;
	ensureHook(
		name:
			| string
			| AsyncSeriesBailHook<
					[ResolveRequest, ResolveContext],
					null | ResolveRequest
			  >
	): AsyncSeriesBailHook<
		[ResolveRequest, ResolveContext],
		null | ResolveRequest
	>;
	getHook(
		name:
			| string
			| AsyncSeriesBailHook<
					[ResolveRequest, ResolveContext],
					null | ResolveRequest
			  >
	): AsyncSeriesBailHook<
		[ResolveRequest, ResolveContext],
		null | ResolveRequest
	>;
	resolveSync(
		parent: string | URL,
		specifier: string | URL,
		resolveContext?: ResolveContext
	): string | false;
	resolveSync(
		context: ContextResolver,
		parent: string | URL,
		specifier: string | URL,
		resolveContext?: ResolveContext
	): string | false;
	resolvePromise(
		parent: string | URL,
		specifier: string | URL,
		resolveContext?: ResolveContext
	): Promise<string | false>;
	resolvePromise(
		context: ContextResolver,
		parent: string | URL,
		specifier: string | URL,
		resolveContext?: ResolveContext
	): Promise<string | false>;
	resolve(
		parent: string | URL,
		specifier: string | URL,
		callback: (
			err: null | ErrorWithDetail,
			res?: string | false,
			req?: ResolveRequest
		) => void
	): void;
	resolve(
		parent: string | URL,
		specifier: string | URL,
		resolveContext: ResolveContext,
		callback: (
			err: null | ErrorWithDetail,
			res?: string | false,
			req?: ResolveRequest
		) => void
	): void;
	resolve(
		context: ContextResolver,
		parent: string | URL,
		specifier: string | URL,
		callback: (
			err: null | ErrorWithDetail,
			res?: string | false,
			req?: ResolveRequest
		) => void
	): void;
	resolve(
		context: ContextResolver,
		parent: string | URL,
		specifier: string | URL,
		resolveContext: ResolveContext,
		callback: (
			err: null | ErrorWithDetail,
			res?: string | false,
			req?: ResolveRequest
		) => void
	): void;
	doResolve(
		hook: AsyncSeriesBailHook<
			[ResolveRequest, ResolveContext],
			null | ResolveRequest
		>,
		request: ResolveRequest,
		message: null | string,
		resolveContext: ResolveContext,
		callback: (err?: null | Error, result?: ResolveRequest) => void
	): void;
	parse(identifier: string): ParsedIdentifier;
	isModule(path: string): boolean;
	isPrivate(path: string): boolean;
	isDirectory(path: string): boolean;
	normalize(path: string): string;
	join(path: string, request: string): string;
	dirname(path: string): string;
	basename(path: string, suffix?: string): string;
}

/**
 * Represents the resolver factory runtime component.
 */
declare interface ResolverCache {
	direct: WeakMap<ResolveOptionsWithDependencyType, ResolverWithOptions>;
	stringified: Map<string, ResolverWithOptions>;
}
declare abstract class ResolverFactory {
	hooks: Readonly<{
		resolveOptions: HookMap<
			SyncWaterfallHook<
				[ResolveOptionsWithDependencyType],
				ResolveOptionsWithDependencyType
			>
		>;
		resolver: HookMap<
			SyncHook<[Resolver, UserResolveOptions, ResolveOptionsWithDependencyType]>
		>;
	}>;
	cache: Map<string, ResolverCache>;

	/**
	 * Returns the resolver.
	 */
	get(
		type: string,
		resolveOptions?: ResolveOptionsWithDependencyType
	): ResolverWithOptions;
}
type ResolverWithOptions = Resolver & WithOptions;

/**
 * Defines the resource data type used by this module.
 */
declare interface ResourceDataWithData {
	resource: string;
	path?: string;
	query?: string;
	fragment?: string;
	context?: string;
	data: ResourceSchemeData & Partial<ResolveRequest>;
}

/**
 * Full resource-hint configuration.
 * @since 5.109.0
 */
declare interface ResourceHintsOptions {
	/**
	 * Skip the runtime-injected `<link rel="prefetch">` for a chunk that is already preloaded or prefetched in the document (avoids a duplicate request in some browsers such as Chrome).
	 */
	dedupe?: boolean;

	/**
	 * Initial dependency-graph chunk hints. `true` auto-emits `<link rel="modulepreload">` (ESM output) or `<link rel="preload" as="script">` (classic) for each of the entry's initial dependency chunks; `"prefetch"` uses `<link rel="prefetch">`; `"preload"` is an alias of `true`; `false` disables chunk hints (URL-asset hints from magic comments / `urlHints` still fire); `"none"` is a hard off switch (no `<link>` anywhere, empty stats / manifest); an array of `HtmlResourceHint` descriptors replaces the auto set; a function receives the auto `defaultHints` plus context (`entryName`, `entrypoint`, `hostType: "html" | "js"`, `compilation`) and returns the final list (replaces the removed `resolveDependencies` hook).
	 * @since 5.109.0
	 */
	initial?:
		| boolean
		| "none"
		| HtmlResourceHintWebpackOptions[]
		| "prefetch"
		| "preload"
		| ((context: {
				entryName: string;
				entrypoint: Entrypoint;
				hostType: "html" | "js";
				compilation: Compilation;
				defaultHints: (HtmlResourceHintHtmlEntryDependency & {
					hostChunks: string[];
				})[];
		  }) => HtmlResourceHintHtmlEntryDependency[]);

	/**
	 * Emit a JSON manifest of the resolved resource hints for each entrypoint (the same descriptors as `stats.entrypoints[].resourceHints`) as an output asset at this path. Lets an SSR server inject the `<link>` tags itself without walking the chunk graph — webpack's analogue of Vite's `build.ssrManifest`. Empty when `initial` is `"none"`.
	 */
	manifest?: string;

	/**
	 * Inject a tiny inline `<script>` polyfill for `<link rel="modulepreload">` into extracted HTML pages. Defaults from the target's modulepreload support (`output.environment.modulePreload`) — `true` when the environment lacks native support, `false` when it has it. Set `false` to never inject (the `<link>` tags are still emitted but do nothing on browsers without support — useful under a strict CSP that forbids inline scripts).
	 */
	modulePreloadPolyfill?: boolean;

	/**
	 * Auto-emit `<link rel="preconnect">` for the origin of a cross-origin `output.publicPath` (the origin bundles and assets are served from) into extracted HTML entries and the resource-hint stats / manifest. Mirrors `output.crossOriginLoading`. No-op when `publicPath` is relative or `"auto"`.
	 */
	preconnect?: boolean;

	/**
	 * Project-wide URL-referenced-asset hint rules, applied as the base `urlHints` of every parser (JavaScript `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>`). Parser-scoped `module.parser.<type>.urlHints` rules and per-URL magic comments still override these.
	 */
	urlHints?: UrlHintRule[];
}

/**
 * Defines the resource scheme data type used by this module.
 */
declare interface ResourceSchemeData {
	/**
	 * mime type of the resource
	 */
	mimetype?: string;

	/**
	 * additional parameters for the resource
	 */
	parameters?: string;

	/**
	 * encoding of the resource
	 */
	encoding?: false | "base64";

	/**
	 * encoded content of the resource
	 */
	encodedContent?: string;
}
declare abstract class RestoreProvidedData {
	exports: RestoreProvidedDataExports[];
	otherProvided?: null | boolean;
	otherCanMangleProvide?: boolean;
	otherTerminalBinding: boolean;

	/**
	 * Serializes this instance into the provided serializer context.
	 */
	serialize(context: ObjectSerializerContextObjectMiddlewareObject_4): void;
}

/**
 * Defines the restore provided data exports type used by this module.
 */
declare interface RestoreProvidedDataExports {
	name: string;
	provided?: null | boolean;
	canMangleProvide?: boolean;
	canInlineProvide?: InlinedValue;
	terminalBinding: boolean;
	pureProvide?: boolean;
	exportsInfo?: RestoreProvidedData;
}

/**
 * Defines the rule condition type used by this module.
 */
declare interface RuleCondition {
	property: string | string[];
	matchWhenEmpty: boolean;
	fn: (
		value: EffectData[
			| "compiler"
			| "dependency"
			| "resource"
			| "scheme"
			| "phase"
			| "attributes"
			| "realResource"
			| "resourceQuery"
			| "resourceFragment"
			| "mimetype"
			| "descriptionData"
			| "descriptionRelativePath"
			| "issuer"
			| "issuerLayer"]
	) => boolean;
}

/**
 * Glob patterns matched against the file name, `!` in front of a pattern excludes it, and a relative pattern matches at any depth.
 * @since 5.112.0
 */
declare interface RuleGlob {
	/**
	 * Glob patterns to match.
	 */
	glob: string | string[];
}
type RuleObject = string | RegExp | ((str: string) => boolean) | RuleGlob;

/**
 * Defines the rule set type used by this module.
 */
declare interface RuleSet {
	/**
	 * map of references in the rule set (may grow over time)
	 */
	references: Map<string, RuleSetLoaderOptions>;

	/**
	 * execute the rule set
	 */
	exec: (effectData: EffectData) => Effect[];

	/**
	 * the rules that never matched, outermost first
	 */
	unusedRules: () => CompiledRule[];
}
type RuleSetCondition =
	| string
	| RegExp
	| ((value: string) => boolean)
	| RuleSetLogicalConditions
	| RuleSetCondition[];
type RuleSetConditionAbsolute =
	| string
	| RegExp
	| ((value: string) => boolean)
	| RuleSetLogicalConditionsAbsolute
	| RuleSetConditionAbsolute[];
type RuleSetConditionOrConditions =
	| string
	| RegExp
	| ((value: string) => boolean)
	| RuleSetLogicalConditions
	| RuleSetCondition[];
type RuleSetLoaderOptions = string | { [index: string]: any };

/**
 * Logic operators and glob patterns used in a condition matcher.
 */
declare interface RuleSetLogicalConditions {
	/**
	 * Logical AND.
	 */
	and?: RuleSetCondition[];

	/**
	 * Match glob patterns against the value, `!` in front of a pattern excludes it. Path separators are normalized to `/` on every OS, and a relative pattern matches at any depth.
	 * @since 5.110.0
	 */
	glob?: string | string[];

	/**
	 * Logical NOT.
	 */
	not?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Logical OR.
	 */
	or?: RuleSetCondition[];
}

/**
 * Logic operators and glob patterns used in a condition matcher.
 */
declare interface RuleSetLogicalConditionsAbsolute {
	/**
	 * Logical AND.
	 */
	and?: RuleSetConditionAbsolute[];

	/**
	 * Match glob patterns against the value, `!` in front of a pattern excludes it. Path separators are normalized to `/` on every OS, and a relative pattern matches at any depth.
	 * @since 5.110.0
	 */
	glob?: string | string[];

	/**
	 * Logical NOT.
	 */
	not?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditionsAbsolute
		| RuleSetConditionAbsolute[];

	/**
	 * Logical OR.
	 */
	or?: RuleSetConditionAbsolute[];
}

/**
 * A rule description with conditions and effects for modules.
 */
declare interface RuleSetRule {
	/**
	 * Match on import assertions of the dependency.
	 */
	assert?: { [index: string]: RuleSetConditionOrConditions };

	/**
	 * Match the child compiler name.
	 */
	compiler?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Match dependency type.
	 */
	dependency?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Match values of properties in the description file (usually package.json).
	 */
	descriptionData?: { [index: string]: RuleSetConditionOrConditions };

	/**
	 * Match the path of the module relative to the directory of the description file (usually package.json), i.e. './lib/button.js'. Always uses forward slashes.
	 * @since 5.110.0
	 */
	descriptionRelativePath?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Enforce this rule as pre or post step.
	 */
	enforce?: "pre" | "post";

	/**
	 * Shortcut for resource.exclude.
	 */
	exclude?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditionsAbsolute
		| RuleSetConditionAbsolute[];

	/**
	 * Enable/Disable extracting source map.
	 */
	extractSourceMap?: boolean;

	/**
	 * The options for the module generator.
	 */
	generator?: { [index: string]: any };

	/**
	 * Match the module resource against glob patterns, `!` in front of a pattern excludes it. Combines with `test`, `include` and `exclude`.
	 * @since 5.110.0
	 */
	glob?: string | string[];

	/**
	 * Shortcut for resource.include.
	 */
	include?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditionsAbsolute
		| RuleSetConditionAbsolute[];

	/**
	 * Match the issuer of the module (The module pointing to this module).
	 */
	issuer?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditionsAbsolute
		| RuleSetConditionAbsolute[];

	/**
	 * Match layer of the issuer of this module (The module pointing to this module).
	 */
	issuerLayer?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Specifies the layer in which the module should be placed in.
	 */
	layer?: string;

	/**
	 * Shortcut for use.loader.
	 */
	loader?: string;

	/**
	 * Match module mimetype when load from Data URI.
	 */
	mimetype?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Only execute the first matching rule in this array.
	 */
	oneOf?: (undefined | null | false | "" | 0 | RuleSetRule)[];

	/**
	 * Shortcut for use.options.
	 */
	options?: string | { [index: string]: any };

	/**
	 * Options for parsing.
	 */
	parser?: { [index: string]: any };

	/**
	 * Match the import phase of the dependency.
	 */
	phase?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Match the real resource path of the module.
	 */
	realResource?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditionsAbsolute
		| RuleSetConditionAbsolute[];

	/**
	 * Options for the resolver.
	 */
	resolve?: ResolveOptionsWebpackOptions;

	/**
	 * Match the resource path of the module.
	 */
	resource?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditionsAbsolute
		| RuleSetConditionAbsolute[];

	/**
	 * Match the resource fragment of the module.
	 */
	resourceFragment?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Match the resource query of the module.
	 */
	resourceQuery?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Match and execute these rules when this rule is matched.
	 */
	rules?: (undefined | null | false | "" | 0 | RuleSetRule)[];

	/**
	 * Match module scheme.
	 */
	scheme?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Flags a module as with or without side effects.
	 */
	sideEffects?: boolean;

	/**
	 * Shortcut for resource.test.
	 */
	test?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditionsAbsolute
		| RuleSetConditionAbsolute[];

	/**
	 * Module type to use for the module.
	 */
	type?: string;

	/**
	 * Modifiers applied to the module when rule is matched.
	 */
	use?:
		| string
		| (
				| undefined
				| null
				| string
				| false
				| 0
				| RuleSetUseFunction
				| {
						/**
						 * Unique loader options identifier.
						 */
						ident?: string;
						/**
						 * Loader name.
						 */
						loader?: string;
						/**
						 * Loader options.
						 */
						options?: string | { [index: string]: any };
				  }
		  )[]
		| RuleSetUseFunction
		| {
				/**
				 * Unique loader options identifier.
				 */
				ident?: string;
				/**
				 * Loader name.
				 */
				loader?: string;
				/**
				 * Loader options.
				 */
				options?: string | { [index: string]: any };
		  };

	/**
	 * Match on import attributes of the dependency.
	 */
	with?: { [index: string]: RuleSetConditionOrConditions };
}
type RuleSetUse =
	| string
	| (
			| undefined
			| null
			| string
			| false
			| 0
			| RuleSetUseFunction
			| {
					/**
					 * Unique loader options identifier.
					 */
					ident?: string;
					/**
					 * Loader name.
					 */
					loader?: string;
					/**
					 * Loader options.
					 */
					options?: string | { [index: string]: any };
			  }
	  )[]
	| RuleSetUseFunction
	| {
			/**
			 * Unique loader options identifier.
			 */
			ident?: string;
			/**
			 * Loader name.
			 */
			loader?: string;
			/**
			 * Loader options.
			 */
			options?: string | { [index: string]: any };
	  };
type RuleSetUseFunction = (data: EffectData) =>
	| string
	| RuleSetUseFunction
	| {
			/**
			 * Unique loader options identifier.
			 */
			ident?: string;
			/**
			 * Loader name.
			 */
			loader?: string;
			/**
			 * Loader options.
			 */
			options?: string | { [index: string]: any };
	  }
	| (
			| undefined
			| null
			| string
			| false
			| 0
			| RuleSetUseFunction
			| {
					/**
					 * Unique loader options identifier.
					 */
					ident?: string;
					/**
					 * Loader name.
					 */
					loader?: string;
					/**
					 * Loader options.
					 */
					options?: string | { [index: string]: any };
			  }
	  )[];
type RuleSetUseItem =
	| string
	| RuleSetUseFunction
	| {
			/**
			 * Unique loader options identifier.
			 */
			ident?: string;
			/**
			 * Loader name.
			 */
			loader?: string;
			/**
			 * Loader options.
			 */
			options?: string | { [index: string]: any };
	  };
type RuleSyntaxParser = AtRule | QualifiedRule;

/**
 * what a run hands its visitors as `path.state`
 */
declare interface RunState<S> {
	state?: S;
}
declare class RuntimeChunkPlugin {
	/**
	 * Creates an instance of RuntimeChunkPlugin.
	 */
	constructor(options?: {
		/**
		 * The name factory for the runtime chunks.
		 */
		name?: (entrypoint: { name: string }) => string;
	});
	options: { name: string | ((entrypoint: { name: string }) => string) };

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
type RuntimeCondition = undefined | string | boolean | SortableSet<string>;
type RuntimeId = string | number;
declare class RuntimeModule extends Module {
	/**
	 * Creates an instance of RuntimeModule.
	 */
	constructor(name: string, stage?: number);
	name: string;
	stage: number;
	compilation?: Compilation;
	chunk?: Chunk;
	chunkGraph?: ChunkGraph;
	fullHash: boolean;
	dependentHash: boolean;

	/**
	 * Processes the provided compilation.
	 */
	attach(compilation: Compilation, chunk: Chunk, chunkGraph?: ChunkGraph): void;

	/**
	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
	 */
	getInstalledChunkHandlers(): null | [string, string][];

	/**
	 * Generates runtime code for this runtime module.
	 */
	generate(): null | string;

	/**
	 * Gets generated code.
	 */
	getGeneratedCode(): null | string;

	/**
	 * Returns true, if the runtime module should get it's own scope.
	 * When false, `generate()` must emit complete statements ending with `;`
	 * so a following runtime IIFE is not parsed as a call (ASI).
	 */
	shouldIsolate(): boolean;

	/**
	 * The answer a runtime module gives when it installs no chunk handler at all
	 */
	static NO_CHUNK_HANDLERS: [string, string][];

	/**
	 * Runtime modules without any dependencies to other runtime modules
	 */
	static STAGE_NORMAL: number;

	/**
	 * Runtime modules with simple dependencies on other runtime modules
	 */
	static STAGE_BASIC: number;

	/**
	 * Runtime modules which attach to handlers of other runtime modules
	 */
	static STAGE_ATTACH: number;

	/**
	 * Runtime modules which trigger actions on bootstrap
	 */
	static STAGE_TRIGGER: number;
	static KINDS: Set<
		| "html"
		| "runtime"
		| "normal"
		| "css"
		| "context"
		| "remote"
		| "consume-shared"
		| "external"
		| "concatenated"
	>;

	/**
	 * Gets source basic types.
	 * @deprecated In the next major release, call getSourceBasicTypes() directly on the module instance instead of using this static method.
	 */
	static getSourceBasicTypes(module: Module): ReadonlySet<string>;
}

/**
 * Defines the runtime requirements context type used by this module.
 */
declare interface RuntimeRequirementsContext {
	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * the code generation results
	 */
	codeGenerationResults: CodeGenerationResults;
}
type RuntimeSpec = undefined | string | SortableSet<string>;

/**
 * Represents RuntimeSpecMap.
 */
declare class RuntimeSpecMap<T, R = T> {
	/**
	 * Creates an instance of RuntimeSpecMap.
	 */
	constructor(clone?: RuntimeSpecMap<T, R>);

	/**
	 * Returns value.
	 */
	get(runtime: RuntimeSpec): undefined | R;

	/**
	 * Returns true, when the runtime is stored.
	 */
	has(runtime: RuntimeSpec): boolean;

	/**
	 * Updates default using the provided runtime.
	 */
	set(runtime: RuntimeSpec, value: R): void;

	/**
	 * Returns the new value.
	 */
	provide(runtime: RuntimeSpec, computer: () => R): R;

	/**
	 * Processes the provided runtime.
	 */
	delete(runtime: RuntimeSpec): void;

	/**
	 * Processes the provided runtime.
	 */
	update(runtime: RuntimeSpec, fn: (value?: R) => R): void;
	keys(): RuntimeSpec[];

	/**
	 * Returns values.
	 */
	values(): IterableIterator<R>;
	get size(): number;
}
declare class RuntimeSpecSet {
	/**
	 * Creates an instance of RuntimeSpecSet.
	 */
	constructor(iterable?: Iterable<RuntimeSpec>);

	/**
	 * Processes the provided runtime.
	 */
	add(runtime: RuntimeSpec): void;

	/**
	 * Returns true, when the runtime exists.
	 */
	has(runtime: RuntimeSpec): boolean;
	get size(): number;

	/**
	 * Returns iterable iterator.
	 */
	[Symbol.iterator](): IterableIterator<RuntimeSpec>;
}
declare abstract class RuntimeTemplate {
	compilation: Compilation;
	outputOptions: OutputNormalizedWithDefaults;
	requestShortener: RequestShortener;
	globalObject: string;
	contentHashReplacement: string;
	isIIFE(): boolean;

	/**
	 * Whether the global object expression reads the `this` binding, which only
	 * refers to the global object outside of strict mode.
	 */
	globalObjectUsesThis(): boolean;
	isModule(): boolean;
	isNeutralPlatform(): boolean;

	/**
	 * Whether the bundle targets node and web at once (universal `["node", "web"]` + `output.module`), like `isUniversalTarget` in `WebpackOptionsApply`.
	 */
	isUniversalTarget(): boolean;

	/**
	 * Runtime expression that is truthy in browser-like environments (a DOM
	 * `document` or a worker `self`) and falsy in Node.js. Single source of
	 * truth for branching a universal ("node-or-web") target at runtime.
	 */
	isWebLikePlatformExpression(): string;

	/**
	 * Expression for the global registry that collects CSS server-side when there
	 * is no DOM (SSR). Read it with `__webpack_css_server_styles__`; it is keyed
	 * by the style/chunk identifier and namespaced by `output.uniqueName`.
	 * Targets without `globalThis` go through the `__webpack_require__.g`
	 * polyfill, so consumers must also require `RuntimeGlobals.global`.
	 */
	cssServerStyleRegistry(): string;
	supportsConst(): boolean;
	supportsLet(): boolean;
	supportsMethodShorthand(): boolean;
	supportsLogicalAssignment(): boolean;
	supportsArrowFunction(): boolean;
	supportsAsyncFunction(): boolean;
	supportsGenerator(): boolean;
	supportsTopLevelAwait(): boolean;
	supportsOptionalChaining(): boolean;
	supportsSpread(): boolean;
	supportsObjectHasOwn(): boolean;
	supportsSymbol(): boolean;
	supportsForOf(): boolean;
	supportsDestructuring(): boolean;
	supportsBigIntLiteral(): boolean;
	supportsDynamicImport(): boolean;
	supportsEcmaScriptModuleSyntax(): boolean;
	supportsDeferImport(): boolean;
	supportsSourceImport(): boolean;
	supportsModulePreload(): boolean;

	/**
	 * Whether the deferred fill rewrote a chunk whose hashed name would otherwise go
	 * stale, which `RealContentHashPlugin` reads to run — and to repair `[chunkhash]`
	 * names — where `optimization.realContentHash` did not ask for it.
	 */
	needsAnalyzableRepair(): boolean;

	/**
	 * The assets the deferred fill rewrote under a name that has to be repaired: an
	 * on-demand repair renames only these and whatever names them.
	 */
	analyzableRepairedAssets(): ReadonlySet<string>;

	/**
	 * Whether a reference a foreign bundler can follow without running webpack's runtime
	 * may be emitted — the one question every caller asks, in the form it is asking for:
	 * - `"import"` — a literal `import("./chunk.js")` in place of `ensureChunk(id)`
	 * - `"url"` — a literal `new URL(<file>, import.meta.url)`
	 * - `"url-runtime"` — the same, written into a runtime module rather than a module
	 * - `"url-inline"` — whether such a reference names the file at the call site
	 * - `"wasm"` — the same, fully baked for a wasm binary the runtime would name
	 * - `"wasm-relative"` — a wasm path built at runtime under an `import.meta.url` base
	 * `"url-inline"` differs from `"url"` only in taking the `.p + <file>` fallback as
	 * an answer too — both name the file where it is used rather than through the
	 * asset's javascript wrapper, which is what decides whether that wrapper is emitted.
	 * A name code generation cannot settle may still be baked, through a stand-in the
	 * deferred pass fills in. Not covered here, because only the reference can tell: a
	 * chunk with no id, and one this compilation emits no javascript for.
	 */
	supportsAnalyzable(
		form: AnalyzableForm,
		chunkGraph?: ChunkGraph,
		module?: Module,
		runtime?: RuntimeSpec
	): boolean;

	/**
	 * Reports an analyzable-ESM bailout from outside this class.
	 */
	analyzableBailout(module: undefined | Module, reason: string): void;

	/**
	 * Names the module whose code generation starts, so the reasons its references
	 * record are handed back by `finishAnalyzableBailouts` and attributed to it.
	 */
	beginAnalyzableBailouts(module: Module): void;

	/**
	 * Ends the collection `beginAnalyzableBailouts` started, so the reasons can be
	 * stored beside the result and reapplied when the cache restores it.
	 */
	finishAnalyzableBailouts(): undefined | string[];

	/**
	 * Reapplies the bailouts a cached code generation result was stored with, so a
	 * restored module reports the same reasons a generated one does.
	 */
	restoreAnalyzableBailouts(module: Module, reasons: string[]): void;

	/**
	 * The reasons a module's references keep the runtime form, as recorded while its
	 * code was generated.
	 */
	analyzableBailoutsOf(module: Module): string[];

	/**
	 * Builds the analyzable `new URL(specifier, import.meta.url)` expression the ESM
	 * wasm/asset loader backends use to reference an emitted binary relative to the
	 * current module (via `output.importMetaName`) instead of the runtime public-path
	 * global — the form other bundlers and webpack itself can statically follow.
	 */
	importMetaUrl(specifier: string): string;

	/**
	 * Whether a baked asset url resolves against the entry `baseUri` at all. A public
	 * path that reaches the same place from any base never reads `.b` — and `auto`
	 * resolves to an absolute url too — while output with no baked form has nothing to
	 * resolve. Where this is false, what `baseUri` is set to cannot reach the generated
	 * code, so it must not reach the module hash either: `URLDependency.updateHash`
	 * asks this before contributing one.
	 */
	analyzableUrlReadsBaseUri(): boolean;

	/**
	 * Static literal specifier (already quoted) for the `new URL(<here>, import.meta.url)`
	 * an asset reference bakes to, or `null` to keep the runtime form. Unlike a wasm
	 * binary, the runtime resolves an asset url against `__webpack_require__.b` — the
	 * output root, or an entry `baseUri` where one is set — so that base is settled here
	 * before the rest of the name is.
	 */
	getAnalyzableAssetUrl(
		module: Module,
		chunkGraph: ChunkGraph,
		filename: string,
		runtime: RuntimeSpec
	): null | string;

	/**
	 * The `baseUri` the entries this code runs under agree on, which replaces the output
	 * root an asset url resolves against. Asked per runtime, because that is what the
	 * module is generated for: two entries with different bases each get their own
	 * source. `undefined` when none of them sets one, `null` when they disagree — an
	 * entry that omits it disagrees with one that sets it.
	 */
	entryBaseUri(runtime: RuntimeSpec): undefined | null | string;

	/**
	 * `output.publicPath` as the constant it will be, for code that would otherwise read
	 * `__webpack_require__.p` for a value that never changes. `undefined` when only the
	 * hash could say, or when a runtime reassigns `__webpack_public_path__` — then the
	 * global is the only thing that knows.
	 */
	constantPublicPath(): undefined | string;
	supportTemplateLiteral(): boolean;
	supportNodePrefixForCoreModules(): boolean;

	/**
	 * Renders node prefix for core module.
	 */
	renderNodePrefixForCoreModule(mod: string): string;

	/**
	 * Renders return const when it is supported, otherwise let when supported, otherwise var.
	 */
	renderConst(): "var" | "const" | "let";

	/**
	 * Renders return let when it is supported, otherwise var.
	 */
	renderLet(): "var" | "let";

	/**
	 * Returning function.
	 */
	returningFunction(returnValue: string, args?: string): string;

	/**
	 * Returns basic function.
	 */
	basicFunction(args: string, body: string | string[]): string;

	/**
	 * Returns result expression.
	 */
	concatenation(...args: (string | { expr: string })[]): string;

	/**
	 * Expression function.
	 */
	expressionFunction(expression: string, args?: string): string;

	/**
	 * Returns empty function code.
	 */
	emptyFunction(): string;

	/**
	 * Guards an access/call on `object` with optional chaining when supported,
	 * otherwise an equivalent `&&` short-circuit. `object` is evaluated twice in
	 * the fallback, so it must be side-effect free.
	 */
	optionalChaining(object: string, access: string): string;

	/**
	 * Reads a node builtin via `process.getBuiltinModule()`, guarded to stay falsy off node so universal `["node", "web"]` bundles don't crash (also falsy on node <22.3).
	 */
	getBuiltinModule(request: string, access?: string): string;

	/**
	 * Renders a `then` callback calling `fn` with `args`. An arrow keeps the `this`
	 * a method call gives; the bound form is shorter without arrows.
	 */
	deferredCall(fn: string, args: string): string;

	/**
	 * Renders an object-literal method, using method shorthand when supported
	 * and falling back to a `prop: function/arrow` property otherwise.
	 */
	method(prop: string, args: string, body: string | string[]): string;

	/**
	 * Returns an own-property check, using `Object.hasOwn` when supported and
	 * falling back to `Object.prototype.hasOwnProperty.call` otherwise.
	 */
	objectHasOwn(object: string, property: string): string;

	/**
	 * Returns a self-defaulting assignment, using the `||=` logical assignment
	 * operator when supported and falling back to `target = target || value`
	 * otherwise. `target` is evaluated twice in the fallback, so it must be
	 * side-effect free. The expression evaluates to the resulting value.
	 * Models `||` only, so `target` must never hold a legitimate falsy value
	 * (`0`, `""`, `false`) — it would be overwritten; use it for object/array defaults.
	 */
	assignOr(target: string, value: string): string;

	/**
	 * Returns destructure array code.
	 */
	destructureArray(items: string[], value: string): string;

	/**
	 * Destructure object.
	 */
	destructureObject(items: string[], value: string): string;

	/**
	 * Returns iIFE code.
	 */
	iife(args: string, body: string): string;

	/**
	 * Returns for each code.
	 */
	forEach(variable: string, array: string, body: string | string[]): string;

	/**
	 * Returns comment.
	 */
	comment(__0: {
		/**
		 * request string used originally
		 */
		request?: string;
		/**
		 * name of the chunk referenced
		 */
		chunkName?: null | string;
		/**
		 * reason information of the chunk
		 */
		chunkReason?: string;
		/**
		 * additional message
		 */
		message?: string;
		/**
		 * name of the export
		 */
		exportName?: string;
	}): string;

	/**
	 * Throw missing module error block.
	 */
	throwMissingModuleErrorBlock(__0: {
		/**
		 * request string used originally
		 */
		request?: string;
	}): string;

	/**
	 * Throw missing module error function.
	 */
	throwMissingModuleErrorFunction(__0: {
		/**
		 * request string used originally
		 */
		request?: string;
	}): string;

	/**
	 * Returns generated error IIFE.
	 */
	missingModule(__0: {
		/**
		 * request string used originally
		 */
		request?: string;
	}): string;

	/**
	 * Missing module statement.
	 */
	missingModuleStatement(__0: {
		/**
		 * request string used originally
		 */
		request?: string;
	}): string;

	/**
	 * Missing module promise.
	 */
	missingModulePromise(__0: {
		/**
		 * request string used originally
		 */
		request?: string;
	}): string;

	/**
	 * Returns the code.
	 */
	weakError(__0: {
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * the module
		 */
		module: Module;
		/**
		 * the request that should be printed as comment
		 */
		request?: string;
		/**
		 * expression to use as id expression
		 */
		idExpr?: string;
		/**
		 * which kind of code should be returned
		 */
		type: "promise" | "expression" | "statements";
	}): string;

	/**
	 * Returns the expression.
	 */
	moduleId(__0: {
		/**
		 * the module
		 */
		module: Module;
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * the request that should be printed as comment
		 */
		request?: string;
		/**
		 * if the dependency is weak (will create a nice error message)
		 */
		weak?: boolean;
	}): string;

	/**
	 * The side-effect annotation for output another build reads back, which is the
	 * only output it can pay for — elsewhere it is bytes with no consumer.
	 */
	sideEffectsAnnotation(): string;

	/**
	 * A module instantiation's side-effect annotation. Write it only where the
	 * statement ends the call: a minifier reads `f(id)(x)` as one and drops it.
	 */
	moduleSideEffectsAnnotation(module: Module, moduleGraph: ModuleGraph): string;

	/**
	 * Returns the expression.
	 */
	moduleRaw(__0: {
		/**
		 * the module
		 */
		module: null | Module;
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * the request that should be printed as comment
		 */
		request?: string;
		/**
		 * if the dependency is weak (will create a nice error message)
		 */
		weak?: boolean;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
	}): string;

	/**
	 * Returns the expression.
	 */
	moduleExports(__0: {
		/**
		 * the module
		 */
		module: null | Module;
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * the request that should be printed as comment
		 */
		request: string;
		/**
		 * if the dependency is weak (will create a nice error message)
		 */
		weak?: boolean;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
	}): string;

	/**
	 * Returns the expression.
	 */
	moduleNamespace(__0: {
		/**
		 * the module
		 */
		module: Module;
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * the request that should be printed as comment
		 */
		request: string;
		/**
		 * if the current module is in strict esm mode
		 */
		strict?: boolean;
		/**
		 * if the dependency is weak (will create a nice error message)
		 */
		weak?: boolean;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
	}): string;

	/**
	 * Module namespace promise.
	 */
	moduleNamespacePromise(__0: {
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * the current dependencies block
		 */
		block?: AsyncDependenciesBlock;
		/**
		 * the module
		 */
		module: Module;
		/**
		 * the request that should be printed as comment
		 */
		request: string;
		/**
		 * a message for the comment
		 */
		message: string;
		/**
		 * if the current module is in strict esm mode
		 */
		strict?: boolean;
		/**
		 * if the dependency is weak (will create a nice error message)
		 */
		weak?: boolean;
		/**
		 * dependency
		 */
		dependency: Dependency;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
		/**
		 * the module the `import()` is emitted into
		 */
		originModule?: Module;
	}): string;

	/**
	 * Runtime condition expression.
	 */
	runtimeConditionExpression(__0: {
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * runtime for which this code will be generated
		 */
		runtime?: RuntimeSpec;
		/**
		 * only execute the statement in some runtimes
		 */
		runtimeCondition?: string | boolean | SortableSet<string>;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
	}): string;

	/**
	 * Returns the import statement and the compat statement.
	 */
	importStatement(__0: {
		/**
		 * whether a new variable should be created or the existing one updated
		 */
		update?: boolean;
		/**
		 * the module
		 */
		module: Module;
		/**
		 * module in which the statement is emitted
		 */
		originModule: Module;
		/**
		 * the module graph
		 */
		moduleGraph: ModuleGraph;
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
		/**
		 * name of the import variable
		 */
		importVar: string;
		/**
		 * the request that should be printed as comment
		 */
		request?: string;
		/**
		 * true, if this is a weak dependency
		 */
		weak?: boolean;
		/**
		 * module dependency
		 */
		dependency?: ModuleDependency;
	}): [string, string];

	/**
	 * Export from import.
	 */
	exportFromImport<GenerateContext>(__0: {
		/**
		 * the module graph
		 */
		moduleGraph: ModuleGraph;
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * the module
		 */
		module: Module;
		/**
		 * the request
		 */
		request: string;
		/**
		 * the export name
		 */
		exportName: string | string[];
		/**
		 * the origin module
		 */
		originModule: Module;
		/**
		 * true, if location is safe for ASI, a bracket can be emitted
		 */
		asiSafe?: boolean;
		/**
		 * true, if expression will be called
		 */
		isCall?: boolean;
		/**
		 * when false, call context will not be preserved
		 */
		callContext: null | boolean;
		/**
		 * when true and accessing the default exports, interop code will be generated
		 */
		defaultInterop: boolean;
		/**
		 * the identifier name of the import variable
		 */
		importVar: string;
		/**
		 * init fragments will be added here
		 */
		initFragments: InitFragment<GenerateContext>[];
		/**
		 * runtime for which this code will be generated
		 */
		runtime: RuntimeSpec;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
		/**
		 * module dependency
		 */
		dependency: ModuleDependency;
		/**
		 * true, when a whole-namespace value may use a decoupled namespace object that keeps the original export names
		 */
		mangleableNamespace?: boolean;
	}): string;

	/**
	 * Returns expression.
	 */
	blockPromise(__0: {
		/**
		 * the async block
		 */
		block?: AsyncDependenciesBlock;
		/**
		 * the message
		 */
		message: string;
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
		/**
		 * the module the `import()` is emitted into, to report against
		 */
		originModule?: Module;
	}): string;

	/**
	 * The `../` path from a chunk's own asset back to the output root. Hashes are
	 * neutralized first: a runtime module is generated once to be hashed, before any
	 * hash exists, so resolving one there throws — and `RuntimeModule.updateHash`
	 * lets that throw fail the build rather than hashing it.
	 */
	chunkRootOutputDir(chunk: Chunk, enforceRelative: boolean): string;

	/**
	 * Static literal specifier (already quoted) for the `new URL(<here>, import.meta.url)`
	 * a worker or worklet entry chunk bakes to, or `null` to keep the runtime form. The
	 * gate and the build are asked together so every call site agrees on both — the
	 * `new Worker(...)` emit, and the resource hint `ResourceHintPlugin` spells for it.
	 */
	getAnalyzableWorkerUrl(
		overridePublicPath: undefined | string,
		chunk: Chunk,
		module: Module,
		chunkGraph: ChunkGraph
	): null | string;

	/**
	 * Static `new URL(<file>, import.meta.url)` for every stylesheet a runtime can load,
	 * keyed by chunk id, or `null` when they have to keep the runtime
	 * `publicPath + getChunkCssFilename(id)` form. Both the runtime module reading them
	 * and the plugin declaring what it needs ask this, so the two always agree. The
	 * runtime hands an absolute url string to `link.href`, and so does this — the browser
	 * resolves the element against the document, which is not where the chunk sits, and
	 * the loader reads the url as text either way.
	 */
	analyzableCssChunkUrls(
		runtimeChunk: Chunk,
		chunkGraph: ChunkGraph,
		runtimeRequirements: ReadonlySet<string>,
		consumingModule?: Module
	): null | Map<ChunkId, string>;

	/**
	 * Static `new URL(<file>, import.meta.url).href` for every javascript chunk a
	 * runtime can hint at with `<link rel="prefetch"/"modulepreload">`, keyed by chunk
	 * id, or `null` when they have to keep the runtime
	 * `publicPath + getChunkScriptFilename(id)` form. Both the runtime module reading
	 * them and the plugin declaring what it needs ask this, so the two always agree.
	 */
	analyzableChunkScriptUrls(
		runtimeChunk: Chunk,
		chunkGraph: ChunkGraph,
		runtimeRequirements: ReadonlySet<string>,
		consumingModule?: Module
	): null | Map<ChunkId, string>;

	/**
	 * Records that this runtime reads its chunks some way other than a native
	 * `import()`, so no literal can name what it loads. Recorded on the entries that
	 * chose it, which is where the setting behind it lives.
	 */
	reportChunkImportBailout(chunk: Chunk, chunkGraph: ChunkGraph): void;

	/**
	 * Whether the loader still needs to build a url from a chunk id, which is the case
	 * for a chunk it can be asked for that `analyzableChunkImports` leaves unnamed: one
	 * carrying a runtime of its own, or one a second entrypoint has at startup.
	 */
	chunkImportsNeedRuntimeUrl(
		runtimeChunk: Chunk,
		chunkGraph: ChunkGraph
	): boolean;

	/**
	 * A literal `import()` specifier for every javascript chunk a runtime loads on
	 * demand, keyed by chunk id, or `null` when one of them cannot be named here. The
	 * map is written into the runtime chunk rather than at each import site, so a
	 * hashed chunk name reaches no module that imports it.
	 */
	analyzableChunkImports(
		runtimeChunk: Chunk,
		chunkGraph: ChunkGraph,
		runtimeRequirements: ReadonlySet<string>,
		consumingModule?: Module
	): null | Map<ChunkId, string>;

	/**
	 * Static `new URL(<file>, import.meta.url)` for the binary emitted for an async wasm
	 * module. Only called when `supportsAnalyzable("wasm")` holds.
	 */
	getAnalyzableWasmUrl(
		module: Module,
		chunkGraph: ChunkGraph,
		runtime: RuntimeSpec,
		runtimeRequirements: Set<string>
	): string;

	/**
	 * Async module factory.
	 */
	asyncModuleFactory(__0: {
		/**
		 * the async block
		 */
		block: AsyncDependenciesBlock;
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
		/**
		 * request string used originally
		 */
		request?: string;
		/**
		 * the module the factory is emitted into
		 */
		originModule?: Module;
	}): string;

	/**
	 * Sync module factory.
	 */
	syncModuleFactory(__0: {
		/**
		 * the dependency
		 */
		dependency: Dependency;
		/**
		 * the chunk graph
		 */
		chunkGraph: ChunkGraph;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
		/**
		 * request string used originally
		 */
		request?: string;
	}): string;
	moduleFactoryFnHeader(__0: {
		/**
		 * the module the body belongs to
		 */
		module: Module;
		/**
		 * whether the body reads `module`
		 */
		needModule: boolean;
		/**
		 * whether the body reads `exports`
		 */
		needExports: boolean;
		/**
		 * whether the body reads `__webpack_require__`
		 */
		needRequire: boolean;
		/**
		 * whether the body reads `this` as exports
		 */
		needThisAsExports: boolean;
		/**
		 * render as a method shorthand, without the `function` keyword
		 */
		shorthand?: boolean;
	}): string;

	/**
	 * Define es module flag statement.
	 */
	defineEsModuleFlagStatement(__0: {
		/**
		 * the name of the exports object
		 */
		exportsArgument: string;
		/**
		 * if set, will be filled with runtime requirements
		 */
		runtimeRequirements: Set<string>;
	}): string;
}
declare abstract class RuntimeValue {
	fn: (value: {
		module: NormalModule;
		key: string;
		readonly version: ValueCacheVersion;
	}) => GeneratedValue;
	options: true | RuntimeValueOptions;

	/**
	 * Resolved before the module is parsed, since the parser cannot wait.
	 * Use the option for promise-returning functions not declared `async`.
	 */
	async: boolean;
	get fileDependencies(): true | string[];

	/**
	 * Records what the value is computed from on the module it is rendered into,
	 * so a change to any of it rebuilds that module.
	 */
	addDependencies(module: NormalModule, key: string): void;

	/**
	 * Runs the generator for one module.
	 */
	call(
		module: NormalModule,
		valueCacheVersions: Map<string, ValueCacheVersion>,
		key: string
	): GeneratedValue;

	/**
	 * Returns code.
	 */
	exec(
		parser: JavascriptParser,
		valueCacheVersions: Map<string, ValueCacheVersion>,
		key: string
	): CodeValuePrimitive;
	getCacheVersion(): undefined | string;
}

/**
 * Defines the runtime value options type used by this module.
 */
declare interface RuntimeValueOptions {
	fileDependencies?: string[];
	contextDependencies?: string[];
	missingDependencies?: string[];
	buildDependencies?: string[];
	version?: string | (() => string);

	/**
	 * resolve the generator before parsing, including promise-returning functions not declared `async`
	 */
	async?: boolean;
}
declare class SSRManifestPlugin {
	/**
	 * Creates an instance of SSRManifestPlugin.
	 */
	constructor(options?: SSRManifestPluginOptions);
	options: SSRManifestPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface SSRManifestPluginOptions {
	context?: string;
	filename?: string;
}

/**
 * A lexical scope. One shape for every kind, so the property loads in the
 * resolution loop stay monomorphic.
 */
declare abstract class Scope {
	type: ScopeType;
	blockType: string;
	blockStart: number;
	upper: null | Scope;
	childScopes: Scope[];
	variables: Variable[];
	variableScope: Scope;

	/**
	 * For a function scope with parameters, the offset where its body
	 * starts; `-1` for every other scope. Separates the two regions that
	 * share this scope, so a reference in the parameter list can be kept
	 * from resolving to a binding declared in the body — see
	 * `isHiddenBodyBinding`.
	 */
	paramBoundary: number;
	getBinding(name: string): undefined | Variable;
}

/**
 * Defines the scope info type used by this module.
 */
declare interface ScopeInfo {
	definitions: StackedMap<string, VariableInfo | ScopeInfo>;
	topLevelScope: boolean | "arrow";
	inShorthand: string | boolean;
	inTaggedTemplateTag: boolean;
	inTry: boolean;
	isStrict: boolean;
	isAsmJs: boolean;
	terminated?: 1 | 2;
}
type ScopeType =
	| "function"
	| "module"
	| "global"
	| "catch"
	| "for"
	| "switch"
	| "with"
	| "class"
	| "function-expression-name"
	| "block"
	| "class-field-initializer"
	| "class-static-block";

/**
 * What replaying an entry streamed for a `scopes` request needs besides its
 * map. The map only keeps the encoded `scopes` field, so `bindings` holds, by
 * source index, the bindings each source reported. The field also appended
 * names to the map, and `names` counts the ones the stream itself reported,
 * so a replay reports the same names a fresh stream would.
 */
declare interface ScopesReplay {
	/**
	 * bindings by source index
	 */
	bindings: (undefined | Map<string, string>)[];

	/**
	 * number of names the stream reported
	 */
	names: number;
}

/**
 * Defines the selector type used by this module.
 */
declare interface Selector<A, B> {
	(input: A): undefined | null | B;
}

/**
 * Represents Serializer.
 */
declare abstract class Serializer<DeserializedValue, SerializedValue, Context> {
	serializeMiddlewares: SerializerMiddleware[];
	deserializeMiddlewares: SerializerMiddleware[];
	context?: Context;

	/**
	 * Serializes this instance into the provided serializer context.
	 */
	serialize<ExtendedContext>(
		obj: DeserializedValue | Promise<DeserializedValue>,
		context: Context & ExtendedContext
	): Promise<SerializedValue>;

	/**
	 * Restores this instance from the provided deserializer context.
	 */
	deserialize<ExtendedContext>(
		value: SerializedValue | Promise<SerializedValue>,
		context: Context & ExtendedContext
	): Promise<DeserializedValue>;
}

/**
 * Represents SerializerMiddleware.
 */
declare abstract class SerializerMiddleware<
	DeserializedType = ComplexSerializableType,
	SerializedType = ComplexSerializableType,
	Context = object
> {
	/**
	 * Serializes this instance into the provided serializer context.
	 */
	serialize(
		data: DeserializedType,
		context: Context
	): null | SerializedType | Promise<SerializedType>;

	/**
	 * Restores this instance from the provided deserializer context.
	 */
	deserialize(
		data: SerializedType,
		context: Context
	): DeserializedType | Promise<DeserializedType>;
}
type ServerLazyCompilationBackend = ServerImportHttp | ServerImportHttps;
declare interface SetIterator<T> extends IteratorObject<T, undefined> {
	[Symbol.iterator](): SetIterator<T>;
	[Symbol.dispose](): void;
}
declare class SharePlugin {
	/**
	 * Creates an instance of SharePlugin.
	 */
	constructor(options: SharePluginOptions);

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Options for shared modules.
 */
declare interface SharePluginOptions {
	/**
	 * Share scope name used for all shared modules (defaults to 'default').
	 */
	shareScope?: string;
	shared: Shared;
}
type Shared = SharedObject | SharedBranch1Item[];
type SharedBranch1Item = string | SharedObject;

/**
 * Advanced configuration for modules that should be shared in the share scope.
 */
declare interface SharedConfig {
	/**
	 * Include the provided and fallback module directly instead behind an async request. This allows to use this shared module in initial load too. All possible shared modules need to be eager too.
	 */
	eager?: boolean;
	exclude?: SharedModuleFilter;

	/**
	 * Provided module that should be provided to share scope. Also acts as fallback module if no shared module is found in share scope or version isn't valid. Defaults to the property name.
	 */
	import?: string | false;
	include?: SharedModuleFilter;

	/**
	 * Package name to determine required version from description file. This is only needed when package name can't be automatically determined from request.
	 */
	packageName?: string;

	/**
	 * Version requirement from module in share scope.
	 */
	requiredVersion?: string | false;

	/**
	 * Module is looked up under this key from the share scope.
	 */
	shareKey?: string;

	/**
	 * Share scope name.
	 */
	shareScope?: string;

	/**
	 * Allow only a single version of the shared module in share scope (disabled by default).
	 */
	singleton?: boolean;

	/**
	 * Do not accept shared module if version is not valid (defaults to yes, if local fallback module is available and shared module is not a singleton, otherwise no, has no effect if there is no required version specified).
	 */
	strictVersion?: boolean;

	/**
	 * Version of the provided module. Will replace lower matching versions, but not higher.
	 */
	version?: string | false;
}

/**
 * Filters shared modules by version or request: with 'include' only matching modules are shared, with 'exclude' matching ones are not. A filtered-out module is resolved and bundled as if it wasn't shared.
 * @since 5.112.0
 */
declare interface SharedModuleFilter {
	/**
	 * Request remainder after a key ending in a slash (e.g. 'get' for 'lodash/get' under 'lodash/'). Has no effect on other keys.
	 */
	request?: string | RegExp;

	/**
	 * Version range the module's version (from its description file or the 'version' option) is tested against. A consumed module is tested through its fallback module, so this has no effect on consumes without one.
	 */
	version?: string;
}

/**
 * Modules that should be shared in the share scope. Property names are used to match requested modules in this compilation. Relative requests are resolved, module requests are matched unresolved, absolute paths will match resolved requests. A trailing slash will match all requests with this prefix. In this case shareKey must also have a trailing slash.
 */
declare interface SharedObject {
	[index: string]: SharedObjectValue;
}
type SharedObjectValue = string | SharedConfig;
declare class SideEffectsFlagPlugin {
	/**
	 * Creates an instance of SideEffectsFlagPlugin.
	 */
	constructor(analyseSource?: boolean);

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Module has side effects.
	 */
	static moduleHasSideEffects(
		moduleName: string,
		flagValue: SideEffectsFlagValue,
		cache: Map<string, RegExp>
	): undefined | boolean;
}
type SideEffectsFlagValue = undefined | string | boolean | string[];
type SimpleBlock = NodeSyntaxParser & {
	token: SimpleBlockToken;
	value: ComponentValue[];
};
type SimpleBlockToken = "{" | "(" | "[";
type SimpleType = "string" | "number" | "boolean";
declare class SizeOnlySource extends Source {
	constructor(size: number);
}

/**
 * `MAP.skip`, which a transform returns to drop a node from its list
 */
declare interface SkipMarker {
	[index: string]: never;
}

/**
 * `CssProcessOptions.skip`: two independent axes, so each reads unambiguously.
 */
declare interface SkipOptions {
	/**
	 * component-value node types to drop from declaration value / function-arg lists (indexed by `NodeType`, 1 = skip; build with `buildSkipSet`)
	 */
	types?: Uint8Array;

	/**
	 * drop qualified-rule (selector) preludes — the rule and its block are still produced (default false)
	 */
	selectorPrelude?: boolean;

	/**
	 * drop at-rule preludes — the at-rule and its block are still produced (default false)
	 */
	atRulePrelude?: boolean;
}
declare abstract class Snapshot {
	startTime?: number;
	fileTimestamps?: Map<string, null | FileSystemInfoEntry>;
	fileHashes?: Map<string, null | string>;
	fileTshs?: Map<string, null | string | TimestampAndHash>;
	contextTimestamps?: Map<string, null | ResolvedContextFileSystemInfoEntry>;
	contextHashes?: Map<string, null | string>;
	contextTshs?: Map<string, null | ResolvedContextTimestampAndHash>;
	missingExistence?: Map<string, boolean>;
	managedItemInfo?: Map<string, string>;
	managedFiles?: Set<string>;
	managedContexts?: Set<string>;
	managedMissing?: Set<string>;
	children?: Set<Snapshot>;
	hasStartTime(): boolean;

	/**
	 * Updates start time using the provided value.
	 */
	setStartTime(value: number): void;

	/**
	 * Sets merged start time.
	 */
	setMergedStartTime(value: undefined | number, snapshot: Snapshot): void;
	hasFileTimestamps(): boolean;

	/**
	 * Sets file timestamps.
	 */
	setFileTimestamps(value: Map<string, null | FileSystemInfoEntry>): void;
	hasFileHashes(): boolean;

	/**
	 * Updates file hashes using the provided value.
	 */
	setFileHashes(value: Map<string, null | string>): void;
	hasFileTshs(): boolean;

	/**
	 * Updates file tshs using the provided value.
	 */
	setFileTshs(value: Map<string, null | string | TimestampAndHash>): void;
	hasContextTimestamps(): boolean;

	/**
	 * Sets context timestamps.
	 */
	setContextTimestamps(
		value: Map<string, null | ResolvedContextFileSystemInfoEntry>
	): void;
	hasContextHashes(): boolean;

	/**
	 * Sets context hashes.
	 */
	setContextHashes(value: Map<string, null | string>): void;
	hasContextTshs(): boolean;

	/**
	 * Updates context tshs using the provided value.
	 */
	setContextTshs(
		value: Map<string, null | ResolvedContextTimestampAndHash>
	): void;
	hasMissingExistence(): boolean;

	/**
	 * Sets missing existence.
	 */
	setMissingExistence(value: Map<string, boolean>): void;
	hasManagedItemInfo(): boolean;

	/**
	 * Sets managed item info.
	 */
	setManagedItemInfo(value: Map<string, string>): void;
	hasManagedFiles(): boolean;

	/**
	 * Sets managed files.
	 */
	setManagedFiles(value: Set<string>): void;
	hasManagedContexts(): boolean;

	/**
	 * Sets managed contexts.
	 */
	setManagedContexts(value: Set<string>): void;
	hasManagedMissing(): boolean;

	/**
	 * Sets managed missing.
	 */
	setManagedMissing(value: Set<string>): void;
	hasChildren(): boolean;

	/**
	 * Updates children using the provided value.
	 */
	setChildren(value: Set<Snapshot>): void;

	/**
	 * Adds the provided child to the snapshot.
	 */
	addChild(child: Snapshot): void;

	/**
	 * Serializes this instance into the provided serializer context.
	 */
	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;

	/**
	 * Restores this instance from the provided deserializer context.
	 */
	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;

	/**
	 * Gets file iterable.
	 */
	getFileIterable(): Iterable<string>;

	/**
	 * Gets context iterable.
	 */
	getContextIterable(): Iterable<string>;

	/**
	 * Gets missing iterable.
	 */
	getMissingIterable(): Iterable<string>;
}
type SnapshotNormalizedWithDefaults = SnapshotOptionsWebpackOptions & {
	managedPaths: (string | RegExp)[];
	unmanagedPaths: (string | RegExp)[];
	immutablePaths: (string | RegExp)[];
	resolveBuildDependencies: {
		/**
		 * Use hashes of the content of the files/directories to determine invalidation.
		 */
		hash?: boolean;
		/**
		 * Use timestamps of the files/directories to determine invalidation.
		 */
		timestamp?: boolean;
	};
	buildDependencies: {
		/**
		 * Use hashes of the content of the files/directories to determine invalidation.
		 */
		hash?: boolean;
		/**
		 * Use timestamps of the files/directories to determine invalidation.
		 */
		timestamp?: boolean;
	};
	module: {
		/**
		 * Use hashes of the content of the files/directories to determine invalidation.
		 */
		hash?: boolean;
		/**
		 * Use timestamps of the files/directories to determine invalidation.
		 */
		timestamp?: boolean;
	};
	resolve: {
		/**
		 * Use hashes of the content of the files/directories to determine invalidation.
		 */
		hash?: boolean;
		/**
		 * Use timestamps of the files/directories to determine invalidation.
		 */
		timestamp?: boolean;
	};
};

/**
 * Defines the snapshot options type used by this module.
 */
declare interface SnapshotOptionsFileSystemInfo {
	/**
	 * should use hash to snapshot
	 */
	hash?: boolean;

	/**
	 * should use timestamp to snapshot
	 */
	timestamp?: boolean;
}

/**
 * Options affecting how file system snapshots are created and validated.
 */
declare interface SnapshotOptionsWebpackOptions {
	/**
	 * Options for snapshotting build dependencies to determine if the whole cache need to be invalidated.
	 */
	buildDependencies?: {
		/**
		 * Use hashes of the content of the files/directories to determine invalidation.
		 */
		hash?: boolean;
		/**
		 * Use timestamps of the files/directories to determine invalidation.
		 */
		timestamp?: boolean;
	};

	/**
	 * Options for snapshotting the context module to determine if it needs to be built again.
	 */
	contextModule?: {
		/**
		 * Use hashes of the content of the files/directories to determine invalidation.
		 */
		hash?: boolean;
		/**
		 * Use timestamps of the files/directories to determine invalidation.
		 */
		timestamp?: boolean;
	};

	/**
	 * List of paths that are managed by a package manager and contain a version or hash in its path so all files are immutable.
	 */
	immutablePaths?: (string | RegExp)[];

	/**
	 * List of paths that are managed by a package manager and can be trusted to not be modified otherwise.
	 */
	managedPaths?: (string | RegExp)[];

	/**
	 * Options for snapshotting dependencies of modules to determine if they need to be built again.
	 */
	module?: {
		/**
		 * Use hashes of the content of the files/directories to determine invalidation.
		 */
		hash?: boolean;
		/**
		 * Use timestamps of the files/directories to determine invalidation.
		 */
		timestamp?: boolean;
	};

	/**
	 * Options for snapshotting dependencies of request resolving to determine if requests need to be re-resolved.
	 */
	resolve?: {
		/**
		 * Use hashes of the content of the files/directories to determine invalidation.
		 */
		hash?: boolean;
		/**
		 * Use timestamps of the files/directories to determine invalidation.
		 */
		timestamp?: boolean;
	};

	/**
	 * Options for snapshotting the resolving of build dependencies to determine if the build dependencies need to be re-resolved.
	 */
	resolveBuildDependencies?: {
		/**
		 * Use hashes of the content of the files/directories to determine invalidation.
		 */
		hash?: boolean;
		/**
		 * Use timestamps of the files/directories to determine invalidation.
		 */
		timestamp?: boolean;
	};

	/**
	 * List of paths that are not managed by a package manager and the contents are subject to change.
	 */
	unmanagedPaths?: (string | RegExp)[];
}

/**
 * Create a new sortable set
 */
declare interface SortFunction<T> {
	(a: T, b: T): number;
}

/**
 * A subset of Set that offers sorting functionality
 */
declare abstract class SortableSet<T> extends Set<T> {
	/**
	 * Sort with a comparer function
	 */
	sortWith(sortFn?: SortFunction<T>): void;
	sort(): SortableSet<T>;

	/**
	 * Get data from cache
	 */
	getFromCache<R>(fn: (set: SortableSet<T>) => R): R;

	/**
	 * Get data from cache (ignoring sorting)
	 */
	getFromUnorderedCache<R>(fn: (set: SortableSet<T>) => R): R;

	/**
	 * Returns the raw array.
	 */
	toJSON(): T[];
}
declare class Source {
	constructor();
	source(): SourceValue;
	buffer(): Buffer;
	buffers(): Buffer[];
	size(): number;
	map(options?: MapOptions): null | RawSourceMap;
	sourceAndMap(options?: MapOptions): SourceAndMap;
	updateHash(hash: HashLike): void;

	/**
	 * Release cached data held by this source. clearCache is a memory
	 * hint: it never affects correctness or output, only how expensive
	 * the next read is. Subclasses override; the base is a no-op so
	 * every Source supports the call. Composite sources always recurse
	 * into wrapped sources. When the same child is reachable via several
	 * parents (e.g. modules shared across webpack chunks), pass a shared
	 * `visited` WeakSet so each subtree is walked at most once.
	 * Not safe to call concurrently with source/map/sourceAndMap/
	 * streamChunks/updateHash on the same instance.
	 */
	clearCache(options?: ClearCacheOptions, visited?: WeakSet<Source>): void;
}
declare interface SourceAndMap {
	/**
	 * source
	 */
	source: SourceValue;

	/**
	 * map
	 */
	map: null | RawSourceMap;
}
declare interface SourceBucket {
	[index: string]: undefined | SourceItem;
}
declare interface SourceItem {
	type: SourceTypeOrResolver;
	filter?: (attributes: Map<string, string>, value: string) => boolean;
	namespace?: 1 | 2;
}
declare interface SourceLike {
	/**
	 * source
	 */
	source: () => SourceValue;

	/**
	 * buffer
	 */
	buffer?: () => Buffer;

	/**
	 * buffers
	 */
	buffers?: () => Buffer[];

	/**
	 * size
	 */
	size?: () => number;

	/**
	 * map
	 */
	map?: (options?: MapOptions) => null | RawSourceMap;

	/**
	 * source and map
	 */
	sourceAndMap?: (options?: MapOptions) => SourceAndMap;

	/**
	 * hash updater
	 */
	updateHash?: (hash: HashLike) => void;

	/**
	 * clear cache
	 */
	clearCache?: (options?: ClearCacheOptions, visited?: WeakSet<Source>) => void;
}

/**
 * A version-3 source map. Written structurally (with the `3` literal) so it
 * satisfies both `webpack-sources` and the minimizer plugin's map types without
 * depending on either.
 */
declare interface SourceMap {
	version: 3;
	file: string;
	sources: string[];
	sourcesContent?: string[];
	names: string[];
	mappings: string;
}
declare class SourceMapDevToolPlugin {
	/**
	 * Creates an instance of SourceMapDevToolPlugin.
	 */
	constructor(options?: SourceMapDevToolPluginOptions);
	sourceMapFilename?: null | string | false;
	sourceMappingURLComment: string | false | TemplatePathFn<PathData>;
	moduleFilenameTemplate: DevtoolModuleFilenameTemplate;
	fallbackModuleFilenameTemplate: DevtoolFallbackModuleFilenameTemplate;
	namespace: string;
	options: SourceMapDevToolPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface SourceMapDevToolPluginOptions {
	/**
	 * Appends the given value to the original asset. Usually the #sourceMappingURL comment. [url] is replaced with a URL to the source map file. false disables the appending.
	 */
	append?: null | string | false | TemplatePathFn<PathData>;

	/**
	 * Indicates whether column mappings should be used (defaults to true).
	 */
	columns?: boolean;

	/**
	 * Emit debug IDs into source and SourceMap.
	 */
	debugIds?: boolean;

	/**
	 * Exclude modules that match the given value from source map generation.
	 */
	exclude?:
		string | RegExp | ((str: string) => boolean) | RuleGlob | RuleObject[];

	/**
	 * Generator string or function to create identifiers of modules for the 'sources' array in the SourceMap used only if 'moduleFilenameTemplate' would result in a conflict.
	 */
	fallbackModuleFilenameTemplate?:
		string | ((context: ModuleFilenameTemplateContext) => string);

	/**
	 * Path prefix to which the [file] placeholder is relative to.
	 */
	fileContext?: string;

	/**
	 * Defines the output filename of the SourceMap (will be inlined if no value is provided).
	 */
	filename?: null | string | false;

	/**
	 * Decide whether to ignore source files that match the specified value in the SourceMap.
	 */
	ignoreList?:
		string | RegExp | ((str: string) => boolean) | RuleGlob | RuleObject[];

	/**
	 * Include source maps for module paths that match the given value.
	 */
	include?:
		string | RegExp | ((str: string) => boolean) | RuleGlob | RuleObject[];

	/**
	 * Indicates whether SourceMaps from loaders should be used (defaults to true).
	 */
	module?: boolean;

	/**
	 * Generator string or function to create identifiers of modules for the 'sources' array in the SourceMap.
	 */
	moduleFilenameTemplate?:
		string | ((context: ModuleFilenameTemplateContext) => string);

	/**
	 * Namespace prefix to allow multiple webpack roots in the devtools.
	 */
	namespace?: string;

	/**
	 * Omit the 'sourceContents' array from the SourceMap.
	 */
	noSources?: boolean;

	/**
	 * Provide a custom public path for the SourceMapping comment.
	 */
	publicPath?: string;
	scopes?: boolean;

	/**
	 * Provide a custom value for the 'sourceRoot' property in the SourceMap.
	 */
	sourceRoot?: string;

	/**
	 * Include source maps for modules based on their extension (defaults to .js and .css).
	 */
	test?: string | RegExp | ((str: string) => boolean) | RuleGlob | RuleObject[];
}

/**
 * The `process` source-map option: turns map collection on and names the input
 * (`sources[0]` / optional `sourcesContent[0]`). Present => `process` returns
 * `{ code, map }` instead of a bare string.
 */
declare interface SourceMapOptions {
	source: string;
	content?: string;
}
declare class SourceMapSource extends Source {
	constructor(
		value: string | Buffer,
		name: string,
		sourceMap?: string | Buffer | RawSourceMap,
		originalSource?: string | Buffer,
		innerSourceMap?: null | string | Buffer | RawSourceMap,
		removeOriginalSource?: boolean
	);
	getArgsAsBuffers(): [
		Buffer,
		string,
		Buffer,
		undefined | Buffer,
		undefined | Buffer,
		undefined | boolean
	];
	streamChunks(
		options: OptionsStreamChunks,
		onChunk: (
			chunk: undefined | string,
			generatedLine: number,
			generatedColumn: number,
			sourceIndex: number,
			originalLine: number,
			originalColumn: number,
			nameIndex: number
		) => void,
		onSource: (
			sourceIndex: number,
			source: null | string,
			sourceContent?: string,
			scopeBindings?: Map<string, string>
		) => void,
		onName: (nameIndex: number, name: string) => void
	): GeneratedSourceInfo;
}

/**
 * Defines the source position type used by this module.
 */
declare interface SourcePosition {
	line: number;
	column?: number;
}

/**
 * Visitor coordinator: owns the visitor registry and drives a language
 * `grammar` over the source. Language-agnostic — each syntax (CSS, HTML, …)
 * binds its own grammar, node-type enum and (optionally) node printer.
 * Usage:
 * ```
 * processor.use({ [NodeType.X]: (path) => {}, [NodeType.Y]: { enter, exit } });
 * processor.process(source);
 * ```
 */
declare abstract class SourceProcessor<
	TPath extends NodePath<TNode, unknown>,
	TNode,
	TProcessOptions = object,
	TPrintOptions = object,
	TParts extends NodeParts = AnyParts,
	TState = unknown,
	TVisitors = VisitorMap<TPath>
> {
	/**
	 * Register one bucket for several node types, as a map naming each would;
	 * its path takes only the parts those types have.
	 */
	use<T extends number>(
		types: T[],
		bucket: VisitorBucket<TypedNodePath<TPath, TNode, TParts, T, TState>>
	): SourceProcessor<
		TPath,
		TNode,
		TProcessOptions,
		TPrintOptions,
		TParts,
		TState,
		TVisitors
	>;

	/**
	 * Register a visitor map; calls accumulate per node type, and each
	 * visitor's path takes only its type's parts.
	 * A bucket is a function (= `{ enter }`) or `{ enter?, exit? }`.
	 */
	use(
		map: TVisitors
	): SourceProcessor<
		TPath,
		TNode,
		TProcessOptions,
		TPrintOptions,
		TParts,
		TState,
		TVisitors
	>;

	/**
	 * Register a visitor map built at runtime, keyed by any node type.
	 */
	use(
		map: VisitorMap<TPath>
	): SourceProcessor<
		TPath,
		TNode,
		TProcessOptions,
		TPrintOptions,
		TParts,
		TState,
		TVisitors
	>;

	/**
	 * Parse `input` once and fire the visitors in source order. Asking for output
	 * — `mode`, the one thing that names it — makes the same walk print, given a
	 * printer supplied at construction: a
	 * {@link PrintContext} is created, each node's printer fires into it as the node
	 * finishes, and the result is returned as `{ code, map }`: the serialized output
	 * and, for a caller that named its input with `source` / `content`, the
	 * input->output source map — `map` is `undefined` without one. Asking for
	 * none of it only walks and returns `undefined`. A single parse — printing
	 * never re-parses; all configuration is per-call.
	 */
	process(
		input: string,
		options: TProcessOptions &
			RunState<TState> & { mode: "beautify" | "minify" } & {
				source: string;
				content?: string;
			}
	): { code: string; map: SourceMap };
	process(
		input: string,
		options: TProcessOptions &
			RunState<TState> & { mode: "beautify" | "minify" }
	): { code: string; map: undefined };
	process(
		input: string,
		options?: TProcessOptions & RunState<TState>
	): undefined;

	/**
	 * {@link process}, for a caller whose renderer answers asynchronously. Code
	 * generation is synchronous — a printer returns its node's text, it cannot
	 * await one — so the walk leaves a marker where each answer goes, they are
	 * asked for together, and {@link PrintContext.substitute} stands each in its
	 * place before the output and its map are built. One parse either way, and
	 * the async boundary stays at the top rather than on every node.
	 * This is the shape `process` itself takes once it is async: how the answers
	 * are waited for is this method's business, so nothing above it changes.
	 */
	processAsync(
		input: string,
		options: Omit<TProcessOptions, "renderEmbeddedSource"> &
			RunState<TState> & { mode: "beautify" | "minify" } & {
				source?: string;
				content?: string;
				renderEmbeddedSource?: (
					source: string,
					hole: DeferredEmbeddedSource
				) => undefined | string | Promise<undefined | string>;
			}
	): Promise<{ code: string; map?: SourceMap }>;
}
declare interface SourceTable {
	[index: string]: SourceBucket;
}
type SourceType =
	| "html"
	| "script"
	| "css-url"
	| "stylesheet"
	| "prefetch"
	| "preload"
	| "script-module"
	| "modulepreload"
	| "src"
	| "srcset"
	| "stylesheet-style"
	| "stylesheet-style-attribute"
	| "srcdoc"
	| "msapplication-task";
type SourceTypeOrResolver =
	| "html"
	| "script"
	| "css-url"
	| "stylesheet"
	| "prefetch"
	| "preload"
	| "script-module"
	| "modulepreload"
	| "src"
	| "srcset"
	| "stylesheet-style"
	| "stylesheet-style-attribute"
	| "srcdoc"
	| "msapplication-task"
	| ((attrs: Map<string, string>, css: boolean) => SourceType);
type SourceValue = string | Buffer;

/**
 * terser's `Splice`: what a transform returns to put several nodes in its place.
 */
declare abstract class Splice<T = NodeShape> {
	v: T[];
}

/**
 * Defines the split chunks options type used by this module.
 */
declare interface SplitChunksOptions {
	dedupDepth?: number;
	chunksFilter: (chunk: Chunk) => undefined | boolean;
	defaultSizeTypes: string[];
	minSize: SplitChunksSizes;
	minSizeReduction: SplitChunksSizes;
	minRemainingSize: SplitChunksSizes;
	enforceSizeThreshold: SplitChunksSizes;
	maxInitialSize: SplitChunksSizes;
	maxAsyncSize: SplitChunksSizes;
	minChunks: number;
	maxAsyncRequests: number;
	maxInitialRequests: number;
	hidePathInfo: boolean;
	filename?:
		string | ((pathData: PathDataChunk, assetInfo?: AssetInfo) => string);
	automaticNameDelimiter: string;
	getCacheGroups: (
		module: Module,
		context: CacheGroupsContext
	) => null | CacheGroupSource[];
	getName: (module: Module, chunks: Chunk[], key: string) => undefined | string;
	usedExports: boolean;
	fallbackCacheGroup: FallbackCacheGroup;
}
declare class SplitChunksPlugin {
	/**
	 * Creates an instance of SplitChunksPlugin.
	 */
	constructor(options?: OptimizationSplitChunksOptions);
	options: SplitChunksOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
	static getCappedSplits: (
		compilation: Compilation
	) => undefined | CappedSplit[];
}
declare interface SplitChunksSizes {
	[index: string]: number;
}
declare interface SplitData {
	id?: string | number;
	hash?: string;
	modules: string[];
	size: number;
}

/**
 * Singly-linked stack entry that also exposes a Set-like API
 * (`has`, `size`, iteration). Each `doResolve` call prepends a new
 * `StackEntry` that points at the previous tip via `.parent`, so pushing
 * is O(1) in time and memory. Recursion detection walks the linked list
 * (O(n)) but the stack is typically shallow, so this is cheaper overall
 * than cloning a `Set` per call.
 */
declare abstract class StackEntry {
	name?: string;
	path: string | false;
	request: string;
	query: string;
	fragment: string;
	directory: boolean;
	module: boolean;
	parent?: StackEntry;

	/**
	 * Strings seeded by callers that still pass `stack: new Set([...])`.
	 * Propagated through the chain so deeper `doResolve` calls still see
	 * them during recursion checks. `undefined` in the common case so
	 * there is no extra work on the hot path.
	 */
	preSeeded?: Set<string>;

	/**
	 * Walk the linked list looking for an entry with the same request shape.
	 * Set-compatible: callers that used `stack.has(entry)` keep working.
	 * NOTE: kept monomorphic on purpose. An earlier draft accepted a string
	 * query too (so pre-5.21 plugins keeping their own `Set<string>` of
	 * seen entries could probe the live stack with the formatted form),
	 * but adding the second shape regressed `doResolve`'s heap profile by
	 * ~1 MiB / 200 resolves on stack-churn — V8 keeps a polymorphic
	 * call-site state for `parent.has(stackEntry)` once `has` has two
	 * argument shapes. Plugins that need string membership can reach for
	 * `[...stack].find(e => e.includes(formattedString))` via the
	 * `String`-method proxies on `StackEntry` instead.
	 */
	has(query: StackEntry): boolean;

	/**
	 * Number of entries on the stack (oldest-to-newest length).
	 */
	get size(): number;

	/**
	 * Human-readable form used in recursion error messages, logs, and the
	 * iterator above. Not memoized: caching would require an extra slot on
	 * every `StackEntry`, which costs heap even on resolves that never look
	 * at the formatted form.
	 */
	toString(): string;

	/**
	 * Iterate entries from oldest (root) to newest (tip), matching how a
	 * `Set` that was populated in insertion order would iterate. Pre-seeded
	 * legacy `Set<string>` entries come first so error-message output stays
	 * ordered oldest-to-newest.
	 * Yields each entry as its formatted `toString()` form. Plugins written
	 * against the pre-5.21 `Set<string>` shape — e.g.
	 * `[...resolveContext.stack].find(a => a.includes("module:"))` — keep
	 * working unchanged because each yielded value is a plain string with
	 * all of `String.prototype` available natively. Resolves that never
	 * iterate the stack pay nothing; iteration costs one `toString()`
	 * allocation per stack frame.
	 */
	[Symbol.iterator](): IterableIterator<string>;
}

/**
 * Layered map that supports child scopes while memoizing lookups from parent
 * scopes. Layers form a linked parent chain, so `createChild` is O(1) instead
 * of copying a layer array per scope. A layer's `Map` is only allocated on its
 * first own write, and lookup results are memoized into the nearest
 * `Map`-bearing layer of the walk — read-only layers (most block scopes) stay
 * allocation-free and share their parent's memoized entries.
 */
declare abstract class StackedMap<K, V> {
	map?: Map<K, InternalCell<V>>;
	parent?: StackedMap<K, V>;

	/**
	 * Stores a value in the current layer, preserving explicit `undefined`
	 * values with an internal marker.
	 */
	set(item: K, value: V): void;

	/**
	 * Deletes a key from the current view, either by removing it outright in the
	 * root layer or by recording a tombstone in child layers.
	 */
	delete(item: K): void;

	/**
	 * Checks whether a key exists in the current scope chain, caching any parent
	 * lookup result in the nearest `Map`-bearing layer.
	 */
	has(item: K): boolean;

	/**
	 * Returns the visible value for a key, caching parent hits and misses in the
	 * nearest `Map`-bearing layer so repeated lookups (from this layer or any
	 * sibling below that layer) answer with a single probe.
	 */
	get(item: K): Cell<V>;

	/**
	 * Returns the visible keys as an array after collapsing the stack.
	 */
	asArray(): K[];

	/**
	 * Returns the visible keys as a `Set` after collapsing the stack.
	 */
	asSet(): Set<K>;

	/**
	 * Returns visible key/value pairs using the external representation.
	 */
	asPairArray(): [K, Cell<V>][];

	/**
	 * Returns the visible contents as a plain `Map`.
	 */
	asMap(): Map<K, Cell<V>>;

	/**
	 * Returns the number of visible keys after collapsing the stack.
	 */
	get size(): number;

	/**
	 * Creates a child `StackedMap` that sees the current layers as its parent
	 * scope.
	 */
	createChild(): StackedMap<K, V>;
}

/**
 * Defines the object deserializer context type used by this module.
 * `T` is the tuple of values read in order: `read` returns the head, and `rest`
 * re-types the same context to `Tail<T>` so successive reads stay positional.
 */
declare interface StarListDeserializerContext {
	read: () => ESMExportImportedSpecifierDependency[];
	rest: ObjectDeserializerContextObjectMiddlewareObject_2<[]>;
	setCircularReference: (value: ReferenceableItem) => void;
}

/**
 * Defines the object serializer context type used by this module.
 * `T` is the tuple of values written in order; each `write` consumes the head.
 */
declare interface StarListSerializerContext {
	write: (
		value: ESMExportImportedSpecifierDependency[]
	) => ObjectSerializerContextObjectMiddlewareObject_3<[]>;
	setCircularReference: (value: ReferenceableItem) => void;
	snapshot: () => ObjectSerializerSnapshot;
	rollback: (snapshot: ObjectSerializerSnapshot) => void;
	writeLazy?: (item: ComplexSerializableType) => void;
	writeSeparate?: (
		item: ComplexSerializableType,
		obj?: LazyOptions
	) => LazyFunction<
		any,
		PrimitiveSerializableType[],
		SerializerMiddleware,
		LazyOptions
	>;
}

/**
 * Defines the startup render context type used by this module.
 */
declare interface StartupRenderContext {
	/**
	 * the chunk
	 */
	chunk: Chunk;

	/**
	 * the dependency templates
	 */
	dependencyTemplates: DependencyTemplates;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * results of code generation
	 */
	codeGenerationResults: CodeGenerationResults;

	/**
	 * rendering in strict context
	 */
	strictMode?: boolean;

	/**
	 * inlined
	 */
	inlined?: boolean;

	/**
	 * the inlined entry module is wrapped in an IIFE
	 */
	inlinedInIIFE?: boolean;

	/**
	 * whether the top-level exports declaration needs to be generated
	 */
	needExportsDeclaration?: boolean;

	/**
	 * the inlined entry's top-level declarations renamed to avoid a collision, original to new name
	 */
	renamedDeclarations?: Map<string, string>;

	/**
	 * the startup already awaited the last entry, so `__webpack_exports__` holds its settled exports
	 */
	exportsAwaited?: boolean;
}

/**
 * Describes the stat shape.
 */
declare interface StatFs {
	(
		path: PathLikeFs,
		callback: (err: null | NodeJS.ErrnoException, result?: IStatsFs) => void
	): void;
	(
		path: PathLikeFs,
		options: undefined | (StatOptionsFs & { bigint?: false }),
		callback: (err: null | NodeJS.ErrnoException, result?: IStatsFs) => void
	): void;
	(
		path: PathLikeFs,
		options: StatOptionsFs & { bigint: true },
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IBigIntStatsFs
		) => void
	): void;
	(
		path: PathLikeFs,
		options: undefined | StatOptionsFs,
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IStatsFs | IBigIntStatsFs
		) => void
	): void;
}

/**
 * Defines the stat options type used by this module.
 */
declare interface StatOptionsFs {
	bigint?: boolean;
}
declare interface StatOptionsResolver {
	/**
	 * need bigint values
	 */
	bigint?: boolean;
}
declare interface StatResolver {
	(
		path: PathLikeResolver,
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IStatsResolver
		) => void
	): void;
	(
		path: PathLikeResolver,
		options: undefined | (StatOptionsResolver & { bigint?: false }),
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IStatsResolver
		) => void
	): void;
	(
		path: PathLikeResolver,
		options: StatOptionsResolver & { bigint: true },
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IBigIntStatsResolver
		) => void
	): void;
	(
		path: PathLikeResolver,
		options: undefined | StatOptionsResolver,
		callback: (
			err: null | NodeJS.ErrnoException,
			result?: IStatsResolver | IBigIntStatsResolver
		) => void
	): void;
}

/**
 * Describes the stat sync shape.
 */
declare interface StatSync {
	(path: PathLikeFs): IStatsFs;
	(
		path: PathLikeFs,
		options?: StatSyncOptions & { bigint?: false; throwIfNoEntry?: true }
	): IStatsFs;
	(
		path: PathLikeFs,
		options: StatSyncOptions & { bigint: true; throwIfNoEntry?: true }
	): IBigIntStatsFs;
	(
		path: PathLikeFs,
		options?: StatSyncOptions & { bigint?: false; throwIfNoEntry: false }
	): undefined | IStatsFs;
	(
		path: PathLikeFs,
		options: StatSyncOptions & { bigint: true; throwIfNoEntry: false }
	): undefined | IBigIntStatsFs;
	(
		path: PathLikeFs,
		options: StatSyncOptions & { bigint: boolean; throwIfNoEntry?: true }
	): IStatsFs | IBigIntStatsFs;
	(
		path: PathLikeFs,
		options?: StatSyncOptions
	): undefined | IStatsFs | IBigIntStatsFs;
}

/**
 * Defines the stat sync options type used by this module.
 */
declare interface StatSyncOptions {
	bigint?: boolean;
	throwIfNoEntry?: boolean;
}
type Statement =
	| FunctionDeclaration
	| VariableDeclaration
	| ClassDeclaration
	| ExpressionStatement
	| BlockStatement
	| StaticBlock
	| EmptyStatement
	| DebuggerStatement
	| WithStatement
	| ReturnStatement
	| LabeledStatement
	| BreakStatement
	| ContinueStatement
	| IfStatement
	| SwitchStatement
	| ThrowStatement
	| TryStatement
	| WhileStatement
	| DoWhileStatement
	| ForStatement
	| ForInStatement
	| ForOfStatement;
type StatementPathItem =
	| ImportDeclaration
	| ExportNamedDeclaration
	| ExportAllDeclaration
	| ImportExpressionImport
	| UnaryExpression
	| ArrayExpression
	| ArrowFunctionExpression
	| AssignmentExpression
	| AwaitExpression
	| BinaryExpression
	| SimpleCallExpression
	| NewExpression
	| ChainExpression
	| ClassExpression
	| ConditionalExpression
	| FunctionExpression
	| Identifier
	| SimpleLiteral
	| RegExpLiteral
	| BigIntLiteral
	| LogicalExpression
	| MemberExpression
	| MetaProperty
	| ObjectExpression
	| SequenceExpression
	| TaggedTemplateExpression
	| TemplateLiteral
	| ThisExpression
	| UpdateExpression
	| YieldExpression
	| FunctionDeclaration
	| MaybeNamedFunctionDeclaration
	| VariableDeclaration
	| ClassDeclaration
	| MaybeNamedClassDeclaration
	| ExpressionStatement
	| BlockStatement
	| StaticBlock
	| EmptyStatement
	| DebuggerStatement
	| WithStatement
	| ReturnStatement
	| LabeledStatement
	| BreakStatement
	| ContinueStatement
	| IfStatement
	| SwitchStatement
	| ThrowStatement
	| TryStatement
	| WhileStatement
	| DoWhileStatement
	| ForStatement
	| ForInStatement
	| ForOfStatement
	| ExportDefaultDeclaration;
declare class Stats {
	/**
	 * Creates an instance of Stats.
	 */
	constructor(compilation: Compilation);
	compilation: Compilation;
	get hash(): string;
	get startTime(): number;
	get endTime(): number;

	/**
	 * Checks whether this stats has warnings.
	 */
	hasWarnings(): boolean;

	/**
	 * Checks whether this stats has errors.
	 */
	hasErrors(): boolean;

	/**
	 * Returns json output.
	 */
	toJson(
		options?:
			| boolean
			| StatsOptions
			| "none"
			| "summary"
			| "errors-only"
			| "errors-warnings"
			| "minimal"
			| "normal"
			| "detailed"
			| "verbose"
	): StatsCompilation;

	/**
	 * Returns a string representation.
	 */
	toString(
		options?:
			| boolean
			| StatsOptions
			| "none"
			| "summary"
			| "errors-only"
			| "errors-warnings"
			| "minimal"
			| "normal"
			| "detailed"
			| "verbose"
	): string;
}
type StatsAsset = KnownStatsAsset & Record<string, StatsJsonValue>;
type StatsChunk = KnownStatsChunk & Record<string, StatsJsonValue>;
type StatsChunkGroup = KnownStatsChunkGroup & Record<string, StatsJsonValue>;
type StatsChunkOrigin = KnownStatsChunkOrigin & Record<string, StatsJsonValue>;
type StatsCompilation = KnownStatsCompilation & Record<string, StatsJsonValue>;
type StatsError = KnownStatsError & Record<string, StatsJsonValue>;
declare abstract class StatsFactory {
	hooks: StatsFactoryHooks;

	/**
	 * Returns created object.
	 */
	create<FactoryData, FallbackCreatedObject>(
		type: string,
		data: FactoryData,
		baseContext: Omit<StatsFactoryContext, "type">
	): CreatedObject<FactoryData, FallbackCreatedObject>;
}
type StatsFactoryContext = KnownStatsFactoryContext & Record<string, any>;
type StatsFactoryExtractHookMap = {
	for<
		K extends
			| "module"
			| "error"
			| "asset"
			| "compilation"
			| "chunk"
			| "profile"
			| "warning"
			| "asset$visible"
			| "chunkGroup"
			| "module$visible"
			| "moduleIssuer"
			| "moduleReason"
			| "chunkOrigin"
			| "cause"
			| "moduleTraceItem"
			| "moduleTraceDependency"
	>(
		key: K
	): SyncBailHook<
		[
			KnownStatsFactoryExtract[K][0],
			KnownStatsFactoryExtract[K][1],
			StatsFactoryContext
		],
		void
	>;
	for<O = any, D = any>(
		key: string
	): SyncBailHook<[O, D, StatsFactoryContext], void>;
} & HookMap<SyncBailHook<[any, any, StatsFactoryContext], void>>;
type StatsFactoryGetItemFactoryHookMap = {
	for<
		K extends
			| "module"
			| "error"
			| "asset"
			| "compilation"
			| "chunk"
			| "profile"
			| "warning"
			| "asset$visible"
			| "chunkGroup"
			| "module$visible"
			| "moduleIssuer"
			| "moduleReason"
			| "chunkOrigin"
			| "cause"
			| "moduleTraceItem"
			| "moduleTraceDependency"
			| "compilation.children[].compilation"
	>(
		key: K
	): SyncBailHook<
		[KnownStatsFactoryItemFactories[K], StatsFactoryContext],
		void | StatsFactory
	>;
	for<I = any>(
		key: string
	): SyncBailHook<[I, StatsFactoryContext], void | StatsFactory>;
} & HookMap<SyncBailHook<[any, StatsFactoryContext], void | StatsFactory>>;
type StatsFactoryGetItemNameHookMap = {
	for<
		K extends
			| "compilation.assets[]"
			| "compilation.chunks[]"
			| "compilation.modules[]"
			| "compilation.entrypoints[]"
			| "compilation.namedChunkGroups[]"
			| "compilation.errors[]"
			| "compilation.warnings[]"
			| "compilation.hints[]"
			| "compilation.children[]"
			| "asset.related[]"
			| "error.errors[]"
			| "warning.errors[]"
			| "chunk.modules[]"
			| "chunk.rootModules[]"
			| "chunk.origins[]"
			| "module.issuerPath[]"
			| "module.reasons[]"
			| "module.modules[]"
			| "module.children[]"
			| "moduleTrace[]"
			| "moduleTraceItem.dependencies[]"
	>(
		key: K
	): SyncBailHook<
		[KnownStatsFactoryItemNames[K], StatsFactoryContext],
		string | void
	>;
	for<I = any>(
		key: string
	): SyncBailHook<[I, StatsFactoryContext], string | void>;
} & HookMap<SyncBailHook<[any, StatsFactoryContext], string | void>>;
type StatsFactoryGroupResultsHookMap = {
	for<
		K extends
			| "moduleTrace"
			| "compilation.assets"
			| "compilation.chunks"
			| "compilation.modules"
			| "compilation.entrypoints"
			| "compilation.namedChunkGroups"
			| "compilation.errors"
			| "compilation.warnings"
			| "compilation.hints"
			| "compilation.children"
			| "asset.related"
			| "error.errors"
			| "warning.errors"
			| "chunk.modules"
			| "chunk.rootModules"
			| "chunk.origins"
			| "module.issuerPath"
			| "module.reasons"
			| "module.modules"
			| "module.children"
			| "moduleTraceItem.dependencies",
		G = object
	>(
		key: K
	): SyncBailHook<
		[GroupConfig<KnownStatsFactoryResultItems[K], G>[], StatsFactoryContext],
		void
	>;
	for<I = any, G = any>(
		key: string
	): SyncBailHook<[GroupConfig<I, G>[], StatsFactoryContext], void>;
} & HookMap<SyncBailHook<[GroupConfig<any, any>[], StatsFactoryContext], void>>;

/**
 * Defines the stats factory hooks type used by this module.
 */
declare interface StatsFactoryHooks {
	extract: StatsFactoryExtractHookMap;
	filter: StatsFactoryItemFilterHookMap;
	sort: StatsFactoryItemSortHookMap;
	filterSorted: StatsFactoryItemFilterHookMap;
	groupResults: StatsFactoryGroupResultsHookMap;
	sortResults: StatsFactoryResultSortHookMap;
	filterResults: StatsFactoryResultFilterHookMap;
	merge: StatsFactoryMergeHookMap;
	result: StatsFactoryResultHookMap;
	getItemName: StatsFactoryGetItemNameHookMap;
	getItemFactory: StatsFactoryGetItemFactoryHookMap;
}
type StatsFactoryItemFilterHookMap = {
	for<
		K extends
			| "moduleTrace"
			| "compilation.assets"
			| "compilation.chunks"
			| "compilation.modules"
			| "compilation.entrypoints"
			| "compilation.namedChunkGroups"
			| "compilation.errors"
			| "compilation.warnings"
			| "compilation.hints"
			| "compilation.children"
			| "asset.related"
			| "error.errors"
			| "warning.errors"
			| "chunk.modules"
			| "chunk.rootModules"
			| "chunk.origins"
			| "module.issuerPath"
			| "module.reasons"
			| "module.modules"
			| "module.children"
			| "moduleTraceItem.dependencies"
	>(
		key: K
	): SyncBailHook<
		[KnownStatsFactoryRawItems[K], StatsFactoryContext, number, number],
		boolean | void
	>;
	for<I = any>(
		key: string
	): SyncBailHook<[I, StatsFactoryContext, number, number], boolean | void>;
} & HookMap<
	SyncBailHook<[any, StatsFactoryContext, number, number], boolean | void>
>;
type StatsFactoryItemSortHookMap = {
	for<
		K extends
			| "moduleTrace"
			| "compilation.assets"
			| "compilation.chunks"
			| "compilation.modules"
			| "compilation.entrypoints"
			| "compilation.namedChunkGroups"
			| "compilation.errors"
			| "compilation.warnings"
			| "compilation.hints"
			| "compilation.children"
			| "asset.related"
			| "error.errors"
			| "warning.errors"
			| "chunk.modules"
			| "chunk.rootModules"
			| "chunk.origins"
			| "module.issuerPath"
			| "module.reasons"
			| "module.modules"
			| "module.children"
			| "moduleTraceItem.dependencies"
	>(
		key: K
	): SyncBailHook<
		[Comparator<KnownStatsFactoryRawItems[K]>[], StatsFactoryContext],
		void
	>;
	for<I = any>(
		key: string
	): SyncBailHook<[Comparator<I>[], StatsFactoryContext], void>;
} & HookMap<SyncBailHook<[Comparator<any>[], StatsFactoryContext], void>>;
type StatsFactoryMergeHookMap = {
	for<
		K extends
			| "moduleTrace"
			| "compilation.assets"
			| "compilation.chunks"
			| "compilation.modules"
			| "compilation.entrypoints"
			| "compilation.namedChunkGroups"
			| "compilation.errors"
			| "compilation.warnings"
			| "compilation.hints"
			| "compilation.children"
			| "asset.related"
			| "error.errors"
			| "warning.errors"
			| "chunk.modules"
			| "chunk.rootModules"
			| "chunk.origins"
			| "module.issuerPath"
			| "module.reasons"
			| "module.modules"
			| "module.children"
			| "moduleTraceItem.dependencies",
		R = Record<string, KnownStatsFactoryResultItems[K]>
	>(
		key: K
	): SyncBailHook<
		[KnownStatsFactoryResultItems[K][], StatsFactoryContext],
		void | R
	>;
	for<I = any, R = any>(
		key: string
	): SyncBailHook<[I[], StatsFactoryContext], void | R>;
} & HookMap<SyncBailHook<[any[], StatsFactoryContext], any>>;
type StatsFactoryResultFilterHookMap = {
	for<
		K extends
			| "moduleTrace"
			| "compilation.assets"
			| "compilation.chunks"
			| "compilation.modules"
			| "compilation.entrypoints"
			| "compilation.namedChunkGroups"
			| "compilation.errors"
			| "compilation.warnings"
			| "compilation.hints"
			| "compilation.children"
			| "asset.related"
			| "error.errors"
			| "warning.errors"
			| "chunk.modules"
			| "chunk.rootModules"
			| "chunk.origins"
			| "module.issuerPath"
			| "module.reasons"
			| "module.modules"
			| "module.children"
			| "moduleTraceItem.dependencies"
	>(
		key: K
	): SyncBailHook<
		[KnownStatsFactoryResultItems[K], StatsFactoryContext, number, number],
		boolean | void
	>;
	for<I = any>(
		key: string
	): SyncBailHook<[I, StatsFactoryContext, number, number], boolean | void>;
} & HookMap<
	SyncBailHook<[any, StatsFactoryContext, number, number], boolean | void>
>;
type StatsFactoryResultHookMap = {
	for<
		K extends
			| "module"
			| "error"
			| "asset"
			| "compilation"
			| "chunk"
			| "moduleTrace"
			| "profile"
			| "warning"
			| "asset$visible"
			| "chunkGroup"
			| "module$visible"
			| "moduleIssuer"
			| "moduleReason"
			| "chunkOrigin"
			| "cause"
			| "moduleTraceItem"
			| "moduleTraceDependency"
			| "compilation.assets"
			| "compilation.chunks"
			| "compilation.modules"
			| "compilation.entrypoints"
			| "compilation.namedChunkGroups"
			| "compilation.errors"
			| "compilation.warnings"
			| "compilation.hints"
			| "compilation.children"
			| "asset.related"
			| "error.errors"
			| "warning.errors"
			| "chunk.modules"
			| "chunk.rootModules"
			| "chunk.origins"
			| "module.issuerPath"
			| "module.reasons"
			| "module.modules"
			| "module.children"
			| "moduleTraceItem.dependencies"
	>(
		key: K
	): SyncBailHook<
		[KnownStatsFactoryResults[K], StatsFactoryContext],
		KnownStatsFactoryResults[K]
	>;
	for<R = any>(key: string): SyncBailHook<[R, StatsFactoryContext], R>;
} & HookMap<SyncBailHook<[any, StatsFactoryContext], any>>;
type StatsFactoryResultSortHookMap = {
	for<
		K extends
			| "moduleTrace"
			| "compilation.assets"
			| "compilation.chunks"
			| "compilation.modules"
			| "compilation.entrypoints"
			| "compilation.namedChunkGroups"
			| "compilation.errors"
			| "compilation.warnings"
			| "compilation.hints"
			| "compilation.children"
			| "asset.related"
			| "error.errors"
			| "warning.errors"
			| "chunk.modules"
			| "chunk.rootModules"
			| "chunk.origins"
			| "module.issuerPath"
			| "module.reasons"
			| "module.modules"
			| "module.children"
			| "moduleTraceItem.dependencies"
	>(
		key: K
	): SyncBailHook<
		[Comparator<KnownStatsFactoryResultItems[K]>[], StatsFactoryContext],
		void
	>;
	for<I = any>(
		key: string
	): SyncBailHook<[Comparator<I>[], StatsFactoryContext], void>;
} & HookMap<SyncBailHook<[Comparator<any>[], StatsFactoryContext], void>>;
type StatsJsonValue =
	| undefined
	| null
	| string
	| number
	| boolean
	| Buffer
	| StatsJsonValue[]
	| { [index: string]: StatsJsonValue };
type StatsLogging = KnownStatsLogging & Record<string, StatsJsonValue>;
type StatsLoggingEntry = KnownStatsLoggingEntry &
	Record<string, StatsJsonValue>;
type StatsModule = KnownStatsModule & Record<string, StatsJsonValue>;
type StatsModuleIssuer = KnownStatsModuleIssuer &
	Record<string, StatsJsonValue>;
type StatsModuleReason = KnownStatsModuleReason &
	Record<string, StatsJsonValue>;
type StatsModuleTraceDependency = KnownStatsModuleTraceDependency &
	Record<string, StatsJsonValue>;
type StatsModuleTraceItem = KnownStatsModuleTraceItem &
	Record<string, StatsJsonValue>;
type StatsObject<T, F> = T extends Compilation
	? StatsCompilation
	: T extends ChunkGroupInfoWithName
		? StatsChunkGroup
		: T extends Chunk
			? StatsChunk
			: T extends OriginRecord
				? StatsChunkOrigin
				: T extends Module
					? StatsModule
					: T extends ModuleGraphConnection
						? StatsModuleReason
						: T extends Asset
							? StatsAsset
							: T extends ModuleTrace
								? StatsModuleTraceItem
								: T extends Dependency
									? StatsModuleTraceDependency
									: T extends Error
										? StatsError
										: T extends ModuleProfile
											? StatsProfile
											: F;

/**
 * Stats options object.
 */
declare interface StatsOptions {
	/**
	 * Fallback value for stats options when an option is not defined (has precedence over local webpack defaults).
	 */
	all?: boolean;

	/**
	 * Add assets information.
	 */
	assets?: boolean;

	/**
	 * Sort the assets by that field.
	 */
	assetsSort?: string | false;

	/**
	 * Space to display assets (groups will be collapsed to fit this space).
	 */
	assetsSpace?: number;

	/**
	 * Add built at time information.
	 */
	builtAt?: boolean;

	/**
	 * Add information about cached (not built) modules (deprecated: use 'cachedModules' instead).
	 * @deprecated
	 */
	cached?: boolean;

	/**
	 * Show cached assets (setting this to `false` only shows emitted files).
	 */
	cachedAssets?: boolean;

	/**
	 * Add information about cached (not built) modules.
	 */
	cachedModules?: boolean;

	/**
	 * Add children information.
	 */
	children?:
		| boolean
		| StatsOptions
		| "none"
		| "summary"
		| "errors-only"
		| "errors-warnings"
		| "minimal"
		| "normal"
		| "detailed"
		| "verbose"
		| StatsValue[];

	/**
	 * Display auxiliary assets in chunk groups.
	 */
	chunkGroupAuxiliary?: boolean;

	/**
	 * Display children of chunk groups.
	 */
	chunkGroupChildren?: boolean;

	/**
	 * Limit of assets displayed in chunk groups.
	 */
	chunkGroupMaxAssets?: number;

	/**
	 * Include the resolved `<link>` resource-hint descriptors for each entrypoint (`entrypoints[name].resourceHints`). Combines `output.resourceHints.chunks` (initial-graph modulepreload/preload/prefetch) with `output.resourceHints.assets` (URL-referenced fonts / images / …). Lets SSR frameworks inject the hints server-side without walking the chunk graph themselves; the analogue of Vite's `build.ssrManifest`.
	 * @since 5.109.0
	 */
	chunkGroupResourceHints?: boolean;

	/**
	 * Display all chunk groups with the corresponding bundles.
	 */
	chunkGroups?: boolean;

	/**
	 * Add built modules information to chunk information.
	 */
	chunkModules?: boolean;

	/**
	 * Space to display chunk modules (groups will be collapsed to fit this space, value is in number of modules/group).
	 */
	chunkModulesSpace?: number;

	/**
	 * Add the origins of chunks and chunk merging info.
	 */
	chunkOrigins?: boolean;

	/**
	 * Add information about parent, children and sibling chunks to chunk information.
	 */
	chunkRelations?: boolean;

	/**
	 * Add chunk information.
	 */
	chunks?: boolean;

	/**
	 * Sort the chunks by that field.
	 */
	chunksSort?: string | false;

	/**
	 * Enables/Disables colorful output.
	 */
	colors?:
		| boolean
		| {
				/**
				 * Custom color for bold text.
				 */
				bold?: string;
				/**
				 * Custom color for cyan text.
				 */
				cyan?: string;
				/**
				 * Custom color for green text.
				 */
				green?: string;
				/**
				 * Custom color for magenta text.
				 */
				magenta?: string;
				/**
				 * Custom color for red text.
				 */
				red?: string;
				/**
				 * Custom color for yellow text.
				 */
				yellow?: string;
		  };

	/**
	 * Context directory for request shortening.
	 */
	context?: string;

	/**
	 * Show chunk modules that are dependencies of other modules of the chunk.
	 */
	dependentModules?: boolean;

	/**
	 * Add module depth in module graph.
	 */
	depth?: boolean;

	/**
	 * Display the entry points with the corresponding bundles.
	 */
	entrypoints?: boolean | "auto";

	/**
	 * Add --env information.
	 */
	env?: boolean;

	/**
	 * Add cause to errors.
	 */
	errorCause?: boolean | "auto";

	/**
	 * Add details to errors (like resolving log).
	 */
	errorDetails?: boolean | "auto";

	/**
	 * Add nested errors to errors (like in AggregateError).
	 */
	errorErrors?: boolean | "auto";

	/**
	 * Add internal stack trace to errors.
	 */
	errorStack?: boolean;

	/**
	 * Add errors.
	 */
	errors?: boolean;

	/**
	 * Add errors count.
	 */
	errorsCount?: boolean;

	/**
	 * Space to display errors (value is in number of lines).
	 */
	errorsSpace?: number;

	/**
	 * Please use excludeModules instead.
	 */
	exclude?:
		| string
		| boolean
		| RegExp
		| ModuleFilterItemTypes[]
		| ((
				name: string,
				module: StatsModule,
				type: "module" | "chunk" | "root-of-chunk" | "nested"
		  ) => boolean);

	/**
	 * Suppress assets that match the specified filters. Filters can be Strings, RegExps or Functions.
	 */
	excludeAssets?:
		| string
		| RegExp
		| AssetFilterItemTypes[]
		| ((name: string, asset: StatsAsset) => boolean);

	/**
	 * Suppress modules that match the specified filters. Filters can be Strings, RegExps, Booleans or Functions.
	 */
	excludeModules?:
		| string
		| boolean
		| RegExp
		| ModuleFilterItemTypes[]
		| ((
				name: string,
				module: StatsModule,
				type: "module" | "chunk" | "root-of-chunk" | "nested"
		  ) => boolean);

	/**
	 * Group assets by how their are related to chunks.
	 */
	groupAssetsByChunk?: boolean;

	/**
	 * Group assets by their status (emitted, compared for emit or cached).
	 */
	groupAssetsByEmitStatus?: boolean;

	/**
	 * Group assets by their extension.
	 */
	groupAssetsByExtension?: boolean;

	/**
	 * Group assets by their asset info (immutable, development, hotModuleReplacement, etc).
	 */
	groupAssetsByInfo?: boolean;

	/**
	 * Group assets by their path.
	 */
	groupAssetsByPath?: boolean;

	/**
	 * Group modules by their attributes (errors, warnings, assets, optional, orphan, or dependent).
	 */
	groupModulesByAttributes?: boolean;

	/**
	 * Group modules by their status (cached or built and cacheable).
	 */
	groupModulesByCacheStatus?: boolean;

	/**
	 * Group modules by their extension.
	 */
	groupModulesByExtension?: boolean;

	/**
	 * Group modules by their layer.
	 */
	groupModulesByLayer?: boolean;

	/**
	 * Group modules by their path.
	 */
	groupModulesByPath?: boolean;

	/**
	 * Group modules by their type.
	 */
	groupModulesByType?: boolean;

	/**
	 * Group reasons by their origin module.
	 */
	groupReasonsByOrigin?: boolean;

	/**
	 * Add the hash of the compilation.
	 */
	hash?: boolean;

	/**
	 * Add performance hints reported with 'performance.hints: "stats"'.
	 * @since 5.110.0
	 */
	hints?: boolean;

	/**
	 * Add the number of performance hints.
	 * @since 5.110.0
	 */
	hintsCount?: boolean;

	/**
	 * Add ids.
	 */
	ids?: boolean;

	/**
	 * Add logging output.
	 */
	logging?: boolean | "none" | "verbose" | "error" | "warn" | "info" | "log";

	/**
	 * Include debug logging of specified loggers (i. e. for plugins or loaders). Filters can be Strings, RegExps or Functions.
	 */
	loggingDebug?:
		| string
		| boolean
		| RegExp
		| FilterItemTypes[]
		| ((value: string) => boolean);

	/**
	 * Add stack traces to logging output.
	 */
	loggingTrace?: boolean;

	/**
	 * Add information about assets inside modules.
	 */
	moduleAssets?: boolean;

	/**
	 * Add dependencies and origin of warnings/errors.
	 */
	moduleTrace?: boolean;

	/**
	 * Add built modules information.
	 */
	modules?: boolean;

	/**
	 * Sort the modules by that field.
	 */
	modulesSort?: string | false;

	/**
	 * Space to display modules (groups will be collapsed to fit this space, value is in number of modules/groups).
	 */
	modulesSpace?: number;

	/**
	 * Add information about modules nested in other modules (like with module concatenation).
	 */
	nestedModules?: boolean;

	/**
	 * Space to display modules nested within other modules (groups will be collapsed to fit this space, value is in number of modules/group).
	 */
	nestedModulesSpace?: number;

	/**
	 * Show reasons why optimization bailed out for modules.
	 */
	optimizationBailout?: boolean;

	/**
	 * Add information about orphan modules.
	 */
	orphanModules?: boolean;

	/**
	 * Add output path information.
	 */
	outputPath?: boolean;

	/**
	 * Add performance hint flags.
	 */
	performance?: boolean;

	/**
	 * Preset for the default values.
	 */
	preset?: string | boolean;

	/**
	 * Show exports provided by modules.
	 */
	providedExports?: boolean;

	/**
	 * Add public path information.
	 */
	publicPath?: boolean;

	/**
	 * Add information about the reasons why modules are included.
	 */
	reasons?: boolean;

	/**
	 * Space to display reasons (groups will be collapsed to fit this space).
	 */
	reasonsSpace?: number;

	/**
	 * Add information about assets that are related to other assets (like SourceMaps for assets).
	 */
	relatedAssets?: boolean;

	/**
	 * Add information about runtime modules (deprecated: use 'runtimeModules' instead).
	 * @deprecated
	 */
	runtime?: boolean;

	/**
	 * Add information about runtime modules.
	 */
	runtimeModules?: boolean;

	/**
	 * Add the source code of modules.
	 */
	source?: boolean;

	/**
	 * Add timing information.
	 */
	timings?: boolean;

	/**
	 * Show exports used by modules.
	 */
	usedExports?: boolean;

	/**
	 * Add webpack version information.
	 */
	version?: boolean;

	/**
	 * Add warnings.
	 */
	warnings?: boolean;

	/**
	 * Add warnings count.
	 */
	warningsCount?: boolean;

	/**
	 * Suppress listing warnings that match the specified filters (they will still be counted). Filters can be Strings, RegExps or Functions.
	 */
	warningsFilter?:
		| string
		| RegExp
		| WarningFilterItemTypes[]
		| ((warning: StatsError, warningString: string) => boolean);

	/**
	 * Space to display warnings (value is in number of lines).
	 */
	warningsSpace?: number;
}

/**
 * Represents the stats printer runtime component.
 */
declare interface StatsPrintHooks {
	sortElements: HookMap<SyncBailHook<[string[], StatsPrinterContext], void>>;
	printElements: HookMap<
		SyncBailHook<
			[PrintedElement[], StatsPrinterContext],
			undefined | string | void
		>
	>;
	sortItems: StatsPrinterSortItemsHookMap;
	getItemName: StatsPrinterGetItemNameHookMap;
	printItems: HookMap<
		SyncBailHook<[string[], StatsPrinterContext], undefined | string>
	>;
	print: StatsPrinterPrintHookMap;
	result: HookMap<SyncWaterfallHook<[string, StatsPrinterContext], string>>;
}
declare abstract class StatsPrinter {
	hooks: StatsPrintHooks;

	/**
	 * Returns printed result.
	 */
	print<T>(
		type: string,
		object: T,
		baseContext?: StatsPrinterContext
	): undefined | string;
}
type StatsPrinterContext = KnownStatsPrinterColorFunctions &
	KnownStatsPrinterFormatters &
	KnownStatsPrinterContext &
	Record<string, any>;
type StatsPrinterGetItemNameHookMap = {
	for<
		K extends
			| "compilation.assets[]"
			| "compilation.chunks[]"
			| "compilation.modules[]"
			| "compilation.entrypoints[]"
			| "compilation.namedChunkGroups[]"
			| "compilation.errors[]"
			| "compilation.warnings[]"
			| "compilation.hints[]"
			| "compilation.children[]"
			| "asset.related[]"
			| "error.errors[]"
			| "chunk.modules[]"
			| "chunk.origins[]"
			| "module.issuerPath[]"
			| "module.reasons[]"
			| "module.modules[]"
			| "module.children[]"
			| "moduleTraceItem.dependencies[]"
			| "compilation.logging[]"
			| "asset.children[]"
			| "moduleReason.children[]"
			| "loggingGroup.entries[]"
			| "loggingEntry.children[]"
			| "error.moduleTrace[]"
	>(
		key: K
	): SyncBailHook<
		[KnownStatsPrintItemNames[K], StatsPrinterContext],
		string | void
	>;
	for<I = any>(
		key: string
	): SyncBailHook<[I, StatsPrinterContext], string | void>;
} & HookMap<SyncBailHook<[any, StatsPrinterContext], string | void>>;
type StatsPrinterPrintHookMap = {
	for<
		K extends
			| "module"
			| "error"
			| "asset"
			| "compilation"
			| "chunk"
			| "profile"
			| "chunkGroup"
			| "moduleIssuer"
			| "moduleReason"
			| "chunkOrigin"
			| "moduleTraceItem"
			| "moduleTraceDependency"
			| "loggingGroup"
	>(
		key: K
	): SyncBailHook<
		[KnownStatsPrintObjects[K], StatsPrinterContext],
		undefined | string | void
	>;
	for<T = any>(
		key: string
	): SyncBailHook<[T, StatsPrinterContext], undefined | string | void>;
} & HookMap<
	SyncBailHook<[any, StatsPrinterContext], undefined | string | void>
>;
type StatsPrinterSortItemsHookMap = {
	for<
		K extends
			| "compilation.assets"
			| "compilation.chunks"
			| "compilation.modules"
			| "compilation.entrypoints"
			| "compilation.namedChunkGroups"
			| "compilation.errors"
			| "compilation.warnings"
			| "compilation.hints"
			| "compilation.children"
			| "asset.related"
			| "error.errors"
			| "chunk.modules"
			| "chunk.origins"
			| "module.issuerPath"
			| "module.reasons"
			| "module.modules"
			| "module.children"
			| "moduleTraceItem.dependencies"
			| "compilation.logging"
			| "asset.children"
			| "moduleReason.children"
			| "loggingGroup.entries"
			| "loggingEntry.children"
			| "error.moduleTrace"
	>(
		key: K
	): SyncBailHook<
		[KnownStatsPrintItems[K][], StatsPrinterContext],
		boolean | void
	>;
	for<I = any>(
		key: string
	): SyncBailHook<[I[], StatsPrinterContext], boolean | void>;
} & HookMap<SyncBailHook<[any[], StatsPrinterContext], boolean | void>>;
type StatsProfile = KnownStatsProfile & Record<string, StatsJsonValue>;
type StatsValue =
	| boolean
	| StatsOptions
	| "none"
	| "summary"
	| "errors-only"
	| "errors-warnings"
	| "minimal"
	| "normal"
	| "detailed"
	| "verbose";

/**
 * Defines the stream options type used by this module.
 */
declare interface StreamOptions {
	flags?: string;
	encoding?:
		| "ascii"
		| "utf8"
		| "utf-8"
		| "utf16le"
		| "utf-16le"
		| "ucs2"
		| "ucs-2"
		| "base64"
		| "base64url"
		| "latin1"
		| "binary"
		| "hex";
	fd?: number | FileHandle;
	mode?: number;
	autoClose?: boolean;
	emitClose?: boolean;
	start?: number;
	signal?: null | AbortSignal;
}

/**
 * Represents the template runtime component.
 */
declare interface Stringable {
	toString: () => string;
}
type Stylesheet = NodeSyntaxParser & { rules: RuleSyntaxParser[] };
type Supports = undefined | string;

/**
 * one of terser's `SymbolDef`s
 */
declare interface SymbolDefinition {
	[index: number]: any;
	[index: string]: any;
}
declare class SyncModuleIdsPlugin {
	/**
	 * Creates an instance of SyncModuleIdsPlugin.
	 */
	constructor(options: SyncModuleIdsPluginOptions);
	options: SyncModuleIdsPluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}

/**
 * Represents the sync module ids plugin runtime component.
 */
declare interface SyncModuleIdsPluginOptions {
	/**
	 * path to file
	 */
	path: string;

	/**
	 * context for module names
	 */
	context?: string;

	/**
	 * selector for modules
	 */
	test?: (module: Module) => boolean;

	/**
	 * operation mode (defaults to merge)
	 */
	mode?: "read" | "create" | "merge" | "update";
}
type SyncWasmModuleBuildMeta = KnownBuildMeta &
	Record<string, any> &
	KnownSyncWasmModuleBuildMeta;

/**
 * The ECMAScript parser webpack owns, ported from acorn 8.18.0 so the bundler
 * ships no parser dependency. `WebpackParser` below subclasses it and
 * overrides the hot paths.
 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/state.js
 */
declare class SyntaxParser {
	constructor(
		options: undefined | null | Partial<OptionsSyntaxParser>,
		input: string,
		startPos?: number
	);
	options: ResolvedOptionsSyntaxParser;
	sourceFile: null | string;
	keywords: RegExp;
	reservedWords: RegExp;
	reservedWordsStrict: RegExp;
	reservedWordsStrictBind: RegExp;
	input: string;
	containsEsc: boolean;
	pos: number;
	curLine: number;
	lineStart: number;
	type: TokenType;
	value: any;
	end: number;
	start: number;
	endLoc?: Position;
	startLoc?: Position;
	lastTokStartLoc?: null | Position;
	lastTokEndLoc?: null | Position;
	lastTokEnd: number;
	lastTokStart: number;
	context: TokContextLike[];
	exprAllowed: boolean;
	inModule: boolean;
	strict: boolean;
	potentialArrowAt: number;
	potentialArrowInForAwait: boolean;
	awaitIdentPos: number;
	awaitPos: number;
	yieldPos: number;
	labels: LabelLike[];
	undefinedExports: Record<string, NodeLike>;
	scopeStack: ParserScope[];
	regexpState: null | RegExpValidationState;
	privateNameStack: any[];
	get inFunction(): boolean;
	get inGenerator(): boolean;
	get inAsync(): boolean;
	get canAwait(): boolean;
	get allowReturn(): boolean;
	get allowSuper(): boolean;
	get allowDirectSuper(): boolean;
	get treatFunctionsAsVar(): number | boolean;
	get allowNewDotTarget(): boolean;
	get allowUsing(): boolean;
	get inClassStaticBlock(): boolean;

	/**
	 * Whether a directive prologue starting at `start` opens with `"use strict"`.
	 * acorn source: https://github.com/acornjs/acorn/blob/8.19.0/acorn/src/parseutil.js
	 */
	strictDirective(start: number): boolean;
	unexpected(pos?: number): never;
	initialContext(): TokContextLike[];
	enterScope(flags: number): void;
	treatFunctionsAsVarInScope(scope: { flags: number }): number | boolean;
	currentScope(): ParserScope;
	currentVarScope(): ParserScope;
	currentThisScope(): ParserScope;

	/**
	 * Report a parse error, naming where in the source it was found.
	 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/location.js
	 */
	raise(pos: number, message: string): never;
	raiseRecoverable(pos: number, message: string): never;
	curPosition(): undefined | Position;
	skipLineComment(startSkip: number): void;
	parse(): any;
	eat(type: TokenType): boolean;
	isContextual(name: string): boolean;
	eatContextual(name: string): boolean;

	/**
	 * Turn the host's stack overflow into a parse error, since a deeply nested
	 * expression is an input the caller can act on rather than a crash.
	 */
	catchStackOverflow<T>(f: () => T): T;
	expectContextual(name: string): void;
	canInsertSemicolon(): boolean;
	insertSemicolon(): undefined | boolean;
	semicolon(): void;
	afterTrailingComma(
		tokType: TokenType,
		notNext?: boolean
	): undefined | boolean;
	expect(type: TokenType): void;
	checkPatternErrors(refDestructuringErrors?: any, isAssign?: boolean): void;
	checkExpressionErrors(
		refDestructuringErrors?: any,
		andThrow?: boolean
	): undefined | boolean;
	checkYieldAwaitInDefaultParams(): void;
	isSimpleAssignTarget(expr?: any): boolean;

	/**
	 * Read statements until the end of input and wrap them in a `Program`.
	 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/statement.js
	 */
	parseTopLevel(node?: any): any;

	/**
	 * Whether a `let` here opens a lexical declaration rather than naming a
	 * variable, which needs a look-ahead past the keyword.
	 */
	isLet(context?: null | string): boolean;

	/**
	 * Whether `async` here heads a function declaration, which no line break may
	 * separate from the `function` keyword.
	 */
	isAsyncFunction(): boolean;

	/**
	 * Whether `using` (or `await using`) here heads a declaration rather than
	 * naming a variable.
	 */
	isUsingKeyword(isAwaitUsing: boolean, isFor?: boolean): boolean;
	isAwaitUsing(isFor?: boolean): boolean;
	isUsing(isFor?: boolean): boolean;

	/**
	 * Read one statement. A statement head that is only a keyword by position —
	 * `let`, `async`, `using` — is settled by the probes above.
	 */
	parseStatement(
		context?: null | string,
		topLevel?: boolean,
		exports?: any
	): any;
	parseBreakContinueStatement(node: any, keyword: string): any;
	parseDebuggerStatement(node?: any): any;
	parseDoStatement(node?: any): any;

	/**
	 * Read a `for` head, which is only known to be plain, `in` or `of` once its
	 * init part has been parsed with `in` held back as an operator.
	 */
	parseForStatement(node?: any): any;
	parseForAfterInit(node: any, init: any, awaitAt: number): any;
	parseFunctionStatement(
		node: any,
		isAsync: boolean,
		declarationPosition: boolean
	): any;
	parseIfStatement(node?: any): any;
	parseReturnStatement(node?: any): any;
	parseSwitchStatement(node?: any): any;
	parseThrowStatement(node?: any): any;
	parseCatchClauseParam(): any;
	parseTryStatement(node?: any): any;
	parseVarStatement(
		node: any,
		kind: string,
		allowMissingInitializer?: boolean
	): any;
	parseWhileStatement(node?: any): any;
	parseWithStatement(node?: any): any;
	parseEmptyStatement(node?: any): any;
	parseLabeledStatement(
		node?: any,
		maybeName?: any,
		expr?: any,
		context?: null | string
	): any;
	parseExpressionStatement(node?: any, expr?: any): any;
	parseBlock(
		createNewLexicalScope?: boolean,
		node?: any,
		exitStrict?: boolean
	): any;
	parseFor(node?: any, init?: any): any;
	parseForIn(node?: any, init?: any): any;
	parseVar(
		node: any,
		isFor: boolean,
		kind: string,
		allowMissingInitializer?: boolean
	): any;
	parseVarId(decl: any, kind: string): void;
	parseFunction(
		node: any,
		statement: number,
		allowExpressionBody?: boolean,
		isAsync?: boolean,
		forInit?: string | boolean
	): any;
	parseFunctionParams(node?: any): void;
	parseClass(node?: any, isStatement?: string | boolean): any;
	parseClassElement(constructorAllowsSuper: boolean): any;
	isClassElementNameStart(): boolean;
	parseClassElementName(element?: any): void;
	parseClassMethod(
		method: any,
		isGenerator: boolean,
		isAsync: boolean,
		allowsDirectSuper: boolean
	): any;
	parseClassField(field?: any): any;
	parseClassStaticBlock(node?: any): any;
	parseClassId(node?: any, isStatement?: string | boolean): void;
	parseClassSuper(node?: any): void;
	enterClassBody(): any;
	exitClassBody(): void;
	parseExportAllDeclaration(node?: any, exports?: any): any;
	parseExport(node?: any, exports?: any): any;
	parseExportDeclaration(node?: any): any;
	parseExportDefaultDeclaration(): any;
	checkExport(exports: any, name: any, pos: number): void;
	checkPatternExport(exports?: any, pat?: any): void;
	checkVariableExport(exports: any, declarations: any[]): void;
	shouldParseExportStatement(): boolean;
	parseExportSpecifier(exports?: any): any;
	parseExportSpecifiers(exports?: any): any[];
	parseImport(node?: any): any;
	parseImportSpecifier(): any;
	parseImportDefaultSpecifier(): any;
	parseImportNamespaceSpecifier(): any;
	parseImportSpecifiers(): any[];
	parseWithClause(): any[];
	parseImportAttribute(): any;
	parseModuleExportName(): any;
	adaptDirectivePrologue(statements: any[]): void;
	isDirectiveCandidate(statement: NodeLike & { expression?: any }): boolean;

	/**
	 * Rewrite an expression as the binding pattern it turns out to be, which is
	 * only known once the `=` or `of` after it has been read.
	 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/lval.js
	 */
	toAssignable(
		node?: any,
		isBinding?: boolean,
		refDestructuringErrors?: any
	): any;
	toAssignableList(exprList: any[], isBinding?: boolean): any[];
	parseSpread(refDestructuringErrors?: any): any;
	parseRestBinding(): any;
	parseBindingAtom(): any;
	parseBindingList(
		close: TokenType,
		allowEmpty: boolean,
		allowTrailingComma: boolean,
		allowModifiers?: boolean
	): any[];
	parseAssignableListItem(allowModifiers?: boolean): any;
	parseBindingListItem(param?: any): any;
	parseMaybeDefault(
		startPos: number,
		startLoc?: null | PositionLike,
		left?: any
	): any;

	/**
	 * Check a target that may only be an identifier or member expression, and
	 * record the binding it introduces.
	 */
	checkLValSimple(expr?: any, bindingType?: number, checkClashes?: any): void;
	checkLValPattern(expr?: any, bindingType?: number, checkClashes?: any): void;
	checkLValInnerPattern(
		expr?: any,
		bindingType?: number,
		checkClashes?: any
	): void;
	curContext(): TokContextLike;

	/**
	 * Whether a `{` here opens a block rather than an object literal, which the
	 * token before it decides.
	 */
	braceIsBlock(prevType: TokenType): boolean;

	/**
	 * Whether the enclosing function is a generator. A parse reads its scope: a
	 * method's `*` pushes no `function` context, which only the tokenizer reads.
	 */
	inGeneratorContext(): boolean;
	updateContext(prevType: TokenType): void;
	overrideContext(tokenCtx: TokContextLike): void;
	exitScope(): void;

	/**
	 * Record a name in the scope its binding belongs to, and report a name that
	 * was already declared there.
	 */
	declareName(name: string, bindingType: number, pos: number): void;
	checkLocalExport(id?: any): void;
	startNode(): any;
	startNodeAt(pos: number, loc?: null | PositionLike): any;
	finishNode(node: any, type: string): any;
	finishNodeAt(
		node: any,
		type: string,
		pos: number,
		loc?: null | PositionLike
	): any;
	copyNode(node?: any): any;

	/**
	 * Report a property name that may not be repeated: a getter or setter that
	 * clashes, and under ES5 a repeated `init` in strict mode.
	 */
	checkPropClash(
		prop?: any,
		propHash?: any,
		refDestructuringErrors?: any
	): void;

	/**
	 * Read a full expression, including the comma operator.
	 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/expression.js
	 */
	parseExpression(
		forInit?: string | boolean,
		refDestructuringErrors?: any
	): any;
	parseMaybeAssign(
		forInit?: string | boolean,
		refDestructuringErrors?: any,
		afterLeftParse?: any
	): any;
	parseMaybeConditional(
		forInit?: string | boolean,
		refDestructuringErrors?: any
	): any;
	parseExprOps(forInit?: string | boolean, refDestructuringErrors?: any): any;

	/**
	 * Read binary operators by precedence climbing, stopping where an operator
	 * binds less tightly than the caller is parsing.
	 */
	parseExprOp(
		left: any,
		leftStartPos: number,
		leftStartLoc: undefined | null | PositionLike,
		minPrec: number,
		forInit?: string | boolean
	): any;
	buildBinary(
		startPos: number,
		startLoc: undefined | null | PositionLike,
		left: any,
		right: any,
		op: any,
		logical: boolean
	): any;
	parseMaybeUnary(
		refDestructuringErrors?: any,
		sawUnary?: boolean,
		incDec?: boolean,
		forInit?: string | boolean
	): any;
	parseExprSubscripts(
		refDestructuringErrors?: any,
		forInit?: string | boolean
	): any;
	parseSubscripts(
		baseExpr: any,
		startPos: number,
		startLoc: undefined | null | PositionLike,
		noCalls: boolean,
		forInit?: string | boolean
	): any;
	shouldParseAsyncArrow(): boolean;
	parseSubscriptAsyncArrow(
		startPos: number,
		startLoc: undefined | null | PositionLike,
		exprList: any[],
		forInit?: string | boolean
	): any;
	parseSubscript(
		baseExpr: any,
		startPos: number,
		startLoc: undefined | null | PositionLike,
		noCalls: boolean,
		maybeAsyncArrow: boolean,
		optionalChained: boolean,
		forInit?: string | boolean
	): any;

	/**
	 * Read an expression that no operator binds into: a token that is an
	 * expression on its own, or one that punctuation encloses.
	 */
	parseExprAtom(
		refDestructuringErrors?: any,
		forInit?: string | boolean,
		forNew?: boolean
	): any;
	parseExprAtomDefault(): never;
	parseExprImport(forNew?: boolean): any;
	parseDynamicImport(node?: any): any;
	parseImportMeta(node?: any): any;
	parseLiteral(value?: any): any;
	parseParenExpression(): any;
	shouldParseArrow(exprList: any[]): boolean;

	/**
	 * Read a parenthesized expression, which is only known to be an arrow's
	 * parameter list once the `=>` after the closing paren is seen.
	 */
	parseParenAndDistinguishExpression(
		canBeArrow: boolean,
		forInit?: string | boolean
	): any;
	parseParenItem(item?: any): any;
	parseParenArrowList(
		startPos: number,
		startLoc: undefined | null | PositionLike,
		exprList: any[],
		forInit?: string | boolean
	): any;

	/**
	 * Read a `new` expression, whose callee takes subscripts but not a call —
	 * the argument list belongs to the `new` itself.
	 */
	parseNew(): any;
	parseTemplateElement(opts: { isTagged: boolean }): any;
	parseTemplate(opts?: { isTagged?: boolean }): any;
	isAsyncProp(prop?: any): boolean;
	parseObj(isPattern: boolean, refDestructuringErrors?: any): any;
	parseProperty(isPattern: boolean, refDestructuringErrors?: any): any;
	parseGetterSetter(prop?: any): void;
	parsePropertyValue(
		prop: any,
		isPattern: boolean,
		isGenerator: undefined | boolean,
		isAsync: undefined | boolean,
		startPos: undefined | number,
		startLoc: undefined | null | PositionLike,
		refDestructuringErrors: any,
		containsEsc: boolean
	): void;
	parsePropertyName(prop?: any): any;
	initFunction(node?: any): void;
	parseMethod(
		isGenerator?: boolean,
		isAsync?: boolean,
		allowDirectSuper?: boolean
	): any;
	parseArrowExpression(
		node: any,
		params: any[],
		isAsync: boolean,
		forInit?: string | boolean
	): any;
	parseFunctionBody(
		node?: any,
		isArrowFunction?: boolean,
		isMethod?: boolean,
		forInit?: string | boolean
	): void;

	/**
	 * The token after a function body is read in the body's scope, so a `yield`
	 * there is classified again in the enclosing one.
	 */
	rereadYieldContext(): void;
	isSimpleParamList(params: any[]): boolean;
	checkParams(node: any, allowDuplicates: boolean): void;
	parseExprList(
		close: TokenType,
		allowTrailingComma: boolean,
		allowEmpty: boolean,
		refDestructuringErrors?: any
	): any[];

	/**
	 * Report a name that the surrounding code may not use as an identifier.
	 */
	checkUnreserved(ref?: any): void;
	parseIdent(liberal?: boolean): any;
	parseIdentNode(): any;
	parsePrivateIdent(): any;
	parseYield(forInit?: string | boolean): any;
	parseAwait(forInit?: string | boolean): any;

	/**
	 * Move past the current token.
	 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/tokenize.js
	 */
	next(ignoreEscapeSequenceInKeyword?: boolean): void;
	getToken(): TokenSyntaxParserClass;
	nextToken(): void;
	readToken(code: number): void;
	fullCharCodeAt(pos: number): number;
	fullCharCodeAtPos(): number;
	skipBlockComment(): void;
	skipSpace(): void;
	finishToken(type: TokenType, value?: any): void;
	readToken_dot(): void;
	readToken_slash(): void;
	readToken_mult_modulo_exp(code: number): void;
	readToken_pipe_amp(code: number): void;
	readToken_caret(): void;
	readToken_plus_min(code: number): void;
	readToken_lt_gt(code: number): void;
	readToken_eq_excl(code: number): void;
	readToken_question(): void;
	readToken_numberSign(): void;
	getTokenFromCode(code: number): void;
	finishOp(type: TokenType, size: number): void;

	/**
	 * Check a regexp literal's flags.
	 * acorn source: https://github.com/acornjs/acorn/blob/8.18.0/acorn/src/regexp.js
	 */
	validateRegExpFlags(state: RegExpValidationState): void;

	/**
	 * Check a regexp literal's pattern, re-reading it once a group name shows
	 * that the named-capture goal symbol was the right one.
	 */
	validateRegExpPattern(state: RegExpValidationState): void;
	readRegexp(): void;

	/**
	 * Read digits in the given radix, or `null` where none were there or the
	 * count did not match what an escape asked for.
	 */
	readInt(
		radix: number,
		len?: number,
		maybeLegacyOctalNumericLiteral?: boolean
	): null | number;
	readRadixNumber(radix: number): void;
	readNumber(startsWithDot: boolean): void;
	readCodePoint(): number;
	readString(quote: number): void;
	tryReadTemplateToken(): void;
	inTemplateElement?: boolean;

	/**
	 * Report a bad escape, unless it sits in a tagged template, where the raw
	 * text is still well-formed and only the cooked value is lost.
	 */
	invalidStringToken(position: number, message: string): void;
	readTmplToken(): void;
	readInvalidTemplateToken(): void;
	readEscapedChar(inTemplate: boolean): string;
	readHexChar(len: number): number;

	/**
	 * Read an identifier's text, recording in `containsEsc` whether any of it
	 * was written as an escape — which stops it reading as a keyword.
	 */
	readWord1(): string;
	readWord(): void;
	[Symbol.iterator](): Iterator<TokenSyntaxParserClass>;
	static extend(...plugins: ((parser?: any) => any)[]): any;
	static parse(
		input: string,
		options?: Partial<OptionsSyntaxParser>
	): ParsedProgram;
	static parseExpressionAt(
		input: string,
		pos: number,
		options?: Partial<OptionsSyntaxParser>
	): ParsedExpression;
	static tokenizer(
		input: string,
		options?: Partial<OptionsSyntaxParser>
	): SyntaxParser;
}

/**
 * A JavaScript syntax tree held as a struct of arrays: a node is an integer
 * id from 1, `0` is no node, and it reads as the CSS and HTML paths do.
 */
declare class SyntaxTree {
	constructor();

	/**
	 * Forgets every node, keeping the columns for the next tree.
	 */
	reset(): void;
	add(type: number, start: number, end: number): number;

	/**
	 * Sets one field of a node: a child node, an array of them for a list,
	 * `0` or null where ESTree has null.
	 */
	set(
		node: number,
		name: string,
		value?:
			| null
			| string
			| number
			| bigint
			| boolean
			| RegExp
			| (null | number)[]
			| { cooked?: null | string; raw: string }
	): void;

	/**
	 * Writes a parsed node and everything under it, its children taking ids
	 * after it in source order; a child already written stands as its id.
	 */
	addEstree(root: NodeEstreeIndex): number;
	type(node: number): number;
	start(node: number): number;
	end(node: number): number;
	range(node: number): [number, number];
	name(node: number): string;
	value(
		node: number
	):
		| undefined
		| null
		| string
		| number
		| bigint
		| boolean
		| RegExp
		| { cooked?: null | string; raw: string };
	fieldCount(field: number, node: number): number;
	field(i: number, field: number, node: number): number;
	flag(flag: number, node: number): boolean;
	textOf(part: number, node: number): null | string;
}

/**
 * Defines the synthetic dependency location type used by this module.
 */
declare interface SyntheticDependencyLocation {
	name: string;
	index?: number;
}
declare const TOMBSTONE: unique symbol;
declare const TRANSITIVE_ONLY: unique symbol;

/**
 * Defines the tag info type used by this module.
 */
declare interface TagInfo {
	tag: symbol;
	data?:
		| object
		| TopLevelSymbol
		| ESMSettings
		| ImportSettings
		| CommonJsImportSettings
		| CompatibilitySettings;
	next?: TagInfo;
}
type Tail<T> = T extends readonly [infer _First, ...infer R] ? R : T;
declare interface TargetItemWithConnection {
	module: Module;
	connection: ModuleGraphConnection;
	export?: string[];
}
declare class Template {
	constructor();

	/**
	 * Gets function content.
	 */
	static getFunctionContent(fn: Stringable): string;

	/**
	 * Returns created identifier.
	 */
	static toIdentifier(str: string): string;

	/**
	 * Returns a commented version of string.
	 */
	static toComment(str: string): string;

	/**
	 * Returns a commented version of string.
	 */
	static toNormalComment(str: string): string;

	/**
	 * Returns normalized bundle-safe path.
	 */
	static toPath(str: string): string;

	/**
	 * Number to identifier.
	 */
	static numberToIdentifier(n: number): string;

	/**
	 * Number to identifier continuation.
	 */
	static numberToIdentifierContinuation(n: number): string;

	/**
	 * Returns converted identity.
	 */
	static indent(s: string | string[]): string;

	/**
	 * Returns new prefix string.
	 */
	static prefix(s: string | string[], prefix: string): string;

	/**
	 * Returns a single string from array.
	 */
	static asString(str: string | string[]): string;

	/**
	 * Gets modules array bounds.
	 */
	static getModulesArrayBounds(modules: WithId[]): false | [number, number];

	/**
	 * Renders chunk modules.
	 */
	static renderChunkModules(
		renderContext: ChunkRenderContextJavascriptModulesPlugin,
		modules: Module[],
		renderModule: (module: Module, renderInArray?: boolean) => null | Source,
		prefix?: string
	): null | Source;

	/**
	 * Renders runtime modules.
	 */
	static renderRuntimeModules(
		runtimeModules: RuntimeModule[],
		renderContext: RenderContextJavascriptModulesPlugin & {
			codeGenerationResults?: CodeGenerationResults;
		}
	): Source;

	/**
	 * Renders chunk runtime modules.
	 */
	static renderChunkRuntimeModules(
		runtimeModules: RuntimeModule[],
		renderContext: RenderContextJavascriptModulesPlugin
	): Source;
	static NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS: number;
	static NUMBER_OF_IDENTIFIER_START_CHARS: number;
}
type TemplatePath = string | TemplatePathFn<PathData>;

/**
 * Callback used to compute a path from contextual data. The type parameter
 * narrows the `pathData` shape when the caller knows it operates in a chunk
 * (`PathDataChunk`) or module (`PathDataModule`) context — defaults to the
 * fully-optional `PathData` for backward compatibility.
 */
declare interface TemplatePathFn<T extends PathData = PathData> {
	(pathData: T, assetInfo?: AssetInfo): string;
}

/**
 * Defines the timestamp and hash type used by this module.
 */
declare interface TimestampAndHash {
	safeTime: number;
	timestamp?: number;
	hash: string;
}

/**
 * A tokenizer context: what kind of brace, paren or template the tokenizer is
 * inside, which decides how the next `/` or `}` reads.
 */
declare class TokContext {
	constructor(
		token: string,
		isExpr: boolean,
		preserveSpace?: boolean,
		override?: (parser?: any) => void,
		generator?: boolean
	);
	token: string;
	isExpr: boolean;
	preserveSpace: boolean;
	override?: (parser?: any) => void;
	generator: boolean;
}

/**
 * a tokenizer context, as the owned tokenizer reads one
 */
declare interface TokContextLike {
	token: string;
	isExpr: boolean;
	preserveSpace?: boolean;
	override?: (parser: SyntaxParser) => void;
	generator?: boolean;
}

/**
 * Position-based view over the lexer — webpack's stand-in for the spec's
 * "normalize into a token stream" (CSS Syntax §9). It unifies the lexer and the
 * stream in one class: the `readToken` primitive lexes one token (the CSS
 * tokenizer), and the spec token-stream operations `next` / `consume` /
 * `discard` / `mark` / `restoreMark` / `discardMark` drive it from a byte
 * cursor. `parse*` entry points wrap a source string in one of these and every
 * `consume*` algorithm reads tokens from it.
 * No token buffer is kept: the cursor is a byte offset and the only state is
 * the next token (lazily tokenized once and cached until consumed). The
 * declaration-vs-qualified-rule backtracking in `consumeABlocksContents`
 * rewinds by `mark`ing / `restoreMark`ing that byte offset, which simply
 * re-tokenizes the rewound span — comment tokens are filtered here and fire
 * `onComment` once each, tracked by a monotonic high-water mark so a
 * re-tokenized span never re-fires them.
 * `SourceProcessor` is handed this class (not an instance) and threads it to
 * the grammar, so a different language can drive the same visitor machinery by
 * swapping the tokenizer — the per-token `readToken` primitive — for its own.
 */
declare class TokenStream {
	constructor(
		input: string,
		pos?: number,
		locConverter?: LocConverter,
		onComment?: (input: string, start: number, end: number) => number
	);
	input: string;
	locConverter: LocConverter;

	/**
	 * The next token (CSS Syntax §3 "next token") — the upcoming token without
	 * consuming it; the `<eof-token>` once the source is exhausted. This is the
	 * token the consume algorithms dispatch on (the spec's "process"). Tokenized
	 * from `_pos` on first use and cached until consumed; comment tokens are
	 * skipped here, firing `onComment` once each.
	 */
	next(): MutableToken;

	/**
	 * Consume a token (CSS Syntax §3 "consume a token") — return the next token
	 * and advance the cursor past it. The returned token is valid until the next
	 * `next` re-tokenizes (the reused instance is not cleared by advancing).
	 */
	consume(): MutableToken;

	/**
	 * Discard a token (CSS Syntax §3 "discard a token") — advance the cursor past
	 * the next token without returning it.
	 */
	discard(): void;

	/**
	 * Advance past the already-peeked next token, skipping the redundant `next()`
	 * re-check `consume` / `discard` pay. Precondition: the caller has just called
	 * `next()` (so `_tok` is the cached next token and `_hasNext` is true) and that
	 * token is not the `<eof-token>` — the hot "peek, decide, advance" sites where
	 * both always hold. Callers that can't guarantee a non-EOF cached token use
	 * `consume` / `discard` instead.
	 */
	advance(): void;

	/**
	 * Step over the whitespace the next token would be, without tokenizing it —
	 * for the sites that discard whitespace tokens. No-op while a token is cached.
	 */
	skipWhitespace(): void;

	/**
	 * Step over the run of selector-prelude leaves a skip-mode parse drops (CSS
	 * Syntax §5.4.3's "append to prelude", which skip mode does not do), without
	 * lexing one token each. Only valid where every leaf up to the next
	 * `BC_PRELUDE_STOP` code point is dropped whatever it is — which in
	 * `consumeAQualifiedRule` is once the two tokens the `--foo: {`
	 * disambiguation reads have both been seen. No-op while a token is cached.
	 */
	skipPreludeLeaves(): void;

	/**
	 * Mark (CSS Syntax §3 "mark") — push the current cursor position.
	 */
	mark(): void;

	/**
	 * Restore a mark (CSS Syntax §3 "restore a mark") — pop the last mark and
	 * rewind the cursor to it. The rewound span is re-tokenized on the next read;
	 * already-fired comments are not re-fired (`_commentHigh`).
	 */
	restoreMark(): void;

	/**
	 * Discard a mark (CSS Syntax §3 "discard a mark") — pop without rewinding.
	 */
	discardMark(): void;
}

/**
 * A token as `options.onToken` receives one.
 */
declare class TokenSyntaxParserClass {
	constructor(p: SyntaxParser);
	type: TokenType;
	value: any;
	start: number;
	end: number;
	loc?: ParserSourceLocation;
	range?: number[];
}
type TokenSyntaxParserObject = NodeSyntaxParser & {
	value: string;
	unescaped: string;
	numericValue: number;
	typeFlag: "number" | "id" | "integer" | "unrestricted";
	sign: "" | "+" | "-";
	unit: string;
	contentStart: number;
	contentEnd: number;
};

/**
 * A token's kind, carrying what the parser needs to know about it without
 * re-inspecting the source: whether an expression may follow, its binary
 * precedence, and how it updates the tokenizer's context.
 */
declare class TokenType {
	constructor(
		label: string,
		conf?: {
			keyword?: string;
			beforeExpr?: boolean;
			startsExpr?: boolean;
			isLoop?: boolean;
			isAssign?: boolean;
			prefix?: boolean;
			postfix?: boolean;
			binop?: number;
		}
	);
	label: string;
	keyword?: string;
	beforeExpr: boolean;
	startsExpr: boolean;
	isLoop: boolean;
	isAssign: boolean;
	prefix: boolean;
	postfix: boolean;
	binop: null | number;
	updateContext: null | ((prevType: TokenType) => void);
}
declare class TopLevelSymbol {
	/**
	 * Creates an instance of TopLevelSymbol.
	 */
	constructor(
		name: string,
		pure?: boolean | ((compilation: Compilation, module: Module) => boolean)
	);
	name: string;
	conditional: boolean;
	pureFn?: (compilation: Compilation, module: Module) => boolean;

	/**
	 * Sets the pure condition
	 */
	setPure(pure: PureCondition): void;
	isPure(compilation: Compilation, module: Module): boolean;
}

/**
 * Use a Trusted Types policy to create urls for chunks.
 */
declare interface TrustedTypes {
	/**
	 * If the call to `trustedTypes.createPolicy(...)` fails -- e.g., due to the policy name missing from the CSP `trusted-types` list, or it being a duplicate name, etc. -- controls whether to continue with loading in the hope that `require-trusted-types-for 'script'` isn't enforced yet, versus fail immediately. Default behavior is 'stop'.
	 */
	onPolicyCreationFailure?: "continue" | "stop";

	/**
	 * The name of the Trusted Types policy created by webpack to serve bundle chunks.
	 */
	policyName?: string;
}
declare interface TsconfigPathsData {
	/**
	 * tsconfig file data
	 */
	alias: CompiledAliasOptions;

	/**
	 * tsconfig file data
	 */
	modules: string[];
}
declare interface TsconfigPathsMap {
	/**
	 * main tsconfig paths data
	 */
	main: TsconfigPathsData;

	/**
	 * main tsconfig base URL (absolute path)
	 */
	mainContext: string;

	/**
	 * referenced tsconfig paths data mapped by baseUrl
	 */
	refs: { [index: string]: TsconfigPathsData };

	/**
	 * all contexts (main + refs) for quick lookup
	 */
	allContexts: { [index: string]: TsconfigPathsData };

	/**
	 * precomputed `Object.keys(allContexts)` — read-only; used on the `_selectPathsDataForContext` hot path
	 */
	contextList: string[];

	/**
	 * file dependencies
	 */
	fileDependencies: Set<string>;
}
type TupleElement =
	undefined | null | string | number | bigint | boolean | symbol | object;
declare class TypeScriptPlugin {
	constructor();
	apply(compiler: Compiler): void;
}
type TypedNode<TNode, T> = TNode & { readonly __nodeType: T };
type TypedNodePath<TPath, TNode, P extends NodeParts, T, S = unknown> = Omit<
	TPath,
	| "flag"
	| "node"
	| "state"
	| "within"
	| "field"
	| "fieldCount"
	| "fieldNamed"
	| "rangeOf"
	| "startOf"
	| "endOf"
	| "textOf"
> & {
	readonly node: TypedNode<TNode, T>;
	readonly state: S;
	within(type: P["types"]): boolean;
	field<R = TypedNode<TNode, T>, F extends number = number>(
		i: number,
		field: F & PartOf<R, P["fields"], P["field"]>,
		n?: R
	): TypedNode<TNode, P["items"][F]>;
	fieldCount<R = TypedNode<TNode, T>>(
		field: PartOf<R, P["fields"], P["field"]>,
		n?: R
	): number;
	fieldNamed<R = TypedNode<TNode, T>, F extends number = number>(
		field: F & PartOf<R, P["fields"], P["field"]>,
		name: string,
		n?: R
	): TypedNode<TNode, P["items"][F]>;
	flag<R = TypedNode<TNode, T>>(
		flag: PartOf<R, P["flags"], P["flag"]>,
		n?: R
	): boolean;
	rangeOf<R = TypedNode<TNode, T>>(
		part: PartOf<R, P["parts"], P["part"]>,
		n?: R
	): null | [number, number];
	startOf<R = TypedNode<TNode, T>>(
		part: PartOf<R, P["parts"], P["part"]>,
		n?: R
	): number;
	endOf<R = TypedNode<TNode, T>>(
		part: PartOf<R, P["parts"], P["part"]>,
		n?: R
	): number;
	textOf<R = TypedNode<TNode, T>>(
		part: PartOf<R, P["texts"], P["text"]>,
		n?: R
	): null | string;
};
declare const UNDEFINED_MARKER: unique symbol;
declare interface UnicodePropertyTables {
	/**
	 * the binary property names and general category values
	 */
	binary: RegExp;

	/**
	 * the string-valued property names
	 */
	binaryOfStrings: RegExp;

	/**
	 * each non-binary property's values, by property name
	 */
	nonBinary: Record<string, RegExp>;
}
type UnsafeCacheData = KnownUnsafeCacheData & Record<string, any>;

/**
 * Specifiers the module declares but never reads, with the presence level to
 * report them at. Allocated only for a module that has one, so the common
 * import pays a single empty slot.
 */
declare interface UnusedSpecifiers {
	exportPresenceMode: ExportPresenceMode;
	specifiers: [string[], string][];
}

/**
 * Defines the update hash context type used by this module.
 */
declare interface UpdateHashContextDependency {
	chunkGraph: ChunkGraph;
	runtime: RuntimeSpec;
	runtimeTemplate?: RuntimeTemplate;
}

/**
 * Represents the generator runtime component.
 */
declare interface UpdateHashContextGenerator<
	TModule extends NormalModule = NormalModule
> {
	/**
	 * the module
	 */
	module: TModule;
	chunkGraph: ChunkGraph;
	runtime: RuntimeSpec;
	runtimeTemplate?: RuntimeTemplate;
}

/**
 * One default-hint rule for URL-referenced assets emitted by this parser (JS `new URL(...)`, CSS `url(...)`, HTML `<img src>` / `<link href>` / `<script src>`). `test` / `include` / `exclude` match against the asset's request; omit all three to apply to every asset. Matching rules set the same fields a `webpackPrefetch` / `webpackPreload` / `webpackAs` / `webpackType` / `webpackMedia` / `webpackFetchPriority` magic comment would; explicit magic comments on the same URL still win.
 * @since 5.109.0
 */
declare interface UrlHintRule {
	/**
	 * Default `as` attribute (script / style / font / image / …).
	 */
	as?: string;

	/**
	 * A condition matcher.
	 */
	exclude?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Default fetchpriority for prefetch / preload links.
	 */
	fetchPriority?: false | "auto" | "low" | "high";

	/**
	 * A condition matcher.
	 */
	include?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Default `media` attribute (e.g. `"(min-width: 800px)"`).
	 */
	media?: string;

	/**
	 * When true, emit `<link rel="prefetch">` for matching assets without an explicit hint comment.
	 */
	prefetch?: boolean;

	/**
	 * When true, emit `<link rel="preload">` for matching assets without an explicit hint comment.
	 */
	preload?: boolean;

	/**
	 * A condition matcher.
	 */
	test?:
		| string
		| RegExp
		| ((value: string) => boolean)
		| RuleSetLogicalConditions
		| RuleSetCondition[];

	/**
	 * Default `type` attribute (MIME).
	 */
	type?: string;
}
type Usage = string | true | TopLevelSymbol;
type UsageStateType = 0 | 1 | 2 | 3 | 4;
type UsedName = string | false | string[] | InlinedUsedName;
type Value = string | number | boolean | RegExp;
type ValueCacheVersion = string | Set<string>;
declare interface Values {
	[index: string]: Value[];
}

/**
 * A binding: one name declared in one scope.
 */
declare abstract class Variable {
	name: string;
	identifiers: Identifier[];
	references: Reference[];
	scope: Scope;
}
declare class VariableInfo {
	/**
	 * Creates an instance of VariableInfo.
	 */
	constructor(
		declaredScope: ScopeInfo,
		name: undefined | string,
		flags: VariableInfoFlagsType,
		tagInfo?: TagInfo
	);
	declaredScope: ScopeInfo;
	name?: string;
	flags: VariableInfoFlagsType;
	tagInfo?: TagInfo;

	/**
	 * Checks whether this variable info is free.
	 */
	isFree(): boolean;

	/**
	 * Checks whether this variable info is tagged.
	 */
	isTagged(): boolean;
}
type VariableInfoFlagsType = 0 | 1 | 2 | 4;

/**
 * A virtual module definition.
 */
declare interface VirtualModule {
	/**
	 * The context for the virtual module. A string path. Defaults to 'auto', which will try to resolve the context from the module id.
	 */
	context?: string;

	/**
	 * The source function that provides the virtual content.
	 */
	source: (
		loaderContext: LoaderContextNormalModule<Record<string, any>, LoaderData>
	) => string | Buffer | Promise<string | Buffer>;

	/**
	 * The module type.
	 */
	type?: string;

	/**
	 * Optional version function or value for cache invalidation.
	 */
	version?: string | true | (() => string);
}
type VirtualModuleContent =
	| string
	| ((
			loaderContext: LoaderContextNormalModule<Record<string, any>, LoaderData>
	  ) => string | Buffer | Promise<string | Buffer>)
	| VirtualModule;
declare interface VirtualModules {
	[index: string]: VirtualModuleContent;
}

/**
 * Options for building virtual resources.
 */
declare interface VirtualUrlOptions {
	/**
	 * The default context for virtual modules. A string path. Defaults to 'auto', which will try to resolve the context from the module id.
	 */
	context?: string;

	/**
	 * The virtual modules configuration.
	 */
	modules: { [index: string]: VirtualModuleContent };

	/**
	 * The URL scheme to use for virtual resources.
	 */
	scheme?: string;
}
declare class VirtualUrlPlugin {
	/**
	 * Creates an instance of VirtualUrlPlugin.
	 */
	constructor(
		modules: VirtualModules,
		schemeOrOptions?: string | Omit<VirtualUrlOptions, "modules">
	);
	options: VirtualUrlOptions;
	scheme: string;
	context?: string;
	modules: NormalizedModules;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;

	/**
	 * Finds virtual module config by id.
	 */
	findVirtualModuleConfigById(id: string): VirtualModule;

	/**
	 * Get the cache version for a given version value
	 */
	getCacheVersion(version: string | true | (() => string)): undefined | string;
	static DEFAULT_SCHEME: string;
}
type VisitorBucket<TPath> =
	VisitorFn<TPath> | { enter?: VisitorFn<TPath>; exit?: VisitorFn<TPath> };

/**
 * Visitor map keyed by a numeric node-type discriminator; a bucket
 * is a function (enter-only) or `{ enter?, exit? }`.
 * A visitor receives a single `path` argument: the
 * language's AST accessor with the current position on it — `path.node`,
 * `path.parent` (null at a root) — plus `path.skipChildren()` (enter only)
 * to stop the walk descending, and every field-read method (which defaults
 * to the current node). The path is one reused object rebound before each callback:
 * it is only valid during the callback, and future per-node functionality
 * lands on it without changing any visitor signature.
 */
declare interface VisitorFn<TPath> {
	(path: TPath): void;
}
declare interface VisitorMap<TPath> {
	[index: number]: VisitorBucket<TPath>;
}
type WarningFilterItemTypes =
	string | RegExp | ((warning: StatsError, warningString: string) => boolean);

/**
 * Defines the watch file system type used by this module.
 */
declare interface WatchFileSystem {
	watch: (
		files: Iterable<string>,
		directories: Iterable<string>,
		missing: Iterable<string>,
		startTime: number,
		options: WatchOptions,
		callback: (
			err: null | Error,
			timeInfoEntries1?: Map<
				string,
				| null
				| "ignore"
				| EntryTypesIndex
				| OnlySafeTimeEntry
				| ExistenceOnlyTimeEntryTypesIndex
			>,
			timeInfoEntries2?: Map<
				string,
				| null
				| "ignore"
				| EntryTypesIndex
				| OnlySafeTimeEntry
				| ExistenceOnlyTimeEntryTypesIndex
			>,
			changes?: Set<string>,
			removals?: Set<string>
		) => void,
		callbackUndelayed: (value: string, num: number) => void
	) => Watcher;
}
type WatchIgnoreEntry = string | RegExp;
declare class WatchIgnorePlugin {
	/**
	 * Creates an instance of WatchIgnorePlugin.
	 */
	constructor(options: WatchIgnorePluginOptions);
	options: WatchIgnorePluginOptions;

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare interface WatchIgnorePluginOptions {
	paths: WatchIgnoreEntry[];
}

/**
 * Options for the watcher.
 */
declare interface 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;
}

/**
 * Defines the watcher type used by this module.
 */
declare interface Watcher {
	/**
	 * closes the watcher and all underlying file watchers
	 */
	close: () => void;

	/**
	 * closes the watcher, but keeps underlying file watchers alive until the next watch call
	 */
	pause: () => void;

	/**
	 * get current aggregated changes that have not yet send to callback
	 */
	getAggregatedChanges?: () => null | Set<string>;

	/**
	 * get current aggregated removals that have not yet send to callback
	 */
	getAggregatedRemovals?: () => null | Set<string>;

	/**
	 * get info about files
	 */
	getFileTimeInfoEntries: () => Map<
		string,
		| null
		| "ignore"
		| EntryTypesIndex
		| OnlySafeTimeEntry
		| ExistenceOnlyTimeEntryTypesIndex
	>;

	/**
	 * get info about directories
	 */
	getContextTimeInfoEntries: () => Map<
		string,
		| null
		| "ignore"
		| EntryTypesIndex
		| OnlySafeTimeEntry
		| ExistenceOnlyTimeEntryTypesIndex
	>;

	/**
	 * get info about timestamps and changes
	 */
	getInfo?: () => WatcherInfo;
}

/**
 * Defines the watcher info type used by this module.
 */
declare interface WatcherInfo {
	/**
	 * get current aggregated changes that have not yet send to callback
	 */
	changes: null | Set<string>;

	/**
	 * get current aggregated removals that have not yet send to callback
	 */
	removals: null | Set<string>;

	/**
	 * get info about files
	 */
	fileTimeInfoEntries: Map<
		string,
		| null
		| "ignore"
		| EntryTypesIndex
		| OnlySafeTimeEntry
		| ExistenceOnlyTimeEntryTypesIndex
	>;

	/**
	 * get info about directories
	 */
	contextTimeInfoEntries: Map<
		string,
		| null
		| "ignore"
		| EntryTypesIndex
		| OnlySafeTimeEntry
		| ExistenceOnlyTimeEntryTypesIndex
	>;
}
declare abstract class Watching {
	startTime: null | number;
	invalid: boolean;
	handler: CallbackWebpackFunction_2<Stats, void>;
	callbacks: ((err: null | Error, result?: void) => void)[];
	closed: boolean;
	suspended: boolean;
	blocked: boolean;
	watchOptions: WatchOptions;
	compiler: Compiler;
	running: boolean;
	watcher?: null | Watcher;
	pausedWatcher?: null | Watcher;
	lastWatcherStartTime?: number;

	/**
	 * Processes the provided file.
	 */
	watch(
		files: Iterable<string>,
		dirs: Iterable<string>,
		missing: Iterable<string>
	): void;

	/**
	 * Processes the provided error callback.
	 */
	invalidate(callback?: (err: null | Error, result?: void) => void): void;
	suspend(): void;
	resume(): void;

	/**
	 * Processes the provided error callback.
	 */
	close(callback: (err: null | Error, result?: void) => void): void;
}

/**
 * Stores values by tuple keys while using `WeakMap` for object elements so the
 * cache can release entries when those objects are collected.
 */
declare abstract class WeakTupleMap<K extends TupleElement[], V> {
	/**
	 * Stores a value at the node identified by the provided tuple key.
	 */
	set(...args: [K, ...V[]]): void;

	/**
	 * Checks whether the exact tuple key has a stored value.
	 */
	has(...args: K): boolean;

	/**
	 * Returns the value stored for the exact tuple key, if any.
	 */
	get(...args: K): undefined | V;

	/**
	 * Returns an existing value for the tuple or computes, stores, and returns a
	 * new one when the tuple is missing.
	 */
	provide(...args: [K, ...((...args: K) => V)[]]): V;

	/**
	 * Memoizes `compute(thisArg, ...args)` under the tuple key `[compute,
	 * ...args]`, computing it on a miss. Equivalent to `provide(compute, ...args,
	 * () => compute(thisArg, ...args))` but without allocating that closure (or an
	 * extra rest array) on every call — `ModuleGraph#cached` runs this on hot
	 * paths where most calls hit the cache and the closure would be pure waste.
	 */
	cachedProvide<This>(
		compute: (thisArg: This, ...args: K) => V,
		thisArg: This,
		args: K
	): V;

	/**
	 * Removes the value stored for the tuple key without pruning the trie.
	 */
	delete(...args: K): void;

	/**
	 * Clears the stored value and all strong and weak child maps from this node.
	 */
	clear(): void;
}
declare abstract class WebAssemblyParser extends Parser<BuiltSyncWasmModule> {}

/**
 * Defines the web assembly render context type used by this module.
 */
declare interface WebAssemblyRenderContext {
	/**
	 * the chunk
	 */
	chunk: Chunk;

	/**
	 * the dependency templates
	 */
	dependencyTemplates: DependencyTemplates;

	/**
	 * the runtime template
	 */
	runtimeTemplate: RuntimeTemplate;

	/**
	 * the module graph
	 */
	moduleGraph: ModuleGraph;

	/**
	 * the chunk graph
	 */
	chunkGraph: ChunkGraph;

	/**
	 * results of code generation
	 */
	codeGenerationResults: CodeGenerationResults;
}
declare class WebWorkerTemplatePlugin {
	constructor();

	/**
	 * Applies the plugin by registering its hooks on the compiler.
	 */
	apply(compiler: Compiler): void;
}
declare class WebpackError extends Error {
	/**
	 * Creates an instance of WebpackError.
	 */
	constructor(message?: string, options?: { cause?: unknown });
	[index: number]: () => string;
	details?: string;
	module?: null | Module;
	loc?: SyntheticDependencyLocation | RealDependencyLocation;
	hideStack?: boolean;
	chunk?: Chunk;
	file?: string;

	/**
	 * Serializes this instance into the provided serializer context.
	 */
	serialize(__0: ObjectSerializerContextObjectMiddlewareObject_3): void;

	/**
	 * Restores this instance from the provided deserializer context.
	 */
	deserialize(__0: ObjectDeserializerContextObjectMiddlewareObject_2): void;

	/**
	 * Whether an error is a webpack error rather than any other thrown value.
	 */
	static isWebpackError<T>(value: T): boolean;

	/**
	 * Creates a `.stack` property on `targetObject`, which when accessed returns
	 * a string representing the location in the code at which
	 * `Error.captureStackTrace()` was called.
	 * ```js
	 * const myObject = {};
	 * Error.captureStackTrace(myObject);
	 * myObject.stack;  // Similar to `new Error().stack`
	 * ```
	 * The first line of the trace will be prefixed with
	 * `${myObject.name}: ${myObject.message}`.
	 * The optional `constructorOpt` argument accepts a function. If given, all frames
	 * above `constructorOpt`, including `constructorOpt`, will be omitted from the
	 * generated stack trace.
	 * The `constructorOpt` argument is useful for hiding implementation
	 * details of error generation from the user. For instance:
	 * ```js
	 * function a() {
	 *   b();
	 * }
	 * function b() {
	 *   c();
	 * }
	 * function c() {
	 *   // Create an error without stack trace to avoid calculating the stack trace twice.
	 *   const { stackTraceLimit } = Error;
	 *   Error.stackTraceLimit = 0;
	 *   const error = new Error();
	 *   Error.stackTraceLimit = stackTraceLimit;
	 *   // Capture the stack trace above function b
	 *   Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
	 *   throw error;
	 * }
	 * a();
	 * ```
	 */
	static captureStackTrace(
		targetObject: object,
		constructorOpt?: Function
	): void;
	static prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;

	/**
	 * The `Error.stackTraceLimit` property specifies the number of stack frames
	 * collected by a stack trace (whether generated by `new Error().stack` or
	 * `Error.captureStackTrace(obj)`).
	 * The default value is `10` but may be set to any valid JavaScript number. Changes
	 * will affect any stack trace captured _after_ the value has been changed.
	 * If set to a non-number value, or set to a negative number, stack traces will
	 * not capture any frames.
	 */
	static stackTraceLimit: number;
}
declare class WebpackOptionsApply extends OptionsApply {
	constructor();
}
declare class WebpackOptionsDefaulter {
	constructor();

	/**
	 * Returns normalized webpack options.
	 */
	process(options: Configuration): WebpackOptionsNormalized;
}

/**
 * Defines the webpack options interception type used by this module.
 */
declare interface WebpackOptionsInterception {
	devtool?:
		| string
		| false
		| {
				/**
				 * Which asset type should receive this devtool value.
				 */
				type: "all" | "css" | "javascript";
				/**
				 * A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).
				 */
				use: RawDevTool;
		  }[];
}

/**
 * Normalized webpack options object.
 */
declare interface WebpackOptionsNormalized {
	/**
	 * Set the value of `require.amd` and `define.amd`. Or disable AMD support.
	 */
	amd?: false | { [index: string]: any };

	/**
	 * Report the first error as a hard error instead of tolerating it.
	 */
	bail?: boolean;

	/**
	 * Cache generated modules and chunks to improve performance for multiple incremental builds.
	 */
	cache: CacheOptionsNormalized;

	/**
	 * The base directory (absolute path!) for resolving the `entry` option. If `output.pathinfo` is set, the included pathinfo is shortened to this directory.
	 */
	context?: string;

	/**
	 * References to other configurations to depend on.
	 */
	dependencies?: string[];

	/**
	 * Options for the webpack-dev-server.
	 */
	devServer?: false | { [index: string]: any };

	/**
	 * A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).
	 */
	devtool?:
		| string
		| false
		| {
				/**
				 * Which asset type should receive this devtool value.
				 */
				type: "all" | "css" | "javascript";
				/**
				 * A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).
				 */
				use: RawDevTool;
		  }[];

	/**
	 * Enable and configure the Dotenv plugin to load environment variables from .env files.
	 */
	dotenv?: boolean | DotenvPluginOptions;

	/**
	 * The entry point(s) of the compilation.
	 */
	entry: EntryNormalized;

	/**
	 * Enables/Disables experiments (experimental features with relax SemVer compatibility).
	 */
	experiments: ExperimentsNormalized;

	/**
	 * Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on `output.libraryTarget`.
	 */
	externals: Externals;

	/**
	 * Enable presets of externals for specific targets.
	 */
	externalsPresets: ExternalsPresets;

	/**
	 * Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).
	 */
	externalsType?:
		| "import"
		| "var"
		| "module"
		| "assign"
		| "this"
		| "window"
		| "self"
		| "global"
		| "commonjs"
		| "commonjs2"
		| "commonjs-module"
		| "commonjs-static"
		| "amd"
		| "amd-require"
		| "umd"
		| "umd2"
		| "jsonp"
		| "system"
		| "amd-async"
		| "promise"
		| "module-import"
		| "script"
		| "node-commonjs"
		| "asset"
		| "asset-url"
		| "css-import"
		| "css-url";

	/**
	 * Ignore specific warnings.
	 */
	ignoreWarnings?: ((warning: Error, compilation: Compilation) => boolean)[];

	/**
	 * Options for infrastructure level logging.
	 */
	infrastructureLogging: InfrastructureLogging;

	/**
	 * Custom values available in the loader context.
	 */
	loader?: Loader;

	/**
	 * Enable production optimizations or development hints.
	 */
	mode?: "none" | "development" | "production";

	/**
	 * Options affecting the normal modules (`NormalModuleFactory`).
	 */
	module: ModuleOptionsNormalized;

	/**
	 * Name of the configuration. Used when loading multiple configurations.
	 */
	name?: string;

	/**
	 * Include polyfills or mocks for various node stuff.
	 */
	node: NodeWebpackOptions;

	/**
	 * Enables/Disables integrated optimizations.
	 */
	optimization: OptimizationNormalized;

	/**
	 * Normalized options affecting the output of the compilation. `output` options tell webpack how to write the compiled files to disk.
	 */
	output: OutputNormalized;

	/**
	 * The number of parallel processed modules in the compilation.
	 */
	parallelism?: number;

	/**
	 * Configuration for web performance recommendations.
	 */
	performance?: false | PerformanceOptions;

	/**
	 * Add additional plugins to the compiler.
	 */
	plugins: (
		((this: Compiler, compiler: Compiler) => void) | WebpackPluginInstance
	)[];

	/**
	 * Capture timing information for each module.
	 */
	profile?: boolean;

	/**
	 * Store compiler state to a json file.
	 */
	recordsInputPath?: string | false;

	/**
	 * Load compiler state from a json file.
	 */
	recordsOutputPath?: string | false;

	/**
	 * Options for the resolver.
	 */
	resolve: ResolveOptionsWebpackOptions;

	/**
	 * Options for the resolver when resolving loaders.
	 */
	resolveLoader: ResolveOptionsWebpackOptions;

	/**
	 * Options affecting how file system snapshots are created and validated.
	 */
	snapshot: SnapshotOptionsWebpackOptions;

	/**
	 * Stats options object or preset name.
	 */
	stats: StatsValue;

	/**
	 * Environment to build for. An array of environments to build for all of them when possible.
	 */
	target?: string | false | string[];

	/**
	 * Enable validation of webpack configuration. Defaults to true in development mode. In production mode, defaults to true unless futureDefaults is enabled, then defaults to false.
	 */
	validate?: boolean;

	/**
	 * Enter watch mode, which rebuilds on file change.
	 */
	watch?: boolean;

	/**
	 * Options for the watcher.
	 */
	watchOptions: WatchOptions;
}
type WebpackOptionsNormalizedWithDefaults = WebpackOptionsNormalized & {
	context: string;
} & { infrastructureLogging: InfrastructureLoggingNormalizedWithDefaults } & {
	target: NonNullable<undefined | string | false | string[]>;
} & { output: OutputNormalizedWithDefaults } & {
	optimization: OptimizationNormalizedWithDefaults;
} & {
	devtool: NonNullable<
		| undefined
		| string
		| false
		| {
				/**
				 * Which asset type should receive this devtool value.
				 */
				type: "all" | "css" | "javascript";
				/**
				 * A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).
				 */
				use: RawDevTool;
		  }[]
	>;
} & { stats: NonNullable<StatsValue> } & {
	node: NonNullable<NodeWebpackOptions>;
} & { profile: NonNullable<undefined | boolean> } & { parallelism: number } & {
	snapshot: SnapshotNormalizedWithDefaults;
} & { externalsPresets: ExternalsPresetsNormalizedWithDefaults } & {
	externalsType: NonNullable<
		| undefined
		| "import"
		| "var"
		| "module"
		| "assign"
		| "this"
		| "window"
		| "self"
		| "global"
		| "commonjs"
		| "commonjs2"
		| "commonjs-module"
		| "commonjs-static"
		| "amd"
		| "amd-require"
		| "umd"
		| "umd2"
		| "jsonp"
		| "system"
		| "amd-async"
		| "promise"
		| "module-import"
		| "script"
		| "node-commonjs"
		| "asset"
		| "asset-url"
		| "css-import"
		| "css-url"
	>;
} & { watch: NonNullable<undefined | boolean> } & {
	performance: NonNullable<undefined | false | PerformanceOptions>;
} & { recordsInputPath: NonNullable<undefined | string | false> } & {
	recordsOutputPath: NonNullable<undefined | string | false>;
} & { dotenv: NonNullable<undefined | boolean | DotenvPluginOptions> };

/**
 * webpack's parser: acorn plus lazy `range` (no `loc` at all), Set-based scopes,
 * tokenizer fast paths, import attributes and import phases (with acorn's
 * `!forNew` guard, unlike the former `acorn-import-phases` package).
 */
declare class WebpackParser extends SyntaxParser {
	constructor(
		options: OptionsSyntaxParser & {
			lazyNodes?: boolean;
			lazyComments?: CollectedComment[];
			importPhases?: boolean;
			moduleFallback?: boolean;
		},
		input: string,
		startPos?: number
	);
	[Symbol.iterator](): Iterator<TokenSyntaxParserClass>;

	/**
	 * Applies parser plugins, keeping the result typed as this parser.
	 */
	static extend(
		...plugins: ((BaseParser: typeof SyntaxParser) => typeof SyntaxParser)[]
	): typeof WebpackParser;
	static parse(
		input: string,
		options?: Partial<OptionsSyntaxParser>
	): ParsedProgram;
	static parseExpressionAt(
		input: string,
		pos: number,
		options?: Partial<OptionsSyntaxParser>
	): ParsedExpression;
	static tokenizer(
		input: string,
		options?: Partial<OptionsSyntaxParser>
	): SyntaxParser;
}

/**
 * Plugin instance.
 */
declare interface WebpackPluginInstance {
	[index: string]: any;

	/**
	 * The run point of the plugin, required method.
	 */
	apply: (compiler: Compiler) => void;
}

declare interface WebpackRequire {
	(id: string): any;
	i?: ((options: ExecuteOptions) => void)[];
	c?: Record<string, ExecuteModuleObject>;
	p?: string;
}

/**
 * Defines the with id type used by this module.
 */
declare interface WithId {
	id: string | number;
}

/**
 * Defines the with options type used by this module.
 */
declare interface WithOptions {
	/**
	 * create a resolver with additional/different options
	 */
	withOptions: (
		options: Partial<ResolveOptionsWithDependencyType>
	) => ResolverWithOptions;
}

/**
 * Describes the write file shape.
 */
declare interface WriteFile {
	(
		file: PathOrFileDescriptorFs,
		data: string | NodeJS.ArrayBufferView,
		options: WriteFileOptions,
		callback: (err: null | NodeJS.ErrnoException) => void
	): void;
	(
		file: PathOrFileDescriptorFs,
		data: string | NodeJS.ArrayBufferView,
		callback: (err: null | NodeJS.ErrnoException) => void
	): void;
}
type WriteFileOptions =
	| null
	| "ascii"
	| "utf8"
	| "utf-8"
	| "utf16le"
	| "utf-16le"
	| "ucs2"
	| "ucs-2"
	| "base64"
	| "base64url"
	| "latin1"
	| "binary"
	| "hex"
	| (ObjectEncodingOptionsFs &
			Abortable & { mode?: string | number; flag?: string; flush?: boolean });
declare interface WriteOnlySet<T> {
	add: (item: T) => void;
}
type WriteStatement =
	AssignmentExpression | UpdateExpression | ForInStatement | ForOfStatement;
type WriteStreamOptions = StreamOptions & {
	fs?: null | CreateWriteStreamFSImplementation;
	flush?: boolean;
};
declare interface _functionSyntaxParser {
	/**
	 * Decode HTML character references in a string. Handles all numeric
	 * references (with WHATWG remap of 0x00, surrogates, out-of-range, and the
	 * C1 Windows-1252 table) and the full WHATWG named character references
	 * table. Unknown or malformed references are left as literal text.
	 * When `isAttribute` is `true`, applies the WHATWG
	 * "consumed-as-part-of-an-attribute" rule: a named reference without a
	 * trailing `;` whose next character is `=` or ASCII alphanumeric is left
	 * undecoded, so e.g. `&amp=foo` stays literal in an attribute value but
	 * decodes to `&=foo` in text.
	 * With `withMap` the result also carries a boundary map from the decoded
	 * string back to raw offsets, so spans computed on the decoded text (e.g.
	 * srcset candidate URLs) can be translated to source ranges. `map[i]` is the
	 * raw offset of decoded boundary `i` (`0..text.length`); boundaries inside a
	 * reference's decoded text map to the reference start. `map` is `undefined`
	 * when nothing was decoded (then `text === str`).
	 */
	(str: string, isAttribute?: boolean): string;
	(
		str: string,
		isAttribute: undefined | boolean,
		withMap: true
	): DecodedEntitiesWithMap;
}

/**
 * Returns compiler or MultiCompiler.
 */
declare interface _functionWebpack {
	/**
	 * Returns the compiler object.
	 */
	(
		options: Configuration,
		callback: CallbackWebpackFunction_2<Stats, void>
	): null | Compiler;

	/**
	 * Returns the compiler object.
	 */
	(options: Configuration): Compiler;

	/**
	 * Returns the multi compiler object.
	 */
	(
		options: MultiConfiguration,
		callback: CallbackWebpackFunction_2<MultiStats, void>
	): null | MultiCompiler;

	/**
	 * Returns the multi compiler object.
	 */
	(options: MultiConfiguration): MultiCompiler;
}

/**
 * Defines the chunk module hash map type used by this module.
 */
declare interface chunkModuleHashMap {
	[index: number]: string;
	[index: string]: string;
}
declare function exports(
	options: Configuration,
	callback: CallbackWebpackFunction_2<Stats, void>
): null | Compiler;
declare function exports(options: Configuration): Compiler;
declare function exports(
	options: MultiConfiguration,
	callback: CallbackWebpackFunction_2<MultiStats, void>
): null | MultiCompiler;
declare function exports(options: MultiConfiguration): MultiCompiler;
declare namespace exports {
	export const webpack: _functionWebpack;
	export const defineConfig: <T extends DefineConfigInput>(config: T) => T;
	export const validate: (
		configuration: Configuration | MultiConfiguration
	) => void;
	/** Validates a value against a JSON schema. @deprecated use `config.validateSchema` — TODO in the next major release: remove */ export const validateSchema: (
		schema: Parameters<typeof validateFunction>[0],
		options: Parameters<typeof validateFunction>[1],
		validationConfiguration?: ValidationErrorConfiguration
	) => void;
	export const version: string;
	export namespace cli {
		export const getArguments: (
			schema?:
				| (JSONSchema4 & {
						absolutePath: boolean;
						instanceof: string;
						cli: {
							helper?: boolean;
							exclude?: boolean;
							description?: string;
							negatedDescription?: string;
							resetDescription?: string;
						};
				  })
				| (JSONSchema6 & {
						absolutePath: boolean;
						instanceof: string;
						cli: {
							helper?: boolean;
							exclude?: boolean;
							description?: string;
							negatedDescription?: string;
							resetDescription?: string;
						};
				  })
				| (JSONSchema7 & {
						absolutePath: boolean;
						instanceof: string;
						cli: {
							helper?: boolean;
							exclude?: boolean;
							description?: string;
							negatedDescription?: string;
							resetDescription?: string;
						};
				  })
		) => Flags;
		export const processArguments: (
			args: Flags,
			config: ObjectConfiguration,
			values: Values
		) => null | Problem[];
		export const createColors: (__0?: ColorsOptions) => Colors;
		export const isColorSupported: () => boolean;
	}
	export namespace ModuleFilenameHelpers {
		export let DEFAULT_MODULE_FILENAME_TEMPLATE: string;
		export let DEFAULT_FALLBACK_MODULE_FILENAME_TEMPLATE: string;
		export let ALL_LOADERS_RESOURCE: string;
		export let REGEXP_ALL_LOADERS_RESOURCE: RegExp;
		export let LOADERS_RESOURCE: string;
		export let REGEXP_LOADERS_RESOURCE: RegExp;
		export let RESOURCE: string;
		export let REGEXP_RESOURCE: RegExp;
		export let ABSOLUTE_RESOURCE_PATH: string;
		export let REGEXP_ABSOLUTE_RESOURCE_PATH: RegExp;
		export let RESOURCE_PATH: string;
		export let REGEXP_RESOURCE_PATH: RegExp;
		export let ALL_LOADERS: string;
		export let REGEXP_ALL_LOADERS: RegExp;
		export let LOADERS: string;
		export let REGEXP_LOADERS: RegExp;
		export let QUERY: string;
		export let REGEXP_QUERY: RegExp;
		export let ID: string;
		export let REGEXP_ID: RegExp;
		export let HASH: string;
		export let REGEXP_HASH: RegExp;
		export let NAMESPACE: string;
		export let REGEXP_NAMESPACE: RegExp;
		export let createFilename: (
			module: string | Module,
			options: {
				namespace?: string;
				moduleFilenameTemplate?:
					string | ((context: ModuleFilenameTemplateContext) => string);
			},
			__2: {
				requestShortener: RequestShortener;
				chunkGraph: ChunkGraph;
				hashFunction?: string | typeof Hash;
			}
		) => string;
		export let replaceDuplicates: <T>(
			array: T[],
			fn: (
				duplicateItem: T,
				duplicateItemIndex: number,
				numberOfTimesReplaced: number
			) => T,
			comparator?: (firstElement: T, nextElement: T) => 0 | 1 | -1
		) => T[];
		export let matchPart: (str: string, test: Matcher) => boolean;
		export let matchObject: (obj: MatchObject, str: string) => boolean;
	}
	/** The stage constants the optimization hooks are tapped at. @deprecated use `optimize.OptimizationStages` — TODO in the next major release: remove */ export namespace OptimizationStages {
		export let STAGE_ADVANCED: 10;
		export let STAGE_BASIC: -10;
		export let STAGE_DEFAULT: 0;
	}
	/** The symbols a runtime module may declare a requirement on. @deprecated use `runtime.RuntimeGlobals` — TODO in the next major release: remove */ export namespace RuntimeGlobals {
		export let amdDefine: "__webpack_require__.amdD";
		export let amdOptions: "__webpack_require__.amdO";
		export let asyncModule: "__webpack_require__.a";
		export let asyncModuleDoneSymbol: "__webpack_require__.aD";
		export let asyncModuleExportSymbol: "__webpack_require__.aE";
		export let asyncModuleGenerator: "__webpack_require__.aG";
		export let baseURI: "__webpack_require__.b";
		export let chunkCallback: "webpackChunk";
		export let chunkName: "__webpack_require__.cn";
		export let compatGetDefaultExport: "__webpack_require__.n";
		export let compileWasm: "__webpack_require__.vs";
		export let concatenationWrap: "__webpack_require__.cw";
		export let constructRequire: "__webpack_require__.cr";
		export let createFakeNamespaceObject: "__webpack_require__.t";
		export let createScript: "__webpack_require__.ts";
		export let createScriptUrl: "__webpack_require__.tu";
		export let cssInjectStyle: "__webpack_require__.is";
		export let currentRemoteGetScope: "__webpack_require__.R";
		export let deferredModuleAsyncTransitiveDependencies: "__webpack_require__.zT";
		export let deferredModuleAsyncTransitiveDependenciesSymbol: "__webpack_require__.zS";
		export let deferredModuleNamespaceCache: "__webpack_require__.zC";
		export let definePropertyGetters: "__webpack_require__.d";
		export let definePropertyGettersFromArray: "__webpack_require__.d (array)";
		export let ensureChunk: "__webpack_require__.e";
		export let ensureChunkHandlers: "__webpack_require__.f";
		export let ensureChunkIncludeEntries: "__webpack_require__.f (include entries)";
		export let entryModuleId: "__webpack_require__.s";
		export let esmIds: "__webpack_esm_ids__";
		export let esmModuleDecorator: "__webpack_require__.hmd";
		export let esmModules: "__webpack_esm_modules__";
		export let esmRuntime: "__webpack_esm_runtime__";
		export let exports: "__webpack_exports__";
		export let externalInstallChunk: "__webpack_require__.C";
		export let getChunkCssFilename: "__webpack_require__.k";
		export let getChunkScriptFilename: "__webpack_require__.u";
		export let getChunkUpdateCssFilename: "__webpack_require__.hk";
		export let getChunkUpdateScriptFilename: "__webpack_require__.hu";
		export let getCssServerStyles: "__webpack_require__.cs";
		export let getFullHash: "__webpack_require__.h";
		export let getTrustedTypesPolicy: "__webpack_require__.tt";
		export let getUpdateManifestFilename: "__webpack_require__.hmrF";
		export let getWorkletBootstrap: "__webpack_require__.wb";
		export let global: "__webpack_require__.g";
		/** esm module decorator @deprecated use `esmModuleDecorator` — TODO in the next major release: remove */ export let harmonyModuleDecorator: "__webpack_require__.hmd";
		export let hasCssModules: "has css modules";
		export let hasServerRenderedStylesheets: "has server rendered stylesheets";
		export let hasFetchPriority: "has fetch priority";
		export let hasChunkPriority: "has chunk priority";
		export let hasOwnProperty: "__webpack_require__.o";
		export let hasSealedDeferredNamespace: "has sealed deferred namespace";
		export let hasSynthesizedDeferredNamespace: "has synthesized deferred namespace";
		export let hmrDownloadManifest: "__webpack_require__.hmrM";
		export let hmrDownloadUpdateHandlers: "__webpack_require__.hmrC";
		export let hmrInvalidateModuleHandlers: "__webpack_require__.hmrI";
		export let hmrModuleData: "__webpack_require__.hmrD";
		export let hmrRuntimeStatePrefix: "__webpack_require__.hmrS";
		export let initializeSharing: "__webpack_require__.I";
		export let instantiateWasm: "__webpack_require__.v";
		export let interceptModuleExecution: "__webpack_require__.i";
		export let liveExportSetters: "__webpack_require__.lE";
		export let loadScript: "__webpack_require__.l";
		export let makeDeferredNamespaceObject: "__webpack_require__.z";
		export let makeNamespaceObject: "__webpack_require__.r";
		export let makeOptimizedDeferredNamespaceObject: "__webpack_require__.zO";
		export let module: "module";
		export let moduleCache: "__webpack_require__.c";
		export let moduleFactories: "__webpack_require__.m";
		export let moduleFactoriesAddOnly: "__webpack_require__.m (add only)";
		export let moduleId: "module.id";
		export let moduleLoaded: "module.loaded";
		export let nodeModuleDecorator: "__webpack_require__.nmd";
		export let onChunksLoaded: "__webpack_require__.O";
		export let prefetchAsset: "__webpack_require__.PA";
		export let prefetchChunk: "__webpack_require__.E";
		export let prefetchChunkHandlers: "__webpack_require__.F";
		export let preloadAsset: "__webpack_require__.LA";
		export let preloadChunk: "__webpack_require__.G";
		export let preloadChunkHandlers: "__webpack_require__.H";
		export let publicPath: "__webpack_require__.p";
		export let relativeUrl: "__webpack_require__.U";
		export let require: "__webpack_require__";
		export let requireScope: "__webpack_require__.*";
		export let returnExportsFromRuntime: "return-exports-from-runtime";
		export let runtimeId: "__webpack_require__.j";
		export let scriptNonce: "__webpack_require__.nc";
		export let setAnonymousDefaultName: "__webpack_require__.dn";
		export let shareScopeMap: "__webpack_require__.S";
		export let specNamespaceObject: "__webpack_require__.ns";
		export let startup: "__webpack_require__.x";
		export let startupAssetHints: "__webpack_require__.SAH";
		export let startupEntrypoint: "__webpack_require__.X";
		/** Describes how this item operation behaves. @deprecated creating a default startup function with the entry modules */ export let startupNoDefault: "__webpack_require__.x (no default handler)";
		export let startupOnlyAfter: "__webpack_require__.x (only after)";
		export let startupOnlyBefore: "__webpack_require__.x (only before)";
		export let system: "__webpack_require__.System";
		export let systemContext: "__webpack_require__.y";
		export let thisAsExports: "top-level-this-exports";
		export let toBinary: "__webpack_require__.tb";
		export let uncaughtErrorHandler: "__webpack_require__.oe";
		export let wasmInstances: "__webpack_require__.w";
		export let worker: "__webpack_require__.wc";
	}
	export const UsageState: Readonly<{
		Unused: 0;
		OnlyPropertiesUsed: 1;
		NoInfo: 2;
		Unknown: 3;
		Used: 4;
	}>;
	export namespace cache {
		export { Cache, MemoryCachePlugin };
	}
	export namespace config {
		export const defineConfig: <T extends DefineConfigInput>(config: T) => T;
		export const validateSchema: (
			schema: Parameters<typeof validateFunction>[0],
			options: Parameters<typeof validateFunction>[1],
			validationConfiguration?: ValidationErrorConfiguration
		) => void;
		export const getNormalizedWebpackOptions: (
			config: Configuration
		) => WebpackOptionsNormalized;
		export const applyWebpackOptionsDefaults: (
			options: WebpackOptionsNormalized,
			compilerIndex?: number
		) => ResolvedOptionsDefaults;
		export { PlatformPlugin, WebpackOptionsApply };
	}
	export namespace dependencies {
		export {
			ModuleDependency,
			ESMImportDependency,
			/** The dependency an ESM `import` declaration makes. @deprecated use `dependencies.ESMImportDependency` — TODO in the next major release: remove */ ESMImportDependency as HarmonyImportDependency,
			ConstDependency,
			NullDependency
		};
	}
	export namespace ids {
		export {
			ChunkModuleIdRangePlugin,
			NaturalModuleIdsPlugin,
			OccurrenceModuleIdsPlugin,
			NamedModuleIdsPlugin,
			DeterministicChunkIdsPlugin,
			DeterministicModuleIdsPlugin,
			NamedChunkIdsPlugin,
			OccurrenceChunkIdsPlugin,
			HashedModuleIdsPlugin
		};
	}
	export namespace javascript {
		export namespace syntax {
			export namespace parser {
				export let BIND_FUNCTION: 3;
				export let BIND_LEXICAL: 2;
				export let BIND_NONE: 0;
				export let BIND_OUTSIDE: 5;
				export let BIND_SIMPLE_CATCH: 4;
				export let BIND_VAR: 1;
				export let Field: Readonly<{
					object: 1;
					property: 2;
					callee: 3;
					arguments: 4;
					expression: 5;
					id: 6;
					init: 7;
					declarations: 8;
					key: 9;
					value: 10;
					left: 11;
					right: 12;
					body: 13;
					argument: 14;
					elements: 15;
					properties: 16;
					params: 17;
					test: 18;
					consequent: 19;
					alternate: 20;
					expressions: 21;
					quasis: 22;
					tag: 23;
					quasi: 24;
					discriminant: 25;
					cases: 26;
					update: 27;
					label: 28;
					block: 29;
					handler: 30;
					finalizer: 31;
					param: 32;
					superClass: 33;
					specifiers: 34;
					source: 35;
					attributes: 36;
					imported: 37;
					local: 38;
					options: 39;
					declaration: 40;
					exported: 41;
					meta: 42;
				}>;
				export let Flag: Readonly<{
					computed: 1;
					optional: 2;
					method: 4;
					shorthand: 8;
					delegate: 16;
					prefix: 32;
					expression: 64;
					generator: 128;
					async: 256;
					static: 512;
					tail: 1024;
					await: 2048;
				}>;
				export let SCOPE_ARROW: 16;
				export let SCOPE_ASYNC: 4;
				export let SCOPE_CLASS_FIELD_INIT: 512;
				export let SCOPE_CLASS_STATIC_BLOCK: 256;
				export let SCOPE_DIRECT_SUPER: 128;
				export let SCOPE_FUNCTION: 2;
				export let SCOPE_GENERATOR: 8;
				export let SCOPE_SIMPLE_CATCH: 32;
				export let SCOPE_SUPER: 64;
				export let SCOPE_SWITCH: 1024;
				export let SCOPE_TOP: 1;
				export let SCOPE_VAR: number;
				export let codePointToString: (code: number) => string;
				export namespace defaultOptions {
					export let ecmaVersion: null;
					export let sourceType: string;
					export let strict: boolean;
					export let onInsertedSemicolon: null;
					export let onTrailingComma: null;
					export let allowReserved: null;
					export let allowReturnOutsideFunction: boolean;
					export let allowImportExportEverywhere: boolean;
					export let allowAwaitOutsideFunction: null;
					export let allowSuperOutsideMethod: null;
					export let allowHashBang: boolean;
					export let checkPrivateFields: boolean;
					export let locations: boolean;
					export let startLocation: null;
					export let onToken: null;
					export let onTokenRead: null;
					export let onComment: null;
					export let ranges: boolean;
					export let program: null;
					export let sourceFile: null;
					export let directSourceFile: null;
					export let preserveParens: boolean;
				}
				export let functionFlags: (
					async: boolean,
					generator: boolean
				) => number;
				export let getLineInfo: (input: string, offset: number) => Position;
				export let getOptions: (
					opts?: null | Partial<OptionsSyntaxParser>
				) => ResolvedOptionsSyntaxParser;
				export let isIdentifierChar: (
					code: number,
					astral?: boolean
				) => boolean;
				export let isIdentifierStart: (
					code: number,
					astral?: boolean
				) => boolean;
				export let isLocalVariableAccess: (node?: any) => boolean;
				export let isNewLine: (code: number) => boolean;
				export let isPrivateFieldAccess: (node?: any) => boolean;
				export let keywordTypes: Record<string, TokenType>;
				export let lineBreak: RegExp;
				export let lineBreakG: RegExp;
				export let nextLineBreak: (
					code: string,
					from: number,
					end?: number
				) => number;
				export let nonASCIIwhitespace: RegExp;
				export let skipWhiteSpace: RegExp;
				export let stringToNumber: (
					str: string,
					isLegacyOctalNumericLiteral: boolean
				) => number;
				export namespace tokContexts {
					export let b_stat: TokContext;
					export let b_expr: TokContext;
					export let b_tmpl: TokContext;
					export let p_stat: TokContext;
					export let p_expr: TokContext;
					export let q_tmpl: TokContext;
					export let f_stat: TokContext;
					export let f_expr: TokContext;
					export let f_expr_gen: TokContext;
					export let f_gen: TokContext;
				}
				export namespace tokTypes {
					export let num: TokenType;
					export let regexp: TokenType;
					export let string: TokenType;
					export let name: TokenType;
					export let privateId: TokenType;
					export let eof: TokenType;
					export let bracketL: TokenType;
					export let bracketR: TokenType;
					export let braceL: TokenType;
					export let braceR: TokenType;
					export let parenL: TokenType;
					export let parenR: TokenType;
					export let comma: TokenType;
					export let semi: TokenType;
					export let colon: TokenType;
					export let dot: TokenType;
					export let question: TokenType;
					export let questionDot: TokenType;
					export let arrow: TokenType;
					export let template: TokenType;
					export let invalidTemplate: TokenType;
					export let ellipsis: TokenType;
					export let backQuote: TokenType;
					export let dollarBraceL: TokenType;
					export let eq: TokenType;
					export let assign: TokenType;
					export let incDec: TokenType;
					export let prefix: TokenType;
					export let logicalOR: TokenType;
					export let logicalAND: TokenType;
					export let bitwiseOR: TokenType;
					export let bitwiseXOR: TokenType;
					export let bitwiseAND: TokenType;
					export let equality: TokenType;
					export let relational: TokenType;
					export let bitShift: TokenType;
					export let plusMin: TokenType;
					export let modulo: TokenType;
					export let star: TokenType;
					export let slash: TokenType;
					export let starstar: TokenType;
					export let coalesce: TokenType;
				}
				export let wordsRegexp: (words: string) => RegExp;
				export let MAX_MASKED_INDEX: 30;
				export let NodeType: Readonly<{
					Identifier: 1;
					PrivateIdentifier: 2;
					Literal: 3;
					MemberExpression: 4;
					CallExpression: 5;
					NewExpression: 6;
					ExpressionStatement: 7;
					VariableDeclarator: 8;
					VariableDeclaration: 9;
					Property: 10;
					BinaryExpression: 11;
					LogicalExpression: 12;
					AssignmentExpression: 13;
					AssignmentPattern: 14;
					BlockStatement: 15;
					StaticBlock: 16;
					ClassBody: 17;
					Program: 18;
					ReturnStatement: 19;
					ThrowStatement: 20;
					AwaitExpression: 21;
					SpreadElement: 22;
					RestElement: 23;
					YieldExpression: 24;
					UnaryExpression: 25;
					UpdateExpression: 26;
					ArrayExpression: 27;
					ArrayPattern: 28;
					ObjectExpression: 29;
					ObjectPattern: 30;
					ThisExpression: 31;
					Super: 32;
					EmptyStatement: 33;
					DebuggerStatement: 34;
					FunctionExpression: 35;
					FunctionDeclaration: 36;
					ArrowFunctionExpression: 37;
					IfStatement: 38;
					ConditionalExpression: 39;
					ParenthesizedExpression: 40;
					PropertyDefinition: 41;
					MethodDefinition: 42;
					TemplateElement: 43;
					TemplateLiteral: 44;
					TaggedTemplateExpression: 45;
					SequenceExpression: 46;
					SwitchCase: 47;
					SwitchStatement: 48;
					ForStatement: 49;
					ForInStatement: 50;
					ForOfStatement: 51;
					WhileStatement: 52;
					DoWhileStatement: 53;
					WithStatement: 54;
					LabeledStatement: 55;
					BreakStatement: 56;
					ContinueStatement: 57;
					TryStatement: 58;
					CatchClause: 59;
					ClassDeclaration: 60;
					ClassExpression: 61;
					ChainExpression: 62;
					ImportDeclaration: 63;
					ImportSpecifier: 64;
					ImportDefaultSpecifier: 65;
					ImportNamespaceSpecifier: 66;
					ImportAttribute: 67;
					ImportExpression: 68;
					ExportNamedDeclaration: 69;
					ExportDefaultDeclaration: 70;
					ExportAllDeclaration: 71;
					ExportSpecifier: 72;
					MetaProperty: 73;
				}>;
				export let Part: Readonly<{
					raw: 1;
					directive: 2;
					kind: 3;
					operator: 4;
					sourceType: 5;
					phase: 6;
				}>;
				export let buildLineStarts: (source: string) => number[];
				export let collectCjsRequireSpecifiers: (source: string) => Set<string>;
				export let declaresIntoBlock: (statement?: any) => boolean;
				export let overflowFrom: (mask: number, index: number) => number[];
				export let hasOctalEscape: (raw: string) => boolean;
				export let parse: (
					input: string,
					options: ParserOptionsSyntaxParser
				) => Program;
				export let positionAt: (
					lineStarts: number[],
					offset: number
				) => SourcePosition;
				export let releaseParserCaches: () => void;
				export let toEstreeObject: (
					tree: SyntaxTree,
					node: number,
					fields?: string[]
				) =>
					| null
					| Program
					| ImportDeclaration
					| ExportNamedDeclaration
					| ExportAllDeclaration
					| ImportExpressionImport
					| UnaryExpression
					| ArrayExpression
					| ArrowFunctionExpression
					| AssignmentExpression
					| AwaitExpression
					| BinaryExpression
					| SimpleCallExpression
					| NewExpression
					| ChainExpression
					| ClassExpression
					| ConditionalExpression
					| FunctionExpression
					| Identifier
					| SimpleLiteral
					| RegExpLiteral
					| BigIntLiteral
					| LogicalExpression
					| MemberExpression
					| MetaProperty
					| ObjectExpression
					| SequenceExpression
					| TaggedTemplateExpression
					| TemplateLiteral
					| ThisExpression
					| UpdateExpression
					| YieldExpression
					| SpreadElement
					| PrivateIdentifier
					| Super
					| FunctionDeclaration
					| VariableDeclaration
					| ClassDeclaration
					| ExpressionStatement
					| BlockStatement
					| StaticBlock
					| EmptyStatement
					| DebuggerStatement
					| WithStatement
					| ReturnStatement
					| LabeledStatement
					| BreakStatement
					| ContinueStatement
					| IfStatement
					| SwitchStatement
					| ThrowStatement
					| TryStatement
					| WhileStatement
					| DoWhileStatement
					| ForStatement
					| ForInStatement
					| ForOfStatement
					| ExportDefaultDeclaration
					| MethodDefinition
					| PropertyDefinition
					| VariableDeclarator
					| Property
					| CatchClause
					| ClassBody
					| SwitchCase
					| TemplateElement
					| AssignmentProperty
					| ImportSpecifier
					| ImportDefaultSpecifier
					| ImportNamespaceSpecifier
					| ExportSpecifier
					| ObjectPattern
					| ArrayPattern
					| RestElement
					| AssignmentPattern;
				export {
					DestructuringErrors,
					Label,
					ParserNode,
					SyntaxParser as Parser,
					Position,
					ParserScope as Scope,
					ParserSourceLocation,
					TokContext,
					TokenSyntaxParserClass as Token,
					TokenType,
					BLOCK_DECLARATIONS,
					HOISTED_DECLARATIONS,
					MODULE_DECLARATIONS,
					LEGACY_ASSERT_ATTRIBUTES,
					ParserPosition,
					SyntaxTree,
					WebpackParser
				};
			}
			export namespace printer {
				export let NODE_KIND_ANCESTRY: Record<string, string[]>;
				export let plainIdentifier: (name: string) => string;
				export let load: () => Promise<Minifier>;
				export let PHASES: Phase[];
				export let FORMAT_DEFAULTS: any;
				export let IGNORED_FORMAT_OPTIONS: string[];
				export let createAst: () => Ast;
				export let createModules: () => MinifierModules;
				export let createCompressHelpers: (
					modules: MinifierModules
				) => CompressHelpers;
				export let createUnicode: () => {
					getFullChar: (str: string, pos: number) => string;
					getFullCharCode: (str: string, pos: number) => number;
					isBasicIdentifier: (str: string) => boolean;
					isIdentifierStart: (character: string) => boolean;
					isIdentifierChar: (character: string) => boolean;
					isIdentifierStartBroad: (character: string) => boolean;
					isIdentifierCharBroad: (character: string) => boolean;
					isIdentifierCharacter: (character: string) => boolean;
					isIdentifierString: (
						str: string,
						allowSurrogates?: boolean
					) => boolean;
				};
			}
			export const toEstreeObject: (
				tree: SyntaxTree,
				node: number,
				fields?: string[]
			) =>
				| null
				| Program
				| ImportDeclaration
				| ExportNamedDeclaration
				| ExportAllDeclaration
				| ImportExpressionImport
				| UnaryExpression
				| ArrayExpression
				| ArrowFunctionExpression
				| AssignmentExpression
				| AwaitExpression
				| BinaryExpression
				| SimpleCallExpression
				| NewExpression
				| ChainExpression
				| ClassExpression
				| ConditionalExpression
				| FunctionExpression
				| Identifier
				| SimpleLiteral
				| RegExpLiteral
				| BigIntLiteral
				| LogicalExpression
				| MemberExpression
				| MetaProperty
				| ObjectExpression
				| SequenceExpression
				| TaggedTemplateExpression
				| TemplateLiteral
				| ThisExpression
				| UpdateExpression
				| YieldExpression
				| SpreadElement
				| PrivateIdentifier
				| Super
				| FunctionDeclaration
				| VariableDeclaration
				| ClassDeclaration
				| ExpressionStatement
				| BlockStatement
				| StaticBlock
				| EmptyStatement
				| DebuggerStatement
				| WithStatement
				| ReturnStatement
				| LabeledStatement
				| BreakStatement
				| ContinueStatement
				| IfStatement
				| SwitchStatement
				| ThrowStatement
				| TryStatement
				| WhileStatement
				| DoWhileStatement
				| ForStatement
				| ForInStatement
				| ForOfStatement
				| ExportDefaultDeclaration
				| MethodDefinition
				| PropertyDefinition
				| VariableDeclarator
				| Property
				| CatchClause
				| ClassBody
				| SwitchCase
				| TemplateElement
				| AssignmentProperty
				| ImportSpecifier
				| ImportDefaultSpecifier
				| ImportNamespaceSpecifier
				| ExportSpecifier
				| ObjectPattern
				| ArrayPattern
				| RestElement
				| AssignmentPattern;
		}
		export {
			EnableChunkLoadingPlugin,
			JavascriptModulesPlugin,
			JavascriptParser
		};
	}
	export namespace optimize {
		export namespace OptimizationStages {
			export let STAGE_ADVANCED: 10;
			export let STAGE_BASIC: -10;
			export let STAGE_DEFAULT: 0;
		}
		export namespace InnerGraph {
			export let getDependencyUsedByExportsCondition: (
				dependency: Dependency,
				moduleGraph: ModuleGraph
			) =>
				| null
				| false
				| ((
						moduleGraphConnection: ModuleGraphConnection,
						runtime: RuntimeSpec
				  ) => ConnectionState);
			export let getInnerGraphUtils: (
				compilation: Compilation
			) => InnerGraphUtils;
			export { TopLevelSymbol, topLevelSymbolTag };
		}
		export {
			ConcatenationScope,
			AggressiveMergingPlugin,
			AggressiveSplittingPlugin,
			LimitChunkCountPlugin,
			MergeDuplicateChunksPlugin,
			MinChunkSizePlugin,
			ModuleConcatenationPlugin,
			RealContentHashPlugin,
			RuntimeChunkPlugin,
			SideEffectsFlagPlugin,
			SplitChunksPlugin
		};
	}
	export namespace runtime {
		export namespace RuntimeGlobals {
			export let amdDefine: "__webpack_require__.amdD";
			export let amdOptions: "__webpack_require__.amdO";
			export let asyncModule: "__webpack_require__.a";
			export let asyncModuleDoneSymbol: "__webpack_require__.aD";
			export let asyncModuleExportSymbol: "__webpack_require__.aE";
			export let asyncModuleGenerator: "__webpack_require__.aG";
			export let baseURI: "__webpack_require__.b";
			export let chunkCallback: "webpackChunk";
			export let chunkName: "__webpack_require__.cn";
			export let compatGetDefaultExport: "__webpack_require__.n";
			export let compileWasm: "__webpack_require__.vs";
			export let concatenationWrap: "__webpack_require__.cw";
			export let constructRequire: "__webpack_require__.cr";
			export let createFakeNamespaceObject: "__webpack_require__.t";
			export let createScript: "__webpack_require__.ts";
			export let createScriptUrl: "__webpack_require__.tu";
			export let cssInjectStyle: "__webpack_require__.is";
			export let currentRemoteGetScope: "__webpack_require__.R";
			export let deferredModuleAsyncTransitiveDependencies: "__webpack_require__.zT";
			export let deferredModuleAsyncTransitiveDependenciesSymbol: "__webpack_require__.zS";
			export let deferredModuleNamespaceCache: "__webpack_require__.zC";
			export let definePropertyGetters: "__webpack_require__.d";
			export let definePropertyGettersFromArray: "__webpack_require__.d (array)";
			export let ensureChunk: "__webpack_require__.e";
			export let ensureChunkHandlers: "__webpack_require__.f";
			export let ensureChunkIncludeEntries: "__webpack_require__.f (include entries)";
			export let entryModuleId: "__webpack_require__.s";
			export let esmIds: "__webpack_esm_ids__";
			export let esmModuleDecorator: "__webpack_require__.hmd";
			export let esmModules: "__webpack_esm_modules__";
			export let esmRuntime: "__webpack_esm_runtime__";
			export let exports: "__webpack_exports__";
			export let externalInstallChunk: "__webpack_require__.C";
			export let getChunkCssFilename: "__webpack_require__.k";
			export let getChunkScriptFilename: "__webpack_require__.u";
			export let getChunkUpdateCssFilename: "__webpack_require__.hk";
			export let getChunkUpdateScriptFilename: "__webpack_require__.hu";
			export let getCssServerStyles: "__webpack_require__.cs";
			export let getFullHash: "__webpack_require__.h";
			export let getTrustedTypesPolicy: "__webpack_require__.tt";
			export let getUpdateManifestFilename: "__webpack_require__.hmrF";
			export let getWorkletBootstrap: "__webpack_require__.wb";
			export let global: "__webpack_require__.g";
			/** esm module decorator @deprecated use `esmModuleDecorator` — TODO in the next major release: remove */ export let harmonyModuleDecorator: "__webpack_require__.hmd";
			export let hasCssModules: "has css modules";
			export let hasServerRenderedStylesheets: "has server rendered stylesheets";
			export let hasFetchPriority: "has fetch priority";
			export let hasChunkPriority: "has chunk priority";
			export let hasOwnProperty: "__webpack_require__.o";
			export let hasSealedDeferredNamespace: "has sealed deferred namespace";
			export let hasSynthesizedDeferredNamespace: "has synthesized deferred namespace";
			export let hmrDownloadManifest: "__webpack_require__.hmrM";
			export let hmrDownloadUpdateHandlers: "__webpack_require__.hmrC";
			export let hmrInvalidateModuleHandlers: "__webpack_require__.hmrI";
			export let hmrModuleData: "__webpack_require__.hmrD";
			export let hmrRuntimeStatePrefix: "__webpack_require__.hmrS";
			export let initializeSharing: "__webpack_require__.I";
			export let instantiateWasm: "__webpack_require__.v";
			export let interceptModuleExecution: "__webpack_require__.i";
			export let liveExportSetters: "__webpack_require__.lE";
			export let loadScript: "__webpack_require__.l";
			export let makeDeferredNamespaceObject: "__webpack_require__.z";
			export let makeNamespaceObject: "__webpack_require__.r";
			export let makeOptimizedDeferredNamespaceObject: "__webpack_require__.zO";
			export let module: "module";
			export let moduleCache: "__webpack_require__.c";
			export let moduleFactories: "__webpack_require__.m";
			export let moduleFactoriesAddOnly: "__webpack_require__.m (add only)";
			export let moduleId: "module.id";
			export let moduleLoaded: "module.loaded";
			export let nodeModuleDecorator: "__webpack_require__.nmd";
			export let onChunksLoaded: "__webpack_require__.O";
			export let prefetchAsset: "__webpack_require__.PA";
			export let prefetchChunk: "__webpack_require__.E";
			export let prefetchChunkHandlers: "__webpack_require__.F";
			export let preloadAsset: "__webpack_require__.LA";
			export let preloadChunk: "__webpack_require__.G";
			export let preloadChunkHandlers: "__webpack_require__.H";
			export let publicPath: "__webpack_require__.p";
			export let relativeUrl: "__webpack_require__.U";
			export let require: "__webpack_require__";
			export let requireScope: "__webpack_require__.*";
			export let returnExportsFromRuntime: "return-exports-from-runtime";
			export let runtimeId: "__webpack_require__.j";
			export let scriptNonce: "__webpack_require__.nc";
			export let setAnonymousDefaultName: "__webpack_require__.dn";
			export let shareScopeMap: "__webpack_require__.S";
			export let specNamespaceObject: "__webpack_require__.ns";
			export let startup: "__webpack_require__.x";
			export let startupAssetHints: "__webpack_require__.SAH";
			export let startupEntrypoint: "__webpack_require__.X";
			/** Describes how this item operation behaves. @deprecated creating a default startup function with the entry modules */ export let startupNoDefault: "__webpack_require__.x (no default handler)";
			export let startupOnlyAfter: "__webpack_require__.x (only after)";
			export let startupOnlyBefore: "__webpack_require__.x (only before)";
			export let system: "__webpack_require__.System";
			export let systemContext: "__webpack_require__.y";
			export let thisAsExports: "top-level-this-exports";
			export let toBinary: "__webpack_require__.tb";
			export let uncaughtErrorHandler: "__webpack_require__.oe";
			export let wasmInstances: "__webpack_require__.w";
			export let worker: "__webpack_require__.wc";
		}
		export {
			RuntimeModule,
			GetChunkFilenameRuntimeModule,
			LoadScriptRuntimeModule
		};
	}
	export namespace module {
		export { NullFactory };
	}
	export namespace template {
		export { DependencyTemplate };
	}
	export namespace prefetch {
		export {
			AutomaticPrefetchPlugin,
			PrefetchPlugin,
			ChunkPrefetchPreloadPlugin
		};
	}
	export namespace web {
		export {
			FetchCompileWasmPlugin,
			FetchCompileAsyncWasmPlugin,
			JsonpChunkLoadingRuntimeModule,
			JsonpTemplatePlugin,
			/** The runtime module that loads a chunk's CSS. @deprecated use `css.CssLoadingRuntimeModule`, the scope this module lives in — TODO in the next major release: remove */ CssLoadingRuntimeModule
		};
	}
	export namespace esm {
		export { ModuleChunkLoadingRuntimeModule };
	}
	export namespace webworker {
		export { WebWorkerTemplatePlugin };
	}
	export namespace node {
		export {
			NodeEnvironmentPlugin,
			NodeSourcePlugin,
			NodeTargetPlugin,
			NodeTemplatePlugin,
			ReadFileCompileWasmPlugin,
			ReadFileCompileAsyncWasmPlugin
		};
	}
	export namespace electron {
		export { ElectronTargetPlugin };
	}
	export namespace bun {
		export { BunTargetPlugin };
	}
	export namespace deno {
		export { DenoTargetPlugin };
	}
	export namespace wasm {
		export { AsyncWebAssemblyModulesPlugin, EnableWasmLoadingPlugin };
	}
	export namespace asset {
		export { AssetModulesPlugin };
	}
	export namespace json {
		export { JsonModulesPlugin };
	}
	export namespace css {
		export function cssMinify(
			input: { [index: string]: string | Buffer },
			sourceMap?: object,
			minimizerOptions?: {
				as?: "stylesheet" | "block-contents";
				environment?: CssEnvironment;
				charset?: false | "auto";
				convertLengthUnits?: boolean;
				convertApproximateColors?: boolean;
				dropOverriddenDeclarations?: boolean;
				extractComments?:
					| string
					| boolean
					| RegExp
					| ((comment: {
							value: string;
							line: number;
							col: number;
					  }) => boolean);
				mergeDistantRules?: boolean;
				rewriteCustomProperties?: boolean;
				unusedSymbols?: string[];
				pseudoClasses?: { [index: string]: string };
				renderEmbeddedSource?: (
					source: string,
					info: { type: string; hostType: string }
				) =>
					| undefined
					| string
					| EmbeddedSourceResult
					| Promise<undefined | string | EmbeddedSourceResult>;
				svg?: boolean;
			} & CssTransformOptions,
			extractComments?:
				| string
				| boolean
				| RegExp
				| ((...args: never[]) => boolean)
				| {
						condition?:
							string | boolean | RegExp | ((...args: never[]) => boolean);
				  }
		): Promise<{
			code: string;
			map?: SourceMap;
			extractedComments?: string[];
			warnings?: (string | Error)[];
			errors?: (string | Error)[];
		}>;
		export namespace cssMinify {
			export let supportsWorkerThreads: () => boolean;
			export let getBannerPosition: () => "end";
			export let getTypes: () => string[];
			export let getEmbeddedTypes: () => string[];
			export let filter: (name: string) => boolean;
		}
		export namespace syntax {
			export namespace parser {
				export let A: {
					state: unknown;
					get node(): NodeSyntaxParser;
					get parent(): null | NodeSyntaxParser;
					get index(): number;
					/**
					 * Stop the walk descending into the current node (enter only).
					 */
					skipChildren(): void;
					/**
					 * Stop the walk: no visitor fires after the current one returns.
					 */
					stop(): void;
					/**
					 * A top-level rule and a comment have none; a hash within a declaration is
					 * a color, elsewhere an id.
					 */
					within(type: number): boolean;
					type(n?: NodeSyntaxParser): number;
					range(n?: NodeSyntaxParser): [number, number];
					start(n?: NodeSyntaxParser): number;
					end(n?: NodeSyntaxParser): number;
					loc(n?: NodeSyntaxParser): [number, number, number, number];
					/**
					 * A node's text exactly as the input wrote it (`name` and `value` decode).
					 */
					source(n?: number | NodeSyntaxParser, end?: number): string;
					/**
					 * The token's value as CSS Syntax defines it: a number for a number,
					 * percentage or dimension, otherwise text with escapes resolved (a string
					 * without its quotes, a hash without its `#`, a `url()`'s contents, a
					 * comment's text); "" for a rule, declaration, function or block.
					 */
					value(n?: NodeSyntaxParser): string | number;
					name(n?: NodeSyntaxParser): string;
					/**
					 * A rule's children are its prelude; its block is read with {@link field }.
					 */
					childCount(n?: NodeSyntaxParser): number;
					child(i: number, n?: NodeSyntaxParser): ComponentValue;
					/**
					 * Every child as a new array, for a reader that keeps or searches them.
					 */
					children(n?: NodeSyntaxParser): ComponentValue[];
					/**
					 * A block big enough to stream hands its children to the visitors as each
					 * one finishes rather than collecting them, so its lists read as empty here.
					 */
					fieldCount(field: number, n?: NodeSyntaxParser): number;
					field(
						i: number,
						field: number,
						n?: NodeSyntaxParser
					): NodeSyntaxParser;
					fieldNamed(
						field: number,
						name: string,
						n?: NodeSyntaxParser
					): NodeSyntaxParser;
					/**
					 * `important` is a container's bit, cleared when its id is reused; a token's
					 * type flags are read off its text.
					 */
					flag(flag: number, n?: NodeSyntaxParser): boolean;
					rangeOf(part: number, n?: NodeSyntaxParser): null | [number, number];
					startOf(part: number, n?: NodeSyntaxParser): number;
					endOf(part: number, n?: NodeSyntaxParser): number;
					/**
					 * CSS has no text beyond a node's name and value, read with `name` and `value`.
					 */
					textOf(_part: number, _n?: NodeSyntaxParser): null;
				};
				export let DARK_PROPERTY: "--webpack-dark";
				export let KEYFRAMES_AT_RULE_RE: RegExp;
				export let LIGHT_PROPERTY: "--webpack-light";
				export namespace Field {
					export let prelude: 1;
					export let value: 2;
					export let declarations: 3;
					export let rules: 4;
				}
				export namespace Flag {
					export let important: 1;
					export let integer: 2;
					export let id: 4;
				}
				export namespace Part {
					export let name: 1;
					export let value: 2;
					export let block: 3;
				}
				export namespace NodeType {
					export let Ident: 1;
					export let Function: 2;
					export let AtKeyword: 3;
					export let Hash: 4;
					export let String: 5;
					export let BadString: 6;
					export let Url: 7;
					export let BadUrl: 8;
					export let Delim: 9;
					export let Number: 10;
					export let Percentage: 11;
					export let Dimension: 12;
					export let Whitespace: 13;
					export let Colon: 14;
					export let Semicolon: 15;
					export let Comma: 16;
					export let RightParenthesis: 17;
					export let RightSquareBracket: 18;
					export let RightCurlyBracket: 19;
					export let CDO: 20;
					export let CDC: 21;
					export let SimpleBlock: 22;
					export let Declaration: 23;
					export let AtRule: 24;
					export let QualifiedRule: 25;
					export let Stylesheet: 26;
					export let Comment: 27;
					export let Raw: 28;
				}
				export namespace TokenType {
					export let Comment: 1;
					export let Whitespace: 2;
					export let String: 3;
					export let BadString: 4;
					export let Hash: 5;
					export let Delim: 6;
					export let LeftParenthesis: 7;
					export let LeftSquareBracket: 8;
					export let LeftCurlyBracket: 9;
					export let RightParenthesis: 10;
					export let RightSquareBracket: 11;
					export let RightCurlyBracket: 12;
					export let Comma: 13;
					export let Colon: 14;
					export let Semicolon: 15;
					export let AtKeyword: 16;
					export let Function: 17;
					export let Url: 18;
					export let BadUrl: 19;
					export let Ident: 20;
					export let Number: 21;
					export let Percentage: 22;
					export let Dimension: 23;
					export let CDO: 24;
					export let CDC: 25;
					export let EOF: 26;
				}
				export let VENDOR_PREFIX: RegExp;
				export let containsSubstitutionFunction: (text: string) => boolean;
				export let isDigit: (cc: number) => boolean;
				export let isHexDigit: (cc: number) => boolean;
				export let isIdentCodePoint: (cc: number) => boolean;
				export let isIdentStartCodePoint: (cc: number) => boolean;
				export let isLetter: (cc: number) => boolean;
				export let asciiLowercaseName: (s: string) => string;
				export let buildSkipSet: (nodeTypes: number[]) => Uint8Array;
				export let consumeExtraNewline: (
					cc: number,
					input: string,
					pos: number
				) => number;
				export let asciiCaseInsensitiveMatch: (
					s: string,
					lit: string
				) => boolean;
				export let escapeIdentifier: MakeCacheableResult<string> & {
					bindCache: BindCache<string>;
				};
				export let escapeName: (name: string) => string;
				export let grammar: (
					input: string,
					visitors: CompiledVisitorBucket<{
						state: unknown;
						get node(): NodeSyntaxParser;
						get parent(): null | NodeSyntaxParser;
						get index(): number;
						/**
						 * Stop the walk descending into the current node (enter only).
						 */
						skipChildren(): void;
						/**
						 * Stop the walk: no visitor fires after the current one returns.
						 */
						stop(): void;
						/**
						 * A top-level rule and a comment have none; a hash within a declaration is
						 * a color, elsewhere an id.
						 */
						within(type: number): boolean;
						type(n?: NodeSyntaxParser): number;
						range(n?: NodeSyntaxParser): [number, number];
						start(n?: NodeSyntaxParser): number;
						end(n?: NodeSyntaxParser): number;
						loc(n?: NodeSyntaxParser): [number, number, number, number];
						/**
						 * A node's text exactly as the input wrote it (`name` and `value` decode).
						 */
						source(n?: number | NodeSyntaxParser, end?: number): string;
						/**
						 * The token's value as CSS Syntax defines it: a number for a number,
						 * percentage or dimension, otherwise text with escapes resolved (a string
						 * without its quotes, a hash without its `#`, a `url()`'s contents, a
						 * comment's text); "" for a rule, declaration, function or block.
						 */
						value(n?: NodeSyntaxParser): string | number;
						name(n?: NodeSyntaxParser): string;
						/**
						 * A rule's children are its prelude; its block is read with {@link field }.
						 */
						childCount(n?: NodeSyntaxParser): number;
						child(i: number, n?: NodeSyntaxParser): ComponentValue;
						/**
						 * Every child as a new array, for a reader that keeps or searches them.
						 */
						children(n?: NodeSyntaxParser): ComponentValue[];
						/**
						 * A block big enough to stream hands its children to the visitors as each
						 * one finishes rather than collecting them, so its lists read as empty here.
						 */
						fieldCount(field: number, n?: NodeSyntaxParser): number;
						field(
							i: number,
							field: number,
							n?: NodeSyntaxParser
						): NodeSyntaxParser;
						fieldNamed(
							field: number,
							name: string,
							n?: NodeSyntaxParser
						): NodeSyntaxParser;
						/**
						 * `important` is a container's bit, cleared when its id is reused; a token's
						 * type flags are read off its text.
						 */
						flag(flag: number, n?: NodeSyntaxParser): boolean;
						rangeOf(
							part: number,
							n?: NodeSyntaxParser
						): null | [number, number];
						startOf(part: number, n?: NodeSyntaxParser): number;
						endOf(part: number, n?: NodeSyntaxParser): number;
						/**
						 * CSS has no text beyond a node's name and value, read with `name` and `value`.
						 */
						textOf(_part: number, _n?: NodeSyntaxParser): null;
					}>[],
					writer:
						| undefined
						| PrintContext<
								{
									state: unknown;
									get node(): NodeSyntaxParser;
									get parent(): null | NodeSyntaxParser;
									get index(): number;
									/**
									 * Stop the walk descending into the current node (enter only).
									 */
									skipChildren(): void;
									/**
									 * Stop the walk: no visitor fires after the current one returns.
									 */
									stop(): void;
									/**
									 * A top-level rule and a comment have none; a hash within a declaration is
									 * a color, elsewhere an id.
									 */
									within(type: number): boolean;
									type(n?: NodeSyntaxParser): number;
									range(n?: NodeSyntaxParser): [number, number];
									start(n?: NodeSyntaxParser): number;
									end(n?: NodeSyntaxParser): number;
									loc(n?: NodeSyntaxParser): [number, number, number, number];
									/**
									 * A node's text exactly as the input wrote it (`name` and `value` decode).
									 */
									source(n?: number | NodeSyntaxParser, end?: number): string;
									/**
									 * The token's value as CSS Syntax defines it: a number for a number,
									 * percentage or dimension, otherwise text with escapes resolved (a string
									 * without its quotes, a hash without its `#`, a `url()`'s contents, a
									 * comment's text); "" for a rule, declaration, function or block.
									 */
									value(n?: NodeSyntaxParser): string | number;
									name(n?: NodeSyntaxParser): string;
									/**
									 * A rule's children are its prelude; its block is read with {@link field }.
									 */
									childCount(n?: NodeSyntaxParser): number;
									child(i: number, n?: NodeSyntaxParser): ComponentValue;
									/**
									 * Every child as a new array, for a reader that keeps or searches them.
									 */
									children(n?: NodeSyntaxParser): ComponentValue[];
									/**
									 * A block big enough to stream hands its children to the visitors as each
									 * one finishes rather than collecting them, so its lists read as empty here.
									 */
									fieldCount(field: number, n?: NodeSyntaxParser): number;
									field(
										i: number,
										field: number,
										n?: NodeSyntaxParser
									): NodeSyntaxParser;
									fieldNamed(
										field: number,
										name: string,
										n?: NodeSyntaxParser
									): NodeSyntaxParser;
									/**
									 * `important` is a container's bit, cleared when its id is reused; a token's
									 * type flags are read off its text.
									 */
									flag(flag: number, n?: NodeSyntaxParser): boolean;
									rangeOf(
										part: number,
										n?: NodeSyntaxParser
									): null | [number, number];
									startOf(part: number, n?: NodeSyntaxParser): number;
									endOf(part: number, n?: NodeSyntaxParser): number;
									/**
									 * CSS has no text beyond a node's name and value, read with `name` and `value`.
									 */
									textOf(_part: number, _n?: NodeSyntaxParser): null;
								},
								NodeSyntaxParser,
								CssPrintOptions
						  >,
					options: CssProcessOptions
				) => void;
				export let isDashedIdentifier: (identifier: string) => boolean;
				export let isSimpleIdentifier: (value: string) => boolean;
				export let isAsciiWhitespace: (cc: number) => boolean;
				export let normalizeUrl: (str: string, isString: boolean) => string;
				export let parseABlocksContents: (
					input: string | TokenStream,
					pos?: number,
					options?: ParseOptionsSyntaxParser
				) => { decls: DeclarationSyntaxParser[]; rules: RuleSyntaxParser[] };
				export let parseACommaSeparatedListOfComponentValues: (
					input: string | TokenStream,
					pos?: number,
					options?: ParseOptionsSyntaxParser
				) => ComponentValue[][];
				export let parseAComponentValue: (
					input: string | TokenStream,
					pos?: number,
					options?: ParseOptionsSyntaxParser
				) => undefined | TokenSyntaxParserObject | FunctionNode | SimpleBlock;
				export let parseADeclaration: (
					input: string | TokenStream,
					pos?: number,
					options?: ParseOptionsSyntaxParser
				) => undefined | DeclarationSyntaxParser;
				export let parseAListOfComponentValues: (
					input: string | TokenStream,
					pos?: number,
					options?: ParseOptionsSyntaxParser
				) => ComponentValue[];
				export let parseARule: (
					input: string | TokenStream,
					pos?: number,
					options?: ParseOptionsSyntaxParser
				) => undefined | AtRule | QualifiedRule;
				export let parseAStylesheet: (
					input: string | TokenStream,
					pos?: number,
					options?: ParseOptionsSyntaxParser
				) => Stylesheet;
				export let parseAStylesheetsContents: (
					input: string | TokenStream,
					pos?: number,
					options?: ParseOptionsSyntaxParser
				) => RuleSyntaxParser[];
				export let pickTransforms: (
					options: CssTransformOptions
				) => undefined | CssTransformOptions;
				export let rangeEquals: (
					input: string,
					start: number,
					end: number,
					lit: string
				) => boolean;
				export let rangeAsciiCaseInsensitiveMatch: (
					input: string,
					start: number,
					end: number,
					lit: string
				) => boolean;
				export let readToken: (
					input: string,
					pos: number,
					out: MutableToken
				) => undefined | MutableToken;
				export let skipEscape: (input: string, pos: number) => number;
				export let toLowerCaseIfNeeded: (s: string) => string;
				export let unescapeIdentifier: MakeCacheableResult<string> & {
					bindCache: BindCache<string>;
				};
				export { TokenStream };
			}
			export namespace printer {
				export let printer: (
					path: {
						state: unknown;
						get node(): NodeSyntaxParser;
						get parent(): null | NodeSyntaxParser;
						get index(): number;
						/**
						 * Stop the walk descending into the current node (enter only).
						 */
						skipChildren(): void;
						/**
						 * Stop the walk: no visitor fires after the current one returns.
						 */
						stop(): void;
						/**
						 * A top-level rule and a comment have none; a hash within a declaration is
						 * a color, elsewhere an id.
						 */
						within(type: number): boolean;
						type(n?: NodeSyntaxParser): number;
						range(n?: NodeSyntaxParser): [number, number];
						start(n?: NodeSyntaxParser): number;
						end(n?: NodeSyntaxParser): number;
						loc(n?: NodeSyntaxParser): [number, number, number, number];
						/**
						 * A node's text exactly as the input wrote it (`name` and `value` decode).
						 */
						source(n?: number | NodeSyntaxParser, end?: number): string;
						/**
						 * The token's value as CSS Syntax defines it: a number for a number,
						 * percentage or dimension, otherwise text with escapes resolved (a string
						 * without its quotes, a hash without its `#`, a `url()`'s contents, a
						 * comment's text); "" for a rule, declaration, function or block.
						 */
						value(n?: NodeSyntaxParser): string | number;
						name(n?: NodeSyntaxParser): string;
						/**
						 * A rule's children are its prelude; its block is read with {@link field }.
						 */
						childCount(n?: NodeSyntaxParser): number;
						child(i: number, n?: NodeSyntaxParser): ComponentValue;
						/**
						 * Every child as a new array, for a reader that keeps or searches them.
						 */
						children(n?: NodeSyntaxParser): ComponentValue[];
						/**
						 * A block big enough to stream hands its children to the visitors as each
						 * one finishes rather than collecting them, so its lists read as empty here.
						 */
						fieldCount(field: number, n?: NodeSyntaxParser): number;
						field(
							i: number,
							field: number,
							n?: NodeSyntaxParser
						): NodeSyntaxParser;
						fieldNamed(
							field: number,
							name: string,
							n?: NodeSyntaxParser
						): NodeSyntaxParser;
						/**
						 * `important` is a container's bit, cleared when its id is reused; a token's
						 * type flags are read off its text.
						 */
						flag(flag: number, n?: NodeSyntaxParser): boolean;
						rangeOf(
							part: number,
							n?: NodeSyntaxParser
						): null | [number, number];
						startOf(part: number, n?: NodeSyntaxParser): number;
						endOf(part: number, n?: NodeSyntaxParser): number;
						/**
						 * CSS has no text beyond a node's name and value, read with `name` and `value`.
						 */
						textOf(_part: number, _n?: NodeSyntaxParser): null;
					},
					writer: PrintContext<
						{
							state: unknown;
							get node(): NodeSyntaxParser;
							get parent(): null | NodeSyntaxParser;
							get index(): number;
							/**
							 * Stop the walk descending into the current node (enter only).
							 */
							skipChildren(): void;
							/**
							 * Stop the walk: no visitor fires after the current one returns.
							 */
							stop(): void;
							/**
							 * A top-level rule and a comment have none; a hash within a declaration is
							 * a color, elsewhere an id.
							 */
							within(type: number): boolean;
							type(n?: NodeSyntaxParser): number;
							range(n?: NodeSyntaxParser): [number, number];
							start(n?: NodeSyntaxParser): number;
							end(n?: NodeSyntaxParser): number;
							loc(n?: NodeSyntaxParser): [number, number, number, number];
							/**
							 * A node's text exactly as the input wrote it (`name` and `value` decode).
							 */
							source(n?: number | NodeSyntaxParser, end?: number): string;
							/**
							 * The token's value as CSS Syntax defines it: a number for a number,
							 * percentage or dimension, otherwise text with escapes resolved (a string
							 * without its quotes, a hash without its `#`, a `url()`'s contents, a
							 * comment's text); "" for a rule, declaration, function or block.
							 */
							value(n?: NodeSyntaxParser): string | number;
							name(n?: NodeSyntaxParser): string;
							/**
							 * A rule's children are its prelude; its block is read with {@link field }.
							 */
							childCount(n?: NodeSyntaxParser): number;
							child(i: number, n?: NodeSyntaxParser): ComponentValue;
							/**
							 * Every child as a new array, for a reader that keeps or searches them.
							 */
							children(n?: NodeSyntaxParser): ComponentValue[];
							/**
							 * A block big enough to stream hands its children to the visitors as each
							 * one finishes rather than collecting them, so its lists read as empty here.
							 */
							fieldCount(field: number, n?: NodeSyntaxParser): number;
							field(
								i: number,
								field: number,
								n?: NodeSyntaxParser
							): NodeSyntaxParser;
							fieldNamed(
								field: number,
								name: string,
								n?: NodeSyntaxParser
							): NodeSyntaxParser;
							/**
							 * `important` is a container's bit, cleared when its id is reused; a token's
							 * type flags are read off its text.
							 */
							flag(flag: number, n?: NodeSyntaxParser): boolean;
							rangeOf(
								part: number,
								n?: NodeSyntaxParser
							): null | [number, number];
							startOf(part: number, n?: NodeSyntaxParser): number;
							endOf(part: number, n?: NodeSyntaxParser): number;
							/**
							 * CSS has no text beyond a node's name and value, read with `name` and `value`.
							 */
							textOf(_part: number, _n?: NodeSyntaxParser): null;
						},
						NodeSyntaxParser,
						CssPrintOptions
					>
				) => string;
			}
			export { CssSourceProcessor as SourceProcessor };
		}
		export { CssLoadingRuntimeModule, CssModulesPlugin };
	}
	export namespace html {
		export const builtinEmbeddedRenderer: (
			options?: BuiltinEmbeddedRendererOptions
		) => (
			source: string,
			info: { type: string; hostType: string; as?: string }
		) => undefined | string;
		export function htmlMinify(
			input: { [index: string]: string | Buffer },
			sourceMap?: RawSourceMap,
			minimizerOptions?: Omit<
				HtmlPrintOptions,
				"renderEmbeddedSource" | "deferEmbeddedSource"
			> & {
				environment?: CssEnvironment;
				css?: {
					convertLengthUnits?: boolean;
					convertApproximateColors?: boolean;
					dropOverriddenDeclarations?: boolean;
					rewriteCustomProperties?: boolean;
					unusedSymbols?: string[];
					pseudoClasses?: { [index: string]: string };
				} & CssTransformOptions;
				minifyConditionalComments?: boolean;
				extractComments?:
					| string
					| boolean
					| RegExp
					| ((comment: {
							value: string;
							line: number;
							col: number;
					  }) => boolean);
				renderEmbeddedSource?: (
					source: string,
					info: { type: string; hostType: string; as?: string }
				) =>
					| undefined
					| string
					| EmbeddedSourceResult
					| Promise<undefined | string | EmbeddedSourceResult>;
				svg?: boolean;
			} & HtmlTransformOptions,
			extractComments?:
				| string
				| boolean
				| RegExp
				| ((...args: never[]) => boolean)
				| {
						condition?:
							string | boolean | RegExp | ((...args: never[]) => boolean);
				  }
		): Promise<{
			code: string;
			extractedComments?: string[];
			warnings?: (string | Error)[];
			errors?: (string | Error)[];
		}>;
		export namespace htmlMinify {
			export let supportsWorkerThreads: () => boolean;
			export let getTypes: () => string[];
			export let getEmbeddedTypes: () => string[];
			export let filter: (name: string) => boolean;
			export let formatBanner: (banner: string) => string;
			export let getBannerPosition: () => "end";
		}
		export namespace syntax {
			export namespace parser {
				export let A: {
					state: unknown;
					get node(): number;
					get parent(): null | number;
					/**
					 * Counted along the sibling links when asked, so the walk stores nothing for it.
					 */
					get index(): number;
					/**
					 * Stop the walk descending into the current node (enter only).
					 */
					skipChildren(): void;
					/**
					 * Stop the walk: no visitor fires after the current one returns.
					 */
					stop(): void;
					/**
					 * Walks the parent links, so a `<template>`'s content ends at its fragment.
					 */
					within(type: number): boolean;
					type(n?: number): number;
					range(n?: number): [number, number];
					start(n?: number): number;
					end(n?: number): number;
					/**
					 * Line / column are converted only when asked, by a converter made on the
					 * first call of a parse. Valid during the walk, as {@link source } is.
					 */
					loc(n?: number): [number, number, number, number];
					/**
					 * A node's text as written; valid during the walk, before `parseHtml` releases the source.
					 */
					source(n?: number, end?: number): string;
					/**
					 * An element's or attribute's name (lowercased, adjusted in foreign content),
					 * a doctype's name, a processing instruction's target; "" for other nodes.
					 */
					name(n?: number): string;
					fieldCount(field: number, n?: number): number;
					/**
					 * An attribute item is a node the shared reads take.
					 */
					field(i: number, field: number, n?: number): number;
					/**
					 * Attribute names are stored lowercased, so `name` is compared as written.
					 */
					fieldNamed(field: number, name: string, n?: number): number;
					flag(flag: number, n?: number): boolean;
					/**
					 * A parser-inserted element has no name, tags or content in the source.
					 */
					rangeOf(part: number, n?: number): null | [number, number];
					startOf(part: number, n?: number): number;
					endOf(part: number, n?: number): number;
					/**
					 * Name and value are read with `name` and `value`; this reads a node's
					 * other text, such as a doctype's identifiers, which are stored decoded.
					 */
					textOf(part: number, n?: number): null | string;
					/**
					 * A text's, comment's, processing instruction's or attribute's data,
					 * character references decoded; "" for other nodes.
					 */
					value(n?: number): string;
					/**
					 * Counted along the sibling links once per node and visitor call.
					 */
					childCount(n?: number): number;
					/**
					 * Reached along the sibling links from the last child read under `n`, so a
					 * loop over a node's children takes one step per child.
					 */
					child(i: number, n?: number): number;
					/**
					 * Every child as a new array, for a reader that keeps or searches them.
					 */
					children(n?: number): number[];
				};
				export let BLOCK_CONTENTS: "block-contents";
				export let EMBEDDED_LANGUAGES: string[];
				export let EVENT_HANDLER: "event-handler";
				export let FOREIGN_ELEMENT: "foreign-element";
				export let FLAG_FOSTER_REGION: 128;
				export let JSON_TYPE: "json";
				export namespace Field {
					export let attributes: 1;
					export let content: 2;
				}
				export namespace Flag {
					export let mathml: 1;
					export let svg: 2;
					export let selfClosing: 4;
				}
				export namespace Part {
					export let name: 1;
					export let value: 2;
					export let content: 3;
					export let startTag: 4;
					export let endTag: 5;
					export let publicId: 6;
					export let systemId: 7;
				}
				export namespace Namespace {
					export let HTML: 0;
					export let MathML: 1;
					export let SVG: 2;
					export let XML: 3;
				}
				export namespace NodeType {
					export let Document: 1;
					export let DocumentFragment: 2;
					export let Element: 3;
					export let Text: 4;
					export let Comment: 5;
					export let Doctype: 6;
					export let ProcessingInstruction: 7;
					export let Attribute: 8;
				}
				export namespace Quote {
					export let None: 0;
					export let Double: 1;
					export let Single: 2;
				}
				export let SVG_TYPE: "svg";
				export let asciiLowercase: (value: string) => string;
				export let stripAsciiWhitespace: (value: string) => string;
				export let baseTag: (
					base:
						| string
						| {
								/**
								 * Value for the `href` attribute of the `<base>` element.
								 */
								href: string;
								/**
								 * Value for the `target` attribute of the `<base>` element (e.g. `"_blank"`).
								 */
								target?: string;
						  }
				) => string;
				export let buildHeadTags: (opts: OutputHtmlOptions) => string;
				export let collapseWhitespaceRuns: (s: string) => string;
				export let decodeEntities: _functionSyntaxParser;
				export let decodeXmlAttribute: (value: string) => string;
				export let decodeXmlEntities: (value: string) => string;
				export let escapeAttribute: (
					s: string,
					delimiter?: number,
					minimal?: boolean
				) => string;
				export let escapeText: (s: string) => string;
				export let escapeXmlAttribute: (value: string, quote: string) => string;
				export let escapeXmlText: (data: string) => string;
				export let grammar: (
					input: string,
					visitors: CompiledVisitorBucket<{
						state: unknown;
						get node(): number;
						get parent(): null | number;
						/**
						 * Counted along the sibling links when asked, so the walk stores nothing for it.
						 */
						get index(): number;
						/**
						 * Stop the walk descending into the current node (enter only).
						 */
						skipChildren(): void;
						/**
						 * Stop the walk: no visitor fires after the current one returns.
						 */
						stop(): void;
						/**
						 * Walks the parent links, so a `<template>`'s content ends at its fragment.
						 */
						within(type: number): boolean;
						type(n?: number): number;
						range(n?: number): [number, number];
						start(n?: number): number;
						end(n?: number): number;
						/**
						 * Line / column are converted only when asked, by a converter made on the
						 * first call of a parse. Valid during the walk, as {@link source } is.
						 */
						loc(n?: number): [number, number, number, number];
						/**
						 * A node's text as written; valid during the walk, before `parseHtml` releases the source.
						 */
						source(n?: number, end?: number): string;
						/**
						 * An element's or attribute's name (lowercased, adjusted in foreign content),
						 * a doctype's name, a processing instruction's target; "" for other nodes.
						 */
						name(n?: number): string;
						fieldCount(field: number, n?: number): number;
						/**
						 * An attribute item is a node the shared reads take.
						 */
						field(i: number, field: number, n?: number): number;
						/**
						 * Attribute names are stored lowercased, so `name` is compared as written.
						 */
						fieldNamed(field: number, name: string, n?: number): number;
						flag(flag: number, n?: number): boolean;
						/**
						 * A parser-inserted element has no name, tags or content in the source.
						 */
						rangeOf(part: number, n?: number): null | [number, number];
						startOf(part: number, n?: number): number;
						endOf(part: number, n?: number): number;
						/**
						 * Name and value are read with `name` and `value`; this reads a node's
						 * other text, such as a doctype's identifiers, which are stored decoded.
						 */
						textOf(part: number, n?: number): null | string;
						/**
						 * A text's, comment's, processing instruction's or attribute's data,
						 * character references decoded; "" for other nodes.
						 */
						value(n?: number): string;
						/**
						 * Counted along the sibling links once per node and visitor call.
						 */
						childCount(n?: number): number;
						/**
						 * Reached along the sibling links from the last child read under `n`, so a
						 * loop over a node's children takes one step per child.
						 */
						child(i: number, n?: number): number;
						/**
						 * Every child as a new array, for a reader that keeps or searches them.
						 */
						children(n?: number): number[];
					}>[],
					writer:
						| undefined
						| PrintContext<
								{
									state: unknown;
									get node(): number;
									get parent(): null | number;
									/**
									 * Counted along the sibling links when asked, so the walk stores nothing for it.
									 */
									get index(): number;
									/**
									 * Stop the walk descending into the current node (enter only).
									 */
									skipChildren(): void;
									/**
									 * Stop the walk: no visitor fires after the current one returns.
									 */
									stop(): void;
									/**
									 * Walks the parent links, so a `<template>`'s content ends at its fragment.
									 */
									within(type: number): boolean;
									type(n?: number): number;
									range(n?: number): [number, number];
									start(n?: number): number;
									end(n?: number): number;
									/**
									 * Line / column are converted only when asked, by a converter made on the
									 * first call of a parse. Valid during the walk, as {@link source } is.
									 */
									loc(n?: number): [number, number, number, number];
									/**
									 * A node's text as written; valid during the walk, before `parseHtml` releases the source.
									 */
									source(n?: number, end?: number): string;
									/**
									 * An element's or attribute's name (lowercased, adjusted in foreign content),
									 * a doctype's name, a processing instruction's target; "" for other nodes.
									 */
									name(n?: number): string;
									fieldCount(field: number, n?: number): number;
									/**
									 * An attribute item is a node the shared reads take.
									 */
									field(i: number, field: number, n?: number): number;
									/**
									 * Attribute names are stored lowercased, so `name` is compared as written.
									 */
									fieldNamed(field: number, name: string, n?: number): number;
									flag(flag: number, n?: number): boolean;
									/**
									 * A parser-inserted element has no name, tags or content in the source.
									 */
									rangeOf(part: number, n?: number): null | [number, number];
									startOf(part: number, n?: number): number;
									endOf(part: number, n?: number): number;
									/**
									 * Name and value are read with `name` and `value`; this reads a node's
									 * other text, such as a doctype's identifiers, which are stored decoded.
									 */
									textOf(part: number, n?: number): null | string;
									/**
									 * A text's, comment's, processing instruction's or attribute's data,
									 * character references decoded; "" for other nodes.
									 */
									value(n?: number): string;
									/**
									 * Counted along the sibling links once per node and visitor call.
									 */
									childCount(n?: number): number;
									/**
									 * Reached along the sibling links from the last child read under `n`, so a
									 * loop over a node's children takes one step per child.
									 */
									child(i: number, n?: number): number;
									/**
									 * Every child as a new array, for a reader that keeps or searches them.
									 */
									children(n?: number): number[];
								},
								number,
								HtmlPrintOptions
						  >,
					options: HtmlProcessOptions
				) => void;
				export let isAllAsciiWhitespace: (s: string) => boolean;
				export let isAsciiAlphanumeric: (cc: number) => boolean;
				export let isAsciiWhitespace: (cc: number) => boolean;
				export let metaTag: (name: string, content: string) => string;
				export let parseCssUrls: (input: string) => [string, number, number][];
				export let parseHtml: (
					input: string,
					pos?: number,
					options?: HtmlParseOptions
				) => number;
				export let parseMsapplicationTask: (
					input: string
				) => [string, number, number][];
				export let parseSrc: (input: string) => [string, number, number][];
				export let parseSrcset: (input: string) => [string, number, number][];
				export let pickTransforms: (
					options: HtmlTransformOptions
				) => undefined | HtmlTransformOptions;
				export let startsWithAsciiWhitespace: (s: string) => boolean;
				export let tokenize: (
					input: string,
					pos?: number,
					callbacks?: HtmlTokenCallbacks
				) => number;
				export let tokenizeXml: (
					input: string,
					pos?: number,
					callbacks?: HtmlTokenCallbacks
				) => number;
			}
			export namespace printer {
				export let CLASSIC_SCRIPT: "script";
				export let MODULE_SCRIPT: "module";
				export let printer: (
					path: {
						state: unknown;
						get node(): number;
						get parent(): null | number;
						/**
						 * Counted along the sibling links when asked, so the walk stores nothing for it.
						 */
						get index(): number;
						/**
						 * Stop the walk descending into the current node (enter only).
						 */
						skipChildren(): void;
						/**
						 * Stop the walk: no visitor fires after the current one returns.
						 */
						stop(): void;
						/**
						 * Walks the parent links, so a `<template>`'s content ends at its fragment.
						 */
						within(type: number): boolean;
						type(n?: number): number;
						range(n?: number): [number, number];
						start(n?: number): number;
						end(n?: number): number;
						/**
						 * Line / column are converted only when asked, by a converter made on the
						 * first call of a parse. Valid during the walk, as {@link source } is.
						 */
						loc(n?: number): [number, number, number, number];
						/**
						 * A node's text as written; valid during the walk, before `parseHtml` releases the source.
						 */
						source(n?: number, end?: number): string;
						/**
						 * An element's or attribute's name (lowercased, adjusted in foreign content),
						 * a doctype's name, a processing instruction's target; "" for other nodes.
						 */
						name(n?: number): string;
						fieldCount(field: number, n?: number): number;
						/**
						 * An attribute item is a node the shared reads take.
						 */
						field(i: number, field: number, n?: number): number;
						/**
						 * Attribute names are stored lowercased, so `name` is compared as written.
						 */
						fieldNamed(field: number, name: string, n?: number): number;
						flag(flag: number, n?: number): boolean;
						/**
						 * A parser-inserted element has no name, tags or content in the source.
						 */
						rangeOf(part: number, n?: number): null | [number, number];
						startOf(part: number, n?: number): number;
						endOf(part: number, n?: number): number;
						/**
						 * Name and value are read with `name` and `value`; this reads a node's
						 * other text, such as a doctype's identifiers, which are stored decoded.
						 */
						textOf(part: number, n?: number): null | string;
						/**
						 * A text's, comment's, processing instruction's or attribute's data,
						 * character references decoded; "" for other nodes.
						 */
						value(n?: number): string;
						/**
						 * Counted along the sibling links once per node and visitor call.
						 */
						childCount(n?: number): number;
						/**
						 * Reached along the sibling links from the last child read under `n`, so a
						 * loop over a node's children takes one step per child.
						 */
						child(i: number, n?: number): number;
						/**
						 * Every child as a new array, for a reader that keeps or searches them.
						 */
						children(n?: number): number[];
					},
					writer: PrintContext<
						{
							state: unknown;
							get node(): number;
							get parent(): null | number;
							/**
							 * Counted along the sibling links when asked, so the walk stores nothing for it.
							 */
							get index(): number;
							/**
							 * Stop the walk descending into the current node (enter only).
							 */
							skipChildren(): void;
							/**
							 * Stop the walk: no visitor fires after the current one returns.
							 */
							stop(): void;
							/**
							 * Walks the parent links, so a `<template>`'s content ends at its fragment.
							 */
							within(type: number): boolean;
							type(n?: number): number;
							range(n?: number): [number, number];
							start(n?: number): number;
							end(n?: number): number;
							/**
							 * Line / column are converted only when asked, by a converter made on the
							 * first call of a parse. Valid during the walk, as {@link source } is.
							 */
							loc(n?: number): [number, number, number, number];
							/**
							 * A node's text as written; valid during the walk, before `parseHtml` releases the source.
							 */
							source(n?: number, end?: number): string;
							/**
							 * An element's or attribute's name (lowercased, adjusted in foreign content),
							 * a doctype's name, a processing instruction's target; "" for other nodes.
							 */
							name(n?: number): string;
							fieldCount(field: number, n?: number): number;
							/**
							 * An attribute item is a node the shared reads take.
							 */
							field(i: number, field: number, n?: number): number;
							/**
							 * Attribute names are stored lowercased, so `name` is compared as written.
							 */
							fieldNamed(field: number, name: string, n?: number): number;
							flag(flag: number, n?: number): boolean;
							/**
							 * A parser-inserted element has no name, tags or content in the source.
							 */
							rangeOf(part: number, n?: number): null | [number, number];
							startOf(part: number, n?: number): number;
							endOf(part: number, n?: number): number;
							/**
							 * Name and value are read with `name` and `value`; this reads a node's
							 * other text, such as a doctype's identifiers, which are stored decoded.
							 */
							textOf(part: number, n?: number): null | string;
							/**
							 * A text's, comment's, processing instruction's or attribute's data,
							 * character references decoded; "" for other nodes.
							 */
							value(n?: number): string;
							/**
							 * Counted along the sibling links once per node and visitor call.
							 */
							childCount(n?: number): number;
							/**
							 * Reached along the sibling links from the last child read under `n`, so a
							 * loop over a node's children takes one step per child.
							 */
							child(i: number, n?: number): number;
							/**
							 * Every child as a new array, for a reader that keeps or searches them.
							 */
							children(n?: number): number[];
						},
						number,
						HtmlPrintOptions
					>
				) => string;
			}
			export { HtmlSourceProcessor as SourceProcessor };
		}
		export function xmlMinify(
			input: { [index: string]: string | Buffer },
			sourceMap?: RawSourceMap,
			minimizerOptions?: OptimizationMinimizeXml & {
				environment?: CssEnvironment;
				css?: {
					convertLengthUnits?: boolean;
					convertApproximateColors?: boolean;
					dropOverriddenDeclarations?: boolean;
					rewriteCustomProperties?: boolean;
					unusedSymbols?: string[];
					pseudoClasses?: { [index: string]: string };
				} & CssTransformOptions;
			}
		): Promise<{ code: string }>;
		export namespace xmlMinify {
			export let supportsWorkerThreads: () => boolean;
			export let getTypes: () => string[];
			export let filter: (name: string) => boolean;
		}
		export { HtmlModulesPlugin };
	}
	export namespace library {
		export { AbstractLibraryPlugin, EnableLibraryPlugin };
	}
	export namespace dll {
		export {
			DelegatedPlugin,
			DllPlugin,
			DllReferencePlugin,
			LibManifestPlugin
		};
	}
	export namespace container {
		export const scope: <T>(
			scope: string,
			options: ContainerOptionsFormat<T>
		) => Record<string, string | string[] | T>;
		export {
			ContainerPlugin,
			ContainerReferencePlugin,
			ModuleFederationPlugin
		};
	}
	export namespace sharing {
		export const scope: <T>(
			scope: string,
			options: ContainerOptionsFormat<T>
		) => Record<string, string | string[] | T>;
		export { ConsumeSharedPlugin, ProvideSharedPlugin, SharePlugin };
	}
	export namespace debug {
		export { ProfilingPlugin };
	}
	export namespace util {
		export const createHash: (algorithm: HashFunction) => Hash;
		export namespace comparators {
			export let compareChunkGroupsByIndex: (
				a: ChunkGroup,
				b: ChunkGroup
			) => 0 | 1 | -1;
			export let compareChunks: ParameterizedComparator<ChunkGraph, Chunk>;
			export let compareChunksById: (a: Chunk, b: Chunk) => 0 | 1 | -1;
			export let compareChunksNatural: (
				chunkGraph: ChunkGraph
			) => Comparator<Chunk>;
			export let compareErrors: Comparator<Error>;
			export let compareIds: (
				a: string | number,
				b: string | number
			) => 0 | 1 | -1;
			export let compareIterables: <T>(
				elementComparator: Comparator<T>
			) => Comparator<Iterable<T>>;
			export let compareLocations: (
				a: DependencyLocation,
				b: DependencyLocation
			) => 0 | 1 | -1;
			export let compareModulesByFullName: ParameterizedComparator<
				Compiler,
				Module
			>;
			export let compareModulesById: ParameterizedComparator<
				ChunkGraph,
				Module
			>;
			export let compareModulesByIdOrIdentifier: ParameterizedComparator<
				ChunkGraph,
				Module
			>;
			export let compareModulesByIdentifier: (
				a: Module,
				b: Module
			) => 0 | 1 | -1;
			export let compareModulesByPostOrderIndexOrIdentifier: ParameterizedComparator<
				ModuleGraph,
				Module
			>;
			export let compareModulesByPreOrderIndexOrIdentifier: ParameterizedComparator<
				ModuleGraph,
				Module
			>;
			export let compareNumbers: (a: number, b: number) => 0 | 1 | -1;
			export let compareSelect: <T, R>(
				getter: Selector<T, R>,
				comparator: Comparator<R>
			) => Comparator<T>;
			export let compareStrings: (a: string, b: string) => 0 | 1 | -1;
			export let compareStringsNumeric: (a: string, b: string) => 0 | 1 | -1;
			export let concatComparators: <T>(
				c1: Comparator<T>,
				c2: Comparator<T>,
				...cRest: Comparator<T>[]
			) => Comparator<T>;
			export let keepOriginalOrder: <T>(iterable: Iterable<T>) => Comparator<T>;
			export let sortWithSourceOrder: (
				dependencies: Dependency[],
				dependencySourceOrderMap: WeakMap<Dependency, DependencySourceOrder>,
				onDependencyReSort?: (dep: Dependency, index: number) => void
			) => void;
		}
		export namespace runtime {
			export let compareRuntime: (a: RuntimeSpec, b: RuntimeSpec) => 0 | 1 | -1;
			export let filterRuntime: (
				runtime: RuntimeSpec,
				filter: (runtime?: RuntimeSpec) => boolean
			) => undefined | string | boolean | SortableSet<string>;
			export let forEachRuntime: (
				runtime: RuntimeSpec,
				fn: (runtime?: string) => void,
				deterministicOrder?: boolean
			) => void;
			export let getEntryRuntime: (
				compilation: Compilation,
				name: string,
				options?: EntryOptions
			) => RuntimeSpec;
			export let getRuntimeKey: (runtime: RuntimeSpec) => string;
			export let intersectRuntime: (
				a: RuntimeSpec,
				b: RuntimeSpec
			) => RuntimeSpec;
			export let keyToRuntime: (key: string) => RuntimeSpec;
			export let mergeRuntime: (a: RuntimeSpec, b: RuntimeSpec) => RuntimeSpec;
			export let mergeRuntimeCondition: (
				a: RuntimeCondition,
				b: RuntimeCondition,
				runtime: RuntimeSpec
			) => RuntimeCondition;
			export let mergeRuntimeConditionNonFalse: (
				a: undefined | string | true | SortableSet<string>,
				b: undefined | string | true | SortableSet<string>,
				runtime: RuntimeSpec
			) => undefined | string | true | SortableSet<string>;
			export let mergeRuntimeOwned: (
				a: RuntimeSpec,
				b: RuntimeSpec
			) => RuntimeSpec;
			export let runtimeConditionToString: (
				runtimeCondition: RuntimeCondition
			) => string;
			export let runtimeEqual: (a: RuntimeSpec, b: RuntimeSpec) => boolean;
			export let runtimeToString: (runtime: RuntimeSpec) => string;
			export let subtractRuntime: (
				a: RuntimeSpec,
				b: RuntimeSpec
			) => RuntimeSpec;
			export let subtractRuntimeCondition: (
				a: RuntimeCondition,
				b: RuntimeCondition,
				runtime: RuntimeSpec
			) => RuntimeCondition;
			export { RuntimeSpecMap, RuntimeSpecSet };
		}
		export namespace serialization {
			export const register: <C extends Constructor>(
				Constructor: C,
				request: string,
				name: null | string,
				serializer: ObjectSerializer<InstanceType<C>>
			) => void;
			export const registerLegacyRequest: (
				Constructor: Constructor,
				request: string,
				name?: null | string
			) => void;
			export const registerLoader: (
				regExp: RegExp,
				loader: (request: string) => boolean
			) => void;
			export const registerNotSerializable: (Constructor: Constructor) => void;
			export const NOT_SERIALIZABLE: object;
			export const buffersSerializer: Serializer<
				ComplexSerializableType,
				BufferSerializableType[],
				object
			>;
			export let createFileSerializer: <D, S, C>(
				fs: IntermediateFileSystem,
				hashFunction: HashFunction
			) => Serializer<D, S, C>;
			export { MEASURE_START_OPERATION, MEASURE_END_OPERATION };
		}
		export const makeSerializable: <
			T extends { new (...params: never[]): object }
		>(
			Constructor: T,
			request: string | (string | [string, null | string])[],
			name?: null | string
		) => void;
		export const cleverMerge: <T, O>(
			first?: null | T,
			second?: null | O
		) => T | O | (T & O);
		export function compileBooleanMatcher(
			map: Record<string | number, boolean>
		): boolean | ((value: string) => string);
		export namespace compileBooleanMatcher {
			export let fromLists: (
				positiveItems: string[],
				negativeItems: string[]
			) => (value: string) => string;
			export let itemsToRegexp: (itemsArr: string[]) => string;
		}
		export namespace dataURL {
			export let EMBEDDED_LANGUAGES: string[];
			export let JSON_TYPE: "json";
			export let SVG_TYPE: "svg";
			export let URIRegEx: RegExp;
			export let askEmbeddedRenderer: (
				render: (
					source: string,
					info: { type: string; hostType: string; as?: string }
				) =>
					| undefined
					| string
					| EmbeddedSourceResult
					| Promise<undefined | string | EmbeddedSourceResult>,
				hole: { source: string; type: string; hostType: string; as?: string },
				reported: EmbeddedSourceResult[]
			) => Promise<undefined | string | EmbeddedSourceResult>;
			export let buildDataURI: (parsed: ParsedDataURI, text: string) => string;
			export let collectEmbeddedDiagnostics: (
				reported: {
					warnings?: (string | Error)[];
					errors?: (string | Error)[];
				}[]
			) => { warnings?: (string | Error)[]; errors?: (string | Error)[] };
			export let decodeDataURI: (uri: string) => null | Buffer;
			export let decodeDataURIPayload: (parsed: ParsedDataURI) => null | string;
			export let embeddedText: (
				answer?: string | { code?: string }
			) => undefined | string;
			export let encodeDataURIPayload: (text: string) => string;
			export let languageOfFilename: (
				filename: null | string
			) => undefined | string;
			export let languageOfMediaType: (mediaType: string) => undefined | string;
			export let parseDataURI: (uri: string) => null | ParsedDataURI;
			export let readEmbeddedDataURI: (
				uri: string
			) => null | { parsed: ParsedDataURI; type: string; payload: string };
		}
		export namespace extractComments {
			export let extractComments: (
				option:
					| undefined
					| string
					| boolean
					| RegExp
					| ((...args: never[]) => boolean)
					| {
							condition?:
								string | boolean | RegExp | ((...args: never[]) => boolean);
					  }
					| ((comment: {
							value: string;
							line: number;
							col: number;
					  }) => boolean),
				comments:
					| undefined
					| string
					| boolean
					| RegExp
					| ((comment: string) => boolean),
				syntax: CommentSyntax
			) =>
				| undefined
				| {
						comments: (
							comment: string,
							line: number,
							column: number
						) => boolean;
						extracted: string[];
				  };
			export let keepCondition: (
				comments: CommentsOption,
				some: (comment: string) => boolean
			) => (comment: string) => boolean;
		}
		export { LazySet, RequestShortener };
	}
	export namespace sources {
		export namespace util {
			export namespace scopes {
				export {
					addScopesToSourceMap,
					collectSourceScopes,
					createScopeCollector,
					createScopesWriter,
					encodeScopes
				};
			}
			export namespace stringBufferUtils {
				export {
					disableDualStringBufferCaching,
					enableDualStringBufferCaching,
					enterStringInterningRange,
					exitStringInterningRange,
					internString,
					isDualStringBufferCachingEnabled
				};
			}
		}
		export {
			Source,
			RawSource,
			OriginalSource,
			ReplaceSource,
			SourceMapSource,
			ConcatSource,
			PrefixSource,
			CachedSource,
			SizeOnlySource,
			CompatSource
		};
	}
	export namespace experiments {
		export namespace schemes {
			export { HttpUriPlugin, VirtualUrlPlugin };
		}
		export namespace ids {
			export { SyncModuleIdsPlugin };
		}
		export namespace typescript {
			export { TypeScriptPlugin };
		}
	}
	export type RuleSetUseFunction = (data: EffectData) =>
		| string
		| RuleSetUseFunction
		| {
				/**
				 * Unique loader options identifier.
				 */
				ident?: string;
				/**
				 * Loader name.
				 */
				loader?: string;
				/**
				 * Loader options.
				 */
				options?: string | { [index: string]: any };
		  }
		| (
				| undefined
				| null
				| string
				| false
				| 0
				| RuleSetUseFunction
				| {
						/**
						 * Unique loader options identifier.
						 */
						ident?: string;
						/**
						 * Loader name.
						 */
						loader?: string;
						/**
						 * Loader options.
						 */
						options?: string | { [index: string]: any };
				  }
		  )[];
	export type WebpackPluginFunction = (
		this: Compiler,
		compiler: Compiler
	) => void;
	export type ExternalItemFunctionCallback = (
		data: ExternalItemFunctionData,
		callback: (
			err?: null | Error,
			result?:
				| string
				| boolean
				| string[]
				| ExternalItemValueObject
				| ExternalItemValueWithOptions
		) => void
	) => void;
	export type ExternalItemFunctionDataGetResolve = (
		options?: ResolveOptionsWebpackOptions
	) =>
		| ((
				context: string,
				request: string,
				callback: (
					err?: null | Error,
					result?: string | false,
					resolveRequest?: ResolveRequest
				) => void
		  ) => void)
		| ((context: string, request: string) => Promise<string>);
	export type ExternalItemFunctionDataGetResolveCallbackResult = (
		context: string,
		request: string,
		callback: (
			err?: null | Error,
			result?: string | false,
			resolveRequest?: ResolveRequest
		) => void
	) => void;
	export type ExternalItemFunctionDataGetResolveResult = (
		context: string,
		request: string
	) => Promise<string>;
	export type ExternalItemFunctionPromise = (
		data: ExternalItemFunctionData
	) => Promise<ExternalItemValue>;
	export type MultiCompilerPluginFunction = (
		this: MultiCompiler,
		compiler: MultiCompiler
	) => void;
	export type ConfigurationFactory = (
		env: Record<string, any>,
		argv: Record<string, any>
	) => MaybePromise<Configuration | MultiConfiguration>;
	export type ObjectSerializerContext =
		typeof ObjectSerializerContextObjectMiddlewareObject_2;
	export type ObjectDeserializerContext =
		typeof ObjectDeserializerContextObjectMiddlewareObject_1;
	export {
		/** Resolves every module of the last build eagerly. @deprecated use `prefetch.AutomaticPrefetchPlugin` — TODO in the next major release: remove */ AutomaticPrefetchPlugin,
		AsyncDependenciesBlock,
		BannerPlugin,
		/** The cache a compilation stores and restores through. @deprecated use `cache.Cache` — TODO in the next major release: remove */ Cache,
		Chunk,
		ChunkGraph,
		CleanPlugin,
		Compilation,
		Compiler,
		/** The protocol scope hoisting renders through. @deprecated use `optimize.ConcatenationScope` — TODO in the next major release: remove */ ConcatenationScope,
		ContextExclusionPlugin,
		ContextReplacementPlugin,
		CopyPlugin,
		DefinePlugin,
		Dependency,
		DynamicEntryPlugin,
		DotenvPlugin,
		EntryOptionPlugin,
		EntryPlugin,
		EnvironmentPlugin,
		EvalDevToolModulePlugin,
		EvalSourceMapDevToolPlugin,
		ExternalModule,
		ExternalsPlugin,
		Generator,
		HotUpdateChunk,
		HotModuleReplacementPlugin,
		InitFragment,
		IgnorePlugin,
		JavascriptModulesPlugin,
		LibraryTemplatePlugin,
		LoaderOptionsPlugin,
		LoaderTargetPlugin,
		Module,
		ModuleFactory,
		ModuleGraph,
		ModuleGraphConnection,
		NoEmitOnErrorsPlugin,
		NormalModule,
		NormalModuleReplacementPlugin,
		MultiCompiler,
		Parser,
		/** Pins the target platform a `target: false` build cannot infer. @deprecated use `config.PlatformPlugin` — TODO in the next major release: remove */ PlatformPlugin,
		/** Resolves one request eagerly at build time. @deprecated use `prefetch.PrefetchPlugin` — TODO in the next major release: remove */ PrefetchPlugin,
		ProgressPlugin,
		ProvidePlugin,
		/** The base class every emitted runtime module extends. @deprecated use `runtime.RuntimeModule` — TODO in the next major release: remove */ RuntimeModule,
		EntryPlugin as SingleEntryPlugin,
		SSRManifestPlugin,
		SourceMapDevToolPlugin,
		Stats,
		ManifestPlugin,
		Template,
		WatchIgnorePlugin,
		WebpackError,
		/** Reads a resolved configuration into the plugins it implies. @deprecated use `config.WebpackOptionsApply` — TODO in the next major release: remove */ WebpackOptionsApply,
		WebpackOptionsDefaulter,
		ValidationError as WebpackOptionsValidationError,
		ValidationError,
		DelegatedPlugin,
		DllPlugin,
		DllReferencePlugin,
		LibManifestPlugin,
		EntryLibIndex as Entry,
		EntryNormalized,
		EntryObject,
		ExternalItem,
		ExternalItemFunction,
		ExternalItemObjectKnown,
		ExternalItemObjectUnknown,
		ExternalItemValue,
		Externals,
		FileCacheOptions,
		GeneratorOptionsByModuleTypeKnown,
		LibraryOptions,
		MemoryCacheOptions,
		ModuleOptions,
		ParserOptionsByModuleTypeKnown,
		ResolveOptionsWebpackOptions as ResolveOptions,
		RuleSetCondition,
		RuleSetConditionAbsolute,
		RuleSetRule,
		RuleSetUse,
		RuleSetUseItem,
		StatsOptions,
		Configuration,
		WebpackOptionsNormalized,
		WebpackPluginInstance,
		AssetModuleBuildInfo,
		ChunkGroup,
		AssetEmittedInfo,
		ContextModuleBuildInfo,
		CssModuleBuildInfo,
		CssModuleBuildMeta,
		ExternalModuleBuildInfo,
		HtmlModuleBuildInfo,
		JavascriptModuleBuildInfo,
		JavascriptModuleBuildMeta,
		JsonModuleBuildInfo,
		BuildInfo,
		BuildMeta,
		NormalModuleBuildInfo,
		ConcatenatedModuleBuildInfo,
		SyncWasmModuleBuildMeta,
		Asset,
		AssetInfo,
		EntryOptions,
		PathData,
		PathDataChunk,
		PathDataModule,
		CodeGenerationResults,
		Entrypoint,
		ExternalItemFunctionData,
		MultiCompilerOptions,
		MultiCompilerPluginInstance,
		MultiConfiguration,
		MultiStats,
		StatsOptions as MultiStatsOptions,
		ResolveData,
		ParserState,
		ResolvePluginInstance,
		Resolver,
		RenderManifestEntry,
		RenderManifestOptions,
		TemplatePath,
		Watching,
		Argument,
		Problem,
		Colors,
		ColorsOptions,
		DefineConfigInput,
		StatsAsset,
		StatsChunk,
		StatsChunkGroup,
		StatsChunkOrigin,
		StatsCompilation,
		StatsError,
		StatsLogging,
		StatsLoggingEntry,
		StatsModule,
		StatsModuleIssuer,
		StatsModuleReason,
		StatsModuleTraceDependency,
		StatsModuleTraceItem,
		StatsProfile,
		InputFileSystem,
		OutputFileSystem,
		LoaderModule,
		RawLoaderDefinition,
		LoaderDefinition,
		LoaderDefinitionFunction,
		PitchLoaderDefinitionFunction,
		RawLoaderDefinitionFunction,
		LoaderContextLibIndex as LoaderContext
	};
}
declare const topLevelSymbolTag: unique symbol;

export = exports;