@remotion/cloudrun 4.1.0-alpha10

package/dist/cli/helpers/progress-bar.d.ts

@@ -0,0 +1,23 @@
+export declare type BundleProgress = {
+    progress: number;
+    doneIn: number | null;
+};
+export declare const makeBundleProgress: ({ progress, doneIn }: BundleProgress) => string;
+export declare type BucketCreationProgress = {
+    creationState: 'Checking for existing bucket' | 'Creating new bucket' | 'Created bucket' | 'Using existing bucket';
+    doneIn: number | null;
+};
+export declare const makeBucketProgress: ({ creationState, doneIn, }: BucketCreationProgress) => string;
+declare type UploadStats = {
+    addedFiles: number;
+    removedFiles: number;
+    untouchedFiles: number;
+};
+export declare type DeployToStorageProgress = {
+    sizeUploaded: number;
+    totalSize: number | null;
+    doneIn: number | null;
+    stats: UploadStats | null;
+};
+export declare const makeDeployProgressBar: ({ sizeUploaded, totalSize, doneIn, stats, }: DeployToStorageProgress) => string;
+export {};

package/dist/cli/helpers/progress-bar.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeployProgressBar = exports.makeBucketProgress = exports.makeBundleProgress = void 0;
+const cli_1 = require("@remotion/cli");
+const remotion_1 = require("remotion");
+const makeBundleProgress = ({ progress, doneIn }) => {
+    return [
+        `(1/3)`,
+        cli_1.CliInternals.makeProgressBar(progress / 100),
+        `${doneIn === null ? 'Bundling' : 'Bundled'} video`,
+        doneIn === null
+            ? `${Math.round(progress)}%`
+            : cli_1.CliInternals.chalk.gray(`${doneIn}ms`),
+    ].join(' ');
+};
+exports.makeBundleProgress = makeBundleProgress;
+const makeBucketProgress = ({ creationState, doneIn, }) => {
+    let progress = 0;
+    let statesFinished = 0;
+    switch (creationState) {
+        case 'Checking for existing bucket':
+            progress = 1;
+            break;
+        case 'Creating new bucket':
+            progress = 2 / 3;
+            statesFinished = 2;
+            break;
+        case 'Created bucket':
+            progress = 3 / 3;
+            statesFinished = 3;
+            break;
+        case 'Using existing bucket':
+            progress = 3 / 3;
+            statesFinished = 3;
+            break;
+        default:
+            progress = 0;
+            break;
+    }
+    return [
+        `(2/3)`,
+        cli_1.CliInternals.makeProgressBar(progress),
+        creationState,
+        doneIn === null
+            ? `${statesFinished} / ${3}`
+            : cli_1.CliInternals.chalk.gray(`${doneIn}ms`),
+    ].join(' ');
+};
+exports.makeBucketProgress = makeBucketProgress;
+const makeUploadDiff = ({ stats }) => {
+    if (!stats) {
+        return null;
+    }
+    if (stats.addedFiles === 0 && stats.removedFiles === 0) {
+        return cli_1.CliInternals.chalk.gray(`(Unchanged)`);
+    }
+    const total = stats.addedFiles + stats.removedFiles;
+    return cli_1.CliInternals.chalk.gray(`(${[
+        stats.addedFiles ? `+${stats.addedFiles}` : null,
+        stats.removedFiles ? `-${stats.removedFiles}` : null,
+    ]
+        .filter(remotion_1.Internals.truthy)
+        .join(',')} ${total === 1 ? 'file' : 'files'})`);
+};
+const makeDeployProgressBar = ({ sizeUploaded, totalSize, doneIn, stats, }) => {
+    const progress = totalSize === null ? 0 : sizeUploaded / totalSize;
+    return [
+        `(3/3)`,
+        cli_1.CliInternals.makeProgressBar(progress),
+        `${doneIn === null ? 'Uploading' : 'Uploaded'} to GCP Storage Bucket`,
+        doneIn === null
+            ? typeof totalSize === 'number'
+                ? `${cli_1.CliInternals.formatBytes(sizeUploaded)}/${cli_1.CliInternals.formatBytes(totalSize)}`
+                : ''
+            : cli_1.CliInternals.chalk.gray(`${doneIn}ms`),
+        makeUploadDiff({ stats }),
+    ]
+        .filter(remotion_1.Internals.truthy)
+        .join(' ');
+};
+exports.makeDeployProgressBar = makeDeployProgressBar;

