declare type addListenerCallback<T> = (...args: any[]) => T;

export declare enum AreaCode {
    CHINA = 1,
    NORTH_AMERICA = 2,
    EUROPE = 4,
    ASIA = 8,
    JAPAN = 16,
    INDIA = 32,
    GLOBAL = 4294967295
}

declare const ArRTC: IArRTC;
export { ArRTC }
export default ArRTC;

declare class ArRTCError {
    name: string;
    code: string;
    message: string;
    data: any;
    constructor(code: string, message?: string, data?: any);
    toString(): string;
}

export declare interface ArRTCStats {
    Duration: number;
    OutgoingAvailableBandwidth: number;
    RTT: number;
    RecvBitrate: number;
    RecvBytes: number;
    SendBitrate: number;
    SendBytes: number;
    UserCount: number;
}

export declare interface AudioEncoderConfiguration {
    bitrate?: number;
    sampleRate?: number;
    sampleSize?: number;
    stereo?: boolean;
}

export declare type AudioEncoderConfigurationPreset = keyof typeof audioEncoderConfigurationPreset;

declare const audioEncoderConfigurationPreset: {
    speech_low_quality: {
        sampleRate: number;
        stereo: boolean;
        bitrate: number | undefined;
    };
    speech_standard: {
        sampleRate: number;
        stereo: boolean;
        bitrate: number | undefined;
    };
    music_standard: {
        sampleRate: number;
        stereo: boolean;
        bitrate: number | undefined;
    };
    standard_stereo: {
        sampleRate: number;
        stereo: boolean;
        bitrate: number | undefined;
    };
    high_quality: {
        sampleRate: number;
        stereo: boolean;
        bitrate: number | undefined;
    };
    high_quality_stereo: {
        sampleRate: number;
        stereo: boolean;
        bitrate: number | undefined;
    };
};

declare interface AudioSourceOptions {
    cycle?: number;
    loop?: boolean;
    startPlayTime?: number;
}

export declare type AudioSourceState = "stopped" | "playing" | "paused";

export declare interface BufferSourceAudioTrackInitConfig {
    cacheOnlineFile?: boolean;
    encoderConfig?: AudioEncoderConfiguration | AudioEncoderConfigurationPreset;
    source: File | string | AudioBuffer;
}

export declare interface CameraVideoTrackInitConfig {
    cameraId?: string;
    encoderConfig?: VideoEncoderConfiguration | VideoEncoderConfigurationPreset;
    facingMode?: "user" | "environment";
    optimizationMode?: "balanced" | "motion" | "detail";
}

export declare enum ChannelMediaRelayError {
    DEST_TOKEN_EXPIRED = "DEST_TOKEN_EXPIRED",
    RELAY_OK = "RELAY_OK",
    SERVER_CONNECTION_LOST = "SERVER_CONNECTION_LOST",
    SRC_TOKEN_EXPIRED = "SRC_TOKEN_EXPIRED"
}

export declare enum ChannelMediaRelayEvent {
    NETWORK_CONNECTED = "NETWORK_CONNECTED",
    NETWORK_DISCONNECTED = "NETWORK_DISCONNECTED",
    PACKET_JOINED_DEST_CHANNEL = "PACKET_JOINED_DEST_CHANNEL",
    PACKET_JOINED_SRC_CHANNEL = "PACKET_JOINED_SRC_CHANNEL",
    PACKET_RECEIVED_AUDIO_FROM_SRC = "PACKET_RECEIVED_AUDIO_FROM_SRC",
    PACKET_RECEIVED_VIDEO_FROM_SRC = "PACKET_RECEIVED_VIDEO_FROM_SRC",
    PACKET_SENT_TO_DEST_CHANNEL = "PACKET_SENT_TO_DEST_CHANNEL",
    PACKET_UPDATE_DEST_CHANNEL = "PACKET_UPDATE_DEST_CHANNEL",
    PACKET_UPDATE_DEST_CHANNEL_NOT_CHANGE = "PACKET_UPDATE_DEST_CHANNEL_NOT_CHANGE",
    PACKET_UPDATE_DEST_CHANNEL_REFUSED = "PACKET_UPDATE_DEST_CHANNEL_REFUSED"
}

