@whereby.com/media 2.8.2 → 2.8.4

package/dist/index.d.ts

@@ -315,252 +315,6 @@ declare function detectMicrophoneNotWorking(pc: any): any;
 
 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;
-    rtcStatsDisconnect(): void;
-    rtcStatsReconnect(): void;
-    replaceTrack(oldTrack: CustomMediaStreamTrack, newTrack: CustomMediaStreamTrack): 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 UnifiedPlanSDP = {
-    sdp: string;
-    sdpU: string;
-    type: RTCSdpType;
-};
-type SDPRelayMessage = {
-    clientId: string;
-    message: UnifiedPlanSDP;
-};
-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 UpdatedDeviceInfo = {
-    deviceId?: string | null;
-    kind?: MediaDeviceKind;
-    label?: string;
-};
-type UpdatedDevicesInfo = {
-    audioinput?: UpdatedDeviceInfo;
-    videoinput?: UpdatedDeviceInfo;
-    audiooutput?: UpdatedDeviceInfo;
-};
-type GetUpdatedDevicesResult = {
-    addedDevices: UpdatedDevicesInfo;
-    changedDevices: UpdatedDevicesInfo;
-    removedDevices: UpdatedDevicesInfo;
-};
-type GetDeviceDataResult = {
-    audio: {
-        deviceId: string;
-        label: string;
-        kind: string;
-    };
-    video: {
-        deviceId: string;
-        label: string;
-        kind: string;
-    };
-};
-interface CustomMediaStreamTrack extends MediaStreamTrack {
-    effectTrack?: boolean;
-    replaced?: boolean;
-}
-
-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 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: MediaDeviceInfo[], after: MediaDeviceInfo[]): any;
-declare function getUpdatedDevices({ oldDevices, newDevices, currentAudioId, currentVideoId, currentSpeakerId, }: {
-    oldDevices: MediaDeviceInfo[];
-    newDevices: MediaDeviceInfo[];
-    currentAudioId?: string | undefined;
-    currentVideoId?: string | undefined;
-    currentSpeakerId?: string | undefined;
-}): GetUpdatedDevicesResult;
-
-interface P2PSessionOptions {
-    peerConnectionId: string;
-    clientId: string;
-    bandwidth: number;
-    peerConnectionConfig: RTCConfiguration;
-    deprioritizeH264Encoding: boolean;
-    shouldAddLocalVideo: boolean;
-    incrementAnalyticMetric: P2PIncrementAnalyticMetric;
-}
-declare class Session {
-    peerConnectionId: any;
-    relayCandidateSeen: boolean;
-    serverReflexiveCandidateSeen: boolean;
-    publicHostCandidateSeen: boolean;
-    ipv6HostCandidateSeen: boolean;
-    ipv6HostCandidateTeredoSeen: boolean;
-    ipv6HostCandidate6to4Seen: boolean;
-    mdnsHostCandidateSeen: boolean;
-    pc: RTCPeerConnection;
-    wasEverConnected: boolean;
-    connectionStatus: any;
-    stats: {
-        totalSent: number;
-        totalRecv: number;
-    };
-    bandwidth: any;
-    pending: any[];
-    isOperationPending: boolean;
-    streamIds: any[];
-    streams: MediaStream[];
-    earlyIceCandidates: any[];
-    afterConnected: Promise<unknown>;
-    registerConnected: any;
-    offerOptions: {
-        offerToReceiveAudio: boolean;
-        offerToReceiveVideo: boolean;
-    };
-    _deprioritizeH264Encoding: any;
-    clientId: any;
-    peerConnectionConfig: RTCConfiguration;
-    shouldAddLocalVideo: boolean;
-    signalingState: any;
-    srdComplete: any;
-    _incrementAnalyticMetric: P2PIncrementAnalyticMetric;
-    constructor({ peerConnectionId, clientId, bandwidth, peerConnectionConfig, deprioritizeH264Encoding, shouldAddLocalVideo, incrementAnalyticMetric, }: P2PSessionOptions);
-    addStream(stream: MediaStream): void;
-    addTrack(track: MediaStreamTrack, stream?: MediaStream): void;
-    removeTrack(track: MediaStreamTrack): void;
-    removeStream(stream: MediaStream): void;
-    _setRemoteDescription(desc: any): any;
-    handleOffer(message: RTCSessionDescription): any;
-    handleAnswer(message: RTCSessionDescription): any;
-    addIceCandidate(candidate: any): void;
-    canModifyPeerConnection(): boolean;
-    close(): void;
-    hasConnectedPeerConnection(): boolean;
-    replaceTrack(oldTrack: CustomMediaStreamTrack | undefined, newTrack: CustomMediaStreamTrack | undefined): false | RTCRtpSender | Promise<CustomMediaStreamTrack>;
-    changeBandwidth(bandwidth: any): void;
-    setAudioOnly(enable: boolean, excludedTrackIds?: string[]): void;
-}
-
 declare const assert: {
     fail: (message?: string | Error) => void;
     ok: (value: any, message?: string | Error) => void;
@@ -946,23 +700,33 @@ interface ForbiddenError {
     error: ForbiddenErrorNames;
 }
 type RoomJoinedErrors = RoomLockedError | RoomFullError | RoomConcurrencyControlsError | CannotJoinUnclaimedRoomError | OrganizationPlanExhaustedError | RoomMeetingTimeExhaustedError | MaxViewerLimitReachedError | HostPresenceControlsError | ForbiddenError | InternalServerError | InvalidAssistantKeyError | OrganizationAssistantNotFoundError | OrganizationAssistantNotEnabledError;
-interface RoomJoinedSuccess {
-    room: {
-        mode: RoomMode;
-        isClaimed: boolean;
-        isLocked: boolean;
-        clients: SignalClient[];
-        knockers: SignalKnocker[];
-        spotlights: Spotlight[];
-        session: {
-            createdAt: string;
-            id: string;
-        } | null;
+type SignalRoom = {
+    clients: SignalClient[];
+    iceServers: {
+        iceServers: SignalIceServer[];
     };
+    isClaimed: boolean;
+    isLocked: boolean;
+    knockers: SignalKnocker[];
+    mediaserverConfigTtlSeconds: number;
+    mode: RoomMode;
+    name: string;
+    organizationId: string;
+    spotlights: Spotlight[];
+    session: {
+        createdAt: string;
+        id: string;
+    } | null;
+    sfuServer?: SignalSFUServer;
+    turnServers: SignalTurnServer[];
+};
+interface RoomJoinedSuccess {
+    room: SignalRoom;
     selfId: string;
     breakoutGroup?: string | null;
     clientClaim: string;
     breakout?: BreakoutConfig;
+    eventClaim: string;
 }
 type RoomJoinedEvent = RoomJoinedErrors | RoomJoinedSuccess;
 interface BreakoutSessionUpdatedEvent extends BreakoutConfig {
@@ -1116,67 +880,345 @@ interface RemoveSpotlightRequest {
     clientId: string;
     streamId: string;
 }
-interface SignalRequests {
-    add_spotlight: AddSpotlightRequest;
-    chat_message: {
-        text: string;
-    };
-    enable_audio: {
-        enabled: boolean;
+interface SignalRequests {
+    add_spotlight: AddSpotlightRequest;
+    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;
+    remove_spotlight: RemoveSpotlightRequest;
+    request_audio_enable: AudioEnableRequest;
+    request_video_enable: VideoEnableRequest;
+    send_client_metadata: {
+        type: string;
+        payload: {
+            displayName?: string;
+            stickyReaction?: unknown;
+        };
+    };
+    set_lock: {
+        locked: boolean;
+    };
+    start_recording: {
+        recording: string;
+    };
+    stop_recording: void;
+}
+type TurnTransportProtocol = "onlyudp" | "onlytcp" | "onlytls";
+
+declare function fromLocation({ host, protocol }?: {
+    host?: string | undefined;
+    protocol?: string | undefined;
+}): {
+    domain: string;
+    domainWithSeparator: string;
+    organizationDomain: string;
+    organization: string;
+    service: string;
+    subdomain: string;
+};
+
+type TrackAnnotation = {
+    fromGetDisplayMedia: boolean;
+};
+declare function trackAnnotations(o: MediaStreamTrack): TrackAnnotation;
+
+declare enum RtcEventNames {
+    rtc_manager_created = "rtc_manager_created",
+    stream_added = "stream_added"
+}
+type RtcEventEmitter = {
+    emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K]) => void;
+};
+interface RtcManagerOptions {
+    selfId: string;
+    room: SignalRoom;
+    emitter: RtcEventEmitter;
+    serverSocket: ServerSocket;
+    webrtcProvider: any;
+    features: any;
+}
+interface VegaRtcManagerOptions extends RtcManagerOptions {
+    eventClaim: string;
+}
+interface RtcManager {
+    acceptNewStream: ({ clientId, streamId }: {
+        clientId: string;
+        streamId: string;
+    }) => void;
+    addNewStream(streamId: string, stream: MediaStream, isAudioEnabled: boolean, isVideoEnabled: boolean): void;
+    disconnect(streamId: string, eventClaim?: string): void;
+    disconnectAll(): void;
+    rtcStatsDisconnect(): void;
+    rtcStatsReconnect(): void;
+    replaceTrack(oldTrack: CustomMediaStreamTrack, newTrack: CustomMediaStreamTrack): 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 UnifiedPlanSDP = {
+    sdp: string;
+    sdpU: string;
+    type: RTCSdpType;
+};
+type SDPRelayMessage = {
+    clientId: string;
+    message: UnifiedPlanSDP;
+};
+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;
+        };
     };
-    enable_video: {
-        enabled: boolean;
+    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 UpdatedDeviceInfo = {
+    deviceId?: string | null;
+    kind?: MediaDeviceKind;
+    label?: string;
+};
+type UpdatedDevicesInfo = {
+    audioinput?: UpdatedDeviceInfo;
+    videoinput?: UpdatedDeviceInfo;
+    audiooutput?: UpdatedDeviceInfo;
+};
+type GetUpdatedDevicesResult = {
+    addedDevices: UpdatedDevicesInfo;
+    changedDevices: UpdatedDevicesInfo;
+    removedDevices: UpdatedDevicesInfo;
+};
+type GetDeviceDataResult = {
+    audio: {
+        deviceId: string;
+        label: string;
+        kind: string;
     };
-    handle_knock: {
-        action: "accept" | "reject";
-        clientId: string;
-        response: unknown;
+    video: {
+        deviceId: string;
+        label: string;
+        kind: string;
     };
-    identify_device: IdentifyDeviceRequest;
-    join_room: JoinRoomRequest;
-    knock_room: KnockRoomRequest;
-    leave_room: void;
-    remove_spotlight: RemoveSpotlightRequest;
-    request_audio_enable: AudioEnableRequest;
-    request_video_enable: VideoEnableRequest;
-    send_client_metadata: {
-        type: string;
-        payload: {
-            displayName?: string;
-            stickyReaction?: unknown;
+};
+interface CustomMediaStreamTrack extends MediaStreamTrack {
+    effectTrack?: boolean;
+    replaced?: boolean;
+}
+type SignalIceServer = {
+    credential: string;
+    url: string;
+    urls: string[];
+    username: string;
+};
+type SignalTurnServer = {
+    credential: string;
+    urls: string | string[];
+    username: string;
+};
+type SignalMediaServerConfig = {
+    error?: any;
+    mediaserverConfigTtlSeconds: number;
+    iceServers: SignalIceServer[];
+    turnServers: SignalTurnServer[];
+    sfuServer?: SignalSFUServer;
+};
+type SignalSFUServer = {
+    url: string;
+    fallbackUrl?: string;
+    fallbackServers?: any[];
+};
+
+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 getStream(constraintOpt: any, { replaceStream, fallback }?: GetStreamOptions): Promise<GetStreamResult>;
+declare function hasGetDisplayMedia(): boolean;
+declare function getDisplayMedia(constraints?: {
+    video: {
+        width: {
+            max: number;
+        };
+        height: {
+            max: number;
         };
     };
-    set_lock: {
-        locked: boolean;
+}, contentHint?: string): Promise<MediaStream>;
+declare function compareLocalDevices(before: MediaDeviceInfo[], after: MediaDeviceInfo[]): any;
+declare function getUpdatedDevices({ oldDevices, newDevices, currentAudioId, currentVideoId, currentSpeakerId, }: {
+    oldDevices: MediaDeviceInfo[];
+    newDevices: MediaDeviceInfo[];
+    currentAudioId?: string | undefined;
+    currentVideoId?: string | undefined;
+    currentSpeakerId?: string | undefined;
+}): GetUpdatedDevicesResult;
+
+interface P2PSessionOptions {
+    peerConnectionId: string;
+    clientId: string;
+    bandwidth: number;
+    peerConnectionConfig: RTCConfiguration;
+    deprioritizeH264Encoding: boolean;
+    incrementAnalyticMetric: P2PIncrementAnalyticMetric;
+}
+declare class Session {
+    peerConnectionId: any;
+    relayCandidateSeen: boolean;
+    serverReflexiveCandidateSeen: boolean;
+    publicHostCandidateSeen: boolean;
+    ipv6HostCandidateSeen: boolean;
+    ipv6HostCandidateTeredoSeen: boolean;
+    ipv6HostCandidate6to4Seen: boolean;
+    mdnsHostCandidateSeen: boolean;
+    pc: RTCPeerConnection;
+    wasEverConnected: boolean;
+    connectionStatus: any;
+    stats: {
+        totalSent: number;
+        totalRecv: number;
     };
-    start_recording: {
-        recording: string;
+    bandwidth: any;
+    pending: any[];
+    isOperationPending: boolean;
+    streamIds: string[];
+    streams: MediaStream[];
+    earlyIceCandidates: any[];
+    afterConnected: Promise<unknown>;
+    registerConnected: any;
+    offerOptions: {
+        offerToReceiveAudio: boolean;
+        offerToReceiveVideo: boolean;
     };
-    stop_recording: void;
+    _deprioritizeH264Encoding: any;
+    clientId: any;
+    peerConnectionConfig: RTCConfiguration;
+    signalingState: any;
+    srdComplete: any;
+    _incrementAnalyticMetric: P2PIncrementAnalyticMetric;
+    constructor({ peerConnectionId, clientId, bandwidth, peerConnectionConfig, deprioritizeH264Encoding, incrementAnalyticMetric, }: P2PSessionOptions);
+    addStream(stream: MediaStream): void;
+    addTrack(track: MediaStreamTrack, stream?: MediaStream): void;
+    removeTrack(track: MediaStreamTrack): void;
+    removeStream(stream: MediaStream): void;
+    _setRemoteDescription(desc: any): any;
+    handleOffer(message: RTCSessionDescription): any;
+    handleAnswer(message: RTCSessionDescription): any;
+    addIceCandidate(candidate: any): void;
+    canModifyPeerConnection(): boolean;
+    close(): void;
+    hasConnectedPeerConnection(): boolean;
+    replaceTrack(oldTrack: CustomMediaStreamTrack | undefined, newTrack: CustomMediaStreamTrack | undefined): false | RTCRtpSender | Promise<CustomMediaStreamTrack>;
+    changeBandwidth(bandwidth: any): void;
+    setAudioOnly(enable: boolean, excludedTrackIds?: string[]): void;
 }
-type TurnTransportProtocol = "onlyudp" | "onlytcp" | "onlytls";
-
-declare function fromLocation({ host, protocol }?: {
-    host?: string | undefined;
-    protocol?: string | undefined;
-}): {
-    domain: string;
-    domainWithSeparator: string;
-    organizationDomain: string;
-    organization: string;
-    service: string;
-    subdomain: string;
-};
-
-type TrackAnnotation = {
-    fromGetDisplayMedia: boolean;
-};
-declare function trackAnnotations(o: MediaStreamTrack): TrackAnnotation;
 
 interface GetOrCreateSessionOptions {
     peerConnectionId: string;
     clientId: string;
-    shouldAddLocalVideo: boolean;
     initialBandwidth: number;
     peerConnectionConfig: RTCConfiguration;
 }
@@ -1237,7 +1279,6 @@ declare class P2pRtcManager implements RtcManager {
     _videoTrackOnEnded: () => void;
     _iceServers: any;
     _turnServers: any;
-    _sfuServer: any;
     _mediaserverConfigTtlSeconds: any;
     _fetchMediaServersTimer: any;
     _wasScreenSharing: any;
@@ -1249,19 +1290,12 @@ declare class P2pRtcManager implements RtcManager {
     skipEmittingServerMessageCount: number;
     analytics: P2PAnalytics;
     _rtcStatsDisconnectTimeout?: ReturnType<typeof setTimeout>;
-    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features, }: {
-        selfId: any;
-        room: any;
-        emitter: any;
-        serverSocket: ServerSocket;
-        webrtcProvider: any;
-        features: any;
-    });
+    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features }: RtcManagerOptions);
     numberOfPeerconnections(): number;
     isInitializedWith({ selfId, roomName, isSfu }: {
-        selfId: any;
-        roomName: any;
-        isSfu: any;
+        selfId: string;
+        roomName: string;
+        isSfu: boolean;
     }): boolean;
     supportsScreenShareAudio(): boolean;
     addNewStream(streamId: string, stream: MediaStream, audioPaused: boolean, videoPaused: boolean, beforeEffectTracks?: CustomMediaStreamTrack[]): void;
@@ -1285,19 +1319,18 @@ declare class P2pRtcManager implements RtcManager {
     _addEnabledLocalStreamId(streamId: string): void;
     _deleteEnabledLocalStreamId(streamId: string): void;
     _getSession(peerConnectionId: string): Session | null;
-    _getOrCreateSession({ peerConnectionId, clientId, initialBandwidth, peerConnectionConfig, shouldAddLocalVideo, }: GetOrCreateSessionOptions): Session;
+    _getOrCreateSession({ peerConnectionId, clientId, initialBandwidth, peerConnectionConfig, }: GetOrCreateSessionOptions): Session;
     _getLocalCameraStream(): any;
     _getNonLocalCameraStreamIds(): string[];
     _isScreensharingLocally(): boolean;
     _getFirstLocalNonCameraStream(): any;
     _transformIncomingSdp(original: UnifiedPlanSDP): RTCSessionDescription;
     _transformOutgoingSdp(original: RTCSessionDescription): UnifiedPlanSDP;
-    _createSession({ clientId, initialBandwidth, isOfferer, peerConnectionId, shouldAddLocalVideo, }: {
+    _createSession({ clientId, initialBandwidth, isOfferer, peerConnectionId, }: {
         clientId: string;
         initialBandwidth: any;
         isOfferer: any;
         peerConnectionId: string;
-        shouldAddLocalVideo: boolean;
     }): Session;
     _cleanup(peerConnectionId: string): void;
     _forEachPeerConnection(func: any): void;
@@ -1308,7 +1341,7 @@ declare class P2pRtcManager implements RtcManager {
     _removeTrackFromPeerConnections(track: any): void;
     _addLocalStream(streamId: string, stream: any): void;
     _removeLocalStream(streamId: string): void;
-    _updateAndScheduleMediaServersRefresh({ iceServers, turnServers, sfuServer, mediaserverConfigTtlSeconds }: any): void;
+    _updateAndScheduleMediaServersRefresh({ iceServers, turnServers, mediaserverConfigTtlSeconds, }: SignalMediaServerConfig): void;
     _clearMediaServersRefresh(): void;
     _monitorAudioTrack(track: any): void;
     _monitorVideoTrack(track: CustomMediaStreamTrack): void;
@@ -1318,16 +1351,14 @@ declare class P2pRtcManager implements RtcManager {
     _negotiatePeerConnection(clientId: string, session: any, constraints?: any): void;
     _withForcedRenegotiation(session: Session, action: any): void;
     _changeBandwidthForAllClients(isJoining: boolean): number;
-    _createP2pSession({ clientId, initialBandwidth, shouldAddLocalVideo, isOfferer, }: {
+    _createP2pSession({ clientId, initialBandwidth, isOfferer, }: {
         clientId: string;
         initialBandwidth: number;
-        shouldAddLocalVideo: boolean;
         isOfferer: boolean;
     }): Session;
-    acceptNewStream({ streamId, clientId, shouldAddLocalVideo, }: {
+    acceptNewStream({ streamId, clientId }: {
         streamId: string;
         clientId: string;
-        shouldAddLocalVideo?: boolean;
     }): Session;
     disconnect(clientId: string): void;
     updateStreamResolution(): void;
@@ -1340,6 +1371,7 @@ declare class P2pRtcManager implements RtcManager {
     _shareScreen(streamId: string, stream: any): void;
     removeStream(streamId: string, stream: any, requestedByClientId: any): void;
     hasClient(clientId: string): boolean;
+    shouldAcceptStreamsFromBothSides(): boolean;
 }
 
 declare class RtcManagerDispatcher {
@@ -1348,9 +1380,7 @@ declare class RtcManagerDispatcher {
     };
     currentManager: RtcManager | null;
     constructor({ emitter, serverSocket, webrtcProvider, features, }: {
-        emitter: {
-            emit: <K extends keyof RtcEvents>(eventName: K, args?: RtcEvents[K]) => void;
-        };
+        emitter: RtcEventEmitter;
         serverSocket: ServerSocket;
         webrtcProvider: any;
         features: any;
@@ -1621,7 +1651,7 @@ declare class VegaRtcManager implements RtcManager {
     _fetchMediaServersTimer: any;
     _iceServers: any;
     _turnServers: any;
-    _sfuServer: any;
+    _sfuServer?: SignalSFUServer;
     _sfuServers?: HostListEntryOptionalDC[];
     _mediaserverConfigTtlSeconds: any;
     _videoTrackBeingMonitored?: CustomMediaStreamTrack;
@@ -1631,22 +1661,8 @@ declare class VegaRtcManager implements RtcManager {
     _networkIsDetectedUpBySignal: boolean;
     _cpuOveruseDetected: boolean;
     analytics: VegaAnalytics;
-    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features, eventClaim, }: {
-        selfId: any;
-        room: any;
-        emitter: any;
-        serverSocket: any;
-        webrtcProvider: any;
-        features?: any;
-        eventClaim?: string;
-    });
-    _updateAndScheduleMediaServersRefresh({ iceServers, turnServers, sfuServer, sfuServers, mediaserverConfigTtlSeconds, }: {
-        iceServers: any;
-        turnServers: any;
-        sfuServer: any;
-        sfuServers: any;
-        mediaserverConfigTtlSeconds: any;
-    }): void;
+    constructor({ selfId, room, emitter, serverSocket, webrtcProvider, features, eventClaim }: VegaRtcManagerOptions);
+    _updateAndScheduleMediaServersRefresh({ iceServers, turnServers, sfuServer, mediaserverConfigTtlSeconds, }: SignalMediaServerConfig): void;
     _clearMediaServersRefresh(): void;
     _onNetworkIsDetectedUpBySignal(): void;
     _onNetworkIsDetectedPossiblyDownBySignal(): void;
@@ -1687,7 +1703,7 @@ declare class VegaRtcManager implements RtcManager {
     setAudioOnly(audioOnly: boolean): void;
     setRemoteScreenshareVideoTrackIds(): void;
     setRoomSessionId(roomSessionId: string): void;
-    disconnect(clientIdOrStreamId: string, _activeBreakout: any, eventClaim?: string): void;
+    disconnect(clientId: string, eventClaim?: string): void;
     replaceTrack(oldTrack: CustomMediaStreamTrack | null, track: CustomMediaStreamTrack): void;
     removeStream(streamId: string, _stream: MediaStream, requestedByClientId: string): void;
     _onMicAnalyserScoreUpdated(data: any): void;
@@ -1901,27 +1917,11 @@ declare const PROTOCOL_EVENTS: {
     MEDIA_QUALITY_CHANGED: string;
 };
 
+declare const CAMERA_STREAM_ID = "0";
 declare const STREAM_TYPES: {
-    CAMERA: string;
-    SCREEN_SHARE: string;
+    webcam: string;
+    screenshare: 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;
-}
 
-export { ADDITIONAL_SCREEN_SHARE_SETTINGS, AUDIO_SETTINGS, BandwidthTester, EVENTS, KNOCK_MESSAGES, KalmanFilter, Logger, MEDIA_JITTER_BUFFER_TARGET, NoDevicesError, P2pRtcManager, PROTOCOL_ERRORS, PROTOCOL_EVENTS, PROTOCOL_REQUESTS, PROTOCOL_RESPONSES, RELAY_MESSAGES, ReconnectManager, RtcEventNames, RtcManagerDispatcher, RtcStream, SCREEN_SHARE_SETTINGS, SCREEN_SHARE_SIMULCAST_SETTINGS, STREAM_TYPES, ServerSocket, Session, SfuV2Parser, TYPES, VIDEO_SETTINGS_HD, VIDEO_SETTINGS_SD, VIDEO_SETTINGS_VP9, VIDEO_SETTINGS_VP9_LOW_BANDWIDTH, VegaConnection, VegaMediaQualityMonitor, VegaRtcManager, addAbsCaptureTimeExtMap, addExtMap, assert, buildDeviceList, calculateStd, captureAudioSsrcMetrics, captureCandidatePairInfoMetrics, captureCommonSsrcMetrics, captureSsrcInfo, captureVideoSsrcMetrics, changeMediaDirection, cleanSdp, compareLocalDevices, createACFCalculator, createMicAnalyser, createWorker, deprioritizeH264, detectMicrophoneNotWorking, enumerate, external_stun_servers, filterMidExtension, filterMsidSemantic, fromLocation, generateByteString, getConstraints, getCurrentPeerConnections, getDeviceData, getDisplayMedia, getIssuesAndMetrics, getMediaConstraints, getMediaSettings, getMediasoupDeviceAsync, getNumFailedStatsReports, getNumFailedTrackSsrcLookups, getNumMissingTrackSsrcLookups, getPeerConnectionIndex, getStats, getStream, getUpdatedDevices, getUpdatedStats, getUserMedia, hasGetDisplayMedia, ipRegex, isMobile, issueDetectorOrMetricEnabled, maybeRejectNoH264, maybeTurnOnly, modifyMediaCapabilities, removePeerConnection, replaceTracksInStream, _default as rtcManagerEvents, rtcStats, setClientProvider, setCodecPreferenceSDP, setPeerConnectionsForTests, setVideoBandwidthUsingSetParameters, sortCodecs, standardDeviation, startPerformanceMonitor, stopStreamTracks, subscribeIssues, subscribeStats, trackAnnotations, turnServerOverride, variance };
-export type { AddSpotlightRequest, AudioEnableRequest, AudioEnableRequestedEvent, AudioEnabledEvent, BreakoutConfig, BreakoutGroupJoinedEvent, BreakoutSessionUpdatedEvent, CannotJoinUnclaimedRoomError, ChatMessage, ClientKickedEvent, ClientLeftEvent, ClientMetadataPayload, ClientMetadataReceivedEvent, ClientRole, ClientUnableToJoinEvent, CloudRecordingStartedEvent, Codec, Credentials, CustomMediaStreamTrack, ForbiddenError, ForbiddenErrorNames, GetConstraintsOptions, GetDeviceDataResult, GetMediaConstraintsOptions, GetStreamOptions, GetStreamResult, GetUpdatedDevicesResult, HostPresenceControlsError, IdentifyDeviceRequest, InternalServerError, InvalidAssistantKeyError, IssuesAndMetricsByView, JoinRoomRequest, KnockAcceptedEvent, KnockRejectedEvent, KnockRoomRequest, KnockerLeftEvent, LiveTranscriptionStartedEvent, LiveTranscriptionStoppedEvent, MaxViewerLimitReachedError, Metric, NewClientEvent, OrganizationAssistantNotEnabledError, OrganizationAssistantNotFoundError, OrganizationPlanExhaustedError, RemoveSpotlightRequest, RoleName, RoomConcurrencyControlsError, RoomFullError, RoomJoinedErrors, RoomJoinedEvent, RoomJoinedSuccess, RoomKnockedEvent, RoomLockedError, RoomLockedEvent, RoomMeetingTimeExhaustedError, RoomMode, RoomSessionEndedEvent, RtcClientConnectionStatusChangedPayload, RtcEvents, RtcLocalStreamTrackAddedPayload, RtcLocalStreamTrackRemovedPayload, RtcManager, RtcManagerCreatedPayload, RtcStreamAddedPayload, SDPRelayMessage, ScreenshareStartedEvent, ScreenshareStoppedEvent, SendClientMetadataRequest, SignalClient, SignalEvents, SignalKnocker, SignalRequests, SocketConf, SocketManager, Spotlight, SpotlightAddedEvent, SpotlightRemovedEvent, StatsMonitorOptions, StatsMonitorState, StatsSubscription, TurnTransportProtocol, UnifiedPlanSDP, UpdatedDeviceInfo, UpdatedDevicesInfo, VideoEnableRequest, VideoEnableRequestedEvent, VideoEnabledEvent };
+export { ADDITIONAL_SCREEN_SHARE_SETTINGS, AUDIO_SETTINGS, BandwidthTester, CAMERA_STREAM_ID, EVENTS, KNOCK_MESSAGES, KalmanFilter, Logger, MEDIA_JITTER_BUFFER_TARGET, NoDevicesError, P2pRtcManager, PROTOCOL_ERRORS, PROTOCOL_EVENTS, PROTOCOL_REQUESTS, PROTOCOL_RESPONSES, RELAY_MESSAGES, ReconnectManager, RtcEventNames, RtcManagerDispatcher, SCREEN_SHARE_SETTINGS, SCREEN_SHARE_SIMULCAST_SETTINGS, STREAM_TYPES, ServerSocket, Session, SfuV2Parser, TYPES, VIDEO_SETTINGS_HD, VIDEO_SETTINGS_SD, VIDEO_SETTINGS_VP9, VIDEO_SETTINGS_VP9_LOW_BANDWIDTH, VegaConnection, VegaMediaQualityMonitor, VegaRtcManager, addAbsCaptureTimeExtMap, addExtMap, assert, buildDeviceList, calculateStd, captureAudioSsrcMetrics, captureCandidatePairInfoMetrics, captureCommonSsrcMetrics, captureSsrcInfo, captureVideoSsrcMetrics, changeMediaDirection, cleanSdp, compareLocalDevices, createACFCalculator, createMicAnalyser, createWorker, deprioritizeH264, detectMicrophoneNotWorking, enumerate, external_stun_servers, filterMidExtension, filterMsidSemantic, fromLocation, generateByteString, getConstraints, getCurrentPeerConnections, getDeviceData, getDisplayMedia, getIssuesAndMetrics, getMediaConstraints, getMediaSettings, getMediasoupDeviceAsync, getNumFailedStatsReports, getNumFailedTrackSsrcLookups, getNumMissingTrackSsrcLookups, getPeerConnectionIndex, getStats, getStream, getUpdatedDevices, getUpdatedStats, getUserMedia, hasGetDisplayMedia, ipRegex, isMobile, issueDetectorOrMetricEnabled, maybeRejectNoH264, maybeTurnOnly, modifyMediaCapabilities, removePeerConnection, replaceTracksInStream, _default as rtcManagerEvents, rtcStats, setClientProvider, setCodecPreferenceSDP, setPeerConnectionsForTests, setVideoBandwidthUsingSetParameters, sortCodecs, standardDeviation, startPerformanceMonitor, stopStreamTracks, subscribeIssues, subscribeStats, trackAnnotations, turnServerOverride, variance };
+export type { AddSpotlightRequest, AudioEnableRequest, AudioEnableRequestedEvent, AudioEnabledEvent, BreakoutConfig, BreakoutGroupJoinedEvent, BreakoutSessionUpdatedEvent, CannotJoinUnclaimedRoomError, ChatMessage, ClientKickedEvent, ClientLeftEvent, ClientMetadataPayload, ClientMetadataReceivedEvent, ClientRole, ClientUnableToJoinEvent, CloudRecordingStartedEvent, Codec, Credentials, CustomMediaStreamTrack, ForbiddenError, ForbiddenErrorNames, GetConstraintsOptions, GetDeviceDataResult, GetMediaConstraintsOptions, GetStreamOptions, GetStreamResult, GetUpdatedDevicesResult, HostPresenceControlsError, IdentifyDeviceRequest, InternalServerError, InvalidAssistantKeyError, IssuesAndMetricsByView, JoinRoomRequest, KnockAcceptedEvent, KnockRejectedEvent, KnockRoomRequest, KnockerLeftEvent, LiveTranscriptionStartedEvent, LiveTranscriptionStoppedEvent, MaxViewerLimitReachedError, Metric, NewClientEvent, OrganizationAssistantNotEnabledError, OrganizationAssistantNotFoundError, OrganizationPlanExhaustedError, RemoveSpotlightRequest, RoleName, RoomConcurrencyControlsError, RoomFullError, RoomJoinedErrors, RoomJoinedEvent, RoomJoinedSuccess, RoomKnockedEvent, RoomLockedError, RoomLockedEvent, RoomMeetingTimeExhaustedError, RoomMode, RoomSessionEndedEvent, RtcClientConnectionStatusChangedPayload, RtcEventEmitter, RtcEvents, RtcLocalStreamTrackAddedPayload, RtcLocalStreamTrackRemovedPayload, RtcManager, RtcManagerCreatedPayload, RtcManagerOptions, RtcStreamAddedPayload, SDPRelayMessage, ScreenshareStartedEvent, ScreenshareStoppedEvent, SendClientMetadataRequest, SignalClient, SignalEvents, SignalIceServer, SignalKnocker, SignalMediaServerConfig, SignalRequests, SignalRoom, SignalSFUServer, SignalTurnServer, SocketConf, SocketManager, Spotlight, SpotlightAddedEvent, SpotlightRemovedEvent, StatsMonitorOptions, StatsMonitorState, StatsSubscription, TurnTransportProtocol, UnifiedPlanSDP, UpdatedDeviceInfo, UpdatedDevicesInfo, VegaRtcManagerOptions, VideoEnableRequest, VideoEnableRequestedEvent, VideoEnabledEvent };