@remotion/renderer 4.0.0-alpha.4 → 4.0.0-alpha5

package/dist/get-local-browser-executable.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalBrowserExecutable = exports.ensureLocalBrowser = void 0;
 const fs_1 = __importDefault(require("fs"));
+const BrowserFetcher_1 = require("./browser/BrowserFetcher");
 const create_browser_fetcher_1 = require("./browser/create-browser-fetcher");
-const node_1 = require("./browser/node");
 const revisions_1 = require("./browser/revisions");
 const getSearchPathsForProduct = (product) => {
     var _a;
@@ -18,6 +18,7 @@ const getSearchPathsForProduct = (product) => {
                 : null,
             process.platform === 'linux' ? '/usr/bin/google-chrome' : null,
             process.platform === 'linux' ? '/usr/bin/chromium-browser' : null,
+            process.platform === 'linux' ? '/usr/bin/chromium' : null,
             process.platform === 'linux'
                 ? '/app/.apt/usr/bin/google-chrome-stable'
                 : null,
@@ -43,17 +44,6 @@ const getLocalBrowser = (product) => {
     }
     return null;
 };
-const getBrowserRevision = (product) => {
-    const browserFetcher = node_1.puppeteer.createBrowserFetcher({
-        product,
-        path: null,
-        platform: null,
-    });
-    const revisionInfo = browserFetcher.revisionInfo(product === 'firefox'
-        ? revisions_1.PUPPETEER_REVISIONS.firefox
-        : revisions_1.PUPPETEER_REVISIONS.chromium);
-    return revisionInfo;
-};
 const getBrowserStatus = (product, browserExecutablePath) => {
     if (browserExecutablePath) {
         if (!fs_1.default.existsSync(browserExecutablePath)) {
@@ -65,8 +55,8 @@ const getBrowserStatus = (product, browserExecutablePath) => {
     if (localBrowser !== null) {
         return { path: localBrowser, type: 'local-browser' };
     }
-    const revision = getBrowserRevision(product);
-    if (revision.local !== null && fs_1.default.existsSync(revision.executablePath)) {
+    const revision = (0, BrowserFetcher_1.getRevisionInfo)(revisions_1.PUPPETEER_REVISIONS.chromium, product);
+    if (revision.local && fs_1.default.existsSync(revision.executablePath)) {
         return { path: revision.executablePath, type: 'local-puppeteer-browser' };
     }
     return { type: 'no-browser' };

package/dist/get-port.d.ts

@@ -1 +1,4 @@
-export declare const getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<number>;
+export declare const getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<{
+    port: number;
+    didUsePort: () => void;
+}>;

package/dist/get-port.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDesiredPort = void 0;
 const net_1 = __importDefault(require("net"));
-const p_limit_1 = require("./p-limit");
+const locks_1 = require("./locks");
 const getAvailablePort = (portToTry) => new Promise((resolve) => {
     let status = 'unavailable';
     const host = '127.0.0.1';
@@ -35,21 +35,21 @@ const getPort = async (from, to) => {
     }
     throw new Error('No available ports found');
 };
-const getDesiredPortUnlimited = async (desiredPort, from, to) => {
+const portLocks = (0, locks_1.createLock)({ timeout: 10000 });
+const getDesiredPort = async (desiredPort, from, to) => {
+    await portLocks.waitForAllToBeDone();
+    const lockPortSelection = portLocks.lock();
+    const didUsePort = () => portLocks.unlock(lockPortSelection);
     if (typeof desiredPort !== 'undefined' &&
         (await getAvailablePort(desiredPort)) === 'available') {
-        return desiredPort;
+        return { port: desiredPort, didUsePort };
     }
     const actualPort = await getPort(from, to);
     // If did specify a port but did not get that one, fail hard.
     if (desiredPort && desiredPort !== actualPort) {
         throw new Error(`You specified port ${desiredPort} to be used for the HTTP server, but it is not available. Choose a different port or remove the setting to let Remotion automatically select a free port.`);
     }
-    return actualPort;
-};
-const limit = (0, p_limit_1.pLimit)(1);
-const getDesiredPort = (desiredPort, from, to) => {
-    return limit(() => getDesiredPortUnlimited(desiredPort, from, to));
+    return { port: actualPort, didUsePort };
 };
 exports.getDesiredPort = getDesiredPort;
 const makeRange = (from, to) => {

package/dist/get-video-info.d.ts

@@ -1,3 +1,8 @@
 import type { DownloadMap, Vp9Result } from './assets/download-map';
 import type { FfmpegExecutable } from './ffmpeg-executable';
-export declare const getVideoInfo: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable) => Promise<Vp9Result>;
+export declare function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }: {
+    src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}): Promise<Vp9Result>;
+export declare const getVideoInfo: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<Vp9Result>;

package/dist/get-video-info.js

@@ -3,17 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVideoInfo = void 0;
+exports.getVideoInfo = exports.getVideoInfoUncached = void 0;
 const execa_1 = __importDefault(require("execa"));
 const calculate_sar_dar_pixels_1 = require("./calculate-sar-dar-pixels");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const p_limit_1 = require("./p-limit");
 const limit = (0, p_limit_1.pLimit)(1);
-async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable) {
+async function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }) {
     var _a;
-    if (typeof downloadMap.isVp9VideoCache[src] !== 'undefined') {
-        return downloadMap.isVp9VideoCache[src];
-    }
-    const task = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', [src]);
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), [src]);
     const isVp9 = task.stderr.includes('Video: vp9');
     const isVp8 = task.stderr.includes('Video: vp8');
     const dimensions = (_a = task.stderr
@@ -37,13 +35,25 @@ async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable) {
         }
     }
     const result = {
-        specialVcodec: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
+        specialVcodecForTransparency: isVp9 ? 'vp9' : isVp8 ? 'vp8' : 'none',
         needsResize,
     };
+    return result;
+}
+exports.getVideoInfoUncached = getVideoInfoUncached;
+async function getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (typeof downloadMap.isVp9VideoCache[src] !== 'undefined') {
+        return downloadMap.isVp9VideoCache[src];
+    }
+    const result = await getVideoInfoUncached({
+        ffprobeExecutable,
+        remotionRoot,
+        src,
+    });
     downloadMap.isVp9VideoCache[src] = result;
     return downloadMap.isVp9VideoCache[src];
 }
