sip-connector 14.1.0 → 14.1.2-0

package/dist/src/SipConnector.d.ts

@@ -0,0 +1,235 @@
+import { RTCSession, RegisteredEvent, UA, URI, UnRegisteredEvent, WebSocketInterface } from '@krivega/jssip';
+import { TEventSession, TEventUA } from './eventNames';
+import { TContentHint, TJsSIP, TOnAddedTransceiver } from './types';
+export declare const hasCanceledCallError: (error: unknown) => boolean;
+export declare const hasCanceledStartPresentationError: (error: unknown) => error is import('node_modules/repeated-calls/dist/utils').TCanceledError<unknown>;
+type TChannels = {
+    inputChannels: string;
+    outputChannels: string;
+};
+type TMediaState = {
+    cam: boolean;
+    mic: boolean;
+};
+type TOptionsInfoMediaState = {
+    noTerminateWhenError?: boolean;
+};
+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 TConnect = (parameters: TParametersConnection, options?: {
+    callLimit?: number;
+}) => 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 {
+    promisePendingStartPresentation?: Promise<MediaStream>;
+    promisePendingStopPresentation?: Promise<MediaStream | undefined>;
+    ua?: UA;
+    rtcSession?: RTCSession;
+    incomingRTCSession?: RTCSession;
+    streamPresentationCurrent?: MediaStream;
+    socket?: WebSocketInterface;
+    private isRegisterConfigInner;
+    private connectionConfiguration;
+    private remoteStreams;
+    private readonly JsSIP;
+    private readonly sessionEvents;
+    private readonly uaEvents;
+    private cancelableConnectWithRepeatedCalls;
+    private cancelableSendPresentationWithRepeatedCalls;
+    private isPendingConnect;
+    private isPendingInitUa;
+    private isPendingCall;
+    private isPendingAnswer;
+    constructor({ JsSIP }: {
+        JsSIP: TJsSIP;
+    });
+    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;
+    get isPendingPresentation(): boolean;
+    connect: TConnect;
+    hangUp: THangUp;
+    register(): Promise<RegisteredEvent>;
+    unregister(): Promise<UnRegisteredEvent>;
+    readonly 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;
+    }) => Promise<void>;
+    busyIncomingCall: () => Promise<void>;
+    askPermissionToEnableCam(options?: TOptionsInfoMediaState): Promise<void>;
+    startPresentation(stream: MediaStream, { isNeedReinvite, isP2P, maxBitrate, contentHint, sendEncodings, onAddedTransceiver, }?: {
+        isNeedReinvite?: boolean;
+        isP2P?: boolean;
+        maxBitrate?: number;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+    }, options?: {
+        callLimit: number;
+    }): Promise<MediaStream>;
+    stopPresentation({ isP2P, }?: {
+        isP2P?: boolean;
+    }): Promise<MediaStream | undefined>;
+    updatePresentation(stream: MediaStream, { isP2P, maxBitrate, contentHint, sendEncodings, onAddedTransceiver, }?: {
+        isP2P?: boolean;
+        maxBitrate?: number;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+    }): Promise<MediaStream | undefined>;
+    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;
+    getIncomingRTCSession(): RTCSession;
+    set: TSet;
+    disconnect: () => Promise<void>;
+    call: TCall;
+    answerToIncomingCall: TAnswerToIncomingCall;
+    sendDTMF: TSendDTMF;
+    cancelSendPresentationWithRepeatedCalls(): void;
+    waitChannels(): Promise<TChannels>;
+    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>;
+    private readonly removeIncomingSession;
+    private getSipServerUrl;
+    private sendMustStopPresentation;
+    private readonly connectWithDuplicatedCalls;
+    private sendPresentationWithDuplicatedCalls;
+    private hasEqualConnectionConfiguration;
+    private createUaConfiguration;
+    private sendPresentation;
+    private removeStreamPresentationCurrent;
+    private resetPresentation;
+    private cancelRequestsAndResetPresentation;
+    private readonly handleNewRTCSession;
+    private readonly connectInner;
+    private readonly initUa;
+    private readonly createUa;
+    private readonly start;
+    private readonly handleCall;
+    private readonly restoreSession;
+    private generateStream;
+    private generateAudioStream;
+    private generateStreams;
+    private generateAudioStreams;
+    private readonly hangUpWithoutCancelRequests;
+    private cancelRequests;
+    private cancelConnectWithRepeatedCalls;
+    private readonly handleShareState;
+    private readonly maybeTriggerChannels;
+    private readonly handleNotify;
+    private readonly triggerRemovedFromListModeratorsNotify;
+    private readonly triggerAddedToListModeratorsNotify;
+    private readonly triggerWebcastStartedNotify;
+    private readonly triggerWebcastStoppedNotify;
+    private readonly triggerAccountChangedNotify;
+    private readonly triggerAccountDeletedNotify;
+    private readonly triggerConferenceParticipantTokenIssued;
+    private readonly triggerChannelsNotify;
+    private readonly triggerParticipationAcceptingWordRequest;
+    private readonly triggerParticipationCancellingWordRequest;
+    private readonly triggerParticipantMoveRequestToStream;
+    private readonly triggerEnterRoom;
+    private readonly triggerShareState;
+    private readonly maybeTriggerParticipantMoveRequest;
+    private readonly triggerMainCamControl;
+    private readonly triggerMicControl;
+    private readonly triggerUseLicense;
+    private readonly handleNewInfo;
+    private readonly handleSipEvent;
+    private readonly maybeHandleNotify;
+    private readonly handleEnded;
+}
+export {};

