import { Api, RegisterRtpOutput, RegisterMp4Output, RegisterHlsOutput, RegisterWhipClientOutput, RegisterWhepServerOutput, RegisterRtmpClientOutput, _smelterInternals, RegisterRtpInput, RegisterMp4Input, RegisterHlsInput, RegisterWhipServerInput, RegisterWhepClientInput, RegisterRtmpServerInput, Renderers } from '@swmansion/smelter';
export { Api } from '@swmansion/smelter';
import { ReactElement } from 'react';

/**
 * It represents HTTP request that can be sent to
 * to compositor, but also additional variants that are specific to WASM like canvas
 */
type RegisterOutputRequest = Api.RegisterOutput | RegisterWasmSpecificOutputRequest;
type RegisterWasmSpecificOutputRequest = RegisterWasmSpecificOutput & {
    initial: {
        video?: Api.VideoScene;
        audio?: Api.AudioScene;
    };
};
type RegisterWasmWhipOutput = {
    type: 'web-wasm-whip';
    iceServers?: Array<{
        credential?: string;
        urls: string | string[];
        username?: string;
    }>;
    endpointUrl: string;
    bearerToken?: string;
    video?: {
        resolution: Api.Resolution;
        maxBitrate?: number;
    };
    audio?: boolean;
};
type RegisterWasmCanvasOutput = {
    type: 'web-wasm-canvas';
    video?: {
        resolution: Api.Resolution;
        canvas: any;
    };
    audio?: boolean;
};
type RegisterWasmStreamOutput = {
    type: 'web-wasm-stream';
    video?: {
        resolution: Api.Resolution;
    };
    audio?: boolean;
};
type RegisterWasmSpecificOutput = RegisterWasmWhipOutput | RegisterWasmStreamOutput | RegisterWasmCanvasOutput;
type RegisterOutput = ({
    type: 'rtp_stream';
} & RegisterRtpOutput) | ({
    type: 'mp4';
} & RegisterMp4Output) | ({
    type: 'hls';
} & RegisterHlsOutput) | ({
    type: 'whip_client';
} & RegisterWhipClientOutput) | ({
    type: 'whep_server';
} & RegisterWhepServerOutput) | ({
    type: 'rtmp_client';
} & RegisterRtmpClientOutput) | RegisterWasmSpecificOutput;
declare function intoRegisterOutput(output: RegisterOutput, initial: {
    video?: Api.VideoScene;
    audio?: Api.AudioScene;
}): RegisterOutputRequest;
declare function intoAudioInputsConfiguration(inputs: _smelterInternals.AudioConfig): Api.AudioScene;

type output_RegisterOutput = RegisterOutput;
type output_RegisterOutputRequest = RegisterOutputRequest;
type output_RegisterWasmCanvasOutput = RegisterWasmCanvasOutput;
type output_RegisterWasmSpecificOutput = RegisterWasmSpecificOutput;
type output_RegisterWasmSpecificOutputRequest = RegisterWasmSpecificOutputRequest;
type output_RegisterWasmStreamOutput = RegisterWasmStreamOutput;
type output_RegisterWasmWhipOutput = RegisterWasmWhipOutput;
declare const output_intoAudioInputsConfiguration: typeof intoAudioInputsConfiguration;
declare const output_intoRegisterOutput: typeof intoRegisterOutput;
declare namespace output {
  export { type output_RegisterOutput as RegisterOutput, type output_RegisterOutputRequest as RegisterOutputRequest, type output_RegisterWasmCanvasOutput as RegisterWasmCanvasOutput, type output_RegisterWasmSpecificOutput as RegisterWasmSpecificOutput, type output_RegisterWasmSpecificOutputRequest as RegisterWasmSpecificOutputRequest, type output_RegisterWasmStreamOutput as RegisterWasmStreamOutput, type output_RegisterWasmWhipOutput as RegisterWasmWhipOutput, output_intoAudioInputsConfiguration as intoAudioInputsConfiguration, output_intoRegisterOutput as intoRegisterOutput };
}

type Logger = _smelterInternals.Logger;
declare enum LoggerLevel {
    ERROR = "error",
    WARN = "warn",
    INFO = "info",
    DEBUG = "debug",
    TRACE = "trace"
}

interface SetupInstanceOptions {
    /**
     * sets SMELTER_AHEAD_OF_TIME_PROCESSING_ENABLE environment variable.
     */
    aheadOfTimeProcessing: boolean;
    logger: Logger;
}
interface SmelterManager {
    setupInstance(opts: SetupInstanceOptions): Promise<void>;
    sendRequest(request: ApiRequest): Promise<object>;
    sendMultipartRequest(request: MultipartRequest): Promise<object>;
    registerEventListener(cb: (event: unknown) => void): void;
    terminate(): Promise<void>;
}

type ImageRef = _smelterInternals.ImageRef;
declare const imageRefIntoRawId: typeof _smelterInternals.imageRefIntoRawId;
declare const parseImageRef: typeof _smelterInternals.parseImageRef;

