sip-connector 14.1.2-7 → 15.1.0

package/dist/ConnectionManager/ConnectionFlow.d.ts

@@ -0,0 +1,84 @@
+import { UA, WebSocketInterface } from '@krivega/jssip';
+import { Events } from 'events-constructor';
+import { TGetServerUrl } from '../CallManager';
+import { TJsSIP } from '../types';
+import { default as ConnectionStateMachine } from './ConnectionStateMachine';
+import { EVENT_NAMES } from './eventNames';
+import { default as RegistrationManager } from './RegistrationManager';
+import { default as UAFactory } from './UAFactory';
+export type TOptionsExtraHeaders = {
+    extraHeaders?: string[];
+};
+export 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;
+};
+export type TConnect = (parameters: TParametersConnection, options?: {
+    callLimit?: number;
+}) => Promise<UA>;
+export type TSet = (parameters: {
+    displayName?: string;
+}) => Promise<boolean>;
+interface IDependencies {
+    JsSIP: TJsSIP;
+    events: Events<typeof EVENT_NAMES>;
+    uaFactory: UAFactory;
+    stateMachine: ConnectionStateMachine;
+    registrationManager: RegistrationManager;
+    getUa: () => UA | undefined;
+    setUa: (ua: UA | undefined) => void;
+    getConnectionConfiguration: () => {
+        sipServerUrl?: string;
+        displayName?: string;
+        register?: boolean;
+        user?: string;
+        password?: string;
+    };
+    setConnectionConfiguration: (config: {
+        sipServerUrl?: string;
+        displayName?: string;
+        register?: boolean;
+        user?: string;
+        password?: string;
+    }) => void;
+    updateConnectionConfiguration: (key: 'displayName', value: string) => void;
+    setSipServerUrl: (getSipServerUrl: TGetServerUrl) => void;
+    setSocket: (socket: WebSocketInterface) => void;
+}
+export default class ConnectionFlow {
+    private cancelableConnectWithRepeatedCalls;
+    private readonly JsSIP;
+    private readonly events;
+    private readonly uaFactory;
+    private readonly stateMachine;
+    private readonly registrationManager;
+    private readonly getUa;
+    private readonly setUa;
+    private readonly getConnectionConfiguration;
+    private readonly setConnectionConfiguration;
+    private readonly updateConnectionConfiguration;
+    private readonly setSipServerUrl;
+    private readonly setSocket;
+    constructor(dependencies: IDependencies);
+    connect: TConnect;
+    set: TSet;
+    disconnect: () => Promise<void>;
+    cancelRequests(): void;
+    private readonly connectWithDuplicatedCalls;
+    private hasEqualConnectionConfiguration;
+    private readonly connectInner;
+    private readonly initUa;
+    private readonly start;
+    private cancelConnectWithRepeatedCalls;
+}
+export {};

package/dist/ConnectionManager/ConnectionStateMachine.d.ts

@@ -0,0 +1,61 @@
+import { Events } from 'events-constructor';
+import { EVENT_NAMES } from './eventNames';
+export declare enum EEvents {
+    START_CONNECT = "START_CONNECT",
+    START_INIT_UA = "START_INIT_UA",
+    UA_CONNECTED = "UA_CONNECTED",
+    UA_REGISTERED = "UA_REGISTERED",
+    UA_UNREGISTERED = "UA_UNREGISTERED",
+    UA_DISCONNECTED = "UA_DISCONNECTED",
+    CONNECTION_FAILED = "CONNECTION_FAILED",
+    RESET = "RESET"
+}
+type TConnectionMachineEvent = `${EEvents}`;
+export declare enum EState {
+    IDLE = "idle",
+    CONNECTING = "connecting",
+    INITIALIZING = "initializing",
+    CONNECTED = "connected",
+    REGISTERED = "registered",
+    DISCONNECTED = "disconnected",
+    FAILED = "failed"
+}
+export default class ConnectionStateMachine {
+    private readonly actor;
+    private readonly stateChangeListeners;
+    private readonly events;
+    private unsubscribeFromEvents?;
+    private readonly actorSubscription?;
+    constructor(events: Events<typeof EVENT_NAMES>);
+    get state(): EState;
+    get isIdle(): boolean;
+    get isConnecting(): boolean;
+    get isInitializing(): boolean;
+    get isConnected(): boolean;
+    get isRegistered(): boolean;
+    get isDisconnected(): boolean;
+    get isFailed(): boolean;
+    get isPending(): boolean;
+    get isPendingConnect(): boolean;
+    get isPendingInitUa(): boolean;
+    get isActiveConnection(): boolean;
+    startConnect(): void;
+    startInitUa(): void;
+    reset(): void;
+    destroy(): void;
+    onStateChange(listener: (state: EState) => void): () => void;
+    canTransition(event: TConnectionMachineEvent): boolean;
+    getValidEvents(): TConnectionMachineEvent[];
+    private hasState;
+    private sendEvent;
+    private readonly toStartConnect;
+    private readonly toStartInitUa;
+    private readonly toConnected;
+    private readonly toRegistered;
+    private readonly toUnregistered;
+    private readonly toDisconnected;
+    private readonly toFailed;
+    private readonly toIdle;
+    private subscribeToEvents;
+}
+export {};