package/dist/{SipConnectorFacade → src/SipConnectorFacade}/SipConnectorFacade.d.ts

@@ -24,9 +24,6 @@ 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'];
@@ -47,6 +44,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[];
@@ -118,7 +118,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,7 +129,7 @@ declare class SipConnectorFacade implements IProxyMethods {
         sendEncodings?: RTCRtpEncodingParameters[];
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
-    }) => Promise<MediaStream | void>;
+    }) => Promise<MediaStream | undefined>;
     startPresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, }: {
         mediaStream: MediaStream;
         isP2P: boolean;
@@ -142,10 +142,10 @@ declare class SipConnectorFacade implements IProxyMethods {
         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/{__fixtures__ → src/__fixtures__}/BaseSession.mock.d.ts

@@ -1,36 +1,31 @@
 import { AnswerOptions, ExtraHeaders, HoldOptions, MediaStreamTypes, NameAddrHeader, OnHoldResult, RTCPeerConnectionDeprecated, RTCSession, ReferOptions, RenegotiateOptions, SessionDirection, SessionStatus, TerminateOptions, URI, C as constants } from '@krivega/jssip';
 import { default as Events } from 'events-constructor';
 import { TEventSession, SESSION_EVENT_NAMES } from '../eventNames';
-/**
- * BaseSession
- * @class
- */
+export type TEventHandlers = Record<string, (data: unknown) => void>;
 declare class BaseSession implements RTCSession {
     originator: string;
-    _connection: RTCPeerConnectionDeprecated;
-    _events: Events<typeof SESSION_EVENT_NAMES>;
-    _remote_identity: NameAddrHeader;
-    _mutedOptions: {
+    connection: RTCPeerConnectionDeprecated;
+    events: Events<typeof SESSION_EVENT_NAMES>;
+    remote_identity: NameAddrHeader;
+    mutedOptions: {
         audio: boolean;
         video: boolean;
     };
-    constructor({ originator, eventHandlers }: {
-        originator?: string | undefined;
-        eventHandlers: any;
+    constructor({ originator, eventHandlers, }: {
+        originator?: string;
+        eventHandlers: TEventHandlers;
     });
-    get C(): SessionStatus;
-    get causes(): constants.causes;
-    get id(): string;
-    set data(_data: any);
-    get data(): any;
-    get connection(): RTCPeerConnectionDeprecated;
     get contact(): string;
     get direction(): SessionDirection;
     get local_identity(): NameAddrHeader;
-    get remote_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;
@@ -50,30 +45,23 @@ declare class BaseSession implements RTCSession {
         deleteExisting: boolean;
         addMissing: boolean;
     }): Promise<void>;
-    addListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
-    once(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
-    removeListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
-    off(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
+    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;
     removeAllListeners(_event?: string | symbol): this;
     setMaxListeners(_n: number): this;
     getMaxListeners(): number;
     listeners(_event: string | symbol): (() => void)[];
     rawListeners(_event: string | symbol): (() => void)[];
-    emit(_event: string | symbol, ..._arguments_: any[]): boolean;
+    emit(_event: string | symbol, ..._arguments_: unknown[]): boolean;
     listenerCount(_event: string | symbol): number;
-    prependListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
-    prependOnceListener(_event: string | symbol, _listener: (...arguments_: any[]) => void): this;
+    prependListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
+    prependOnceListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     eventNames(): (string | symbol)[];
-    /**
-     * initEvents
-     *
-     * @param {Array} [eventHandlers=[] - ]  The event handlers
-     *
-     * @returns {undefined}
-     */
-    initEvents(eventHandlers?: never[]): void;
+    initEvents(eventHandlers: TEventHandlers): void;
     on<T>(eventName: string, handler: (data: T) => void): this;
-    trigger(eventName: TEventSession, data?: any): void;
+    trigger(eventName: TEventSession, data?: unknown): void;
     /**
      * sendDTMF
      *

package/dist/{__fixtures__ → src/__fixtures__}/RTCPeerConnectionMock.d.ts

@@ -2,9 +2,8 @@ import { RTCPeerConnectionDeprecated } from '@krivega/jssip';
 import { MediaStreamTrackMock } from 'webrtc-mock';
 import { default as RTCRtpSenderMock } from './RTCRtpSenderMock';
 declare class RTCPeerConnectionMock implements RTCPeerConnectionDeprecated {
-    _senders: RTCRtpSender[];
-    _receivers: any[];
-    constructor(_configuration?: RTCConfiguration, tracks: MediaStreamTrackMock[]);
+    senders: RTCRtpSender[];
+    receivers: RTCRtpReceiver[];
     canTrickleIceCandidates: boolean | null;
     connectionState: RTCPeerConnectionState;
     currentLocalDescription: RTCSessionDescription | null;
@@ -14,21 +13,22 @@ declare class RTCPeerConnectionMock implements RTCPeerConnectionDeprecated {
     idpErrorInfo: string | null;
     idpLoginUrl: string | null;
     localDescription: RTCSessionDescription | null;
-    onconnectionstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    ondatachannel: ((this: RTCPeerConnection, event_: RTCDataChannelEvent) => any) | null;
-    onicecandidate: ((this: RTCPeerConnection, event_: RTCPeerConnectionIceEvent) => any) | null;
-    onicecandidateerror: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    oniceconnectionstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    onicegatheringstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    onnegotiationneeded: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    onsignalingstatechange: ((this: RTCPeerConnection, event_: Event) => any) | null;
-    ontrack: ((this: RTCPeerConnection, event_: RTCTrackEvent) => any) | null;
+    onconnectionstatechange: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    ondatachannel: ((this: RTCPeerConnection, event_: RTCDataChannelEvent) => unknown) | null;
+    onicecandidate: ((this: RTCPeerConnection, event_: RTCPeerConnectionIceEvent) => unknown) | null;
+    onicecandidateerror: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    oniceconnectionstatechange: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    onicegatheringstatechange: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    onnegotiationneeded: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    onsignalingstatechange: ((this: RTCPeerConnection, event_: Event) => unknown) | null;
+    ontrack: ((this: RTCPeerConnection, event_: RTCTrackEvent) => unknown) | null;
     peerIdentity: undefined;
     pendingLocalDescription: RTCSessionDescription | null;
     pendingRemoteDescription: RTCSessionDescription | null;
     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;
@@ -47,12 +47,12 @@ declare class RTCPeerConnectionMock implements RTCPeerConnectionDeprecated {
     setConfiguration(_configuration: RTCConfiguration): void;
     setLocalDescription(_description: RTCSessionDescriptionInit): Promise<void>;
     setRemoteDescription(_description: RTCSessionDescriptionInit): Promise<void>;
-    addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, event_: RTCPeerConnectionEventMap[K]) => any, options?: AddEventListenerOptions | boolean): void;
+    addEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, event_: RTCPeerConnectionEventMap[K]) => unknown, options?: AddEventListenerOptions | boolean): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: AddEventListenerOptions | boolean): void;
-    removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, event_: RTCPeerConnectionEventMap[K]) => any, options?: EventListenerOptions | boolean): void;
+    removeEventListener<K extends keyof RTCPeerConnectionEventMap>(type: K, listener: (this: RTCPeerConnection, event_: RTCPeerConnectionEventMap[K]) => unknown, options?: EventListenerOptions | boolean): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: EventListenerOptions | boolean): void;
     dispatchEvent(_event: Event): boolean;
-    getReceivers: () => any[];
+    getReceivers: () => RTCRtpReceiver[];
     getSenders: () => RTCRtpSender[];
     addTrack: (track: MediaStreamTrack) => RTCRtpSenderMock;
 }

package/dist/{__fixtures__ → src/__fixtures__}/RTCRtpSenderMock.d.ts

@@ -3,8 +3,8 @@ declare class RTCRtpSenderMock implements RTCRtpSender {
     track: MediaStreamTrack | null;
     transport: RTCDtlsTransport | null;
     transform: RTCRtpTransform | null;
-    private _parameters;
-    private _parametersGets?;
+    private parameters;
+    private parametersGets?;
     constructor({ track }?: {
         track?: MediaStreamTrack;
     });

package/dist/{__fixtures__ → src/__fixtures__}/RTCSessionMock.d.ts

@@ -1,18 +1,30 @@
 import { IncomingInfoEvent } from '@krivega/jssip';
-import { default as BaseSession } from './BaseSession.mock';
+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 _isEnded;
     private static startPresentationError?;
     private static countStartPresentationError;
     private static countStartsPresentation;
+    url: string;
+    status_code?: number;
+    /**
+       * answer
+       *
+       * @param {Object} arg1               - The argument 1
+       * @param {Object} arg1.mediaStream   - The media stream
+       * @param {Array}  arg1.eventHandlers - The event handlers
+  
+   * @returns {undefined}
+       */
+    answer: jest.Mock<void, [{
+        mediaStream: MediaStream;
+    }], any>;
+    private isEndedInner;
     constructor({ url, mediaStream, eventHandlers, originator, }: {
         url?: string;
-        mediaStream?: any;
-        eventHandlers?: any;
+        mediaStream?: MediaStream;
+        eventHandlers: TEventHandlers;
         originator: string;
     });
     static setStartPresentationError(startPresentationError: Error, { count }?: {
@@ -20,54 +32,38 @@ declare class RTCSessionMock extends BaseSession {
     }): void;
     static resetStartPresentationError(): void;
     startPresentation(stream: MediaStream): Promise<MediaStream>;
-    initPeerconnection(mediaStream: any): boolean;
-    createPeerconnection(sendedStream: any): void;
+    initPeerconnection(mediaStream: MediaStream | undefined): boolean;
+    createPeerconnection(sendedStream: MediaStream): void;
     connect(target: string): void;
-    /**
-       * answer
-       *
-       * @param {Object} arg1               - The argument 1
-       * @param {Object} arg1.mediaStream   - The media stream
-       * @param {Array}  arg1.eventHandlers - The event handlers
-  
-   * @returns {undefined}
-       */
-    answer: jest.Mock<void, [any], any>;
-    terminate({ status_code }?: {
+    terminate({ status_code, cause }?: {
         status_code?: number;
+        cause?: string;
     }): this;
-    terminateAsync({ status_code }?: {
+    terminateAsync({ status_code, cause, }?: {
         status_code?: number;
+        cause?: string;
     }): Promise<void>;
     terminateRemote({ status_code }?: {
         status_code?: number;
     }): this;
-    _addStream(stream: Record<string, () => any[]>, action?: string): void;
-    _forEachSenders(callback: {
-        ({ track }: {
-            track: any;
-        }): void;
-        ({ track }: {
-            track: any;
-        }): void;
-        (argument0: any): void;
-    }): RTCRtpSender[];
-    _toggleMuteAudio(mute: boolean): void;
-    _toggleMuteVideo(mute: boolean): void;
+    addStream(stream: MediaStream, action?: 'getTracks' | 'getAudioTracks' | 'getVideoTracks'): void;
+    forEachSenders(callback: (sender: RTCRtpSender) => void): RTCRtpSender[];
+    toggleMuteAudio(mute: boolean): void;
+    toggleMuteVideo(mute: boolean): void;
     mute(options: {
-        audio: any;
-        video: any;
+        audio: boolean;
+        video: boolean;
     }): void;
     unmute(options: {
-        audio: any;
-        video: any;
+        audio: boolean;
+        video: boolean;
     }): void;
     isMuted(): {
         audio: boolean;
         video: boolean;
     };
-    replaceMediaStream(mediaStream: any): Promise<any>;
-    _onmute({ audio, video }: {
+    replaceMediaStream(_mediaStream: MediaStream): Promise<void>;
+    onmute({ audio, video }: {
         audio: boolean;
         video: boolean;
     }): void;

package/dist/{__fixtures__ → src/__fixtures__}/UA.mock.d.ts

@@ -1,43 +1,36 @@
-import { UA as IUA, IncomingRequest, UAConfiguration, UAConfigurationParams } from '@krivega/jssip';
+import { DisconnectEvent, UA as IUA, IncomingRequest, UAConfiguration, UAConfigurationParams, UAEventMap } from '@krivega/jssip';
 import { default as Events } from 'events-constructor';
-import { TEventUA, UA_EVENT_NAMES } from '../eventNames';
+import { TEventHandlers } from './BaseSession.mock';
 import { default as Registrator } from './Registrator.mock';
 import { default as RTCSessionMock } from './RTCSessionMock';
 export declare const PASSWORD_CORRECT = "PASSWORD_CORRECT";
 export declare const PASSWORD_CORRECT_2 = "PASSWORD_CORRECT_2";
 export declare const NAME_INCORRECT = "NAME_INCORRECT";
-export declare const createWebsocketHandshakeTimeoutError: (sipServerUrl: string) => {
-    socket: {
-        _url: string;
-        _sip_uri: string;
-        _via_transport: string;
-        _ws: null;
-    };
-    error: boolean;
-    code: number;
-    reason: string;
-};
+export declare const createWebsocketHandshakeTimeoutError: (sipServerUrl: string) => DisconnectEvent;
 declare class UA implements IUA {
     private static isAvailableTelephony;
     private static startError?;
     private static countStartError;
     private static countStarts;
-    static setStartError(startError: unknown, { count }?: {
+    events: Events<readonly (keyof UAEventMap)[]>;
+    readonly registratorInner: Registrator;
+    call: jest.Mock<RTCSessionMock, [url: string, parameters: {
+        mediaStream: MediaStream;
+        eventHandlers: TEventHandlers;
+    }], any>;
+    private startedTimeout?;
+    private stopedTimeout?;
+    private session?;
+    private isRegisteredInner?;
+    private isConnectedInner?;
+    private configuration;
+    constructor(_configuration: UAConfigurationParams);
+    static setStartError(startError: DisconnectEvent, { count }?: {
         count?: number;
     }): void;
     static resetStartError(): void;
     static setAvailableTelephony(): void;
     static setNotAvailableTelephony(): void;
-    _events: Events<typeof UA_EVENT_NAMES>;
-    _startedTimeout?: ReturnType<typeof setTimeout>;
-    _stopedTimeout?: ReturnType<typeof setTimeout>;
-    session?: RTCSessionMock;
-    _isRegistered?: boolean;
-    _isConnected?: boolean;
-    configuration: UAConfiguration;
-    _registrator: Registrator;
-    constructor(_configuration: UAConfigurationParams);
-    isConnected(): boolean;
     /**
      * start
      *
@@ -50,27 +43,18 @@ declare class UA implements IUA {
      * @returns {undefined}
      */
     stop(): void;
-    call: jest.Mock<RTCSessionMock, [url: string, parameters: any], any>;
-    on(eventName: TEventUA, handler: any): this;
-    once(eventName: TEventUA, handler: any): this;
-    off(eventName: TEventUA, handler: any): this;
+    on<T extends keyof UAEventMap>(eventName: T, handler: UAEventMap[T]): this;
+    once<T extends keyof UAEventMap>(eventName: T, handler: UAEventMap[T]): this;
+    off<T extends keyof UAEventMap>(eventName: T, handler: UAEventMap[T]): this;
     removeAllListeners(): this;
-    trigger(eventName: TEventUA, data?: any): void;
+    trigger<T extends keyof UAEventMap>(eventName: T, data: Parameters<UAEventMap[T]>[0]): void;
     /**
      * terminateSessions
      *
      * @returns {undefined}
      */
     terminateSessions(): void;
-    /**
-     * set
-     *
-     * @param {string} key   - key
-     * @param {string} value - value
-     *
-     * @returns {boolean} true
-     */
-    set(key: string, value: any): boolean;
+    set(key: keyof UAConfiguration, value: UAConfiguration[keyof UAConfiguration]): boolean;
     /**
      * register
      *
@@ -83,21 +67,18 @@ declare class UA implements IUA {
      * @returns {undefined}
      */
     unregister(): void;
-    /**
-     * isRegistered
-     *
-     * @returns {boolean} isRegistered
-     */
     isRegistered(): boolean;
+    isConnected(): boolean;
     /**
      * isStarted
      *
      * @returns {boolean} isStarted
      */
     isStarted(): boolean;
-    registrator(): Registrator;
     newSipEvent(data: {
+        event: unknown;
         request: IncomingRequest;
     }): void;
+    registrator(): Registrator;
 }
 export default UA;