vue-simple-range-slider

/* * This file was automatically generated. * DO NOT MODIFY BY HAND. * Run `yarn special-lint-fix` to update */ import { Buffer } from "buffer"; import { ArrayExpression, ArrayPattern, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AssignmentProperty, AwaitExpression, BigIntLiteral, BinaryExpression, BlockStatement, BreakStatement, CatchClause, ChainExpression, ClassBody, ClassDeclaration, ClassExpression, Comment, ConditionalExpression, ContinueStatement, DebuggerStatement, DoWhileStatement, EmptyStatement, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier, ExpressionStatement, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier, LabeledStatement, LogicalExpression, MemberExpression, MetaProperty, MethodDefinition, NewExpression, ObjectExpression, ObjectPattern, PrivateIdentifier, Program, Property, PropertyDefinition, RegExpLiteral, RestElement, ReturnStatement, SequenceExpression, SimpleCallExpression, SimpleLiteral, SpreadElement, StaticBlock, Super, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UpdateExpression, VariableDeclaration, VariableDeclarator, WhileStatement, WithStatement, YieldExpression } from "estree"; import { ServerOptions as ServerOptionsImport } from "http"; import { ListenOptions, Server } from "net"; import { validate as validateFunction } from "schema-utils"; import { default as ValidationError } from "schema-utils/declarations/ValidationError"; import { ValidationErrorConfiguration } from "schema-utils/declarations/validate"; import { AsArray, AsyncParallelHook, AsyncSeriesBailHook, AsyncSeriesHook, AsyncSeriesWaterfallHook, HookMap, MultiHook, SyncBailHook, SyncHook, SyncWaterfallHook } from "tapable"; import { SecureContextOptions, TlsOptions } from "tls"; declare class AbstractLibraryPlugin<T> { constructor(__0: { /** * name of the plugin */ pluginName: string; /** * used library type */ type: string; }); /** * Apply the plugin */ apply(compiler: Compiler): void; parseOptions(library: LibraryOptions): false | T; finishEntryModule( module: Module, entryName: string, libraryContext: LibraryContext<T> ): void; embedInRuntimeBailout( module: Module, renderContext: RenderContext, libraryContext: LibraryContext<T> ): undefined | string; strictRuntimeBailout( renderContext: RenderContext, libraryContext: LibraryContext<T> ): undefined | string; runtimeRequirements( chunk: Chunk, set: Set<string>, libraryContext: LibraryContext<T> ): void; render( source: Source, renderContext: RenderContext, libraryContext: LibraryContext<T> ): Source; renderStartup( source: Source, module: Module, renderContext: StartupRenderContext, libraryContext: LibraryContext<T> ): Source; chunkHash( chunk: Chunk, hash: Hash, chunkHashContext: ChunkHashContext, libraryContext: LibraryContext<T> ): void; static COMMON_LIBRARY_NAME_MESSAGE: string; } declare interface AdditionalData { [index: string]: any; webpackAST: object; } declare class AggressiveMergingPlugin { constructor(options?: any); options: any; /** * Apply the plugin */ apply(compiler: Compiler): void; } declare class AggressiveSplittingPlugin { constructor(options?: AggressiveSplittingPluginOptions); options: AggressiveSplittingPluginOptions; /** * Apply the plugin */ apply(compiler: Compiler): void; 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; } declare interface AliasOption { alias: string | false | string[]; name: string; onlyModule?: boolean; } type AliasOptionNewRequest = string | false | string[]; declare interface AliasOptions { [index: string]: AliasOptionNewRequest; } declare interface Argument { description: string; simpleType: "string" | "number" | "boolean"; multiple: boolean; configs: ArgumentConfig[]; } declare interface ArgumentConfig { description: string; negatedDescription?: string; path: string; multiple: boolean; type: "string" | "number" | "boolean" | "path" | "enum" | "RegExp" | "reset"; values?: any[]; } declare interface Asset { /** * the filename of the asset */ name: string; /** * source of the asset */ source: Source; /** * info about the asset */ info: AssetInfo; } declare interface AssetEmittedInfo { content: Buffer; source: Source; compilation: Compilation; outputPath: string; targetPath: string; } type AssetFilterItemTypes = | string | RegExp | ((name: string, asset: StatsAsset) => boolean); /** * 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 { /** * The options for data url generator. */ dataUrl?: | AssetGeneratorDataUrlOptions | (( source: string | Buffer, context: { filename: string; module: Module } ) => string); } /** * 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 { /** * Emit an output asset from this asset module. This can be set to 'false' to omit emitting e. g. for SSR. */ emit?: boolean; /** * Specifies the filename template 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 | ((pathData: PathData, assetInfo?: AssetInfo) => string); /** * 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 | ((pathData: PathData, assetInfo?: AssetInfo) => string); /** * The 'publicPath' specifies the public URL address of the output files when referenced in a browser. */ publicPath?: string | ((pathData: PathData, assetInfo?: AssetInfo) => string); } declare class AsyncDependenciesBlock extends DependenciesBlock { constructor( groupOptions: RawChunkGroupOptions & { name?: string } & { entryOptions?: EntryOptions; }, loc?: SyntheticDependencyLocation | RealDependencyLocation, request?: string ); groupOptions: RawChunkGroupOptions & { name?: string } & { entryOptions?: EntryOptions; }; loc?: SyntheticDependencyLocation | RealDependencyLocation; request?: string; chunkName: string; module: any; } declare abstract class AsyncQueue<T, K, R> { hooks: { beforeAdd: AsyncSeriesHook<[T]>; added: SyncHook<[T]>; beforeStart: AsyncSeriesHook<[T]>; started: SyncHook<[T]>; result: SyncHook<[T, Error, R]>; }; add(item: T, callback: CallbackAsyncQueue<R>): void; invalidate(item: T): void; /** * Waits for an already started item */ waitFor(item: T, callback: CallbackAsyncQueue<R>): void; stop(): void; increaseParallelism(): void; decreaseParallelism(): void; isProcessing(item: T): boolean; isQueued(item: T): boolean; isDone(item: T): boolean; clear(): void; } declare class AsyncWebAssemblyModulesPlugin { constructor(options?: any); options: any; /** * Apply the plugin */ apply(compiler: Compiler): void; renderModule(module?: any, renderContext?: any, hooks?: any): any; static getCompilationHooks( compilation: Compilation ): CompilationHooksAsyncWebAssemblyModulesPlugin; } declare class AutomaticPrefetchPlugin { constructor(); /** * Apply the plugin */ apply(compiler: Compiler): void; } type AuxiliaryComment = string | LibraryCustomUmdCommentObject; declare interface BackendApi { dispose: (arg0?: Error) => void; module: (arg0: Module) => { client: string; data: string; active: boolean }; } declare class BannerPlugin { constructor(options: BannerPluginArgument); options: BannerPluginOptions; banner: (data: { hash: string; chunk: Chunk; filename: string }) => string; /** * Apply the plugin */ apply(compiler: Compiler): void; } type BannerPluginArgument = | string | BannerPluginOptions | ((data: { hash: string; chunk: Chunk; filename: string }) => string); declare interface BannerPluginOptions { /** * Specifies the banner. */ banner: | string | ((data: { hash: string; 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 | Rule[]; /** * 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 | Rule[]; /** * If true, banner will not be wrapped in a comment. */ raw?: boolean; /** * Include all modules that pass test assertion. */ test?: string | RegExp | Rule[]; } declare interface BaseResolveRequest { path: string | false; descriptionFilePath?: string; descriptionFileRoot?: string; descriptionFileData?: object; relativePath?: string; ignoreSymlinks?: boolean; fullySpecified?: boolean; } declare abstract class BasicEvaluatedExpression { type: number; range: [number, number]; falsy: boolean; truthy: boolean; nullish?: boolean; sideEffects: boolean; bool?: boolean; number?: number; bigint?: bigint; regExp?: RegExp; string?: string; quasis?: BasicEvaluatedExpression[]; parts?: BasicEvaluatedExpression[]; array?: any[]; items?: BasicEvaluatedExpression[]; options?: BasicEvaluatedExpression[]; prefix?: BasicEvaluatedExpression; postfix?: BasicEvaluatedExpression; wrappedInnerExpressions: any; identifier?: string | VariableInfoInterface; rootInfo: VariableInfoInterface; getMembers: () => string[]; getMembersOptionals: () => boolean[]; expression: NodeEstreeIndex; 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; /** * Gets the compile-time value of the expression */ asCompileTimeValue(): any; isTruthy(): boolean; isFalsy(): boolean; isNullish(): undefined | boolean; /** * Can this expression have side effects? */ couldHaveSideEffects(): boolean; asBool(): any; asNullish(): undefined | boolean; asString(): any; setString(string?: any): BasicEvaluatedExpression; setUndefined(): BasicEvaluatedExpression; setNull(): BasicEvaluatedExpression; setNumber(number?: any): BasicEvaluatedExpression; setBigInt(bigint?: any): BasicEvaluatedExpression; setBoolean(bool?: any): BasicEvaluatedExpression; setRegExp(regExp?: any): BasicEvaluatedExpression; setIdentifier( identifier?: any, rootInfo?: any, getMembers?: any, getMembersOptionals?: any ): BasicEvaluatedExpression; setWrapped( prefix?: any, postfix?: any, innerExpressions?: any ): BasicEvaluatedExpression; setOptions(options?: any): BasicEvaluatedExpression; addOptions(options?: any): BasicEvaluatedExpression; setItems(items?: any): BasicEvaluatedExpression; setArray(array?: any): BasicEvaluatedExpression; setTemplateString( quasis?: any, parts?: any, kind?: any ): BasicEvaluatedExpression; templateStringKind: any; setTruthy(): BasicEvaluatedExpression; setFalsy(): BasicEvaluatedExpression; setNullish(value?: any): BasicEvaluatedExpression; setRange(range?: any): BasicEvaluatedExpression; setSideEffects(sideEffects?: boolean): BasicEvaluatedExpression; setExpression(expression?: any): BasicEvaluatedExpression; } type BuildMeta = KnownBuildMeta & Record<string, any>; declare abstract class ByTypeGenerator extends Generator { map: any; } declare const CIRCULAR_CONNECTION: unique symbol; declare class Cache { constructor(); hooks: { get: AsyncSeriesBailHook< [ string, null | Etag, ((result: any, callback: (arg0?: Error) => void) => void)[] ], any >; store: AsyncParallelHook<[string, null | Etag, any]>; storeBuildDependencies: AsyncParallelHook<[Iterable<string>]>; beginIdle: SyncHook<[]>; endIdle: AsyncParallelHook<[]>; shutdown: AsyncParallelHook<[]>; }; get<T>( identifier: string, etag: null | Etag, callback: CallbackCache<T> ): void; store<T>( identifier: string, etag: null | Etag, data: T, callback: CallbackCache<void> ): void; /** * After this method has succeeded the cache can only be restored when build dependencies are */ storeBuildDependencies( dependencies: Iterable<string>, callback: CallbackCache<void> ): void; beginIdle(): void; endIdle(callback: CallbackCache<void>): void; shutdown(callback: CallbackCache<void>): void; static STAGE_MEMORY: number; static STAGE_DEFAULT: number; static STAGE_DISK: number; static STAGE_NETWORK: number; } declare abstract class CacheFacade { getChildCache(name: string): CacheFacade; getItemCache(identifier: string, etag: null | Etag): ItemCacheFacade; getLazyHashedEtag(obj: HashableObject): Etag; mergeEtags(a: Etag, b: Etag): Etag; get<T>( identifier: string, etag: null | Etag, callback: CallbackCache<T> ): void; getPromise<T>(identifier: string, etag: null | Etag): Promise<T>; store<T>( identifier: string, etag: null | Etag, data: T, callback: CallbackCache<void> ): void; storePromise<T>( identifier: string, etag: null | Etag, data: T ): Promise<void>; provide<T>( identifier: string, etag: null | Etag, computer: (arg0: CallbackNormalErrorCache<T>) => void, callback: CallbackNormalErrorCache<T> ): void; providePromise<T>( identifier: string, etag: null | Etag, computer: () => T | Promise<T> ): Promise<T>; } declare interface CacheGroupSource { key?: string; priority?: number; getName?: ( module?: Module, chunks?: Chunk[], key?: string ) => undefined | string; chunksFilter?: (chunk: Chunk) => boolean; enforce?: boolean; minSize: SplitChunksSizes; minSizeReduction: SplitChunksSizes; minRemainingSize: SplitChunksSizes; enforceSizeThreshold: SplitChunksSizes; maxAsyncSize: SplitChunksSizes; maxInitialSize: SplitChunksSizes; minChunks?: number; maxAsyncRequests?: number; maxInitialRequests?: number; filename?: string | ((arg0: PathData, arg1?: AssetInfo) => string); idHint?: string; automaticNameDelimiter: string; reuseExistingChunk?: boolean; usedExports?: boolean; } declare interface CacheGroupsContext { moduleGraph: ModuleGraph; chunkGraph: ChunkGraph; } type CacheOptionsNormalized = false | FileCacheOptions | MemoryCacheOptions; declare class CachedSource extends Source { constructor(source: Source); constructor(source: Source | (() => Source), cachedData?: any); original(): Source; originalLazy(): Source | (() => Source); getCachedData(): any; } type CallExpression = SimpleCallExpression | NewExpression; declare interface CallExpressionInfo { type: "call"; call: CallExpression; calleeName: string; rootInfo: string | VariableInfo; getCalleeMembers: () => string[]; name: string; getMembers: () => string[]; getMembersOptionals: () => boolean[]; } declare interface CallbackAsyncQueue<T> { (err?: null | WebpackError, result?: T): any; } declare interface CallbackCache<T> { (err?: null | WebpackError, result?: T): void; } declare interface CallbackFunction<T> { (err?: null | Error, result?: T): any; } declare interface CallbackNormalErrorCache<T> { (err?: null | Error, result?: T): void; } declare interface CallbackWebpack<T> { (err?: Error, stats?: T): void; } type Cell<T> = undefined | T; declare class Chunk { constructor(name?: string, backCompat?: boolean); id: null | string | number; ids: null | (string | number)[]; debugId: number; name: string; idNameHints: SortableSet<string>; preventIntegration: boolean; filenameTemplate: | null | string | ((arg0: PathData, arg1?: AssetInfo) => string); cssFilenameTemplate: | null | string | ((arg0: PathData, arg1?: AssetInfo) => string); runtime: RuntimeSpec; files: Set<string>; auxiliaryFiles: Set<string>; rendered: boolean; hash?: string; contentHash: Record<string, string>; renderedHash?: string; chunkReason?: string; extraAsync: boolean; readonly entryModule?: Module; hasEntryModule(): boolean; addModule(module: Module): boolean; removeModule(module: Module): void; getNumberOfModules(): number; readonly modulesIterable: Iterable<Module>; compareTo(otherChunk: Chunk): 0 | 1 | -1; containsModule(module: Module): boolean; getModules(): Module[]; remove(): void; moveModule(module: Module, otherChunk: Chunk): void; integrate(otherChunk: Chunk): boolean; canBeIntegrated(otherChunk: Chunk): boolean; isEmpty(): boolean; modulesSize(): number; size(options?: ChunkSizeOptions): number; integratedSize(otherChunk: Chunk, options: ChunkSizeOptions): number; getChunkModuleMaps(filterFn: (m: Module) => boolean): ChunkModuleMaps; hasModuleInGraph( filterFn: (m: Module) => boolean, filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean ): boolean; getChunkMaps(realHash: boolean): ChunkMaps; hasRuntime(): boolean; canBeInitial(): boolean; isOnlyInitial(): boolean; getEntryOptions(): undefined | EntryOptions; addGroup(chunkGroup: ChunkGroup): void; removeGroup(chunkGroup: ChunkGroup): void; isInGroup(chunkGroup: ChunkGroup): boolean; getNumberOfGroups(): number; readonly groupsIterable: Iterable<ChunkGroup>; disconnectFromGroups(): void; split(newChunk: Chunk): void; updateHash(hash: Hash, chunkGraph: ChunkGraph): void; getAllAsyncChunks(): Set<Chunk>; getAllInitialChunks(): Set<Chunk>; getAllReferencedChunks(): Set<Chunk>; getAllReferencedAsyncEntrypoints(): Set<Entrypoint>; hasAsyncChunks(): boolean; getChildIdsByOrders( chunkGraph: ChunkGraph, filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean ): Record<string, (string | number)[]>; getChildrenOfTypeInOrder( chunkGraph: ChunkGraph, type: string ): { onChunks: Chunk[]; chunks: Set<Chunk> }[]; getChildIdsByOrdersMap( chunkGraph: ChunkGraph, includeDirectChildren?: boolean, filterFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean ): Record<string | number, Record<string, (string | number)[]>>; } declare class ChunkGraph { constructor(moduleGraph: ModuleGraph, hashFunction?: string | typeof Hash); moduleGraph: ModuleGraph; connectChunkAndModule(chunk: Chunk, module: Module): void; disconnectChunkAndModule(chunk: Chunk, module: Module): void; disconnectChunk(chunk: Chunk): void; attachModules(chunk: Chunk, modules: Iterable<Module>): void; attachRuntimeModules(chunk: Chunk, modules: Iterable<RuntimeModule>): void; attachFullHashModules(chunk: Chunk, modules: Iterable<RuntimeModule>): void; attachDependentHashModules( chunk: Chunk, modules: Iterable<RuntimeModule> ): void; replaceModule(oldModule: Module, newModule: Module): void; isModuleInChunk(module: Module, chunk: Chunk): boolean; isModuleInChunkGroup(module: Module, chunkGroup: ChunkGroup): boolean; isEntryModule(module: Module): boolean; getModuleChunksIterable(module: Module): Iterable<Chunk>; getOrderedModuleChunksIterable( module: Module, sortFn: (arg0: Chunk, arg1: Chunk) => 0 | 1 | -1 ): Iterable<Chunk>; getModuleChunks(module: Module): Chunk[]; getNumberOfModuleChunks(module: Module): number; getModuleRuntimes(module: Module): RuntimeSpecSet; getNumberOfChunkModules(chunk: Chunk): number; getNumberOfChunkFullHashModules(chunk: Chunk): number; getChunkModulesIterable(chunk: Chunk): Iterable<Module>; getChunkModulesIterableBySourceType( chunk: Chunk, sourceType: string ): undefined | Iterable<Module>; setChunkModuleSourceTypes( chunk: Chunk, module: Module, sourceTypes: Set<string> ): void; getChunkModuleSourceTypes(chunk: Chunk, module: Module): Set<string>; getModuleSourceTypes(module: Module): Set<string>; getOrderedChunkModulesIterable( chunk: Chunk, comparator: (arg0: Module, arg1: Module) => 0 | 1 | -1 ): Iterable<Module>; getOrderedChunkModulesIterableBySourceType( chunk: Chunk, sourceType: string, comparator: (arg0: Module, arg1: Module) => 0 | 1 | -1 ): undefined | Iterable<Module>; getChunkModules(chunk: Chunk): Module[]; getOrderedChunkModules( chunk: Chunk, comparator: (arg0: Module, arg1: Module) => 0 | 1 | -1 ): Module[]; getChunkModuleIdMap( chunk: Chunk, filterFn: (m: Module) => boolean, includeAllChunks?: boolean ): Record<string | number, (string | number)[]>; getChunkModuleRenderedHashMap( chunk: Chunk, filterFn: (m: Module) => boolean, hashLength?: number, includeAllChunks?: boolean ): Record<string | number, Record<string | number, string>>; getChunkConditionMap( chunk: Chunk, filterFn: (c: Chunk, chunkGraph: ChunkGraph) => boolean ): Record<string | number, boolean>; hasModuleInGraph( chunk: Chunk, filterFn: (m: Module) => boolean, filterChunkFn?: (c: Chunk, chunkGraph: ChunkGraph) => boolean ): boolean; compareChunks(chunkA: Chunk, chunkB: Chunk): 0 | 1 | -1; getChunkModulesSize(chunk: Chunk): number; getChunkModulesSizes(chunk: Chunk): Record<string, number>; getChunkRootModules(chunk: Chunk): Module[]; getChunkSize(chunk: Chunk, options?: ChunkSizeOptions): number; getIntegratedChunksSize( chunkA: Chunk, chunkB: Chunk, options?: ChunkSizeOptions ): number; canChunksBeIntegrated(chunkA: Chunk, chunkB: Chunk): boolean; integrateChunks(chunkA: Chunk, chunkB: Chunk): void; upgradeDependentToFullHashModules(chunk: Chunk): void; isEntryModuleInChunk(module: Module, chunk: Chunk): boolean; connectChunkAndEntryModule( chunk: Chunk, module: Module, entrypoint?: Entrypoint ): void; connectChunkAndRuntimeModule(chunk: Chunk, module: RuntimeModule): void; addFullHashModuleToChunk(chunk: Chunk, module: RuntimeModule): void; addDependentHashModuleToChunk(chunk: Chunk, module: RuntimeModule): void; disconnectChunkAndEntryModule(chunk: Chunk, module: Module): void; disconnectChunkAndRuntimeModule(chunk: Chunk, module: RuntimeModule): void; disconnectEntryModule(module: Module): void; disconnectEntries(chunk: Chunk): void; getNumberOfEntryModules(chunk: Chunk): number; getNumberOfRuntimeModules(chunk: Chunk): number; getChunkEntryModulesIterable(chunk: Chunk): Iterable<Module>; getChunkEntryDependentChunksIterable(chunk: Chunk): Iterable<Chunk>; hasChunkEntryDependentChunks(chunk: Chunk): boolean; getChunkRuntimeModulesIterable(chunk: Chunk): Iterable<RuntimeModule>; getChunkRuntimeModulesInOrder(chunk: Chunk): RuntimeModule[]; getChunkFullHashModulesIterable( chunk: Chunk ): undefined | Iterable<RuntimeModule>; getChunkFullHashModulesSet( chunk: Chunk ): undefined | ReadonlySet<RuntimeModule>; getChunkDependentHashModulesIterable( chunk: Chunk ): undefined | Iterable<RuntimeModule>; getChunkEntryModulesWithChunkGroupIterable( chunk: Chunk ): Iterable<[Module, undefined | Entrypoint]>; getBlockChunkGroup(depBlock: AsyncDependenciesBlock): ChunkGroup; connectBlockAndChunkGroup( depBlock: AsyncDependenciesBlock, chunkGroup: ChunkGroup ): void; disconnectChunkGroup(chunkGroup: ChunkGroup): void; getModuleId(module: Module): string | number; setModuleId(module: Module, id: string | number): void; getRuntimeId(runtime: string): string | number; setRuntimeId(runtime: string, id: string | number): void; hasModuleHashes(module: Module, runtime: RuntimeSpec): boolean; getModuleHash(module: Module, runtime: RuntimeSpec): string; getRenderedModuleHash(module: Module, runtime: RuntimeSpec): string; setModuleHashes( module: Module, runtime: RuntimeSpec, hash: string, renderedHash: string ): void; addModuleRuntimeRequirements( module: Module, runtime: RuntimeSpec, items: Set<string>, transferOwnership?: boolean ): void; addChunkRuntimeRequirements(chunk: Chunk, items: Set<string>): void; addTreeRuntimeRequirements(chunk: Chunk, items: Iterable<string>): void; getModuleRuntimeRequirements( module: Module, runtime: RuntimeSpec ): ReadonlySet<string>; getChunkRuntimeRequirements(chunk: Chunk): ReadonlySet<string>; getModuleGraphHash( module: Module, runtime: RuntimeSpec, withConnections?: boolean ): string; getModuleGraphHashBigInt( module: Module, runtime: RuntimeSpec, withConnections?: boolean ): bigint; getTreeRuntimeRequirements(chunk: Chunk): ReadonlySet<string>; static getChunkGraphForModule( module: Module, deprecateMessage: string, deprecationCode: string ): ChunkGraph; static setChunkGraphForModule(module: Module, chunkGraph: ChunkGraph): void; static clearChunkGraphForModule(module: Module): void; static getChunkGraphForChunk( chunk: Chunk, deprecateMessage: string, deprecationCode: string ): ChunkGraph; static setChunkGraphForChunk(chunk: Chunk, chunkGraph: ChunkGraph): void; static clearChunkGraphForChunk(chunk: Chunk): void; } declare abstract class ChunkGroup { groupDebugId: number; options: ChunkGroupOptions; chunks: Chunk[]; origins: OriginRecord[]; index: number; /** * when a new chunk is added to a chunkGroup, addingOptions will occur. */ addOptions(options: ChunkGroupOptions): void; /** * returns the name of current ChunkGroup * sets a new name for current ChunkGroup */ name?: string; /** * get a uniqueId for ChunkGroup, made up of its member Chunk debugId's */ readonly debugId: string; /** * get a unique id for ChunkGroup, made up of its member Chunk id's */ readonly id: string; /** * Performs an unshift of a specific chunk */ unshiftChunk(chunk: Chunk): boolean; /** * inserts a chunk before another existing chunk in group */ insertChunk(chunk: Chunk, before: Chunk): boolean; /** * add a chunk into ChunkGroup. Is pushed on or prepended */ pushChunk(chunk: Chunk): boolean; replaceChunk(oldChunk: Chunk, newChunk: Chunk): boolean; removeChunk(chunk: Chunk): boolean; isInitial(): boolean; addChild(group: ChunkGroup): boolean; getChildren(): ChunkGroup[]; getNumberOfChildren(): number; readonly childrenIterable: SortableSet<ChunkGroup>; removeChild(group: ChunkGroup): boolean; addParent(parentChunk: ChunkGroup): boolean; getParents(): ChunkGroup[]; getNumberOfParents(): number; hasParent(parent: ChunkGroup): boolean; readonly parentsIterable: SortableSet<ChunkGroup>; removeParent(chunkGroup: ChunkGroup): boolean; addAsyncEntrypoint(entrypoint: Entrypoint): boolean; readonly asyncEntrypointsIterable: SortableSet<ChunkGroup>; getBlocks(): any[]; getNumberOfBlocks(): number; hasBlock(block?: any): boolean; readonly blocksIterable: Iterable<AsyncDependenciesBlock>; addBlock(block: AsyncDependenciesBlock): boolean; addOrigin(module: Module, loc: DependencyLocation, request: string): void; getFiles(): string[]; 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; getChildrenByOrders( moduleGraph: ModuleGraph, chunkGraph: ChunkGraph ): Record<string, ChunkGroup[]>; /** * Sets the top-down index of a module in this ChunkGroup */ setModulePreOrderIndex(module: Module, index: number): void; /** * Gets the top-down index of a module in this ChunkGroup */ getModulePreOrderIndex(module: Module): number; /** * Sets the bottom-up index of a module in this ChunkGroup */ setModulePostOrderIndex(module: Module, index: number): void; /** * Gets the bottom-up index of a module in this ChunkGroup */ getModulePostOrderIndex(module: Module): number; checkConstraints(): void; getModuleIndex: (module: Module) => number; getModuleIndex2: (module: Module) => number; } type ChunkGroupOptions = RawChunkGroupOptions & { name?: string }; 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 ChunkMaps { hash: Record<string | number, string>; contentHash: Record<string | number, Record<string, string>>; name: Record<string | number, string>; } declare class ChunkModuleIdRangePlugin { constructor(options?: any); options: any; /** * Apply the plugin */ apply(compiler: Compiler): void; } declare interface ChunkModuleMaps { id: Record<string | number, (string | number)[]>; hash: Record<string | number, string>; } declare interface ChunkPathData { id: string | number; name?: string; hash: string; hashWithLength?: (arg0: number) => string; contentHash?: Record<string, string>; contentHashWithLength?: Record<string, (length: number) => string>; } declare class ChunkPrefetchPreloadPlugin { constructor(); apply(compiler: Compiler): void; } declare interface ChunkRenderContext { /** * 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<ChunkRenderContext>[]; /** * rendering in strict context */ strictMode: boolean; } declare interface ChunkSizeOptions { /** * constant overhead for a chunk */ chunkOverhead?: number; /** * multiplicator for initial chunks */ entryChunkMultiplicator?: number; } declare abstract class ChunkTemplate { hooks: Readonly<{ renderManifest: { tap: (options?: any, fn?: any) => void }; modules: { tap: (options?: any, fn?: any) => void }; render: { tap: (options?: any, fn?: any) => void }; renderWithEntry: { tap: (options?: any, fn?: any) => void }; hash: { tap: (options?: any, fn?: any) => void }; hashForChunk: { tap: (options?: any, fn?: any) => void }; }>; readonly outputOptions: Output; } /** * 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 | ((filename: string) => boolean); } declare class CleanPlugin { constructor(options?: CleanOptions); options: { /** * Log the assets that should be removed instead of deleting them. */ dry: boolean; /** * Keep these assets. */ keep?: string | RegExp | ((filename: string) => boolean); }; /** * Apply the plugin */ apply(compiler: Compiler): void; static getCompilationHooks( compilation: Compilation ): CleanPluginCompilationHooks; } declare interface CleanPluginCompilationHooks { /** * when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config */ keep: SyncBailHook<[string], boolean>; } 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; /** * 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 CodeGenerationResult { /** * the resulting sources for all source types */ sources: Map<string, Source>; /** * the resulting data for all source types */ data?: Map<string, any>; /** * the runtime requirements */ runtimeRequirements: ReadonlySet<string>; /** * a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided) */ hash?: string; } declare abstract class CodeGenerationResults { map: Map<Module, RuntimeSpecMap<CodeGenerationResult>>; get(module: Module, runtime: RuntimeSpec): CodeGenerationResult; has(module: Module, runtime: RuntimeSpec): boolean; getSource(module: Module, runtime: RuntimeSpec, sourceType: string): Source; getRuntimeRequirements( module: Module, runtime: RuntimeSpec ): ReadonlySet<string>; getData(module: Module, runtime: RuntimeSpec, key: string): any; getHash(module: Module, runtime: RuntimeSpec): any; 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; declare interface Comparator<T> { (arg0: T, arg1: T): 0 | 1 | -1; } declare class CompatSource extends Source { constructor(sourceLike: SourceLike); static from(sourceLike: SourceLike): Source; } 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] >; executeModule: SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>; prepareModuleExecution: AsyncParallelHook< [ExecuteModuleArgument, ExecuteModuleContext] >; finishModules: AsyncSeriesHook<[Iterable<Module>]>; finishRebuildingModule: AsyncSeriesHook<[Module]>; unseal: SyncHook<[]>; seal: SyncHook<[]>; beforeChunks: SyncHook<[]>; afterChunks: SyncHook<[Iterable<Chunk>]>; optimizeDependencies: SyncBailHook<[Iterable<Module>], any>; afterOptimizeDependencies: SyncHook<[Iterable<Module>]>; optimize: SyncHook<[]>; optimizeModules: SyncBailHook<[Iterable<Module>], any>; afterOptimizeModules: SyncHook<[Iterable<Module>]>; optimizeChunks: SyncBailHook<[Iterable<Chunk>, ChunkGroup[]], any>; afterOptimizeChunks: SyncHook<[Iterable<Chunk>, ChunkGroup[]]>; optimizeTree: AsyncSeriesHook<[Iterable<Chunk>, Iterable<Module>]>; afterOptimizeTree: SyncHook<[Iterable<Chunk>, Iterable<Module>]>; optimizeChunkModules: AsyncSeriesBailHook< [Iterable<Chunk>, Iterable<Module>], any >; afterOptimizeChunkModules: SyncHook<[Iterable<Chunk>, Iterable<Module>]>; shouldRecord: SyncBailHook<[], boolean>; additionalChunkRuntimeRequirements: SyncHook< [Chunk, Set<string>, RuntimeRequirementsContext] >; runtimeRequirementInChunk: HookMap< SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], any> >; additionalModuleRuntimeRequirements: SyncHook< [Module, Set<string>, RuntimeRequirementsContext] >; runtimeRequirementInModule: HookMap< SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext], any> >; additionalTreeRuntimeRequirements: SyncHook< [Chunk, Set<string>, RuntimeRequirementsContext] >; runtimeRequirementInTree: HookMap< SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], any> >; runtimeModule: SyncHook<[RuntimeModule, Chunk]>; reviveModules: SyncHook<[Iterable<Module>, any]>; beforeModuleIds: SyncHook<[Iterable<Module>]>; moduleIds: SyncHook<[Iterable<Module>]>; optimizeModuleIds: SyncHook<[Iterable<Module>]>; afterOptimizeModuleIds: SyncHook<[Iterable<Module>]>; reviveChunks: SyncHook<[Iterable<Chunk>, any]>; beforeChunkIds: SyncHook<[Iterable<Chunk>]>; chunkIds: SyncHook<[Iterable<Chunk>]>; optimizeChunkIds: SyncHook<[Iterable<Chunk>]>; afterOptimizeChunkIds: SyncHook<[Iterable<Chunk>]>; recordModules: SyncHook<[Iterable<Module>, any]>; recordChunks: SyncHook<[Iterable<Chunk>, any]>; 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<[any]>; record: SyncHook<[Compilation, any]>; beforeModuleAssets: SyncHook<[]>; shouldGenerateChunkAssets: SyncBailHook<[], boolean>; beforeChunkAssets: SyncHook<[]>; additionalChunkAssets: FakeHook< Pick< AsyncSeriesHook<[Set<Chunk>]>, "name" | "tap" | "tapAsync" | "tapPromise" > >; additionalAssets: FakeHook< Pick<AsyncSeriesHook<[]>, "name" | "tap" | "tapAsync" | "tapPromise"> >; optimizeChunkAssets: FakeHook< Pick< AsyncSeriesHook<[Set<Chunk>]>, "name" | "tap" | "tapAsync" | "tapPromise" > >; afterOptimizeChunkAssets: FakeHook< Pick< AsyncSeriesHook<[Set<Chunk>]>, "name" | "tap" | "tapAsync" | "tapPromise" > >; optimizeAssets: AsyncSeriesHook< [CompilationAssets], ProcessAssetsAdditionalOptions >; afterOptimizeAssets: SyncHook<[CompilationAssets]>; processAssets: AsyncSeriesHook< [CompilationAssets], ProcessAssetsAdditionalOptions >; afterProcessAssets: SyncHook<[CompilationAssets]>; processAdditionalAssets: AsyncSeriesHook<[CompilationAssets]>; needAdditionalSeal: SyncBailHook<[], boolean>; afterSeal: AsyncSeriesHook<[]>; renderManifest: SyncWaterfallHook< [RenderManifestEntry[], RenderManifestOptions] >; fullHash: SyncHook<[Hash]>; chunkHash: SyncHook<[Chunk, Hash, ChunkHashContext]>; moduleAsset: SyncHook<[Module, string]>; chunkAsset: SyncHook<[Chunk, string]>; assetPath: SyncWaterfallHook<[string, object, AssetInfo]>; needAdditionalPass: SyncBailHook<[], boolean>; childCompiler: SyncHook<[Compiler, string, number]>; log: SyncBailHook<[string, LogEntry], true>; processWarnings: SyncWaterfallHook<[WebpackError[]]>; processErrors: SyncWaterfallHook<[WebpackError[]]>; statsPreset: HookMap< SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]> >; statsNormalize: SyncHook< [Partial<NormalizedStatsOptions>, CreateStatsOptionsContext] >; statsFactory: SyncHook<[StatsFactory, NormalizedStatsOptions]>; statsPrinter: SyncHook<[StatsPrinter, NormalizedStatsOptions]>; readonly normalModuleLoader: SyncHook<[object, NormalModule]>; }>; name?: string; startTime: any; endTime: any; compiler: Compiler; resolverFactory: ResolverFactory; inputFileSystem: InputFileSystem; fileSystemInfo: FileSystemInfo; valueCacheVersions: Map<string, string | Set<string>>; requestShortener: RequestShortener; compilerPath: string; logger: WebpackLogger; options: WebpackOptionsNormalized; outputOptions: OutputNormalized; bail: boolean; profile: boolean; params: CompilationParams; mainTemplate: MainTemplate; chunkTemplate: ChunkTemplate; runtimeTemplate: RuntimeTemplate; moduleTemplates: { javascript: ModuleTemplate }; 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: any; additionalChunkAssets: string[]; assets: CompilationAssets; assetsInfo: Map<string, AssetInfo>; errors: WebpackError[]; warnings: WebpackError[]; children: Compilation[]; logging: Map<string, LogEntry[]>; dependencyFactories: Map<DepConstructor, ModuleFactory>; dependencyTemplates: DependencyTemplates; childrenCounters: object; usedChunkIds: Set<string | number>; usedModuleIds: 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>; compilationDependencies: { add: (item?: any) => LazySet<string> }; getStats(): Stats; createStatsOptions( optionsOrPreset: string | StatsOptions, context?: CreateStatsOptionsContext ): NormalizedStatsOptions; createStatsFactory(options?: any): StatsFactory; createStatsPrinter(options?: any): StatsPrinter; getCache(name: string): CacheFacade; getLogger(name: string | (() => string)): WebpackLogger; addModule( module: Module, callback: (err?: null | WebpackError, result?: 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?: Module) => void ): void; processModuleDependencies( module: Module, callback: (err?: null | WebpackError, result?: Module) => void ): void; processModuleDependenciesNonRecursive(module: Module): void; handleModuleCreation( __0: HandleModuleCreationOptions, callback: (err?: null | WebpackError, result?: Module) => void ): void; addModuleChain( context: string, dependency: Dependency, callback: (err?: null | WebpackError, result?: Module) => void ): void; 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?: Module) => void ): void; addEntry( context: string, entry: Dependency, optionsOrName: string | EntryOptions, callback: (err?: null | WebpackError, result?: Module) => void ): void; addInclude( context: string, dependency: Dependency, options: EntryOptions, callback: (err?: null | WebpackError, result?: Module) => void ): void; rebuildModule( module: Module, callback: (err?: null | WebpackError, result?: Module) => void ): void; finish(callback?: any): void; unseal(): void; seal(callback: (err?: null | WebpackError) => void): void; reportDependencyErrorsAndWarnings( module: Module, blocks: DependenciesBlock[] ): boolean; codeGeneration(callback?: any): void; processRuntimeRequirements(__0?: { /** * the chunk graph */ chunkGraph?: ChunkGraph; /** * modules */ modules?: Iterable<Module>; /** * chunks */ chunks?: Iterable<Chunk>; /** * codeGenerationResults */ codeGenerationResults?: CodeGenerationResults; /** * chunkGraphEntries */ chunkGraphEntries?: Iterable<Chunk>; }): void; 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; 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?: string): Chunk; assignDepth(module: Module): void; assignDepths(modules: Set<Module>): void; getDependencyReferencedExports( dependency: Dependency, runtime: RuntimeSpec ): (string[] | ReferencedExport)[]; removeReasonsOfDependencyBlock( module: Module, block: DependenciesBlockLike ): void; patchChunksAfterReasonRemoval(module: Module, chunk: Chunk): void; removeChunkFromDependencies(block: DependenciesBlock, chunk: Chunk): void; assignRuntimeIds(): void; sortItemsWithChunkIds(): void; summarizeDependencies(): void; createModuleHashes(): void; createHash(): { module: Module; hash: string; runtime: RuntimeSpec; runtimes: RuntimeSpec[]; }[]; fullHash?: string; hash?: string; emitAsset(file: string, source: Source, assetInfo?: AssetInfo): void; updateAsset( file: string, newSourceOrFunction: Source | ((arg0: Source) => Source), assetInfoUpdateOrFunction?: AssetInfo | ((arg0?: AssetInfo) => AssetInfo) ): void; renameAsset(file?: any, newFile?: any): void; deleteAsset(file: string): void; getAssets(): Readonly<Asset>[]; getAsset(name: string): undefined | Readonly<Asset>; clearAssets(): void; createModuleAssets(): void; getRenderManifest(options: RenderManifestOptions): RenderManifestEntry[]; createChunkAssets(callback: (err?: null | WebpackError) => void): void; getPath( filename: string | ((arg0: PathData, arg1?: AssetInfo) => string), data?: PathData ): string; getPathWithInfo( filename: string | ((arg0: PathData, arg1?: AssetInfo) => string), data?: PathData ): { path: string; info: AssetInfo }; getAssetPath( filename: string | ((arg0: PathData, arg1?: AssetInfo) => string), data: PathData ): string; getAssetPathWithInfo( filename: string | ((arg0: PathData, arg1?: AssetInfo) => string), data: PathData ): { path: string; info: AssetInfo }; getWarnings(): WebpackError[]; getErrors(): WebpackError[]; /** * 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?: OutputNormalized, plugins?: ( | ((this: Compiler, compiler: Compiler) => void) | WebpackPluginInstance )[] ): Compiler; executeModule( module: Module, options: ExecuteModuleOptions, callback: (err?: null | WebpackError, result?: ExecuteModuleResult) => void ): void; checkConstraints(): void; factorizeModule: { ( options: FactorizeModuleOptions & { factoryResult?: false }, callback: (err?: null | WebpackError, result?: Module) => void ): void; ( options: FactorizeModuleOptions & { factoryResult: true }, callback: ( err?: null | WebpackError, result?: ModuleFactoryResult ) => void ): void; }; /** * Add additional assets to the compilation. */ static PROCESS_ASSETS_STAGE_ADDITIONAL: number; /*