declare function createFetcher(): {
    /**
     * @param {string} baseUrl
     */
    createInstance: (baseUrl: string) => {
        getBaseUrl: () => string;
        get: (endpoint: string, options?: RequestInit | undefined) => Promise<any>;
        post: (endpoint: string, options?: RequestInit | undefined) => Promise<any>;
        put: (endpoint: string, options?: RequestInit | undefined) => Promise<any>;
        patch: (endpoint: string, options?: RequestInit | undefined) => Promise<any>;
        delete: (endpoint: string, options?: RequestInit | undefined) => Promise<any>;
    };
};

declare function createApi({ fetcher, config }: RoomAPIType.ApiDependencies): {
    createInstance: () => {
        createRoom: (name?: string | undefined, id?: string | undefined, options?: {
            bitrates?: {
                audioRed?: number | undefined;
                audio?: number | undefined;
                video?: number | undefined;
                videoHigh?: number | undefined;
                videoHighPixels?: number | undefined;
                videoMid?: number | undefined;
                videoMidPixels?: number | undefined;
                videoLow?: number | undefined;
                videoLowPixels?: number | undefined;
                initialBandwidth?: number | undefined;
            } | undefined;
            codecs?: string[] | undefined;
            emptyRoomTimeoutMS?: number | undefined;
            pliIntervalMS?: number | undefined;
            qualityPresets?: {
                high?: {
                    sid?: number | undefined;
                    tid?: number | undefined;
                } | undefined;
                low?: {
                    sid?: number | undefined;
                    tid?: number | undefined;
                } | undefined;
                mid?: {
                    sid?: number | undefined;
                    tid?: number | undefined;
                } | undefined;
            } | undefined;
        } | undefined) => Promise<RoomAPIType.RoomReturnBody>;
        getRoom: (roomId: string) => Promise<RoomAPIType.RoomReturnBody>;
        registerClient: (roomId: string, config?: {
            clientId?: string | undefined;
            clientName?: string | undefined;
            enableVAD?: boolean | undefined;
        } | undefined) => Promise<RoomAPIType.RegisterClientReturn>;
        getClient: (roomId: string, clientId: string) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: {
                clientId: string;
                clientName: string;
                connectionState: RTCPeerConnectionState;
                iceConnectionState: RTCIceConnectionState;
                events: {
                    [key: string]: {
                        name: string;
                        timestamp: number;
                        data: {
                            [key: string]: string | null;
                        };
                    };
                };
            };
        }>;
        setClientName: (roomId: string, clientId: string, clientName: string) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: {
                clientId: string;
                clientName: string;
                bitrates: {
                    audio: number;
                    audioRed: number;
                    video: number;
                    videoHigh: number;
                    videoHighPixels: number;
                    videoMid: number;
                    videoMidPixels: number;
                    videoLow: number;
                    videoLowPixels: number;
                    initialBandwidth: number;
                };
            };
        }>;
        getMetadata: (roomId: string, key: string) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: any;
        }>;
        setMetadata: (roomId: string, metadata: {
            [key: string]: any;
        }) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: null;
        }>;
        deleteMetadata: (roomId: string, key: string) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: null;
        }>;
        sendIceCandidate: (roomId: string, clientId: string, candidate: RTCIceCandidate) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: null;
        }>;
        checkNegotiateAllowed: (roomId: string, clientId: string) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: null;
        }>;
        negotiateConnection: (roomId: string, clientId: string, localDescription: RTCSessionDescription) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: {
                answer: RTCSessionDescription;
            };
        }>;
        setTrackSources: (roomId: string, clientId: string, trackSources: RoomAPIType.TrackSourcesRequestBody[]) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: null;
        }>;
        subscribeTracks: (roomId: string, clientId: string, subscribeTracks: RoomAPIType.SubscribeTracksRequestBody[]) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: null;
        }>;
        leaveRoom: (roomId: string, clientId: string, useBeacon?: boolean) => Promise<{
            code: number;
            ok: boolean;
            message: string;
            data: null;
        }>;
        endRoom: (roomId: string) => Promise<RoomAPIType.BaseResponseReturn>;
        createDataChannel: (roomId: string, name: string, ordered?: boolean) => Promise<{
            url: string;
            headers: Headers;
            code: number;
            ok: boolean;
            message: string;
            data: null;
        }>;
        setAuth: (auth: {
            url: string;
            data: {
                expirySeconds: number;
                accessToken: string;
                refreshToken: string;
            };
        }) => {
            baseUrl: string;
            apiVersion: string;
            accessToken: string;
            refreshToken: string;
            expirySeconds: number;
        };
    };
};

