sip-connector 14.0.1-0 → 14.1.0-alpha.0

package/dist/src/SipConnector.d.ts

@@ -1,301 +1,107 @@
-import { IncomingInfoEvent, IncomingRTCSessionEvent, IncomingRequest, OutgoingInfoEvent, RTCSession, RegisteredEvent, UA, UAConfigurationParams, URI, UnRegisteredEvent, WebSocketInterface } from '@krivega/jssip';
-import { TEventSession, TEventUA } from './eventNames';
-import { TContentHint, TCustomError, TJsSIP, TOnAddedTransceiver } from './types';
-export declare const hasCanceledCallError: (error: unknown) => boolean;
-type TChannels = {
-    inputChannels: string;
-    outputChannels: string;
-};
-type TMediaState = {
-    cam: boolean;
-    mic: boolean;
-};
-type TOptionsInfoMediaState = {
-    noTerminateWhenError?: boolean;
-};
-declare const CMD_CHANNELS = "channels";
-declare const CMD_WEBCAST_STARTED = "WebcastStarted";
-declare const CMD_ADDED_TO_LIST_MODERATORS = "addedToListModerators";
-declare const CMD_REMOVED_FROM_LIST_MODERATORS = "removedFromListModerators";
-declare const CMD_ACCEPTING_WORD_REQUEST = "ParticipationRequestAccepted";
-declare const CMD_CANCELLING_WORD_REQUEST = "ParticipationRequestRejected";
-declare const CMD_MOVE_REQUEST_TO_STREAM = "ParticipantMovedToWebcast";
-declare const CMD_CONFERENCE_PARTICIPANT_TOKEN_ISSUED = "ConferenceParticipantTokenIssued";
-type TAddedToListModeratorsInfoNotify = {
-    cmd: typeof CMD_ADDED_TO_LIST_MODERATORS;
-    conference: string;
-};
-type TRemovedFromListModeratorsInfoNotify = {
-    cmd: typeof CMD_REMOVED_FROM_LIST_MODERATORS;
-    conference: string;
-};
-type TAcceptingWordRequestInfoNotify = {
-    cmd: typeof CMD_ACCEPTING_WORD_REQUEST;
-    body: {
-        conference: string;
-    };
-};
-type TCancellingWordRequestInfoNotify = {
-    cmd: typeof CMD_CANCELLING_WORD_REQUEST;
-    body: {
-        conference: string;
-    };
-};
-type TMoveRequestToStreamInfoNotify = {
-    cmd: typeof CMD_MOVE_REQUEST_TO_STREAM;
-    body: {
-        conference: string;
-    };
-};
-type TConferenceParticipantTokenIssued = {
-    cmd: typeof CMD_CONFERENCE_PARTICIPANT_TOKEN_ISSUED;
-    body: {
-        conference: string;
-        participant: string;
-        jwt: string;
-    };
-};
-type TWebcastInfoNotify = {
-    cmd: typeof CMD_WEBCAST_STARTED;
-    body: {
-        conference: string;
-        type: string;
-    };
-};
-type TChannelsInfoNotify = {
-    cmd: typeof CMD_CHANNELS;
-    input: string;
-    output: string;
-};
-type TInfoNotify = Omit<TAddedToListModeratorsInfoNotify | TChannelsInfoNotify | TRemovedFromListModeratorsInfoNotify, 'cmd'> & {
-    cmd: string;
-};
-type TOptionsExtraHeaders = {
-    extraHeaders?: string[];
-};
-type TOntrack = (track: RTCTrackEvent) => void;
-type TParametersConnection = TOptionsExtraHeaders & {
-    displayName?: string;
-    user?: string;
-    password?: string;
-    register?: boolean;
-    sipServerUrl: string;
-    sipWebSocketServerURL: string;
-    remoteAddress?: string;
-    sessionTimers?: boolean;
-    registerExpires?: number;
-    connectionRecoveryMinInterval?: number;
-    connectionRecoveryMaxInterval?: number;
-    userAgent?: string;
-};
-type TParametersCheckTelephony = {
-    displayName: string;
-    sipServerUrl: string;
-    sipWebSocketServerURL: string;
-    userAgent?: string;
-    remoteAddress?: string;
-    extraHeaders?: string[];
-};
-type TParametersCreateUa = UAConfigurationParams & {
-    remoteAddress?: string;
-    extraHeaders?: string[];
-};
-type TConnect = (parameters: TParametersConnection, options?: {
-    callLimit?: number;
-}) => Promise<UA>;
-type TInitUa = (parameters: TParametersConnection) => Promise<UA>;
-type TCreateUa = (parameters: TParametersCreateUa) => UA;
-type TStart = () => Promise<UA>;
-type TSet = ({ displayName, password, }: {
-    displayName?: string;
-    password?: string;
-}) => Promise<boolean>;
-type TParametersAnswerToIncomingCall = {
-    mediaStream: MediaStream;
-    extraHeaders?: TOptionsExtraHeaders['extraHeaders'];
-    ontrack?: TOntrack;
-    iceServers?: RTCIceServer[];
-    directionVideo?: RTCRtpTransceiverDirection;
-    directionAudio?: RTCRtpTransceiverDirection;
-    contentHint?: TContentHint;
-    sendEncodings?: RTCRtpEncodingParameters[];
-    offerToReceiveAudio?: boolean;
-    offerToReceiveVideo?: boolean;
-    onAddedTransceiver?: TOnAddedTransceiver;
-};
-type TParametersCall = TParametersAnswerToIncomingCall & {
-    number: string;
-};
-type TCall = (parameters: TParametersCall) => Promise<RTCPeerConnection>;
-type TAnswerToIncomingCall = (parameters: TParametersAnswerToIncomingCall) => Promise<RTCPeerConnection>;
-type TSendDTMF = (tone: number | string) => Promise<void>;
-type THangUp = () => Promise<void>;
-export default class SipConnector {
-    private isRegisterConfigInner;
-    private connectionConfiguration;
-    private remoteStreams;
-    private readonly JsSIP;
-    private readonly sessionEvents;
-    private readonly uaEvents;
-    private getSipServerUrl;
-    private cancelableConnectWithRepeatedCalls;
-    private cancelableSendPresentationWithRepeatedCalls;
-    private isPendingConnect;
-    private isPendingInitUa;
-    private isPendingCall;
-    private isPendingAnswer;
-    promisePendingStartPresentation?: Promise<MediaStream>;
-    promisePendingStopPresentation?: Promise<MediaStream | void>;
-    ua?: UA;
-    rtcSession?: RTCSession;
-    incomingRTCSession?: RTCSession;
-    streamPresentationCurrent?: MediaStream;
-    socket?: WebSocketInterface;
+import { TApiEvent, ApiManager } from './ApiManager';
+import { TCallEvent, CallManager } from './CallManager';
+import { TConnectionManagerEvent, ConnectionManager } from './ConnectionManager';
+import { TIncomingCallEvent, IncomingCallManager } from './IncomingCallManager';
+import { PresentationManager } from './PresentationManager';
+import { TContentHint, TOnAddedTransceiver } from './PresentationManager/types';
+import { TGetServerUrl, TJsSIP } from './types';
+declare class SipConnector {
+    readonly connectionManager: ConnectionManager;
+    readonly callManager: CallManager;
+    readonly apiManager: ApiManager;
+    readonly incomingCallManager: IncomingCallManager;
+    readonly presentationManager: PresentationManager;
     constructor({ JsSIP }: {
         JsSIP: TJsSIP;
     });
-    connect: TConnect;
-    hangUp: THangUp;
-    register(): Promise<RegisteredEvent>;
-    unregister(): Promise<UnRegisteredEvent>;
-    tryRegister: () => Promise<RegisteredEvent>;
-    sendOptions(target: URI | string, body?: string, extraHeaders?: string[]): Promise<void>;
-    ping(body?: string, extraHeaders?: string[]): Promise<void>;
-    checkTelephony({ userAgent, displayName, sipServerUrl, sipWebSocketServerURL, remoteAddress, extraHeaders, }: TParametersCheckTelephony): Promise<void>;
-    replaceMediaStream(mediaStream: MediaStream, options?: {
-        deleteExisting?: boolean;
-        addMissing?: boolean;
-        forceRenegotiation?: boolean;
-        contentHint?: TContentHint;
-        sendEncodings?: RTCRtpEncodingParameters[];
-        onAddedTransceiver?: TOnAddedTransceiver;
-    }): Promise<void>;
-    declineToIncomingCall: ({ statusCode }?: {
-        statusCode?: number | undefined;
-    }) => Promise<unknown>;
-    busyIncomingCall: () => Promise<unknown>;
-    removeIncomingSession: () => void;
-    askPermissionToEnableCam(options?: TOptionsInfoMediaState): Promise<void>;
-    get isPendingPresentation(): boolean;
-    private readonly connectWithDuplicatedCalls;
-    private sendPresentationWithDuplicatedCalls;
-    private hasEqualConnectionConfiguration;
-    private createUaConfiguration;
-    private sendPresentation;
-    startPresentation(stream: MediaStream, { isNeedReinvite, isP2P, maxBitrate, contentHint, sendEncodings, onAddedTransceiver, }?: {
-        isNeedReinvite?: boolean;
+    get requestedConnection(): boolean;
+    get isPendingConnect(): boolean;
+    get isPendingInitUa(): boolean;
+    get connectionState(): import('./ConnectionManager/ConnectionStateMachine').EState;
+    get isRegistered(): boolean;
+    get isRegisterConfig(): boolean;
+    get socket(): import('@krivega/jssip').WebSocketInterface | undefined;
+    get requestedCall(): boolean;
+    get connection(): RTCPeerConnection | undefined;
+    get establishedRTCSession(): import('@krivega/jssip').RTCSession | undefined;
+    get isCallActive(): boolean;
+    get remoteCallerData(): IncomingCallManager['remoteCallerData'];
+    get isAvailableIncomingCall(): IncomingCallManager['isAvailableIncomingCall'];
+    connect: ConnectionManager['connect'];
+    set: ConnectionManager['set'];
+    disconnect: () => Promise<void>;
+    register: () => Promise<import('@krivega/jssip').RegisteredEvent>;
+    unregister: () => Promise<import('@krivega/jssip').UnRegisteredEvent>;
+    tryRegister: () => Promise<import('@krivega/jssip').RegisteredEvent>;
+    sendOptions: (target: Parameters<ConnectionManager["sendOptions"]>[0], body?: Parameters<ConnectionManager["sendOptions"]>[1], extraHeaders?: Parameters<ConnectionManager["sendOptions"]>[2]) => Promise<void>;
+    ping: (body?: Parameters<ConnectionManager["ping"]>[0], extraHeaders?: Parameters<ConnectionManager["ping"]>[1]) => Promise<void>;
+    checkTelephony: ConnectionManager['checkTelephony'];
+    onConnection<T>(eventName: TConnectionManagerEvent, handler: (data: T) => void): () => void;
+    onceConnection<T>(eventName: TConnectionManagerEvent, handler: (data: T) => void): () => void;
+    onceRaceConnection<T>(eventNames: TConnectionManagerEvent[], handler: (data: T, eventName: string) => void): () => void;
+    waitConnection<T>(eventName: TConnectionManagerEvent): Promise<T>;
+    offConnection<T>(eventName: TConnectionManagerEvent, handler: (data: T) => void): void;
+    isConfigured: () => boolean;
+    getConnectionConfiguration: () => import('./ConnectionManager/ConfigurationManager').IConnectionConfiguration;
+    getSipServerUrl: TGetServerUrl;
+    call: (params: Parameters<CallManager["startCall"]>[2]) => Promise<RTCPeerConnection>;
+    hangUp: CallManager['endCall'];
+    answerToIncomingCall: (params: Parameters<CallManager["answerToIncomingCall"]>[1]) => Promise<RTCPeerConnection>;
+    declineToIncomingCall: IncomingCallManager['declineToIncomingCall'];
+    getEstablishedRTCSession: CallManager['getEstablishedRTCSession'];
+    getCallConfiguration: CallManager['getCallConfiguration'];
+    getRemoteStreams: CallManager['getRemoteStreams'];
+    replaceMediaStream: CallManager['replaceMediaStream'];
+    onCall<T>(eventName: TCallEvent, handler: (data: T) => void): () => void;
+    onceCall<T>(eventName: TCallEvent, handler: (data: T) => void): () => void;
+    onceRaceCall<T>(eventNames: TCallEvent[], handler: (data: T, eventName: string) => void): () => void;
+    waitCall<T>(eventName: TCallEvent): Promise<T>;
+    offIncomingCall<T>(eventName: TIncomingCallEvent, handler: (data: T) => void): void;
+    onIncomingCall<T>(eventName: TIncomingCallEvent, handler: (data: T) => void): () => void;
+    onceIncomingCall<T>(eventName: TIncomingCallEvent, handler: (data: T) => void): () => void;
+    onceRaceIncomingCall<T>(eventNames: TIncomingCallEvent[], handler: (data: T, eventName: string) => void): () => void;
+    waitIncomingCall<T>(eventName: TIncomingCallEvent): Promise<T>;
+    offCall<T>(eventName: TCallEvent, handler: (data: T) => void): void;
+    startPresentation(stream: MediaStream, options?: {
         isP2P?: boolean;
+        isNeedReinvite?: boolean;
         maxBitrate?: number;
         contentHint?: TContentHint;
         sendEncodings?: RTCRtpEncodingParameters[];
         onAddedTransceiver?: TOnAddedTransceiver;
-    }, options?: {
-        callLimit: number;
+        callLimit?: number;
     }): Promise<MediaStream>;
-    private sendMustStopPresentation;
-    stopPresentation({ isP2P, }?: {
+    stopPresentation(options?: {
         isP2P?: boolean;
-    }): Promise<MediaStream | void>;
-    updatePresentation(stream: MediaStream, { isP2P, maxBitrate, contentHint, sendEncodings, onAddedTransceiver, }?: {
+    }): Promise<MediaStream | undefined>;
+    updatePresentation(stream: MediaStream, options?: {
         isP2P?: boolean;
+        isNeedReinvite?: boolean;
         maxBitrate?: number;
         contentHint?: TContentHint;
         sendEncodings?: RTCRtpEncodingParameters[];
         onAddedTransceiver?: TOnAddedTransceiver;
-    }): Promise<MediaStream | void>;
-    removeStreamPresentationCurrent(): void;
-    resetPresentation(): void;
-    cancelRequestsAndResetPresentation(): void;
-    handleNewRTCSession: ({ originator, session: rtcSession }: IncomingRTCSessionEvent) => void;
-    on<T>(eventName: TEventUA, handler: (data: T) => void): () => void;
-    once<T>(eventName: TEventUA, handler: (data: T) => void): () => void;
-    onceRace<T>(eventNames: TEventUA[], handler: (data: T, eventName: string) => void): () => void;
-    wait<T>(eventName: TEventUA): Promise<T>;
-    off<T>(eventName: TEventUA, handler: (data: T) => void): void;
-    onSession<T>(eventName: TEventSession, handler: (data: T) => void): () => void;
-    onceSession<T>(eventName: TEventSession, handler: (data: T) => void): () => void;
-    onceRaceSession<T>(eventNames: TEventSession[], handler: (data: T, eventName: string) => void): () => void;
-    waitSession<T>(eventName: TEventSession): Promise<T>;
-    offSession<T>(eventName: TEventSession, handler: (data: T) => void): void;
-    isConfigured(): boolean;
-    getConnectionConfiguration(): {
-        sipServerUrl?: string;
-        displayName?: string;
-        register?: boolean;
-        user?: string;
-        password?: string;
-        number?: string;
-        answer?: boolean;
-    };
-    getRemoteStreams(): MediaStream[] | undefined;
-    get connection(): RTCPeerConnection | undefined;
-    get remoteCallerData(): {
-        displayName: string | undefined;
-        host: string | undefined;
-        incomingNumber: string | undefined;
-        rtcSession: RTCSession | undefined;
-    };
-    get requested(): boolean;
-    get establishedRTCSession(): RTCSession | undefined;
-    get isRegistered(): boolean;
-    get isRegisterConfig(): boolean;
-    get isCallActive(): boolean;
-    get isAvailableIncomingCall(): boolean;
-    connectInner: TConnect;
-    initUa: TInitUa;
-    createUa: TCreateUa;
-    start: TStart;
-    set: TSet;
-    disconnect: () => Promise<void>;
-    call: TCall;
-    answerToIncomingCall: TAnswerToIncomingCall;
-    handleCall: ({ ontrack }: {
-        ontrack?: TOntrack;
-    }) => Promise<RTCPeerConnection>;
-    restoreSession: () => void;
-    sendDTMF: TSendDTMF;
-    generateStream(videoTrack: MediaStreamTrack, audioTrack?: MediaStreamTrack): MediaStream;
-    generateAudioStream(audioTrack: MediaStreamTrack): MediaStream;
-    generateStreams(remoteTracks: MediaStreamTrack[]): MediaStream[];
-    generateAudioStreams(remoteTracks: MediaStreamTrack[]): MediaStream[];
-    hangUpWithoutCancelRequests: THangUp;
-    cancelRequests(): void;
-    cancelConnectWithRepeatedCalls(): void;
-    cancelSendPresentationWithRepeatedCalls(): void;
-    handleShareState: (eventName: string) => void;
-    maybeTriggerChannels: (request: IncomingRequest) => void;
-    handleNotify: (header: TInfoNotify) => void;
-    triggerRemovedFromListModeratorsNotify: ({ conference, }: TRemovedFromListModeratorsInfoNotify) => void;
-    triggerAddedToListModeratorsNotify: ({ conference }: TAddedToListModeratorsInfoNotify) => void;
-    triggerWebcastStartedNotify: ({ body: { conference, type } }: TWebcastInfoNotify) => void;
-    triggerWebcastStoppedNotify: ({ body: { conference, type } }: TWebcastInfoNotify) => void;
-    triggerAccountChangedNotify: () => void;
-    triggerAccountDeletedNotify: () => void;
-    triggerConferenceParticipantTokenIssued: ({ body: { conference, participant, jwt }, }: TConferenceParticipantTokenIssued) => void;
-    triggerChannelsNotify: (channelsInfo: TChannelsInfoNotify) => void;
-    triggerParticipationAcceptingWordRequest: ({ body: { conference }, }: TAcceptingWordRequestInfoNotify) => void;
-    triggerParticipationCancellingWordRequest: ({ body: { conference }, }: TCancellingWordRequestInfoNotify) => void;
-    triggerParticipantMoveRequestToStream: ({ body: { conference }, }: TMoveRequestToStreamInfoNotify) => void;
-    triggerEnterRoom: (request: IncomingRequest) => void;
-    triggerShareState: (request: IncomingRequest) => void;
-    maybeTriggerParticipantMoveRequest: (request: IncomingRequest) => void;
-    triggerMainCamControl: (request: IncomingRequest) => void;
-    triggerMicControl: (request: IncomingRequest) => void;
-    triggerUseLicense: (request: IncomingRequest) => void;
-    handleNewInfo: (info: IncomingInfoEvent | OutgoingInfoEvent) => void;
-    handleSipEvent: ({ request }: {
-        request: IncomingRequest;
-    }) => void;
-    maybeHandleNotify: (request: IncomingRequest) => void;
-    waitChannels(): Promise<TChannels>;
-    waitSyncMediaState(): Promise<{
+    }): Promise<MediaStream | undefined>;
+    waitChannels(...args: Parameters<ApiManager['waitChannels']>): Promise<import('./ApiManager/types').TChannels>;
+    waitSyncMediaState(...args: Parameters<ApiManager['waitSyncMediaState']>): Promise<{
         isSyncForced: boolean;
     }>;
-    sendChannels({ inputChannels, outputChannels }: TChannels): Promise<void>;
-    sendMediaState({ cam, mic }: TMediaState, options?: TOptionsInfoMediaState): Promise<void>;
-    sendRefusalToTurnOn(type: 'cam' | 'mic', options?: TOptionsInfoMediaState): Promise<void>;
-    sendRefusalToTurnOnMic(options?: TOptionsInfoMediaState): Promise<void>;
-    sendRefusalToTurnOnCam(options?: TOptionsInfoMediaState): Promise<void>;
-    handleEnded: (error: TCustomError) => void;
+    sendDTMF(...args: Parameters<ApiManager['sendDTMF']>): Promise<void>;
+    sendChannels(...args: Parameters<ApiManager['sendChannels']>): Promise<void>;
+    sendMediaState(...args: Parameters<ApiManager['sendMediaState']>): Promise<void>;
+    sendRefusalToTurnOn(...args: Parameters<ApiManager['sendRefusalToTurnOn']>): Promise<void>;
+    sendRefusalToTurnOnMic(...args: Parameters<ApiManager['sendRefusalToTurnOnMic']>): Promise<void>;
+    sendRefusalToTurnOnCam(...args: Parameters<ApiManager['sendRefusalToTurnOnCam']>): Promise<void>;
+    sendMustStopPresentationP2P(...args: Parameters<ApiManager['sendMustStopPresentationP2P']>): Promise<void>;
+    sendStoppedPresentationP2P(...args: Parameters<ApiManager['sendStoppedPresentationP2P']>): Promise<void>;
+    sendStoppedPresentation(...args: Parameters<ApiManager['sendStoppedPresentation']>): Promise<void>;
+    askPermissionToStartPresentationP2P(...args: Parameters<ApiManager['askPermissionToStartPresentationP2P']>): Promise<void>;
+    askPermissionToStartPresentation(...args: Parameters<ApiManager['askPermissionToStartPresentation']>): Promise<void>;
+    askPermissionToEnableCam(...args: Parameters<ApiManager['askPermissionToEnableCam']>): Promise<void>;
+    onApi<T>(eventName: TApiEvent, handler: (data: T) => void): () => void;
+    onceApi<T>(eventName: TApiEvent, handler: (data: T) => void): () => void;
+    onceRaceApi<T>(eventNames: TApiEvent[], handler: (data: T, eventName: string) => void): () => void;
+    waitApi<T>(eventName: TApiEvent): Promise<T>;
+    offApi<T>(eventName: TApiEvent, handler: (data: T) => void): void;
 }
-export {};
+export default SipConnector;

package/dist/src/SipConnectorFacade/SipConnectorFacade.d.ts

@@ -2,16 +2,21 @@ import { UA } from '@krivega/jssip';
 import { default as SipConnector } from '../SipConnector';
 import { EUseLicense, TContentHint, TSimulcastEncoding } from '../types';
 interface IProxyMethods {
-    on: SipConnector['on'];
-    once: SipConnector['once'];
-    onceRace: SipConnector['onceRace'];
-    wait: SipConnector['wait'];
-    off: SipConnector['off'];
-    onSession: SipConnector['onSession'];
-    onceSession: SipConnector['onceSession'];
-    onceRaceSession: SipConnector['onceRaceSession'];
-    waitSession: SipConnector['waitSession'];
-    offSession: SipConnector['offSession'];
+    on: SipConnector['onConnection'];
+    once: SipConnector['onceConnection'];
+    onceRace: SipConnector['onceRaceConnection'];
+    wait: SipConnector['waitConnection'];
+    off: SipConnector['offConnection'];
+    onCall: SipConnector['onCall'];
+    onceCall: SipConnector['onceCall'];
+    onceRaceCall: SipConnector['onceRaceCall'];
+    waitCall: SipConnector['waitCall'];
+    offCall: SipConnector['offCall'];
+    onIncomingCall: SipConnector['onIncomingCall'];
+    onceIncomingCall: SipConnector['onceIncomingCall'];
+    onceRaceIncomingCall: SipConnector['onceRaceIncomingCall'];
+    waitIncomingCall: SipConnector['waitIncomingCall'];
+    offIncomingCall: SipConnector['offIncomingCall'];
     sendDTMF: SipConnector['sendDTMF'];
     hangUp: SipConnector['hangUp'];
     declineToIncomingCall: SipConnector['declineToIncomingCall'];
@@ -24,19 +29,21 @@ interface IProxyMethods {
     isRegistered: SipConnector['isRegistered'];
 }
 declare class SipConnectorFacade implements IProxyMethods {
-    readonly sipConnector: SipConnector;
-    private readonly preferredMimeTypesVideoCodecs?;
-    private readonly excludeMimeTypesVideoCodecs?;
     on: IProxyMethods['on'];
     once: IProxyMethods['once'];
     onceRace: IProxyMethods['onceRace'];
     wait: IProxyMethods['wait'];
     off: IProxyMethods['off'];
-    onSession: IProxyMethods['onSession'];
-    onceSession: IProxyMethods['onceSession'];
-    onceRaceSession: IProxyMethods['onceRaceSession'];
-    waitSession: IProxyMethods['waitSession'];
-    offSession: IProxyMethods['offSession'];
+    onCall: IProxyMethods['onCall'];
+    onceCall: IProxyMethods['onceCall'];
+    onceRaceCall: IProxyMethods['onceRaceCall'];
+    waitCall: IProxyMethods['waitCall'];
+    offCall: IProxyMethods['offCall'];
+    onIncomingCall: IProxyMethods['onIncomingCall'];
+    onceIncomingCall: IProxyMethods['onceIncomingCall'];
+    onceRaceIncomingCall: IProxyMethods['onceRaceIncomingCall'];
+    waitIncomingCall: IProxyMethods['waitIncomingCall'];
+    offIncomingCall: IProxyMethods['offIncomingCall'];
     sendDTMF: IProxyMethods['sendDTMF'];
     hangUp: IProxyMethods['hangUp'];
     declineToIncomingCall: IProxyMethods['declineToIncomingCall'];
@@ -47,6 +54,9 @@ declare class SipConnectorFacade implements IProxyMethods {
     connection: IProxyMethods['connection'];
     isConfigured: IProxyMethods['isConfigured'];
     isRegistered: IProxyMethods['isRegistered'];
+    readonly sipConnector: SipConnector;
+    private readonly preferredMimeTypesVideoCodecs?;
+    private readonly excludeMimeTypesVideoCodecs?;
     constructor(sipConnector: SipConnector, { preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, }?: {
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
@@ -94,7 +104,7 @@ declare class SipConnectorFacade implements IProxyMethods {
     disconnectFromServer: () => Promise<{
         isSuccessful: boolean;
     }>;
-    answerIncomingCall: (parameters: {
+    answerToIncomingCall: (parameters: {
         mediaStream: MediaStream;
         extraHeaders?: string[] | undefined;
         iceServers?: RTCIceServer[];
@@ -118,7 +128,7 @@ declare class SipConnectorFacade implements IProxyMethods {
             isSuccessProgressCall: boolean;
         }) => void;
         onEndedCall?: () => void;
-    }) => Promise<RTCPeerConnection | void>;
+    }) => Promise<RTCPeerConnection | undefined>;
     updatePresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, }: {
         mediaStream: MediaStream;
         isP2P: boolean;
@@ -129,8 +139,8 @@ declare class SipConnectorFacade implements IProxyMethods {
         sendEncodings?: RTCRtpEncodingParameters[];
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
-    }) => Promise<MediaStream | void>;
-    startPresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, }: {
+    }) => Promise<MediaStream | undefined>;
+    startPresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, callLimit, }: {
         mediaStream: MediaStream;
         isP2P: boolean;
         maxBitrate?: number;
@@ -140,12 +150,11 @@ declare class SipConnectorFacade implements IProxyMethods {
         sendEncodings?: RTCRtpEncodingParameters[];
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
-    }, options?: {
         callLimit: number;
-    }) => Promise<MediaStream | void>;
+    }) => Promise<MediaStream | undefined>;
     stopShareSipConnector: ({ isP2P }?: {
         isP2P?: boolean;
-    }) => Promise<void | MediaStream>;
+    }) => Promise<void | MediaStream | undefined>;
     sendRefusalToTurnOnMic: () => Promise<void>;
     sendRefusalToTurnOnCam: () => Promise<void>;
     sendMediaState: ({ isEnabledCam, isEnabledMic, }: {

package/dist/src/__fixtures__/BaseSession.mock.d.ts

@@ -11,21 +11,22 @@ declare class BaseSession implements RTCSession {
         audio: boolean;
         video: boolean;
     };
-    constructor({ originator, eventHandlers, }: {
+    constructor({ originator, eventHandlers, remoteIdentity, }: {
         originator?: string;
         eventHandlers: TEventHandlers;
+        remoteIdentity: NameAddrHeader;
     });
-    get C(): SessionStatus;
-    get causes(): constants.causes;
-    get id(): string;
-    set data(_data: unknown);
-    get data(): unknown;
     get contact(): string;
     get direction(): SessionDirection;
     get local_identity(): NameAddrHeader;
     get start_time(): Date;
     get end_time(): Date;
     get status(): SessionStatus;
+    get C(): SessionStatus;
+    get causes(): constants.causes;
+    get id(): string;
+    get data(): unknown;
+    set data(_data: unknown);
     isInProgress(): boolean;
     isEnded(): boolean;
     isReadyToReOffer(): boolean;
@@ -48,7 +49,7 @@ declare class BaseSession implements RTCSession {
     addListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     once(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     removeListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
-    off(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
+    off(eventName: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     removeAllListeners(_event?: string | symbol): this;
     setMaxListeners(_n: number): this;
     getMaxListeners(): number;
@@ -59,7 +60,7 @@ declare class BaseSession implements RTCSession {
     prependListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     prependOnceListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     eventNames(): (string | symbol)[];
-    initEvents(eventHandlers: TEventHandlers): void;
+    initEvents(eventHandlers?: TEventHandlers): void;
     on<T>(eventName: string, handler: (data: T) => void): this;
     trigger(eventName: TEventSession, data?: unknown): void;
     /**
@@ -71,7 +72,6 @@ declare class BaseSession implements RTCSession {
      */
     sendDTMF(): void;
     startPresentation(stream: MediaStream): Promise<MediaStream>;
-    updatePresentation(stream: MediaStream): Promise<MediaStream>;
     stopPresentation(stream: MediaStream): Promise<MediaStream>;
     isEstablished(): boolean;
 }

package/dist/src/__fixtures__/RTCPeerConnectionMock.d.ts

@@ -4,7 +4,6 @@ import { default as RTCRtpSenderMock } from './RTCRtpSenderMock';
 declare class RTCPeerConnectionMock implements RTCPeerConnectionDeprecated {
     senders: RTCRtpSender[];
     receivers: RTCRtpReceiver[];
-    constructor(_configuration?: RTCConfiguration, tracks: MediaStreamTrackMock[]);
     canTrickleIceCandidates: boolean | null;
     connectionState: RTCPeerConnectionState;
     currentLocalDescription: RTCSessionDescription | null;
@@ -29,6 +28,7 @@ declare class RTCPeerConnectionMock implements RTCPeerConnectionDeprecated {
     remoteDescription: RTCSessionDescription | null;
     sctp: null;
     signalingState: RTCSignalingState;
+    constructor(_configuration?: RTCConfiguration, tracks: MediaStreamTrackMock[]);
     getRemoteStreams(): MediaStream[];
     addIceCandidate(_candidate: RTCIceCandidate | RTCIceCandidateInit): Promise<void>;
     addTransceiver(_trackOrKind: MediaStreamTrack | string, _init?: RTCRtpTransceiverInit): RTCRtpTransceiver;

package/dist/src/__fixtures__/RTCSessionMock.d.ts

@@ -1,28 +1,14 @@
-import { IncomingInfoEvent } from '@krivega/jssip';
+import { IncomingInfoEvent, NameAddrHeader } from '@krivega/jssip';
 import { TEventHandlers, default as BaseSession } from './BaseSession.mock';
 export declare const FAILED_CONFERENCE_NUMBER = "777";
 export declare const createDeclineStartPresentationError: () => Error;
 declare class RTCSessionMock extends BaseSession {
-    url: string;
-    status_code?: number;
-    private isEndedInner;
+    private static presentationError?;
     private static startPresentationError?;
     private static countStartPresentationError;
     private static countStartsPresentation;
-    constructor({ url, mediaStream, eventHandlers, originator, }: {
-        url?: string;
-        mediaStream?: MediaStream;
-        eventHandlers: TEventHandlers;
-        originator: string;
-    });
-    static setStartPresentationError(startPresentationError: Error, { count }?: {
-        count?: number;
-    }): void;
-    static resetStartPresentationError(): void;
-    startPresentation(stream: MediaStream): Promise<MediaStream>;
-    initPeerconnection(mediaStream: MediaStream | undefined): boolean;
-    createPeerconnection(sendedStream: MediaStream): void;
-    connect(target: string): void;
+    url: string;
+    status_code?: number;
     /**
        * answer
        *
@@ -35,11 +21,31 @@ declare class RTCSessionMock extends BaseSession {
     answer: jest.Mock<void, [{
         mediaStream: MediaStream;
     }], any>;
+    replaceMediaStream: jest.Mock<Promise<void>, [_mediaStream: MediaStream], any>;
+    private isEndedInner;
+    constructor({ url, mediaStream, eventHandlers, originator, remoteIdentity, }: {
+        url?: string;
+        mediaStream?: MediaStream;
+        eventHandlers: TEventHandlers;
+        originator: string;
+        remoteIdentity?: NameAddrHeader;
+    });
+    static setPresentationError(presentationError: Error): void;
+    static resetPresentationError(): void;
+    static setStartPresentationError(startPresentationError: Error, { count }?: {
+        count?: number;
+    }): void;
+    static resetStartPresentationError(): void;
+    startPresentation: (stream: MediaStream) => Promise<MediaStream>;
+    stopPresentation: (stream: MediaStream) => Promise<MediaStream>;
+    initPeerconnection(mediaStream: MediaStream | undefined): boolean;
+    createPeerconnection(sendedStream: MediaStream): void;
+    connect(target: string): void;
     terminate({ status_code, cause }?: {
         status_code?: number;
         cause?: string;
     }): this;
-    terminateAsync({ status_code, cause }?: {
+    terminateAsync({ status_code, cause, }?: {
         status_code?: number;
         cause?: string;
     }): Promise<void>;
@@ -62,7 +68,6 @@ declare class RTCSessionMock extends BaseSession {
         audio: boolean;
         video: boolean;
     };
-    replaceMediaStream(_mediaStream: MediaStream): Promise<void>;
     onmute({ audio, video }: {
         audio: boolean;
         video: boolean;