-const getVideoInfo = (downloadMap, src, ffprobeExecutable) => {
-    return limit(() => getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable));
+const getVideoInfo = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoInfoUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
 };
 exports.getVideoInfo = getVideoInfo;

package/dist/guess-extension-for-media.d.ts

@@ -1 +1,3 @@
-export declare const guessExtensionForVideo: (src: string) => Promise<"mp3" | "wav" | "webm" | "mp4">;
+export declare const guessExtensionForVideo: ({ src }: {
+    src: string;
+}) => Promise<"mp3" | "wav" | "mp4" | "webm">;

package/dist/guess-extension-for-media.js

@@ -1,13 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.guessExtensionForVideo = void 0;
-const execa_1 = __importDefault(require("execa"));
-const guessExtensionForVideo = async (src) => {
-    const { stderr } = await (0, execa_1.default)('ffprobe', [src]);
-    if (stderr.includes('mp3,')) {
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const guessExtensionForVideo = async ({ src }) => {
+    const { stderr } = await (0, call_ffmpeg_1.callFf)('ffprobe', [src]);
+    if (stderr.includes('Audio: mp3,')) {
         return 'mp3';
     }
     if (stderr.includes('Video: vp9')) {
@@ -22,6 +19,6 @@ const guessExtensionForVideo = async (src) => {
     if (stderr.includes('Video: h264')) {
         return 'mp4';
     }
-    throw new Error(`A media file ${src} which has no file extension and whose format could not be guessed. Is this a valid media file?`);
+    throw new Error(`The media file "${src}" has no file extension and the format could not be guessed. Tips: a) Ensure this is a valid video or audio file b) Add a file extension to the URL like ".mp4" c) Set a "Content-Type" or "Content-Disposition" header if possible.`);
 };
 exports.guessExtensionForVideo = guessExtensionForVideo;

package/dist/image-format.d.ts

@@ -1,7 +1,13 @@
 import type { PixelFormat } from './pixel-format';
-export declare const validImageFormats: readonly ["png", "jpeg", "none"];
-export declare type ImageFormat = typeof validImageFormats[number];
-export declare type StillImageFormat = 'png' | 'jpeg';
-export declare const DEFAULT_IMAGE_FORMAT: ImageFormat;
-export declare const validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: PixelFormat, imageFormat: ImageFormat) => 'none' | 'valid';
-export declare const validateNonNullImageFormat: (imageFormat: ImageFormat) => void;
+export declare const validVideoImageFormats: readonly ["png", "jpeg", "none"];
+export declare const validStillImageFormats: readonly ["png", "jpeg", "pdf", "webp"];
+export declare type VideoImageFormat = typeof validVideoImageFormats[number];
+export declare type StillImageFormat = typeof validStillImageFormats[number];
+/**
+ * @deprecated Use VideoImageFormat or StillImageFormat instead
+ */
+export declare type ImageFormat = 'This type is deprecated, use VideoImageFormat or StillImageFormat instead';
+export declare const DEFAULT_VIDEO_IMAGE_FORMAT: VideoImageFormat;
+export declare const DEFAULT_STILL_IMAGE_FORMAT: StillImageFormat;
+export declare const validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: PixelFormat | undefined, videoImageFormat: VideoImageFormat) => 'none' | 'valid';
+export declare const validateStillImageFormat: (imageFormat: StillImageFormat) => void;

package/dist/image-format.js

@@ -2,30 +2,36 @@
 // Keeping the default image format PNG if you don't pass a
 // value to the renderer for backwards compatibility.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateNonNullImageFormat = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.DEFAULT_IMAGE_FORMAT = exports.validImageFormats = void 0;
-exports.validImageFormats = ['png', 'jpeg', 'none'];
-// However, the CLI will override it and use JPEG if suitable.
-exports.DEFAULT_IMAGE_FORMAT = 'png';
+exports.validateStillImageFormat = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.DEFAULT_STILL_IMAGE_FORMAT = exports.DEFAULT_VIDEO_IMAGE_FORMAT = exports.validStillImageFormats = exports.validVideoImageFormats = void 0;
+exports.validVideoImageFormats = ['png', 'jpeg', 'none'];
+exports.validStillImageFormats = ['png', 'jpeg', 'pdf', 'webp'];
+exports.DEFAULT_VIDEO_IMAGE_FORMAT = 'jpeg';
+exports.DEFAULT_STILL_IMAGE_FORMAT = 'png';
 // By returning a value, we improve testability as we can specifically test certain branches
-const validateSelectedPixelFormatAndImageFormatCombination = (pixelFormat, imageFormat) => {
-    if (imageFormat === 'none') {
+const validateSelectedPixelFormatAndImageFormatCombination = (pixelFormat, videoImageFormat) => {
+    if (videoImageFormat === 'none') {
         return 'none';
     }
-    if (!exports.validImageFormats.includes(imageFormat)) {
-        throw new TypeError(`Value ${imageFormat} is not valid as an image format.`);
+    if (typeof pixelFormat === 'undefined') {
+        return 'valid';
+    }
+    if (!exports.validVideoImageFormats.includes(videoImageFormat)) {
+        throw new TypeError(`Value ${videoImageFormat} is not valid as an image format.`);
     }
     if (pixelFormat !== 'yuva420p' && pixelFormat !== 'yuva444p10le') {
         return 'valid';
     }
-    if (imageFormat !== 'png') {
+    if (videoImageFormat !== 'png') {
         throw new TypeError(`Pixel format was set to '${pixelFormat}' but the image format is not PNG. To render transparent videos, you need to set PNG as the image format.`);
     }
     return 'valid';
 };
 exports.validateSelectedPixelFormatAndImageFormatCombination = validateSelectedPixelFormatAndImageFormatCombination;
-const validateNonNullImageFormat = (imageFormat) => {
-    if (imageFormat !== 'jpeg' && imageFormat !== 'png') {
-        throw new TypeError('Image format should be either "png" or "jpeg"');
+const validateStillImageFormat = (imageFormat) => {
+    if (!exports.validStillImageFormats.includes(imageFormat)) {
+        throw new TypeError(String(`Image format should be one of: ${exports.validStillImageFormats
+            .map((v) => `"${v}"`)
+            .join(', ')}`));
     }
 };
-exports.validateNonNullImageFormat = validateNonNullImageFormat;
+exports.validateStillImageFormat = validateStillImageFormat;

package/dist/index.d.ts

@@ -4,54 +4,44 @@ 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 { 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 { 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 { ProResProfile } from './prores-profile';
 export { renderFrames } from './render-frames';
-export { renderMedia, RenderMediaOnProgress, RenderMediaOptions, StitchingState, } from './render-media';
-export { renderStill } from './render-still';
+export { renderMedia, RenderMediaOnProgress, RenderMediaOptions, SlowFrame, StitchingState, } from './render-media';
+export { renderStill, RenderStillOptions } from './render-still';
 export { StitcherOptions, stitchFramesToVideo } 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, isLambda, }: {
-        ffmpegExecutable: string | null;
-        feature: "enable-gpl" | "enable-libx265" | "enable-libvpx";
-        isLambda: boolean;
-    }) => 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;
     }) => Promise<{
         port: number;
         close: () => Promise<void>;
@@ -60,23 +50,18 @@ export declare const RenderInternals: {
         width: number;
         height: number;
         scale: number;
-        codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+        codec: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "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: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", type: "chunk" | "final") => "mp3" | "aac" | "wav" | "gif" | "mp4" | "mkv" | "mov" | "webm";
+    getFileExtensionFromCodec: <T extends "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: "pcm-16" | "aac" | "mp3" | "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, }: {
         url: string;
-        to: (contentDisposition: string | null) => string;
+        to: (contentDisposition: string | null, contentType: string | null) => string;
         onProgress: ((progress: {
             percent: number | null;
             downloaded: number;
@@ -86,14 +71,16 @@ export declare const RenderInternals: {
         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>;
@@ -115,7 +102,7 @@ export declare const RenderInternals: {
     };
     registerErrorSymbolicationLock: () => number;
     unlockErrorSymbolicationLock: (id: number) => void;
-    canUseParallelEncoding: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
+    canUseParallelEncoding: (codec: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif") => boolean;
     mimeContentType: typeof mimeContentType;
     mimeLookup: typeof mimeLookup;
     validateConcurrency: (value: unknown, setting: string) => void;
@@ -124,26 +111,192 @@ export declare const RenderInternals: {
     validateFrameRange: (frameRange: import("./frame-range").FrameRange | null) => void;
     DEFAULT_OPENGL_RENDERER: "swangle" | "angle" | "egl" | "swiftshader" | null;
     validateOpenGlRenderer: (option: "swangle" | "angle" | "egl" | "swiftshader" | null) => "swangle" | "angle" | "egl" | "swiftshader" | null;
-    getDefaultCrfForCodec: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => number;
-    validateSelectedCrfAndCodecCombination: (crf: unknown, codec: "vp9" | "vp8" | "h264" | "h265" | "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_OVERWRITE: boolean;
     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: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => [number, number];
-    validateSelectedPixelFormatAndCodecCombination: (pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le", codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => void;
-    validateSelectedCodecAndProResCombination: (actualCodec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif", actualProResProfile: "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy" | undefined) => void;
-    validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le", imageFormat: "none" | "png" | "jpeg") => "none" | "valid";
-    DEFAULT_CODEC: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
-    isAudioCodec: (codec: "vp9" | "vp8" | "h264" | "h265" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
+    DEFAULT_CODEC: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif";
+    isAudioCodec: (codec: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
     logLevels: readonly ["verbose", "info", "warn", "error"];
     isEqualOrBelowLogLevel: (currentLevel: "verbose" | "info" | "warn" | "error", level: "verbose" | "info" | "warn" | "error") => 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>;
+    cleanDownloadMap: (downloadMap: import("./assets/download-map").DownloadMap) => 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: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif";
+        fps: number;
+        numberOfGifLoops: number | null;
+        audioCodec: "pcm-16" | "aac" | "mp3" | "opus" | null;
+    }) => Promise<void>;
+    getMinConcurrency: () => number;
+    getMaxConcurrency: () => any;
+    getDefaultAudioCodec: ({ codec, preferLossless, }: {
+        codec: "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif";
+        preferLossless: boolean;
+    }) => "pcm-16" | "aac" | "mp3" | "opus" | null;
+    validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+    defaultFileExtensionMap: {
+        aac: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        mp3: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                mp3: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        h264: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        h265: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                aac: {
+                    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;
+                };
+            };
+        };
+        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: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                aac: {
+                    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, ("aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "wav" | "prores" | "h264-mkv" | "gif")[]>;
+    defaultCodecsForFileExtension: Record<import("./file-extensions").FileExtension, "aac" | "mp3" | "h264" | "h265" | "vp8" | "vp9" | "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: "png" | "jpeg" | "pdf" | "webp";
+    DEFAULT_VIDEO_IMAGE_FORMAT: "png" | "jpeg" | "none";
 };