declare namespace SharedType {
  type ObjectLiteral = {
    [key: string]: any
  }

  type DeepPartial<Thing> = Thing extends any[]
    ? Thing
    : { [Key in keyof Thing]?: DeepPartial<Thing[Key]> }
}

declare namespace api {
    let baseUrl: string;
    let version: string;
    let apiKey: string;
}
declare namespace webrtc {
    let iceServers: {
        urls: string;
        username: string;
        credential: string;
    }[];
}
declare namespace media {
    namespace webcam {
        let maxFramerate: number;
        let videoCodecs: string[];
        let simulcast: boolean;
        let svc: boolean;
        let scalabilityMode: string;
        namespace bitrates {
            let high: number;
            let mid: number;
            let low: number;
        }
    }
    namespace screen {
        let maxFramerate_1: number;
        export { maxFramerate_1 as maxFramerate };
        let videoCodecs_1: string[];
        export { videoCodecs_1 as videoCodecs };
        let simulcast_1: boolean;
        export { simulcast_1 as simulcast };
        let svc_1: boolean;
        export { svc_1 as svc };
        let scalabilityMode_1: string;
        export { scalabilityMode_1 as scalabilityMode };
        export namespace bitrates_1 {
            let high_1: number;
            export { high_1 as high };
            let mid_1: number;
            export { mid_1 as mid };
            let low_1: number;
            export { low_1 as low };
        }
        export { bitrates_1 as bitrates };
    }
    namespace microphone {
        let audioCodecs: string[];
    }
}

declare namespace RoomType {
  type Config = {
    api: typeof api
    webrtc: typeof webrtc
    media: typeof media
  }

  type UserConfig = {
    api?: SharedType.DeepPartial<typeof api>
    webrtc?: SharedType.DeepPartial<typeof webrtc>
    media?: SharedType.DeepPartial<typeof media>
  }
}

declare namespace RoomAPIType {
  type CreateFetcher = typeof createFetcher
  type CreateApi = typeof createApi

  type InstanceFetcher = ReturnType<ReturnType<CreateFetcher>['createInstance']>
  type InstanceApi = ReturnType<ReturnType<CreateApi>['createInstance']>

  type ApiDependencies = {
    fetcher: InstanceFetcher
    config: RoomType.Config
  }

  type TrackSourcesRequestBody = {
    track_id: string
    source: string
  }

  type SubscribeTracksRequestBody = {
    client_id: string
    stream_id: string
    track_id: string
  }

  type RegisterClientRequestBody = {
    uid?: string
    name?: string
    enable_vad?: boolean
  }

  type BitratesCamelCase = {
    audioRed: number
    audio: number
    video: number
    videoHigh: number
    videoHighPixels: number
    videoMid: number
    videoMidPixels: number
    videoLow: number
    videoLowPixels: number
    initialBandwidth: number
  }

  type BitratesSnakeCase = {
    audio: number
    audio_red: number
    video: number
    video_high: number
    video_high_pixels: number
    video_mid: number
    video_mid_pixels: number
    video_low: number
    video_low_pixels: number
    initial_bandwidth: number
  }

  type QualityPreset = {
    sid: number
    tid: number
  }

  type QualityPresets = {
    high: QualityPreset
    low: QualityPreset
    mid: QualityPreset
  }

  type RoomOptions = {
    bitrates: BitratesCamelCase
    codecs: string[]
    emptyRoomTimeoutMS: number
    pliIntervalMS: number
    qualityPresets: QualityPresets
  }

  type RoomUserOptions = SharedType.DeepPartial<RoomOptions>

  type RoomResponse = {
    id: string
    name: string
    options: {
      bitrates: BitratesSnakeCase
      codecs: string[]
      empty_room_timeout_ns: number
      pli_interval_ns: number
      quality_presets: QualityPresets
    }
  }

  type BaseResponseBody = {
    url: string
    headers: Headers
    code: number
    ok: boolean
    message: string
  }

  type BaseResponseReturn = BaseResponseBody & {
    data: null
  }

  type RoomResponseBody = BaseResponseBody & {
    data: RoomResponse
  }

