@whereby.com/media 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,1300 @@
+import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
+import * as mediasoup_client_lib_Device from 'mediasoup-client/lib/Device';
+
+declare const getIssuesAndMetrics: () => any;
+declare function subscribeIssues(subscription: any): {
+    stop(): void;
+};
+
+declare function startPerformanceMonitor({ onMetricsUpdated, onTerminated, isHidden, }: {
+    onMetricsUpdated: (aggregatedMetrics: any) => void;
+    onTerminated: () => void;
+    isHidden: () => boolean;
+}): {
+    registerDecodedFps: (fpsData: any) => void;
+    terminate: () => void;
+    updateHidden: () => void;
+};
+
+declare const setClientProvider: (provider: any) => any;
+declare const getStats: () => any;
+declare const getUpdatedStats: () => any;
+declare function subscribeStats(subscription: any): {
+    stop(): void;
+};
+
+declare function captureCandidatePairInfoMetrics(cpMetrics: any, currentCptats: any, prevCptats: any, timeDiff: any, report: any): void;
+declare function captureSsrcInfo(ssrcMetrics: any, currentSsrcStats: any, prevSsrcStats: any, timeDiff: any, report: any): void;
+declare function captureCommonSsrcMetrics(ssrcMetrics: any, currentSsrcStats: any, prevSsrcStats: any, timeDiff: any, report: any): void;
+declare function captureAudioSsrcMetrics(ssrcMetrics: any, currentSsrcStats: any, prevSsrcStats: any, timeDiff: any, report: any): void;
+declare function captureVideoSsrcMetrics(ssrcMetrics: any, currentSsrcStats: any, prevSsrcStats: any, timeDiff: any, report: any): void;
+
+declare const removePeerConnection: (pc: any) => void;
+declare const getCurrentPeerConnections: () => any;
+declare const getPeerConnectionIndex: (pc: any) => any;
+declare const setPeerConnectionsForTests: (pcs: any) => any;
+
+declare class BandwidthTester extends EventEmitter {
+    closed: boolean;
+    _features: any;
+    _vegaConnection: any;
+    _mediasoupDevice: any;
+    _routerRtpCapabilities: any;
+    _sendTransport: any;
+    _receiveTransport: any;
+    _producer: any;
+    _consumers: Map<any, any>;
+    _startTime: any;
+    _connectTime: any;
+    _mediaEstablishedTime: any;
+    _runTime: any;
+    _endTime: any;
+    _timeout: any;
+    _canvas: any;
+    _drawInterval: any;
+    _resultTimeout: any;
+    _reportTimeout: any;
+    constructor({ features }?: {
+        features?: any;
+    });
+    start(runTime?: number): void;
+    close(): void;
+    _start(): Promise<void>;
+    _createTransport(send: any): Promise<void>;
+    _getTestTrack(): any;
+    _createProducer(): Promise<void>;
+    _onMessage(message: any): Promise<void>;
+    _onConsumerReady(options: any): Promise<void>;
+    _onConsumerClosed({ consumerId }: {
+        consumerId: any;
+    }): void;
+    _reportResults(): Promise<void>;
+    _startTimeout(seconds?: number): void;
+    _clearTimeouts(): void;
+}
+
+declare function detectMicrophoneNotWorking(pc: any): any;
+
+declare const MAXIMUM_TURN_BANDWIDTH = 1280;
+declare const MAXIMUM_TURN_BANDWIDTH_UNLIMITED = -1;
+declare const MEDIA_JITTER_BUFFER_TARGET = 400;
+
+declare enum RtcEventNames {
+    rtc_manager_created = "rtc_manager_created",
+    stream_added = "stream_added"
+}
+interface RtcManager {
+    acceptNewStream: ({ activeBreakout, clientId, shouldAddLocalVideo, streamId, }: {
+        activeBreakout: boolean;
+        clientId: string;
+        shouldAddLocalVideo: boolean;
+        streamId: string;
+    }) => void;
+    addNewStream(streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean): void;
+    disconnect(streamId: string, activeBreakout: boolean | null, eventClaim?: string): void;
+    disconnectAll(): void;
+    replaceTrack(oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack): void;
+    removeStream(streamId: string, _stream: MediaStream, requestedByClientId: string | null): void;
+    shouldAcceptStreamsFromBothSides?: () => boolean;
+    updateStreamResolution(streamId: string, ignored: null, resolution: {
+        width: number;
+        height: number;
+    }): void;
+    sendStatsCustomEvent(eventName: string, data: unknown): void;
+    isInitializedWith({ selfId, roomName, isSfu }: {
+        selfId: string;
+        roomName: string;
+        isSfu: boolean;
+    }): boolean;
+    setEventClaim?(eventClaim: string): void;
+    hasClient(clientId: string): boolean;
+}
+interface RtcManagerCreatedPayload {
+    rtcManager: RtcManager;
+}
+interface RtcStreamAddedPayload {
+    clientId: string;
+    stream: MediaStream;
+    streamId: string | undefined;
+    streamType: "webcam" | "screenshare" | undefined;
+}
+interface RtcClientConnectionStatusChangedPayload {
+    streamIds: string[];
+    clientId: string;
+    status: string;
+    previous: string;
+}
+interface RtcLocalStreamTrackAddedPayload {
+    streamId: string;
+    tracks: MediaStreamTrack[];
+    screenShare: boolean;
+}
+interface RtcLocalStreamTrackRemovedPayload {
+    stream: MediaStream;
+    track: MediaStreamTrack;
+}
+type RtcEvents = {
+    client_connection_status_changed: RtcClientConnectionStatusChangedPayload;
+    stream_added: RtcStreamAddedPayload;
+    rtc_manager_created: RtcManagerCreatedPayload;
+    rtc_manager_destroyed: void;
+    local_stream_track_added: RtcLocalStreamTrackAddedPayload;
+    local_stream_track_removed: RtcLocalStreamTrackRemovedPayload;
+    remote_stream_track_added: void;
+    remote_stream_track_removed: void;
+};
+type GetMediaConstraintsOptions = {
+    disableAEC: boolean;
+    disableAGC: boolean;
+    hd: boolean;
+    lax: boolean;
+    lowDataMode: boolean;
+    preferredDeviceIds: {
+        audioId?: boolean | string | null | {
+            ideal?: string | null;
+            exact?: string | null;
+        };
+        videoId?: boolean | string | null | {
+            ideal?: string | null;
+            exact?: string | null;
+        };
+    };
+    resolution?: string;
+    simulcast: boolean;
+    widescreen: boolean;
+    usingAspectRatio16x9: boolean;
+};
+type GetConstraintsOptions = {
+    devices: MediaDeviceInfo[];
+    audioId?: boolean | string;
+    videoId?: boolean | string;
+    type?: "ideal" | "exact";
+    options: Omit<GetMediaConstraintsOptions, "preferredDeviceIds">;
+};
+type GetStreamOptions = {
+    replaceStream?: MediaStream;
+    fallback?: boolean;
+};
+type GetStreamResult = {
+    error?: unknown;
+    replacedTracks?: MediaStreamTrack[];
+    stream: MediaStream;
+};
+type GetUpdatedDevicesResult = {
+    addedDevices: {
+        audioinput?: {
+            deviceId: string;
+            label: string;
+            kind: string;
+        };
+        videoinput?: {
+            deviceId: string;
+            label: string;
+            kind: string;
+        };
+        audiooutput?: {
+            deviceId: string;
+            label: string;
+            kind: string;
+        };
+    };
+    changedDevices: {
+        audioinput?: {
+            deviceId: string;
+            label: string;
+            kind: string;
+        };
+        videoinput?: {
+            deviceId: string;
+            label: string;
+            kind: string;
+        };
+        audiooutput?: {
+            deviceId: string;
+            label: string;
+            kind: string;
+        };
+    };
+};
+type GetDeviceDataResult = {
+    audio: {
+        deviceId: string;
+        label: string;
+        kind: string;
+    };
+    video: {
+        deviceId: string;
+        label: string;
+        kind: string;
+    };
+};
+
+declare function getMediaConstraints({ disableAEC, disableAGC, hd, lax, lowDataMode, preferredDeviceIds, resolution, simulcast, widescreen, }: GetMediaConstraintsOptions): any;
+declare function getConstraints({ devices, videoId, audioId, options, type }: GetConstraintsOptions): any;
+
+declare const isMobile: boolean;
+declare class NoDevicesError extends Error {
+    constructor(...args: any);
+}
+declare function enumerate(): Promise<MediaDeviceInfo[]>;
+declare function buildDeviceList({ busyDeviceIds, devices, kind }: any): any;
+declare function getUserMedia(constraints: any): Promise<MediaStream>;
+declare function getDeviceData({ audioTrack, videoTrack, devices, stoppedVideoTrack, lastAudioId, lastVideoId, }: {
+    audioTrack?: MediaStreamTrack | null;
+    videoTrack?: MediaStreamTrack | null;
+    devices: MediaDeviceInfo[];
+    stoppedVideoTrack?: boolean;
+    lastAudioId?: string | undefined;
+    lastVideoId?: string | undefined;
+}): GetDeviceDataResult;
+declare function stopStreamTracks(stream: MediaStream, only?: "audio" | "video" | false): void;
+declare function replaceTracksInStream(stream: MediaStream, newStream: MediaStream, only: "audio" | "video" | false): MediaStreamTrack[];
+declare function getStream2(constraintOpt: GetConstraintsOptions, additionalOpts?: GetStreamOptions): Promise<GetStreamResult>;
+declare function getStream(constraintOpt: any, { replaceStream, fallback }?: GetStreamOptions): Promise<GetStreamResult>;
+declare function hasGetDisplayMedia(): boolean;
+declare function getDisplayMedia(constraints?: {
+    video: {
+        width: {
+            max: number;
+        };
+        height: {
+            max: number;
+        };
+    };
+}, contentHint?: string): Promise<MediaStream>;
+declare function compareLocalDevices(before: any, after: any): any;
+declare function getUpdatedDevices({ oldDevices, newDevices, currentAudioId, currentVideoId, currentSpeakerId, }: {
+    oldDevices: MediaDeviceInfo[];
+    newDevices: MediaDeviceInfo[];
+    currentAudioId?: string | undefined;
+    currentVideoId?: string | undefined;
+    currentSpeakerId?: string | undefined;
+}): GetUpdatedDevicesResult;
+
+declare class P2pRtcManager implements RtcManager {
+    _selfId: any;
+    _roomName: any;
+    _roomSessionId: any;
+    peerConnections: any;
+    localStreams: any;
+    enabledLocalStreamIds: any[];
+    _screenshareVideoTrackIds: any[];
+    _socketListenerDeregisterFunctions: any[];
+    _localStreamDeregisterFunction: any;
+    _emitter: any;
+    _serverSocket: any;
+    _webrtcProvider: any;
+    _features: any;
+    _isAudioOnlyMode: boolean;
+    offerOptions: {
+        offerToReceiveAudio: boolean;
+        offerToReceiveVideo: boolean;
+    };
+    _pendingActionsForConnectedPeerConnections: any[];
+    _audioTrackOnEnded: () => void;
+    totalSessionsCreated: number;
+    _iceServers: any;
+    _sfuServer: any;
+    _mediaserverConfigTtlSeconds: any;
+    _fetchMediaServersTimer: any;
+    _wasScreenSharing: any;
+    ipv6HostCandidateTeredoSeen: any;
+    ipv6HostCandidate6to4Seen: any;
+    mdnsHostCandidateSeen: any;
+    _lastReverseDirectionAttemptByClientId: any;
+    _stoppedVideoTrack: any;
+    icePublicIPGatheringTimeoutID: any;
+    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features, }: {
+        selfId: any;
+        room: any;
+        emitter: any;
+        serverSocket: any;
+        webrtcProvider: any;
+        features: any;
+    });
+    numberOfPeerconnections(): number;
+    isInitializedWith({ selfId, roomName, isSfu }: {
+        selfId: any;
+        roomName: any;
+        isSfu: any;
+    }): boolean;
+    supportsScreenShareAudio(): boolean;
+    maybeRestrictRelayBandwidth(session: any): void;
+    addNewStream(streamId: string, stream: MediaStream): void;
+    replaceTrack(oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack): Promise<any[]>;
+    accept({ clientId, shouldAddLocalVideo }: {
+        clientId: string;
+        shouldAddLocalVideo?: boolean;
+    }): any;
+    disconnectAll(): void;
+    fixChromeAudio(constraints: any): Promise<any[]> | undefined;
+    setupSocketListeners(): void;
+    sendAudioMutedStats(muted: boolean): void;
+    sendVideoMutedStats(muted: boolean): void;
+    sendStatsCustomEvent(eventName: string, data: any): void;
+    rtcStatsDisconnect(): void;
+    rtcStatsReconnect(): void;
+    setAudioOnly(audioOnly: any): void;
+    setRemoteScreenshareVideoTrackIds(remoteScreenshareVideoTrackIds?: never[]): void;
+    setRoomSessionId(roomSessionId: string): void;
+    _setConnectionStatus(session: any, newStatus: any, clientId: string): void;
+    _setJitterBufferTarget(pc: any): void;
+    _emitServerEvent(eventName: string, data?: any, callback?: any): void;
+    _emit(eventName: string, data?: any): void;
+    _addEnabledLocalStreamId(streamId: string): void;
+    _deleteEnabledLocalStreamId(streamId: string): void;
+    _getSession(peerConnectionId: string): any;
+    _getOrCreateSession(peerConnectionId: string, initialBandwidth: any): any;
+    _getLocalCameraStream(): any;
+    _getNonLocalCameraStreamIds(): string[];
+    _isScreensharingLocally(): boolean;
+    _getFirstLocalNonCameraStream(): any;
+    _transformIncomingSdp(original: any, _: any): {
+        type: any;
+        sdp: any;
+    };
+    _transformOutgoingSdp(original: any): {
+        type: any;
+        sdpU: any;
+    };
+    _createSession({ clientId, initialBandwidth, isOfferer, peerConnectionId, shouldAddLocalVideo, }: {
+        clientId: string;
+        initialBandwidth: any;
+        isOfferer: any;
+        peerConnectionId: string;
+        shouldAddLocalVideo: boolean;
+    }): any;
+    _cleanup(peerConnectionId: string): void;
+    _forEachPeerConnection(func: any): void;
+    _addStreamToPeerConnections(stream: any): void;
+    _addTrackToPeerConnections(track: any, stream?: any): void;
+    _replaceTrackToPeerConnections(oldTrack: any, newTrack: any): Promise<any[]>;
+    _removeStreamFromPeerConnections(stream: any): void;
+    _removeTrackFromPeerConnections(track: any): void;
+    _addLocalStream(streamId: string, stream: any): void;
+    _removeLocalStream(streamId: string): void;
+    _updateAndScheduleMediaServersRefresh({ iceServers, sfuServer, mediaserverConfigTtlSeconds }: any): void;
+    _clearMediaServersRefresh(): void;
+    _startMonitoringAudioTrack(track: any): void;
+    _stopMonitoringAudioTrack(track: any): void;
+    _connect(clientId: string): Promise<any>;
+    _maybeRestartIce(clientId: string, session: any): void;
+    _setCodecPreferences(pc: any, vp9On: any, av1On: any, redOn: any): void;
+    _negotiatePeerConnection(clientId: string, session: any, constraints?: any): void;
+    _withForcedRenegotiation(session: any, action: any): void;
+    _changeBandwidthForAllClients(isJoining: boolean): number;
+    _createP2pSession(clientId: string, initialBandwidth: any, shouldAddLocalVideo: any, isOfferer?: any): any;
+    acceptNewStream({ streamId, clientId, shouldAddLocalVideo, }: {
+        streamId: string;
+        clientId: string;
+        shouldAddLocalVideo?: boolean;
+    }): any;
+    disconnect(clientId: string): void;
+    updateStreamResolution(): void;
+    stopOrResumeAudio(): void;
+    _handleStopOrResumeVideo({ enable, track }: {
+        enable: boolean;
+        track: any;
+    }): void;
+    stopOrResumeVideo(localStream: any, enable: boolean): void;
+    _shareScreen(streamId: string, stream: any): void;
+    removeStream(streamId: string, stream: any, requestedByClientId: any): void;
+    hasClient(clientId: string): boolean;
+}
+
+declare const assert: {
+    fail: (message?: string | Error) => void;
+    ok: (value: any, message?: string | Error) => void;
+    equal?: (actual: any, expected: any, message?: string | Error) => void;
+    notEqual?: (actual: any, expected: any, message?: string | Error) => void;
+};
+
+declare const createWorker: (fn: Function) => Worker;
+declare const generateByteString: (count: number) => string;
+
+declare const getHandler: () => mediasoup_client_lib_Device.BuiltinHandlerName | undefined;
+
+declare const ipRegex: {
+    (options: {
+        exact: boolean;
+        includeBoundaries?: boolean;
+    }): RegExp;
+    v4(options: {
+        exact: boolean;
+        includeBoundaries?: boolean;
+    }): RegExp;
+    v6(options: {
+        exact: boolean;
+        includeBoundaries?: boolean;
+    }): RegExp;
+};
+
+declare class Logger {
+    _isEnabled: boolean;
+    _debugger: any;
+    constructor();
+    isEnabled(): boolean;
+    enable(): void;
+    disable(): void;
+    info(...params: any[]): void;
+    warn(...params: any[]): void;
+    error(...params: any[]): void;
+    withDebugLogger(myDebugger?: null): this;
+    debug(...params: any[]): void;
+}
+
+declare const getMediaSettings: (kind: string, isScreenShare: boolean, features: any) => {
+    encodings: {}[];
+};
+declare const modifyMediaCapabilities: (routerRtpCapabilities: any, features: any) => void;
+
+declare function getOptimalBitrate(width: number, height: number, frameRate: number): number;
+
+declare class ReconnectManager extends EventEmitter {
+    _socket: any;
+    _clients: any;
+    _signalDisconnectTime?: number;
+    rtcManager?: RtcManager;
+    metrics: {
+        roomJoinedLate: number;
+        pendingClientCanceled: number;
+        evaluationFailed: number;
+        roomJoined: number;
+    };
+    constructor(socket: any);
+    _onRoomJoined(payload: any): Promise<void>;
+    _onClientLeft(payload: any): void;
+    _onPendingClientLeft(payload: any): void;
+    _onNewClient(payload: any): void;
+    _abortIfNotActive(payload: any): Promise<void>;
+    _checkIsActive(clientId: string): Promise<boolean>;
+    _isClientMediaActive(stats: any, clientId: string): boolean;
+    _onAudioEnabled(payload: any): void;
+    _onVideoEnabled(payload: any): void;
+    _onScreenshareChanged(payload: any, action: boolean): void;
+    _hasClientStateChanged({ clientId, webcam, mic, screenShare, }: {
+        clientId: string;
+        webcam: boolean;
+        mic: boolean;
+        screenShare: boolean;
+    }): boolean;
+    _addClientToState(newClient: any): void;
+    _wasClientSendingMedia(clientId: string): any;
+    _getPendingClientsByDeviceId(deviceId: string): unknown[];
+    _resetClientState(payload: any): void;
+}
+
+declare class ServerSocket {
+    _socket: any;
+    _reconnectManager?: ReconnectManager | null;
+    noopKeepaliveInterval: any;
+    _wasConnectedUsingWebsocket?: boolean;
+    constructor(hostName: string, optionsOverrides?: any, glitchFree?: boolean);
+    setRtcManager(rtcManager?: RtcManager): void;
+    connect(): void;
+    disconnect(): void;
+    disconnectOnConnect(): void;
+    emit(eventName: string, ...args: any[]): void;
+    emitIfConnected(eventName: string, data: any): void;
+    getTransport(): any;
+    getManager(): any;
+    isConnecting(): any;
+    isConnected(): any;
+    on(eventName: string, handler: Function): () => void;
+    once(eventName: string, handler: Function): void;
+    off(eventName: string, handler: Function): void;
+    _interceptEvent(eventName: string, handler: any): () => void;
+    getGlitchFreeMetrics(): {
+        roomJoinedLate: number;
+        pendingClientCanceled: number;
+        evaluationFailed: number;
+        roomJoined: number;
+    } | undefined;
+}
+
+declare const maybeTurnOnly: (transportConfig: any, features: {
+    useOnlyTURN: string;
+}) => void;
+
+interface Credentials {
+    credentials: {
+        uuid: string;
+    };
+    hmac: string;
+    userId: string;
+}
+interface SocketConf {
+    host?: string;
+    path?: string;
+    reconnectionDelay?: number;
+    reconnectionDelayMax?: number;
+    timeout?: number;
+    autoConnect?: boolean;
+}
+interface SocketManager {
+    on: (eventName: string, callback: (args: unknown) => void) => void;
+}
+interface ClientRole {
+    roleName: string;
+}
+interface SignalKnocker {
+    clientId: string;
+    displayName: string | null;
+    imageUrl: string | null;
+    liveVideo: boolean;
+    userAvatarUrl: string | null;
+    userId: string | null;
+}
+interface SignalClient {
+    displayName: string;
+    id: string;
+    streams: string[];
+    isAudioEnabled: boolean;
+    isVideoEnabled: boolean;
+    role: ClientRole;
+    startedCloudRecordingAt: string | null;
+}
+interface AudioEnabledEvent {
+    clientId: string;
+    isAudioEnabled: boolean;
+}
+interface ChatMessage {
+    id: string;
+    messageType: "text";
+    roomName: string;
+    senderId: string;
+    sig: string;
+    text: string;
+    timestamp: string;
+    userId: string;
+}
+interface CloudRecordingStartedEvent {
+    error?: string;
+    startedAt?: string;
+}
+interface ClientLeftEvent {
+    clientId: string;
+}
+interface NewClientEvent {
+    client: SignalClient;
+    room?: {
+        session: {
+            createdAt: string;
+            id: string;
+        } | null;
+    };
+}
+interface ClientKickedEvent {
+    clientId: string;
+}
+interface KnockerLeftEvent {
+    clientId: string;
+}
+interface KnockAcceptedEvent {
+    clientId: string;
+    metadata: {
+        roomKey: string;
+        roomName: string;
+    };
+    resolution: "accepted";
+}
+interface KnockRejectedEvent {
+    clientId: string;
+    resolution: "rejected";
+}
+interface RoomJoinedEvent {
+    error?: string;
+    isLocked: boolean;
+    room?: {
+        clients: SignalClient[];
+        knockers: SignalKnocker[];
+        session: {
+            createdAt: string;
+            id: string;
+        } | null;
+    };
+    selfId: string;
+}
+interface RoomKnockedEvent {
+    clientId: string;
+    displayName: string | null;
+    imageUrl: string | null;
+    liveVideo: boolean;
+}
+interface RoomSessionEndedEvent {
+    roomSessionId: string;
+}
+interface ScreenshareStartedEvent {
+    clientId: string;
+    streamId: string;
+    hasAudioTrack: boolean;
+}
+interface ScreenshareStoppedEvent {
+    clientId: string;
+    streamId: string;
+}
+interface VideoEnabledEvent {
+    clientId: string;
+    isVideoEnabled: boolean;
+}
+interface ClientMetadataReceivedEvent {
+    type: string;
+    payload: {
+        clientId: string;
+        displayName: string;
+    };
+}
+interface SignalEvents {
+    audio_enabled: AudioEnabledEvent;
+    client_left: ClientLeftEvent;
+    client_kicked: ClientKickedEvent;
+    client_metadata_received: ClientMetadataReceivedEvent;
+    cloud_recording_started: CloudRecordingStartedEvent;
+    cloud_recording_stopped: void;
+    chat_message: ChatMessage;
+    connect: void;
+    connect_error: void;
+    device_identified: void;
+    disconnect: void;
+    knock_handled: KnockAcceptedEvent | KnockRejectedEvent;
+    knocker_left: KnockerLeftEvent;
+    new_client: NewClientEvent;
+    room_joined: RoomJoinedEvent;
+    room_knocked: RoomKnockedEvent;
+    room_left: void;
+    room_session_ended: RoomSessionEndedEvent;
+    screenshare_started: ScreenshareStartedEvent;
+    screenshare_stopped: ScreenshareStoppedEvent;
+    streaming_stopped: void;
+    video_enabled: VideoEnabledEvent;
+}
+interface IdentifyDeviceRequest {
+    deviceCredentials: Credentials;
+}
+interface JoinRoomRequest {
+    config: {
+        isAudioEnabled: boolean;
+        isVideoEnabled: boolean;
+    };
+    organizationId: string;
+    roomName: string;
+    displayName?: string;
+}
+interface KnockRoomRequest {
+    displayName: string;
+    imageUrl: string | null;
+    kickFromOtherRooms: boolean;
+    liveVideo: boolean;
+    organizationId: string;
+    roomKey: string | null;
+    roomName: string;
+}
+interface SignalRequests {
+    chat_message: {
+        text: string;
+    };
+    enable_audio: {
+        enabled: boolean;
+    };
+    enable_video: {
+        enabled: boolean;
+    };
+    handle_knock: {
+        action: "accept" | "reject";
+        clientId: string;
+        response: unknown;
+    };
+    identify_device: IdentifyDeviceRequest;
+    join_room: JoinRoomRequest;
+    knock_room: KnockRoomRequest;
+    leave_room: void;
+    send_client_metadata: {
+        type: string;
+        payload: {
+            displayName?: string;
+        };
+    };
+    start_recording: {
+        recording: string;
+    };
+    stop_recording: void;
+}
+
+declare function fromLocation({ host, protocol }?: {
+    host?: string | undefined;
+    protocol?: string | undefined;
+}): {
+    domain: string;
+    domainWithSeparator: string;
+    organizationDomain: string;
+    organization: string;
+    service: string;
+    subdomain: string;
+};
+
+declare class RtcManagerDispatcher {
+    emitter: {
+        emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K]) => void;
+    };
+    currentManager: RtcManager | null;
+    constructor({ emitter, serverSocket, webrtcProvider, features, }: {
+        emitter: {
+            emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K]) => void;
+        };
+        serverSocket: ServerSocket;
+        webrtcProvider: any;
+        features: any;
+    });
+    stopRtcManager(): void;
+}
+
+declare const _default: {
+    CAMERA_NOT_WORKING: string;
+    CONNECTION_BLOCKED_BY_NETWORK: string;
+    ICE_IPV6_SEEN: string;
+    ICE_MDNS_SEEN: string;
+    ICE_NO_PUBLIC_IP_GATHERED: string;
+    ICE_NO_PUBLIC_IP_GATHERED_3SEC: string;
+    ICE_RESTART: string;
+    MICROPHONE_NOT_WORKING: string;
+    MICROPHONE_STOPPED_WORKING: string;
+    NEW_PC: string;
+    SFU_CONNECTION_OPEN: string;
+    SFU_CONNECTION_CLOSED: string;
+    COLOCATION_SPEAKER: string;
+    DOMINANT_SPEAKER: string;
+};
+
+declare function setVideoBandwidthUsingSetParameters(pc: any, bandwidth: any, logger?: any): any;
+
+declare const rtcStats: {
+    sendEvent: (type: any, value: any) => void;
+    sendAudioMuted: (muted: boolean) => void;
+    sendVideoMuted: (muted: boolean) => void;
+    server: {
+        connected: boolean;
+        trace: (...args: any) => void;
+        close: () => void;
+        connect: () => void;
+    };
+};
+
+declare function setCodecPreferenceSDP(sdp: any, vp9On: any, redOn: any): string | undefined;
+declare function maybeRejectNoH264(sdp: any): any;
+declare function deprioritizeH264(sdp: any): string;
+declare function replaceSSRCs(currentDescription: any, newDescription: any): any;
+declare function filterMidExtension(sdp: any): any;
+declare function filterMsidSemantic(sdp: any): any;
+declare function changeMediaDirection(sdp: any, active: any): string;
+declare function addExtMap(sdp: any, extmapUri: any, modifyAudio?: any, modifyVideo?: any): any;
+declare function addAbsCaptureTimeExtMap(sdp: any): any;
+
+declare class Session {
+    peerConnectionId: any;
+    relayCandidateSeen: boolean;
+    serverReflexiveCandidateSeen: boolean;
+    publicHostCandidateSeen: boolean;
+    ipv6HostCandidateSeen: boolean;
+    ipv6HostCandidateTeredoSeen: boolean;
+    ipv6HostCandidate6to4Seen: boolean;
+    mdnsHostCandidateSeen: boolean;
+    pc: any;
+    wasEverConnected: boolean;
+    connectionStatus: any;
+    stats: {
+        totalSent: number;
+        totalRecv: number;
+    };
+    bandwidth: any;
+    maximumTurnBandwidth: any;
+    pending: any[];
+    isOperationPending: boolean;
+    streamIds: any[];
+    streams: any[];
+    earlyIceCandidates: any[];
+    afterConnected: Promise<unknown>;
+    registerConnected: any;
+    offerOptions: {
+        offerToReceiveAudio: boolean;
+        offerToReceiveVideo: boolean;
+    };
+    _deprioritizeH264Encoding: any;
+    clientId: any;
+    peerConnectionConfig: any;
+    shouldAddLocalVideo: any;
+    signalingState: any;
+    srdComplete: any;
+    pendingOffer: any;
+    constructor({ peerConnectionId, bandwidth, maximumTurnBandwidth, deprioritizeH264Encoding, }: {
+        peerConnectionId: any;
+        bandwidth: any;
+        maximumTurnBandwidth: any;
+        deprioritizeH264Encoding: any;
+    });
+    setAndGetPeerConnection({ clientId, constraints, peerConnectionConfig, shouldAddLocalVideo, }: {
+        clientId: any;
+        constraints: any;
+        peerConnectionConfig: any;
+        shouldAddLocalVideo: any;
+    }): any;
+    addStream(stream: MediaStream): void;
+    addTrack(track: MediaStreamTrack, stream?: MediaStream): void;
+    removeTrack(track: MediaStreamTrack): void;
+    removeStream(stream: MediaStream): void;
+    _setRemoteDescription(desc: any): any;
+    handleOffer(message: any): any;
+    handleAnswer(message: any): any;
+    addIceCandidate(candidate: any): void;
+    canModifyPeerConnection(): boolean;
+    close(): void;
+    hasConnectedPeerConnection(): any;
+    replaceTrack(oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack): any;
+    maybeRestrictRelayBandwidth(): void;
+    changeBandwidth(bandwidth: any): void;
+    setAudioOnly(enable: boolean, excludedTrackIds?: any[]): void;
+}
+
+declare class SfuV2Parser {
+    static parse(raw: any): any;
+    static _handleRequest(rawMessage: any): any;
+    static _handleResponse(rawMessage: any): any;
+    static _handleMessage(rawMessage: any): any;
+    static createRequest(method: any, data: any): {
+        request: boolean;
+        id: number;
+        method: any;
+        data: any;
+    };
+    static createSuccessResponse(request: any, data: any): {
+        response: boolean;
+        id: any;
+        ok: boolean;
+        data: any;
+    };
+    static createErrorResponse(request: any, errorCode: any, errorReason: any): {
+        response: boolean;
+        id: any;
+        errorCode: any;
+        errorReason: any;
+    };
+    static createMessage(method: any, data: any): {
+        message: boolean;
+        method: any;
+        data: any;
+    };
+}
+
+declare function isRelayed(pc: any): any;
+
+declare class VegaConnection extends EventEmitter$1 {
+    wsUrl: string;
+    protocol: string;
+    socket: WebSocket | null;
+    sents: Map<any, any>;
+    constructor(wsUrl: string, protocol?: string);
+    _setupSocket(): void;
+    _tearDown(): void;
+    close(): void;
+    _onOpen(): void;
+    _onMessage(event: any): void;
+    _onClose(): void;
+    _onError(error: any): void;
+    _handleResponse(socketMessage: any): void;
+    send(message: any): void;
+    message(method: any, data?: any): void;
+    request(method: any, data?: any, timeout?: number): Promise<unknown>;
+}
+
+declare class VegaMediaQualityMonitor extends EventEmitter {
+    _clients: any;
+    _producers: any;
+    _intervalHandle: any;
+    constructor();
+    close(): void;
+    _startMonitor(): void;
+    _evaluateClient(clientId: string, producers: any): void;
+    _evaluateProducer(clientId: string, producers: any, kind: string): void;
+    _updateTrend(newQuality: any, state: any): boolean;
+    addProducer(clientId: string, producerId: string): void;
+    removeProducer(clientId: string, producerId: string): void;
+    addConsumer(clientId: string, consumerId: string): void;
+    removeConsumer(clientId: string, consumerId: string): void;
+    addProducerScore(clientId: string, producerId: string, kind: string, score: any): void;
+    addConsumerScore(clientId: string, consumerId: string, kind: string, score: any): void;
+    _evaluateScore(score: number): "critical" | "ok" | "warning";
+    _calcAvgProducerScore(scores: any): number;
+}
+
+declare function createMicAnalyser({ micTrack, params, onScoreUpdated, }: {
+    micTrack: MediaStreamTrack;
+    params?: any;
+    onScoreUpdated: (data: any) => void;
+}): {
+    setParams: (newParams: any) => void;
+    setTrack: (track: MediaStreamTrack | null) => Promise<void>;
+    close(): void;
+};
+
+declare class KalmanFilter {
+    R: number;
+    Q: number;
+    A: number;
+    C: number;
+    B: number;
+    cov: number;
+    x: number;
+    constructor({ R, Q, A, B, C }?: {
+        R?: number;
+        Q?: number;
+        A?: number;
+        B?: number;
+        C?: number;
+    });
+    filter(z: number, u?: number): number;
+    predict(u?: number): number;
+    uncertainty(): number;
+    lastMeasurement(): number;
+    setMeasurementNoise(noise: number): void;
+    setProcessNoise(noise: number): void;
+}
+declare const createACFCalculator: () => (arr: any[]) => number;
+declare const calculateStd: (arr: any[]) => number;
+declare const standardDeviation: (arr: any[]) => {
+    mean: number;
+    SD: number;
+};
+declare const variance: (arr: any[], usePopulation?: boolean) => number;
+
+declare class VegaRtcManager implements RtcManager {
+    _selfId: any;
+    _room: any;
+    _roomSessionId: any;
+    _emitter: any;
+    _serverSocket: any;
+    _webrtcProvider: any;
+    _features: any;
+    _eventClaim?: any;
+    _vegaConnection: any;
+    _micAnalyser: any;
+    _micAnalyserDebugger: any;
+    _mediasoupDevice: any;
+    _routerRtpCapabilities: any;
+    _sendTransport: any;
+    _receiveTransport: any;
+    _clientStates: any;
+    _streamIdToVideoConsumerId: any;
+    _consumers: any;
+    _dataConsumers: any;
+    _localStreamDeregisterFunction: any;
+    _micTrack: any;
+    _webcamTrack: any;
+    _screenVideoTrack: any;
+    _screenAudioTrack: any;
+    _micProducer: any;
+    _micProducerPromise: any;
+    _micPaused: any;
+    _micScoreProducer: any;
+    _micScoreProducerPromise: any;
+    _webcamProducer: any;
+    _webcamProducerPromise: any;
+    _webcamPaused: any;
+    _screenVideoProducer: any;
+    _screenVideoProducerPromise: any;
+    _screenAudioProducer: any;
+    _screenAudioProducerPromise: any;
+    _sndTransportIceRestartPromise: any;
+    _rcvTransportIceRestartPromise: any;
+    _colocation: any;
+    _stopCameraTimeout: any;
+    _audioTrackOnEnded: any;
+    _socketListenerDeregisterFunctions: any;
+    _reconnect: any;
+    _reconnectTimeOut: any;
+    _qualityMonitor: any;
+    _fetchMediaServersTimer: any;
+    _iceServers: any;
+    _sfuServer: any;
+    _mediaserverConfigTtlSeconds: any;
+    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features, eventClaim, deviceHandlerFactory, }: {
+        selfId: any;
+        room: any;
+        emitter: any;
+        serverSocket: any;
+        webrtcProvider: any;
+        features?: any;
+        eventClaim?: string;
+        deviceHandlerFactory?: any;
+    });
+    _updateAndScheduleMediaServersRefresh({ iceServers, sfuServer, mediaserverConfigTtlSeconds, }: {
+        iceServers: any;
+        sfuServer: any;
+        mediaserverConfigTtlSeconds: any;
+    }): void;
+    _clearMediaServersRefresh(): void;
+    setupSocketListeners(): void;
+    _emitScreenshareStarted(): void;
+    _connect(): void;
+    _onClose(): void;
+    _join(): Promise<void>;
+    _createTransport(send: any): Promise<void>;
+    _restartIce(transport: any, retried?: number): Promise<void>;
+    _internalSendMic(): Promise<void>;
+    _internalSetupMicScore(): Promise<void>;
+    _stopMicScoreProducer(): void;
+    _replaceMicTrack(): Promise<void>;
+    _pauseResumeMic(): void;
+    _sendMic(track: MediaStreamTrack): Promise<void>;
+    _sendMicScore(score: number): void;
+    _internalSendWebcam(): Promise<void>;
+    _replaceWebcamTrack(): Promise<void>;
+    _pauseResumeWebcam(): void;
+    _sendWebcam(track: MediaStreamTrack): Promise<void>;
+    _internalSendScreenVideo(): Promise<void>;
+    _replaceScreenVideoTrack(): Promise<void>;
+    _sendScreenVideo(track: MediaStreamTrack): Promise<void>;
+    _internalSendScreenAudio(): Promise<void>;
+    _replaceScreenAudioTrack(): Promise<void>;
+    _sendScreenAudio(track: MediaStreamTrack): Promise<void>;
+    _stopProducer(producer: any): void;
+    isInitializedWith({ selfId, roomName, isSfu }: {
+        selfId: string;
+        roomName: string;
+        isSfu: boolean;
+    }): boolean;
+    setEventClaim(eventClaim: string): void;
+    setColocation(colocation: any): void;
+    setAudioOnly(audioOnly: boolean): void;
+    setRemoteScreenshareVideoTrackIds(): void;
+    setRoomSessionId(roomSessionId: string): void;
+    disconnect(clientIdOrStreamId: string, _activeBreakout: any, eventClaim?: string): void;
+    replaceTrack(oldTrack: MediaStreamTrack | null, track: MediaStreamTrack): void;
+    removeStream(streamId: string, _stream: MediaStream, requestedByClientId: string): void;
+    _onMicAnalyserScoreUpdated(data: any): void;
+    addNewStream(streamId: string, stream: MediaStream, audioPaused: boolean, videoPaused: boolean): void;
+    _syncMicAnalyser(): void;
+    stopOrResumeAudio(stream: MediaStream, enabled: boolean): void;
+    _handleStopOrResumeVideo({ enable, track }: {
+        enable: boolean;
+        track: MediaStreamTrack;
+    }): void;
+    stopOrResumeVideo(localStream: MediaStream, enable: boolean): void;
+    supportsScreenShareAudio(): boolean;
+    acceptNewStream({ streamId, clientId }: {
+        streamId: string;
+        clientId: string;
+    }): void;
+    updateStreamResolution(streamId: string, _ignored: any, { width, height, }: {
+        width: number;
+        height: number;
+    }): void;
+    disconnectAll(): void;
+    sendAudioMutedStats(muted: boolean): void;
+    sendVideoMutedStats(muted: boolean): void;
+    sendStatsCustomEvent(eventName: string, data?: any): void;
+    rtcStatsDisconnect(): void;
+    rtcStatsReconnect(): void;
+    _startMonitoringAudioTrack(track: MediaStreamTrack): void;
+    _stopMonitoringAudioTrack(track: MediaStreamTrack): void;
+    _onMessage(message: any): Promise<void>;
+    _onConsumerReady(options: any): Promise<void>;
+    _onConsumerClosed({ consumerId, reason }: {
+        consumerId: string;
+        reason: string;
+    }): Promise<void>;
+    _onConsumerPaused({ consumerId }: {
+        consumerId: string;
+    }): void;
+    _onConsumerResumed({ consumerId }: {
+        consumerId: string;
+    }): void;
+    _onConsumerScore({ consumerId, kind, score }: {
+        consumerId: string;
+        kind: string;
+        score: number;
+    }): void;
+    _onProducerScore({ producerId, kind, score }: {
+        producerId: string;
+        kind: string;
+        score: number;
+    }): void;
+    _onDataConsumerReady(options: any): Promise<void>;
+    _onDataConsumerClosed({ dataConsumerId, reason }: {
+        dataConsumerId: string;
+        reason: string;
+    }): Promise<void>;
+    _onDominantSpeaker({ consumerId }: {
+        consumerId: string;
+    }): void;
+    _consumerClosedCleanup(consumer: any): void;
+    _syncIncomingStreamsWithPWA(clientId: string): void;
+    _getOrCreateClientState(clientId: string): any;
+    _emitToPWA(eventName: string, data?: any): void;
+    _emitToSignal(eventName: string, data?: any, callback?: any): void;
+    shouldAcceptStreamsFromBothSides(): boolean;
+    setMicAnalyserDebugger(analyserDebugger: any): void;
+    setMicAnalyserParams(params: any): void;
+    hasClient(clientId: string): any;
+}
+
+declare const EVENTS: Record<string, keyof RtcEvents>;
+declare const TYPES: {
+    CONNECTING: string;
+    CONNECTION_FAILED: string;
+    CONNECTION_SUCCESSFUL: string;
+    CONNECTION_DISCONNECTED: string;
+};
+
+declare const PROTOCOL_REQUESTS: {
+    BLOCK_CLIENT: string;
+    CLAIM_ROOM: string;
+    CLEAR_CHAT_HISTORY: string;
+    ENABLE_AUDIO: string;
+    ENABLE_VIDEO: string;
+    END_STREAM: string;
+    FETCH_MEDIASERVER_CONFIG: string;
+    HANDLE_KNOCK: string;
+    IDENTIFY_DEVICE: string;
+    INVITE_CLIENT_AS_MEMBER: string;
+    JOIN_ROOM: string;
+    KICK_CLIENT: string;
+    KNOCK_ROOM: string;
+    LEAVE_ROOM: string;
+    SEND_CLIENT_METADATA: string;
+    SET_LOCK: string;
+    SHARE_MEDIA: string;
+    START_NEW_STREAM: string;
+    START_SCREENSHARE: string;
+    STOP_SCREENSHARE: string;
+    START_URL_EMBED: string;
+    STOP_URL_EMBED: string;
+    START_RECORDING: string;
+    STOP_RECORDING: string;
+    SFU_TOKEN: string;
+};
+declare const PROTOCOL_RESPONSES: {
+    AUDIO_ENABLED: string;
+    BACKGROUND_IMAGE_CHANGED: string;
+    BLOCK_ADDED: string;
+    BLOCK_REMOVED: string;
+    CHAT_HISTORY_CLEARED: string;
+    CLIENT_BLOCKED: string;
+    CLIENT_INVITED_AS_MEMBER: string;
+    CLIENT_KICKED: string;
+    CLIENT_LEFT: string;
+    CLIENT_METADATA_RECEIVED: string;
+    CLIENT_READY: string;
+    CLIENT_ROLE_CHANGED: string;
+    CLIENT_USER_ID_CHANGED: string;
+    CONTACTS_UPDATED: string;
+    DEVICE_IDENTIFIED: string;
+    ROOM_ROLES_UPDATED: string;
+    KNOCK_HANDLED: string;
+    KNOCK_PAGE_BACKGROUND_CHANGED: string;
+    KNOCKER_LEFT: string;
+    MEDIASERVER_CONFIG: string;
+    MEDIA_SHARED: string;
+    MEMBER_INVITE: string;
+    NEW_CLIENT: string;
+    NEW_STREAM_STARTED: string;
+    SCREENSHARE_STARTED: string;
+    SCREENSHARE_STOPPED: string;
+    OWNER_NOTIFIED: string;
+    OWNERS_CHANGED: string;
+    PLAY_CLIENT_STICKER: string;
+    ROOM_INTEGRATION_ENABLED: string;
+    ROOM_INTEGRATION_DISABLED: string;
+    ROOM_JOINED: string;
+    ROOM_KNOCKED: string;
+    ROOM_LEFT: string;
+    ROOM_LOCKED: string;
+    ROOM_PERMISSIONS_CHANGED: string;
+    ROOM_LOGO_CHANGED: string;
+    ROOM_TYPE_CHANGED: string;
+    ROOM_MODE_CHANGED: string;
+    SOCKET_USER_ID_CHANGED: string;
+    STICKERS_UNLOCKED: string;
+    STREAM_ENDED: string;
+    URL_EMBED_STARTED: string;
+    URL_EMBED_STOPPED: string;
+    RECORDING_STARTED: string;
+    RECORDING_STOPPED: string;
+    USER_NOTIFIED: string;
+    VIDEO_ENABLED: string;
+    CLIENT_UNABLE_TO_JOIN: string;
+};
+declare const PROTOCOL_ERRORS: {
+    CANNOT_INVITE_YOURSELF: string;
+    CLIENT_MISSING_DEVICE_ID: string;
+    FORBIDDEN: string;
+    INTERNAL_SERVER_ERROR: string;
+    INVALID_AVATAR: string;
+    INVALID_PARAMETERS: string;
+    INVALID_ROOM_NAME: string;
+    MISSING_PARAMETERS: string;
+    MISSING_ROOM_NAME: string;
+    NOT_AN_OWNER: string;
+    NOT_IN_A_ROOM: string;
+    ROOM_ALREADY_CLAIMED: string;
+    ROOM_EMAIL_MISSING: string;
+    ROOM_FULL: string;
+    ROOM_UNCLAIMED: string;
+    CLIENT_BLOCKED: string;
+    ROOM_LOCKED: string;
+    TOO_LONG_TEXT: string;
+    VIDEO_STICKER_DOES_NOT_EXIST: string;
+    VIDEO_STICKER_FORMAT_ERROR: string;
+    UNSUPPORTED_VIDEO_ENCODING: string;
+};
+declare const RELAY_MESSAGES: {
+    CHAT_MESSAGE: string;
+    CHAT_READ_STATE: string;
+    CHAT_STATE: string;
+    ICE_CANDIDATE: string;
+    ICE_END_OF_CANDIDATES: string;
+    READY_TO_RECEIVE_OFFER: string;
+    REMOTE_CLIENT_MEDIA_REQUEST: string;
+    SDP_ANSWER: string;
+    SDP_OFFER: string;
+    VIDEO_STICKER: string;
+};
+declare const KNOCK_MESSAGES: {
+    actions: {
+        ACCEPT: string;
+        HOLD: string;
+        REJECT: string;
+    };
+    resolutions: {
+        ACCEPTED: string;
+        ON_HOLD: string;
+        REJECTED: string;
+    };
+};
+declare const PROTOCOL_EVENTS: {
+    PENDING_CLIENT_LEFT: string;
+    MEDIA_QUALITY_CHANGED: string;
+};
+
+declare const STREAM_TYPES: {
+    CAMERA: string;
+    SCREEN_SHARE: string;
+};
+declare class RtcStream {
+    id: string;
+    type: string;
+    isEnabled: boolean;
+    hasSupportForAutoSuperSize: boolean;
+    isAudioEnabled: boolean;
+    isVideoEnabled: boolean;
+    status: string;
+    stream: MediaStream | null;
+    streamId: string | null;
+    constructor(id: string | number, type: string);
+    setup(stream: MediaStream): this;
+    setStatus(status: string): this;
+    setVideoEnabled(isEnabled: boolean): void;
+    setAudioEnabled(isEnabled: boolean): void;
+    static getCameraId(): string;
+    static getTypeFromId(id: string): string;
+}
+
+export { type AudioEnabledEvent, BandwidthTester, type ChatMessage, type ClientKickedEvent, type ClientLeftEvent, type ClientMetadataReceivedEvent, type ClientRole, type CloudRecordingStartedEvent, type Credentials, EVENTS, type GetConstraintsOptions, type GetDeviceDataResult, type GetMediaConstraintsOptions, type GetStreamOptions, type GetStreamResult, type GetUpdatedDevicesResult, type IdentifyDeviceRequest, type JoinRoomRequest, KNOCK_MESSAGES, KalmanFilter, type KnockAcceptedEvent, type KnockRejectedEvent, type KnockRoomRequest, type KnockerLeftEvent, Logger, MAXIMUM_TURN_BANDWIDTH, MAXIMUM_TURN_BANDWIDTH_UNLIMITED, MEDIA_JITTER_BUFFER_TARGET, type NewClientEvent, NoDevicesError, P2pRtcManager, PROTOCOL_ERRORS, PROTOCOL_EVENTS, PROTOCOL_REQUESTS, PROTOCOL_RESPONSES, RELAY_MESSAGES, ReconnectManager, type RoomJoinedEvent, type RoomKnockedEvent, type RoomSessionEndedEvent, type RtcClientConnectionStatusChangedPayload, RtcEventNames, type RtcEvents, type RtcLocalStreamTrackAddedPayload, type RtcLocalStreamTrackRemovedPayload, type RtcManager, type RtcManagerCreatedPayload, RtcManagerDispatcher, RtcStream, type RtcStreamAddedPayload, STREAM_TYPES, type ScreenshareStartedEvent, type ScreenshareStoppedEvent, ServerSocket, Session, SfuV2Parser, type SignalClient, type SignalEvents, type SignalKnocker, type SignalRequests, type SocketConf, type SocketManager, TYPES, VegaConnection, VegaMediaQualityMonitor, VegaRtcManager, type VideoEnabledEvent, addAbsCaptureTimeExtMap, addExtMap, assert, buildDeviceList, calculateStd, captureAudioSsrcMetrics, captureCandidatePairInfoMetrics, captureCommonSsrcMetrics, captureSsrcInfo, captureVideoSsrcMetrics, changeMediaDirection, compareLocalDevices, createACFCalculator, createMicAnalyser, createWorker, deprioritizeH264, detectMicrophoneNotWorking, enumerate, filterMidExtension, filterMsidSemantic, fromLocation, generateByteString, getConstraints, getCurrentPeerConnections, getDeviceData, getDisplayMedia, getHandler, getIssuesAndMetrics, getMediaConstraints, getMediaSettings, getOptimalBitrate, getPeerConnectionIndex, getStats, getStream, getStream2, getUpdatedDevices, getUpdatedStats, getUserMedia, hasGetDisplayMedia, ipRegex, isMobile, isRelayed, maybeRejectNoH264, maybeTurnOnly, modifyMediaCapabilities, removePeerConnection, replaceSSRCs, replaceTracksInStream, _default as rtcManagerEvents, rtcStats, setClientProvider, setCodecPreferenceSDP, setPeerConnectionsForTests, setVideoBandwidthUsingSetParameters, standardDeviation, startPerformanceMonitor, stopStreamTracks, subscribeIssues, subscribeStats, variance };