sip-connector 19.8.3 → 20.0.0

package/dist/ApiManager/@ApiManager.d.ts

@@ -58,6 +58,5 @@ declare class ApiManager {
     private readonly triggerMainCamControl;
     private readonly triggerMicControl;
     private readonly triggerUseLicense;
-    private readonly triggerRestart;
 }
 export default ApiManager;

package/dist/ApiManager/constants.d.ts

@@ -26,7 +26,8 @@ export declare enum EHeader {
     AVAILABLE_INCOMING_BITRATE = "X-WEBRTC-AVAILABLE-INCOMING-BITRATE",
     AUDIO_TRACK_COUNT = "X-WEBRTC-AUDIO-TRACK-COUNT",
     VIDEO_TRACK_COUNT = "X-WEBRTC-VIDEO-TRACK-COUNT",
-    TRACKS_DIRECTION = "X-WEBRTC-TRACKS-DIRECTION"
+    TRACKS_DIRECTION = "X-WEBRTC-TRACKS-DIRECTION",
+    AUDIO_ID = "X-WEBRTC-AUDIOID"
 }
 export declare enum EShareState {
     AVAILABLE_SECOND_REMOTE_STREAM = "YOUCANRECEIVECONTENT",
@@ -44,8 +45,7 @@ export declare enum EContentTypeReceived {
     PARTICIPANT_STATE = "application/vinteo.webrtc.partstate",
     NOTIFY = "application/vinteo.webrtc.notify",
     SHARE_STATE = "application/vinteo.webrtc.sharedesktop",
-    MAIN_CAM = "application/vinteo.webrtc.maincam",
-    RESTART = "application/vinteo.webrtc.restart"
+    MAIN_CAM = "application/vinteo.webrtc.maincam"
 }
 export declare enum EContentTypeSent {
     CHANNELS = "application/vinteo.webrtc.channels",
@@ -75,8 +75,3 @@ export declare enum EUseLicense {
     VIDEO = "VIDEO",
     AUDIOPLUSPRESENTATION = "AUDIOPLUSPRESENTATION"
 }
-export declare enum ETracksDirection {
-    SENDRECV = "SENDRECV",
-    SENDONLY = "SENDONLY",
-    RECVONLY = "RECVONLY"
-}

package/dist/ApiManager/eventNames.d.ts

@@ -1,12 +1,14 @@
 import { TypedEvents } from 'events-constructor';
 import { EUseLicense, EEventsMainCAM } from './constants';
-import { TChannels, TParametersModeratorsList, TParametersWebcast, TParametersConferenceParticipantTokenIssued, TRestartData } from './types';
+import { TChannels, TParametersModeratorsList, TParametersWebcast, TParametersConferenceParticipantTokenIssued } from './types';
 export declare enum EEvent {
     CHANNELS_NOTIFY = "channels:notify",
     PARTICIPANT_ADDED_TO_LIST_MODERATORS = "participant:added-to-list-moderators",
     PARTICIPANT_REMOVED_FROM_LIST_MODERATORS = "participant:removed-from-list-moderators",
     PARTICIPANT_MOVE_REQUEST_TO_STREAM = "participant:move-request-to-stream",
     PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS = "participant:move-request-to-spectators",
+    PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS_SYNTHETIC = "participant:move-request-to-spectators-synthetic",
+    PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS_WITH_AUDIO_ID = "participant:move-request-to-spectators-with-audio-id",
     PARTICIPANT_MOVE_REQUEST_TO_PARTICIPANTS = "participant:move-request-to-participants",
     PARTICIPATION_ACCEPTING_WORD_REQUEST = "participation:accepting-word-request",
     PARTICIPATION_CANCELLING_WORD_REQUEST = "participation:cancelling-word-request",
@@ -28,18 +30,26 @@ export declare enum EEvent {
     AVAILABLE_SECOND_REMOTE_STREAM = "availableSecondRemoteStream",
     NOT_AVAILABLE_SECOND_REMOTE_STREAM = "notAvailableSecondRemoteStream",
     MUST_STOP_PRESENTATION = "mustStopPresentation",
-    NEW_DTMF = "newDTMF",
-    RESTART = "restart"
+    NEW_DTMF = "newDTMF"
 }
-export declare const EVENT_NAMES: readonly ["participation:accepting-word-request", "participation:cancelling-word-request", "participant:move-request-to-stream", "channels:notify", "conference:participant-token-issued", "account:changed", "account:deleted", "webcast:started", "webcast:stopped", "participant:added-to-list-moderators", "participant:removed-from-list-moderators", "participant:move-request-to-spectators", "participant:move-request-to-participants", "channels", "enterRoom", "shareState", "main-cam-control", "useLicense", "admin-start-main-cam", "admin-stop-main-cam", "admin-start-mic", "admin-stop-mic", "admin-force-sync-media-state", "availableSecondRemoteStream", "notAvailableSecondRemoteStream", "mustStopPresentation", "newDTMF", "restart"];
+export declare const EVENT_NAMES: readonly ["participation:accepting-word-request", "participation:cancelling-word-request", "participant:move-request-to-stream", "channels:notify", "conference:participant-token-issued", "account:changed", "account:deleted", "webcast:started", "webcast:stopped", "participant:added-to-list-moderators", "participant:removed-from-list-moderators", "participant:move-request-to-spectators", "participant:move-request-to-spectators-synthetic", "participant:move-request-to-spectators-with-audio-id", "participant:move-request-to-participants", "channels", "enterRoom", "shareState", "main-cam-control", "useLicense", "admin-start-main-cam", "admin-stop-main-cam", "admin-start-mic", "admin-stop-mic", "admin-force-sync-media-state", "availableSecondRemoteStream", "notAvailableSecondRemoteStream", "mustStopPresentation", "newDTMF"];
 export type TEvent = (typeof EVENT_NAMES)[number];
 export type TEventMap = {
     'channels:notify': TChannels;
     'participant:added-to-list-moderators': TParametersModeratorsList;
     'participant:removed-from-list-moderators': TParametersModeratorsList;
     'participant:move-request-to-stream': TParametersModeratorsList;
-    'participant:move-request-to-spectators': Record<string, never>;
     'participant:move-request-to-participants': Record<string, never>;
+    'participant:move-request-to-spectators': {
+        isSynthetic: true;
+    } | {
+        isSynthetic: false;
+        audioId: string;
+    };
+    'participant:move-request-to-spectators-synthetic': Record<string, never>;
+    'participant:move-request-to-spectators-with-audio-id': {
+        audioId: string;
+    };
     'participation:accepting-word-request': TParametersModeratorsList;
     'participation:cancelling-word-request': TParametersModeratorsList;
     'webcast:started': TParametersWebcast;
@@ -79,6 +89,5 @@ export type TEventMap = {
     newDTMF: {
         originator: string;
     };
-    restart: TRestartData;
 };
 export type TEvents = TypedEvents<TEventMap>;

package/dist/ApiManager/index.d.ts

@@ -1,4 +1,3 @@
 export { default as ApiManager } from './@ApiManager';
 export { EContentTypeReceived, EContentTypeSent, EEventsMainCAM, EEventsMic, EEventsSyncMediaState, EHeader, EShareState, EUseLicense, } from './constants';
 export type { TEvent as TApiEvent } from './eventNames';
-export type { TRestartData } from './types';

package/dist/ApiManager/types.d.ts

@@ -1,4 +1,3 @@
-import { ETracksDirection } from './constants';
 export declare enum ECMDNotify {
     CHANNELS = "channels",
     WEBCAST_STARTED = "WebcastStarted",
@@ -98,8 +97,3 @@ export type TOptionsInfoMediaState = {
 export type TOptionsExtraHeaders = {
     extraHeaders?: string[];
 };
-export type TRestartData = {
-    tracksDirection: ETracksDirection;
-    audioTrackCount: number;
-    videoTrackCount: number;
-};

package/dist/CallManager/@CallManager.d.ts

@@ -1,29 +1,58 @@
+import { RTCSession } from '@krivega/jssip';
 import { TEvents, TEventMap } from './eventNames';
-import { ICallStrategy } from './types';
+import { TStartCall, TCallConfiguration, TReplaceMediaStream, TAnswerToIncomingCall, TCallRoleSpectator } from './types';
 declare class CallManager {
     readonly events: TEvents;
-    private strategy;
-    constructor(strategy?: ICallStrategy);
+    protected isPendingCall: boolean;
+    protected isPendingAnswer: boolean;
+    protected rtcSession?: RTCSession;
+    protected readonly callConfiguration: TCallConfiguration;
+    private readonly mainRemoteStreamsManager;
+    private readonly recvRemoteStreamsManager;
+    private readonly roleManager;
+    private readonly mcuSession;
+    private recvSession?;
+    private disposeRecvSessionTrackListener?;
+    constructor();
     get requested(): boolean;
-    get connection(): ICallStrategy['connection'];
-    get isCallActive(): ICallStrategy['isCallActive'];
-    getEstablishedRTCSession: ICallStrategy['getEstablishedRTCSession'];
+    get connection(): RTCPeerConnection | undefined;
+    get isCallActive(): boolean;
+    getEstablishedRTCSession: () => RTCSession | undefined;
     on<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
     onRace<T extends keyof TEventMap>(eventNames: T[], handler: (data: TEventMap[T], eventName: string) => void): () => void;
     once<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
     onceRace<T extends keyof TEventMap>(eventNames: T[], handler: (data: TEventMap[T], eventName: string) => void): () => void;
     wait<T extends keyof TEventMap>(eventName: T): Promise<TEventMap[T]>;
     off<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): void;
-    setStrategy(strategy: ICallStrategy): void;
-    startCall: ICallStrategy['startCall'];
-    endCall: ICallStrategy['endCall'];
-    answerToIncomingCall: ICallStrategy['answerToIncomingCall'];
-    getCallConfiguration: ICallStrategy['getCallConfiguration'];
-    getRemoteStreams: ICallStrategy['getRemoteStreams'];
-    addTransceiver: ICallStrategy['addTransceiver'];
-    replaceMediaStream: ICallStrategy['replaceMediaStream'];
-    restartIce: ICallStrategy['restartIce'];
+    startCall: TStartCall;
+    endCall(): Promise<void>;
+    answerToIncomingCall: TAnswerToIncomingCall;
+    getCallConfiguration(): {
+        answer?: boolean;
+        number?: string;
+    };
+    getRemoteStreams(): MediaStream[];
+    setCallRoleParticipant(): void;
+    setCallRoleSpectatorSynthetic(): void;
+    setCallRoleSpectator(recvParams: TCallRoleSpectator['recvParams']): void;
+    replaceMediaStream(mediaStream: Parameters<TReplaceMediaStream>[0], options?: Parameters<TReplaceMediaStream>[1]): Promise<void>;
+    restartIce(options?: {
+        useUpdate?: boolean;
+        extraHeaders?: string[];
+        rtcOfferConstraints?: RTCOfferOptions;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        degradationPreference?: RTCDegradationPreference;
+    }): Promise<boolean>;
+    private readonly reset;
     private subscribeCallStatusChange;
     private maybeTriggerCallStatus;
+    private subscribeMcuRemoteTrackEvents;
+    private addRemoteTrack;
+    private emitRemoteStreamsChanged;
+    private getActiveStreamsManager;
+    private attachRecvSessionTracks;
+    private startRecvSession;
+    private stopRecvSession;
+    private readonly onRoleChanged;
 }
 export default CallManager;

package/dist/CallManager/MCUSession.d.ts

@@ -15,7 +15,6 @@ export declare class MCUSession implements IMCUSession {
     startCall: IMCUSession['startCall'];
     endCall(): Promise<void>;
     answerToIncomingCall: IMCUSession['answerToIncomingCall'];
-    getRemoteTracks(): MediaStreamTrack[] | undefined;
     replaceMediaStream(mediaStream: Parameters<IMCUSession['replaceMediaStream']>[0], options?: Parameters<IMCUSession['replaceMediaStream']>[1]): Promise<void>;
     restartIce(options?: {
         useUpdate?: boolean;
@@ -24,7 +23,6 @@ export declare class MCUSession implements IMCUSession {
         sendEncodings?: RTCRtpEncodingParameters[];
         degradationPreference?: RTCDegradationPreference;
     }): Promise<boolean>;
-    addTransceiver(kind: 'audio' | 'video', options?: RTCRtpTransceiverInit): Promise<RTCRtpTransceiver>;
     private readonly handleCall;
     private subscribeToSessionEvents;
     private unsubscribeFromSessionEvents;

package/dist/CallManager/RecvSession.d.ts

@@ -0,0 +1,29 @@
+type TConferenceNumber = string;
+type TSendOfferParams = {
+    quality: 'low' | 'medium' | 'high';
+    audioChannel: string;
+};
+type TConfig = Pick<TSendOfferParams, 'quality' | 'audioChannel'> & {
+    pcConfig?: RTCConfiguration;
+};
+export type TTools = {
+    sendOffer: (params: TSendOfferParams & {
+        conferenceNumber: TConferenceNumber;
+    }, offer: RTCSessionDescriptionInit) => Promise<RTCSessionDescription>;
+};
+declare class RecvSession {
+    private readonly config;
+    private readonly tools;
+    private readonly connection;
+    constructor(config: TConfig, tools: TTools);
+    get settings(): TConfig;
+    get peerConnection(): RTCPeerConnection;
+    close(): void;
+    call(conferenceNumber: TConferenceNumber): Promise<void>;
+    private createOffer;
+    private setRemoteDescription;
+    private waitForTracks;
+    private addTransceivers;
+    private addRecvOnlyTransceiver;
+}
+export default RecvSession;

package/dist/CallManager/RemoteStreamsManager.d.ts

@@ -1,8 +1,23 @@
 export declare class RemoteStreamsManager {
-    private remoteStreams;
+    private readonly participantGroups;
+    private readonly trackToGroup;
+    private readonly trackDisposers;
     reset(): void;
-    generateStream(videoTrack: MediaStreamTrack, audioTrack?: MediaStreamTrack): MediaStream;
-    generateAudioStream(audioTrack: MediaStreamTrack): MediaStream;
-    generateStreams(remoteTracks: MediaStreamTrack[]): MediaStream[];
-    generateAudioStreams(remoteTracks: MediaStreamTrack[]): MediaStream[];
+    addTrack(track: MediaStreamTrack, { onRemoved, streamHint, }?: {
+        streamHint?: string;
+        onRemoved?: ({ trackId, participantId }: {
+            trackId: string;
+            participantId: string;
+        }) => void;
+    }): {
+        isAdded: true;
+        participantId: string;
+    } | {
+        isAdded: false;
+    };
+    removeTrack(trackId: string): boolean;
+    removeStaleTracks(participantId: string, keepTrackIds: string[]): boolean;
+    getStreams(participantId?: string): MediaStream[];
+    private disposeTrackListener;
+    private getParticipantGroups;
 }

package/dist/CallManager/RoleManager.d.ts

@@ -0,0 +1,31 @@
+import { RemoteStreamsManager } from './RemoteStreamsManager';
+import { TCallRole, TCallRoleParticipant, TCallRoleSpectatorSynthetic, TCallRoleSpectator } from './types';
+type TOnRoleChanged = (params: {
+    previous: TCallRole;
+    next: TCallRole;
+}) => void;
+export declare class RoleManager {
+    private role;
+    private readonly mainManager;
+    private readonly recvManager;
+    private readonly onRoleChanged?;
+    constructor({ mainManager, recvManager, }: {
+        mainManager: RemoteStreamsManager;
+        recvManager: RemoteStreamsManager;
+    }, onRoleChanged?: TOnRoleChanged);
+    static hasParticipant(role: TCallRole): role is TCallRoleParticipant;
+    static hasSpectatorSynthetic(role: TCallRole): role is TCallRoleSpectatorSynthetic;
+    static hasSpectator(role: TCallRole): role is TCallRoleSpectator;
+    getRole(): TCallRole;
+    setCallRoleParticipant(): void;
+    setCallRoleSpectatorSynthetic(): void;
+    setCallRoleSpectator(recvParams: TCallRoleSpectator['recvParams']): void;
+    changeRole(next: TCallRole): void;
+    reset(): void;
+    getActiveManager(): RemoteStreamsManager;
+    hasParticipant(): boolean;
+    hasSpectatorSynthetic(): boolean;
+    hasSpectator(): boolean;
+    private setRole;
+}
+export {};

package/dist/CallManager/eventNames.d.ts

@@ -34,7 +34,8 @@ export declare enum EEvent {
     PEER_CONNECTION_CONFIRMED = "peerconnection:confirmed",
     PEER_CONNECTION_ONTRACK = "peerconnection:ontrack",
     ENDED_FROM_SERVER = "ended:fromserver",
-    CALL_STATUS_CHANGED = "call-status-changed"
+    CALL_STATUS_CHANGED = "call-status-changed",
+    REMOTE_STREAMS_CHANGED = "remote-streams-changed"
 }
 export declare enum Originator {
     LOCAL = "local",
@@ -42,7 +43,7 @@ export declare enum Originator {
     SYSTEM = "system"
 }
 export declare const SESSION_JSSIP_EVENT_NAMES: readonly ["peerconnection", "connecting", "sending", "progress", "accepted", "confirmed", "ended", "failed", "newInfo", "newDTMF", "presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed", "reinvite", "update", "refer", "replaces", "sdp", "icecandidate", "getusermediafailed", "peerconnection:createofferfailed", "peerconnection:createanswerfailed", "peerconnection:setlocaldescriptionfailed", "peerconnection:setremotedescriptionfailed"];
-export declare const EVENT_NAMES: readonly ["peerconnection", "connecting", "sending", "progress", "accepted", "confirmed", "ended", "failed", "newInfo", "newDTMF", "presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed", "reinvite", "update", "refer", "replaces", "sdp", "icecandidate", "getusermediafailed", "peerconnection:createofferfailed", "peerconnection:createanswerfailed", "peerconnection:setlocaldescriptionfailed", "peerconnection:setremotedescriptionfailed", "peerconnection:confirmed", "peerconnection:ontrack", "ended:fromserver", "call-status-changed"];
+export declare const EVENT_NAMES: readonly ["peerconnection", "connecting", "sending", "progress", "accepted", "confirmed", "ended", "failed", "newInfo", "newDTMF", "presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed", "reinvite", "update", "refer", "replaces", "sdp", "icecandidate", "getusermediafailed", "peerconnection:createofferfailed", "peerconnection:createanswerfailed", "peerconnection:setlocaldescriptionfailed", "peerconnection:setremotedescriptionfailed", "peerconnection:confirmed", "peerconnection:ontrack", "ended:fromserver", "call-status-changed", "remote-streams-changed"];
 export type TEvent = (typeof EVENT_NAMES)[number];
 export type TEventMap = {
     peerconnection: {
@@ -85,5 +86,11 @@ export type TEventMap = {
     'call-status-changed': {
         isCallActive: boolean;
     };
+    'remote-streams-changed': {
+        participantId: string;
+        changeType: 'added' | 'removed';
+        trackId: string;
+        streams: MediaStream[];
+    };
 };
 export type TEvents = TypedEvents<TEventMap>;

package/dist/CallManager/index.d.ts

@@ -4,5 +4,4 @@ export type { TEventMap } from './eventNames';
 export { EEvent as ECallEvent } from './eventNames';
 export type { TEvent as TCallEvent, TEvents as TCallEvents } from './eventNames';
 export { default as hasCanceledCallError } from './hasCanceledCallError';
-export { MCUCallStrategy } from './MCUCallStrategy';
-export type { TCustomError, TGetServerUrl } from './types';
+export type { TCustomError, TGetUri } from './types';

package/dist/CallManager/types.d.ts

@@ -1,16 +1,15 @@
 import { RTCSession, UA } from '@krivega/jssip';
 import { TContentHint } from '../PresentationManager';
 import { Originator } from './eventNames';
-export type TOntrack = (event: RTCTrackEvent) => void;
+import { TTools } from './RecvSession';
 export type TOnAddedTransceiver = (transceiver: RTCRtpTransceiver, track: MediaStreamTrack, streams: MediaStream[]) => Promise<void>;
-export type TGetServerUrl = (id: string) => string;
+export type TGetUri = (id: string) => string;
 type TOptionsExtraHeaders = {
     extraHeaders?: string[];
 };
 type TParamsAnswerToIncomingCall = {
     mediaStream: MediaStream;
     extraHeaders?: TOptionsExtraHeaders['extraHeaders'];
-    ontrack?: TOntrack;
     iceServers?: RTCIceServer[];
     directionVideo?: RTCRtpTransceiverDirection;
     directionAudio?: RTCRtpTransceiverDirection;
@@ -37,43 +36,39 @@ export type TCallConfiguration = {
     answer?: boolean;
     number?: string;
 };
-export interface ICallStrategy {
-    readonly requested: boolean;
-    readonly connection: RTCPeerConnection | undefined;
-    readonly isCallActive: boolean;
-    getEstablishedRTCSession: () => RTCSession | undefined;
-    startCall: (ua: UA, getSipServerUrl: TGetServerUrl, params: TParamsCall) => Promise<RTCPeerConnection>;
-    endCall: () => Promise<void>;
-    answerToIncomingCall: (extractIncomingRTCSession: () => RTCSession, params: TParamsAnswerToIncomingCall) => Promise<RTCPeerConnection>;
-    getCallConfiguration: () => TCallConfiguration;
-    getRemoteStreams: () => MediaStream[] | undefined;
-    addTransceiver: (kind: 'audio' | 'video', options?: RTCRtpTransceiverInit) => Promise<RTCRtpTransceiver>;
-    replaceMediaStream: (mediaStream: MediaStream, options?: {
-        deleteExisting?: boolean;
-        addMissing?: boolean;
-        forceRenegotiation?: boolean;
-        contentHint?: TContentHint;
-        degradationPreference?: RTCDegradationPreference;
-        sendEncodings?: RTCRtpEncodingParameters[];
-        onAddedTransceiver?: TOnAddedTransceiver;
-    }) => Promise<void>;
-    restartIce: (options?: {
-        extraHeaders?: string[];
-        useUpdate?: boolean;
-        rtcOfferConstraints?: RTCOfferOptions;
-        sendEncodings?: RTCRtpEncodingParameters[];
-        degradationPreference?: RTCDegradationPreference;
-    }) => Promise<boolean>;
-}
+export type TCallRoleParticipant = {
+    type: 'participant';
+};
+export type TCallRoleSpectatorSynthetic = {
+    type: 'spectator_synthetic';
+};
+export type TCallRoleSpectator = {
+    type: 'spectator';
+    recvParams: {
+        audioId: string;
+        sendOffer: TTools['sendOffer'];
+    };
+};
+export type TCallRole = TCallRoleParticipant | TCallRoleSpectatorSynthetic | TCallRoleSpectator;
+export type TStartCall = (ua: UA, getUri: TGetUri, params: TParamsCall) => Promise<RTCPeerConnection>;
+export type TReplaceMediaStream = (mediaStream: MediaStream, options?: {
+    deleteExisting?: boolean;
+    addMissing?: boolean;
+    forceRenegotiation?: boolean;
+    contentHint?: TContentHint;
+    degradationPreference?: RTCDegradationPreference;
+    sendEncodings?: RTCRtpEncodingParameters[];
+    onAddedTransceiver?: TOnAddedTransceiver;
+}) => Promise<void>;
+export type TAnswerToIncomingCall = (extractIncomingRTCSession: () => RTCSession, params: TParamsAnswerToIncomingCall) => Promise<RTCPeerConnection>;
 export interface IMCUSession {
     readonly connection: RTCPeerConnection | undefined;
     readonly isCallActive: boolean;
     getEstablishedRTCSession: () => RTCSession | undefined;
-    startCall: ICallStrategy['startCall'];
+    startCall: TStartCall;
     endCall: () => Promise<void>;
     answerToIncomingCall: (incomingRTCSession: RTCSession, params: TParamsAnswerToIncomingCall) => Promise<RTCPeerConnection>;
-    getRemoteTracks: () => MediaStreamTrack[] | undefined;
-    replaceMediaStream: ICallStrategy['replaceMediaStream'];
+    replaceMediaStream: TReplaceMediaStream;
     restartIce: (options?: {
         useUpdate?: boolean;
         extraHeaders?: string[];
@@ -81,6 +76,5 @@ export interface IMCUSession {
         sendEncodings?: RTCRtpEncodingParameters[];
         degradationPreference?: RTCDegradationPreference;
     }) => Promise<boolean>;
-    addTransceiver: (kind: 'audio' | 'video', options?: RTCRtpTransceiverInit) => Promise<RTCRtpTransceiver>;
 }
 export {};

package/dist/ConnectionManager/@ConnectionManager.d.ts

@@ -1,6 +1,6 @@
 import { default as SipOperations, TParametersCheckTelephony } from './SipOperations';
 import { RegisteredEvent, UA, UnRegisteredEvent, WebSocketInterface } from '@krivega/jssip';
-import { TGetServerUrl } from '../CallManager';
+import { TGetUri } from '../CallManager';
 import { TJsSIP } from '../types';
 import { TConnect, TConnectionConfigurationWithUa, TParametersConnection, TSet } from './ConnectionFlow';
 import { TEventMap, TEvents } from './eventNames';
@@ -48,7 +48,7 @@ export default class ConnectionManager {
     isConfigured(): boolean;
     getConnectionConfiguration: () => import('./ConfigurationManager').IConnectionConfiguration | undefined;
     destroy(): void;
-    getSipServerUrl: TGetServerUrl;
+    getUri: TGetUri;
     readonly getUaProtected: () => UA;
     private readonly getUa;
     private readonly connectWithProcessError;

package/dist/ConnectionManager/ConfigurationManager.d.ts

@@ -1,5 +1,6 @@
 import { UA } from '@krivega/jssip';
 export interface IConnectionConfiguration {
+    sipServerIp: string;
     sipServerUrl: string;
     displayName: string;
     register?: boolean;
@@ -38,7 +39,11 @@ export default class ConfigurationManager {
      */
     isRegister(): boolean;
     /**
-     * Получает SIP сервер URL из конфигурации
+     * Получает SIP сервер IP из конфигурации
+     */
+    getSipServerIp(): string | undefined;
+    /**
+     * Получает SIP сервер URL (WebSocket) из конфигурации
      */
     getSipServerUrl(): string | undefined;
     /**

package/dist/ConnectionManager/ConnectionFlow.d.ts

@@ -1,5 +1,5 @@
 import { UA, WebSocketInterface } from '@krivega/jssip';
-import { TGetServerUrl } from '../CallManager';
+import { TGetUri } from '../CallManager';
 import { TJsSIP } from '../types';
 import { default as ConnectionStateMachine } from './ConnectionStateMachine';
 import { TEvents } from './eventNames';
@@ -9,8 +9,8 @@ export type TOptionsExtraHeaders = {
     extraHeaders?: string[];
 };
 export type TParametersConnection = TOptionsExtraHeaders & {
+    sipServerIp: string;
     sipServerUrl: string;
-    sipWebSocketServerURL: string;
     displayName: string;
     register?: boolean;
     user?: string;
@@ -23,6 +23,7 @@ export type TParametersConnection = TOptionsExtraHeaders & {
     connectionRecoveryMaxInterval?: number;
 };
 export type TConnectionConfiguration = {
+    sipServerIp: string;
     sipServerUrl: string;
     displayName: string;
     register?: boolean;
@@ -49,7 +50,7 @@ interface IDependencies {
     getConnectionConfiguration: () => TConnectionConfiguration | undefined;
     setConnectionConfiguration: (config: TConnectionConfiguration | undefined) => void;
     updateConnectionConfiguration: <K extends keyof TConnectionConfiguration>(key: K, value: TConnectionConfiguration[K]) => void;
-    setSipServerUrl: (getSipServerUrl: TGetServerUrl) => void;
+    setGetUri: (getUri: TGetUri) => void;
     setSocket: (socket: WebSocketInterface) => void;
 }
 export default class ConnectionFlow {
@@ -64,7 +65,7 @@ export default class ConnectionFlow {
     private readonly getConnectionConfiguration;
     private readonly setConnectionConfiguration;
     private readonly updateConnectionConfiguration;
-    private readonly setSipServerUrl;
+    private readonly setGetUri;
     private readonly setSocket;
     constructor(dependencies: IDependencies);
     connect: TConnect;

package/dist/ConnectionManager/SipOperations.d.ts

@@ -2,8 +2,8 @@ import { UA, URI } from '@krivega/jssip';
 import { default as UAFactory } from './UAFactory';
 export type TParametersCheckTelephony = {
     displayName: string;
+    sipServerIp: string;
     sipServerUrl: string;
-    sipWebSocketServerURL: string;
     userAgent?: string;
     remoteAddress?: string;
     extraHeaders?: string[];
@@ -27,6 +27,6 @@ export default class SipOperations {
     /**
      * Проверяет доступность телефонии, создавая временное соединение
      */
-    checkTelephony({ userAgent, displayName, sipServerUrl, sipWebSocketServerURL, remoteAddress, extraHeaders, }: TParametersCheckTelephony): Promise<void>;
+    checkTelephony({ userAgent, displayName, sipServerIp, sipServerUrl, remoteAddress, extraHeaders, }: TParametersCheckTelephony): Promise<void>;
 }
 export {};

package/dist/ConnectionManager/UAFactory.d.ts

@@ -4,7 +4,7 @@ export type TUAConfiguration = {
     configuration: UAConfigurationParams;
     helpers: {
         socket: WebSocketInterface;
-        getSipServerUrl: (id: string) => string;
+        getUri: (id: string) => string;
     };
 };
 export type TCreateUAParameters = UAConfigurationParams & {
@@ -12,9 +12,9 @@ export type TCreateUAParameters = UAConfigurationParams & {
     extraHeaders?: string[];
 };
 type TParametersCreateUaConfiguration = {
-    sipWebSocketServerURL: string;
-    displayName: string;
     sipServerUrl: string;
+    displayName: string;
+    sipServerIp: string;
     user?: string;
     register?: boolean;
     password?: string;
@@ -31,7 +31,7 @@ export default class UAFactory {
     private static validateParametersConnection;
     private static resolveAuthorizationUser;
     private static buildExtraHeaders;
-    createConfiguration({ user, password, sipWebSocketServerURL, displayName, sipServerUrl, register, sessionTimers, registerExpires, // 5 minutes in sec
+    createConfiguration({ user, password, sipServerUrl, displayName, sipServerIp, register, sessionTimers, registerExpires, // 5 minutes in sec
     connectionRecoveryMinInterval, connectionRecoveryMaxInterval, userAgent, }: TParametersCreateUaConfiguration): TUAConfiguration;
     createUA({ remoteAddress, extraHeaders, ...parameters }: TCreateUAParameters): UA;
     /**

package/dist/SipConnector/@SipConnector.d.ts

@@ -1,12 +1,11 @@
 import { ApiManager } from '../ApiManager';
 import { AutoConnectorManager, IAutoConnectorOptions } from '../AutoConnectorManager';
-import { CallManager, TGetServerUrl } from '../CallManager';
+import { CallManager, TGetUri } from '../CallManager';
 import { ConnectionManager } from '../ConnectionManager';
 import { ConnectionQueueManager } from '../ConnectionQueueManager';
 import { IncomingCallManager } from '../IncomingCallManager';
 import { PresentationManager, TContentHint, TOnAddedTransceiver } from '../PresentationManager';
 import { StatsManager } from '../StatsManager';
-import { TransceiverManager } from '../TransceiverManager';
 import { VideoSendingBalancerManager } from '../VideoSendingBalancerManager';
 import { TJsSIP } from '../types';
 import { IBalancerOptions } from '../VideoSendingBalancer';
@@ -22,7 +21,6 @@ declare class SipConnector {
     readonly presentationManager: PresentationManager;
     readonly statsManager: StatsManager;
     readonly videoSendingBalancerManager: VideoSendingBalancerManager;
-    readonly transceiverManager: TransceiverManager;
     private readonly preferredMimeTypesVideoCodecs?;
     private readonly excludeMimeTypesVideoCodecs?;
     constructor({ JsSIP }: {
@@ -61,7 +59,7 @@ declare class SipConnector {
     checkTelephony: ConnectionManager['checkTelephony'];
     isConfigured: () => boolean;
     getConnectionConfiguration: () => import('../ConnectionManager/ConfigurationManager').IConnectionConfiguration | undefined;
-    getSipServerUrl: TGetServerUrl;
+    getUri: TGetUri;
     startAutoConnect: AutoConnectorManager['start'];
     stopAutoConnect: AutoConnectorManager['stop'];
     call: (params: Parameters<CallManager["startCall"]>[2]) => Promise<RTCPeerConnection>;
@@ -108,6 +106,8 @@ declare class SipConnector {
     askPermissionToStartPresentationP2P(...args: Parameters<ApiManager['askPermissionToStartPresentationP2P']>): Promise<void>;
     askPermissionToStartPresentation(...args: Parameters<ApiManager['askPermissionToStartPresentation']>): Promise<void>;
     askPermissionToEnableCam(...args: Parameters<ApiManager['askPermissionToEnableCam']>): Promise<void>;
+    private subscribeChangeRole;
+    private readonly sendOffer;
     private setCodecPreferences;
     private subscribe;
     private readonly bridgeEvents;

package/dist/SipConnector/eventNames.d.ts

@@ -7,7 +7,7 @@ import { TEventMap as TIncomingCallManagerEventMap } from '../IncomingCallManage
 import { TEventMap as TPresentationManagerEventMap } from '../PresentationManager/eventNames';
 import { TEventMap as TStatsManagerEventMap } from '../StatsPeerConnection/eventNames';
 import { TEventMap as TVideoBalancerManagerEventMap } from '../VideoSendingBalancerManager/eventNames';
-export declare const EVENT_NAMES: readonly ("auto-connect:before-attempt" | "auto-connect:success" | "auto-connect:failed-all-attempts" | "auto-connect:cancelled-attempts" | "auto-connect:changed-attempt-status" | "auto-connect:stop-attempts-by-error" | "auto-connect:limit-reached-attempts" | "connection:connecting" | "connection:connected" | "connection:disconnected" | "connection:disconnecting" | "connection:newRTCSession" | "connection:registered" | "connection:unregistered" | "connection:registrationFailed" | "connection:newMessage" | "connection:sipEvent" | "connection:connect-started" | "connection:connect-succeeded" | "connection:connected-with-configuration" | "connection:connect-failed" | "connection:connect-parameters-resolve-success" | "connection:connect-parameters-resolve-failed" | "call:peerconnection" | "call:connecting" | "call:sending" | "call:progress" | "call:accepted" | "call:confirmed" | "call:ended" | "call:failed" | "call:newDTMF" | "call:newInfo" | "call:reinvite" | "call:update" | "call:refer" | "call:replaces" | "call:sdp" | "call:icecandidate" | "call:getusermediafailed" | "call:peerconnection:createofferfailed" | "call:peerconnection:createanswerfailed" | "call:peerconnection:setlocaldescriptionfailed" | "call:peerconnection:setremotedescriptionfailed" | "call:presentation:start" | "call:presentation:started" | "call:presentation:end" | "call:presentation:ended" | "call:presentation:failed" | "call:peerconnection:confirmed" | "call:peerconnection:ontrack" | "call:ended:fromserver" | "call:call-status-changed" | "api:channels:notify" | "api:participant:added-to-list-moderators" | "api:participant:removed-from-list-moderators" | "api:participant:move-request-to-stream" | "api:participant:move-request-to-spectators" | "api:participant:move-request-to-participants" | "api:participation:accepting-word-request" | "api:participation:cancelling-word-request" | "api:webcast:started" | "api:webcast:stopped" | "api:account:changed" | "api:account:deleted" | "api:conference:participant-token-issued" | "api:channels" | "api:enterRoom" | "api:shareState" | "api:main-cam-control" | "api:useLicense" | "api:admin-start-main-cam" | "api:admin-stop-main-cam" | "api:admin-start-mic" | "api:admin-stop-mic" | "api:admin-force-sync-media-state" | "api:availableSecondRemoteStream" | "api:notAvailableSecondRemoteStream" | "api:mustStopPresentation" | "api:newDTMF" | "api:restart" | "incoming-call:incomingCall" | "incoming-call:declinedIncomingCall" | "incoming-call:terminatedIncomingCall" | "incoming-call:failedIncomingCall" | "presentation:presentation:start" | "presentation:presentation:started" | "presentation:presentation:end" | "presentation:presentation:ended" | "presentation:presentation:failed" | "stats:collected" | "video-balancer:balancing-scheduled" | "video-balancer:balancing-started" | "video-balancer:balancing-stopped" | "video-balancer:parameters-updated")[];
+export declare const EVENT_NAMES: readonly ("auto-connect:before-attempt" | "auto-connect:success" | "auto-connect:failed-all-attempts" | "auto-connect:cancelled-attempts" | "auto-connect:changed-attempt-status" | "auto-connect:stop-attempts-by-error" | "auto-connect:limit-reached-attempts" | "connection:connecting" | "connection:connected" | "connection:disconnected" | "connection:disconnecting" | "connection:newRTCSession" | "connection:registered" | "connection:unregistered" | "connection:registrationFailed" | "connection:newMessage" | "connection:sipEvent" | "connection:connect-started" | "connection:connect-succeeded" | "connection:connected-with-configuration" | "connection:connect-failed" | "connection:connect-parameters-resolve-success" | "connection:connect-parameters-resolve-failed" | "call:peerconnection" | "call:connecting" | "call:sending" | "call:progress" | "call:accepted" | "call:confirmed" | "call:ended" | "call:failed" | "call:newDTMF" | "call:newInfo" | "call:reinvite" | "call:update" | "call:refer" | "call:replaces" | "call:sdp" | "call:icecandidate" | "call:getusermediafailed" | "call:peerconnection:createofferfailed" | "call:peerconnection:createanswerfailed" | "call:peerconnection:setlocaldescriptionfailed" | "call:peerconnection:setremotedescriptionfailed" | "call:presentation:start" | "call:presentation:started" | "call:presentation:end" | "call:presentation:ended" | "call:presentation:failed" | "call:peerconnection:confirmed" | "call:peerconnection:ontrack" | "call:ended:fromserver" | "call:call-status-changed" | "call:remote-streams-changed" | "api:channels:notify" | "api:participant:added-to-list-moderators" | "api:participant:removed-from-list-moderators" | "api:participant:move-request-to-stream" | "api:participant:move-request-to-participants" | "api:participant:move-request-to-spectators" | "api:participant:move-request-to-spectators-synthetic" | "api:participant:move-request-to-spectators-with-audio-id" | "api:participation:accepting-word-request" | "api:participation:cancelling-word-request" | "api:webcast:started" | "api:webcast:stopped" | "api:account:changed" | "api:account:deleted" | "api:conference:participant-token-issued" | "api:channels" | "api:enterRoom" | "api:shareState" | "api:main-cam-control" | "api:useLicense" | "api:admin-start-main-cam" | "api:admin-stop-main-cam" | "api:admin-start-mic" | "api:admin-stop-mic" | "api:admin-force-sync-media-state" | "api:availableSecondRemoteStream" | "api:notAvailableSecondRemoteStream" | "api:mustStopPresentation" | "api:newDTMF" | "incoming-call:incomingCall" | "incoming-call:declinedIncomingCall" | "incoming-call:terminatedIncomingCall" | "incoming-call:failedIncomingCall" | "presentation:presentation:start" | "presentation:presentation:started" | "presentation:presentation:end" | "presentation:presentation:ended" | "presentation:presentation:failed" | "stats:collected" | "video-balancer:balancing-scheduled" | "video-balancer:balancing-started" | "video-balancer:balancing-stopped" | "video-balancer:parameters-updated")[];
 export type TEvent = (typeof EVENT_NAMES)[number];
 type PrefixedEventMap<T extends Record<string, unknown>, Prefix extends string> = {
     [K in keyof T as `${Prefix}:${string & K}`]: T[K];