  type Room = {
    id: string
    name: string
    options: RoomOptions
  }

  type RoomReturnBody = BaseResponseBody & {
    data: Room
  }

  type RegisterClientResponseBody = BaseResponseBody & {
    data: {
      client_id: string
      name: string
      bitrates: BitratesSnakeCase
    }
  }

  type RegisterClientReturn = BaseResponseBody & {
    data: {
      clientId: string
      clientName: string
      bitrates: BitratesCamelCase
    }
  }

  type GetClientResponseBody = BaseResponseBody & {
    data: {
      id: string
      name: string
      peer_connection_state: RTCPeerConnectionState
      ice_peer_connection_state: RTCIceConnectionState
      events: {
        [key: string]: {
          name: string
          timestamp: number
          data: { [key: string]: string | null }
        }
      }
    }
  }

  type SetClientNameResponse = BaseResponseBody & {
    data: {
      client_id: string
      name: string
      bitrates: BitratesSnakeCase
    }
  }

  type GetMetadataResponse = BaseResponseBody & {
    data: any
  }

  type NegotiateConnectionResponseBody = BaseResponseBody & {
    data: {
      answer: RTCSessionDescription
    }
  }

  type ApiAuth = {
    baseUrl: string
    apiVersion: string
    expirySeconds: number
    accessToken: string
    refreshToken: string
  }
}

declare function createEvent(): {
    createInstance: () => {
        emit: (eventName: string, value?: any) => void;
        on: (eventName: string, callback: (data: any) => void) => void;
        addEventListener: (eventName: string, callback: (data: any) => void) => void;
        removeEventListener: (eventName: string, callback: (data: any) => void) => void;
    };
};

declare namespace RoomEventType {
  type CreateEvent = typeof createEvent
  type InstanceEvent = ReturnType<ReturnType<CreateEvent>['createInstance']>

  type EventHandlers = Set<(data: SharedType.ObjectLiteral) => void>

  type EventItems = {
    [key: string]: EventHandlers
  }
}

declare function createStream(): {
    /**
     * @param {import('./stream-types.js').RoomStreamType.StreamParameters} data
     */
    createInstance: (data: RoomStreamType.StreamParameters) => {
        id: string;
        clientId: string;
        name: string;
        origin: string;
        source: string;
        mediaStream: MediaStream;
        audioLevel: number;
        lastVoiceActivity: number;
        /**
         * @param {MediaStreamTrack} newTrack
         */
        replaceTrack: (newTrack: MediaStreamTrack) => void;
        /**
         * @param {import('../peer/peer-types.d.ts').RoomPeerType.VoiceActivity} activity
         * @returns {void}
         */
        addVoiceActivity: (activity: RoomPeerType.VoiceActivity) => void;
        /**
         * @param audioLevel {number}
         * @returns {void}
         */
        "__#6629@#triggerVoiceActivityEvent": (audioLevel: number) => void;
        addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined): void;
        dispatchEvent(event: Event): boolean;
        removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined): void;
    };
};

declare function createStreams(): {
    createInstance: () => {
        addStream: (key: string, stream: RoomStreamType.InstanceStream) => RoomStreamType.InstanceStream;
        removeStream: (key: string) => RoomStreamType.InstanceStream | null;
        getAllStreams: () => {
            id: string;
            clientId: string;
            name: string; /**
             * To trigger the type safety
             * @augments {Map<string, import('./stream-types.js').RoomStreamType.InstanceStream>}
             */
            origin: string;
            source: string;
            mediaStream: MediaStream;
            audioLevel: number;
            lastVoiceActivity: number;
            replaceTrack: (newTrack: MediaStreamTrack) => void;
            addVoiceActivity: (activity: RoomPeerType.VoiceActivity) => void;
            "__#6629@#triggerVoiceActivityEvent": (audioLevel: number) => void;
            addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined): void;
            dispatchEvent(event: Event): boolean;
            removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined): void;
        }[];
        getStream: (key: string) => RoomStreamType.InstanceStream | null;
        getStreamByTrackId: (trackId: string) => RoomStreamType.InstanceStream | null;
        getTotalStreams: () => number;
        hasStream: (key: string) => boolean;
        addDraft: (key: string, value?: RoomStreamType.DraftStream) => void;
        getDraft: (key: string) => RoomStreamType.DraftStream | null;
        removeDraft: (key: string) => boolean;
        validateKey: (key: string) => boolean;
        validateStream: (data: RoomStreamType.DraftStream) => boolean;
    };
};