package/dist/ConnectionManager/RegistrationManager.d.ts

@@ -0,0 +1,17 @@
+import { RegisteredEvent, UA, UnRegisteredEvent } from '@krivega/jssip';
+import { Events } from 'events-constructor';
+import { EVENT_NAMES } from './eventNames';
+interface IDependencies {
+    events: Events<typeof EVENT_NAMES>;
+    getUaProtected: () => UA;
+}
+export default class RegistrationManager {
+    private readonly events;
+    private readonly getUaProtected;
+    constructor(dependencies: IDependencies);
+    register(): Promise<RegisteredEvent>;
+    unregister(): Promise<UnRegisteredEvent>;
+    tryRegister(): Promise<RegisteredEvent>;
+    subscribeToStartEvents(onSuccess: () => void, onError: (error: Error) => void): () => void;
+}
+export {};

package/dist/ConnectionManager/SipOperations.d.ts

@@ -0,0 +1,32 @@
+import { UA, URI } from '@krivega/jssip';
+import { default as UAFactory } from './UAFactory';
+export type TParametersCheckTelephony = {
+    displayName: string;
+    sipServerUrl: string;
+    sipWebSocketServerURL: string;
+    userAgent?: string;
+    remoteAddress?: string;
+    extraHeaders?: string[];
+};
+interface IDependencies {
+    uaFactory: UAFactory;
+    getUaProtected: () => UA;
+}
+export default class SipOperations {
+    private readonly uaFactory;
+    private readonly getUaProtected;
+    constructor(dependencies: IDependencies);
+    /**
+     * Отправляет SIP OPTIONS запрос к указанному адресу
+     */
+    sendOptions(target: URI | string, body?: string, extraHeaders?: string[]): Promise<void>;
+    /**
+     * Отправляет SIP OPTIONS запрос к собственному URI (ping)
+     */
+    ping(body?: string, extraHeaders?: string[]): Promise<void>;
+    /**
+     * Проверяет доступность телефонии, создавая временное соединение
+     */
+    checkTelephony({ userAgent, displayName, sipServerUrl, sipWebSocketServerURL, remoteAddress, extraHeaders, }: TParametersCheckTelephony): Promise<void>;
+}
+export {};

package/dist/ConnectionManager/UAFactory.d.ts

