webpack 5.36.2 → 5.37.0

package/schemas/WebpackOptions.json

@@ -2686,6 +2686,22 @@
         "strictModuleExceptionHandling": {
           "$ref": "#/definitions/StrictModuleExceptionHandling"
         },
+        "trustedTypes": {
+          "description": "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.",
+          "anyOf": [
+            {
+              "enum": [true]
+            },
+            {
+              "description": "The name of the Trusted Types policy created by webpack to serve bundle chunks.",
+              "type": "string",
+              "minLength": 1
+            },
+            {
+              "$ref": "#/definitions/TrustedTypes"
+            }
+          ]
+        },
         "umdNamedDefine": {
           "cli": {
             "exclude": true
@@ -2839,6 +2855,9 @@
         "strictModuleExceptionHandling": {
           "$ref": "#/definitions/StrictModuleExceptionHandling"
         },
+        "trustedTypes": {
+          "$ref": "#/definitions/TrustedTypes"
+        },
         "uniqueName": {
           "$ref": "#/definitions/UniqueName"
         },
@@ -4356,6 +4375,18 @@
         }
       ]
     },
+    "TrustedTypes": {
+      "description": "Use a Trusted Types policy to create urls for chunks.",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "policyName": {
+          "description": "The name of the Trusted Types policy created by webpack to serve bundle chunks.",
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
     "UmdNamedDefine": {
       "description": "If `output.libraryTarget` is set to umd and `output.library` is set, setting this to true will name the AMD module.",
       "type": "boolean"

package/types.d.ts

@@ -79,12 +79,8 @@ import {
 	WithStatement,
 	YieldExpression
 } from "estree";
-import { JSONSchema4, JSONSchema6, JSONSchema7 } from "json-schema";
-import { default as ValidationError } from "schema-utils/declarations/ValidationError";
-import {
-	Extend,
-	ValidationErrorConfiguration
-} from "schema-utils/declarations/validate";
+import { ValidationError, validate as validateFunction } from "schema-utils";
+import { ValidationErrorConfiguration } from "schema-utils/declarations/validate";
 import {
 	AsArray,
 	AsyncParallelHook,
@@ -153,6 +149,10 @@ declare class AbstractLibraryPlugin<T> {
 	): void;
 	static COMMON_LIBRARY_NAME_MESSAGE: string;
 }
+declare interface AdditionalData {
+	[index: string]: any;
+	webpackAST: object;
+}
 declare class AggressiveMergingPlugin {
 	constructor(options?: any);
 	options: any;
@@ -1650,8 +1650,8 @@ declare class Compilation {
 	 */
 	createChildCompiler(
 		name: string,
-		outputOptions: OutputNormalized,
-		plugins: (
+		outputOptions?: OutputNormalized,
+		plugins?: (
 			| ((this: Compiler, compiler: Compiler) => void)
 			| WebpackPluginInstance
 		)[]
@@ -1855,8 +1855,8 @@ declare class Compiler {
 		compilation: Compilation,
 		compilerName: string,
 		compilerIndex: number,
-		outputOptions: OutputNormalized,
-		plugins: WebpackPluginInstance[]
+		outputOptions?: OutputNormalized,
+		plugins?: WebpackPluginInstance[]
 	): Compiler;
 	isChild(): boolean;
 	createCompilation(): Compilation;
@@ -3035,7 +3035,7 @@ declare class EntryPlugin {
 	 * An entry plugin which will handle
 	 * creation of the EntryDependency
 	 */
-	constructor(context: string, entry: string, options: string | EntryOptions);
+	constructor(context: string, entry: string, options?: string | EntryOptions);
 	context: string;
 	entry: string;
 	options: string | EntryOptions;
@@ -4194,7 +4194,7 @@ declare interface HashedModuleIdsPluginOptions {
 	/**
 	 * The encoding to use when generating the hash, defaults to 'base64'. All encodings from Node.JS' hash.digest are supported.
 	 */
-	hashDigest?: "hex" | "latin1" | "base64";
+	hashDigest?: "base64" | "latin1" | "hex";
 
 	/**
 	 * The prefix length of the hash digest to use, defaults to 4.
@@ -4217,6 +4217,13 @@ declare class HotModuleReplacementPlugin {
 	apply(compiler: Compiler): void;
 	static getParserHooks(parser: JavascriptParser): HMRJavascriptParserHooks;
 }
+
+/**
+ * These properties are added by the HotModuleReplacementPlugin
+ */
+declare interface HotModuleReplacementPluginLoaderContext {
+	hot?: boolean;
+}
 declare class HotUpdateChunk extends Chunk {
 	constructor();
 }
@@ -4305,6 +4312,17 @@ type IgnorePluginOptions =
 			 */
 			checkResource?: (resource: string, context: string) => boolean;
 	  };
+declare interface ImportModuleOptions {
+	/**
+	 * the target layer
+	 */
+	layer?: string;
+
+	/**
+	 * the target public path
+	 */
+	publicPath?: string;
+}
 type ImportSource =
 	| undefined
 	| null
@@ -4365,30 +4383,30 @@ declare abstract class InitFragment {
 declare interface InputFileSystem {
 	readFile: (
 		arg0: string,
-		arg1: (arg0?: NodeJS.ErrnoException, arg1?: string | Buffer) => void
+		arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: string | Buffer) => void
 	) => void;
 	readJson?: (
 		arg0: string,
-		arg1: (arg0?: Error | NodeJS.ErrnoException, arg1?: any) => void
+		arg1: (arg0?: null | Error | NodeJS.ErrnoException, arg1?: any) => void
 	) => void;
 	readlink: (
 		arg0: string,
-		arg1: (arg0?: NodeJS.ErrnoException, arg1?: string | Buffer) => void
+		arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: string | Buffer) => void
 	) => void;
 	readdir: (
 		arg0: string,
 		arg1: (
-			arg0?: NodeJS.ErrnoException,
+			arg0?: null | NodeJS.ErrnoException,
 			arg1?: (string | Buffer)[] | IDirent[]
 		) => void
 	) => void;
 	stat: (
 		arg0: string,
-		arg1: (arg0?: NodeJS.ErrnoException, arg1?: IStats) => void
+		arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: IStats) => void
 	) => void;
 	realpath?: (
 		arg0: string,
-		arg1: (arg0?: NodeJS.ErrnoException, arg1?: string | Buffer) => void
+		arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: string | Buffer) => void
 	) => void;
 	purge?: (arg0?: string) => void;
 	join?: (arg0: string, arg1: string) => string;
@@ -4404,7 +4422,7 @@ declare interface IntermediateFileSystemExtras {
 	open: (
 		arg0: string,
 		arg1: string,
-		arg2: (arg0?: NodeJS.ErrnoException, arg1?: number) => void
+		arg2: (arg0?: null | NodeJS.ErrnoException, arg1?: number) => void
 	) => void;
 	read: (
 		arg0: number,
@@ -4412,13 +4430,16 @@ declare interface IntermediateFileSystemExtras {
 		arg2: number,
 		arg3: number,
 		arg4: number,
-		arg5: (arg0?: NodeJS.ErrnoException, arg1?: number) => void
+		arg5: (arg0?: null | NodeJS.ErrnoException, arg1?: number) => void
+	) => void;
+	close: (
+		arg0: number,
+		arg1: (arg0?: null | NodeJS.ErrnoException) => void
 	) => void;
-	close: (arg0: number, arg1: (arg0?: NodeJS.ErrnoException) => void) => void;
 	rename: (
 		arg0: string,
 		arg1: string,
-		arg2: (arg0?: NodeJS.ErrnoException) => void
+		arg2: (arg0?: null | NodeJS.ErrnoException) => void
 	) => void;
 }
 type InternalCell<T> = T | typeof TOMBSTONE | typeof UNDEFINED_MARKER;
@@ -5748,7 +5769,7 @@ declare interface LoadScriptCompilationHooks {
 	createScript: SyncWaterfallHook<[string, Chunk]>;
 }
 declare class LoadScriptRuntimeModule extends HelperRuntimeModule {
-	constructor();
+	constructor(withCreateScriptUrl?: boolean);
 	static getCompilationHooks(
 		compilation: Compilation
 	): LoadScriptCompilationHooks;
@@ -5780,12 +5801,45 @@ declare class LoadScriptRuntimeModule extends HelperRuntimeModule {
 declare interface Loader {
 	[index: string]: any;
 }
+type LoaderContext<OptionsType> = NormalModuleLoaderContext<OptionsType> &
+	LoaderRunnerLoaderContext<OptionsType> &
+	LoaderPluginLoaderContext &
+	HotModuleReplacementPluginLoaderContext;
+type LoaderDefinition<
+	OptionsType = {},
+	ContextAdditions = {}
+> = LoaderDefinitionFunction<OptionsType, ContextAdditions> & {
+	raw?: false;
+	pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
+};
+declare interface LoaderDefinitionFunction<
+	OptionsType = {},
+	ContextAdditions = {}
+> {
+	(
+		this: NormalModuleLoaderContext<OptionsType> &
+			LoaderRunnerLoaderContext<OptionsType> &
+			LoaderPluginLoaderContext &
+			HotModuleReplacementPluginLoaderContext &
+			ContextAdditions,
+		content: string,
+		sourceMap?: string | SourceMap,
+		additionalData?: AdditionalData
+	): string | void | Buffer | Promise<string | Buffer>;
+}
 declare interface LoaderItem {
 	loader: string;
 	options: any;
 	ident: null | string;
 	type: null | string;
 }
+declare interface LoaderModule<OptionsType = {}, ContextAdditions = {}> {
+	default?:
+		| RawLoaderDefinitionFunction<OptionsType, ContextAdditions>
+		| LoaderDefinitionFunction<OptionsType, ContextAdditions>;
+	raw?: false;
+	pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
+}
 declare class LoaderOptionsPlugin {
 	constructor(options?: LoaderOptionsPluginOptions);
 	options: LoaderOptionsPluginOptions;
@@ -5819,6 +5873,165 @@ declare interface LoaderOptionsPluginOptions {
 		context?: string;
 	};
 }
+
+/**
+ * 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,
+			sourceMap: any,
+			module: NormalModule
+		) => void
+	): void;
+	importModule(
+		request: string,
+		options: ImportModuleOptions,
+		callback: (err?: Error, exports?: any) => any
+	): void;
+	importModule(request: string, options?: ImportModuleOptions): Promise<any>;
+}
+
+/**
+ * The properties are added by https://github.com/webpack/loader-runner
+ */
+declare interface LoaderRunnerLoaderContext<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?: string | SourceMap,
+		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?: string | SourceMap,
+		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;
+	readonly currentRequest: string;
+	readonly data: any;
+
+	/**
+	 * 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;
+	readonly previousRequest: string;
+	readonly query: string | OptionsType;
+	readonly remainingRequest: string;
+	readonly request: string;
+
+	/**
+	 * An array of all the loaders. It is writeable in the pitch phase.
+	 * loaders = [{request: string, path: string, query: string, module: function}]
+	 * In the example:
+	 * [
+	 *   { request: "/abc/loader1.js?xyz",
+	 *     path: "/abc/loader1.js",
+	 *     query: "?xyz",
+	 *     module: [Function]
+	 *   },
+	 *   { request: "/abc/node_modules/loader2/index.js",
+	 *     path: "/abc/node_modules/loader2/index.js",
+	 *     query: "",
+	 *     module: [Function]
+	 *   }
+	 * ]
+	 */
+	loaders: {
+		request: string;
+		path: string;
+		query: string;
+		fragment: string;
+		options?: string | object;
+		ident: string;
+		normal?: Function;
+		pitch?: Function;
+		raw?: boolean;
+		data?: object;
+		pitchExecuted: boolean;
+		normalExecuted: boolean;
+	}[];
+
+	/**
+	 * 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;
+}
 declare class LoaderTargetPlugin {
 	constructor(target: string);
 	target: string;
@@ -6888,7 +7101,7 @@ declare class NormalModule extends Module {
 		options: WebpackOptionsNormalized,
 		compilation: Compilation,
 		fs: InputFileSystem
-	): any;
+	): NormalModuleLoaderContext<any>;
 	getCurrentLoader(loaderContext?: any, index?: any): null | LoaderItem;
 	createSource(
 		context: string,
@@ -6964,6 +7177,60 @@ declare abstract class NormalModuleFactory extends ModuleFactory {
 	createGenerator(type?: any, generatorOptions?: object): any;
 	getResolver(type?: any, resolveOptions?: any): ResolverWithOptions;
 }
+
+/**
+ * These properties are added by the NormalModule
+ */
+declare interface NormalModuleLoaderContext<OptionsType> {
+	version: number;
+	getOptions(): OptionsType;
+	getOptions(schema: Parameters<typeof validateFunction>[0]): OptionsType;
+	emitWarning(warning: Error): void;
+	emitError(error: Error): void;
+	getLogger(name?: string): WebpackLogger;
+	resolve(
+		context: string,
+		request: string,
+		callback: (
+			arg0: null | Error,
+			arg1?: string | false,
+			arg2?: ResolveRequest
+		) => void
+	): any;
+	getResolve(
+		options?: ResolveOptionsWithDependencyType
+	): {
+		(
+			context: string,
+			request: string,
+			callback: (
+				arg0: null | Error,
+				arg1?: string | false,
+				arg2?: ResolveRequest
+			) => void
+		): void;
+		(context: string, request: string): Promise<string>;
+	};
+	emitFile(
+		name: string,
+		content: string,
+		sourceMap?: string,
+		assetInfo?: AssetInfo
+	): void;
+	addBuildDependency(dep: string): void;
+	utils: {
+		absolutify: (context: string, request: string) => string;
+		contextify: (context: string, request: string) => string;
+	};
+	rootContext: string;
+	fs: InputFileSystem;
+	sourceMap?: boolean;
+	mode: "development" | "production" | "none";
+	webpack?: boolean;
+	_module?: NormalModule;
+	_compilation?: Compilation;
+	_compiler?: Compiler;
+}
 declare class NormalModuleReplacementPlugin {
 	/**
 	 * Create an instance of the plugin
@@ -7675,6 +7942,11 @@ declare interface Output {
 	 */
 	strictModuleExceptionHandling?: 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.
 	 */
@@ -7709,25 +7981,34 @@ declare interface OutputFileSystem {
 	writeFile: (
 		arg0: string,
 		arg1: string | Buffer,
-		arg2: (arg0?: NodeJS.ErrnoException) => void
+		arg2: (arg0?: null | NodeJS.ErrnoException) => void
+	) => void;
+	mkdir: (
+		arg0: string,
+		arg1: (arg0?: null | NodeJS.ErrnoException) => void
 	) => void;
-	mkdir: (arg0: string, arg1: (arg0?: NodeJS.ErrnoException) => void) => void;
 	readdir?: (
 		arg0: string,
 		arg1: (
-			arg0?: NodeJS.ErrnoException,
+			arg0?: null | NodeJS.ErrnoException,
 			arg1?: (string | Buffer)[] | IDirent[]
 		) => void
 	) => void;
-	rmdir?: (arg0: string, arg1: (arg0?: NodeJS.ErrnoException) => void) => void;
-	unlink?: (arg0: string, arg1: (arg0?: NodeJS.ErrnoException) => void) => void;
+	rmdir?: (
+		arg0: string,
+		arg1: (arg0?: null | NodeJS.ErrnoException) => void
+	) => void;
+	unlink?: (
+		arg0: string,
+		arg1: (arg0?: null | NodeJS.ErrnoException) => void
+	) => void;
 	stat: (
 		arg0: string,
-		arg1: (arg0?: NodeJS.ErrnoException, arg1?: IStats) => void
+		arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: IStats) => void
 	) => void;
 	readFile: (
 		arg0: string,
-		arg1: (arg0?: NodeJS.ErrnoException, arg1?: string | Buffer) => void
+		arg1: (arg0?: null | NodeJS.ErrnoException, arg1?: string | Buffer) => void
 	) => void;
 	join?: (arg0: string, arg1: string) => string;
 	relative?: (arg0: string, arg1: string) => string;
@@ -7937,6 +8218,11 @@ declare interface OutputNormalized {
 	 */
 	strictModuleExceptionHandling?: 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.
 	 */
@@ -8083,6 +8369,21 @@ declare interface PerformanceOptions {
 	 */
 	maxEntrypointSize?: number;
 }
+declare interface PitchLoaderDefinitionFunction<
+	OptionsType = {},
+	ContextAdditions = {}
+> {
+	(
+		this: NormalModuleLoaderContext<OptionsType> &
+			LoaderRunnerLoaderContext<OptionsType> &
+			LoaderPluginLoaderContext &
+			HotModuleReplacementPluginLoaderContext &
+			ContextAdditions,
+		remainingRequest: string,
+		previousRequest: string,
+		data: object
+	): string | void | Buffer | Promise<string | Buffer>;
+}
 type Plugin =
 	| { apply: (arg0: Resolver) => void }
 	| ((this: Resolver, arg1: Resolver) => void);
@@ -8370,6 +8671,28 @@ declare interface RawChunkGroupOptions {
 	preloadOrder?: number;
 	prefetchOrder?: number;
 }
+type RawLoaderDefinition<
+	OptionsType = {},
+	ContextAdditions = {}
+> = RawLoaderDefinitionFunction<OptionsType, ContextAdditions> & {
+	raw: true;
+	pitch?: PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>;
+};
+declare interface RawLoaderDefinitionFunction<
+	OptionsType = {},
+	ContextAdditions = {}
+> {
+	(
+		this: NormalModuleLoaderContext<OptionsType> &
+			LoaderRunnerLoaderContext<OptionsType> &
+			LoaderPluginLoaderContext &
+			HotModuleReplacementPluginLoaderContext &
+			ContextAdditions,
+		content: Buffer,
+		sourceMap?: string | SourceMap,
+		additionalData?: AdditionalData
+	): string | void | Buffer | Promise<string | Buffer>;
+}
 declare class RawSource extends Source {
 	constructor(source: string | Buffer, convertToString?: boolean);
 	isBuffer(): boolean;
@@ -9955,10 +10278,6 @@ declare interface RuntimeValueOptions {
 	buildDependencies?: string[];
 	version?: string | (() => string);
 }
-type Schema =
-	| (JSONSchema4 & Extend)
-	| (JSONSchema6 & Extend)
-	| (JSONSchema7 & Extend);
 declare interface ScopeInfo {
 	definitions: StackedMap<string, ScopeInfo | VariableInfo>;
 	topLevelScope: boolean | "arrow";
@@ -10234,6 +10553,15 @@ declare interface SourceData {
 declare interface SourceLike {
 	source(): string | Buffer;
 }
+declare interface SourceMap {
+	version: number;
+	sources: string[];
+	mappings: string;
+	file?: string;
+	sourceRoot?: string;
+	sourcesContent?: string[];
+	names?: string[];
+}
 declare class SourceMapDevToolPlugin {
 	constructor(options?: SourceMapDevToolPluginOptions);
 	sourceMapFilename: string | false;
@@ -10985,6 +11313,16 @@ declare interface TimestampAndHash {
 	timestampHash?: string;
 	hash: string;
 }
+
+/**
+ * Use a Trusted Types policy to create urls for chunks.
+ */
+declare interface TrustedTypes {
+	/**
+	 * The name of the Trusted Types policy created by webpack to serve bundle chunks.
+	 */
+	policyName?: string;
+}
 declare const UNDEFINED_MARKER: unique symbol;
 declare interface UpdateHashContextDependency {
 	chunkGraph: ChunkGraph;
@@ -11623,8 +11961,8 @@ declare namespace exports {
 	};
 	export const validate: (options?: any) => void;
 	export const validateSchema: (
-		schema: Schema,
-		options: object | object[],
+		schema: Parameters<typeof validateFunction>[0],
+		options: Parameters<typeof validateFunction>[1],
 		validationConfiguration?: ValidationErrorConfiguration
 	) => void;
 	export const version: string;
@@ -11712,6 +12050,7 @@ declare namespace exports {
 		export let uncaughtErrorHandler: string;
 		export let scriptNonce: string;
 		export let loadScript: string;
+		export let createScriptUrl: string;
 		export let chunkName: string;
 		export let runtimeId: string;
 		export let getChunkScriptFilename: string;
@@ -11750,8 +12089,6 @@ declare namespace exports {
 		Unknown: 3;
 		Used: 4;
 	}>;
-	export const WebpackOptionsValidationError: ValidationError;
-	export const ValidationError: ValidationError;
 	export namespace cache {
 		export { MemoryCachePlugin };
 	}
@@ -12010,6 +12347,8 @@ declare namespace exports {
 		WebpackError,
 		WebpackOptionsApply,
 		WebpackOptionsDefaulter,
+		ValidationError as WebpackOptionsValidationError,
+		ValidationError,
 		Entry,
 		EntryNormalized,
 		EntryObject,
@@ -12042,7 +12381,14 @@ declare namespace exports {
 		StatsModuleReason,
 		StatsModuleTraceDependency,
 		StatsModuleTraceItem,
-		StatsProfile
+		StatsProfile,
+		LoaderModule,
+		RawLoaderDefinition,
+		LoaderDefinition,
+		LoaderDefinitionFunction,
+		PitchLoaderDefinitionFunction,
+		RawLoaderDefinitionFunction,
+		LoaderContext
 	};
 }