opensips-js 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1044 @@
+import { AnswerOptions } from 'jssip/lib/RTCSession';
+import { CallListener } from 'jssip/lib/RTCSession';
+import { ConfirmedListener } from 'jssip/lib/RTCSession';
+import { ConnectingListener } from 'jssip/lib/RTCSession';
+import { DTMFListener } from 'jssip/lib/RTCSession';
+import { EndEvent } from 'jssip/lib/RTCSession';
+import { EndListener } from 'jssip/lib/RTCSession';
+import { EventEmitter } from 'events';
+import { ExtraContactParams } from 'jssip/lib/Registrator';
+import { HoldListener } from 'jssip/lib/RTCSession';
+import { IceCandidateListener } from 'jssip/lib/RTCSession';
+import { IncomingAckEvent } from 'jssip/lib/RTCSession';
+import { IncomingEvent } from 'jssip/lib/RTCSession';
+import { IncomingRequest } from 'jssip/lib/SIPMessage';
+import { InfoListener } from 'jssip/lib/RTCSession';
+import { MediaConstraints } from 'jssip/lib/RTCSession';
+import { MuteListener } from 'jssip/lib/RTCSession';
+import { OnHoldResult } from 'jssip/lib/RTCSession';
+import { Originator } from 'jssip/lib/RTCSession';
+import { OutgoingAckEvent } from 'jssip/lib/RTCSession';
+import { OutgoingEvent } from 'jssip/lib/RTCSession';
+import { PeerConnectionListener } from 'jssip/lib/RTCSession';
+import { ReferListener } from 'jssip/lib/RTCSession';
+import { ReInviteListener } from 'jssip/lib/RTCSession';
+import { RTCPeerConnectionDeprecated } from 'jssip/lib/RTCSession';
+import { RTCSession } from 'jssip/lib/RTCSession';
+import { RTCSessionEventMap } from 'jssip/lib/RTCSession';
+import { SDPListener } from 'jssip/lib/RTCSession';
+import { SendingListener } from 'jssip/lib/RTCSession';
+import { SessionDirection } from 'jssip/lib/RTCSession';
+import { UA } from 'jssip';
+import { UAConfiguration } from 'jssip/lib/UA';
+import { UAEventMap } from 'jssip/lib/UA';
+import { UpdateListener } from 'jssip/lib/RTCSession';
+
+declare type ActiveRoomListener = (event: number | undefined) => void
+
+declare type addRoomListener = (value: RoomChangeEmitType) => void
+
+declare interface AnswerOptionsExtended extends AnswerOptions {
+    mediaConstraints?: MediaConstraints | ExactConstraints
+}
+
+declare interface AnswerOptionsExtended_2 extends AnswerOptions {
+    mediaConstraints?: MediaConstraints | ExactConstraints_2
+}
+
+declare class AudioModule {
+    private context;
+    private currentActiveRoomIdValue;
+    private isAutoAnswer;
+    private isCallAddingInProgress;
+    private muteWhenJoinEnabled;
+    private isDNDEnabled;
+    private isCallWaitingEnabled;
+    private muted;
+    private microphoneInputLevelValue;
+    private speakerVolumeValue;
+    private activeRooms;
+    private activeCalls;
+    private extendedCalls;
+    private availableMediaDevices;
+    private selectedMediaDevices;
+    private callStatus;
+    private callTime;
+    private callMetrics;
+    private timeIntervals;
+    private metricConfig;
+    private activeStreamValue;
+    private initialStreamValue;
+    private VUMeter;
+    constructor(context: OpenSIPSJS);
+    get sipOptions(): {
+        mediaConstraints: {
+            video: boolean;
+            audio: boolean;
+        } | {
+            audio: {
+                deviceId: {
+                    exact: string;
+                };
+            };
+            video: boolean;
+        };
+        session_timers: boolean;
+        extraHeaders: [string];
+        pcConfig: RTCConfiguration_2;
+    };
+    get currentActiveRoomId(): number | undefined;
+    private set currentActiveRoomId(value);
+    get autoAnswer(): boolean;
+    get callAddingInProgress(): string | undefined;
+    private set callAddingInProgress(value);
+    get muteWhenJoin(): boolean;
+    get isDND(): boolean;
+    /**
+     * Gets the current state of the call waiting feature.
+     *
+     * When call waiting is enabled (true), incoming calls will be allowed even when
+     * other calls are active.
+     *
+     * When call waiting is disabled (false) and there are already active calls,
+     * any new incoming calls will be automatically rejected with a "busy" status.
+     *
+     * @returns {boolean} True if call waiting is enabled, false if disabled
+     */
+    get isCallWaiting(): boolean;
+    get speakerVolume(): number;
+    get microphoneInputLevel(): number;
+    get getActiveCalls(): {
+        [key: string]: ICall;
+    };
+    get hasActiveCalls(): boolean;
+    get hasActiveAnsweredCalls(): boolean;
+    get getActiveRooms(): {
+        [key: number]: IRoom;
+    };
+    get isMuted(): boolean;
+    get getInputDeviceList(): MediaDeviceInfo[];
+    get getOutputDeviceList(): MediaDeviceInfo[];
+    get getUserMediaConstraints(): {
+        video: boolean;
+        audio: boolean;
+    } | {
+        audio: {
+            deviceId: {
+                exact: string;
+            };
+        };
+        video: boolean;
+    };
+    get selectedInputDevice(): string;
+    get selectedOutputDevice(): string;
+    get activeStream(): MediaStream;
+    private setAvailableMediaDevices;
+    updateDeviceList(): Promise<void>;
+    private initializeMediaDevices;
+    setCallTime(value: ITimeData): void;
+    removeCallTime(callId: string): void;
+    private setTimeInterval;
+    private removeTimeInterval;
+    private stopCallTimer;
+    private emitVolumeChange;
+    setMetricsConfig(config: WebrtcMetricsConfigType): void;
+    sendDTMF(callId: string, value: string): void;
+    private setIsMuted;
+    private processMute;
+    mute(): void;
+    unmute(): void;
+    private processHold;
+    holdCall(callId: string, automatic?: boolean): Promise<void>;
+    unholdCall(callId: string): Promise<void>;
+    private cancelAllOutgoingUnanswered;
+    answerCall(callId: string): void;
+    moveCall(callId: string, roomId: number): Promise<void>;
+    updateCall(value: ICall): void;
+    updateRoom(value: IRoomUpdate): void;
+    private hasAutoAnswerHeaders;
+    private addCall;
+    private addCallStatus;
+    private updateCallStatus;
+    private removeCallStatus;
+    private addRoom;
+    private getActiveStream;
+    setMicrophone(dId: string): Promise<void>;
+    private setActiveStream;
+    setSpeaker(dId: string): Promise<void>;
+    private removeRoom;
+    private deleteRoomIfEmpty;
+    private checkInitialized;
+    private muteReconfigure;
+    private roomReconfigure;
+    private doConference;
+    private processCallerMute;
+    muteCaller(callId: string): void;
+    unmuteCaller(callId: string): void;
+    terminateCall(callId: string): void;
+    transferCall(callId: string, target: string): Error;
+    mergeCall(roomId: number): void;
+    mergeCallByIds(firstCallId: string, secondCallId: string): void;
+    setDND(value: boolean): void;
+    /**
+     * Sets the call waiting feature state.
+     *
+     * When call waiting is disabled (false) and there are already active calls,
+     * any new incoming calls will be automatically rejected with a "busy" status.
+     *
+     * When call waiting is enabled (true), incoming calls will be allowed even when
+     * other calls are active.
+     *
+     * This setting is used in the shouldTerminateNewSession method to determine whether
+     * to automatically terminate new incoming sessions when the user is already on a call.
+     *
+     * @param {boolean} value - True to enable call waiting, false to disable
+     */
+    setCallWaiting(value: boolean): void;
+    private startCallTimer;
+    setActiveRoom(roomId: number | undefined): Promise<void>;
+    private getNewRoomId;
+    private setupCall;
+    private removeCall;
+    private activeCallListRemove;
+    /**
+     * Determines whether a new incoming session should be automatically terminated
+     * based on Do Not Disturb (DND) settings and Call Waiting settings.
+     *
+     * @param {RTCSessionEvent} event - The event containing the new RTC session
+     * @returns {boolean} True if the session should be terminated automatically, false otherwise
+     */
+    private shouldTerminateNewSession;
+    private newRTCSessionCallback;
+    setMuteWhenJoin(value: boolean): void;
+    setMicrophoneSensitivity(value: number): void;
+    setSpeakerVolume(value: number): void;
+    setAutoAnswer(value: boolean): void;
+    private setSelectedInputDevice;
+    private setSelectedOutputDevice;
+    private setCallMetrics;
+    private removeCallMetrics;
+    private getCallQuality;
+    private setupVUMeter;
+    private stopVUMeter;
+    setupStream(): Promise<void>;
+    private triggerAddStream;
+    initCall(target: string, addToCurrentRoom: boolean, holdOtherCalls?: boolean): void;
+    private processRoomChange;
+}
+
+declare type AudioModuleName = typeof MODULES.AUDIO
+
+export declare class BaseNewStreamPlugin extends BasePlugin {
+    private _candidates;
+    private _subscribeSent;
+    private _configureSent;
+    private _lastTrickleReceived;
+    private _publisherSubscribeSent;
+    private opaqueId;
+    protected handleId: number;
+    private readonly type;
+    protected _connection: RTCPeerConnection;
+    protected jsep_offer: RTCSessionDescription | void;
+    protected _request: unknown;
+    stream: MediaStream;
+    constructor(name: any, type: any);
+    connect(options?: ConnectOptions): void;
+    getStream(): MediaStream;
+    getConnection(): RTCPeerConnection;
+    private _createRTCConnection;
+    private addTracks;
+    private _sendInitialRequest;
+    private _receiveInviteResponse;
+    private _sendConfigureMessage;
+    private _sendDetach;
+    protected stopMedia(): Promise<void>;
+    stop(): Promise<void>;
+    generateStream(): Promise<void>;
+}
+
+declare class BasePlugin {
+    opensips: any;
+    session: any;
+    name: string;
+    constructor(name: any);
+    setOpensips(opensips: any): void;
+    setSession(session: any): void;
+    kill(): void;
+}
+
+export declare class BaseProcessStreamPlugin extends BasePlugin {
+    stream: any;
+    running: boolean;
+    immediate: boolean;
+    type: string;
+    constructor(name: any, type: any, options?: BaseProcessStreamPluginOptions);
+    start(stream: any): any;
+    stop(): void;
+    process(stream: any): Promise<any>;
+    connect(): Promise<void>;
+    terminate(): void;
+    kill(): Promise<void>;
+}
+
+declare interface BaseProcessStreamPluginOptions {
+    immediate?: boolean;
+}
+
+declare type CallAddingProgressListener = (callId: string | undefined) => void
+
+declare interface CallOptionsExtended extends AnswerOptionsExtended {
+    eventHandlers?: Partial<RTCSessionEventMap>;
+    anonymous?: boolean;
+    fromUserName?: string;
+    fromDisplayName?: string;
+}
+
+declare interface CallOptionsExtended_2 extends AnswerOptionsExtended_2 {
+    eventHandlers?: Partial<RTCSessionEventMap>;
+    anonymous?: boolean;
+    fromUserName?: string;
+    fromDisplayName?: string;
+}
+
+declare type changeActiveCallsListener = (event: { [key: string]: ICall }) => void
+
+declare type changeActiveInputMediaDeviceListener = (event: string) => void
+
+declare type changeActiveMessagesListener = (event: { [key: string]: IMessage }) => void
+
+declare type changeActiveOutputMediaDeviceListener = (event: string) => void
+
+declare type changeActiveStreamListener = (value: MediaStream) => void
+
+declare type changeAudioStateListener = (state: boolean) => void
+
+declare type changeAvailableDeviceListListener = (event: Array<MediaDeviceInfo>) => void
+
+declare type changeCallMetricsListener = (event: { [key: string]: any }) => void
+
+declare type changeCallStatusListener = (event: { [key: string]: ICallStatus }) => void
+
+declare type changeCallTimeListener = (event: { [key: string]: ITimeData }) => void
+
+declare type changeCallVolumeListener = (event: ChangeVolumeEventType) => void
+
+declare type changeIsCallWaitingListener = (value: boolean) => void
+
+declare type changeIsDNDListener = (value: boolean) => void
+
+declare type changeIsMutedListener = (value: boolean) => void
+
+declare type changeMuteWhenJoinListener = (value: boolean) => void
+
+declare type changeVideoStateListener = (state: boolean) => void
+
+declare type ChangeVolumeEventType = {
+    callId: string
+    volume: number
+}
+
+declare type CommonLogMethodType = (...args: unknown[]) => void
+
+declare type conferenceEndListener = (sessionId) => void
+
+declare type conferenceStartListener = () => void
+
+declare type connectionListener = (value: boolean) => void
+
+declare interface ConnectOptions {
+    extraHeaders?: Array<string>;
+    fromUserName?: string;
+    fromDisplayName?: string;
+    rtcConstraints?: object;
+    pcConfig?: object;
+}
+
+declare interface CustomLoggerType {
+    log: CommonLogMethodType
+    warn: CommonLogMethodType
+    error: CommonLogMethodType
+    debug: CommonLogMethodType
+}
+
+declare type ExactConstraints = {
+    audio?: {
+        deviceId: {exact: string}
+    }
+    video?: boolean;
+}
+
+declare type ExactConstraints_2 = {
+    audio?: {
+        deviceId: {exact: string}
+    }
+    video?: boolean;
+}
+
+declare interface ICall extends RTCSessionExtended {
+    roomId?: number
+    localMuted?: boolean
+    localHold?: boolean
+    audioTag?: StreamMediaType
+    autoAnswer?: boolean
+    putOnHoldTimestamp?: number
+}
+
+declare interface ICallStatus {
+    isMoving: boolean
+    isTransferring: boolean
+    isMerging: boolean
+    isTransferred: boolean
+}
+
+declare interface IMessage extends MSRPSessionExtended {
+    roomId?: number
+    localMuted?: boolean
+    localHold?: boolean
+    audioTag?: StreamMediaType
+    terminate(): void
+}
+
+declare interface IncomingMSRPSessionEvent {
+    originator: Originator.REMOTE;
+    session: MSRPSession;
+    request: IncomingRequest;
+}
+
+declare type IncomingMSRPSessionListener = (event: IncomingMSRPSessionEvent) => void;
+
+declare type IOpenSIPSConfiguration = Omit<UAConfigurationExtended, 'sockets'>
+
+declare interface IOpenSIPSJSOptions {
+    configuration: IOpenSIPSConfiguration
+    socketInterfaces: [ string ]
+    sipDomain: string
+    sipOptions: {
+        session_timers: boolean
+        extraHeaders: [ string ]
+        pcConfig: RTCConfiguration_2
+    },
+    modules: Array<Modules>
+    pnExtraHeaders?: ExtraContactParams
+}
+
+declare interface IRoom {
+    started: Date
+    incomingInProgress: boolean
+    roomId: number
+}
+
+declare type IRoomUpdate = Omit<IRoom, 'started'> & {
+    started?: Date
+}
+
+declare interface ITimeData {
+    callId: string
+    hours: number
+    minutes: number
+    seconds: number
+    formatted: string
+}
+
+declare interface JanusOptions extends AnswerOptions {
+    eventHandlers?: Partial<JanusSessionEventMap>
+    anonymous?: boolean;
+    fromUserName?: string;
+    fromDisplayName?: string;
+}
+
+declare interface JanusSessionEventMap {
+    'peerconnection': PeerConnectionListener;
+    'connecting': ConnectingListener;
+    'sending': SendingListener;
+    'progress': CallListener;
+    'accepted': CallListener;
+    'confirmed': ConfirmedListener;
+    'ended': EndListener;
+    'failed': EndListener;
+    'newDTMF': DTMFListener;
+    'newInfo': InfoListener;
+    'hold': HoldListener;
+    'unhold': HoldListener;
+    'muted': MuteListener;
+    'unmuted': MuteListener;
+    'reinvite': ReInviteListener;
+    'update': UpdateListener;
+    'refer': ReferListener;
+    'replaces': ReferListener;
+    'sdp': SDPListener;
+    'icecandidate': IceCandidateListener;
+    'getusermediafailed': Listener_2;
+    'active' : Listener_2;
+    'msgHistoryUpdate' : Listener_2;
+    'newMessage' : Listener_2;
+    'peerconnection:createofferfailed': Listener_2;
+    'peerconnection:createanswerfailed': Listener_2;
+    'peerconnection:setlocaldescriptionfailed': Listener_2;
+    'peerconnection:setremotedescriptionfailed': Listener_2;
+}
+
+declare type Listener = (event: unknown) => void
+
+declare type Listener_2 = (event: unknown) => void
+
+declare type Listener_3 = (event: unknown) => void
+
+declare type ListenerCallbackFnType<T extends ListenersKeyType> = OpenSIPSEventMap[T]
+
+declare type ListenerEventType = EndEvent | IncomingEvent | OutgoingEvent | IncomingAckEvent | OutgoingAckEvent
+
+declare type ListenersKeyType = keyof OpenSIPSEventMap
+
+declare type memberHangupListener = (event: object) => void
+
+declare type memberJoinListener = (event: object) => void
+
+declare const MODULES: {
+    readonly AUDIO: "audio";
+    readonly VIDEO: "video";
+    readonly MSRP: "msrp";
+};
+
+declare type Modules = AudioModuleName | VideoModuleName | MSRPModuleName
+
+declare type MSRPInitializingListener = (sessionId: string | undefined) => void
+
+declare class MSRPMessage {
+    protocol: string
+    ident: string
+    code: number
+    method: string
+    headers: any
+    body: string
+    direction: string
+
+    constructor(msg: string)
+    addHeader(name: string, content: string): void
+    getHeader(name: string): string
+    toString(): string
+}
+
+declare type MSRPMessageEventType = {
+    message: MSRPMessage,
+    session: MSRPSessionExtended
+}
+
+declare type MSRPMessageListener = (event: MSRPMessageEventType) => void;
+
+declare class MSRPModule {
+    private context;
+    private activeMessages;
+    private extendedMessages;
+    private msrpHistory;
+    private isMSRPInitializingValue;
+    constructor(context: any);
+    get isMSRPInitializing(): boolean;
+    get getActiveMessages(): {
+        [key: string]: IMessage;
+    };
+    msrpAnswer(callId: string): void;
+    updateMSRPSession(value: IMessage): void;
+    private addMMSRPSession;
+    private addMSRPMessage;
+    messageTerminate(callId: string): void;
+    private addMessageSession;
+    private triggerMSRPListener;
+    private removeMMSRPSession;
+    private activeMessageListRemove;
+    private newMSRPSessionCallback;
+    private setIsMSRPInitializing;
+    initMSRP(target: string, body: string, options: any): void;
+    sendMSRP(msrpSessionId: string, body: string): void;
+}
+
+declare type MSRPModuleName = typeof MODULES.MSRP
+
+declare interface MSRPOptions extends AnswerOptions {
+    eventHandlers?: Partial<MSRPSessionEventMap>
+    anonymous?: boolean;
+    fromUserName?: string;
+    fromDisplayName?: string;
+}
+
+declare interface MSRPOptions_2 extends AnswerOptions {
+    eventHandlers?: Partial<MSRPSessionEventMap_2>
+    anonymous?: boolean;
+    fromUserName?: string;
+    fromDisplayName?: string;
+}
+
+declare class MSRPSession extends EventEmitter {
+    _ua: UAExtendedInterface
+    id: any
+    credentials: any
+    status: string
+    target: string
+    message: string
+
+    constructor(ua: UAExtendedInterface)
+
+    get direction(): SessionDirection;
+
+    get connection(): RTCPeerConnectionDeprecated;
+
+    get start_time(): Date;
+
+    isOnHold(): OnHoldResult;
+
+    mute(options?: MediaConstraints): void;
+
+    unmute(options?: MediaConstraints): void;
+
+    init_incoming(request: any): void;
+
+    isEnded(): boolean;
+
+    connect(target?:string): void
+
+    sendMSRP(message: string): void
+
+    _sendOk(message: string): void
+
+    _sendReport(message: string): void
+
+    terminate(options?: any): void
+
+    receiveRequest(request: unknown): void
+
+    on<T extends keyof MSRPSessionEventMap>(type: T, listener: MSRPSessionEventMap[T]): this;
+}
+
+declare class MSRPSession_2 extends EventEmitter {
+    _ua: UAExtendedInterface_2
+    id: any
+    credentials: any
+    status: string
+    target: string
+    message: string
+
+    constructor(ua: UAExtendedInterface_2)
+
+    get direction(): SessionDirection;
+
+    get connection(): RTCPeerConnectionDeprecated;
+
+    get start_time(): Date;
+
+    isOnHold(): OnHoldResult;
+
+    mute(options?: MediaConstraints): void;
+
+    unmute(options?: MediaConstraints): void;
+
+    init_incoming(request: any): void;
+
+    isEnded(): boolean;
+
+    connect(target?:string): void
+
+    sendMSRP(message: string): void
+
+    _sendOk(message: string): void
+
+    _sendReport(message: string): void
+
+    terminate(options?: any): void
+
+    receiveRequest(request: unknown): void
+
+    on<T extends keyof MSRPSessionEventMap_2>(type: T, listener: MSRPSessionEventMap_2[T]): this;
+}
+
+declare interface MSRPSessionEventMap {
+    'peerconnection': PeerConnectionListener;
+    'connecting': ConnectingListener;
+    'sending': SendingListener;
+    'progress': CallListener;
+    'accepted': CallListener;
+    'confirmed': ConfirmedListener;
+    'ended': EndListener;
+    'failed': EndListener;
+    'newDTMF': DTMFListener;
+    'newInfo': InfoListener;
+    'hold': HoldListener;
+    'unhold': HoldListener;
+    'muted': MuteListener;
+    'unmuted': MuteListener;
+    'reinvite': ReInviteListener;
+    'update': UpdateListener;
+    'refer': ReferListener;
+    'replaces': ReferListener;
+    'sdp': SDPListener;
+    'icecandidate': IceCandidateListener;
+    'getusermediafailed': Listener;
+    'active' : Listener;
+    'msgHistoryUpdate' : Listener;
+    'newMessage' : Listener;
+    'peerconnection:createofferfailed': Listener;
+    'peerconnection:createanswerfailed': Listener;
+    'peerconnection:setlocaldescriptionfailed': Listener;
+    'peerconnection:setremotedescriptionfailed': Listener;
+}
+
+declare interface MSRPSessionEventMap_2 {
+    'peerconnection': PeerConnectionListener;
+    'connecting': ConnectingListener;
+    'sending': SendingListener;
+    'progress': CallListener;
+    'accepted': CallListener;
+    'confirmed': ConfirmedListener;
+    'ended': EndListener;
+    'failed': EndListener;
+    'newDTMF': DTMFListener;
+    'newInfo': InfoListener;
+    'hold': HoldListener;
+    'unhold': HoldListener;
+    'muted': MuteListener;
+    'unmuted': MuteListener;
+    'reinvite': ReInviteListener;
+    'update': UpdateListener;
+    'refer': ReferListener;
+    'replaces': ReferListener;
+    'sdp': SDPListener;
+    'icecandidate': IceCandidateListener;
+    'getusermediafailed': Listener_3;
+    'active' : Listener_3;
+    'msgHistoryUpdate' : Listener_3;
+    'newMessage' : Listener_3;
+    'peerconnection:createofferfailed': Listener_3;
+    'peerconnection:createanswerfailed': Listener_3;
+    'peerconnection:setlocaldescriptionfailed': Listener_3;
+    'peerconnection:setremotedescriptionfailed': Listener_3;
+}
+
+declare interface MSRPSessionExtended extends MSRPSession_2 {
+    id: string
+    status: string
+    start_time: Date
+    direction: SessionDirection
+    _id: string
+    _cancel_reason: string
+    _contact: string
+    _end_time: Date
+    _eventsCount: number
+    _from_tag: string
+    _is_canceled: boolean
+    _is_confirmed: boolean
+    _late_sdp: string
+    _status: number
+    _remote_identity: string
+    target_addr: Array<string>
+    answer(options?: any): void
+    _init_incomeing(): void
+    sendMSRP(body: string): void
+    on<T extends keyof MSRPSessionEventMap_2>(type: T, listener: MSRPSessionEventMap_2[T]): this;
+}
+
+declare type MSRPSessionListener = IncomingMSRPSessionListener | OutgoingMSRPSessionListener;
+
+declare type OnTransportCallback = (parsed: object, message: string) => void
+
+declare interface OpenSIPSEventMap extends UAEventMap {
+    ready: readyListener
+    connection: connectionListener
+    reconnecting: reconnectionListener
+    // JSSIP
+    changeActiveCalls: changeActiveCallsListener
+    changeActiveMessages: changeActiveMessagesListener
+    callConfirmed: TestEventListener
+    currentActiveRoomChanged: ActiveRoomListener
+    callAddingInProgressChanged: CallAddingProgressListener
+    isMSRPInitializingChanged: MSRPInitializingListener
+    roomDeleted: RoomDeletedListener
+    changeActiveInputMediaDevice: changeActiveInputMediaDeviceListener
+    changeActiveOutputMediaDevice: changeActiveOutputMediaDeviceListener
+    changeAvailableDeviceList: changeAvailableDeviceListListener
+    changeMuteWhenJoin: changeMuteWhenJoinListener
+    changeIsDND: changeIsDNDListener
+    changeIsCallWaiting: changeIsCallWaitingListener
+    changeIsMuted: changeIsMutedListener
+    changeActiveStream: changeActiveStreamListener
+    addRoom: addRoomListener
+    updateRoom: updateRoomListener
+    removeRoom: removeRoomListener
+    changeCallStatus: changeCallStatusListener
+    changeCallTime: changeCallTimeListener
+    changeCallMetrics: changeCallMetricsListener
+    changeCallVolume: changeCallVolumeListener
+    newMSRPMessage: MSRPMessageListener
+    newMSRPSession: MSRPSessionListener
+    // JANUS
+    conferenceStart: conferenceStartListener
+    conferenceEnd: conferenceEndListener
+    startScreenShare: startScreenShareListener
+    stopScreenShare: stopScreenShareListener
+    startBlur: startBlurListener
+    stopBlur: stopBlurListener
+    memberJoin: memberJoinListener
+    memberHangup: memberHangupListener
+    changeAudioState: changeAudioStateListener
+    changeVideoState: changeVideoStateListener
+}
+
+declare class OpenSIPSJS extends UAExtended {
+    initialized: boolean;
+    connected: boolean;
+    readonly options: IOpenSIPSJSOptions;
+    logger: CustomLoggerType;
+    readonly newRTCSessionEventName: ListenersKeyType;
+    private readonly registeredEventName;
+    private readonly unregisteredEventName;
+    private readonly disconnectedEventName;
+    private readonly connectedEventName;
+    private readonly newMSRPSessionEventName;
+    private isMSRPInitializingValue;
+    private isReconnecting;
+    private activeConnection;
+    private waitingForSessionHangup;
+    private waitingForSessionTimeout;
+    audio: AudioModule;
+    msrp: MSRPModule;
+    video: VideoModule;
+    private listenersList;
+    private modules;
+    constructor(options: IOpenSIPSJSOptions, logger?: CustomLoggerType);
+    isWaitingForSessionHangup(): boolean;
+    stopSessionAfterWaiting(): void;
+    private get hasActiveSessions();
+    on<T extends ListenersKeyType>(type: T, listener: ListenerCallbackFnType<T>): this;
+    off<T extends ListenersKeyType>(type: T, listener: ListenerCallbackFnType<T>): this;
+    emit(type: ListenersKeyType, args: any): boolean;
+    get sipDomain(): string;
+    use(plugin: BaseNewStreamPlugin | BaseProcessStreamPlugin): void;
+    getPlugin(name: string): BaseNewStreamPlugin | BaseProcessStreamPlugin;
+    begin(): this;
+    disconnect(): void;
+    subscribe(type: string, listener: (c: RTCSessionExtended) => void): void;
+    removeIListener(value: string): void;
+    triggerListener({ listenerType, session, event }: TriggerListenerOptions): void;
+    private setInitialized;
+    private setConnected;
+    private setReconnecting;
+}
+export default OpenSIPSJS;
+
+declare interface OutgoingMSRPSessionEvent {
+    originator: Originator.LOCAL;
+    session: MSRPSession;
+    request: IncomingRequest;
+}
+
+declare type OutgoingMSRPSessionListener = (event: OutgoingMSRPSessionEvent) => void;
+
+declare type readyListener = (value: boolean) => void
+
+declare type reconnectionListener = (value: boolean) => void
+
+declare interface RemoteIdentityCallType {
+    _display_name: string
+    _uri: {
+        _user: string
+    }
+}
+
+declare type removeRoomListener = (value: RoomChangeEmitType) => void
+
+declare type RoomChangeEmitType = {
+    room: IRoom
+    roomList: { [key: number]: IRoom }
+}
+
+declare type RoomDeletedListener = (roomId: number) => void
+
+declare type RTCBundlePolicy_2 = 'balanced' | 'max-bundle' | 'max-compat'
+
+declare interface RTCConfiguration_2 {
+    bundlePolicy?: RTCBundlePolicy_2;
+    certificates?: RTCCertificate[];
+    iceCandidatePoolSize?: number;
+    iceServers?: RTCIceServer_2[];
+    iceTransportPolicy?: RTCIceTransportPolicy_2;
+    rtcpMuxPolicy?: RTCRtcpMuxPolicy_2;
+}
+
+declare interface RTCIceServer_2 {
+    credential?: string;
+    urls: string | string[];
+    username?: string;
+}
+
+declare type RTCIceTransportPolicy_2 = 'all' | 'relay'
+
+declare type RTCRtcpMuxPolicy_2 = 'require'
+
+declare interface RTCSessionExtended extends RTCSession {
+    id: string
+    _automaticHold: boolean
+    _id: string
+    _localHold: boolean
+    _audioMuted: boolean
+    _cancel_reason: string
+    _contact: string
+    _end_time: Date
+    _eventsCount: number
+    _from_tag: string
+    _is_canceled: boolean
+    _is_confirmed: boolean
+    _late_sdp: string
+    _videoMuted: boolean
+    _status: number
+    _remote_identity: RemoteIdentityCallType
+    answer(options?: AnswerOptionsExtended): void
+    init_icncoming(request: IncomingRequest): void
+}
+
+declare type startBlurListener = () => void
+
+declare type startScreenShareListener = (event: MediaStream) => void
+
+declare type stopBlurListener = () => void
+
+declare type stopScreenShareListener = () => void
+
+declare interface StreamMediaType extends HTMLAudioElement {
+    className: string
+    setSinkId (id: string): Promise<void>
+}
+
+declare type TestEventListener = (event: { test: string }) => void
+
+declare interface TriggerListenerOptions {
+    listenerType: string
+    session: RTCSessionExtended
+    event?:  ListenerEventType
+}
+
+declare type UAConfigurationExtended = UAConfiguration & {
+    overrideUserAgent?: (userAgent: string) => string
+    onTransportCallback?: OnTransportCallback
+}
+
+declare const UAConstructor: typeof UA;
+
+declare class UAExtended extends UAConstructor implements UAExtendedInterface {
+    _msrp_sessions: MSRPSession[];
+    _transactions: {
+        nist: {};
+        nict: {};
+        ist: {};
+        ict: {};
+    };
+    _janus_sessions: any[];
+    protected newStreamPlugins: Array<BaseNewStreamPlugin>;
+    protected processStreamPlugins: Array<BaseProcessStreamPlugin>;
+    protected optionsInterval: any;
+    protected onTransportCallback: OnTransportCallback;
+    protected lastOptionsTimestamp: any;
+    protected lastRegisterTimestamp: any;
+    constructor(configuration: UAConfiguration);
+    setLastRegisterTimestamp(): void;
+    call(target: string, options?: CallOptionsExtended): RTCSession;
+    joinVideoCall(target: string, displayName: string, options: VideoConferenceJoinOptions): any;
+    startScreenShare(): void;
+    changeMediaConstraints(constraints: MediaStreamConstraints): void;
+    startBlur(): void;
+    stopBlur(): void;
+    _loadConfig(configuration: any): void;
+    /**
+     * new MSRPSession
+     */
+    newMSRPSession(session: MSRPSession, data: object): void;
+    newJanusSession(session: any, data: any): void;
+    kill(): void;
+    /**
+     * MSRPSession destroyed.
+     */
+    destroyMSRPSession(session: MSRPSession): void;
+    destroyJanusSession(session: any): void;
+    clearKeepAliveInterval(): void;
+    receiveRequest(request: any): void;
+    startMSRP(target: string, options: MSRPOptions): MSRPSession;
+    startJanus(target: string, options: JanusOptions): MSRPSession;
+    terminateMSRPSessions(options: object): void;
+    terminateJanusSessions(options: any): void;
+    enableJanusAudio(state: any): void;
+    enableJanusVideo(state: any): void;
+    terminateAllSessions(): void;
+    stop(closeSessions?: boolean): void;
+}
+
+declare interface UAExtendedInterface extends UA {
+    //_msrp_sessions: MSRPSession[]
+    _transactions: {
+        nist: object,
+        nict: object,
+        ist: object,
+        ict: object
+    }
+
+    call (target: string, options?: CallOptionsExtended): RTCSession
+    newMSRPSession (session: MSRPSession, data: object): void
+    destroyMSRPSession (session: MSRPSession): void
+    receiveRequest (request: any): void
+    startMSRP (target: string, options: MSRPOptions): MSRPSession
+    terminateMSRPSessions (options: object): void
+    stop (): void
+}
+
+declare interface UAExtendedInterface_2 extends UA {
+    //_msrp_sessions: MSRPSession[]
+    _transactions: {
+        nist: object,
+        nict: object,
+        ist: object,
+        ict: object
+    }
+
+    call (target: string, options?: CallOptionsExtended_2): RTCSession
+    newMSRPSession (session: MSRPSession_2, data: object): void
+    destroyMSRPSession (session: MSRPSession_2): void
+    receiveRequest (request: any): void
+    startMSRP (target: string, options: MSRPOptions_2): MSRPSession_2
+    terminateMSRPSessions (options: object): void
+    stop (): void
+}
+
+declare type updateRoomListener = (value: RoomChangeEmitType) => void
+
+declare interface VideoConferenceJoinOptions {
+    eventHandlers: Array<unknown>;
+    extraHeaders: Array<string>;
+    mediaConstraints: MediaStreamConstraints;
+}
+
+declare class VideoModule {
+    private context;
+    constructor(context: any);
+    get sipOptions(): any;
+    initCall(target: string, displayName: string): void;
+    stop(options?: {}): void;
+    startAudio(): void;
+    stopAudio(): void;
+    startVideo(): void;
+    stopVideo(): void;
+    changeMediaConstraints(constraints: MediaStreamConstraints): void;
+    startScreenShare(): void;
+    startBlur(): void;
+    stopBlur(): void;
+}
+
+declare type VideoModuleName = typeof MODULES.VIDEO
+
+declare interface WebrtcMetricsConfigType {
+    refreshEvery?: number
+    startAfter?: number
+    stopAfter?: number
+    verbose?: boolean
+    pname?: string
+    cid?: string
+    uid?: string
+    record?: boolean
+    ticket?: boolean
+}
+
+export { }