@@ -0,0 +1,50 @@
+import { UA, UAConfigurationParams, WebSocketInterface } from '@krivega/jssip';
+import { TJsSIP } from '../types';
+export type TUAConfiguration = {
+    configuration: UAConfigurationParams;
+    helpers: {
+        socket: WebSocketInterface;
+        getSipServerUrl: (id: string) => string;
+    };
+};
+export type TCreateUAParameters = UAConfigurationParams & {
+    remoteAddress?: string;
+    extraHeaders?: string[];
+};
+type TParametersCreateUaConfiguration = {
+    sipWebSocketServerURL: string;
+    displayName?: string;
+    sipServerUrl: string;
+    user?: string;
+    register?: boolean;
+    password?: string;
+    sessionTimers?: boolean;
+    registerExpires?: number;
+    connectionRecoveryMinInterval?: number;
+    connectionRecoveryMaxInterval?: number;
+    userAgent?: string;
+};
+export default class UAFactory {
+    private readonly JsSIP;
+    constructor(JsSIP: TJsSIP);
+    static isRegisteredUA(ua?: UA): boolean;
+    private static validateConfiguration;
+    private static resolveAuthorizationUser;
+    private static buildExtraHeaders;
+    createConfiguration({ user, password, sipWebSocketServerURL, displayName, sipServerUrl, register, sessionTimers, registerExpires, // 5 minutes in sec
+    connectionRecoveryMinInterval, connectionRecoveryMaxInterval, userAgent, }: TParametersCreateUaConfiguration): TUAConfiguration;
+    createUA({ remoteAddress, extraHeaders, ...parameters }: TCreateUAParameters): UA;
+    /**
+     * Создает UA с полным жизненным циклом - конфигурация + создание + настройка событий
+     */
+    createUAWithConfiguration(parameters: TParametersCreateUaConfiguration & {
+        remoteAddress?: string;
+        extraHeaders?: string[];
+    }, events: {
+        eachTriggers: (callback: (trigger: (...args: unknown[]) => void, eventName: string) => void) => void;
+    }): {
+        ua: UA;
+        helpers: TUAConfiguration['helpers'];
+    };
+}
+export {};

package/dist/ConnectionManager/eventNames.d.ts

@@ -0,0 +1,16 @@
+import { Events } from 'events-constructor';
+export declare enum EEvent {
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    DISCONNECTED = "disconnected",
+    NEW_RTC_SESSION = "newRTCSession",
+    REGISTERED = "registered",
+    UNREGISTERED = "unregistered",
+    REGISTRATION_FAILED = "registrationFailed",
+    NEW_MESSAGE = "newMessage",
+    SIP_EVENT = "sipEvent"
+}
+export declare const UA_EVENT_NAMES: readonly ["connecting", "connected", "disconnected", "newRTCSession", "registered", "unregistered", "registrationFailed", "newMessage", "sipEvent"];
+export declare const EVENT_NAMES: ("connecting" | "connected" | "disconnected" | "newRTCSession" | "registered" | "unregistered" | "registrationFailed" | "newMessage" | "sipEvent")[];
+export type TEvent = (typeof EVENT_NAMES)[number];
+export type TEvents = Events<typeof EVENT_NAMES>;

package/dist/ConnectionManager/getExtraHeadersRemoteAddress.d.ts

@@ -0,0 +1,2 @@
+declare const getExtraHeadersRemoteAddress: (remoteAddress?: string) => string[];
+export default getExtraHeadersRemoteAddress;

package/dist/ConnectionManager/index.d.ts

@@ -0,0 +1,3 @@
+export { default as ConnectionManager } from './@ConnectionManager';
+export { EVENT_NAMES as CONNECTION_MANAGER_EVENT_NAMES, EEvent as EConnectionManagerEvent, } from './eventNames';
+export type { TEvent as TConnectionManagerEvent, TEvents as TConnectionManagerEvents, } from './eventNames';

package/dist/IncomingCallManager/@IncomingCallManager.d.ts

@@ -0,0 +1,37 @@
+import { Events } from 'events-constructor';
+import { EVENT_NAMES, TEvent } from './eventNames';
+import { RTCSession } from '@krivega/jssip';
+import { ConnectionManager } from '../ConnectionManager';
+type TRemoteCallerData = {
+    displayName?: string;
+    host?: string;
+    incomingNumber?: string;
+    rtcSession?: RTCSession;
+};
+export default class IncomingCallManager {
+    readonly events: Events<typeof EVENT_NAMES>;
+    private incomingRTCSession?;
+    private readonly connectionManager;
+    constructor(connectionManager: ConnectionManager);
+    get remoteCallerData(): TRemoteCallerData;
+    get isAvailableIncomingCall(): boolean;
+    start(): void;
+    stop(): void;
+    getIncomingRTCSession: () => RTCSession;
+    extractIncomingRTCSession: () => RTCSession;
+    declineToIncomingCall({ statusCode, }?: {
+        statusCode?: number;
+    }): Promise<void>;
+    busyIncomingCall(): Promise<void>;
+    on<T>(eventName: TEvent, handler: (data: T) => void): () => void;
+    once<T>(eventName: TEvent, handler: (data: T) => void): () => void;
+    onceRace<T>(eventNames: TEvent[], handler: (data: T, eventName: string) => void): () => void;
+    wait<T>(eventName: TEvent): Promise<T>;
+    off<T>(eventName: TEvent, handler: (data: T) => void): void;
+    private subscribe;
+    private unsubscribe;
+    private readonly handleNewRTCSession;
+    private setIncomingSession;
+    private removeIncomingSession;
+}
+export {};

