@whereby.com/media 2.8.3 → 2.8.5

package/dist/index.d.ts

@@ -315,248 +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: ({ 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;
-        };
-    };
-    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;
-    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: string[];
-    streams: MediaStream[];
-    earlyIceCandidates: any[];
-    afterConnected: Promise<unknown>;
-    registerConnected: any;
-    offerOptions: {
-        offerToReceiveAudio: boolean;
-        offerToReceiveVideo: boolean;
-    };
-    _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;
-}
-
 declare const assert: {
     fail: (message?: string | Error) => void;
     ok: (value: any, message?: string | Error) => void;
@@ -942,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 {
@@ -1169,6 +937,284 @@ type TrackAnnotation = {
 };
 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 RTCSessionDescription = {
+    sdp: string;
+    type: RTCSdpType;
+};
+type SDPRelayMessage = {
+    clientId: string;
+    message: RTCSessionDescription;
+};
+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;
+}
+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;
+        };
+    };
+}, 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;
+    };
+    bandwidth: any;
+    pending: any[];
+    isOperationPending: boolean;
+    streamIds: string[];
+    streams: MediaStream[];
+    earlyIceCandidates: any[];
+    afterConnected: Promise<unknown>;
+    registerConnected: any;
+    offerOptions: {
+        offerToReceiveAudio: boolean;
+        offerToReceiveVideo: boolean;
+    };
+    _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: RTCSessionDescription): Promise<void>;
+    handleOffer(offer: RTCSessionDescription): Promise<RTCSessionDescription>;
+    handleAnswer(message: RTCSessionDescription): Promise<void>;
+    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;
+}
+
 interface GetOrCreateSessionOptions {
     peerConnectionId: string;
     clientId: string;
@@ -1205,6 +1251,9 @@ type P2PAnalytics = {
     P2PReplaceTrackSourceKindNotFound: number;
     P2PRemoveStreamNoPC: number;
     P2POnTrackNoStream: number;
+    P2PSetCodecPreferenceError: number;
+    P2PCreateOfferNoSDP: number;
+    P2PCreateAnswerNoSDP: number;
 };
 type P2PAnalyticMetric = keyof P2PAnalytics;
 type P2PIncrementAnalyticMetric = (metric: P2PAnalyticMetric) => void;
@@ -1232,7 +1281,6 @@ declare class P2pRtcManager implements RtcManager {
     _videoTrackOnEnded: () => void;
     _iceServers: any;
     _turnServers: any;
-    _sfuServer: any;
     _mediaserverConfigTtlSeconds: any;
     _fetchMediaServersTimer: any;
     _wasScreenSharing: any;
@@ -1244,19 +1292,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,8 +1326,6 @@ declare class P2pRtcManager implements RtcManager {
     _getNonLocalCameraStreamIds(): string[];
     _isScreensharingLocally(): boolean;
     _getFirstLocalNonCameraStream(): any;
-    _transformIncomingSdp(original: UnifiedPlanSDP): RTCSessionDescription;
-    _transformOutgoingSdp(original: RTCSessionDescription): UnifiedPlanSDP;
     _createSession({ clientId, initialBandwidth, isOfferer, peerConnectionId, }: {
         clientId: string;
         initialBandwidth: any;
@@ -1302,14 +1341,14 @@ 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;
     _connect(clientId: string): Promise<Session>;
     _maybeRestartIce(clientId: string, session: any): void;
     _setCodecPreferences(pc: RTCPeerConnection): Promise<void>;
-    _negotiatePeerConnection(clientId: string, session: any, constraints?: any): void;
+    _negotiatePeerConnection(clientId: string, session: Session, constraints?: any): void;
     _withForcedRenegotiation(session: Session, action: any): void;
     _changeBandwidthForAllClients(isJoining: boolean): number;
     _createP2pSession({ clientId, initialBandwidth, isOfferer, }: {
@@ -1341,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;
@@ -1365,7 +1402,7 @@ declare const _default: {
     DOMINANT_SPEAKER: string;
 };
 
-declare function setVideoBandwidthUsingSetParameters(pc: any, bandwidth: any, logger?: any): any;
+declare function setVideoBandwidthUsingSetParameters(pc: RTCPeerConnection, bandwidth: number, logger?: any): Promise<void>;
 
 declare const rtcStats: {
     sendEvent: (type: any, value: any) => void;
@@ -1380,7 +1417,12 @@ declare const rtcStats: {
     };
 };
 
-declare function setCodecPreferenceSDP(sdp: any, redOn?: boolean): string | undefined;
+interface SetCodecPreferenceSDPOptions {
+    sdp: string;
+    redOn: boolean;
+    incrementAnalyticMetric: P2PIncrementAnalyticMetric;
+}
+declare function setCodecPreferenceSDP({ sdp, redOn, incrementAnalyticMetric }: SetCodecPreferenceSDPOptions): string;
 declare function cleanSdp(sdp: string): string;
 declare function maybeRejectNoH264(sdp: any): any;
 declare function deprioritizeH264(sdp: any): string;
@@ -1614,7 +1656,7 @@ declare class VegaRtcManager implements RtcManager {
     _fetchMediaServersTimer: any;
     _iceServers: any;
     _turnServers: any;
-    _sfuServer: any;
+    _sfuServer?: SignalSFUServer;
     _sfuServers?: HostListEntryOptionalDC[];
     _mediaserverConfigTtlSeconds: any;
     _videoTrackBeingMonitored?: CustomMediaStreamTrack;
@@ -1624,22 +1666,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;
@@ -1901,4 +1929,4 @@ declare const STREAM_TYPES: {
 };
 
 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, 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 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, RTCSessionDescription, 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, UpdatedDeviceInfo, UpdatedDevicesInfo, VegaRtcManagerOptions, VideoEnableRequest, VideoEnableRequestedEvent, VideoEnabledEvent };