@remotion/cli 4.0.0-lambda.3 → 4.0.0-newpaths.13

package/dist/get-env.js

@@ -4,10 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnvironmentVariables = void 0;
+const renderer_1 = require("@remotion/renderer");
 const dotenv_1 = __importDefault(require("dotenv"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const remotion_1 = require("remotion");
+const chalk_1 = require("./chalk");
+const config_1 = require("./config");
 const log_1 = require("./log");
 const parse_command_line_1 = require("./parse-command-line");
 function getProcessEnv() {
@@ -18,9 +20,54 @@ function getProcessEnv() {
     }
     return env;
 }
-const getEnvForEnvFile = async (processEnv, envFile) => {
+const watchEnvFile = ({ processEnv, envFile, onUpdate, existedBefore, }) => {
+    const listener = async () => {
+        try {
+            const file = await fs_1.default.promises.readFile(envFile, 'utf-8');
+            onUpdate({
+                ...processEnv,
+                ...dotenv_1.default.parse(file),
+            });
+            if (existedBefore) {
+                log_1.Log.info(chalk_1.chalk.blueBright(`Updated env file ${envFile}`));
+            }
+            else {
+                log_1.Log.info(chalk_1.chalk.blueBright(`Added env file ${envFile}`));
+            }
+            fs_1.default.unwatchFile(envFile, listener);
+            watchEnvFile({
+                envFile,
+                existedBefore: true,
+                onUpdate,
+                processEnv,
+            });
+        }
+        catch (err) {
+            // No error message if user did not have a .env file from the beginning
+            if (!existedBefore && !fs_1.default.existsSync(envFile)) {
+                return;
+            }
+            if (fs_1.default.existsSync(envFile) && existedBefore) {
+                log_1.Log.error(`${envFile} update failed with error ${err}`);
+            }
+            else {
+                log_1.Log.warn(`${envFile} was deleted.`);
+                fs_1.default.unwatchFile(envFile, listener);
+                watchEnvFile({
+                    envFile,
+                    existedBefore: false,
+                    onUpdate,
+                    processEnv,
+                });
+            }
+        }
+    };
+    fs_1.default.watchFile(envFile, { interval: 100 }, listener);
+};
+const getEnvForEnvFile = async (processEnv, envFile, onUpdate) => {
     try {
         const envFileData = await fs_1.default.promises.readFile(envFile);
+        watchEnvFile({ processEnv, envFile, onUpdate, existedBefore: true });
         return {
             ...processEnv,
             ...dotenv_1.default.parse(envFileData),
@@ -32,7 +79,7 @@ const getEnvForEnvFile = async (processEnv, envFile) => {
         process.exit(1);
     }
 };
-const getEnvironmentVariables = () => {
+const getEnvironmentVariables = (onUpdate) => {
     const processEnv = getProcessEnv();
     if (parse_command_line_1.parsedCli['env-file']) {
         const envFile = path_1.default.resolve(process.cwd(), parse_command_line_1.parsedCli['env-file']);
@@ -42,23 +89,30 @@ const getEnvironmentVariables = () => {
             log_1.Log.error('Check that your path is correct and try again.');
             process.exit(1);
         }
-        return getEnvForEnvFile(processEnv, envFile);
+        return getEnvForEnvFile(processEnv, envFile, onUpdate);
     }
-    const configFileSetting = remotion_1.Internals.getDotEnvLocation();
+    const remotionRoot = renderer_1.RenderInternals.findRemotionRoot();
+    const configFileSetting = config_1.ConfigInternals.getDotEnvLocation();
     if (configFileSetting) {
-        const envFile = path_1.default.resolve(process.cwd(), configFileSetting);
+        const envFile = path_1.default.resolve(remotionRoot, configFileSetting);
         if (!fs_1.default.existsSync(envFile)) {
-            log_1.Log.error('You specifed a custom .env file using `Config.Rendering.setDotEnvLocation()` in the config file but it could not be found');
+            log_1.Log.error('You specified a custom .env file using `Config.setDotEnvLocation()` in the config file but it could not be found');
             log_1.Log.error('We looked for the file at:', envFile);
             log_1.Log.error('Check that your path is correct and try again.');
             process.exit(1);
         }
-        return getEnvForEnvFile(processEnv, envFile);
+        return getEnvForEnvFile(processEnv, envFile, onUpdate);
     }
-    const defaultEnvFile = path_1.default.resolve(process.cwd(), '.env');
+    const defaultEnvFile = path_1.default.resolve(remotionRoot, '.env');
     if (!fs_1.default.existsSync(defaultEnvFile)) {
+        watchEnvFile({
+            processEnv,
+            envFile: defaultEnvFile,
+            onUpdate,
+            existedBefore: false,
+        });
         return Promise.resolve(processEnv);
     }
-    return getEnvForEnvFile(processEnv, defaultEnvFile);
+    return getEnvForEnvFile(processEnv, defaultEnvFile, onUpdate);
 };
 exports.getEnvironmentVariables = getEnvironmentVariables;

package/dist/get-filename.d.ts

@@ -1,6 +1,8 @@
-import { Codec } from 'remotion';
-export declare const getOutputFilename: ({ codec, imageSequence, type, }: {
+import type { Codec } from '@remotion/renderer';
+export declare const getOutputFilename: ({ codec, imageSequence, compositionName, defaultExtension, args, }: {
     codec: Codec;
     imageSequence: boolean;
-    type: 'still' | 'series';
+    compositionName: string;
+    defaultExtension: string;
+    args: string[];
 }) => string;

package/dist/get-filename.js

@@ -4,11 +4,13 @@ exports.getOutputFilename = void 0;
 const renderer_1 = require("@remotion/renderer");
 const log_1 = require("./log");
 const user_passed_output_location_1 = require("./user-passed-output-location");
-const getOutputFilename = ({ codec, imageSequence, type, }) => {
-    let filename = (0, user_passed_output_location_1.getUserPassedOutputLocation)();
-    if (type === 'still') {
-        return filename;
-    }
+const getOutputFilename = ({ codec, imageSequence, compositionName, defaultExtension, args, }) => {
+    let filename = (0, user_passed_output_location_1.getOutputLocation)({
+        compositionId: compositionName,
+        defaultExtension,
+        args,
+        type: imageSequence ? 'sequence' : 'asset',
+    });
     let extension = renderer_1.RenderInternals.getExtensionOfFilename(filename);
     if (imageSequence) {
         if (extension !== null) {

package/dist/get-final-output-codec.d.ts

@@ -0,0 +1,10 @@
+import type { Codec, CodecOrUndefined } from '@remotion/renderer';
+export declare const getFinalOutputCodec: ({ cliFlag, configFile, downloadName, outName, }: {
+    cliFlag: CodecOrUndefined;
+    outName: string | null;
+    downloadName: string | null;
+    configFile: Codec | null;
+}) => {
+    codec: Codec;
+    reason: string;
+};

package/dist/get-final-output-codec.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFinalOutputCodec = void 0;
+const renderer_1 = require("@remotion/renderer");
+const fileExtensions = {
+    webm: ['vp8', 'vp9'],
+    hevc: ['h265'],
+    mp3: ['mp3'],
+    mov: ['prores'],
+    wav: ['wav'],
+    aac: ['aac'],
+    mkv: ['h264-mkv'],
+    gif: ['gif'],
+    mp4: ['h264'],
+    m4a: ['aac'],
+};
+const deriveExtensionFromFilename = (extension) => {
+    var _a;
+    if (extension === null) {
+        return [];
+    }
+    return (_a = fileExtensions[extension]) !== null && _a !== void 0 ? _a : [];
+};
+const getFinalOutputCodec = ({ cliFlag, configFile, downloadName, outName, }) => {
+    const downloadNameExtension = renderer_1.RenderInternals.getExtensionOfFilename(downloadName);
+    const outNameExtension = renderer_1.RenderInternals.getExtensionOfFilename(outName);
+    const derivedDownloadCodecs = deriveExtensionFromFilename(downloadNameExtension);
+    const derivedOutNameCodecs = deriveExtensionFromFilename(outNameExtension);
+    if (derivedDownloadCodecs.length > 0 &&
+        derivedOutNameCodecs.length > 0 &&
+        derivedDownloadCodecs.join('') !== derivedOutNameCodecs.join('')) {
+        throw new TypeError(`The download name is ${downloadName} but the output name is ${outName}. The file extensions must match`);
+    }
+    if (cliFlag) {
+        if (derivedDownloadCodecs.length > 0 &&
+            derivedDownloadCodecs.indexOf(cliFlag) === -1) {
+            throw new TypeError(`The download name is ${downloadName} but --codec=${cliFlag} was passed. The download name implies a codec of ${derivedDownloadCodecs.join(' or ')} which does not align with the --codec flag.`);
+        }
+        if (derivedOutNameCodecs.length > 0 &&
+            derivedOutNameCodecs.indexOf(cliFlag) === -1) {
+            throw new TypeError(`The out name is ${outName} but --codec=${cliFlag} was passed. The out name implies a codec of ${derivedOutNameCodecs.join(' or ')} which does not align with the --codec flag.`);
+        }
+        return { codec: cliFlag, reason: 'from --codec flag' };
+    }
+    if (derivedDownloadCodecs.length > 0) {
+        return {
+            codec: derivedDownloadCodecs[0],
+            reason: 'derived from download name',
+        };
+    }
+    if (derivedOutNameCodecs.length > 0) {
+        return {
+            codec: derivedOutNameCodecs[0],
+            reason: 'derived from out name',
+        };
+    }
+    if (configFile) {
+        return {
+            codec: configFile,
+            reason: 'Config file',
+        };
+    }
+    return { codec: renderer_1.RenderInternals.DEFAULT_CODEC, reason: 'default' };
+};
+exports.getFinalOutputCodec = getFinalOutputCodec;

package/dist/get-input-props.d.ts

@@ -1 +1 @@
-export declare const getInputProps: () => object;
+export declare const getInputProps: (onUpdate: (newProps: object) => void) => object;

package/dist/get-input-props.js

@@ -9,7 +9,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const log_1 = require("./log");
 const parse_command_line_1 = require("./parse-command-line");
-const getInputProps = () => {
+const getInputProps = (onUpdate) => {
     if (!parse_command_line_1.parsedCli.props) {
         return {};
     }
@@ -17,6 +17,15 @@ const getInputProps = () => {
     try {
         if (fs_1.default.existsSync(jsonFile)) {
             const rawJsonData = fs_1.default.readFileSync(jsonFile, 'utf-8');
+            fs_1.default.watchFile(jsonFile, { interval: 100 }, () => {
+                try {
+                    onUpdate(JSON.parse(fs_1.default.readFileSync(jsonFile, 'utf-8')));
+                    log_1.Log.info(`Updated input props from ${jsonFile}.`);
+                }
+                catch (err) {
+                    log_1.Log.error(`${jsonFile} contains invalid JSON. Did not apply new input props.`);
+                }
+            });
             return JSON.parse(rawJsonData);
         }
         return JSON.parse(parse_command_line_1.parsedCli.props);

package/dist/get-network-address.d.ts

@@ -0,0 +1 @@
+export declare const getNetworkAddress: () => string | undefined;

package/dist/get-network-address.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNetworkAddress = void 0;
+const os_1 = require("os");
+const getNetworkAddress = () => {
+    for (const interfaceDetails of Object.values((0, os_1.networkInterfaces)())) {
+        if (!interfaceDetails)
+            continue;
+        for (const details of interfaceDetails) {
+            const { address, family, internal } = details;
+            if (family === 'IPv4' && !internal)
+                return address;
+        }
+    }
+};
+exports.getNetworkAddress = getNetworkAddress;

package/dist/get-render-media-options.d.ts

@@ -0,0 +1,8 @@
+import type { Codec, RenderMediaOptions } from '@remotion/renderer';
+export declare const getRenderMediaOptions: ({ outputLocation, config, serveUrl, codec, remotionRoot, }: {
+    outputLocation: RenderMediaOptions['outputLocation'];
+    config: RenderMediaOptions['composition'];
+    serveUrl: string;
+    codec: Codec;
+    remotionRoot: string;
+}) => Promise<RenderMediaOptions>;

package/dist/get-render-media-options.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRenderMediaOptions = void 0;
+const renderer_1 = require("@remotion/renderer");
+const config_1 = require("./config");
+const get_cli_options_1 = require("./get-cli-options");
+const image_formats_1 = require("./image-formats");
+const getRenderMediaOptions = async ({ outputLocation, config, serveUrl, codec, remotionRoot, }) => {
+    const { proResProfile, concurrency, frameRange, overwrite, inputProps, envVariables, quality, crf, pixelFormat, browserExecutable, ffmpegExecutable, ffprobeExecutable, scale, chromiumOptions, port, numberOfGifLoops, everyNthFrame, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, height, width, } = await (0, get_cli_options_1.getCliOptions)({
+        isLambda: false,
+        type: 'series',
+        remotionRoot,
+    });
+    const imageFormat = (0, image_formats_1.getImageFormat)(codec);
+    return {
+        outputLocation,
+        composition: {
+            ...config,
+            width: width !== null && width !== void 0 ? width : config.width,
+            height: height !== null && height !== void 0 ? height : config.height,
+        },
+        crf,
+        envVariables,
+        ffmpegExecutable,
+        ffprobeExecutable,
+        frameRange,
+        imageFormat,
+        inputProps,
+        overwrite,
+        pixelFormat,
+        proResProfile,
+        quality,
+        dumpBrowserLogs: renderer_1.RenderInternals.isEqualOrBelowLogLevel(config_1.ConfigInternals.Logging.getLogLevel(), 'verbose'),
+        chromiumOptions,
+        timeoutInMilliseconds: config_1.ConfigInternals.getCurrentPuppeteerTimeout(),
+        scale,
+        port,
+        numberOfGifLoops,
+        everyNthFrame,
+        verbose: renderer_1.RenderInternals.isEqualOrBelowLogLevel(config_1.ConfigInternals.Logging.getLogLevel(), 'verbose'),
+        muted,
+        enforceAudioTrack,
+        browserExecutable,
+        ffmpegOverride,
+        concurrency,
+        serveUrl,
+        codec,
+        audioBitrate,
+        videoBitrate,
+    };
+};
+exports.getRenderMediaOptions = getRenderMediaOptions;

package/dist/handle-common-errors.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleCommonError = void 0;
+const chalk_1 = require("./chalk");
 const log_1 = require("./log");
 const print_error_1 = require("./print-error");
 const handleCommonError = async (err) => {
@@ -21,5 +22,14 @@ const handleCommonError = async (err) => {
         log_1.Log.info();
         log_1.Log.info('💡 Get help for this issue at https://remotion.dev/docs/enametoolong');
     }
+    if (err.message.includes('Error creating WebGL context')) {
+        log_1.Log.info();
+        log_1.Log.info('💡 You might need to set the OpenGL renderer to "angle"');
+        log_1.Log.info('💡 Get help for this issue at https://www.remotion.dev/docs/three');
+    }
+    if (err.message.includes('The bucket does not allow ACLs')) {
+        log_1.Log.info();
+        log_1.Log.info(chalk_1.chalk.green('💡 Fix this issue https://remotion.dev/docs/lambda/troubleshooting/bucket-disallows-acl'));
+    }
 };
 exports.handleCommonError = handleCommonError;

package/dist/image-formats.d.ts

@@ -1,2 +1,3 @@
-import { ImageFormat, Internals } from 'remotion';
-export declare const getImageFormat: (codec: ReturnType<typeof Internals.getOutputCodecOrUndefined>) => ImageFormat;
+import type { ImageFormat } from '@remotion/renderer';
+import { ConfigInternals } from './config';
+export declare const getImageFormat: (codec: ReturnType<typeof ConfigInternals.getOutputCodecOrUndefined>) => ImageFormat;

package/dist/image-formats.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getImageFormat = void 0;
-const remotion_1 = require("remotion");
+const renderer_1 = require("@remotion/renderer");
+const config_1 = require("./config");
 const getImageFormat = (codec) => {
-    const userPreferred = remotion_1.Internals.getUserPreferredImageFormat();
+    const userPreferred = config_1.ConfigInternals.getUserPreferredImageFormat();
     if (typeof userPreferred !== 'undefined') {
         return userPreferred;
     }
-    if (remotion_1.Internals.isAudioCodec(codec)) {
+    if (renderer_1.RenderInternals.isAudioCodec(codec)) {
         return 'none';
     }
     if (codec === 'h264' ||
@@ -15,7 +16,8 @@ const getImageFormat = (codec) => {
         codec === 'h265' ||
         codec === 'vp8' ||
         codec === 'vp9' ||
-        codec === 'prores') {
+        codec === 'prores' ||
+        codec === 'gif') {
         return 'jpeg';
     }
     if (codec === undefined) {

package/dist/index.d.ts

@@ -1,21 +1,63 @@
-/// <reference types="minimist" />
-import chalk from 'chalk';
+import minimist from 'minimist';
 export declare const cli: () => Promise<void>;
+export { ConfigInternals, overrideRemotion } from './config/index';
 export * from './render';
 export declare const CliInternals: {
     createOverwriteableCliOutput: (quiet: boolean) => {
         update: (up: string) => boolean;
     };
-    chalk: chalk.Chalk & chalk.ChalkFunction & {
-        supportsColor: false | chalk.ColorSupport;
-        Level: chalk.Level;
-        Color: ("black" | "blue" | "cyan" | "gray" | "green" | "grey" | "magenta" | "red" | "white" | "yellow" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright") | ("bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright");
-        ForegroundColor: "black" | "blue" | "cyan" | "gray" | "green" | "grey" | "magenta" | "red" | "white" | "yellow" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
-        BackgroundColor: "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
-        Modifiers: "bold" | "reset" | "hidden" | "visible" | "italic" | "underline" | "dim" | "inverse" | "strikethrough";
-        stderr: chalk.Chalk & {
-            supportsColor: false | chalk.ColorSupport;
-        };
+    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;
+        cyan: (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;
+        bgCyan: (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;
+        cyanBright: (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;
+        bgCyanBright: (str: string) => string;
+        bgWhiteBright: (str: string) => string;
     };
     makeProgressBar: (percentage: number) => string;
     Log: {
@@ -24,40 +66,84 @@ export declare const CliInternals: {
         warn: (message?: any, ...optionalParams: any[]) => void;
         error: (message?: any, ...optionalParams: any[]) => void;
     };
-    loadConfigFile: (configFileName: string, isJavascript: boolean) => Promise<string | null>;
     getCliOptions: (options: {
         isLambda: boolean;
         type: "still" | "series" | "get-compositions";
+        remotionRoot: string;
     }) => Promise<{
         puppeteerTimeout: number;
-        parallelism: number | null;
-        frameRange: import("remotion").FrameRange | null;
+        concurrency: string | number | null;
+        frameRange: import("@remotion/renderer").FrameRange | null;
         shouldOutputImageSequence: boolean;
-        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv";
-        overwrite: boolean;
         inputProps: object;
         envVariables: Record<string, string>;
         quality: number | undefined;
-        absoluteOutputFile: string | null;
-        browser: import("remotion").Browser;
-        crf: number | null;
+        browser: import("@remotion/renderer").Browser;
+        crf: import("@remotion/renderer").Crf | null;
         pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
-        imageFormat: "png" | "jpeg" | "none";
         proResProfile: "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy" | undefined;
+        everyNthFrame: number;
+        numberOfGifLoops: import("./config/number-of-gif-loops").Loop;
         stillFrame: number;
-        browserExecutable: import("remotion").BrowserExecutable;
-        ffmpegExecutable: import("remotion").FfmpegExecutable;
-        ffprobeExecutable: import("remotion").FfmpegExecutable;
-        logLevel: "verbose" | "info" | "warn" | "error";
+        browserExecutable: import("@remotion/renderer").BrowserExecutable;
+        ffmpegExecutable: import("@remotion/renderer").FfmpegExecutable;
+        ffprobeExecutable: import("@remotion/renderer").FfmpegExecutable;
+        logLevel: "error" | "verbose" | "info" | "warn";
         scale: number;
         chromiumOptions: import("@remotion/renderer").ChromiumOptions;
+        overwrite: boolean;
         port: number | null;
+        muted: boolean;
+        enforceAudioTrack: boolean;
+        publicDir: string | null;
+        ffmpegOverride: import("@remotion/renderer").FfmpegOverrideFn;
+        audioBitrate: string | null;
+        videoBitrate: string | null;
+        height: number | null;
+        width: number | null;
     }>;
-    parseCommandLine: (type: "sequence" | "still" | "lambda" | "preview" | "versions") => void;
-    loadConfig: () => Promise<string | null>;
-    initializeRenderCli: (type: "sequence" | "still" | "lambda" | "preview") => Promise<void>;
+    loadConfig: (remotionRoot: string) => Promise<string | null>;
+    initializeCli: (remotionRoot: string) => Promise<void>;
     BooleanFlags: string[];
     quietFlagProvided: () => boolean;
-    parsedCli: import("./parse-command-line").CommandLineOptions & import("minimist").ParsedArgs;
+    parsedCli: import("./parse-command-line").CommandLineOptions & {
+        _: string[];
+    };
     handleCommonError: (err: Error) => Promise<void>;
+    formatBytes: (number: number, options?: Intl.NumberFormatOptions & {
+        locale: string;
+        bits?: boolean | undefined;
+        binary?: boolean | undefined;
+        signed: boolean;
+    }) => string;
+    getFileSizeDownloadBar: (downloaded: number) => string;
+    getFinalCodec: (options: {
+        downloadName: string | null;
+        outName: string | null;
+    }) => {
+        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+        reason: string;
+    };
+    determineFinalImageFormat: ({ downloadName, outName, configImageFormat, cliFlag, isLambda, }: {
+        downloadName: string | null;
+        outName: string | null;
+        configImageFormat: "png" | "jpeg" | "none" | null;
+        cliFlag: "png" | "jpeg" | "none" | null;
+        isLambda: boolean;
+    }) => {
+        format: import("@remotion/renderer").StillImageFormat;
+        source: string;
+    };
+    minimist: typeof minimist;
+    selectComposition: (validCompositions: import("remotion").TCompMetadata[]) => Promise<{
+        compositionId: string;
+        reason: string;
+    }>;
+    findEntryPoint: (args: string[], remotionRoot: string) => {
+        file: string | null;
+        remainingArgs: string[];
+        reason: string;
+    };
+    getImageFormat: (codec: import("@remotion/renderer").CodecOrUndefined) => "png" | "jpeg" | "none";
+    printCompositions: (compositions: import("remotion").TCompMetadata[]) => void;
 };