package/dist/IncomingCallManager/eventNames.d.ts

@@ -0,0 +1,13 @@
+export declare enum EEvent {
+    INCOMING_CALL = "incomingCall",
+    DECLINED_INCOMING_CALL = "declinedIncomingCall",
+    TERMINATED_INCOMING_CALL = "terminatedIncomingCall",
+    FAILED_INCOMING_CALL = "failedIncomingCall"
+}
+export declare enum Originator {
+    LOCAL = "local",
+    REMOTE = "remote",
+    SYSTEM = "system"
+}
+export declare const EVENT_NAMES: readonly ["incomingCall", "declinedIncomingCall", "terminatedIncomingCall", "failedIncomingCall"];
+export type TEvent = (typeof EVENT_NAMES)[number];

package/dist/IncomingCallManager/index.d.ts

@@ -0,0 +1,2 @@
+export { default as IncomingCallManager } from './@IncomingCallManager';
+export type { TEvent as TIncomingCallEvent } from './eventNames';

package/dist/PresentationManager/@PresentationManager.d.ts

@@ -0,0 +1,47 @@
+import { CallManager } from '../CallManager';
+import { TEvent, TEvents } from './eventNames';
+import { TContentHint, TOnAddedTransceiver } from './types';
+export declare const hasCanceledStartPresentationError: (error: unknown) => error is import('repeated-calls').TCanceledError<unknown>;
+declare class PresentationManager {
+    readonly events: TEvents;
+    promisePendingStartPresentation?: Promise<MediaStream>;
+    promisePendingStopPresentation?: Promise<MediaStream | undefined>;
+    streamPresentationCurrent?: MediaStream;
+    private cancelableSendPresentationWithRepeatedCalls;
+    private readonly callManager;
+    constructor({ callManager }: {
+        callManager: CallManager;
+    });
+    get isPendingPresentation(): boolean;
+    startPresentation(beforeStartPresentation: () => Promise<void>, stream: MediaStream, { isNeedReinvite, maxBitrate, contentHint, sendEncodings, onAddedTransceiver, }?: {
+        isNeedReinvite?: boolean;
+        maxBitrate?: number;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+    }, options?: {
+        callLimit: number;
+    }): Promise<MediaStream>;
+    stopPresentation(beforeStopPresentation: () => Promise<void>): Promise<MediaStream | undefined>;
+    updatePresentation(beforeStartPresentation: () => Promise<void>, stream: MediaStream, { contentHint, sendEncodings, onAddedTransceiver, }?: {
+        isP2P?: boolean;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+    }): Promise<MediaStream | undefined>;
+    cancelSendPresentationWithRepeatedCalls(): void;
+    on<T>(eventName: TEvent, handler: (data: T) => void): () => void;
+    once<T>(eventName: TEvent, handler: (data: T) => void): () => void;
+    onceRace<T>(eventNames: TEvent[], handler: (data: T, eventName: string) => void): () => void;
+    wait<T>(eventName: TEvent): Promise<T>;
+    off<T>(eventName: TEvent, handler: (data: T) => void): void;
+    private subscribe;
+    private sendPresentationWithDuplicatedCalls;
+    private sendPresentation;
+    private readonly getRtcSessionProtected;
+    private readonly handleEnded;
+    private reset;
+    private resetPresentation;
+    private removeStreamPresentationCurrent;
+}
+export default PresentationManager;

package/dist/PresentationManager/constants.d.ts

@@ -0,0 +1 @@
+export declare const ONE_MEGABIT_IN_BITS = 1000000;

package/dist/PresentationManager/eventNames.d.ts

