import type * as estree from 'estree'; declare module 'estree' { export interface Decorator extends estree.BaseNode { type: 'Decorator'; expression: estree.Expression; } interface PropertyDefinition { decorators: estree.Decorator[]; } interface MethodDefinition { decorators: estree.Decorator[]; } interface BaseClass { decorators: estree.Decorator[]; } } export const VERSION: string; // utils type NullValue = null | undefined | void; type MaybeArray = T | T[]; type MaybePromise = T | Promise; type PartialNull = { [P in keyof T]: T[P] | null; }; export interface RollupError extends RollupLog { name?: string; stack?: string; watchFiles?: string[]; } export interface RollupLog { binding?: string; cause?: unknown; code?: string; exporter?: string; frame?: string; hook?: string; id?: string; ids?: string[]; loc?: { column: number; file?: string; line: number; }; message: string; meta?: any; names?: string[]; plugin?: string; pluginCode?: unknown; pos?: number; reexporter?: string; stack?: string; url?: string; } export type LogLevel = 'warn' | 'info' | 'debug'; export type LogLevelOption = LogLevel | 'silent'; export type SourceMapSegment = | [number] | [number, number, number, number] | [number, number, number, number, number]; export interface ExistingDecodedSourceMap { file?: string; readonly mappings: SourceMapSegment[][]; names: string[]; sourceRoot?: string; sources: string[]; sourcesContent?: string[]; version: number; x_google_ignoreList?: number[]; } export interface ExistingRawSourceMap { file?: string; mappings: string; names: string[]; sourceRoot?: string; sources: string[]; sourcesContent?: string[]; version: number; x_google_ignoreList?: number[]; } export type DecodedSourceMapOrMissing = | { missing: true; plugin: string; } | (ExistingDecodedSourceMap & { missing?: false }); export interface SourceMap { file: string; mappings: string; names: string[]; sources: string[]; sourcesContent?: string[]; version: number; toString(): string; toUrl(): string; } export type SourceMapInput = ExistingRawSourceMap | string | null | { mappings: '' }; interface ModuleOptions { attributes: Record; meta: CustomPluginOptions; moduleSideEffects: boolean | 'no-treeshake'; syntheticNamedExports: boolean | string; } export interface SourceDescription extends Partial> { ast?: ProgramNode; code: string; map?: SourceMapInput; } export interface TransformModuleJSON { ast?: ProgramNode; code: string; // note if plugins use new this.cache to opt-out auto transform cache customTransformCache: boolean; originalCode: string; originalSourcemap: ExistingDecodedSourceMap | null; sourcemapChain: DecodedSourceMapOrMissing[]; transformDependencies: string[]; } export interface ModuleJSON extends TransformModuleJSON, ModuleOptions { ast: ProgramNode; dependencies: string[]; id: string; resolvedIds: ResolvedIdMap; transformFiles: EmittedFile[] | undefined; } export interface PluginCache { delete(id: string): boolean; get(id: string): T; has(id: string): boolean; set(id: string, value: T): void; } export type LoggingFunction = (log: RollupLog | string | (() => RollupLog | string)) => void; export interface MinimalPluginContext { debug: LoggingFunction; error: (error: RollupError | string) => never; info: LoggingFunction; meta: PluginContextMeta; warn: LoggingFunction; } export interface EmittedAsset { fileName?: string; name?: string; needsCodeReference?: boolean; originalFileName?: string | null; source?: string | Uint8Array; type: 'asset'; } export interface EmittedChunk { fileName?: string; id: string; implicitlyLoadedAfterOneOf?: string[]; importer?: string; name?: string; preserveSignature?: PreserveEntrySignaturesOption; type: 'chunk'; } export interface EmittedPrebuiltChunk { code: string; exports?: string[]; fileName: string; map?: SourceMap; sourcemapFileName?: string; type: 'prebuilt-chunk'; } export type EmittedFile = EmittedAsset | EmittedChunk | EmittedPrebuiltChunk; export type EmitFile = (emittedFile: EmittedFile) => string; interface ModuleInfo extends ModuleOptions { ast: ProgramNode | null; code: string | null; dynamicImporters: readonly string[]; dynamicallyImportedIdResolutions: readonly ResolvedId[]; dynamicallyImportedIds: readonly string[]; exportedBindings: Record | null; exports: string[] | null; hasDefaultExport: boolean | null; id: string; implicitlyLoadedAfterOneOf: readonly string[]; implicitlyLoadedBefore: readonly string[]; importedIdResolutions: readonly ResolvedId[]; importedIds: readonly string[]; importers: readonly string[]; isEntry: boolean; isExternal: boolean; isIncluded: boolean | null; } export type GetModuleInfo = (moduleId: string) => ModuleInfo | null; export type CustomPluginOptions = Record; type LoggingFunctionWithPosition = ( log: RollupLog | string | (() => RollupLog | string), pos?: number | { column: number; line: number } ) => void; export type ParseAst = ( input: string, options?: { allowReturnOutsideFunction?: boolean } ) => ProgramNode; // declare AbortSignal here for environments without DOM lib or @types/node declare global { // eslint-disable-next-line @typescript-eslint/no-empty-object-type interface AbortSignal {} } export type ParseAstAsync = ( input: string, options?: { allowReturnOutsideFunction?: boolean; signal?: AbortSignal } ) => Promise; export interface PluginContext extends MinimalPluginContext { addWatchFile: (id: string) => void; cache: PluginCache; debug: LoggingFunction; emitFile: EmitFile; error: (error: RollupError | string) => never; getFileName: (fileReferenceId: string) => string; getModuleIds: () => IterableIterator; getModuleInfo: GetModuleInfo; getWatchFiles: () => string[]; info: LoggingFunction; load: ( options: { id: string; resolveDependencies?: boolean } & Partial> ) => Promise; parse: ParseAst; resolve: ( source: string, importer?: string, options?: { attributes?: Record; custom?: CustomPluginOptions; isEntry?: boolean; skipSelf?: boolean; } ) => Promise; setAssetSource: (assetReferenceId: string, source: string | Uint8Array) => void; warn: LoggingFunction; } export interface PluginContextMeta { rollupVersion: string; watchMode: boolean; } export interface ResolvedId extends ModuleOptions { external: boolean | 'absolute'; id: string; resolvedBy: string; } export type ResolvedIdMap = Record; interface PartialResolvedId extends Partial> { external?: boolean | 'absolute' | 'relative'; id: string; resolvedBy?: string; } export type ResolveIdResult = string | NullValue | false | PartialResolvedId; export type ResolveIdResultWithoutNullValue = string | false | PartialResolvedId; export type ResolveIdHook = ( this: PluginContext, source: string, importer: string | undefined, options: { attributes: Record; custom?: CustomPluginOptions; isEntry: boolean } ) => ResolveIdResult; export type ShouldTransformCachedModuleHook = ( this: PluginContext, options: { ast: ProgramNode; code: string; id: string; meta: CustomPluginOptions; moduleSideEffects: boolean | 'no-treeshake'; resolvedSources: ResolvedIdMap; syntheticNamedExports: boolean | string; } ) => boolean | NullValue; export type IsExternal = ( source: string, importer: string | undefined, isResolved: boolean ) => boolean; export type HasModuleSideEffects = (id: string, external: boolean) => boolean; export type LoadResult = SourceDescription | string | NullValue; export type LoadHook = (this: PluginContext, id: string) => LoadResult; export interface TransformPluginContext extends PluginContext { debug: LoggingFunctionWithPosition; error: (error: RollupError | string, pos?: number | { column: number; line: number }) => never; getCombinedSourcemap: () => SourceMap; info: LoggingFunctionWithPosition; warn: LoggingFunctionWithPosition; } export type TransformResult = string | NullValue | Partial; export type TransformHook = ( this: TransformPluginContext, code: string, id: string ) => TransformResult; export type ModuleParsedHook = (this: PluginContext, info: ModuleInfo) => void; export type RenderChunkHook = ( this: PluginContext, code: string, chunk: RenderedChunk, options: NormalizedOutputOptions, meta: { chunks: Record } ) => { code: string; map?: SourceMapInput } | string | NullValue; export type ResolveDynamicImportHook = ( this: PluginContext, specifier: string | AstNode, importer: string, options: { attributes: Record } ) => ResolveIdResult; export type ResolveImportMetaHook = ( this: PluginContext, property: string | null, options: { chunkId: string; format: InternalModuleFormat; moduleId: string } ) => string | NullValue; export type ResolveFileUrlHook = ( this: PluginContext, options: { chunkId: string; fileName: string; format: InternalModuleFormat; moduleId: string; referenceId: string; relativePath: string; } ) => string | NullValue; export type AddonHookFunction = ( this: PluginContext, chunk: RenderedChunk ) => string | Promise; export type AddonHook = string | AddonHookFunction; export type ChangeEvent = 'create' | 'update' | 'delete'; export type WatchChangeHook = ( this: PluginContext, id: string, change: { event: ChangeEvent } ) => void; /** * use this type for plugin annotation * @example * ```ts * interface Options { * ... * } * const myPlugin: PluginImpl = (options = {}) => { ... } * ``` */ export type PluginImpl = (options?: O) => Plugin; export type OutputBundle = Record; export interface FunctionPluginHooks { augmentChunkHash: (this: PluginContext, chunk: RenderedChunk) => string | void; buildEnd: (this: PluginContext, error?: Error) => void; buildStart: (this: PluginContext, options: NormalizedInputOptions) => void; closeBundle: (this: PluginContext) => void; closeWatcher: (this: PluginContext) => void; generateBundle: ( this: PluginContext, options: NormalizedOutputOptions, bundle: OutputBundle, isWrite: boolean ) => void; load: LoadHook; moduleParsed: ModuleParsedHook; onLog: (this: MinimalPluginContext, level: LogLevel, log: RollupLog) => boolean | NullValue; options: (this: MinimalPluginContext, options: InputOptions) => InputOptions | NullValue; outputOptions: (this: PluginContext, options: OutputOptions) => OutputOptions | NullValue; renderChunk: RenderChunkHook; renderDynamicImport: ( this: PluginContext, options: { customResolution: string | null; format: InternalModuleFormat; moduleId: string; targetModuleId: string | null; } ) => { left: string; right: string } | NullValue; renderError: (this: PluginContext, error?: Error) => void; renderStart: ( this: PluginContext, outputOptions: NormalizedOutputOptions, inputOptions: NormalizedInputOptions ) => void; resolveDynamicImport: ResolveDynamicImportHook; resolveFileUrl: ResolveFileUrlHook; resolveId: ResolveIdHook; resolveImportMeta: ResolveImportMetaHook; shouldTransformCachedModule: ShouldTransformCachedModuleHook; transform: TransformHook; watchChange: WatchChangeHook; writeBundle: ( this: PluginContext, options: NormalizedOutputOptions, bundle: OutputBundle ) => void; } export type OutputPluginHooks = | 'augmentChunkHash' | 'generateBundle' | 'outputOptions' | 'renderChunk' | 'renderDynamicImport' | 'renderError' | 'renderStart' | 'resolveFileUrl' | 'resolveImportMeta' | 'writeBundle'; export type InputPluginHooks = Exclude; export type SyncPluginHooks = | 'augmentChunkHash' | 'onLog' | 'outputOptions' | 'renderDynamicImport' | 'resolveFileUrl' | 'resolveImportMeta'; export type AsyncPluginHooks = Exclude; export type FirstPluginHooks = | 'load' | 'renderDynamicImport' | 'resolveDynamicImport' | 'resolveFileUrl' | 'resolveId' | 'resolveImportMeta' | 'shouldTransformCachedModule'; export type SequentialPluginHooks = | 'augmentChunkHash' | 'generateBundle' | 'onLog' | 'options' | 'outputOptions' | 'renderChunk' | 'transform'; export type ParallelPluginHooks = Exclude< keyof FunctionPluginHooks | AddonHooks, FirstPluginHooks | SequentialPluginHooks >; export type AddonHooks = 'banner' | 'footer' | 'intro' | 'outro'; type MakeAsync = Function_ extends ( this: infer This, ...parameters: infer Arguments ) => infer Return ? (this: This, ...parameters: Arguments) => Return | Promise : never; // eslint-disable-next-line @typescript-eslint/no-empty-object-type type ObjectHook = T | ({ handler: T; order?: 'pre' | 'post' | null } & O); export type PluginHooks = { [K in keyof FunctionPluginHooks]: ObjectHook< K extends AsyncPluginHooks ? MakeAsync : FunctionPluginHooks[K], // eslint-disable-next-line @typescript-eslint/no-empty-object-type K extends ParallelPluginHooks ? { sequential?: boolean } : {} >; }; export interface OutputPlugin extends Partial<{ [K in OutputPluginHooks]: PluginHooks[K] }>, Partial<{ [K in AddonHooks]: ObjectHook }> { cacheKey?: string; name: string; version?: string; } export interface Plugin extends OutputPlugin, Partial { // for inter-plugin communication api?: A; } export type TreeshakingPreset = 'smallest' | 'safest' | 'recommended'; export interface NormalizedTreeshakingOptions { annotations: boolean; correctVarValueBeforeDeclaration: boolean; manualPureFunctions: readonly string[]; moduleSideEffects: HasModuleSideEffects; propertyReadSideEffects: boolean | 'always'; tryCatchDeoptimization: boolean; unknownGlobalSideEffects: boolean; } export interface TreeshakingOptions extends Partial> { moduleSideEffects?: ModuleSideEffectsOption; preset?: TreeshakingPreset; } interface ManualChunkMeta { getModuleIds: () => IterableIterator; getModuleInfo: GetModuleInfo; } export type GetManualChunk = (id: string, meta: ManualChunkMeta) => string | NullValue; export type ExternalOption = | (string | RegExp)[] | string | RegExp | ((source: string, importer: string | undefined, isResolved: boolean) => boolean | NullValue); export type GlobalsOption = Record | ((name: string) => string); export type InputOption = string | string[] | Record; export type ManualChunksOption = Record | GetManualChunk; export type LogHandlerWithDefault = ( level: LogLevel, log: RollupLog, defaultHandler: LogOrStringHandler ) => void; export type LogOrStringHandler = (level: LogLevel | 'error', log: RollupLog | string) => void; export type LogHandler = (level: LogLevel, log: RollupLog) => void; export type ModuleSideEffectsOption = boolean | 'no-external' | string[] | HasModuleSideEffects; export type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only'; export type SourcemapPathTransformOption = ( relativeSourcePath: string, sourcemapPath: string ) => string; export type SourcemapIgnoreListOption = ( relativeSourcePath: string, sourcemapPath: string ) => boolean; export type InputPluginOption = MaybePromise; export interface InputOptions { cache?: boolean | RollupCache; context?: string; experimentalCacheExpiry?: number; experimentalLogSideEffects?: boolean; external?: ExternalOption; input?: InputOption; logLevel?: LogLevelOption; makeAbsoluteExternalsRelative?: boolean | 'ifRelativeSource'; maxParallelFileOps?: number; moduleContext?: ((id: string) => string | NullValue) | Record; onLog?: LogHandlerWithDefault; onwarn?: WarningHandlerWithDefault; perf?: boolean; plugins?: InputPluginOption; preserveEntrySignatures?: PreserveEntrySignaturesOption; preserveSymlinks?: boolean; shimMissingExports?: boolean; strictDeprecations?: boolean; treeshake?: boolean | TreeshakingPreset | TreeshakingOptions; watch?: WatcherOptions | false; } export interface InputOptionsWithPlugins extends InputOptions { plugins: Plugin[]; } export interface NormalizedInputOptions { cache: false | undefined | RollupCache; context: string; experimentalCacheExpiry: number; experimentalLogSideEffects: boolean; external: IsExternal; input: string[] | Record; logLevel: LogLevelOption; makeAbsoluteExternalsRelative: boolean | 'ifRelativeSource'; maxParallelFileOps: number; moduleContext: (id: string) => string; onLog: LogHandler; perf: boolean; plugins: Plugin[]; preserveEntrySignatures: PreserveEntrySignaturesOption; preserveSymlinks: boolean; shimMissingExports: boolean; strictDeprecations: boolean; treeshake: false | NormalizedTreeshakingOptions; } export type InternalModuleFormat = 'amd' | 'cjs' | 'es' | 'iife' | 'system' | 'umd'; export type ImportAttributesKey = 'with' | 'assert'; export type ModuleFormat = InternalModuleFormat | 'commonjs' | 'esm' | 'module' | 'systemjs'; type GeneratedCodePreset = 'es5' | 'es2015'; interface NormalizedGeneratedCodeOptions { arrowFunctions: boolean; constBindings: boolean; objectShorthand: boolean; reservedNamesAsProps: boolean; symbols: boolean; } interface GeneratedCodeOptions extends Partial { preset?: GeneratedCodePreset; } export type OptionsPaths = Record | ((id: string) => string); export type InteropType = 'compat' | 'auto' | 'esModule' | 'default' | 'defaultOnly'; export type GetInterop = (id: string | null) => InteropType; export type AmdOptions = ( | { autoId?: false; id: string; } | { autoId: true; basePath?: string; id?: undefined; } | { autoId?: false; id?: undefined; } ) & { define?: string; forceJsExtensionForImports?: boolean; }; export type NormalizedAmdOptions = ( | { autoId: false; id?: string; } | { autoId: true; basePath: string; } ) & { define: string; forceJsExtensionForImports: boolean; }; type AddonFunction = (chunk: RenderedChunk) => string | Promise; type OutputPluginOption = MaybePromise; type HashCharacters = 'base64' | 'base36' | 'hex'; export interface OutputOptions { amd?: AmdOptions; assetFileNames?: string | ((chunkInfo: PreRenderedAsset) => string); banner?: string | AddonFunction; chunkFileNames?: string | ((chunkInfo: PreRenderedChunk) => string); compact?: boolean; // only required for bundle.write dir?: string; dynamicImportInCjs?: boolean; entryFileNames?: string | ((chunkInfo: PreRenderedChunk) => string); esModule?: boolean | 'if-default-prop'; experimentalMinChunkSize?: number; exports?: 'default' | 'named' | 'none' | 'auto'; extend?: boolean; /** @deprecated Use "externalImportAttributes" instead. */ externalImportAssertions?: boolean; externalImportAttributes?: boolean; externalLiveBindings?: boolean; // only required for bundle.write file?: string; footer?: string | AddonFunction; format?: ModuleFormat; freeze?: boolean; generatedCode?: GeneratedCodePreset | GeneratedCodeOptions; globals?: GlobalsOption; hashCharacters?: HashCharacters; hoistTransitiveImports?: boolean; importAttributesKey?: ImportAttributesKey; indent?: string | boolean; inlineDynamicImports?: boolean; interop?: InteropType | GetInterop; intro?: string | AddonFunction; manualChunks?: ManualChunksOption; minifyInternalExports?: boolean; name?: string; noConflict?: boolean; outro?: string | AddonFunction; paths?: OptionsPaths; plugins?: OutputPluginOption; preserveModules?: boolean; preserveModulesRoot?: string; reexportProtoFromExternal?: boolean; sanitizeFileName?: boolean | ((fileName: string) => string); sourcemap?: boolean | 'inline' | 'hidden'; sourcemapBaseUrl?: string; sourcemapExcludeSources?: boolean; sourcemapFile?: string; sourcemapFileNames?: string | ((chunkInfo: PreRenderedChunk) => string); sourcemapIgnoreList?: boolean | SourcemapIgnoreListOption; sourcemapPathTransform?: SourcemapPathTransformOption; strict?: boolean; systemNullSetters?: boolean; validate?: boolean; virtualDirname?: string; } export interface NormalizedOutputOptions { amd: NormalizedAmdOptions; assetFileNames: string | ((chunkInfo: PreRenderedAsset) => string); banner: AddonFunction; chunkFileNames: string | ((chunkInfo: PreRenderedChunk) => string); compact: boolean; dir: string | undefined; dynamicImportInCjs: boolean; entryFileNames: string | ((chunkInfo: PreRenderedChunk) => string); esModule: boolean | 'if-default-prop'; experimentalMinChunkSize: number; exports: 'default' | 'named' | 'none' | 'auto'; extend: boolean; /** @deprecated Use "externalImportAttributes" instead. */ externalImportAssertions: boolean; externalImportAttributes: boolean; externalLiveBindings: boolean; file: string | undefined; footer: AddonFunction; format: InternalModuleFormat; freeze: boolean; generatedCode: NormalizedGeneratedCodeOptions; globals: GlobalsOption; hashCharacters: HashCharacters; hoistTransitiveImports: boolean; importAttributesKey: ImportAttributesKey; indent: true | string; inlineDynamicImports: boolean; interop: GetInterop; intro: AddonFunction; manualChunks: ManualChunksOption; minifyInternalExports: boolean; name: string | undefined; noConflict: boolean; outro: AddonFunction; paths: OptionsPaths; plugins: OutputPlugin[]; preserveModules: boolean; preserveModulesRoot: string | undefined; reexportProtoFromExternal: boolean; sanitizeFileName: (fileName: string) => string; sourcemap: boolean | 'inline' | 'hidden'; sourcemapBaseUrl: string | undefined; sourcemapExcludeSources: boolean; sourcemapFile: string | undefined; sourcemapFileNames: string | ((chunkInfo: PreRenderedChunk) => string) | undefined; sourcemapIgnoreList: SourcemapIgnoreListOption; sourcemapPathTransform: SourcemapPathTransformOption | undefined; strict: boolean; systemNullSetters: boolean; validate: boolean; virtualDirname: string; } export type WarningHandlerWithDefault = ( warning: RollupLog, defaultHandler: LoggingFunction ) => void; export type SerializedTimings = Record; export interface PreRenderedAsset { name: string | undefined; originalFileName: string | null; source: string | Uint8Array; type: 'asset'; } export interface OutputAsset extends PreRenderedAsset { fileName: string; needsCodeReference: boolean; } export interface RenderedModule { readonly code: string | null; originalLength: number; removedExports: string[]; renderedExports: string[]; renderedLength: number; } export interface PreRenderedChunk { exports: string[]; facadeModuleId: string | null; isDynamicEntry: boolean; isEntry: boolean; isImplicitEntry: boolean; moduleIds: string[]; name: string; type: 'chunk'; } export interface RenderedChunk extends PreRenderedChunk { dynamicImports: string[]; fileName: string; implicitlyLoadedBefore: string[]; importedBindings: Record; imports: string[]; modules: Record; referencedFiles: string[]; } export interface OutputChunk extends RenderedChunk { code: string; map: SourceMap | null; sourcemapFileName: string | null; preliminaryFileName: string; } export type SerializablePluginCache = Record; export interface RollupCache { modules: ModuleJSON[]; plugins?: Record; } export interface RollupOutput { output: [OutputChunk, ...(OutputChunk | OutputAsset)[]]; } export interface RollupBuild { cache: RollupCache | undefined; close: () => Promise; closed: boolean; generate: (outputOptions: OutputOptions) => Promise; getTimings?: () => SerializedTimings; watchFiles: string[]; write: (options: OutputOptions) => Promise; } export interface RollupOptions extends InputOptions { // This is included for compatibility with config files but ignored by rollup.rollup output?: OutputOptions | OutputOptions[]; } export interface MergedRollupOptions extends InputOptionsWithPlugins { output: OutputOptions[]; } export function rollup(options: RollupOptions): Promise; export interface ChokidarOptions { alwaysStat?: boolean; atomic?: boolean | number; awaitWriteFinish?: | { pollInterval?: number; stabilityThreshold?: number; } | boolean; binaryInterval?: number; cwd?: string; depth?: number; disableGlobbing?: boolean; followSymlinks?: boolean; ignoreInitial?: boolean; ignorePermissionErrors?: boolean; ignored?: any; interval?: number; persistent?: boolean; useFsEvents?: boolean; usePolling?: boolean; } export type RollupWatchHooks = 'onError' | 'onStart' | 'onBundleStart' | 'onBundleEnd' | 'onEnd'; export interface WatcherOptions { buildDelay?: number; chokidar?: ChokidarOptions; clearScreen?: boolean; exclude?: string | RegExp | (string | RegExp)[]; include?: string | RegExp | (string | RegExp)[]; skipWrite?: boolean; } export interface RollupWatchOptions extends InputOptions { output?: OutputOptions | OutputOptions[]; watch?: WatcherOptions | false; } export type AwaitedEventListener< T extends Record any>, K extends keyof T > = (...parameters: Parameters) => void | Promise; export interface AwaitingEventEmitter any>> { close(): Promise; emit(event: K, ...parameters: Parameters): Promise; /** * Removes an event listener. */ off(event: K, listener: AwaitedEventListener): this; /** * Registers an event listener that will be awaited before Rollup continues. * All listeners will be awaited in parallel while rejections are tracked via * Promise.all. */ on(event: K, listener: AwaitedEventListener): this; /** * Registers an event listener that will be awaited before Rollup continues. * All listeners will be awaited in parallel while rejections are tracked via * Promise.all. * Listeners are removed automatically when removeListenersForCurrentRun is * called, which happens automatically after each run. */ onCurrentRun( event: K, listener: (...parameters: Parameters) => Promise> ): this; removeAllListeners(): this; removeListenersForCurrentRun(): this; } export type RollupWatcherEvent = | { code: 'START' } | { code: 'BUNDLE_START'; input?: InputOption; output: readonly string[] } | { code: 'BUNDLE_END'; duration: number; input?: InputOption; output: readonly string[]; result: RollupBuild; } | { code: 'END' } | { code: 'ERROR'; error: RollupError; result: RollupBuild | null }; export type RollupWatcher = AwaitingEventEmitter<{ change: (id: string, change: { event: ChangeEvent }) => void; close: () => void; event: (event: RollupWatcherEvent) => void; restart: () => void; }>; export function watch(config: RollupWatchOptions | RollupWatchOptions[]): RollupWatcher; interface AstNodeLocation { end: number; start: number; } type OmittedEstreeKeys = | 'loc' | 'range' | 'leadingComments' | 'trailingComments' | 'innerComments' | 'comments'; type RollupAstNode = Omit & AstNodeLocation; type ProgramNode = RollupAstNode; export type AstNode = RollupAstNode; export function defineConfig(options: RollupOptions): RollupOptions; export function defineConfig(options: RollupOptions[]): RollupOptions[]; export function defineConfig(optionsFunction: RollupOptionsFunction): RollupOptionsFunction; export type RollupOptionsFunction = ( commandLineArguments: Record ) => MaybePromise;