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 | undefined;

atomic?: boolean | number | undefined;

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

binaryInterval?: number | undefined;

cwd?: string | undefined;

depth?: number | undefined;

disableGlobbing?: boolean | undefined;

followSymlinks?: boolean | undefined;

ignored?: any | undefined;

ignoreInitial?: boolean | undefined;

ignorePermissionErrors?: boolean | undefined;

interval?: number | undefined;

persistent?: boolean | undefined;

useFsEvents?: boolean | undefined;

usePolling?: boolean | undefined;

[plugin: string]: any;

fileName?: string | undefined;

name?: string | undefined;

needsCodeReference?: boolean | undefined;

originalFileName?: string | null | undefined;

source?: string | Uint8Array | undefined;

type: 'asset';

fileName?: string | undefined;

id: string;

implicitlyLoadedAfterOneOf?: string[] | undefined;

importer?: string | undefined;

name?: string | undefined;

preserveSignature?: PreserveEntrySignaturesOption | undefined;

type: 'chunk';

code: string;

exports?: string[] | undefined;

fileName: string;

map?: SourceMap | undefined;

sourcemapFileName?: string | undefined;

type: 'prebuilt-chunk';

file?: string | undefined;

readonly mappings: SourceMapSegment[][];

names: string[];

sourceRoot?: string | undefined;

sources: string[];

sourcesContent?: string[] | undefined;

version: number;

x_google_ignoreList?: number[] | undefined;

file?: string | undefined;

mappings: string;

names: string[];

sourceRoot?: string | undefined;

sources: string[];

sourcesContent?: string[] | undefined;

version: number;

x_google_ignoreList?: number[] | undefined;

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 | undefined;

code?: StringFilter | undefined;

id?: StringFilter | undefined;

fileName: string;

resolvedImportPath: string;

type: 'external';

chunk: PreRenderedChunk;

fileName: string;

resolvedImportPath: string;

type: 'internal';

cache?: boolean | RollupCache | undefined;

context?: string | undefined;

experimentalCacheExpiry?: number | undefined;

experimentalLogSideEffects?: boolean | undefined;

external?: ExternalOption | undefined;

fs?: RollupFsModule | undefined;

input?: InputOption | undefined;

jsx?: false | JsxPreset | JsxOptions | undefined;

logLevel?: LogLevelOption | undefined;

makeAbsoluteExternalsRelative?: boolean | 'ifRelativeSource' | undefined;

maxParallelFileOps?: number | undefined;

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

onLog?: LogHandlerWithDefault | undefined;

onwarn?: WarningHandlerWithDefault | undefined;

perf?: boolean | undefined;

plugins?: InputPluginOption | undefined;

preserveEntrySignatures?: PreserveEntrySignaturesOption | undefined;

preserveSymlinks?: boolean | undefined;

shimMissingExports?: boolean | undefined;

strictDeprecations?: boolean | undefined;

treeshake?: boolean | TreeshakingPreset | TreeshakingOptions | undefined;

watch?: WatcherOptions | false | undefined;

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;

onlyExplicitManualChunks: 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;