@@ -0,0 +1,11 @@
+import { Events } from 'events-constructor';
+export declare enum EEvent {
+    START_PRESENTATION = "presentation:start",
+    STARTED_PRESENTATION = "presentation:started",
+    END_PRESENTATION = "presentation:end",
+    ENDED_PRESENTATION = "presentation:ended",
+    FAILED_PRESENTATION = "presentation:failed"
+}
+export declare const EVENT_NAMES: readonly ["presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed"];
+export type TEvent = (typeof EVENT_NAMES)[number];
+export type TEvents = Events<typeof EVENT_NAMES>;

package/dist/PresentationManager/index.d.ts

@@ -0,0 +1,2 @@
+export { hasCanceledStartPresentationError, default as PresentationManager, } from './@PresentationManager';
+export type { TContentHint } from './types';

package/dist/PresentationManager/types.d.ts

@@ -0,0 +1,2 @@
+export type TOnAddedTransceiver = (transceiver: RTCRtpTransceiver, track: MediaStreamTrack, stream: MediaStream) => Promise<void>;
+export type TContentHint = 'motion' | 'detail' | 'text' | 'none';

package/dist/SipConnector/@SipConnector.d.ts

@@ -0,0 +1,96 @@
+import { Events } from 'events-constructor';
+import { ApiManager } from '../ApiManager';
+import { CallManager, TGetServerUrl } from '../CallManager';
+import { ConnectionManager } from '../ConnectionManager';
+import { IncomingCallManager } from '../IncomingCallManager';
+import { PresentationManager } from '../PresentationManager';
+import { EVENT_NAMES, TEvent } from './eventNames';
+import { TContentHint, TOnAddedTransceiver } from '../PresentationManager/types';
+import { TJsSIP } from '../types';
+declare class SipConnector {
+    readonly events: Events<typeof EVENT_NAMES>;
+    readonly connectionManager: ConnectionManager;
+    readonly callManager: CallManager;
+    readonly apiManager: ApiManager;
+    readonly incomingCallManager: IncomingCallManager;
+    readonly presentationManager: PresentationManager;
+    constructor({ JsSIP }: {
+        JsSIP: TJsSIP;
+    });
+    get requestedConnection(): boolean;
+    get isPendingConnect(): boolean;
+    get isPendingInitUa(): boolean;
+    get connectionState(): import('../ConnectionManager/ConnectionStateMachine').EState;
+    get isRegistered(): boolean;
+    get isRegisterConfig(): boolean;
+    get socket(): import('@krivega/jssip').WebSocketInterface | undefined;
+    get requestedCall(): boolean;
+    get connection(): RTCPeerConnection | undefined;
+    get establishedRTCSession(): import('@krivega/jssip').RTCSession | undefined;
+    get isCallActive(): boolean;
+    get remoteCallerData(): IncomingCallManager['remoteCallerData'];
+    get isAvailableIncomingCall(): IncomingCallManager['isAvailableIncomingCall'];
+    on<T>(eventName: TEvent, handler: (data: T) => void): () => void;
+    once<T>(eventName: TEvent, handler: (data: T) => void): () => void;
+    onceRace<T>(eventNames: TEvent[], handler: (data: T, eventName: string) => void): () => void;
+    wait<T>(eventName: TEvent): Promise<T>;
+    off<T>(eventName: TEvent, handler: (data: T) => void): void;
+    connect: ConnectionManager['connect'];
+    set: ConnectionManager['set'];
+    disconnect: () => Promise<void>;
+    register: () => Promise<import('@krivega/jssip').RegisteredEvent>;
+    unregister: () => Promise<import('@krivega/jssip').UnRegisteredEvent>;
+    tryRegister: () => Promise<import('@krivega/jssip').RegisteredEvent>;
+    sendOptions: (target: Parameters<ConnectionManager["sendOptions"]>[0], body?: Parameters<ConnectionManager["sendOptions"]>[1], extraHeaders?: Parameters<ConnectionManager["sendOptions"]>[2]) => Promise<void>;
+    ping: (body?: Parameters<ConnectionManager["ping"]>[0], extraHeaders?: Parameters<ConnectionManager["ping"]>[1]) => Promise<void>;
+    checkTelephony: ConnectionManager['checkTelephony'];
+    isConfigured: () => boolean;
+    getConnectionConfiguration: () => import('../ConnectionManager/ConfigurationManager').IConnectionConfiguration;
+    getSipServerUrl: TGetServerUrl;
+    call: (params: Parameters<CallManager["startCall"]>[2]) => Promise<RTCPeerConnection>;
+    hangUp: CallManager['endCall'];
+    answerToIncomingCall: (params: Parameters<CallManager["answerToIncomingCall"]>[1]) => Promise<RTCPeerConnection>;
+    declineToIncomingCall: IncomingCallManager['declineToIncomingCall'];
+    getEstablishedRTCSession: CallManager['getEstablishedRTCSession'];
+    getCallConfiguration: CallManager['getCallConfiguration'];
+    getRemoteStreams: CallManager['getRemoteStreams'];
+    replaceMediaStream: CallManager['replaceMediaStream'];
+    startPresentation(stream: MediaStream, options?: {
+        isP2P?: boolean;
+        isNeedReinvite?: boolean;
+        maxBitrate?: number;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+        callLimit?: number;
+    }): Promise<MediaStream>;
+    stopPresentation(options?: {
+        isP2P?: boolean;
+    }): Promise<MediaStream | undefined>;
+    updatePresentation(stream: MediaStream, options?: {
+        isP2P?: boolean;
+        isNeedReinvite?: boolean;
+        maxBitrate?: number;
+        contentHint?: TContentHint;
+        sendEncodings?: RTCRtpEncodingParameters[];
+        onAddedTransceiver?: TOnAddedTransceiver;
+    }): Promise<MediaStream | undefined>;
+    waitChannels(...args: Parameters<ApiManager['waitChannels']>): Promise<import('../ApiManager/types').TChannels>;
+    waitSyncMediaState(...args: Parameters<ApiManager['waitSyncMediaState']>): Promise<{
+        isSyncForced: boolean;
+    }>;
+    sendDTMF(...args: Parameters<ApiManager['sendDTMF']>): Promise<void>;
+    sendChannels(...args: Parameters<ApiManager['sendChannels']>): Promise<void>;
+    sendMediaState(...args: Parameters<ApiManager['sendMediaState']>): Promise<void>;
+    sendRefusalToTurnOn(...args: Parameters<ApiManager['sendRefusalToTurnOn']>): Promise<void>;
+    sendRefusalToTurnOnMic(...args: Parameters<ApiManager['sendRefusalToTurnOnMic']>): Promise<void>;
+    sendRefusalToTurnOnCam(...args: Parameters<ApiManager['sendRefusalToTurnOnCam']>): Promise<void>;
+    sendMustStopPresentationP2P(...args: Parameters<ApiManager['sendMustStopPresentationP2P']>): Promise<void>;
+    sendStoppedPresentationP2P(...args: Parameters<ApiManager['sendStoppedPresentationP2P']>): Promise<void>;
+    sendStoppedPresentation(...args: Parameters<ApiManager['sendStoppedPresentation']>): Promise<void>;
+    askPermissionToStartPresentationP2P(...args: Parameters<ApiManager['askPermissionToStartPresentationP2P']>): Promise<void>;
+    askPermissionToStartPresentation(...args: Parameters<ApiManager['askPermissionToStartPresentation']>): Promise<void>;
+    askPermissionToEnableCam(...args: Parameters<ApiManager['askPermissionToEnableCam']>): Promise<void>;
+    private subscribe;
+}
+export default SipConnector;

