sip-connector 14.0.0 → 14.0.1-0

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

@@ -1,7 +1,7 @@
 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?: TCustomError) => boolean;
+export declare const hasCanceledCallError: (error: unknown) => boolean;
 type TChannels = {
     inputChannels: string;
     outputChannels: string;
@@ -127,44 +127,34 @@ type TParametersCall = TParametersAnswerToIncomingCall & {
     number: string;
 };
 type TCall = (parameters: TParametersCall) => Promise<RTCPeerConnection>;
-type TDisconnect = () => Promise<void>;
 type TAnswerToIncomingCall = (parameters: TParametersAnswerToIncomingCall) => Promise<RTCPeerConnection>;
 type TSendDTMF = (tone: number | string) => Promise<void>;
 type THangUp = () => Promise<void>;
 export default class SipConnector {
-    private _isRegisterConfig;
-    private _connectionConfiguration;
-    private _remoteStreams;
+    private isRegisterConfigInner;
+    private connectionConfiguration;
+    private remoteStreams;
     private readonly JsSIP;
-    private readonly _sessionEvents;
-    private readonly _uaEvents;
-    private readonly _cancelableConnect;
-    private _cancelableConnectWithRepeatedCalls;
-    private _cancelableSendPresentationWithRepeatedCalls;
-    private readonly _cancelableInitUa;
-    private readonly _cancelableDisconnect;
-    private readonly _cancelableSet;
-    private readonly _cancelableCall;
-    private readonly _cancelableAnswer;
-    private readonly _cancelableSendDTMF;
+    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;
+    streamPresentationCurrent?: MediaStream;
     socket?: WebSocketInterface;
     constructor({ JsSIP }: {
         JsSIP: TJsSIP;
     });
     connect: TConnect;
-    initUa: TInitUa;
-    set: TSet;
-    call: TCall;
-    disconnect: TDisconnect;
-    answerToIncomingCall: TAnswerToIncomingCall;
-    sendDTMF: TSendDTMF;
     hangUp: THangUp;
     register(): Promise<RegisteredEvent>;
     unregister(): Promise<UnRegisteredEvent>;
@@ -187,11 +177,11 @@ export default class SipConnector {
     removeIncomingSession: () => void;
     askPermissionToEnableCam(options?: TOptionsInfoMediaState): Promise<void>;
     get isPendingPresentation(): boolean;
-    private readonly _connectWithDuplicatedCalls;
-    private _sendPresentationWithDuplicatedCalls;
+    private readonly connectWithDuplicatedCalls;
+    private sendPresentationWithDuplicatedCalls;
     private hasEqualConnectionConfiguration;
     private createUaConfiguration;
-    private _sendPresentation;
+    private sendPresentation;
     startPresentation(stream: MediaStream, { isNeedReinvite, isP2P, maxBitrate, contentHint, sendEncodings, onAddedTransceiver, }?: {
         isNeedReinvite?: boolean;
         isP2P?: boolean;
@@ -213,11 +203,11 @@ export default class SipConnector {
         sendEncodings?: RTCRtpEncodingParameters[];
         onAddedTransceiver?: TOnAddedTransceiver;
     }): Promise<MediaStream | void>;
-    _removeStreamPresentationCurrent(): void;
-    _resetPresentation(): void;
-    _cancelRequestsAndResetPresentation(): void;
+    removeStreamPresentationCurrent(): void;
+    resetPresentation(): void;
+    cancelRequestsAndResetPresentation(): void;
     handleNewRTCSession: ({ originator, session: rtcSession }: IncomingRTCSessionEvent) => void;
-    on<T = void>(eventName: TEventUA, handler: (data: T) => void): () => 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>;
@@ -251,64 +241,61 @@ export default class SipConnector {
     get isRegisterConfig(): boolean;
     get isCallActive(): boolean;
     get isAvailableIncomingCall(): boolean;
-    _connect: TConnect;
-    _initUa: TInitUa;
-    _createUa: TCreateUa;
-    _start: TStart;
-    _set: TSet;
-    _disconnectWithoutCancelRequests: TDisconnect;
-    _disconnect: () => Promise<void>;
-    _call: TCall;
-    _answer: TAnswerToIncomingCall;
-    _handleCall: ({ ontrack }: {
+    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;
-    _cancelCallRequests(): void;
-    _cancelActionsRequests(): 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 }: {
+    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;
+    maybeHandleNotify: (request: IncomingRequest) => 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>;
+    sendRefusalToTurnOn(type: 'cam' | 'mic', options?: TOptionsInfoMediaState): Promise<void>;
     sendRefusalToTurnOnMic(options?: TOptionsInfoMediaState): Promise<void>;
     sendRefusalToTurnOnCam(options?: TOptionsInfoMediaState): Promise<void>;
-    _handleEnded: (error: TCustomError) => void;
+    handleEnded: (error: TCustomError) => void;
 }
 export {};

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

@@ -1,33 +1,28 @@
 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;
+    set data(_data: unknown);
+    get data(): unknown;
     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;
@@ -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,8 +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[];
+    senders: RTCRtpSender[];
+    receivers: RTCRtpReceiver[];
     constructor(_configuration?: RTCConfiguration, tracks: MediaStreamTrackMock[]);
     canTrickleIceCandidates: boolean | null;
     connectionState: RTCPeerConnectionState;
@@ -14,15 +14,15 @@ 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;
@@ -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,18 @@
 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 isEndedInner;
     private static startPresentationError?;
     private static countStartPresentationError;
     private static countStartsPresentation;
     constructor({ url, mediaStream, eventHandlers, originator, }: {
         url?: string;
-        mediaStream?: any;
-        eventHandlers?: any;
+        mediaStream?: MediaStream;
+        eventHandlers: TEventHandlers;
         originator: string;
     });
     static setStartPresentationError(startPresentationError: Error, { count }?: {
@@ -20,8 +20,8 @@ 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
@@ -32,42 +32,38 @@ declare class RTCSessionMock extends BaseSession {
   
    * @returns {undefined}
        */
-    answer: jest.Mock<void, [any], any>;
-    terminate({ status_code }?: {
+    answer: jest.Mock<void, [{
+        mediaStream: MediaStream;
+    }], any>;
+    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,32 @@
-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 }?: {
+    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;
+    events: Events<readonly (keyof UAEventMap)[]>;
+    private startedTimeout?;
+    private stopedTimeout?;
+    private session?;
+    private isRegisteredInner?;
+    private isConnectedInner?;
+    private configuration;
+    readonly registratorInner: Registrator;
     constructor(_configuration: UAConfigurationParams);
-    isConnected(): boolean;
     /**
      * start
      *
@@ -50,27 +39,22 @@ 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;
+    call: jest.Mock<RTCSessionMock, [url: string, parameters: {
+        mediaStream: MediaStream;
+        eventHandlers: TEventHandlers;
+    }], any>;
+    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;

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

@@ -1,5 +1,5 @@
 export declare const channelsHeaders: [string, string][];
 export declare const channelsData: {
-    inputChannels: any;
-    outputChannels: any;
+    inputChannels: string;
+    outputChannels: string;
 };

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

@@ -9,7 +9,7 @@ declare const jssip: {
         displayName: string;
         host: string;
     }) => void;
-    triggerFailIncomingSession: (incomingSession: unknown, options?: {
+    triggerFailIncomingSession: (incomingSession: RTCSession, options?: {
         originator: "local" | "remote";
     }) => void;
     WebSocketInterface: typeof WebSocketInterfaceMock;

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

@@ -1,8 +1,8 @@
 export declare const removedFromListModeratorsHeaders: [string, string][];
 export declare const removedFromListModeratorsData: {
-    conference: any;
+    conference: string;
 };
 export declare const addedToListModeratorsHeaders: [string, string][];
 export declare const addedToListModeratorsData: {
-    conference: any;
+    conference: string;
 };

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

@@ -72,3 +72,8 @@ export declare const PRESENTATION_FAILED = "presentation:failed";
 export declare const SPECTATOR = "SPECTATOR";
 export declare const PARTICIPANT = "PARTICIPANT";
 export declare const ONE_MEGABIT_IN_BITS = 1000000;
+export declare enum Originator {
+    LOCAL = "local",
+    REMOTE = "remote",
+    SYSTEM = "system"
+}

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

@@ -1,4 +1,5 @@
 import { UA, WebSocketInterface } from '@krivega/jssip';
+import { Originator } from './constants';
 export declare enum EEventsMainCAM {
     PAUSE_MAIN_CAM = "PAUSEMAINCAM",
     RESUME_MAIN_CAM = "RESUMEMAINCAM",
@@ -20,7 +21,7 @@ export declare enum EUseLicense {
     AUDIOPLUSPRESENTATION = "AUDIOPLUSPRESENTATION"
 }
 export type TCustomError = Error & {
-    originator?: string;
+    originator?: Originator;
     cause?: unknown;
     message: unknown;
     _ws?: unknown;