@remotion/renderer 4.0.0-webhook.26 → 4.1.0-alpha1

package/dist/index.d.ts

@@ -1,62 +1,55 @@
 /// <reference types="node" />
 import execa from 'execa';
+import { HeadlessBrowser } from './browser/Browser';
 import { SymbolicateableError } from './error-handling/symbolicateable-error';
 import { mimeContentType, mimeLookup } from './mime-types';
 import * as perf from './perf';
 export type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
-export type { DownloadMap } from './assets/download-map';
+export { AudioCodec } from './audio-codec';
 export { Browser } from './browser';
 export { BrowserExecutable } from './browser-executable';
 export { BrowserLog } from './browser-log';
+export type { HeadlessBrowser } from './browser/Browser';
 export { Codec, CodecOrUndefined } from './codec';
-export { combineVideos } from './combine-videos';
 export { Crf } from './crf';
 export { ErrorWithStackFrame } from './error-handling/handle-javascript-exception';
-export { FfmpegExecutable } from './ffmpeg-executable';
-export { FfmpegVersion } from './ffmpeg-flags';
 export type { FfmpegOverrideFn } from './ffmpeg-override';
+export { FileExtension } from './file-extensions';
 export { FrameRange } from './frame-range';
-export { getCompositions } from './get-compositions';
-export { ImageFormat, StillImageFormat, validateSelectedPixelFormatAndImageFormatCombination, validImageFormats, } from './image-format';
+export { getCompositions, GetCompositionsOptions } from './get-compositions';
+export { ImageFormat, StillImageFormat, validateSelectedPixelFormatAndImageFormatCombination, VideoImageFormat, } from './image-format';
 export type { LogLevel } from './log-level';
 export { CancelSignal, makeCancelSignal } from './make-cancel-signal';
 export { openBrowser } from './open-browser';
 export type { ChromiumOptions } from './open-browser';
+export { RemotionOption } from './options/option';
 export { PixelFormat } from './pixel-format';
+export { RemotionServer } from './prepare-server';
 export { ProResProfile } from './prores-profile';
-export { renderFrames } from './render-frames';
-export { renderMedia, RenderMediaOnProgress, RenderMediaOptions, StitchingState, } from './render-media';
+export { renderFrames, RenderFramesOptions } from './render-frames';
+export { InternalRenderMediaOptions, renderMedia, RenderMediaOnProgress, RenderMediaOptions, SlowFrame, StitchingState, } from './render-media';
 export { renderStill, RenderStillOptions } from './render-still';