type image_ImageRef = ImageRef;
declare const image_imageRefIntoRawId: typeof imageRefIntoRawId;
declare const image_parseImageRef: typeof parseImageRef;
declare namespace image {
  export { type image_ImageRef as ImageRef, image_imageRefIntoRawId as imageRefIntoRawId, image_parseImageRef as parseImageRef };
}

type ApiRequest = {
    method: 'GET' | 'POST';
    route: string;
    body?: object;
    headers?: Record<string, string>;
};
type MultipartRequest = {
    method: 'POST';
    route: string;
    body: FormData;
    headers?: Record<string, string>;
};
type RegisterInputResponse = {
    video_duration_ms?: number;
    audio_duration_ms?: number;
    endpoint_route?: string;
    bearer_token?: string;
};
type RegisterOutputResponse = {
    endpoint_route?: string;
};
declare class ApiClient {
    private serverManager;
    constructor(serverManager: SmelterManager);
    updateScene(outputId: string, request: Api.UpdateOutputRequest): Promise<object>;
    registerOutput(outputId: string, request: RegisterOutputRequest): Promise<RegisterOutputResponse>;
    unregisterOutput(outputId: string, body: {
        schedule_time_ms?: number;
    }): Promise<object>;
    registerInput(inputId: InputRef, request: RegisterInputRequest): Promise<RegisterInputResponse>;
    updateInput(inputId: InputRef, request: Api.UpdateInputRequest): Promise<object>;
    unregisterInput(inputId: InputRef, body: {
        schedule_time_ms?: number;
    }): Promise<object>;
    registerShader(shaderId: string, request: Api.ShaderSpec): Promise<object>;
    unregisterShader(shaderId: string): Promise<object>;
    registerImage(imageRef: ImageRef, request: Api.ImageSpec): Promise<object>;
    unregisterImage(imageRef: ImageRef, body: {
        schedule_time_ms?: number;
    }): Promise<object>;
    registerWebRenderer(instanceId: string, request: Api.WebRendererSpec): Promise<object>;
    unregisterWebRenderer(instanceId: string): Promise<object>;
    start(): Promise<void>;
    stats(): Promise<Api.StatsReport>;
}

/**
 * It represents HTTP request that can be sent to
 * to compositor, but also additional variants that are specific to WASM like camera
 */
type RegisterInputRequest = RegisterRtpStreamInputRequest | RegisterMp4InputRequest | RegisterHlsInputRequest | RegisterWhipServerInputRequest | RegisterWhepClientInputRequest | RegisterRtmpServerInputRequest | RegisterV4l2InputRequest | RegisterDecklinkInputRequest | {
    type: 'camera';
} | {
    type: 'screen_capture';
} | {
    type: 'stream';
    stream: any;
} | {
    type: 'web-wasm-whep';
    endpointUrl: string;
    bearerToken?: string;
};
type RegisterRtpStreamInputRequest = Extract<Api.RegisterInput, {
    type: 'rtp_stream';
}>;
type RegisterMp4InputRequest = {
    blob?: any;
} & Extract<Api.RegisterInput, {
    type: 'mp4';
}>;
type RegisterHlsInputRequest = Extract<Api.RegisterInput, {
    type: 'hls';
}>;
type RegisterWhipServerInputRequest = Extract<Api.RegisterInput, {
    type: 'whip_server';
}>;
type RegisterWhepClientInputRequest = Extract<Api.RegisterInput, {
    type: 'whep_client';
}>;
type RegisterRtmpServerInputRequest = Extract<Api.RegisterInput, {
    type: 'rtmp_server';
}>;
type RegisterV4l2InputRequest = Extract<Api.RegisterInput, {
    type: 'v4l2';
}>;
type RegisterDecklinkInputRequest = Extract<Api.RegisterInput, {
    type: 'decklink';
}>;
type InputRef = _smelterInternals.InputRef;
declare const inputRefIntoRawId: typeof _smelterInternals.inputRefIntoRawId;
declare const parseInputRef: typeof _smelterInternals.parseInputRef;
type RegisterInput = ({
    type: 'rtp_stream';
} & RegisterRtpInput) | ({
    type: 'mp4';
} & RegisterMp4Input) | ({
    type: 'hls';
} & RegisterHlsInput) | ({
    type: 'whip_server';
} & RegisterWhipServerInput) | ({
    type: 'whep_client';
} & RegisterWhepClientInput) | ({
    type: 'rtmp_server';
} & RegisterRtmpServerInput) | ({
    type: 'v4l2';
} & RegisterV4l2InputRequest) | {
    type: 'camera';
} | {
    type: 'screen_capture';
} | {
    type: 'stream';
    stream: any;
} | {
    type: 'web-wasm-whep';
    endpointUrl: string;
    bearerToken?: string;
};
/**
 * Converts object passed by user (or modified by platform specific interface) into
 * HTTP request
 */
declare function intoRegisterInput(input: RegisterInput): RegisterInputRequest;