package/dist/cli/helpers/quit.d.ts

@@ -0,0 +1 @@
+export declare const quit: (exitCode: number) => never;

package/dist/cli/helpers/quit.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quit = void 0;
+const quit = (exitCode) => {
+    process.exit(exitCode);
+};
+exports.quit = quit;

package/dist/cli/helpers/yes-or-no.d.ts

@@ -0,0 +1,4 @@
+export declare const yesOrNo: ({ question, defaultValue, }: {
+    question: string;
+    defaultValue: boolean;
+}) => Promise<boolean>;

package/dist/cli/helpers/yes-or-no.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yesOrNo = void 0;
+const readline_1 = __importDefault(require("readline"));
+const options = {
+    yes: ['yes', 'y'],
+    no: ['no', 'n'],
+};
+function defaultInvalidHandler({ yesValues, noValues, }) {
+    process.stdout.write('\nInvalid Response.\n');
+    process.stdout.write('Answer either yes : (' + yesValues.join(', ') + ') \n');
+    process.stdout.write('Or no: (' + noValues.join(', ') + ') \n\n');
+}
+const yesOrNo = ({ question, defaultValue, }) => {
+    const invalid = defaultInvalidHandler;
+    const yesValues = options.yes.map((v) => v.toLowerCase());
+    const noValues = options.no.map((v) => v.toLowerCase());
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question + ' ', async (answer) => {
+            rl.close();
+            const cleaned = answer.trim().toLowerCase();
+            if (cleaned === '' && defaultValue !== null)
+                return resolve(defaultValue);
+            if (yesValues.indexOf(cleaned) >= 0)
+                return resolve(true);
+            if (noValues.indexOf(cleaned) >= 0)
+                return resolve(false);
+            invalid({ question, yesValues, noValues });
+            const result = await (0, exports.yesOrNo)({
+                question,
+                defaultValue,
+            });
+            resolve(result);
+        });
+    });
+};
+exports.yesOrNo = yesOrNo;

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export declare const executeCommand: (args: string[], remotionRoot: string) => Promise<void>;

package/dist/cli/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCommand = void 0;
+const args_1 = require("./args");
+const permissions_1 = require("./commands/permissions");
+const regions_1 = require("./commands/regions");
+const render_1 = require("./commands/render");
+const still_1 = require("./commands/still");
+const services_1 = require("./commands/services");
+const sites_1 = require("./commands/sites");
+const help_1 = require("./help");
+const quit_1 = require("./helpers/quit");
+const log_1 = require("./log");
+const matchCommand = (args, remotionRoot) => {
+    if (args_1.parsedCloudrunCli.help || args.length === 0 || args[0] === 'help') {
+        (0, help_1.printHelp)();
+        (0, quit_1.quit)(0);
+    }
+    if (args[0] === render_1.RENDER_COMMAND) {
+        return (0, render_1.renderCommand)(args.slice(1), remotionRoot);
+    }
+    if (args[0] === still_1.STILL_COMMAND) {
+        return (0, still_1.stillCommand)(args.slice(1), remotionRoot);
+    }
+    if (args[0] === services_1.SERVICES_COMMAND) {
+        return (0, services_1.servicesCommand)(args.slice(1));
+    }
+    if (args[0] === sites_1.SITES_COMMAND) {
+        return (0, sites_1.sitesCommand)(args.slice(1), remotionRoot);
+    }
+    if (args[0] === regions_1.REGIONS_COMMAND) {
+        return (0, regions_1.regionsCommand)();
+    }
+    if (args[0] === permissions_1.PERMISSIONS_COMMAND) {
+        return (0, permissions_1.permissionsCommand)();
+    }
+    if (args[0] === 'deploy') {
+        log_1.Log.info(`The "deploy" command does not exist.`);
+        log_1.Log.info(`Did you mean "service deploy"?`);
+    }
+    log_1.Log.error(`Command ${args[0]} not found.`);
+    (0, help_1.printHelp)();
+    (0, quit_1.quit)(1);
+};
+const executeCommand = async (args, remotionRoot) => {
+    try {
+        await matchCommand(args, remotionRoot);
+    }
+    catch (err) {
+        const error = err;
+        // todo: catch errors and print a message. Check lambda cli for example
+        log_1.Log.error(error.stack);
+        (0, quit_1.quit)(1);
+    }
+};
+exports.executeCommand = executeCommand;

