sip-connector 14.0.0 → 14.1.0-alpha.0

package/dist/src/ConnectionManager/ConnectionFlow.d.ts

@@ -0,0 +1,83 @@
+import { UA, WebSocketInterface } from '@krivega/jssip';
+import { default as Events } from 'events-constructor';
+import { TGetServerUrl, 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/src/ConnectionManager/ConnectionStateMachine.d.ts

@@ -0,0 +1,61 @@
+import { default as 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/src/ConnectionManager/RegistrationManager.d.ts

@@ -0,0 +1,17 @@
+import { RegisteredEvent, UA, UnRegisteredEvent } from '@krivega/jssip';
+import { default as 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/src/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/src/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/src/ConnectionManager/eventNames.d.ts

@@ -0,0 +1,16 @@
+import { default as 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/src/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/src/IncomingCallManager/@IncomingCallManager.d.ts

@@ -0,0 +1,36 @@
+import { RTCSession } from '@krivega/jssip';
+import { ConnectionManager } from '../ConnectionManager';
+import { TEvent } from './eventNames';
+type TRemoteCallerData = {
+    displayName?: string;
+    host?: string;
+    incomingNumber?: string;
+    rtcSession?: RTCSession;
+};
+export default class IncomingCallManager {
+    private incomingRTCSession?;
+    private readonly connectionManager;
+    private readonly events;
+    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/src/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/src/IncomingCallManager/index.d.ts

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

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

@@ -0,0 +1,47 @@
+import { CallManager } from '../CallManager';
+import { TEvent } from './eventNames';
+import { TContentHint, TOnAddedTransceiver } from './types';
+export declare const hasCanceledStartPresentationError: (error: unknown) => error is import('repeated-calls').TCanceledError<unknown>;
+declare class PresentationManager {
+    promisePendingStartPresentation?: Promise<MediaStream>;
+    promisePendingStopPresentation?: Promise<MediaStream | undefined>;
+    streamPresentationCurrent?: MediaStream;
+    private readonly events;
+    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/src/PresentationManager/constants.d.ts

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

package/dist/src/PresentationManager/eventNames.d.ts

@@ -0,0 +1,11 @@
+import { default as 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/src/PresentationManager/index.d.ts

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

package/dist/src/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/src/SipConnector.d.ts

@@ -0,0 +1,107 @@
+import { TApiEvent, ApiManager } from './ApiManager';
+import { TCallEvent, CallManager } from './CallManager';
+import { TConnectionManagerEvent, ConnectionManager } from './ConnectionManager';
+import { TIncomingCallEvent, IncomingCallManager } from './IncomingCallManager';
+import { PresentationManager } from './PresentationManager';
+import { TContentHint, TOnAddedTransceiver } from './PresentationManager/types';
+import { TGetServerUrl, TJsSIP } from './types';
+declare class SipConnector {
+    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'];
+    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'];
+    onConnection<T>(eventName: TConnectionManagerEvent, handler: (data: T) => void): () => void;
+    onceConnection<T>(eventName: TConnectionManagerEvent, handler: (data: T) => void): () => void;
+    onceRaceConnection<T>(eventNames: TConnectionManagerEvent[], handler: (data: T, eventName: string) => void): () => void;
+    waitConnection<T>(eventName: TConnectionManagerEvent): Promise<T>;
+    offConnection<T>(eventName: TConnectionManagerEvent, handler: (data: T) => void): void;
+    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'];
+    onCall<T>(eventName: TCallEvent, handler: (data: T) => void): () => void;
+    onceCall<T>(eventName: TCallEvent, handler: (data: T) => void): () => void;
+    onceRaceCall<T>(eventNames: TCallEvent[], handler: (data: T, eventName: string) => void): () => void;
+    waitCall<T>(eventName: TCallEvent): Promise<T>;
+    offIncomingCall<T>(eventName: TIncomingCallEvent, handler: (data: T) => void): void;
+    onIncomingCall<T>(eventName: TIncomingCallEvent, handler: (data: T) => void): () => void;
+    onceIncomingCall<T>(eventName: TIncomingCallEvent, handler: (data: T) => void): () => void;
+    onceRaceIncomingCall<T>(eventNames: TIncomingCallEvent[], handler: (data: T, eventName: string) => void): () => void;
+    waitIncomingCall<T>(eventName: TIncomingCallEvent): Promise<T>;
+    offCall<T>(eventName: TCallEvent, handler: (data: T) => void): void;
+    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>;
+    onApi<T>(eventName: TApiEvent, handler: (data: T) => void): () => void;
+    onceApi<T>(eventName: TApiEvent, handler: (data: T) => void): () => void;
+    onceRaceApi<T>(eventNames: TApiEvent[], handler: (data: T, eventName: string) => void): () => void;
+    waitApi<T>(eventName: TApiEvent): Promise<T>;
+    offApi<T>(eventName: TApiEvent, handler: (data: T) => void): void;
+}
+export default SipConnector;

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

@@ -2,16 +2,21 @@ import { UA } from '@krivega/jssip';
 import { default as SipConnector } from '../SipConnector';
 import { EUseLicense, TContentHint, TSimulcastEncoding } from '../types';
 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'];
+    on: SipConnector['onConnection'];
+    once: SipConnector['onceConnection'];
+    onceRace: SipConnector['onceRaceConnection'];
+    wait: SipConnector['waitConnection'];
+    off: SipConnector['offConnection'];
+    onCall: SipConnector['onCall'];
+    onceCall: SipConnector['onceCall'];
+    onceRaceCall: SipConnector['onceRaceCall'];
+    waitCall: SipConnector['waitCall'];
+    offCall: SipConnector['offCall'];
+    onIncomingCall: SipConnector['onIncomingCall'];
+    onceIncomingCall: SipConnector['onceIncomingCall'];
+    onceRaceIncomingCall: SipConnector['onceRaceIncomingCall'];
+    waitIncomingCall: SipConnector['waitIncomingCall'];
+    offIncomingCall: SipConnector['offIncomingCall'];
     sendDTMF: SipConnector['sendDTMF'];
     hangUp: SipConnector['hangUp'];
     declineToIncomingCall: SipConnector['declineToIncomingCall'];
@@ -24,19 +29,21 @@ interface IProxyMethods {
     isRegistered: SipConnector['isRegistered'];
 }
 declare class SipConnectorFacade implements IProxyMethods {
-    readonly sipConnector: SipConnector;
-    private readonly preferredMimeTypesVideoCodecs?;
-    private readonly excludeMimeTypesVideoCodecs?;
     on: IProxyMethods['on'];
     once: IProxyMethods['once'];
     onceRace: IProxyMethods['onceRace'];
     wait: IProxyMethods['wait'];
     off: IProxyMethods['off'];
-    onSession: IProxyMethods['onSession'];
-    onceSession: IProxyMethods['onceSession'];
-    onceRaceSession: IProxyMethods['onceRaceSession'];
-    waitSession: IProxyMethods['waitSession'];
-    offSession: IProxyMethods['offSession'];
+    onCall: IProxyMethods['onCall'];
+    onceCall: IProxyMethods['onceCall'];
+    onceRaceCall: IProxyMethods['onceRaceCall'];
+    waitCall: IProxyMethods['waitCall'];
+    offCall: IProxyMethods['offCall'];
+    onIncomingCall: IProxyMethods['onIncomingCall'];
+    onceIncomingCall: IProxyMethods['onceIncomingCall'];
+    onceRaceIncomingCall: IProxyMethods['onceRaceIncomingCall'];
+    waitIncomingCall: IProxyMethods['waitIncomingCall'];
+    offIncomingCall: IProxyMethods['offIncomingCall'];
     sendDTMF: IProxyMethods['sendDTMF'];
     hangUp: IProxyMethods['hangUp'];
     declineToIncomingCall: IProxyMethods['declineToIncomingCall'];
@@ -47,6 +54,9 @@ declare class SipConnectorFacade implements IProxyMethods {
     connection: IProxyMethods['connection'];
     isConfigured: IProxyMethods['isConfigured'];
     isRegistered: IProxyMethods['isRegistered'];
+    readonly sipConnector: SipConnector;
+    private readonly preferredMimeTypesVideoCodecs?;
+    private readonly excludeMimeTypesVideoCodecs?;
     constructor(sipConnector: SipConnector, { preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, }?: {
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
@@ -94,7 +104,7 @@ declare class SipConnectorFacade implements IProxyMethods {
     disconnectFromServer: () => Promise<{
         isSuccessful: boolean;
     }>;
-    answerIncomingCall: (parameters: {
+    answerToIncomingCall: (parameters: {
         mediaStream: MediaStream;
         extraHeaders?: string[] | undefined;
         iceServers?: RTCIceServer[];
@@ -118,7 +128,7 @@ declare class SipConnectorFacade implements IProxyMethods {
             isSuccessProgressCall: boolean;
         }) => void;
         onEndedCall?: () => void;
-    }) => Promise<RTCPeerConnection | void>;
+    }) => Promise<RTCPeerConnection | undefined>;
     updatePresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, }: {
         mediaStream: MediaStream;
         isP2P: boolean;
@@ -129,8 +139,8 @@ declare class SipConnectorFacade implements IProxyMethods {
         sendEncodings?: RTCRtpEncodingParameters[];
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
-    }) => Promise<MediaStream | void>;
-    startPresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, }: {
+    }) => Promise<MediaStream | undefined>;
+    startPresentation: ({ mediaStream, isP2P, maxBitrate, contentHint, simulcastEncodings, degradationPreference, sendEncodings, preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, callLimit, }: {
         mediaStream: MediaStream;
         isP2P: boolean;
         maxBitrate?: number;
@@ -140,12 +150,11 @@ declare class SipConnectorFacade implements IProxyMethods {
         sendEncodings?: RTCRtpEncodingParameters[];
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
-    }, options?: {
         callLimit: number;
-    }) => Promise<MediaStream | void>;
+    }) => Promise<MediaStream | undefined>;
     stopShareSipConnector: ({ isP2P }?: {
         isP2P?: boolean;
-    }) => Promise<void | MediaStream>;
+    }) => Promise<void | MediaStream | undefined>;
     sendRefusalToTurnOnMic: () => Promise<void>;
     sendRefusalToTurnOnCam: () => Promise<void>;
     sendMediaState: ({ isEnabledCam, isEnabledMic, }: {