package/dist/SipConnector/eventNames.d.ts

@@ -0,0 +1,4 @@
+import { Events } from 'events-constructor';
+export declare const EVENT_NAMES: readonly ("connection:connecting" | "connection:connected" | "connection:disconnected" | "connection:newRTCSession" | "connection:registered" | "connection:unregistered" | "connection:registrationFailed" | "connection:newMessage" | "connection:sipEvent" | "call:peerconnection" | "call:connecting" | "call:sending" | "call:progress" | "call:accepted" | "call:confirmed" | "call:ended" | "call:failed" | "call:newDTMF" | "call:newInfo" | "call:reinvite" | "call:update" | "call:refer" | "call:replaces" | "call:sdp" | "call:icecandidate" | "call:getusermediafailed" | "call:peerconnection:createofferfailed" | "call:peerconnection:createanswerfailed" | "call:peerconnection:setlocaldescriptionfailed" | "call:peerconnection:setremotedescriptionfailed" | "call:presentation:start" | "call:presentation:started" | "call:presentation:end" | "call:presentation:ended" | "call:presentation:failed" | "call:peerconnection:confirmed" | "call:peerconnection:ontrack" | "call:ended:fromserver" | "api:newDTMF" | "api:channels:notify" | "api:participant:added-to-list-moderators" | "api:participant:removed-from-list-moderators" | "api:participant:move-request-to-stream" | "api:participant:move-request-to-spectators" | "api:participant:move-request-to-participants" | "api:participant:move-request-to-spectators-over-sfu" | "api:participation:accepting-word-request" | "api:participation:cancelling-word-request" | "api:webcast:started" | "api:webcast:stopped" | "api:account:changed" | "api:account:deleted" | "api:conference:participant-token-issued" | "api:channels" | "api:enterRoom" | "api:shareState" | "api:main-cam-control" | "api:useLicense" | "api:admin-start-main-cam" | "api:admin-stop-main-cam" | "api:admin-start-mic" | "api:admin-stop-mic" | "api:admin-force-sync-media-state" | "api:availableSecondRemoteStream" | "api:notAvailableSecondRemoteStream" | "api:mustStopPresentation" | "incoming-call:incomingCall" | "incoming-call:declinedIncomingCall" | "incoming-call:terminatedIncomingCall" | "incoming-call:failedIncomingCall" | "presentation:presentation:start" | "presentation:presentation:started" | "presentation:presentation:end" | "presentation:presentation:ended" | "presentation:presentation:failed")[];
+export type TEvent = (typeof EVENT_NAMES)[number];
+export type TEvents = Events<typeof EVENT_NAMES>;