export declare interface ChannelMediaRelayInfo {
    channelName: string;
    token?: string;
    uid: number;
}

export declare enum ChannelMediaRelayState {
    RELAY_STATE_CONNECTING = "RELAY_STATE_CONNECTING",
    RELAY_STATE_FAILURE = "RELAY_STATE_FAILURE",
    RELAY_STATE_IDLE = "RELAY_STATE_IDLE",
    RELAY_STATE_RUNNING = "RELAY_STATE_RUNNING"
}

export declare interface ClientConfig {
    codec: SDK_CODEC;
    mode: SDK_MODE;
    role?: ClientRole;
}

export declare type ClientRole = "audience" | "host";

export declare interface ConfigParameters {
    ConfPriCloudAddr?: {
        ServerAdd: string;
        Port?: number;
        Wss?: boolean;
    };
    ConfPriCloudAddr1?: {
        ServerAdd: string;
        Port?: number;
        Wss?: boolean;
    };
    SetTurnSvr?: {
        Uri: string;
        Account: string;
        Pwd: string;
    };
    ConfPriEventAddr?: {
        ServerAdd: string;
        Port?: number;
        Wss?: boolean;
    };
    ConfPriMediaAddr?: {
        ServerAdd: string;
        Port?: number;
        Wss?: boolean;
    };
    UserQuality?: {
        Enable: boolean;
    };
    AudioVolumeInterval?: number;
    AreaCode?: AreaCode;
    Region?: Region;
    ConfIOT?: {
        Enabled: boolean;
        FrameRate: number;
    };
}

export declare enum ConnectionDisconnectedReason {
    CHANNEL_BANNED = "CHANNEL_BANNED",
    IP_BANNED = "IP_BANNED",
    LEAVE = "LEAVE",
    NETWORK_OFFLINE = "NETWORK_OFFLINE",
    NETWORK_ERROR = "NETWORK_ERROR",
    SERVER_ERROR = "SERVER_ERROR",
    UID_BANNED = "UID_BANNED",
    DEVELOPER_INVALID = "DEVELOPER_INVALID",
    TOKEN_INVALID = "TOKEN_INVALID",
    CONNECT_TIME_OUT = "CONNECT_TIME_OUT",
    KEEP_A_LIVE_TIME_OUT = "KEEP_A_LIVE_TIME_OUT"
}

export declare type ConnectionState = "DISCONNECTED" | "CONNECTING" | "RECONNECTING" | "CONNECTED" | "DISCONNECTING";

export declare interface CustomAudioTrackInitConfig {
    encoderConfig?: AudioEncoderConfiguration | AudioEncoderConfigurationPreset;
    mediaStreamTrack: MediaStreamTrack;
}

export declare interface CustomVideoTrackInitConfig {
    bitrateMax?: number;
    bitrateMin?: number;
    mediaStreamTrack: MediaStreamTrack;
    optimizationMode?: "balanced" | "motion" | "detail";
}

export declare interface DeviceInfo {
    device: MediaDeviceInfo;
    initAt: number;
    state: DeviceState;
    updateAt: number;
}

export declare type DeviceState = "ACTIVE" | "INACTIVE";

export declare interface ElectronDesktopCapturerSource {
    id: string;
    name: string;
    thumbnail: IElectronNativeImage;
}

declare type EncryptionMode = "aes-128-xts" | "aes-256-xts" | "aes-128-ecb" | "none";

declare type eventChannelMediaRelayEvent = (event: ChannelMediaRelayEvent) => void;

declare type eventChannelMediaRelayState = (state: ChannelMediaRelayState, code: ChannelMediaRelayError) => void;

declare type eventConnectionStateChange = (curState: ConnectionState, revState: ConnectionState, reason?: ConnectionDisconnectedReason) => void;

declare class EventEmitter {
    private _events;
    private addListener;
    constructor();
    getListeners(event: string): unknown[];
    on(event: string, callback: addListenerCallback<void>): void;
    once(event: string, callback: addListenerCallback<void>): void;
    off(event: string, callback: addListenerCallback<void>): void;
    removeAllListeners(event?: string): void;
    emit(event: string, ...args: any[]): void;
    private _indexOfListener;
}