package/dist/cli/log.d.ts

@@ -0,0 +1,26 @@
+export declare const Log: {
+    verbose: (message?: any, ...optionalParams: any[]) => void;
+    verboseAdvanced: (options: {
+        indent: boolean;
+        logLevel: "error" | "verbose" | "info" | "warn";
+    } & {
+        tag?: 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;
+    errorAdvanced: (options: {
+        indent: boolean;
+        logLevel: "error" | "verbose" | "info" | "warn";
+    } & {
+        tag?: string | undefined;
+    }, message?: any, ...optionalParams: any[]) => void;
+};

package/dist/cli/log.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+const renderer_1 = require("@remotion/renderer");
+exports.Log = renderer_1.RenderInternals.Log;

package/dist/defaults.d.ts

@@ -0,0 +1 @@
+export * from './shared/constants';

package/dist/defaults.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./shared/constants"), exports);

package/dist/functions/helpers/get-composition-from-body.d.ts

@@ -0,0 +1,2 @@
+import type { CloudRunPayloadType } from './payloads';
+export declare const getCompositionFromBody: (body: CloudRunPayloadType) => Promise<import("remotion").VideoConfig>;

package/dist/functions/helpers/get-composition-from-body.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompositionFromBody = void 0;
+const renderer_1 = require("@remotion/renderer");
+const getCompositionFromBody = async (body) => {
+    var _a, _b;
+    const { metadata, propsSize } = await renderer_1.RenderInternals.internalSelectComposition({
+        serveUrl: body.serveUrl,
+        browserExecutable: null,
+        chromiumOptions: (_a = body.chromiumOptions) !== null && _a !== void 0 ? _a : {},
+        envVariables: (_b = body.envVariables) !== null && _b !== void 0 ? _b : {},
+        id: body.composition,
+        indent: false,
+        serializedInputPropsWithCustomSchema: body.serializedInputPropsWithCustomSchema,
+        logLevel: body.logLevel,
+        onBrowserLog: () => null,
+        port: null,
+        puppeteerInstance: undefined,
+        server: undefined,
+        timeoutInMilliseconds: body.delayRenderTimeoutInMilliseconds,
+    });
+    if (propsSize > 10000000) {
+        renderer_1.RenderInternals.Log.warn(`The props of your composition are large (${propsSize} bytes). This may cause slowdown.`);
+    }
+    return metadata;
+};
+exports.getCompositionFromBody = getCompositionFromBody;

package/dist/functions/helpers/io.d.ts

@@ -0,0 +1,11 @@
+import type { File } from '@google-cloud/storage';
+export declare type CloudrunLSInput = {
+    bucketName: string;
+    prefix: string;
+};
+export declare type CloudrunLsReturnType = Promise<File[]>;
+export declare const cloudrunLs: ({ bucketName, prefix, }: CloudrunLSInput) => CloudrunLsReturnType;
+export declare const cloudrunDeleteFile: ({ bucketName, key, }: {
+    bucketName: string;
+    key: string;
+}) => Promise<void>;

package/dist/functions/helpers/io.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloudrunDeleteFile = exports.cloudrunLs = void 0;
+const get_cloud_storage_client_1 = require("../../api/helpers/get-cloud-storage-client");
+const cloudrunLs = async ({ bucketName, prefix, }) => {
+    const cloudStorageClient = (0, get_cloud_storage_client_1.getCloudStorageClient)();
+    const [files] = await cloudStorageClient
+        .bucket(bucketName)
+        .getFiles({ prefix, autoPaginate: true });
+    return files;
+};
+exports.cloudrunLs = cloudrunLs;
+const cloudrunDeleteFile = async ({ bucketName, key, }) => {
+    const cloudStorageClient = (0, get_cloud_storage_client_1.getCloudStorageClient)();
+    await cloudStorageClient.bucket(bucketName).file(key).delete();
+};
+exports.cloudrunDeleteFile = cloudrunDeleteFile;

package/dist/functions/helpers/payloads.d.ts

@@ -0,0 +1,300 @@
+import { z } from 'zod';
+export declare const CloudRunPayload: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"media">;
+    serveUrl: z.ZodString;
+    composition: z.ZodString;
+    forceHeight: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    forceWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    codec: z.ZodEnum<["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"]>;
+    serializedInputPropsWithCustomSchema: z.ZodString;
+    jpegQuality: z.ZodNumber;
+    audioCodec: z.ZodNullable<z.ZodEnum<["pcm-16", "aac", "mp3", "opus"]>>;
+    audioBitrate: z.ZodNullable<z.ZodString>;
+    videoBitrate: z.ZodNullable<z.ZodString>;
+    crf: z.ZodNullable<z.ZodNumber>;
+    pixelFormat: z.ZodEnum<["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"]>;
+    imageFormat: z.ZodEnum<["png", "jpeg", "none"]>;
+    scale: z.ZodNumber;
+    proResProfile: z.ZodNullable<z.ZodEnum<["4444-xq", "4444", "hq", "standard", "light", "proxy"]>>;
+    everyNthFrame: z.ZodNumber;
+    numberOfGifLoops: z.ZodNullable<z.ZodNumber>;
+    frameRange: z.ZodNullable<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodNumber]>>;
+    envVariables: z.ZodRecord<z.ZodString, z.ZodString>;
+    chromiumOptions: z.ZodOptional<z.ZodObject<{
+        ignoreCertificateErrors: z.ZodOptional<z.ZodBoolean>;
+        disableWebSecurity: z.ZodOptional<z.ZodBoolean>;
+        gl: z.ZodNullable<z.ZodOptional<z.ZodEnum<["swangle", "angle", "egl", "swiftshader"]>>>;
+        headless: z.ZodOptional<z.ZodBoolean>;
+        userAgent: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    }, {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    }>>;
+    muted: z.ZodBoolean;
+    outputBucket: z.ZodString;
+    outName: z.ZodOptional<z.ZodString>;
+    privacy: z.ZodOptional<z.ZodEnum<["public", "private"]>>;
+    logLevel: z.ZodEnum<["verbose", "info", "warn", "error"]>;
+    delayRenderTimeoutInMilliseconds: z.ZodNumber;
+    concurrency: z.ZodNullable<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+    enforceAudioTrack: z.ZodBoolean;
+    preferLossless: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    type: "media";
+    serveUrl: string;
+    composition: string;
+    codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    serializedInputPropsWithCustomSchema: string;
+    jpegQuality: number;
+    audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    crf: number | null;
+    pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
+    imageFormat: "png" | "jpeg" | "none";
+    scale: number;
+    proResProfile: "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy" | null;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    frameRange: ((number | [number, number]) & (number | [number, number] | undefined)) | null;
+    envVariables: Record<string, string>;
+    muted: boolean;
+    outputBucket: string;
+    logLevel: "error" | "verbose" | "info" | "warn";
+    delayRenderTimeoutInMilliseconds: number;
+    concurrency: string | number | null;
+    enforceAudioTrack: boolean;
+    preferLossless: boolean;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    chromiumOptions?: {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    } | undefined;
+    outName?: string | undefined;
+    privacy?: "public" | "private" | undefined;
+}, {
+    type: "media";
+    serveUrl: string;
+    composition: string;
+    codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    serializedInputPropsWithCustomSchema: string;
+    jpegQuality: number;
+    audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    crf: number | null;
+    pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
+    imageFormat: "png" | "jpeg" | "none";
+    scale: number;
+    proResProfile: "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy" | null;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    frameRange: ((number | [number, number]) & (number | [number, number] | undefined)) | null;
+    envVariables: Record<string, string>;
+    muted: boolean;
+    outputBucket: string;
+    logLevel: "error" | "verbose" | "info" | "warn";
+    delayRenderTimeoutInMilliseconds: number;
+    concurrency: string | number | null;
+    enforceAudioTrack: boolean;
+    preferLossless: boolean;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    chromiumOptions?: {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    } | undefined;
+    outName?: string | undefined;
+    privacy?: "public" | "private" | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"still">;
+    serveUrl: z.ZodString;
+    composition: z.ZodString;
+    forceHeight: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    forceWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    serializedInputPropsWithCustomSchema: z.ZodString;
+    jpegQuality: z.ZodOptional<z.ZodNumber>;
+    imageFormat: z.ZodEnum<["png", "jpeg", "pdf", "webp"]>;
+    scale: z.ZodNumber;
+    privacy: z.ZodEnum<["public", "private"]>;
+    envVariables: z.ZodRecord<z.ZodString, z.ZodString>;
+    chromiumOptions: z.ZodOptional<z.ZodObject<{
+        ignoreCertificateErrors: z.ZodOptional<z.ZodBoolean>;
+        disableWebSecurity: z.ZodOptional<z.ZodBoolean>;
+        gl: z.ZodNullable<z.ZodOptional<z.ZodEnum<["swangle", "angle", "egl", "swiftshader"]>>>;
+        headless: z.ZodOptional<z.ZodBoolean>;
+        userAgent: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    }, {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    }>>;
+    outputBucket: z.ZodString;
+    outName: z.ZodOptional<z.ZodString>;
+    frame: z.ZodNumber;
+    delayRenderTimeoutInMilliseconds: z.ZodNumber;
+    logLevel: z.ZodEnum<["verbose", "info", "warn", "error"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "still";
+    serveUrl: string;
+    composition: string;
+    serializedInputPropsWithCustomSchema: string;
+    imageFormat: "png" | "jpeg" | "pdf" | "webp";
+    scale: number;
+    envVariables: Record<string, string>;
+    outputBucket: string;
+    privacy: "public" | "private";
+    logLevel: "error" | "verbose" | "info" | "warn";
+    delayRenderTimeoutInMilliseconds: number;
+    frame: number;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    jpegQuality?: number | undefined;
+    chromiumOptions?: {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    } | undefined;
+    outName?: string | undefined;
+}, {
+    type: "still";
+    serveUrl: string;
+    composition: string;
+    serializedInputPropsWithCustomSchema: string;
+    imageFormat: "png" | "jpeg" | "pdf" | "webp";
+    scale: number;
+    envVariables: Record<string, string>;
+    outputBucket: string;
+    privacy: "public" | "private";
+    logLevel: "error" | "verbose" | "info" | "warn";
+    delayRenderTimeoutInMilliseconds: number;
+    frame: number;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    jpegQuality?: number | undefined;
+    chromiumOptions?: {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    } | undefined;
+    outName?: string | undefined;
+}>]>;
+declare const renderFailResponsePayload: z.ZodObject<{
+    status: z.ZodLiteral<"error">;
+    error: z.ZodString;
+    stack: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "error";
+    error: string;
+    stack: string;
+}, {
+    status: "error";
+    error: string;
+    stack: string;
+}>;
+declare const renderStillOnCloudrunResponsePayload: z.ZodObject<{
+    status: z.ZodLiteral<"success">;
+    publicUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    cloudStorageUri: z.ZodString;
+    size: z.ZodNumber;
+    bucketName: z.ZodString;
+    renderId: z.ZodString;
+    privacy: z.ZodEnum<["public-read", "project-private"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}, {
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}>;
+declare const renderMediaOnCloudrunResponsePayload: z.ZodObject<{
+    status: z.ZodLiteral<"success">;
+    publicUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    cloudStorageUri: z.ZodString;
+    size: z.ZodNumber;
+    bucketName: z.ZodString;
+    renderId: z.ZodString;
+    privacy: z.ZodEnum<["public-read", "project-private"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}, {
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}>;
+declare const cloudRunCrashResponse: z.ZodObject<{
+    status: z.ZodLiteral<"crash">;
+    cloudRunEndpoint: z.ZodString;
+    message: z.ZodLiteral<"Service crashed without sending a response. Check the logs in GCP console.">;
+    requestStartTime: z.ZodString;
+    requestCrashTime: z.ZodString;
+    requestElapsedTimeInSeconds: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    message: "Service crashed without sending a response. Check the logs in GCP console.";
+    status: "crash";
+    cloudRunEndpoint: string;
+    requestStartTime: string;
+    requestCrashTime: string;
+    requestElapsedTimeInSeconds: number;
+}, {
+    message: "Service crashed without sending a response. Check the logs in GCP console.";
+    status: "crash";
+    cloudRunEndpoint: string;
+    requestStartTime: string;
+    requestCrashTime: string;
+    requestElapsedTimeInSeconds: number;
+}>;
+export declare type CloudRunPayloadType = z.infer<typeof CloudRunPayload>;
+export declare type RenderStillOnCloudrunOutput = z.infer<typeof renderStillOnCloudrunResponsePayload>;
+export declare type RenderMediaOnCloudrunOutput = z.infer<typeof renderMediaOnCloudrunResponsePayload>;
+export declare type ErrorResponsePayload = z.infer<typeof renderFailResponsePayload>;
+export declare type CloudRunCrashResponse = z.infer<typeof cloudRunCrashResponse>;
+export {};