export declare const COMMAND_NOT_FOUND = "Command not found";
import type { AudioCodec, ChromiumOptions, ColorSpace, LogLevel, PixelFormat, StillImageFormat, SingleFrameRange, ToOptions, VideoImageFormat, X264Preset } from '@remotion/renderer';
import type { BrowserSafeApis } from '@remotion/renderer/client';
import type { _InternalTypes, DownloadBehavior } from 'remotion';
import type { ImageSequenceOutput, RendererOutput, ServerlessRenderOutput } from './image-sequence';
import type { ExpensiveChunk } from './most-expensive-chunks';
import type { ChunkRetry, CloudProvider, ReceivedArtifact } from './types';
import type { EnhancedErrorInfo } from './write-error-to-storage';
export declare const expiryDays: {
    readonly '1-day': 1;
    readonly '3-days': 3;
    readonly '7-days': 7;
    readonly '30-days': 30;
};
export type DeleteAfter = keyof typeof expiryDays;
export declare enum ServerlessRoutines {
    info = "info",
    start = "start",
    launch = "launch",
    status = "status",
    renderer = "renderer",
    still = "still",
    compositions = "compositions"
}
export type CustomCredentialsWithoutSensitiveData = {
    endpoint: string;
    forcePathStyle?: boolean;
};
export type CustomCredentials<Provider extends CloudProvider> = CustomCredentialsWithoutSensitiveData & {
    accessKeyId: string | null;
    secretAccessKey: string | null;
    region?: Provider['region'] | (string & {});
};
export type OutNameInput<Provider extends CloudProvider> = string | {
    bucketName: string;
    key: string;
    s3OutputProvider?: CustomCredentials<Provider>;
};
export type RenderOutput = 'main' | 'separate-audio';
export type SeparateAudioOutput = {
    url: string;
    bucketName: string;
    key: string;
    sizeInBytes: number;
};
export type SerializedInputProps = {
    type: 'bucket-url';
    hash: string;
    bucketName: string;
} | {
    type: 'payload';
    payload: string;
};
export declare const serverlessCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "gif", "prores"];
export type ServerlessCodec = (typeof serverlessCodecs)[number];
export type Privacy = 'public' | 'private' | 'no-acl';
type Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
export type WebhookOption = Prettify<null | ({
    url: string;
    secret: string | null;
} & Partial<ToOptions<{
    customData: typeof BrowserSafeApis.options.webhookCustomDataOption;
}>>)>;
export type ServerlessStatusPayload<Provider extends CloudProvider> = {
    type: ServerlessRoutines.status;
    bucketName: string;
    renderId: string;
    version: string;
    logLevel: LogLevel;
    forcePathStyle: boolean;
    s3OutputProvider: CustomCredentials<Provider> | null;
};
export type ServerlessStartPayload<Provider extends CloudProvider> = {
    enableCancellation: boolean | null;
    rendererFunctionName: string | null;
    type: ServerlessRoutines.start;
    output: ServerlessRenderOutput<Provider>;
    serveUrl: string;
    composition: string;
    framesPerLambda: number | null;
    concurrency: number | null;
    inputProps: SerializedInputProps;
    codec: ServerlessCodec | null;
    audioCodec: AudioCodec | null;
    imageFormat: VideoImageFormat;
    crf: number | undefined | null;
    envVariables: Record<string, string> | undefined;
    pixelFormat: PixelFormat | undefined | null;
    proResProfile: _InternalTypes['ProResProfile'] | undefined | null;
    x264Preset: X264Preset | null;
    gopSize: number | null;
    disableSharedMemoryCapture: boolean;
    jpegQuality: number | undefined;
    maxRetries: number;
    privacy: Privacy;
    logLevel: LogLevel;
    frameRange: SingleFrameRange | null;
    outName: OutNameInput<Provider> | null;
    separateAudioTo: OutNameInput<Provider> | null;
    timeoutInMilliseconds: number;
    chromiumOptions: ChromiumOptions;
    scale: number;
    everyNthFrame: number;
    numberOfGifLoops: number | null;
    concurrencyPerLambda: number;
    downloadBehavior: DownloadBehavior;
    muted: boolean;
    version: string;
    overwrite: boolean;
    audioBitrate: string | null;
    videoBitrate: string | null;
    encodingMaxRate: string | null;
    encodingBufferSize: string | null;
    webhook: WebhookOption;
    forceHeight: number | null;
    forceWidth: number | null;
    forceFps: number | null;
    forceDurationInFrames: number | null;
    bucketName: string | null;
    offthreadVideoCacheSizeInBytes: number | null;
    offthreadVideoThreads: number | null;
    mediaCacheSizeInBytes: number | null;
    deleteAfter: DeleteAfter | null;
    colorSpace: ColorSpace | null;
    preferLossless: boolean;
    forcePathStyle: boolean;
    metadata: Record<string, string> | null;
    licenseKey: string | null;
    storageClass: Provider['storageClass'] | null;
    isProduction: boolean | null;
    sampleRate: number;
};
export type ServerlessPayloads<Provider extends CloudProvider> = {
    info: {
        type: ServerlessRoutines.info;
        logLevel: LogLevel;
    };
    start: ServerlessStartPayload<Provider>;
    launch: {
        enableCancellation: boolean | null;
        rendererFunctionName: string | null;
        type: ServerlessRoutines.launch;
        output: ServerlessRenderOutput<Provider>;
        serveUrl: string;
        composition: string;
        framesPerFunction: number | null;
        concurrency: number | null;
        bucketName: string;
        inputProps: SerializedInputProps;
        renderId: string;
        imageFormat: VideoImageFormat;
        codec: ServerlessCodec | null;
        audioCodec: AudioCodec | null;
        crf: number | null;
        envVariables: Record<string, string> | undefined;
        pixelFormat: PixelFormat | null;
        proResProfile: _InternalTypes['ProResProfile'] | null;
        x264Preset: X264Preset | null;
        gopSize: number | null;
        disableSharedMemoryCapture: boolean;
        jpegQuality: number | undefined;
        maxRetries: number;
        privacy: Privacy;
        logLevel: LogLevel;
        frameRange: SingleFrameRange | null;
        outName: OutNameInput<Provider> | null;
        separateAudioTo: OutNameInput<Provider> | null;
        timeoutInMilliseconds: number;
        chromiumOptions: ChromiumOptions | undefined;
        scale: number;
        everyNthFrame: number;
        numberOfGifLoops: number | null;
        concurrencyPerFunction: number;
        downloadBehavior: DownloadBehavior;
        muted: boolean;
        overwrite: boolean;
        audioBitrate: string | null;
        videoBitrate: string | null;
        encodingMaxRate: string | null;
        encodingBufferSize: string | null;
        webhook: WebhookOption;
        forceHeight: number | null;
        forceWidth: number | null;
        forceFps: number | null;
        forceDurationInFrames: number | null;
        offthreadVideoCacheSizeInBytes: number | null;
        offthreadVideoThreads: number | null;
        mediaCacheSizeInBytes: number | null;
        deleteAfter: DeleteAfter | null;
        colorSpace: ColorSpace | null;
        preferLossless: boolean;
        forcePathStyle: boolean;
        metadata: Record<string, string> | null;
        licenseKey: string | null;
        storageClass: Provider['storageClass'] | null;
        isProduction: boolean;
        sampleRate: number;
    };
    status: ServerlessStatusPayload<Provider>;
    renderer: {
        enableCancellation: boolean | null;
        concurrencyPerLambda: number;
        type: ServerlessRoutines.renderer;
        output: RendererOutput<Provider>;
        serveUrl: string;
        frameRange: [number, number];
        chunk: number;
        bucketName: string;
        composition: string;
        fps: number;
        height: number;
        width: number;
        durationInFrames: number;
        retriesLeft: number;
        inputProps: SerializedInputProps;
        renderId: string;
        imageFormat: VideoImageFormat;
        codec: ServerlessCodec | null;
        crf: number | null;
        proResProfile: _InternalTypes['ProResProfile'] | null;
        x264Preset: X264Preset | null;
        gopSize: number | null;
        disableSharedMemoryCapture: boolean;
        pixelFormat: PixelFormat | null;
        jpegQuality: number | undefined;
        envVariables: Record<string, string> | undefined;
        privacy: Privacy;
        attempt: number;
        logLevel: LogLevel;
        timeoutInMilliseconds: number;
        chromiumOptions: ChromiumOptions;
        resolvedProps: SerializedInputProps;
        scale: number;
        everyNthFrame: number;
        muted: boolean;
        audioCodec: AudioCodec | null;
        audioBitrate: string | null;
        videoBitrate: string | null;
        encodingBufferSize: string | null;
        encodingMaxRate: string | null;
        launchFunctionConfig: {
            version: string;
        };
        preferLossless: boolean;
        offthreadVideoCacheSizeInBytes: number | null;
        offthreadVideoThreads: number | null;
        mediaCacheSizeInBytes: number | null;
        deleteAfter: DeleteAfter | null;
        colorSpace: ColorSpace | null;
        compositionStart: number;
        framesPerLambda: number;
        progressEveryNthFrame: number;
        forcePathStyle: boolean;
        metadata: Record<string, string> | null;
        sampleRate: number;
    };
    still: {
        type: ServerlessRoutines.still;
        serveUrl: string;
        composition: string;
        inputProps: SerializedInputProps;
        imageFormat: StillImageFormat;
        envVariables: Record<string, string>;
        attempt: number;
        jpegQuality: number | undefined;
        maxRetries: number;
        frame: number;
        privacy: Privacy;
        logLevel: LogLevel;
        outName: OutNameInput<Provider> | null;
        timeoutInMilliseconds: number;
        chromiumOptions: ChromiumOptions;
        scale: number;
        downloadBehavior: DownloadBehavior;
        version: string;
        forceHeight: number | null;
        forceWidth: number | null;
        forceFps: number | null;
        forceDurationInFrames: number | null;
        bucketName: string | null;
        offthreadVideoCacheSizeInBytes: number | null;
        offthreadVideoThreads: number | null;
        mediaCacheSizeInBytes: number | null;
        deleteAfter: DeleteAfter | null;
        streamed: boolean;
        forcePathStyle: boolean;
        licenseKey: string | null;
        storageClass: Provider['storageClass'] | null;
        isProduction: boolean | null;
    };
    compositions: {
        type: ServerlessRoutines.compositions;
        version: string;
        chromiumOptions: ChromiumOptions;
        logLevel: LogLevel;
        inputProps: SerializedInputProps;
        envVariables: Record<string, string> | undefined;
        timeoutInMilliseconds: number;
        serveUrl: string;
        bucketName: string | null;
        offthreadVideoCacheSizeInBytes: number | null;
        mediaCacheSizeInBytes: number | null;
        forcePathStyle: boolean;
    };
};
export type ServerlessPayload<Provider extends CloudProvider> = ServerlessPayloads<Provider>[ServerlessRoutines];
export type OutNameOutput<Provider extends CloudProvider> = {
    renderBucketName: string;
    key: string;
    customCredentials: CustomCredentials<Provider> | null;
};
export type OutNameInputWithoutCredentials = string | {
    bucketName: string;
    key: string;
    s3OutputProvider?: CustomCredentialsWithoutSensitiveData;
};
export declare const rendersPrefix: (renderId: string) => string;
export declare const outStillName: (renderId: string, imageFormat: "jpeg" | "pdf" | "png" | "webp") => string;
export declare const outName: (renderId: string, extension: string) => string;
export declare const customOutName: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>(renderId: string, bucketName: string, name: OutNameInput<Provider>) => OutNameOutput<Provider>;
export declare const overallProgressKey: (renderId: string) => string;
export declare const cancellationKey: (renderId: string) => string;
export declare const artifactName: (renderId: string, name: string) => string;
export type PostRenderData<Provider extends CloudProvider> = {
    cost: AfterRenderCost;
    outputFile: string | null;
    separateAudio: SeparateAudioOutput | null;
    outputSequence: ImageSequenceOutput | null;
    outputSize: number;
    renderSize: number;
    timeToFinish: number;
    timeToRenderFrames: number;
    errors: EnhancedErrorInfo[];
    startTime: number;
    endTime: number;
    filesCleanedUp: number;
    timeToEncode: number | null;
    timeToCleanUp: number;
    timeToRenderChunks: number;
    retriesInfo: ChunkRetry[];
    mostExpensiveFrameRanges: ExpensiveChunk[] | undefined;
    estimatedBillingDurationInMilliseconds: number;
    deleteAfter: DeleteAfter | null;
    timeToCombine: number | null;
    artifactProgress: ReceivedArtifact<Provider>[];
};
export type AfterRenderCost = {
    estimatedCost: number;
    estimatedDisplayCost: string;
    currency: string;
    disclaimer: string;
};
export declare const CONCAT_FOLDER_TOKEN = "remotion-concat";
export declare const MAX_FUNCTIONS_PER_RENDER = 200;
export declare const MINIMUM_FRAMES_PER_FUNCTION = 5;
export declare const REMOTION_CONCATENATED_TOKEN = "remotion-concatenated-token";
export declare const RENDERER_PATH_TOKEN = "remotion-bucket";
export {};