declare type eventFirstFrameDecoded = () => void;

declare type eventLiveStreamingError = (url: string, err: ArRTCError) => void;

declare type eventLiveStreamingWarning = (url: string, warning: ArRTCError) => void;

declare type eventNetworkQuality = (stats: NetworkQuality) => void;

declare type eventSourceStateChange = (currentState: AudioSourceState) => void;

declare type eventStreamFallback = (uid: UID, isFallbackOrRecover: "fallback" | "recover") => void;

declare type eventStreamTypeChanged = (streamType: RemoteStreamType) => void;

declare type eventTokenPrivilegeDidExpire = () => void;

declare type eventTokenPrivilegeWillExpire = () => void;

declare type eventTrackEnded = () => void;

declare type eventUserJoined = (user: IArRTCRemoteUser) => void;

declare type eventUserLeft = (user: IArRTCRemoteUser, reason: string) => void;

declare type eventUserPublished = (user: IArRTCRemoteUser, mediaType: "audio" | "video") => void;

declare type eventUserUnpublished = (user: IArRTCRemoteUser, mediaType: "audio" | "video") => void;

declare type eventVolumeIndicator = (result: VolumeIndicator[]) => void;

export declare interface IArRTC {
    onCameraChanged?: (deviceInfo: DeviceInfo) => void;
    onMicrophoneChanged?: (deviceInfo: DeviceInfo) => void;
    onPlaybackDeviceChanged?: (deviceInfo: DeviceInfo) => void;
    onAudioAutoplayFailed?: () => void;
    VERSION: string;
    BUILD: string;
    createClient(config: ClientConfig): IArRTCClient;
    createBufferSourceAudioTrack(config: BufferSourceAudioTrackInitConfig): Promise<IBufferSourceAudioTrack>;
    createCameraVideoTrack(config?: CameraVideoTrackInitConfig): Promise<ICameraVideoTrack>;
    createMicrophoneAudioTrack(config?: MicrophoneAudioTrackInitConfig): Promise<IMicrophoneAudioTrack>;
    createMicrophoneAndCameraTracks(audioConfig?: MicrophoneAudioTrackInitConfig, videoConfig?: CameraVideoTrackInitConfig): Promise<[IMicrophoneAudioTrack, ICameraVideoTrack]>;
    createCustomAudioTrack(config: CustomAudioTrackInitConfig): ILocalAudioTrack;
    createCustomVideoTrack(config: CustomVideoTrackInitConfig): ILocalVideoTrack;
    createScreenVideoTrack(config: ScreenVideoTrackInitConfig, withAudio: "enable"): Promise<[ILocalVideoTrack, ILocalAudioTrack]>;
    createScreenVideoTrack(config: ScreenVideoTrackInitConfig, withAudio: "disable"): Promise<ILocalVideoTrack>;
    createScreenVideoTrack(config: ScreenVideoTrackInitConfig, withAudio?: "enable" | "disable" | "auto"): Promise<[ILocalVideoTrack, ILocalAudioTrack] | ILocalVideoTrack>;
    disableLogUpload(): void;
    enableLogUpload(): void;
    setLogLevel(level: number): void;
    getDevices(skipPermissionCheck?: boolean): Promise<MediaDeviceInfo[]>;
    getCameras(skipPermissionCheck?: boolean): Promise<MediaDeviceInfo[]>;
    getMicrophones(skipPermissionCheck?: boolean): Promise<MediaDeviceInfo[]>;
    getPlaybackDevices(skipPermissionCheck?: boolean): Promise<MediaDeviceInfo[]>;
    getElectronScreenSources(type?: ScreenSourceType): Promise<ElectronDesktopCapturerSource[]>;
    checkSystemRequirements(): boolean;
    createChannelMediaRelayConfiguration(): IChannelMediaRelayConfiguration;
    getSupportedCodec(): Promise<{
        video: string[];
        audio: string[];
    }>;
}