package/dist/SipConnector/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SipConnector } from './@SipConnector';
+export type { TEvent, TEvents } from './eventNames';

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

@@ -1,17 +1,25 @@
 import { UA } from '@krivega/jssip';
-import { default as SipConnector } from '../SipConnector';
-import { EUseLicense, TContentHint, TSimulcastEncoding } from '../types';
+import { EUseLicense } from '../ApiManager';
+import { TContentHint } from '../PresentationManager';
+import { SipConnector } from '../SipConnector';
+import { TSimulcastEncoding } from '../types';
+type TEnterRoomHandlers = {
+    onEnterPurgatory?: () => void;
+    onEnterConference?: (parameters_: {
+        isSuccessProgressCall: boolean;
+    }) => void;
+};
+export declare const TEST_HOOKS: {
+    handleEnterRoomEvent: (room: string, isSuccessProgressCall: boolean, { onEnterPurgatory, onEnterConference }: TEnterRoomHandlers) => void;
+    handleOnceRaceEvent: (unsubscribeEnterConference: () => void, onEndedCall?: () => void) => void;
+    handleFailProgressEvent: (onFailProgressCall: (() => void) | undefined, unsubscribeEnterConference: () => void, error: Error) => never;
+};
 interface IProxyMethods {
     on: SipConnector['on'];
     once: SipConnector['once'];
     onceRace: SipConnector['onceRace'];
     wait: SipConnector['wait'];
     off: SipConnector['off'];
-    onSession: SipConnector['onSession'];
-    onceSession: SipConnector['onceSession'];
-    onceRaceSession: SipConnector['onceRaceSession'];
-    waitSession: SipConnector['waitSession'];
-    offSession: SipConnector['offSession'];
     sendDTMF: SipConnector['sendDTMF'];
     hangUp: SipConnector['hangUp'];
     declineToIncomingCall: SipConnector['declineToIncomingCall'];
@@ -29,11 +37,6 @@ declare class SipConnectorFacade implements IProxyMethods {
     onceRace: IProxyMethods['onceRace'];
     wait: IProxyMethods['wait'];
     off: IProxyMethods['off'];
-    onSession: IProxyMethods['onSession'];
-    onceSession: IProxyMethods['onceSession'];
-    onceRaceSession: IProxyMethods['onceRaceSession'];
-    waitSession: IProxyMethods['waitSession'];
-    offSession: IProxyMethods['offSession'];
     sendDTMF: IProxyMethods['sendDTMF'];
     hangUp: IProxyMethods['hangUp'];
     declineToIncomingCall: IProxyMethods['declineToIncomingCall'];
@@ -94,7 +97,7 @@ declare class SipConnectorFacade implements IProxyMethods {
     disconnectFromServer: () => Promise<{
         isSuccessful: boolean;
     }>;
-    answerIncomingCall: (parameters: {
+    answerToIncomingCall: (parameters: {
         mediaStream: MediaStream;
         extraHeaders?: string[] | undefined;
         iceServers?: RTCIceServer[];
@@ -130,7 +133,7 @@ declare class SipConnectorFacade implements IProxyMethods {
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
     }) => Promise<MediaStream | undefined>;
-    startPresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, }: {
+    startPresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, callLimit, }: {
         mediaStream: MediaStream;
         isP2P: boolean;
         maxBitrate?: number;
@@ -140,8 +143,7 @@ declare class SipConnectorFacade implements IProxyMethods {
         sendEncodings?: RTCRtpEncodingParameters[];
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
-    }, options?: {
-        callLimit: number;
+        callLimit?: number;
     }) => Promise<MediaStream | undefined>;
     stopShareSipConnector: ({ isP2P }?: {
         isP2P?: boolean;
@@ -152,7 +154,7 @@ declare class SipConnectorFacade implements IProxyMethods {
         isEnabledCam: boolean;
         isEnabledMic: boolean;
     }) => Promise<void>;
-    replaceMediaStream: (mediaStream: MediaStream, { deleteExisting, addMissing, forceRenegotiation, contentHint, simulcastEncodings, degradationPreference, sendEncodings, }?: {
+    replaceMediaStream: (mediaStream: MediaStream, { deleteExisting, addMissing, forceRenegotiation, contentHint, simulcastEncodings, degradationPreference, sendEncodings, }: {
         deleteExisting?: boolean;
         addMissing?: boolean;
         forceRenegotiation?: boolean;

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

@@ -1,19 +1,20 @@
+import { Events } from 'events-constructor';
+import { SESSION_JSSIP_EVENT_NAMES } from './eventNames';
 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';
 export type TEventHandlers = Record<string, (data: unknown) => void>;
 declare class BaseSession implements RTCSession {
     originator: string;
     connection: RTCPeerConnectionDeprecated;
-    events: Events<typeof SESSION_EVENT_NAMES>;
+    events: Events<typeof SESSION_JSSIP_EVENT_NAMES>;
     remote_identity: NameAddrHeader;
     mutedOptions: {
         audio: boolean;
         video: boolean;
     };
-    constructor({ originator, eventHandlers, }: {
+    constructor({ originator, eventHandlers, remoteIdentity, }: {
         originator?: string;
         eventHandlers: TEventHandlers;
+        remoteIdentity: NameAddrHeader;
     });
     get contact(): string;
     get direction(): SessionDirection;
@@ -48,7 +49,7 @@ declare class BaseSession implements RTCSession {
     addListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     once(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     removeListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
-    off(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
+    off(eventName: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     removeAllListeners(_event?: string | symbol): this;
     setMaxListeners(_n: number): this;
     getMaxListeners(): number;
@@ -59,9 +60,9 @@ declare class BaseSession implements RTCSession {
     prependListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     prependOnceListener(_event: string | symbol, _listener: (...arguments_: unknown[]) => void): this;
     eventNames(): (string | symbol)[];
-    initEvents(eventHandlers: TEventHandlers): void;
-    on<T>(eventName: string, handler: (data: T) => void): this;
-    trigger(eventName: TEventSession, data?: unknown): void;
+    initEvents(eventHandlers?: TEventHandlers): void;
+    on<T>(eventName: (typeof SESSION_JSSIP_EVENT_NAMES)[number], handler: (data: T) => void): this;
+    trigger(eventName: (typeof SESSION_JSSIP_EVENT_NAMES)[number], data?: unknown): void;
     /**
      * sendDTMF
      *
@@ -71,7 +72,6 @@ declare class BaseSession implements RTCSession {
      */
     sendDTMF(): void;
     startPresentation(stream: MediaStream): Promise<MediaStream>;
-    updatePresentation(stream: MediaStream): Promise<MediaStream>;
     stopPresentation(stream: MediaStream): Promise<MediaStream>;
     isEstablished(): boolean;
 }