sip-connector 17.0.0 → 19.0.0

package/dist/ApiManager/__tests-utils__/helpers.d.ts

@@ -1,9 +1,7 @@
+import { IncomingInfoEvent, OutgoingInfoEvent } from '@krivega/jssip';
 export declare class MockRequest {
     private headers;
-    static createInfoEvent(originator: string, request: MockRequest): {
-        readonly originator: string;
-        readonly request: MockRequest;
-    };
+    static createInfoEvent(originator: 'local' | 'remote', request: MockRequest): IncomingInfoEvent | OutgoingInfoEvent;
     setHeader(name: string, value: string): void;
     getHeader(name: string): string | undefined;
 }

package/dist/ApiManager/constants.d.ts

@@ -35,8 +35,7 @@ export declare enum EShareState {
 }
 export declare enum EParticipantType {
     SPECTATOR = "SPECTATOR",
-    PARTICIPANT = "PARTICIPANT",
-    SPECTATOR_OVER_SFU = "SPECTATOROVERSFU"
+    PARTICIPANT = "PARTICIPANT"
 }
 export declare enum EContentTypeReceived {
     ENTER_ROOM = "application/vinteo.webrtc.roomname",

package/dist/ApiManager/eventNames.d.ts

@@ -6,7 +6,6 @@ export declare enum EEvent {
     PARTICIPANT_MOVE_REQUEST_TO_STREAM = "participant:move-request-to-stream",
     PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS = "participant:move-request-to-spectators",
     PARTICIPANT_MOVE_REQUEST_TO_PARTICIPANTS = "participant:move-request-to-participants",
-    PARTICIPANT_MOVE_REQUEST_TO_SPECTATORS_OVER_SFU = "participant:move-request-to-spectators-over-sfu",
     PARTICIPATION_ACCEPTING_WORD_REQUEST = "participation:accepting-word-request",
     PARTICIPATION_CANCELLING_WORD_REQUEST = "participation:cancelling-word-request",
     WEBCAST_STARTED = "webcast:started",
@@ -30,6 +29,6 @@ export declare enum EEvent {
     NEW_DTMF = "newDTMF",
     RESTART = "restart"
 }
-export declare const EVENT_NAMES: readonly ["participation:accepting-word-request", "participation:cancelling-word-request", "participant:move-request-to-stream", "channels:notify", "conference:participant-token-issued", "account:changed", "account:deleted", "webcast:started", "webcast:stopped", "participant:added-to-list-moderators", "participant:removed-from-list-moderators", "participant:move-request-to-spectators", "participant:move-request-to-participants", "participant:move-request-to-spectators-over-sfu", "channels", "enterRoom", "shareState", "main-cam-control", "useLicense", "admin-start-main-cam", "admin-stop-main-cam", "admin-start-mic", "admin-stop-mic", "admin-force-sync-media-state", "availableSecondRemoteStream", "notAvailableSecondRemoteStream", "mustStopPresentation", "newDTMF", "restart"];
+export declare const EVENT_NAMES: readonly ["participation:accepting-word-request", "participation:cancelling-word-request", "participant:move-request-to-stream", "channels:notify", "conference:participant-token-issued", "account:changed", "account:deleted", "webcast:started", "webcast:stopped", "participant:added-to-list-moderators", "participant:removed-from-list-moderators", "participant:move-request-to-spectators", "participant:move-request-to-participants", "channels", "enterRoom", "shareState", "main-cam-control", "useLicense", "admin-start-main-cam", "admin-stop-main-cam", "admin-start-mic", "admin-stop-mic", "admin-force-sync-media-state", "availableSecondRemoteStream", "notAvailableSecondRemoteStream", "mustStopPresentation", "newDTMF", "restart"];
 export type TEvent = (typeof EVENT_NAMES)[number];
 export type TEvents = Events<typeof EVENT_NAMES>;

package/dist/AutoConnectorManager/@AutoConnectorManager.d.ts

@@ -0,0 +1,41 @@
+import { ConnectionManager } from '../ConnectionManager';
+import { CallManager } from '../CallManager';
+import { ConnectionQueueManager } from '../ConnectionQueueManager';
+import { TEventMap, TEvents } from './eventNames';
+import { IAutoConnectorOptions, TParametersAutoConnect } from './types';
+declare class AutoConnectorManager {
+    readonly events: TEvents;
+    private readonly connectionManager;
+    private readonly connectionQueueManager;
+    private readonly checkTelephonyRequester;
+    private readonly pingServerIfNotActiveCallRequester;
+    private readonly registrationFailedOutOfCallSubscriber;
+    private readonly attemptsState;
+    private readonly delayBetweenAttempts;
+    private readonly cancelableRequestBeforeRetry;
+    private readonly onBeforeRetry;
+    constructor({ connectionQueueManager, connectionManager, callManager, }: {
+        connectionQueueManager: ConnectionQueueManager;
+        connectionManager: ConnectionManager;
+        callManager: CallManager;
+    }, options?: IAutoConnectorOptions);
+    start(parameters: TParametersAutoConnect): void;
+    stop(): void;
+    on<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    once<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    onceRace<T extends keyof TEventMap>(eventNames: T[], handler: (data: TEventMap[T], eventName: string) => void): () => void;
+    wait<T extends keyof TEventMap>(eventName: T): Promise<TEventMap[T]>;
+    off<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): void;
+    private stopAttempts;
+    private stopConnectTriggers;
+    private runCheckTelephony;
+    private connect;
+    private processConnect;
+    private handleLimitReached;
+    private handleSucceededAttempt;
+    private subscribeToConnectTriggers;
+    private connectIfDisconnected;
+    private reconnect;
+    private hasFailedOrDisconnectedConnection;
+}
+export default AutoConnectorManager;

package/dist/AutoConnectorManager/AttemptsState.d.ts

@@ -0,0 +1,21 @@
+import { TEvents } from './eventNames';
+declare class AttemptsState {
+    private readonly events;
+    private countInner;
+    private readonly initialCount;
+    private readonly limitInner;
+    private isInProgress;
+    constructor({ events }: {
+        events: TEvents;
+    });
+    get count(): number;
+    get limit(): number;
+    get isAttemptInProgress(): boolean;
+    hasLimitReached(): boolean;
+    startAttempt(): void;
+    finishAttempt(): void;
+    increment(): void;
+    reset(): void;
+    private emitStatusChange;
+}
+export default AttemptsState;

package/dist/AutoConnectorManager/CheckTelephonyRequester.d.ts

@@ -0,0 +1,19 @@
+import { ConnectionManager } from '../ConnectionManager';
+import { TParametersCheckTelephony } from './types';
+declare class CheckTelephonyRequester {
+    private readonly connectionManager;
+    private readonly interval;
+    private checkTelephonyByTimeout;
+    private cancelableBeforeRequest;
+    constructor({ connectionManager, interval, }: {
+        connectionManager: ConnectionManager;
+        interval: number;
+    });
+    start({ onBeforeRequest, onSuccessRequest, onFailRequest, }: {
+        onBeforeRequest: () => Promise<TParametersCheckTelephony>;
+        onSuccessRequest: () => void;
+        onFailRequest: () => void;
+    }): void;
+    stop(): void;
+}
+export default CheckTelephonyRequester;

package/dist/AutoConnectorManager/PingServerIfNotActiveCallRequester.d.ts

@@ -0,0 +1,18 @@
+import { CallManager } from '../CallManager';
+import { ConnectionManager } from '../ConnectionManager';
+declare class PingServerIfNotActiveCallRequester {
+    private readonly callManager;
+    private readonly pingServerRequester;
+    private disposeCallStatusChange;
+    constructor({ connectionManager, callManager, }: {
+        connectionManager: ConnectionManager;
+        callManager: CallManager;
+    });
+    start({ onFailRequest }: {
+        onFailRequest: () => void;
+    }): void;
+    stop(): void;
+    private unsubscribeCallStatusChange;
+    private handleCallStatusChange;
+}
+export default PingServerIfNotActiveCallRequester;

package/dist/AutoConnectorManager/PingServerRequester.d.ts

@@ -0,0 +1,13 @@
+import { ConnectionManager } from '../ConnectionManager';
+declare class PingServerRequester {
+    private readonly connectionManager;
+    private readonly pingServerByTimeoutWithFailCalls;
+    constructor({ connectionManager }: {
+        connectionManager: ConnectionManager;
+    });
+    start({ onFailRequest }: {
+        onFailRequest: () => void;
+    }): void;
+    stop(): void;
+}
+export default PingServerRequester;

package/dist/AutoConnectorManager/RegistrationFailedOutOfCallSubscriber.d.ts

@@ -0,0 +1,18 @@
+import { CallManager } from '../CallManager';
+import { ConnectionManager } from '../ConnectionManager';
+import { ISubscriber } from './types';
+declare class RegistrationFailedOutOfCallSubscriber implements ISubscriber {
+    private readonly connectionManager;
+    private readonly callManager;
+    private isRegistrationFailed;
+    private disposers;
+    constructor({ connectionManager, callManager, }: {
+        connectionManager: ConnectionManager;
+        callManager: CallManager;
+    });
+    subscribe(callback: () => void): void;
+    unsubscribe(): void;
+    private setIsRegistrationFailed;
+    private resetIsRegistrationFailed;
+}
+export default RegistrationFailedOutOfCallSubscriber;

package/dist/AutoConnectorManager/eventNames.d.ts

@@ -0,0 +1,18 @@
+import { TypedEvents } from 'events-constructor';
+import { TAttemptStatus } from './types';
+export declare enum EEvent {
+    BEFORE_ATTEMPT = "before-attempt",
+    SUCCEEDED_ATTEMPT = "succeeded-attempt",
+    FAILED_ATTEMPT = "failed-attempt",
+    CANCELLED_ATTEMPT = "cancelled-attempt",
+    CHANGED_ATTEMPT_STATUS = "changed-attempt-status"
+}
+export declare const EVENT_NAMES: readonly ["before-attempt", "succeeded-attempt", "failed-attempt", "cancelled-attempt", "changed-attempt-status"];
+export type TEventMap = {
+    'before-attempt': Record<string, never>;
+    'succeeded-attempt': Record<string, never>;
+    'failed-attempt': Error;
+    'cancelled-attempt': Error;
+    'changed-attempt-status': TAttemptStatus;
+};
+export type TEvents = TypedEvents<TEventMap>;

package/dist/AutoConnectorManager/index.d.ts

@@ -0,0 +1,3 @@
+export { default as AutoConnectorManager } from './@AutoConnectorManager';
+export { createParametersNotExistError } from './utils';
+export type { IAutoConnectorOptions } from './types';

package/dist/AutoConnectorManager/types.d.ts

@@ -0,0 +1,22 @@
+import { ConnectionManager } from '../ConnectionManager';
+import { ConnectionQueueManager } from '../ConnectionQueueManager';
+export interface IAutoConnectorOptions {
+    checkTelephonyRequestInterval?: number;
+    timeoutBetweenAttempts?: number;
+    onBeforeRetry?: () => Promise<void>;
+}
+export type ISubscriber<T = void> = {
+    subscribe: (callback: (value: T) => void) => void;
+    unsubscribe: () => void;
+};
+export type TParametersCheckTelephony = Parameters<ConnectionManager['checkTelephony']>[0];
+export type TParametersConnect = Parameters<ConnectionQueueManager['connect']>[0] extends (() => Promise<infer T>) | infer T ? T : never;
+type TOptionsConnect = Parameters<ConnectionQueueManager['connect']>[1];
+export type TParametersAutoConnect = {
+    getParameters: () => Promise<TParametersConnect & TParametersCheckTelephony>;
+    options?: TOptionsConnect;
+};
+export type TAttemptStatus = {
+    isInProgress: boolean;
+};
+export {};

package/dist/AutoConnectorManager/utils/errors.d.ts

@@ -0,0 +1,2 @@
+export declare const hasParametersNotExistError: (error: unknown) => boolean;
+export declare const createParametersNotExistError: () => Error;

package/dist/AutoConnectorManager/utils/index.d.ts

@@ -0,0 +1 @@
+export { hasParametersNotExistError, createParametersNotExistError } from './errors';

package/dist/CallManager/@CallManager.d.ts

@@ -1,5 +1,5 @@
 import { RTCSession } from '@krivega/jssip';
-import { TEvent, TEvents } from './eventNames';
+import { TEvents, TEventMap } from './eventNames';
 import { ICallStrategy } from './types';
 declare class CallManager {
     readonly events: TEvents;
@@ -9,11 +9,12 @@ declare class CallManager {
     get connection(): RTCPeerConnection | undefined;
     get establishedRTCSession(): RTCSession | undefined;
     get isCallActive(): ICallStrategy['isCallActive'];
-    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;
+    on<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    onRace<T extends keyof TEventMap>(eventNames: T[], handler: (data: TEventMap[T], eventName: string) => void): () => void;
+    once<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): () => void;
+    onceRace<T extends keyof TEventMap>(eventNames: T[], handler: (data: TEventMap[T], eventName: string) => void): () => void;
+    wait<T extends keyof TEventMap>(eventName: T): Promise<TEventMap[T]>;
+    off<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): void;
     setStrategy(strategy: ICallStrategy): void;
     startCall: ICallStrategy['startCall'];
     endCall: ICallStrategy['endCall'];
@@ -21,9 +22,10 @@ declare class CallManager {
     getEstablishedRTCSession: ICallStrategy['getEstablishedRTCSession'];
     getCallConfiguration: ICallStrategy['getCallConfiguration'];
     getRemoteStreams: ICallStrategy['getRemoteStreams'];
-    getTransceivers: ICallStrategy['getTransceivers'];
     addTransceiver: ICallStrategy['addTransceiver'];
     replaceMediaStream: ICallStrategy['replaceMediaStream'];
     restartIce: ICallStrategy['restartIce'];
+    private subscribeCallStatusChange;
+    private maybeTriggerCallStatus;
 }
 export default CallManager;

package/dist/CallManager/AbstractCallStrategy.d.ts

@@ -1,6 +1,6 @@
 import { RTCSession } from '@krivega/jssip';
 import { TEvents } from './eventNames';
-import { ICallStrategy, ITransceiverStorage, TCallConfiguration, TOntrack } from './types';
+import { ICallStrategy, TCallConfiguration, TOntrack } from './types';
 export declare abstract class AbstractCallStrategy implements ICallStrategy {
     protected isPendingCall: boolean;
     protected isPendingAnswer: boolean;
@@ -16,7 +16,7 @@ export declare abstract class AbstractCallStrategy implements ICallStrategy {
     /**
      * Запуск исходящего звонка
      */
-    abstract startCall(params: Parameters<ICallStrategy['startCall']>[0], ua: Parameters<ICallStrategy['startCall']>[1], getSipServerUrl: Parameters<ICallStrategy['startCall']>[2]): Promise<RTCPeerConnection>;
+    abstract startCall(ua: Parameters<ICallStrategy['startCall']>[0], getSipServerUrl: Parameters<ICallStrategy['startCall']>[1], params: Parameters<ICallStrategy['startCall']>[2]): Promise<RTCPeerConnection>;
     /**
      * Завершение звонка
      */
@@ -38,10 +38,6 @@ export declare abstract class AbstractCallStrategy implements ICallStrategy {
      * Получение удаленных медиа-потоков
      */
     abstract getRemoteStreams(): MediaStream[] | undefined;
-    /**
-     * Получение сохраненных transceiver'ов
-     */
-    abstract getTransceivers(): Readonly<ITransceiverStorage>;
     /**
      * Добавление нового transceiver'а
      */

package/dist/CallManager/MCUCallStrategy.d.ts

@@ -1,14 +1,10 @@
 import { AbstractCallStrategy } from './AbstractCallStrategy';
 import { RTCSession } from '@krivega/jssip';
 import { TEvents } from './eventNames';
-import { ICallStrategy, ITransceiverStorage, TOntrack } from './types';
+import { ICallStrategy, TOntrack } from './types';
 export declare class MCUCallStrategy extends AbstractCallStrategy {
     private readonly remoteStreamsManager;
     private readonly disposers;
-    /**
-     * Менеджер для управления transceiver'ами
-     */
-    private readonly transceiverManager;
     constructor(events: TEvents);
     get requested(): boolean;
     get connection(): RTCPeerConnection | undefined;
@@ -32,10 +28,6 @@ export declare class MCUCallStrategy extends AbstractCallStrategy {
         degradationPreference?: RTCDegradationPreference;
     }): Promise<boolean>;
     addTransceiver(kind: 'audio' | 'video', options?: RTCRtpTransceiverInit): Promise<RTCRtpTransceiver>;
-    /**
-     * Возвращает сохраненные transceiver'ы
-     */
-    getTransceivers(): Readonly<ITransceiverStorage>;
     protected readonly handleCall: ({ ontrack, }: {
         ontrack?: TOntrack;
     }) => Promise<RTCPeerConnection>;

package/dist/CallManager/eventNames.d.ts

@@ -1,4 +1,5 @@
-import { Events } from 'events-constructor';
+import { IncomingInfoEvent, OutgoingInfoEvent, EndEvent } from '@krivega/jssip';
+import { TypedEvents } from 'events-constructor';
 export declare enum EEvent {
     PEER_CONNECTION = "peerconnection",
     CONNECTING = "connecting",
@@ -32,7 +33,8 @@ export declare enum EEvent {
     FAILED_PRESENTATION = "presentation:failed",
     PEER_CONNECTION_CONFIRMED = "peerconnection:confirmed",
     PEER_CONNECTION_ONTRACK = "peerconnection:ontrack",
-    ENDED_FROM_SERVER = "ended:fromserver"
+    ENDED_FROM_SERVER = "ended:fromserver",
+    CALL_STATUS_CHANGED = "call-status-changed"
 }
 export declare enum Originator {
     LOCAL = "local",
@@ -40,6 +42,48 @@ export declare enum Originator {
     SYSTEM = "system"
 }
 export declare const SESSION_JSSIP_EVENT_NAMES: readonly ["peerconnection", "connecting", "sending", "progress", "accepted", "confirmed", "ended", "failed", "newInfo", "newDTMF", "presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed", "reinvite", "update", "refer", "replaces", "sdp", "icecandidate", "getusermediafailed", "peerconnection:createofferfailed", "peerconnection:createanswerfailed", "peerconnection:setlocaldescriptionfailed", "peerconnection:setremotedescriptionfailed"];
-export declare const EVENT_NAMES: readonly ["peerconnection", "connecting", "sending", "progress", "accepted", "confirmed", "ended", "failed", "newInfo", "newDTMF", "presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed", "reinvite", "update", "refer", "replaces", "sdp", "icecandidate", "getusermediafailed", "peerconnection:createofferfailed", "peerconnection:createanswerfailed", "peerconnection:setlocaldescriptionfailed", "peerconnection:setremotedescriptionfailed", "peerconnection:confirmed", "peerconnection:ontrack", "ended:fromserver"];
-export type TEvents = Events<typeof EVENT_NAMES>;
+export declare const EVENT_NAMES: readonly ["peerconnection", "connecting", "sending", "progress", "accepted", "confirmed", "ended", "failed", "newInfo", "newDTMF", "presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed", "reinvite", "update", "refer", "replaces", "sdp", "icecandidate", "getusermediafailed", "peerconnection:createofferfailed", "peerconnection:createanswerfailed", "peerconnection:setlocaldescriptionfailed", "peerconnection:setremotedescriptionfailed", "peerconnection:confirmed", "peerconnection:ontrack", "ended:fromserver", "call-status-changed"];
 export type TEvent = (typeof EVENT_NAMES)[number];
+export type TEventMap = {
+    peerconnection: {
+        peerconnection: RTCPeerConnection;
+    };
+    connecting: unknown;
+    sending: unknown;
+    progress: unknown;
+    accepted: unknown;
+    confirmed: unknown;
+    ended: EndEvent;
+    failed: EndEvent;
+    newDTMF: {
+        originator: `${Originator}`;
+    };
+    newInfo: IncomingInfoEvent | OutgoingInfoEvent;
+    hold: unknown;
+    unhold: unknown;
+    muted: unknown;
+    unmuted: unknown;
+    reinvite: unknown;
+    update: unknown;
+    refer: unknown;
+    replaces: unknown;
+    sdp: unknown;
+    icecandidate: unknown;
+    getusermediafailed: unknown;
+    'peerconnection:createofferfailed': unknown;
+    'peerconnection:createanswerfailed': unknown;
+    'peerconnection:setlocaldescriptionfailed': unknown;
+    'peerconnection:setremotedescriptionfailed': unknown;
+    'presentation:start': MediaStream;
+    'presentation:started': MediaStream;
+    'presentation:end': MediaStream;
+    'presentation:ended': MediaStream;
+    'presentation:failed': Error;
+    'peerconnection:confirmed': RTCPeerConnection;
+    'peerconnection:ontrack': RTCTrackEvent;
+    'ended:fromserver': EndEvent;
+    'call-status-changed': {
+        isCallActive: boolean;
+    };
+};
+export type TEvents = TypedEvents<TEventMap>;

package/dist/CallManager/index.d.ts

@@ -1,8 +1,8 @@
 export { default as CallManager } from './@CallManager';
 export { ECallCause } from './causes';
-export { EEvent as ECallEvent, Originator } from './eventNames';
+export type { TEventMap } from './eventNames';
+export { EEvent as ECallEvent } from './eventNames';
 export type { TEvent as TCallEvent, TEvents as TCallEvents } from './eventNames';
 export { default as hasCanceledCallError } from './hasCanceledCallError';
 export { MCUCallStrategy } from './MCUCallStrategy';
-export { TransceiverManager } from './TransceiverManager';
-export type { TCustomError, TGetServerUrl, ITransceiverStorage } from './types';
+export type { TCustomError, TGetServerUrl } from './types';

package/dist/CallManager/types.d.ts

@@ -25,7 +25,7 @@ export type TParamsCall = TParamsAnswerToIncomingCall & {
     number: string;
 };
 export type TCustomError = Error & {
-    originator?: Originator;
+    originator?: `${Originator}`;
     cause?: unknown;
     message: unknown;
     _ws?: unknown;
@@ -33,17 +33,6 @@ export type TCustomError = Error & {
     url?: string;
     code?: string;
 };
-/**
- * Интерфейс для хранения основных transceiver'ов
- */
-export interface ITransceiverStorage {
-    /** Основной transceiver для видео */
-    mainVideo?: RTCRtpTransceiver;
-    /** Основной transceiver для аудио */
-    mainAudio?: RTCRtpTransceiver;
-    /** Transceiver для презентации видео */
-    presentationVideo?: RTCRtpTransceiver;
-}
 export type TCallConfiguration = {
     answer?: boolean;
     number?: string;
@@ -59,7 +48,6 @@ export interface ICallStrategy {
     getEstablishedRTCSession: () => RTCSession | undefined;
     getCallConfiguration: () => TCallConfiguration;
     getRemoteStreams: () => MediaStream[] | undefined;
-    getTransceivers: () => Readonly<ITransceiverStorage>;
     addTransceiver: (kind: 'audio' | 'video', options?: RTCRtpTransceiverInit) => Promise<RTCRtpTransceiver>;
     replaceMediaStream: (mediaStream: MediaStream, options?: {
         deleteExisting?: boolean;

package/dist/ConnectionManager/@ConnectionManager.d.ts

@@ -5,6 +5,10 @@ import { RegisteredEvent, UA, UnRegisteredEvent, WebSocketInterface } from '@kri
 import { TGetServerUrl } from '../CallManager';
 import { TJsSIP } from '../types';
 import { TConnect, TSet } from './ConnectionFlow';
+type TConnectParameters = (() => Promise<Parameters<TConnect>[0]>) | Parameters<TConnect>[0];
+type TConnectOptions = Parameters<TConnect>[1] & {
+    hasReadyForConnection?: () => boolean;
+};
 export default class ConnectionManager {
     readonly events: Events<typeof EVENT_NAMES>;
     ua?: UA;
@@ -22,10 +26,12 @@ export default class ConnectionManager {
     get requested(): boolean;
     get isPendingConnect(): boolean;
     get isPendingInitUa(): boolean;
+    get isDisconnected(): boolean;
+    get isFailed(): boolean;
     get connectionState(): import('./ConnectionStateMachine').EState;
     get isRegistered(): boolean;
     get isRegisterConfig(): boolean;
-    connect: TConnect;
+    connect: (parameters: TConnectParameters, options?: TConnectOptions) => Promise<UA>;
     set: TSet;
     disconnect: () => Promise<void>;
     register(): Promise<RegisteredEvent>;
@@ -45,4 +51,7 @@ export default class ConnectionManager {
     getSipServerUrl: TGetServerUrl;
     readonly getUaProtected: () => UA;
     private readonly getUa;
+    private readonly connectWithProcessError;
+    private readonly processConnect;
 }
+export {};

package/dist/ConnectionManager/eventNames.d.ts

@@ -3,14 +3,18 @@ export declare enum EEvent {
     CONNECTING = "connecting",
     CONNECTED = "connected",
     DISCONNECTED = "disconnected",
+    DISCONNECTING = "disconnecting",
     NEW_RTC_SESSION = "newRTCSession",
     REGISTERED = "registered",
     UNREGISTERED = "unregistered",
     REGISTRATION_FAILED = "registrationFailed",
     NEW_MESSAGE = "newMessage",
-    SIP_EVENT = "sipEvent"
+    SIP_EVENT = "sipEvent",
+    CONNECT_STARTED = "connect-started",
+    CONNECT_SUCCEEDED = "connect-succeeded",
+    CONNECT_FAILED = "connect-failed"
 }
 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 declare const EVENT_NAMES: readonly ["connecting", "connected", "disconnected", "newRTCSession", "registered", "unregistered", "registrationFailed", "newMessage", "sipEvent", "disconnecting", "connect-started", "connect-succeeded", "connect-failed"];
 export type TEvent = (typeof EVENT_NAMES)[number];
 export type TEvents = Events<typeof EVENT_NAMES>;

package/dist/ConnectionManager/index.d.ts

@@ -1,3 +1,4 @@
 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';
+export { hasNotReadyForConnectionError, resolveParameters } from './utils';

package/dist/ConnectionManager/utils/errors.d.ts

@@ -0,0 +1,2 @@
+export declare const hasNotReadyForConnectionError: (error: unknown) => boolean;
+export declare const createNotReadyForConnectionError: () => Error;

package/dist/ConnectionManager/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { hasNotReadyForConnectionError, createNotReadyForConnectionError } from './errors';
+export { default as resolveParameters } from './resolveParameters';

package/dist/ConnectionManager/utils/resolveParameters.d.ts

@@ -0,0 +1,2 @@
+declare const resolveParameters: <T extends object>(parameters: (() => Promise<T>) | T) => Promise<T>;
+export default resolveParameters;

package/dist/ConnectionQueueManager/@ConnectionQueueManager.d.ts

@@ -7,12 +7,6 @@ declare class ConnectionQueueManager {
     });
     connect: ConnectionManager['connect'];
     disconnect: ConnectionManager['disconnect'];
-    register: ConnectionManager['register'];
-    unregister: ConnectionManager['unregister'];
-    tryRegister: ConnectionManager['tryRegister'];
-    checkTelephony: ConnectionManager['checkTelephony'];
-    sendOptions: ConnectionManager['sendOptions'];
-    ping: ConnectionManager['ping'];
-    set: ConnectionManager['set'];
+    stop(): void;
 }
 export default ConnectionQueueManager;

package/dist/ConnectionQueueManager/index.d.ts

@@ -1 +1,2 @@
 export { default as ConnectionQueueManager } from './@ConnectionQueueManager';
+export { isPromiseIsNotActualError as hasConnectionPromiseIsNotActualError } from 'stack-promises';

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

@@ -1,14 +1,15 @@
 import { Events } from 'events-constructor';
 import { ApiManager } from '../ApiManager';
-import { default as CallManager } from '../CallManager/@CallManager';
+import { AutoConnectorManager, IAutoConnectorOptions } from '../AutoConnectorManager';
+import { CallManager, TGetServerUrl } from '../CallManager';
 import { ConnectionManager } from '../ConnectionManager';
 import { ConnectionQueueManager } from '../ConnectionQueueManager';
 import { IncomingCallManager } from '../IncomingCallManager';
 import { PresentationManager, TContentHint, TOnAddedTransceiver } from '../PresentationManager';
 import { StatsManager } from '../StatsManager';
+import { TransceiverManager } from '../TransceiverManager';
 import { VideoSendingBalancerManager } from '../VideoSendingBalancerManager';
 import { EVENT_NAMES, TEvent } from './eventNames';
-import { TGetServerUrl } from '../CallManager';
 import { TJsSIP } from '../types';
 import { IBalancerOptions } from '../VideoSendingBalancer';
 declare class SipConnector {
@@ -16,19 +17,22 @@ declare class SipConnector {
     readonly connectionManager: ConnectionManager;
     readonly connectionQueueManager: ConnectionQueueManager;
     readonly callManager: CallManager;
+    readonly autoConnectorManager: AutoConnectorManager;
     readonly apiManager: ApiManager;
     readonly incomingCallManager: IncomingCallManager;
     readonly presentationManager: PresentationManager;
     readonly statsManager: StatsManager;
     readonly videoSendingBalancerManager: VideoSendingBalancerManager;
+    readonly transceiverManager: TransceiverManager;
     private readonly preferredMimeTypesVideoCodecs?;
     private readonly excludeMimeTypesVideoCodecs?;
     constructor({ JsSIP }: {
         JsSIP: TJsSIP;
-    }, { preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, videoBalancerOptions, }?: {
+    }, { preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, videoBalancerOptions, autoConnectorOptions, }?: {
         preferredMimeTypesVideoCodecs?: string[];
         excludeMimeTypesVideoCodecs?: string[];
         videoBalancerOptions?: IBalancerOptions;
+        autoConnectorOptions?: IAutoConnectorOptions;
     });
     get requestedConnection(): boolean;
     get isPendingConnect(): boolean;
@@ -49,17 +53,19 @@ declare class SipConnector {
     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>;
+    set: ConnectionManager['set'];
     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;
+    startAutoConnect: AutoConnectorManager['start'];
+    stopAutoConnect: AutoConnectorManager['stop'];
     call: (params: Parameters<CallManager["startCall"]>[2]) => Promise<RTCPeerConnection>;
     hangUp: CallManager['endCall'];
     answerToIncomingCall: (params: Parameters<CallManager["answerToIncomingCall"]>[1]) => Promise<RTCPeerConnection>;
@@ -106,7 +112,7 @@ declare class SipConnector {
     askPermissionToEnableCam(...args: Parameters<ApiManager['askPermissionToEnableCam']>): Promise<void>;
     private setCodecPreferences;
     private subscribe;
-    private readonly handleRestart;
-    private readonly updateTransceivers;
+    private readonly bridgeEvents;
+    private readonly resolveHandleAddTransceiver;
 }
 export default SipConnector;