export declare interface IArRTCClient extends EventEmitter {
    channelName?: string;
    connectionState: ConnectionState;
    localTracks: ILocalTrack[];
    remoteUsers: IArRTCRemoteUser[];
    uid?: UID;
    on(event: "connection-state-change", listener: eventConnectionStateChange): void;
    on(event: "user-joined", listener: eventUserJoined): void;
    on(event: "user-left", listener: eventUserLeft): void;
    on(event: "user-published", listener: eventUserPublished): void;
    on(event: "user-unpublished", listener: eventUserUnpublished): void;
    on(event: "stream-type-changed", listener: eventStreamTypeChanged): void;
    on(event: "stream-fallback", listener: eventStreamFallback): void;
    on(event: "channel-media-relay-state", listener: eventChannelMediaRelayState): void;
    on(event: "channel-media-relay-event", listener: eventChannelMediaRelayEvent): void;
    on(event: "volume-indicator", listener: eventVolumeIndicator): void;
    on(event: "token-privilege-will-expire", listener: eventTokenPrivilegeWillExpire): void;
    on(event: "token-privilege-did-expire", listener: eventTokenPrivilegeDidExpire): void;
    on(event: "network-quality", listener: eventNetworkQuality): void;
    on(event: "live-streaming-error", listener: eventLiveStreamingError): void;
    on(event: "live-streaming-warning", listener: eventLiveStreamingWarning): void;
    on(event: string, listener: addListenerCallback<void>): void;
    join(appid: string, channel: string, token: string | null, uid?: UID | null): Promise<UID>;
    leave(): Promise<void>;
    publish(tracks: ILocalTrack | ILocalTrack[]): Promise<void>;
    unpublish(tracks?: ILocalTrack | ILocalTrack[]): Promise<void>;
    subscribe(user: IArRTCRemoteUser, mediaType: "video"): Promise<IRemoteVideoTrack>;
    subscribe(user: IArRTCRemoteUser, mediaType: "audio"): Promise<IRemoteAudioTrack>;
    subscribe(user: IArRTCRemoteUser, mediaType: "video" | "audio"): Promise<IRemoteTrack>;
    unsubscribe(user: IArRTCRemoteUser, mediaType?: "video" | "audio"): Promise<void>;
    setLowStreamParameter(streamParameter: LowStreamParameter): void;
    enableDualStream(): Promise<void>;
    disableDualStream(): Promise<void>;
    setClientRole(role: ClientRole): Promise<void>;
    setRemoteVideoStreamType(uid: UID, streamType: RemoteStreamType): Promise<void>;
    setStreamFallbackOption(uid: UID, fallbackType: RemoteStreamFallbackType): Promise<void>;
    setEncryptionConfig(encryptionMode: EncryptionMode, secret: string): void;
    renewToken(token: string): Promise<void>;
    enableAudioVolumeIndicator(): void;
    getRTCStats(): ArRTCStats;
    setLiveTranscoding(config: LiveStreamingTranscodingConfig): Promise<void>;
    startLiveStreaming(url: string, transcodingEnabled?: boolean): Promise<void>;
    stopLiveStreaming(url: string): Promise<void>;
    addInjectStreamUrl(url: string, config: InjectStreamConfig): Promise<void>;
    removeInjectStreamUrl(): Promise<void>;
    startChannelMediaRelay(config: IChannelMediaRelayConfiguration): Promise<void>;
    updateChannelMediaRelay(config: IChannelMediaRelayConfiguration): Promise<void>;
    stopChannelMediaRelay(): Promise<void>;
    getLocalAudioStats(): LocalAudioTrackStats;
    getRemoteAudioStats(): {
        [uid: string]: RemoteAudioTrackStats;
    };
    getRemoteNetworkQuality(): {
        [uid: string]: NetworkQuality;
    };
    getLocalVideoStats(): LocalVideoTrackStats;
    getRemoteVideoStats(): {
        [uid: string]: RemoteVideoTrackStats;
    };
    setParameters(options: ConfigParameters): void;
}

export declare interface IArRTCRemoteUser {
    uid: UID;
    audioTrack?: IRemoteAudioTrack;
    videoTrack?: IRemoteVideoTrack;
    hasAudio: boolean;
    hasVideo: boolean;
}