-export { StitcherOptions, stitchFramesToVideo } from './stitch-frames-to-video';
+export { selectComposition, SelectCompositionOptions, } from './select-composition';
+export { stitchFramesToVideo, StitchFramesToVideoOptions, } from './stitch-frames-to-video';
 export { SymbolicatedStackFrame } from './symbolicate-stacktrace';
 export { OnStartData, RenderFramesOutput } from './types';
 export { OpenGlRenderer } from './validate-opengl-renderer';
 export { validateOutputFilename } from './validate-output-filename';
 export declare const RenderInternals: {
     ensureLocalBrowser: (browser: import("./browser").Browser, preferredBrowserExecutable: import("./browser-executable").BrowserExecutable) => Promise<void>;
-    ffmpegHasFeature: ({ ffmpegExecutable, feature, }: {
-        ffmpegExecutable: string | null;
-        feature: "enable-gpl" | "enable-libx265" | "enable-libvpx";
-    }) => Promise<boolean>;
-    getActualConcurrency: (userPreference: number | null) => number;
-    getFfmpegVersion: (options: {
-        ffmpegExecutable: string | null;
-    }) => Promise<import("./ffmpeg-flags").FfmpegVersion>;
-    validateFfmpeg: (customFfmpegBinary: string | null) => Promise<void>;
-    binaryExists: (name: "ffmpeg" | "brew", localFFmpeg: string | null) => Promise<boolean>;
-    getFfmpegBuildInfo: (options: {
-        ffmpegExecutable: string | null;
-    }) => Promise<string>;
+    getActualConcurrency: (userPreference: string | number | null) => number;
     serveStatic: (path: string | null, options: {
         port: number | null;
-        ffmpegExecutable: import("./ffmpeg-executable").FfmpegExecutable;
-        ffprobeExecutable: import("./ffmpeg-executable").FfmpegExecutable;
-        onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload;
-        onError: (err: Error) => void;
         downloadMap: import("./assets/download-map").DownloadMap;
+        remotionRoot: string;
+        concurrency: number;
+        verbose: boolean;
+        indent: boolean;
     }) => Promise<{
         port: number;
         close: () => Promise<void>;
+        compositor: import("./compositor/compositor").Compositor;
+        events: import("./offthread-video-server").OffthreadVideoServerEmitter;
     }>;
     validateEvenDimensionsWithCodec: ({ width, height, codec, scale, }: {
         width: number;
@@ -64,19 +57,14 @@ export declare const RenderInternals: {
         scale: number;
         codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
     }) => void;
-    normalizeServeUrl: (unnormalized: string) => string;
-    spawnFfmpeg: (options: import("./stitch-frames-to-video").StitcherOptions) => Promise<{
-        task: Promise<Buffer | null>;
-        getLogs: () => string;
-    }>;
-    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "gif" | "webm" | "mp4" | "mov" | "mkv";
+    getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null) => import("./file-extensions").FileExtension;
     tmpDir: (str: string) => string;
-    deleteDirectory: (directory: string) => Promise<void>;
+    deleteDirectory: (directory: string) => void;
     isServeUrl: (potentialUrl: string) => boolean;
     ensureOutputDirectory: (outputLocation: string) => void;
     getRealFrameRange: (durationInFrames: number, frameRange: import("./frame-range").FrameRange | null) => [number, number];
     validatePuppeteerTimeout: (timeoutInMilliseconds: unknown) => void;
-    downloadFile: ({ onProgress, url, to: toFn, }: {
+    downloadFile: (options: {
         url: string;
         to: (contentDisposition: string | null, contentType: string | null) => string;
         onProgress: ((progress: {
@@ -84,18 +72,20 @@ export declare const RenderInternals: {
             downloaded: number;
             totalSize: number | null;
         }) => void) | undefined;
-    }) => Promise<{
+    }, retries?: number, attempt?: number) => Promise<{
         sizeInBytes: number;
         to: string;
     }>;
-    validateScale: (scale: unknown) => void;
     killAllBrowsers: () => Promise<void>;
     parseStack: (stack: string[]) => import("./parse-browser-error-stack").UnsymbolicatedStackFrame[];
     symbolicateError: (symbolicateableError: SymbolicateableError) => Promise<import("./error-handling/handle-javascript-exception").ErrorWithStackFrame>;
     SymbolicateableError: typeof SymbolicateableError;
     getFramesToRender: (frameRange: [number, number], everyNthFrame: number) => number[];
     getExtensionOfFilename: (filename: string | null) => string | null;
-    getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<number>;
+    getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<{
+        port: number;
+        didUsePort: () => void;
+    }>;
     isPathInside: (thePath: string, potentialParent: string) => boolean;
     execa: {
         (file: string, arguments?: readonly string[] | undefined, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
@@ -126,29 +116,358 @@ export declare const RenderInternals: {
     validateFrameRange: (frameRange: import("./frame-range").FrameRange | null) => void;
     DEFAULT_OPENGL_RENDERER: "angle" | "swangle" | "egl" | "swiftshader" | null;
     validateOpenGlRenderer: (option: "angle" | "swangle" | "egl" | "swiftshader" | null) => "angle" | "swangle" | "egl" | "swiftshader" | null;
-    getDefaultCrfForCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => number;
-    validateSelectedCrfAndCodecCombination: (crf: unknown, codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => void;
-    validImageFormats: readonly ["png", "jpeg", "none"];
     validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
     DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
-    validateQuality: (q: number | undefined) => void;
-    validateFrame: (frame: number, durationInFrames: number) => void;
+    validateJpegQuality: (q: number | undefined) => void;
     DEFAULT_TIMEOUT: number;
-    getValidCrfRanges: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => [number, number];
-    validateSelectedPixelFormatAndCodecCombination: (pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le", codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => void;
-    validateSelectedCodecAndProResCombination: (actualCodec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", actualProResProfile: "proxy" | "4444-xq" | "4444" | "hq" | "standard" | "light" | undefined) => void;
-    validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le", imageFormat: "jpeg" | "png" | "none") => "none" | "valid";
     DEFAULT_CODEC: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
     isAudioCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
     logLevels: readonly ["verbose", "info", "warn", "error"];
     isEqualOrBelowLogLevel: (currentLevel: "error" | "verbose" | "info" | "warn", level: "error" | "verbose" | "info" | "warn") => boolean;
     isValidLogLevel: (level: string) => boolean;
-    validateEveryNthFrame: (everyNthFrame: unknown) => void;
     perf: typeof perf;
-    makeDownloadMap: () => import("./assets/download-map").DownloadMap;
-    cleanDownloadMap: (downloadMap: import("./assets/download-map").DownloadMap) => Promise<void>;
     convertToPositiveFrameIndex: ({ frame, durationInFrames, }: {
         frame: number;
         durationInFrames: number;
     }) => number;
+    findRemotionRoot: () => string;
+    validateBitrate: (bitrate: unknown, name: string) => void;
+    combineVideos: (options: {
+        files: string[];
+        filelistDir: string;
+        output: string;
+        onProgress: (p: number) => void;
+        numberOfFrames: number;
+        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+        fps: number;
+        numberOfGifLoops: number | null;
+        audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null;
+    }) => Promise<void>;
+    getMinConcurrency: () => number;
+    getMaxConcurrency: () => any;
+    getDefaultAudioCodec: ({ codec, preferLossless, }: {
+        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+        preferLossless: boolean;
+    }) => "mp3" | "aac" | "pcm-16" | "opus" | null;
+    validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+    defaultFileExtensionMap: {
+        h264: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        h265: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp8: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp9: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        mp3: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                mp3: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        aac: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        wav: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        prores: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        "h264-mkv": {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        gif: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                [x: string]: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+    };
+    supportedAudioCodecs: {
+        readonly h264: readonly ["aac", "pcm-16"];
+        readonly 'h264-mkv': readonly ["pcm-16"];
+        readonly aac: readonly ["aac", "pcm-16"];
+        readonly gif: const[];
+        readonly h265: readonly ["aac", "pcm-16"];
+        readonly mp3: readonly ["mp3", "pcm-16"];
+        readonly prores: readonly ["aac", "pcm-16"];
+        readonly vp8: readonly ["opus", "pcm-16"];
+        readonly vp9: readonly ["opus", "pcm-16"];
+        readonly wav: readonly ["pcm-16"];
+    };
+    makeFileExtensionMap: () => Record<string, ("h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif")[]>;
+    defaultCodecsForFileExtension: Record<import("./file-extensions").FileExtension, "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">;
+    getExecutablePath: (type: "compositor" | "ffmpeg" | "ffprobe" | "ffmpeg-cwd") => string;
+    callFf: (bin: "ffmpeg" | "ffprobe", args: (string | null)[], options?: execa.Options<string> | undefined) => execa.ExecaChildProcess<string>;
+    dynamicLibraryPathOptions: () => {
+        env: {
+            DYLD_LIBRARY_PATH: string;
+            RUST_BACKTRACE: string;
+        } | {
+            PATH: string;
+            RUST_BACKTRACE: string;
+        } | {
+            LD_LIBRARY_PATH: string;
+            RUST_BACKTRACE: string;
+        };
+    };
+    validStillImageFormats: readonly ["png", "jpeg", "pdf", "webp"];
+    validVideoImageFormats: readonly ["png", "jpeg", "none"];
+    DEFAULT_STILL_IMAGE_FORMAT: "jpeg" | "png" | "webp" | "pdf";
+    DEFAULT_VIDEO_IMAGE_FORMAT: "jpeg" | "png" | "none";
+    DEFAULT_JPEG_QUALITY: number;
+    chalk: {
+        enabled: boolean;
+        visible: boolean;
+        styles: Record<string, {
+            codes: [number, number];
+            name: string;
+            wrap?: ((input: string, newline: boolean) => string) | undefined;
+        }>;
+        keys: Record<string, string[]>;
+        alias?: ((name: string, col: string) => void) | undefined;
+    } & {
+        reset: (str: string) => string;
+        bold: (str: string) => string;
+        dim: (str: string) => string;
+        italic: (str: string) => string;
+        underline: (str: string) => string;
+        inverse: (str: string) => string;
+        hidden: (str: string) => string;
+        strikethrough: (str: string) => string;
+        black: (str: string) => string;
+        red: (str: string) => string;
+        green: (str: string) => string;
+        yellow: (str: string) => string;
+        blue: (str: string) => string;
+        magenta: (str: string) => string;
+        white: (str: string) => string;
+        gray: (str: string) => string;
+        bgBlack: (str: string) => string;
+        bgRed: (str: string) => string;
+        bgGreen: (str: string) => string;
+        bgYellow: (str: string) => string;
+        bgBlue: (str: string) => string;
+        bgMagenta: (str: string) => string;
+        bgWhite: (str: string) => string;
+        blackBright: (str: string) => string;
+        redBright: (str: string) => string;
+        greenBright: (str: string) => string;
+        yellowBright: (str: string) => string;
+        blueBright: (str: string) => string;
+        magentaBright: (str: string) => string;
+        whiteBright: (str: string) => string;
+        bgBlackBright: (str: string) => string;
+        bgRedBright: (str: string) => string;
+        bgGreenBright: (str: string) => string;
+        bgYellowBright: (str: string) => string;
+        bgBlueBright: (str: string) => string;
+        bgMagentaBright: (str: string) => string;
+        bgWhiteBright: (str: string) => string;
+    };
+    Log: {
+        verbose: (message?: any, ...optionalParams: any[]) => void;
+        verboseAdvanced: (options: {
+            indent: boolean;
+            logLevel: "error" | "verbose" | "info" | "warn";
+        } & {
+            tag?: string | undefined;
+            secondTag?: string | undefined;
+        }, message?: any, ...optionalParams: any[]) => void;
+        info: (message?: any, ...optionalParams: any[]) => void;
+        infoAdvanced: (options: {
+            indent: boolean;
+            logLevel: "error" | "verbose" | "info" | "warn";
+        }, message?: any, ...optionalParams: any[]) => void;
+        warn: (message?: any, ...optionalParams: any[]) => void;
+        warnAdvanced: (options: {
+            indent: boolean;
+            logLevel: "error" | "verbose" | "info" | "warn";
+        }, message?: any, ...optionalParams: any[]) => void;
+        error: (message?: any, ...optionalParams: any[]) => void;
+    };
+    getLogLevel: () => "error" | "verbose" | "info" | "warn";
+    setLogLevel: (newLogLevel: "error" | "verbose" | "info" | "warn") => void;
+    INDENT_TOKEN: string;
+    isColorSupported: boolean;
+    HeadlessBrowser: typeof HeadlessBrowser;
+    prepareServer: ({ webpackConfigOrServeUrl, port, remotionRoot, concurrency, verbose, indent, }: {
+        webpackConfigOrServeUrl: string;
+        port: number | null;
+        remotionRoot: string;
+        concurrency: number;
+        verbose: boolean;
+        indent: boolean;
+    }) => Promise<import("./prepare-server").RemotionServer>;
+    makeOrReuseServer: (server: import("./prepare-server").RemotionServer | undefined, config: {
+        webpackConfigOrServeUrl: string;
+        port: number | null;
+        remotionRoot: string;
+        concurrency: number;
+        verbose: boolean;
+        indent: boolean;
+    }, { onDownload, onError, }: {
+        onError: (err: Error) => void;
+        onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload | null;
+    }) => Promise<{
+        server: import("./prepare-server").RemotionServer;
+        cleanupServer: (force: boolean) => Promise<unknown>;
+    }>;
+    internalRenderStill: (options: {
+        composition: import("remotion").AnySmallCompMetadata;
+        output: string | null;
+        frame: number;
+        inputProps: Record<string, unknown>;
+        imageFormat: "jpeg" | "png" | "webp" | "pdf";
+        jpegQuality: number;
+        puppeteerInstance: HeadlessBrowser | null;
+        dumpBrowserLogs: boolean;
+        envVariables: Record<string, string>;
+        overwrite: boolean;
+        browserExecutable: import("./browser-executable").BrowserExecutable;
+        onBrowserLog: ((log: import("./browser-log").BrowserLog) => void) | null;
+        timeoutInMilliseconds: number;
+        chromiumOptions: import("./open-browser").ChromiumOptions;
+        scale: number;
+        onDownload: import("./assets/download-and-map-assets-to-file").RenderMediaOnDownload | null;
+        cancelSignal: import("./make-cancel-signal").CancelSignal | null;
+        indent: boolean;
+        server: import("./prepare-server").RemotionServer | undefined;
+        verbose: boolean;
+        serveUrl: string;
+        port: number | null;
+    }) => Promise<{
+        buffer: Buffer | null;
+    }>;
+    internalOpenBrowser: ({ browser, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, shouldDumpIo, viewport, }: {
+        shouldDumpIo: boolean;
+        browserExecutable: string | null;
+        chromiumOptions: import("./open-browser").ChromiumOptions;
+        forceDeviceScaleFactor: number | undefined;
+        viewport: import("./browser/PuppeteerViewport").Viewport | null;
+        indent: boolean;
+        browser: import("./browser").Browser;
+    }) => Promise<HeadlessBrowser>;
+    internalSelectComposition: (options: {
+        inputProps: Record<string, unknown>;
+        envVariables: Record<string, string>;
+        puppeteerInstance: HeadlessBrowser | undefined;
+        onBrowserLog: ((log: import("./browser-log").BrowserLog) => void) | null;
+        browserExecutable: import("./browser-executable").BrowserExecutable;
+        timeoutInMilliseconds: number;
+        chromiumOptions: import("./open-browser").ChromiumOptions;
+        port: number | null;
+        indent: boolean;
+        server: import("./prepare-server").RemotionServer | undefined;
+        verbose: boolean;
+        serveUrl: string;
+        id: string;
+    }) => Promise<import("remotion").AnyCompMetadata>;
+    internalGetCompositions: ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, verbose, }: {
+        inputProps: Record<string, unknown>;
+        envVariables: Record<string, string>;
+        puppeteerInstance: HeadlessBrowser | undefined;
+        onBrowserLog: ((log: import("./browser-log").BrowserLog) => void) | null;
+        browserExecutable: import("./browser-executable").BrowserExecutable;
+        timeoutInMilliseconds: number;
+        chromiumOptions: import("./open-browser").ChromiumOptions;
+        port: number | null;
+        server: import("./prepare-server").RemotionServer | undefined;
+        indent: boolean;
+        verbose: boolean;
+        serveUrlOrWebpackUrl: string;
+    }) => Promise<import("remotion").AnyCompMetadata[]>;
+    internalRenderFrames: ({ browserExecutable, cancelSignal, chromiumOptions, composition, concurrency, dumpBrowserLogs, envVariables, everyNthFrame, frameRange, imageFormat, indent, inputProps, jpegQuality, muted, onBrowserLog, onDownload, onFrameBuffer, onFrameUpdate, onStart, outputDir, port, puppeteerInstance, scale, server, timeoutInMilliseconds, verbose, webpackBundleOrServeUrl, }: import("./render-frames").InternalRenderFramesOptions) => Promise<import("./types").RenderFramesOutput>;
+    internalRenderMedia: ({ proResProfile, crf, composition, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, audioCodec, concurrency, disallowParallelEncoding, everyNthFrame, imageFormat: provisionalImageFormat, indent, jpegQuality, numberOfGifLoops, onCtrlCExit, preferLossless, serveUrl, server: reusedServer, verbose, }: import("./render-media").InternalRenderMediaOptions) => Promise<{
+        buffer: Buffer | null;
+        slowestFrames: import("./render-media").SlowFrame[];
+    }>;
+    validOpenGlRenderers: readonly ["swangle", "angle", "egl", "swiftshader"];
 };