import type { GetPayloadSink, PayloadSink } from '@remotion/streaming';
import type { SerializedArtifact } from '../serialize-artifact';
import type { CloudProvider, RenderStillFunctionResponsePayload } from '../types';
import type { FunctionErrorInfo } from '../write-error-to-storage';
declare const framesUploaded: "frames-uploaded";
declare const framesRendered: "frames-rendered";
declare const errorOccurred: "error-occurred";
declare const renderIdDetermined: "render-id-determined";
declare const videoChunkRendered: "video-chunk-rendered";
declare const audioChunkRendered: "audio-chunk-rendered";
declare const chunkComplete: "chunk-complete";
declare const stillRendered: "still-rendered";
declare const functionInvoked: "lambda-invoked";
declare const artifactEmitted: "artifact-emitted";
declare const messageTypes: {
    readonly '1': {
        readonly type: "frames-rendered";
    };
    readonly '2': {
        readonly type: "error-occurred";
    };
    readonly '3': {
        readonly type: "render-id-determined";
    };
    readonly '4': {
        readonly type: "video-chunk-rendered";
    };
    readonly '5': {
        readonly type: "audio-chunk-rendered";
    };
    readonly '6': {
        readonly type: "still-rendered";
    };
    readonly '7': {
        readonly type: "chunk-complete";
    };
    readonly '8': {
        readonly type: "lambda-invoked";
    };
    readonly '9': {
        readonly type: "artifact-emitted";
    };
    readonly a: {
        readonly type: "frames-uploaded";
    };
};
export type MessageTypeId = keyof typeof messageTypes;
type MessageType = (typeof messageTypes)[MessageTypeId]['type'];
export declare const formatMap: {
    [key in MessageType]: 'json' | 'binary';
};
export type StreamingPayload<Provider extends CloudProvider> = {
    type: typeof framesUploaded;
    payload: {
        uploaded: number;
        sizeInBytes: number;
    };
} | {
    type: typeof framesRendered;
    payload: {
        rendered: number;
        encoded: number;
    };
} | {
    type: typeof videoChunkRendered;
    payload: Uint8Array;
} | {
    type: typeof audioChunkRendered;
    payload: Uint8Array;
} | {
    type: typeof errorOccurred;
    payload: {
        error: string;
        shouldRetry: boolean;
        errorInfo: FunctionErrorInfo;
    };
} | {
    type: typeof renderIdDetermined;
    payload: {
        renderId: string;
    };
} | {
    type: typeof stillRendered;
    payload: RenderStillFunctionResponsePayload<Provider>;
} | {
    type: typeof chunkComplete;
    payload: {
        start: number;
        rendered: number;
    };
} | {
    type: typeof functionInvoked;
    payload: {
        attempt: number;
    };
} | {
    type: typeof artifactEmitted;
    payload: {
        artifact: SerializedArtifact;
    };
};
export declare const messageTypeIdToMessageType: (messageTypeId: "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "a") => "artifact-emitted" | "audio-chunk-rendered" | "chunk-complete" | "error-occurred" | "frames-rendered" | "frames-uploaded" | "lambda-invoked" | "render-id-determined" | "still-rendered" | "video-chunk-rendered";
export type StreamingMessage<Provider extends CloudProvider> = {
    successType: 'error' | 'success';
    message: StreamingPayload<Provider>;
};
export type OnMessage<Provider extends CloudProvider> = (options: StreamingMessage<Provider>) => void;
export type BinaryMessageType = typeof videoChunkRendered | typeof audioChunkRendered;
export type GetBinaryPayloadSink = (params: {
    messageType: BinaryMessageType;
    length: number;
}) => PayloadSink | null;
export declare const binaryPayloadSinkForStreamer: (getBinaryPayloadSink: GetBinaryPayloadSink) => GetPayloadSink;
export type OnStream<Provider extends CloudProvider> = (payload: StreamingPayload<Provider>) => Promise<void>;
export declare const makeStreamPayload: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ message, }: {
    message: StreamingPayload<Provider>;
}) => Uint8Array<ArrayBufferLike>;
export {};