export declare interface IBufferSourceAudioTrack extends ILocalAudioTrack {
    source: string | File | AudioBuffer;
    currentState: AudioSourceState;
    duration: number;
    on(event: "source-state-change", listener: eventSourceStateChange): void;
    on(event: string, listener: addListenerCallback<void>): void;
    getCurrentTime(): number;
    startProcessAudioBuffer(options?: AudioSourceOptions): void;
    pauseProcessAudioBuffer(): void;
    seekAudioBuffer(time: number): void;
    resumeProcessAudioBuffer(): void;
    stopProcessAudioBuffer(): void;
}

export declare interface IBufferSourceAudioTrack extends ILocalAudioTrack {
    currentState: AudioSourceState;
    duration: number;
    source: string | File | AudioBuffer;
    getCurrentTime(): number;
    pauseProcessAudioBuffer(): void;
    resumeProcessAudioBuffer(): void;
    seekAudioBuffer(time: number): void;
    startProcessAudioBuffer(options?: AudioSourceOptions): void;
    stopProcessAudioBuffer(): void;
}

export declare interface ICameraVideoTrack extends ILocalVideoTrack {
    setDevice(deviceId: string): Promise<void>;
    setEnabled(enabled: boolean): Promise<void>;
    setEncoderConfiguration(config: VideoEncoderConfiguration | VideoEncoderConfigurationPreset): Promise<void>;
}

declare interface IChannelMediaRelayConfiguration {
    setSrcChannelInfo(info: ChannelMediaRelayInfo): void;
    addDestChannelInfo(info: ChannelMediaRelayInfo): void;
    removeDestChannelInfo(channelName: string): void;
    getSrcChannelMediaInfo(): void | ChannelMediaRelayInfo;
    getDestChannelMediaInfo(): Map<string, ChannelMediaRelayInfo>;
}

declare interface IElectronNativeImage {
    toDataURL(): string;
}

export declare interface ILocalAudioTrack extends ILocalTrack {
    getVolumeLevel(): number;
    setVolume(volume: number): void;
    play(): void;
    setPlaybackDevice(deviceId: string): Promise<void>;
}

export declare interface ILocalTrack extends ITrack {
    on(event: "track-ended", listener: eventTrackEnded): void;
    close(): void;
    setEnabled(enabled: boolean): void;
    setMuted(muted: boolean): void;
    getTrackLabel(): string;
    close(): void;
    enabled: boolean;
    muted: boolean;
}

export declare interface ILocalVideoTrack extends ILocalTrack {
    on(event: "track-ended", listener: eventTrackEnded): void;
    play(element: string | HTMLElement, config?: VideoPlayerConfig): void;
    getCurrentFrameData(): ImageData;
    setOptimizationMode(mode: "balanced" | "motion" | "detail"): Promise<void>;
}

export declare interface IMicrophoneAudioTrack extends ILocalAudioTrack {
    setDevice(deviceId: string): Promise<void>;
}

declare interface InjectStreamConfig {
    audioBitrate?: number;
    audioChannels?: number;
    audioSampleRate?: number;
    audioVolume?: number;
    height?: number;
    videoBitrate?: number;
    videoFramerate?: number;
    videoGop?: number;
    width?: number;
}

export declare interface IRemoteAudioTrack extends IRemoteTrack {
    getVolumeLevel(): number;
    setVolume(volume: number): void;
    setPlaybackDevice(deviceId: string): Promise<void>;
    play(): void;
}

export declare interface IRemoteTrack extends ITrack {
    on(event: "first-frame-decoded", listener: eventFirstFrameDecoded): void;
}

export declare interface IRemoteVideoTrack extends IRemoteTrack {
    play(element: string | HTMLElement, config?: VideoPlayerConfig): void;
    getCurrentFrameData(): ImageData;
}

declare interface ITrack {
    isPlaying: boolean;
    trackMediaType: "audio" | "video";
    getMediaStreamTrack(): MediaStreamTrack;
    getTrackId(): string;
    play(element?: string | HTMLElement): void;
    stop(): void;
}