type input_InputRef = InputRef;
type input_RegisterDecklinkInputRequest = RegisterDecklinkInputRequest;
type input_RegisterHlsInputRequest = RegisterHlsInputRequest;
type input_RegisterInput = RegisterInput;
type input_RegisterInputRequest = RegisterInputRequest;
type input_RegisterMp4InputRequest = RegisterMp4InputRequest;
type input_RegisterRtmpServerInputRequest = RegisterRtmpServerInputRequest;
type input_RegisterRtpStreamInputRequest = RegisterRtpStreamInputRequest;
type input_RegisterV4l2InputRequest = RegisterV4l2InputRequest;
type input_RegisterWhepClientInputRequest = RegisterWhepClientInputRequest;
type input_RegisterWhipServerInputRequest = RegisterWhipServerInputRequest;
declare const input_inputRefIntoRawId: typeof inputRefIntoRawId;
declare const input_intoRegisterInput: typeof intoRegisterInput;
declare const input_parseInputRef: typeof parseInputRef;
declare namespace input {
  export { type input_InputRef as InputRef, type input_RegisterDecklinkInputRequest as RegisterDecklinkInputRequest, type input_RegisterHlsInputRequest as RegisterHlsInputRequest, type input_RegisterInput as RegisterInput, type input_RegisterInputRequest as RegisterInputRequest, type input_RegisterMp4InputRequest as RegisterMp4InputRequest, type input_RegisterRtmpServerInputRequest as RegisterRtmpServerInputRequest, type input_RegisterRtpStreamInputRequest as RegisterRtpStreamInputRequest, type input_RegisterV4l2InputRequest as RegisterV4l2InputRequest, type input_RegisterWhepClientInputRequest as RegisterWhepClientInputRequest, type input_RegisterWhipServerInputRequest as RegisterWhipServerInputRequest, input_inputRefIntoRawId as inputRefIntoRawId, input_intoRegisterInput as intoRegisterInput, input_parseInputRef as parseInputRef };
}

declare class InputHandle {
    protected inputRef: InputRef;
    protected api: ApiClient;
    protected registerResponse: RegisterInputResponse;
    constructor(inputRef: InputRef, api: ApiClient, response: RegisterInputResponse);
    get videoDurationMs(): number | undefined;
    get audioDurationMs(): number | undefined;
    pause(): Promise<void>;
    resume(): Promise<void>;
}
declare class Mp4InputHandle extends InputHandle {
    seek(seekMs: number): Promise<void>;
}
declare class WhipInputHandle extends InputHandle {
    get endpointRoute(): string | undefined;
    get bearerToken(): string | undefined;
}

declare class Smelter {
    readonly manager: SmelterManager;
    private api;
    private store;
    private outputs;
    private inputs;
    private startTime?;
    private logger;
    constructor(manager: SmelterManager, logger: Logger);
    init(): Promise<void>;
    registerOutput(outputId: string, root: ReactElement, request: RegisterOutput): Promise<RegisterOutputResponse>;
    unregisterOutput(outputId: string): Promise<object>;
    getInputById(inputId: string): InputHandle | undefined;
    registerInput(inputId: string, request: RegisterInput): Promise<InputHandle>;
    unregisterInput(inputId: string): Promise<object>;
    registerShader(shaderId: string, request: Renderers.RegisterShader): Promise<object>;
    unregisterShader(shaderId: string): Promise<object>;
    registerImage(imageId: string, request: Renderers.RegisterImage): Promise<object>;
    unregisterImage(imageId: string): Promise<object>;
    registerWebRenderer(instanceId: string, request: Renderers.RegisterWebRenderer): Promise<object>;
    unregisterWebRenderer(instanceId: string): Promise<object>;
    start(): Promise<void>;
    terminate(): Promise<void>;
    private handleEvent;
    stats(): Promise<Api.StatsReport>;
}

declare class OfflineSmelter {
    readonly manager: SmelterManager;
    private api;
    private store;
    private renderStarted;
    /**
     * Start and end timestamp of an inputs (if known).
     */
    private inputTimestamps;
    private logger;
    constructor(manager: SmelterManager, logger: Logger);
    init(): Promise<void>;
    render(root: ReactElement, request: RegisterOutput, durationMs?: number): Promise<void>;
    registerInput(inputId: string, request: RegisterInput): Promise<RegisterInputResponse>;
    registerShader(shaderId: string, request: Renderers.RegisterShader): Promise<object>;
    registerImage(imageId: string, request: Renderers.RegisterImage): Promise<object>;
    private checkNotStarted;
    stats(): Promise<Api.StatsReport>;
}

declare class StateGuard {
    private state;
    constructor();
    runBlocking<T>(fn: () => Promise<T>): Promise<T>;
    run<T>(fn: () => Promise<T>): Promise<T>;
    private createGuardPromise;
}

export { ApiClient, type ApiRequest, image as Image, input as Input, InputHandle, type Logger, LoggerLevel, Mp4InputHandle, type MultipartRequest, OfflineSmelter, output as Output, type RegisterInputResponse, type RegisterOutputResponse, type SetupInstanceOptions, Smelter, type SmelterManager, StateGuard, WhipInputHandle };