@voicenter-team/opensips-js 1.0.22 → 1.0.42

package/dist/index.d.ts

@@ -0,0 +1,737 @@
+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 { EndListener } from 'jssip/lib/RTCSession';
+import { EventEmitter } from 'events';
+import { HoldListener } from 'jssip/lib/RTCSession';
+import { IceCandidateListener } 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 { 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 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 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 changeIsDNDListener = (value: boolean) => void
+
+declare type changeIsMutedListener = (value: boolean) => void
+
+declare type changeMuteWhenJoinListener = (value: boolean) => void
+
+declare type changeOriginalStreamListener = (value: MediaStream) => void
+
+declare type CommonLogMethodType = (...args: unknown[]) => void
+
+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
+}
+
+declare interface ICallStatus {
+    isMoving: boolean
+    isTransferring: boolean
+    isMerging: boolean
+}
+
+declare interface IDoCallParam {
+    target: string
+    addToCurrentRoom: 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 interface IOpenSIPSJSOptions {
+    configuration: Omit<UAConfiguration, 'sockets'>,
+    socketInterfaces: [ string ]
+    sipDomain: string
+    sipOptions: {
+        session_timers: boolean
+        extraHeaders: [ string ]
+        pcConfig: RTCConfiguration_2
+    }
+}
+
+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 type Listener = (event: unknown) => void
+
+declare type Listener_2 = (event: unknown) => void
+
+declare type ListenerCallbackFnType<T extends ListenersKeyType> = OpenSIPSEventMap[T]
+
+declare type ListenersKeyType = keyof OpenSIPSEventMap
+
+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 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_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 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 interface OpenSIPSEventMap extends UAEventMap {
+    ready: readyListener
+    changeActiveCalls: changeActiveCallsListener
+    changeActiveMessages: changeActiveMessagesListener
+    callConfirmed: TestEventListener
+    currentActiveRoomChanged: ActiveRoomListener
+    callAddingInProgressChanged: CallAddingProgressListener
+    isMSRPInitializingChanged: MSRPInitializingListener
+    roomDeleted: RoomDeletedListener
+    changeActiveInputMediaDevice: changeActiveInputMediaDeviceListener
+    changeActiveOutputMediaDevice: changeActiveOutputMediaDeviceListener
+    changeAvailableDeviceList: changeAvailableDeviceListListener
+    changeMuteWhenJoin: changeMuteWhenJoinListener
+    changeIsDND: changeIsDNDListener
+    changeIsMuted: changeIsMutedListener
+    changeOriginalStream: changeOriginalStreamListener
+    addRoom: addRoomListener
+    updateRoom: updateRoomListener
+    removeRoom: removeRoomListener
+    changeCallStatus: changeCallStatusListener
+    changeCallTime: changeCallTimeListener
+    changeCallMetrics: changeCallMetricsListener
+    newMSRPMessage: MSRPMessageListener
+    newMSRPSession: MSRPSessionListener
+}
+
+declare class OpenSIPSJS extends UAExtended {
+    private initialized;
+    private readonly options;
+    private logger;
+    private readonly newRTCSessionEventName;
+    private readonly registeredEventName;
+    private readonly unregisteredEventName;
+    private readonly disconnectedEventName;
+    private readonly connectedEventName;
+    private readonly newMSRPSessionEventName;
+    private muted;
+    private isAutoAnswer;
+    private isDNDEnabled;
+    private muteWhenJoinEnabled;
+    private activeRooms;
+    private activeCalls;
+    private extendedCalls;
+    private activeMessages;
+    private extendedMessages;
+    private msrpHistory;
+    private microphoneInputLevelValue;
+    private speakerVolumeValue;
+    private availableMediaDevices;
+    private selectedMediaDevices;
+    private callStatus;
+    private callTime;
+    private callMetrics;
+    private timeIntervals;
+    private metricConfig;
+    private originalStreamValue;
+    private currentActiveRoomIdValue;
+    private isCallAddingInProgress;
+    private isMSRPInitializingValue;
+    private isReconnecting;
+    private listenersList;
+    constructor(options: IOpenSIPSJSOptions, logger?: CustomLoggerType);
+    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;
+    get sipOptions(): {
+        mediaConstraints: {
+            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 isMSRPInitializing(): boolean | undefined;
+    get muteWhenJoin(): boolean;
+    get isDND(): boolean;
+    get speakerVolume(): number;
+    get microphoneInputLevel(): number;
+    get getActiveCalls(): {
+        [key: string]: ICall;
+    };
+    get hasActiveCalls(): boolean;
+    get getActiveMessages(): {
+        [key: string]: IMessage;
+    };
+    get getActiveRooms(): {
+        [key: number]: IRoom;
+    };
+    get isMuted(): boolean;
+    get getInputDeviceList(): MediaDeviceInfo[];
+    get getOutputDeviceList(): MediaDeviceInfo[];
+    get getUserMediaConstraints(): {
+        audio: {
+            deviceId: {
+                exact: string;
+            };
+        };
+        video: boolean;
+    };
+    get getInputDefaultDevice(): MediaDeviceInfo | undefined;
+    get getOutputDefaultDevice(): MediaDeviceInfo | undefined;
+    get selectedInputDevice(): string;
+    get selectedOutputDevice(): string;
+    get originalStream(): MediaStream | null;
+    private setAvailableMediaDevices;
+    updateDeviceList(): Promise<void>;
+    setMediaDevices(setDefaults?: boolean): Promise<void>;
+    setCallTime(value: ITimeData): void;
+    removeCallTime(callId: string): void;
+    private setTimeInterval;
+    private removeTimeInterval;
+    private stopCallTimer;
+    setMetricsConfig(config: WebrtcMetricsConfigType): void;
+    sendDTMF(callId: string, value: string): void;
+    private setIsMuted;
+    doMute(value: boolean): void;
+    doCallHold({ callId, toHold, automatic }: {
+        callId: string;
+        toHold: boolean;
+        automatic?: boolean;
+    }): void;
+    private cancelAllOutgoingUnanswered;
+    callAnswer(callId: string): void;
+    msrpAnswer(callId: string): void;
+    callMove(callId: string, roomId: number): Promise<void>;
+    updateCall(value: ICall): void;
+    updateMSRPSession(value: IMessage): void;
+    updateRoom(value: IRoomUpdate): void;
+    private hasAutoAnswerHeaders;
+    private _addCall;
+    private addCallStatus;
+    private addMMSRPSession;
+    private addMSRPMessage;
+    private updateCallStatus;
+    private removeCallStatus;
+    private addRoom;
+    setMicrophone(dId: string): Promise<void>;
+    private setOriginalStream;
+    setSpeaker(dId: string): Promise<void>;
+    private removeRoom;
+    private deleteRoomIfEmpty;
+    private checkInitialized;
+    private muteReconfigure;
+    private roomReconfigure;
+    private doConference;
+    muteCaller(callId: string, value: boolean): void;
+    callTerminate(callId: string): void;
+    messageTerminate(callId: string): void;
+    callTransfer(callId: string, target: string): void;
+    callMerge(roomId: number): void;
+    setDND(value: boolean): void;
+    private startCallTimer;
+    setCurrentActiveRoomId(roomId: number | undefined): Promise<void>;
+    private getNewRoomId;
+    subscribe(type: string, listener: (c: RTCSessionExtended) => void): void;
+    removeIListener(value: string): void;
+    private addCall;
+    private addMessageSession;
+    private triggerListener;
+    private triggerMSRPListener;
+    private removeCall;
+    private removeMMSRPSession;
+    private activeCallListRemove;
+    private activeMessageListRemove;
+    private newRTCSessionCallback;
+    private newMSRPSessionCallback;
+    private setInitialized;
+    begin(): this | undefined;
+    setMuteWhenJoin(value: boolean): void;
+    setMicrophoneInputLevel(value: number): void;
+    setSpeakerVolume(value: number): void;
+    setAutoAnswer(value: boolean): void;
+    private setSelectedInputDevice;
+    private setSelectedOutputDevice;
+    private setIsMSRPInitializing;
+    private setCallMetrics;
+    private removeCallMetrics;
+    private getCallQuality;
+    private triggerAddStream;
+    doCall({ target, addToCurrentRoom }: IDoCallParam): void;
+    initMSRP(target: string, body: string, options: any): void;
+    sendMSRP(msrpSessionId: string, body: string): void;
+    callChangeRoom({ callId, roomId }: {
+        callId: string;
+        roomId: number;
+    }): Promise<void>;
+}
+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 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 interface StreamMediaType extends HTMLAudioElement {
+    className: string
+    setSinkId (id: string): Promise<void>
+}
+
+declare type TestEventListener = (event: { test: string }) => void
+
+declare const UAConstructor: typeof UA;
+
+declare class UAExtended extends UAConstructor implements UAExtendedInterface {
+    _msrp_sessions: MSRPSession[];
+    _transactions: {
+        nist: {};
+        nict: {};
+        ist: {};
+        ict: {};
+    };
+    constructor(configuration: UAConfiguration);
+    call(target: string, options?: CallOptionsExtended): RTCSession;
+    /**
+     * new MSRPSession
+     */
+    newMSRPSession(session: MSRPSession, data: object): void;
+    /**
+     * MSRPSession destroyed.
+     */
+    destroyMSRPSession(session: MSRPSession): void;
+    receiveRequest(request: any): void;
+    startMSRP(target: string, options: MSRPOptions): MSRPSession;
+    terminateMSRPSessions(options: object): void;
+    stop(): void;
+}
+
+declare interface UAExtendedInterface extends UA {
+    //_msrp_sessions: MSRPSession[]
+    _transactions: {
+        nist: object,
+        nict: object,
+        ist: object,
+        ict: object
+    }
+
+    //new (configuration: UAConfiguration): void
+    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
+    }
+
+    //new (configuration: UAConfiguration): void
+    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 WebrtcMetricsConfigType {
+    refreshEvery?: number
+    startAfter?: number
+    stopAfter?: number
+    verbose?: boolean
+    pname?: string
+    cid?: string
+    uid?: string
+    record?: boolean
+    ticket?: boolean
+}
+
+export { }