export declare interface LiveStreamingTranscodingConfig {
    audioBitrate?: number;
    audioChannels?: 1 | 2 | 3 | 4 | 5;
    audioSampleRate?: 32000 | 44100 | 48000;
    backgroundColor?: number;
    backgroundImage?: LiveStreamingTranscodingImage;
    height?: number;
    transcodingUsers?: LiveStreamingTranscodingUser[];
    userConfigExtraInfo?: string;
    videoBitrate?: number;
    videoCodecProfile?: 66 | 77 | 100;
    videoFrameRate?: number;
    videoGop?: number;
    watermark?: LiveStreamingTranscodingImage;
    width?: number;
}

export declare interface LiveStreamingTranscodingImage {
    alpha?: number;
    height?: number;
    url: string;
    width?: number;
    x?: number;
    y?: number;
}

export declare interface LiveStreamingTranscodingUser {
    alpha?: number;
    audioChannel?: number;
    height?: number;
    uid: UID;
    width?: number;
    x?: number;
    y?: number;
    zOrder?: number;
}

export declare interface LocalAudioTrackStats {
    codecType?: "opus" | "aac";
    sendBitrate: number;
    sendBytes: number;
    sendPackets: number;
    sendPacketsLost: number;
    sendVolumeLevel: number;
}

export declare interface LocalVideoTrackStats {
    captureFrameRate?: number;
    captureResolutionHeight: number;
    captureResolutionWidth: number;
    codecType?: "H264";
    encodeDelay?: number;
    sendBitrate: number;
    sendBytes: number;
    sendFrameRate?: number;
    sendPackets: number;
    sendPacketsLost: number;
    sendResolutionHeight: number;
    sendResolutionWidth: number;
    targetSendBitrate: number;
    totalDuration: number;
    totalFreezeTime: number;
    packetLossRate: number;
}

export declare interface LowStreamParameter {
    bitrate?: number;
    framerate?: ConstrainULong;
    height: ConstrainULong;
    width: ConstrainULong;
}

export declare interface MicrophoneAudioTrackInitConfig {
    AEC?: boolean;
    AGC?: boolean;
    ANS?: boolean;
    encoderConfig?: AudioEncoderConfiguration | AudioEncoderConfigurationPreset;
    microphoneId?: string;
}

export declare interface NetworkQuality {
    downlinkNetworkQuality: 0 | 1 | 2 | 3 | 4 | 5 | 6;
    uplinkNetworkQuality: 0 | 1 | 2 | 3 | 4 | 5 | 6;
}

export declare enum Region {
    HB = "HB",
    HD = "HD",
    HN = "HN",
    XN = "XN",
    TW = "TW",
    HK = "HK"
}

export declare interface RemoteAudioTrackStats {
    codecType?: "opus" | "aac";
    end2EndDelay: number;
    freezeRate: number;
    packetLossRate: number;
    receiveBitrate: number;
    receiveBytes: number;
    receiveDelay: number;
    receiveLevel: number;
    receivePackets: number;
    receivePacketsLost: number;
    totalDuration: number;
    totalFreezeTime: number;
    transportDelay: number;
    rtt: number;
}

export declare enum RemoteStreamFallbackType {
    AUDIO_ONLY = 2,
    DISABLE = 0,
    LOW_STREAM = 1
}

export declare enum RemoteStreamType {
    HIGH_STREAM = 0,
    LOW_STREAM = 1
}

export declare interface RemoteVideoTrackStats {
    codecType?: "H264";
    decodeFrameRate?: number;
    end2EndDelay: number;
    freezeRate: number;
    packetLossRate: number;
    receiveBitrate: number;
    receiveBytes: number;
    receiveDelay: number;
    receiveFrameRate?: number;
    receivePackets: number;
    receivePacketsLost: number;
    receiveResolutionHeight: number;
    receiveResolutionWidth: number;
    renderFrameRate?: number;
    totalDuration: number;
    totalFreezeTime: number;
    transportDelay: number;
    rtt: number;
}

export declare type ScreenEncoderConfigurationPreset = keyof typeof screenEncoderConfigurationPreset;