declare namespace RoomStreamType {
  export type CreateStream = typeof createStream
  export type CreateStreams = typeof createStreams

  export type InstanceStream = ReturnType<
    ReturnType<CreateStream>['createInstance']
  >
  export type InstanceStreams = ReturnType<
    ReturnType<CreateStreams>['createInstance']
  >

  export type StreamParameters = {
    id: string
    clientId: string
    name: string
    origin: 'local' | 'remote' | string
    source: 'media' | 'screen' | string
    mediaStream: MediaStream
  }

  export type AddStreamParameters = Omit<StreamParameters, 'id'>

  export type DraftStream = {
    clientId?: string
    name?: string
    origin?: 'local' | 'remote' | string
    source?: 'media' | 'screen' | string
    mediaStream?: MediaStream | undefined
  }
}

declare function createPeer({ api, createStream, event, streams, config }: RoomPeerType.PeerDependencies): {
    createInstance: () => {
        connect: (roomId: string, clientId: string) => Promise<void>;
        disconnect: () => void;
        getClientId: () => string;
        getRoom: () => Promise<RoomAPIType.RoomReturnBody>;
        getRoomId: () => string;
        getPeerConnection: () => Readonly<RTCPeerConnection | null>;
        addStream: (key: string, data: RoomStreamType.AddStreamParameters) => void;
        addIceCandidate: (candidate: RTCIceCandidate) => Promise<void>;
        removeStream: (key: string) => RoomStreamType.InstanceStream | null;
        getAllStreams: () => RoomStreamType.InstanceStream[];
        getStream: (key: string) => RoomStreamType.InstanceStream | null;
        getStreamByTrackId: (trackId: string) => RoomStreamType.InstanceStream | null;
        getTotalStreams: () => number;
        hasStream: (key: string) => boolean;
        turnOnCamera: (newTrack?: MediaStreamTrack | undefined) => Promise<void>;
        turnOnMic: (newTrack?: MediaStreamTrack | undefined) => Promise<void>;
        turnOffCamera: (stop?: boolean | undefined) => void;
        turnOffMic: (stop?: boolean | undefined) => void;
        replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
        observeVideo: (videoElement: HTMLVideoElement) => void;
        updateVideoSize: (trackId: string, width: number, height: number) => void;
        unobserveVideo: (videoElement: HTMLVideoElement) => void;
        negotiate: () => Promise<void>;
        startViewOnly: () => Promise<void>;
        pendingNegotiation: boolean;
    };
};

declare namespace RoomPeerType {
  type CreatePeer = typeof createPeer
  type InstancePeer = {
    connect: (roomId: string, clientId: string) => void
    disconnect: () => void
    getClientId: () => string
    getRoomId: () => string
    getPeerConnection: () => RTCPeerConnection | null
    addStream: (key: string, value: RoomStreamType.AddStreamParameters) => void
    addIceCandidate: (candidate: RTCIceCandidate) => void
    removeStream: (key: string) => RoomStreamType.InstanceStream | null
    getAllStreams: () => RoomStreamType.InstanceStream[]
    getStream: (key: string) => RoomStreamType.InstanceStream | null
    getStreamByTrackId: (
      trackId: string
    ) => RoomStreamType.InstanceStream | null
    getTotalStreams: () => number
    hasStream: (key: string) => boolean
    turnOnCamera: () => void
    turnOnMic: () => void
    turnOffCamera: () => void
    turnOffMic: () => void
    replaceTrack: (
      oldTrack: MediaStreamTrack,
      newTrack: MediaStreamTrack
    ) => Promise<void>
    observeVideo: (video: HTMLVideoElement) => void
    unobserveVideo: (video: HTMLVideoElement) => void
    negotiate: () => Promise<void>
    pendingNegotiation: boolean
  }

  type PeerDependencies = {
    api: RoomAPIType.InstanceApi
    createStream: RoomStreamType.CreateStream
    event: RoomEventType.InstanceEvent
    streams: RoomStreamType.InstanceStreams
    config: RoomType.Config
  }

  type RTCRtpSVCEncodingParameters = RTCRtpEncodingParameters & {
    scalabilityMode?: string
  }

  type RTCRtpSVCTransceiverInit = RTCRtpTransceiverInit & {
    sendEncodings?: RTCRtpSVCEncodingParameters[]
  }

