rollup

end: number;

start: number;

close: () => Promise<void>;

emit: <K extends keyof T>(
    event: K,
    ...parameters: Parameters<T[K]>
) => Promise<unknown>;

off: <K extends keyof T>(event: K, listener: AwaitedEventListener<T, K>) => this;

on: <K extends keyof T>(event: K, listener: AwaitedEventListener<T, K>) => this;

onCurrentRun: <K extends keyof T>(
    event: K,
    listener: (...parameters: Parameters<T[K]>) => Promise<ReturnType<T[K]>>
) => this;

removeAllListeners: () => this;

removeListenersForCurrentRun: () => this;

alwaysStat?: boolean;

atomic?: boolean | number;

awaitWriteFinish?:
    | {
          pollInterval?: number;
          stabilityThreshold?: number;
      }
    | boolean;

binaryInterval?: number;

cwd?: string;

depth?: number;

disableGlobbing?: boolean;

followSymlinks?: boolean;

ignored?: any;

ignoreInitial?: boolean;

ignorePermissionErrors?: boolean;

interval?: number;

persistent?: boolean;

useFsEvents?: boolean;

usePolling?: boolean;

[plugin: string]: any;

fileName?: string;

name?: string;

needsCodeReference?: boolean;

originalFileName?: string | null;

source?: string | Uint8Array;

type: 'asset';

fileName?: string;

id: string;

implicitlyLoadedAfterOneOf?: string[];

importer?: string;

name?: string;

preserveSignature?: PreserveEntrySignaturesOption;

type: 'chunk';

code: string;

exports?: string[];

fileName: string;

map?: SourceMap;

sourcemapFileName?: string;

type: 'prebuilt-chunk';

file?: string;

readonly mappings: SourceMapSegment[][];

names: string[];

sourceRoot?: string;

sources: string[];

sourcesContent?: string[];

version: number;

x_google_ignoreList?: number[];

file?: string;

mappings: string;

names: string[];

sourceRoot?: string;

sources: string[];

sourcesContent?: string[];

version: number;

x_google_ignoreList?: number[];

augmentChunkHash: (this: PluginContext, chunk: RenderedChunk) => string | void;

buildEnd: (this: PluginContext, error?: Error) => void;

buildStart: (this: PluginContext, options: NormalizedInputOptions) => void;

closeBundle: (this: PluginContext, error?: Error) => 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;
        chunk: PreRenderedChunkWithFileName;
        targetChunk: PreRenderedChunkWithFileName | null;
        getTargetChunkImports: () => DynamicImportTargetChunk[] | 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;

preset?: GeneratedCodePreset;

code?: StringFilter;

id?: StringFilter;

fileName: string;

resolvedImportPath: string;

type: 'external';

chunk: PreRenderedChunk;

fileName: string;

resolvedImportPath: string;

type: 'internal';

cache?: boolean | RollupCache;

context?: string;

experimentalCacheExpiry?: number;

experimentalLogSideEffects?: boolean;

external?: ExternalOption;

fs?: RollupFsModule;

input?: InputOption;

jsx?: false | JsxPreset | JsxOptions;

logLevel?: LogLevelOption;

makeAbsoluteExternalsRelative?: boolean | 'ifRelativeSource';

maxParallelFileOps?: number;

moduleContext?: ((id: string) => string | NullValue) | Record<string, string>;

onLog?: LogHandlerWithDefault;

onwarn?: WarningHandlerWithDefault;

perf?: boolean;

plugins?: InputPluginOption;

preserveEntrySignatures?: PreserveEntrySignaturesOption;

preserveSymlinks?: boolean;

shimMissingExports?: boolean;

strictDeprecations?: boolean;

treeshake?: boolean | TreeshakingPreset | TreeshakingOptions;

watch?: WatcherOptions | false;

plugins: Plugin[];

getModuleIds: () => IterableIterator<string>;

getModuleInfo: GetModuleInfo;

output: OutputOptions[];

debug: LoggingFunction;

error: (error: RollupError | string) => never;

info: LoggingFunction;

meta: PluginContextMeta;

warn: LoggingFunction;

ast: ProgramNode | null;

code: string | null;

dynamicallyImportedIdResolutions: readonly ResolvedId[];

dynamicallyImportedIds: readonly string[];

dynamicImporters: readonly string[];

exportedBindings: Record<string, string[]> | 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;

ast: ProgramNode;

dependencies: string[];

id: string;

resolvedIds: ResolvedIdMap;

transformFiles: EmittedFile[] | undefined;

attributes: Record<string, string>;

meta: CustomPluginOptions;

moduleSideEffects: boolean | 'no-treeshake';

syntheticNamedExports: boolean | string;

arrowFunctions: boolean;

constBindings: boolean;

objectShorthand: boolean;

reservedNamesAsProps: boolean;

symbols: boolean;

cache: false | undefined | RollupCache;

context: string;

experimentalCacheExpiry: number;

experimentalLogSideEffects: boolean;

external: IsExternal;

fs: RollupFsModule;

input: string[] | Record<string, string>;

jsx: false | NormalizedJsxOptions;

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;

factory: string;

importSource: string | null;

jsxImportSource: string;

mode: 'automatic';

factory: string;

fragment: string;

importSource: string | null;

mode: 'classic';

factory: string | null;

fragment: string | null;

importSource: string | null;

mode: 'preserve';

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;

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;

sourcemapDebugIds: boolean;

sourcemapExcludeSources: boolean;

sourcemapFile: string | undefined;

sourcemapFileNames:
    | string
    | ((chunkInfo: PreRenderedChunk) => string)
    | undefined;

sourcemapIgnoreList: SourcemapIgnoreListOption;

sourcemapPathTransform: SourcemapPathTransformOption | undefined;

strict: boolean;

systemNullSetters: boolean;

validate: boolean;

virtualDirname: string;

annotations: boolean;

correctVarValueBeforeDeclaration: boolean;

manualPureFunctions: readonly string[];

moduleSideEffects: HasModuleSideEffects;

propertyReadSideEffects: boolean | 'always';

tryCatchDeoptimization: boolean;

unknownGlobalSideEffects: boolean;

fileName: string;

needsCodeReference: boolean;

code: string;

map: SourceMap | null;

preliminaryFileName: string;

sourcemapFileName: string | null;

amd?: AmdOptions;

assetFileNames?: string | ((chunkInfo: PreRenderedAsset) => string);

banner?: string | AddonFunction;

chunkFileNames?: string | ((chunkInfo: PreRenderedChunk) => string);

compact?: boolean;

dir?: string;