declare const screenEncoderConfigurationPreset: {
    "480p": VideoEncoderConfiguration;
    "480p_1": VideoEncoderConfiguration;
    "480p_2": VideoEncoderConfiguration;
    "480p_3": VideoEncoderConfiguration;
    "720p": VideoEncoderConfiguration;
    "720p_1": VideoEncoderConfiguration;
    "720p_2": VideoEncoderConfiguration;
    "720p_3": VideoEncoderConfiguration;
    "1080p": VideoEncoderConfiguration;
    "1080p_1": VideoEncoderConfiguration;
    "1080p_2": VideoEncoderConfiguration;
    "1080p_3": VideoEncoderConfiguration;
};

export declare type ScreenSourceType = "screen" | "window" | "application";

export declare interface ScreenVideoTrackInitConfig {
    electronScreenSourceId?: string;
    encoderConfig?: VideoEncoderConfiguration | ScreenEncoderConfigurationPreset;
    extensionId?: string;
    screenSourceType?: ScreenSourceType;
    optimizationMode?: "balanced" | "motion" | "detail";
}

export declare type SDK_CODEC = "h264";

export declare type SDK_MODE = "live" | "rtc";

export declare type UID = string;

export declare interface VideoEncoderConfiguration {
    bitrateMax?: number;
    bitrateMin?: number;
    frameRate?: ConstrainULong;
    height?: ConstrainULong;
    width?: ConstrainULong;
}

export declare type VideoEncoderConfigurationPreset = keyof typeof videoEncoderConfigurationPreset;

declare const videoEncoderConfigurationPreset: {
    "90p": VideoEncoderConfiguration;
    "90p_1": VideoEncoderConfiguration;
    "120p": VideoEncoderConfiguration;
    "120p_1": VideoEncoderConfiguration;
    "120p_3": VideoEncoderConfiguration;
    "120p_4": VideoEncoderConfiguration;
    "180p": VideoEncoderConfiguration;
    "180p_1": VideoEncoderConfiguration;
    "180p_3": VideoEncoderConfiguration;
    "180p_4": VideoEncoderConfiguration;
    "240p": VideoEncoderConfiguration;
    "240p_1": VideoEncoderConfiguration;
    "240p_3": VideoEncoderConfiguration;
    "240p_4": VideoEncoderConfiguration;
    "360p": VideoEncoderConfiguration;
    "360p_1": VideoEncoderConfiguration;
    "360p_3": VideoEncoderConfiguration;
    "360p_4": VideoEncoderConfiguration;
    "360p_6": VideoEncoderConfiguration;
    "360p_7": VideoEncoderConfiguration;
    "360p_8": VideoEncoderConfiguration;
    "360p_9": VideoEncoderConfiguration;
    "360p_10": VideoEncoderConfiguration;
    "360p_11": VideoEncoderConfiguration;
    "480p": VideoEncoderConfiguration;
    "480p_1": VideoEncoderConfiguration;
    "480p_2": VideoEncoderConfiguration;
    "480p_3": VideoEncoderConfiguration;
    "480p_4": VideoEncoderConfiguration;
    "480p_6": VideoEncoderConfiguration;
    "480p_8": VideoEncoderConfiguration;
    "480p_9": VideoEncoderConfiguration;
    "480p_10": VideoEncoderConfiguration;
    "720p": VideoEncoderConfiguration;
    "720p_1": VideoEncoderConfiguration;
    "720p_2": VideoEncoderConfiguration;
    "720p_3": VideoEncoderConfiguration;
    "720p_5": VideoEncoderConfiguration;
    "720p_6": VideoEncoderConfiguration;
    "1080p": VideoEncoderConfiguration;
    "1080p_1": VideoEncoderConfiguration;
    "1080p_2": VideoEncoderConfiguration;
    "1080p_3": VideoEncoderConfiguration;
    "1080p_5": VideoEncoderConfiguration;
    "1440p": VideoEncoderConfiguration;
    "1440p_1": VideoEncoderConfiguration;
    "1440p_2": VideoEncoderConfiguration;
    "4k": VideoEncoderConfiguration;
    "4k_1": VideoEncoderConfiguration;
    "4k_3": VideoEncoderConfiguration;
};

export declare interface VideoPlayerConfig {
    fit?: "cover" | "contain" | "fill";
    mirror?: boolean;
}

declare interface VolumeIndicator {
    level: number;
    uid: UID;
}

export { }