  type AudioLevel = {
    sequenceNo: number
    timestamp: number
    audioLevel: number
  }

  type VoiceActivity = {
    type: string
    trackID: string
    streamID: string
    ssrc: number
    clockRate: number
    audioLevels?: AudioLevel[]
  }

  type VoiceActivityCallback = (voiceActivity: VoiceActivity) => void
}

declare function createAuth(userConfig?: {
    baseUrl?: string | undefined;
    apiVersion?: string | undefined;
    apiKey?: string | undefined;
    expirySeconds?: number | undefined;
} | undefined): Promise<{
    url: string;
    headers: Headers;
    code: number;
    ok: boolean;
    message: string;
    data: {
        expirySeconds: number;
        accessToken: string;
        refreshToken: string;
    };
}>;

declare namespace REASONS {
    let PEER_CLOSED: string;
    let NOT_FOUND: string;
    let RECONNECT: string;
    let TIMEOUT: string;
}

declare function Room(userConfig?: RoomType.UserConfig | undefined): {
    createRoom: (name?: string | undefined, id?: string | undefined, options?: {
        bitrates?: {
            audioRed?: number | undefined;
            audio?: number | undefined;
            video?: number | undefined;
            videoHigh?: number | undefined;
            videoHighPixels?: number | undefined;
            videoMid?: number | undefined;
            videoMidPixels?: number | undefined;
            videoLow?: number | undefined;
            videoLowPixels?: number | undefined;
            initialBandwidth?: number | undefined;
        } | undefined;
        codecs?: string[] | undefined;
        emptyRoomTimeoutMS?: number | undefined;
        pliIntervalMS?: number | undefined;
        qualityPresets?: {
            high?: {
                sid?: number | undefined;
                tid?: number | undefined;
            } | undefined;
            low?: {
                sid?: number | undefined;
                tid?: number | undefined;
            } | undefined;
            mid?: {
                sid?: number | undefined;
                tid?: number | undefined;
            } | undefined;
        } | undefined;
    } | undefined) => Promise<RoomAPIType.RoomReturnBody>;
    getRoom: (roomId: string) => Promise<RoomAPIType.RoomReturnBody>;
    createClient: (roomId: string, config?: {
        clientId?: string | undefined;
        clientName?: string | undefined;
        enableVAD?: boolean | undefined;
    } | undefined) => Promise<RoomAPIType.RegisterClientReturn>;
    getClient: (roomId: string, clientId: string) => Promise<{
        url: string;
        headers: Headers;
        code: number;
        ok: boolean;
        message: string;
        data: {
            clientId: string;
            clientName: string;
            connectionState: RTCPeerConnectionState;
            iceConnectionState: RTCIceConnectionState;
            events: {
                [key: string]: {
                    name: string;
                    timestamp: number;
                    data: {
                        [key: string]: string | null;
                    };
                };
            };
        };
    }>;
    setClientName: (roomId: string, clientId: string, clientName: string) => Promise<{
        url: string;
        headers: Headers;
        code: number;
        ok: boolean;
        message: string;
        data: {
            clientId: string;
            clientName: string;
            bitrates: {
                audio: number;
                audioRed: number;
                video: number;
                videoHigh: number;
                videoHighPixels: number;
                videoMid: number;
                videoMidPixels: number;
                videoLow: number;
                videoLowPixels: number;
                initialBandwidth: number;
            };
        };
    }>;
    getMetadata: (roomId: string, key: string) => Promise<{
        url: string;
        headers: Headers;
        code: number;
        ok: boolean;
        message: string;
        data: any;
    }>;
    setMetadata: (roomId: string, metadata: {
        [key: string]: any;
    }) => Promise<{
        url: string;
        headers: Headers;
        code: number;
        ok: boolean;
        message: string;
        data: null;
    }>;
    deleteMetadata: (roomId: string, key: string) => Promise<{
        url: string;
        headers: Headers;
        code: number;
        ok: boolean;
        message: string;
        data: null;
    }>;
    createPeer: (roomId: string, clientId: string) => Promise<{
        connect: (roomId: string, clientId: string) => Promise<void>;
        disconnect: () => void;
        getClientId: () => string;
        getRoom: () => Promise<RoomAPIType.RoomReturnBody>;
        getRoomId: () => string;
        getPeerConnection: () => Readonly<RTCPeerConnection | null>;
        addStream: (key: string, data: RoomStreamType.AddStreamParameters) => void;
        addIceCandidate: (candidate: RTCIceCandidate) => Promise<void>;
        removeStream: (key: string) => {
            id: string;
            clientId: string;
            name: string;
            origin: string;
            source: string;
            mediaStream: MediaStream;
            audioLevel: number;
            lastVoiceActivity: number;
            replaceTrack: (newTrack: MediaStreamTrack) => void;
            addVoiceActivity: (activity: RoomPeerType.VoiceActivity) => void;
            "__#6629@#triggerVoiceActivityEvent": (audioLevel: number) => void;
            addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined): void;
            dispatchEvent(event: Event): boolean;
            removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined): void;
        } | null;
        getAllStreams: () => {
            id: string;
            clientId: string;
            name: string;
            origin: string;
            source: string;
            mediaStream: MediaStream;
            audioLevel: number;
            lastVoiceActivity: number;
            replaceTrack: (newTrack: MediaStreamTrack) => void;
            addVoiceActivity: (activity: RoomPeerType.VoiceActivity) => void;
            "__#6629@#triggerVoiceActivityEvent": (audioLevel: number) => void;
            addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined): void;
            dispatchEvent(event: Event): boolean;
            removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined): void;
        }[];
        getStream: (key: string) => {
            id: string;
            clientId: string;
            name: string;
            origin: string;
            source: string;
            mediaStream: MediaStream;
            audioLevel: number;
            lastVoiceActivity: number;
            replaceTrack: (newTrack: MediaStreamTrack) => void;
            addVoiceActivity: (activity: RoomPeerType.VoiceActivity) => void;
            "__#6629@#triggerVoiceActivityEvent": (audioLevel: number) => void;
            addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined): void;
            dispatchEvent(event: Event): boolean;
            removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined): void;
        } | null;
        getStreamByTrackId: (trackId: string) => {
            id: string;
            clientId: string;
            name: string;
            origin: string;
            source: string;
            mediaStream: MediaStream;
            audioLevel: number;
            lastVoiceActivity: number;
            replaceTrack: (newTrack: MediaStreamTrack) => void;
            addVoiceActivity: (activity: RoomPeerType.VoiceActivity) => void;
            "__#6629@#triggerVoiceActivityEvent": (audioLevel: number) => void;
            addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined): void;
            dispatchEvent(event: Event): boolean;
            removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined): void;
        } | null;
        getTotalStreams: () => number;
        hasStream: (key: string) => boolean;
        turnOnCamera: (newTrack?: MediaStreamTrack | undefined) => Promise<void>;
        turnOnMic: (newTrack?: MediaStreamTrack | undefined) => Promise<void>;
        turnOffCamera: (stop?: boolean | undefined) => void;
        turnOffMic: (stop?: boolean | undefined) => void;
        replaceTrack: (oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack) => Promise<void>;
        observeVideo: (videoElement: HTMLVideoElement) => void;
        updateVideoSize: (trackId: string, width: number, height: number) => void;
        unobserveVideo: (videoElement: HTMLVideoElement) => void;
        negotiate: () => Promise<void>;
        startViewOnly: () => Promise<void>;
        pendingNegotiation: boolean;
    }>;
    createDataChannel: (roomId: string, name: string, ordered?: boolean) => Promise<{
        url: string;
        headers: Headers;
        code: number;
        ok: boolean;
        message: string;
        data: null;
    }>;
    setAuth: (auth: {
        url: string;
        data: {
            expirySeconds: number;
            accessToken: string;
            refreshToken: string;
        };
    }) => {
        baseUrl: string;
        apiVersion: string;
        accessToken: string;
        refreshToken: string;
        expirySeconds: number;
    };
    on: (eventName: string, callback: (data: any) => void) => void;
    addEventListener: (eventName: string, callback: (data: any) => void) => void;
    removeEventListener: (eventName: string, callback: (data: any) => void) => void;
    leaveRoom: (roomId: string, clientId: string, useBeacon?: boolean) => Promise<{
        code: number;
        ok: boolean;
        message: string;
        data: null;
    }>;
    endRoom: (roomId: string) => Promise<RoomAPIType.BaseResponseReturn>;
};

export { REASONS as ChannelClosureReasons, Room, createAuth };
//# sourceMappingURL=room.d.ts.map