sip-connector 20.2.1 → 20.4.0

package/dist/ApiManager/index.d.ts

@@ -2,3 +2,4 @@ export { default as ApiManager } from './@ApiManager';
 export { EContentTypeReceived, EContentTypeSent, EEventsMainCAM, EEventsMic, EEventsSyncMediaState, EHeader, EShareState, EUseLicense, } from './constants';
 export { createEvents } from './events';
 export type { TEventMap, TEvent as TApiEvent, TEvents as TApiEvents } from './events';
+export type { TChannels } from './types';

package/dist/CallManager/CallStateMachine.d.ts

@@ -0,0 +1,83 @@
+import { BaseStateMachine } from '../tools/BaseStateMachine';
+import { ActorRefFrom, SnapshotFrom } from 'xstate';
+import { TEvents } from './events';
+export declare enum EState {
+    IDLE = "call:idle",
+    CONNECTING = "call:connecting",
+    RINGING = "call:ringing",
+    ACCEPTED = "call:accepted",
+    IN_CALL = "call:inCall",
+    ENDED = "call:ended",
+    FAILED = "call:failed"
+}
+type TCallEvent = {
+    type: 'CALL.CONNECTING';
+} | {
+    type: 'CALL.RINGING';
+} | {
+    type: 'CALL.ACCEPTED';
+} | {
+    type: 'CALL.CONFIRMED';
+} | {
+    type: 'CALL.ENDED';
+} | {
+    type: 'CALL.FAILED';
+    error?: unknown;
+} | {
+    type: 'CALL.RESET';
+};
+interface ICallContext {
+    lastError?: Error;
+}
+declare const callMachine: import('xstate').StateMachine<ICallContext, {
+    type: "CALL.CONNECTING";
+} | {
+    type: "CALL.RINGING";
+} | {
+    type: "CALL.ACCEPTED";
+} | {
+    type: "CALL.CONFIRMED";
+} | {
+    type: "CALL.ENDED";
+} | {
+    type: "CALL.FAILED";
+    error?: unknown;
+} | {
+    type: "CALL.RESET";
+}, {}, never, {
+    type: "rememberError";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "resetError";
+    params: import('xstate').NonReducibleUnknown;
+}, never, never, EState, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
+    id: "call";
+    states: {
+        readonly "call:idle": {};
+        readonly "call:connecting": {};
+        readonly "call:ringing": {};
+        readonly "call:accepted": {};
+        readonly "call:inCall": {};
+        readonly "call:ended": {};
+        readonly "call:failed": {};
+    };
+}>;
+export type TCallSnapshot = SnapshotFrom<typeof callMachine>;
+export type TCallActor = ActorRefFrom<typeof callMachine>;
+export declare class CallStateMachine extends BaseStateMachine<typeof callMachine, EState> {
+    constructor(events: TEvents);
+    get isIdle(): boolean;
+    get isConnecting(): boolean;
+    get isRinging(): boolean;
+    get isAccepted(): boolean;
+    get isInCall(): boolean;
+    get isEnded(): boolean;
+    get isFailed(): boolean;
+    get isActive(): boolean;
+    get isPending(): boolean;
+    get lastError(): Error | undefined;
+    reset(): void;
+    send(event: TCallEvent): void;
+    private subscribeToEvents;
+}
+export {};

package/dist/ConferenceStateManager/@ConferenceStateManager.d.ts

@@ -0,0 +1,22 @@
+import { TEventMap, TEvents } from './events';
+import { TConferenceState, TConferenceStateUpdate } from './types';
+declare class ConferenceStateManager {
+    readonly events: TEvents;
+    private state;
+    constructor();
+    getState(): Readonly<TConferenceState>;
+    updateState(updates: TConferenceStateUpdate): void;
+    reset(): void;
+    getToken(): string | undefined;
+    getRoom(): string | undefined;
+    getParticipantName(): string | undefined;
+    getChannels(): TConferenceState['channels'];
+    getConference(): string | undefined;
+    getParticipant(): string | undefined;
+    getNumber(): string | undefined;
+    getAnswer(): boolean | undefined;
+    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;
+    off<T extends keyof TEventMap>(eventName: T, handler: (data: TEventMap[T]) => void): void;
+}
+export default ConferenceStateManager;

package/dist/ConferenceStateManager/events.d.ts

@@ -0,0 +1,18 @@
+import { TypedEvents } from 'events-constructor';
+import { TConferenceState } from './types';
+export declare enum EEvent {
+    STATE_CHANGED = "state-changed",
+    STATE_RESET = "state-reset"
+}
+export declare const EVENT_NAMES: readonly ["state-changed", "state-reset"];
+export type TEvent = (typeof EVENT_NAMES)[number];
+export type TEventMap = {
+    'state-changed': {
+        previous: TConferenceState;
+        current: TConferenceState;
+        updates: Partial<TConferenceState>;
+    };
+    'state-reset': Record<string, never>;
+};
+export type TEvents = TypedEvents<TEventMap>;
+export declare const createEvents: () => TypedEvents<TEventMap, readonly (keyof TEventMap)[]>;

package/dist/ConferenceStateManager/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ConferenceStateManager } from './@ConferenceStateManager';
+export { EEvent } from './events';
+export type { TConferenceState, TConferenceStateUpdate } from './types';
+export type { TEventMap, TEvents } from './events';

package/dist/ConferenceStateManager/types.d.ts

@@ -0,0 +1,12 @@
+import { TChannels } from '../ApiManager';
+export type TConferenceState = {
+    room?: string;
+    participantName?: string;
+    channels?: TChannels;
+    token?: string;
+    conference?: string;
+    participant?: string;
+    number?: string;
+    answer?: boolean;
+};
+export type TConferenceStateUpdate = Partial<TConferenceState>;

package/dist/ConnectionManager/ConnectionStateMachine.d.ts

@@ -1,3 +1,5 @@
+import { BaseStateMachine } from '../tools/BaseStateMachine';
+import { ActorRefFrom, SnapshotFrom } from 'xstate';
 import { TEvents } from './events';
 export declare enum EEvents {
     START_CONNECT = "START_CONNECT",
@@ -10,6 +12,13 @@ export declare enum EEvents {
     RESET = "RESET"
 }
 type TConnectionMachineEvent = `${EEvents}`;
+type TConnectionFailedEvent = {
+    type: typeof EEvents.CONNECTION_FAILED;
+    error?: Error;
+};
+interface IConnectionMachineContext {
+    error?: Error;
+}
 export declare enum EState {
     IDLE = "connection:idle",
     CONNECTING = "connection:connecting",
@@ -19,14 +28,51 @@ export declare enum EState {
     DISCONNECTED = "connection:disconnected",
     FAILED = "connection:failed"
 }
-export default class ConnectionStateMachine {
-    private readonly actor;
+declare enum EAction {
+    LOG_TRANSITION = "logTransition",
+    LOG_STATE_CHANGE = "logStateChange",
+    SET_ERROR = "setError",
+    CLEAR_ERROR = "clearError"
+}
+declare const connectionMachine: import('xstate').StateMachine<IConnectionMachineContext, TConnectionFailedEvent | {
+    type: TConnectionMachineEvent;
+}, {}, never, {
+    type: EAction.LOG_TRANSITION;
+    params: {
+        from: string;
+        to: string;
+        event: string;
+    };
+} | {
+    type: EAction.LOG_STATE_CHANGE;
+    params: {
+        state: string;
+    };
+} | {
+    type: EAction.SET_ERROR;
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: EAction.CLEAR_ERROR;
+    params: import('xstate').NonReducibleUnknown;
+}, never, never, EState, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
+    id: "connection";
+    states: {
+        readonly "connection:idle": {};
+        readonly "connection:connecting": {};
+        readonly "connection:initializing": {};
+        readonly "connection:connected": {};
+        readonly "connection:registered": {};
+        readonly "connection:disconnected": {};
+        readonly "connection:failed": {};
+    };
+}>;
+export type TConnectionSnapshot = SnapshotFrom<typeof connectionMachine>;
+export type TConnectionActor = ActorRefFrom<typeof connectionMachine>;
+export default class ConnectionStateMachine extends BaseStateMachine<typeof connectionMachine, EState> {
     private readonly stateChangeListeners;
     private readonly events;
     private unsubscribeFromEvents?;
-    private readonly actorSubscription?;
     constructor(events: TEvents);
-    get state(): EState;
     get isIdle(): boolean;
     get isConnecting(): boolean;
     get isInitializing(): boolean;
@@ -34,6 +80,7 @@ export default class ConnectionStateMachine {
     get isRegistered(): boolean;
     get isDisconnected(): boolean;
     get isFailed(): boolean;
+    get error(): Error | undefined;
     get isPending(): boolean;
     get isPendingConnect(): boolean;
     get isPendingInitUa(): boolean;
@@ -56,5 +103,7 @@ export default class ConnectionStateMachine {
     private readonly toFailed;
     private readonly toIdle;
     private subscribeToEvents;
+    private readonly handleRegistrationFailed;
+    private readonly handleConnectFailed;
 }
 export {};

package/dist/IncomingCallManager/IncomingCallStateMachine.d.ts

@@ -0,0 +1,114 @@
+import { BaseStateMachine } from '../tools/BaseStateMachine';
+import { ActorRefFrom, SnapshotFrom } from 'xstate';
+import { TEvents as TConnectionEvents } from '../ConnectionManager/events';
+import { TEvents as TIncomingEvents, TRemoteCallerData } from './events';
+export declare enum EState {
+    IDLE = "incoming:idle",
+    RINGING = "incoming:ringing",
+    CONSUMED = "incoming:consumed",
+    DECLINED = "incoming:declined",
+    TERMINATED = "incoming:terminated",
+    FAILED = "incoming:failed"
+}
+declare enum EAction {
+    LOG_TRANSITION = "logTransition",
+    LOG_STATE_CHANGE = "logStateChange",
+    REMEMBER_INCOMING = "rememberIncoming",
+    REMEMBER_REASON = "rememberReason",
+    CLEAR_INCOMING = "clearIncoming"
+}
+type TIncomingEvent = {
+    type: 'INCOMING.RINGING';
+    data: TRemoteCallerData;
+} | {
+    type: 'INCOMING.CONSUMED';
+} | {
+    type: 'INCOMING.DECLINED';
+    data: TRemoteCallerData;
+} | {
+    type: 'INCOMING.TERMINATED';
+    data: TRemoteCallerData;
+} | {
+    type: 'INCOMING.FAILED';
+    data: TRemoteCallerData;
+} | {
+    type: 'INCOMING.CLEAR';
+};
+interface IIncomingContext {
+    remoteCallerData?: TRemoteCallerData;
+    lastReason?: EState.CONSUMED | EState.DECLINED | EState.TERMINATED | EState.FAILED;
+}
+declare const incomingMachine: import('xstate').StateMachine<IIncomingContext, {
+    type: "INCOMING.RINGING";
+    data: TRemoteCallerData;
+} | {
+    type: "INCOMING.CONSUMED";
+} | {
+    type: "INCOMING.DECLINED";
+    data: TRemoteCallerData;
+} | {
+    type: "INCOMING.TERMINATED";
+    data: TRemoteCallerData;
+} | {
+    type: "INCOMING.FAILED";
+    data: TRemoteCallerData;
+} | {
+    type: "INCOMING.CLEAR";
+}, {}, never, {
+    type: EAction.LOG_TRANSITION;
+    params: {
+        from: string;
+        to: string;
+        event: string;
+    };
+} | {
+    type: EAction.LOG_STATE_CHANGE;
+    params: {
+        state: string;
+    };
+} | {
+    type: EAction.REMEMBER_INCOMING;
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: EAction.REMEMBER_REASON;
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: EAction.CLEAR_INCOMING;
+    params: import('xstate').NonReducibleUnknown;
+}, never, never, EState, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
+    id: "incoming";
+    states: {
+        readonly "incoming:idle": {};
+        readonly "incoming:ringing": {};
+        readonly "incoming:consumed": {};
+        readonly "incoming:declined": {};
+        readonly "incoming:terminated": {};
+        readonly "incoming:failed": {};
+    };
+}>;
+export type TIncomingSnapshot = SnapshotFrom<typeof incomingMachine>;
+export type TIncomingActor = ActorRefFrom<typeof incomingMachine>;
+type TDeps = {
+    incomingEvents: TIncomingEvents;
+    connectionEvents: TConnectionEvents;
+};
+export declare class IncomingCallStateMachine extends BaseStateMachine<typeof incomingMachine, EState> {
+    constructor({ incomingEvents, connectionEvents }: TDeps);
+    get isIdle(): boolean;
+    get isRinging(): boolean;
+    get isConsumed(): boolean;
+    get isDeclined(): boolean;
+    get isTerminated(): boolean;
+    get isFailed(): boolean;
+    get isActive(): boolean;
+    get isFinished(): boolean;
+    get remoteCallerData(): TRemoteCallerData | undefined;
+    get lastReason(): EState.CONSUMED | EState.DECLINED | EState.TERMINATED | EState.FAILED | undefined;
+    reset(): void;
+    send(event: TIncomingEvent): void;
+    toConsumed(): void;
+    private subscribeIncomingEvents;
+    private subscribeConnectionEvents;
+    private toClearIncoming;
+}
+export {};

package/dist/PresentationManager/PresentationStateMachine.d.ts

@@ -0,0 +1,101 @@
+import { BaseStateMachine } from '../tools/BaseStateMachine';
+import { ActorRefFrom, SnapshotFrom } from 'xstate';
+import { TCallEvents } from '../CallManager';
+export declare enum EState {
+    IDLE = "presentation:idle",
+    STARTING = "presentation:starting",
+    ACTIVE = "presentation:active",
+    STOPPING = "presentation:stopping",
+    FAILED = "presentation:failed"
+}
+declare enum EAction {
+    LOG_TRANSITION = "logTransition",
+    LOG_STATE_CHANGE = "logStateChange",
+    SET_ERROR = "setError",
+    CLEAR_ERROR = "clearError"
+}
+type TPresentationEvent = {
+    type: 'SCREEN.STARTING';
+} | {
+    type: 'SCREEN.STARTED';
+} | {
+    type: 'SCREEN.ENDING';
+} | {
+    type: 'SCREEN.ENDED';
+} | {
+    type: 'SCREEN.FAILED';
+    error?: unknown;
+} | {
+    type: 'CALL.ENDED';
+} | {
+    type: 'CALL.FAILED';
+    error?: unknown;
+} | {
+    type: 'PRESENTATION.RESET';
+};
+interface IPresentationContext {
+    lastError?: Error;
+}
+declare const presentationMachine: import('xstate').StateMachine<IPresentationContext, {
+    type: "SCREEN.STARTING";
+} | {
+    type: "SCREEN.STARTED";
+} | {
+    type: "SCREEN.ENDING";
+} | {
+    type: "SCREEN.ENDED";
+} | {
+    type: "SCREEN.FAILED";
+    error?: unknown;
+} | {
+    type: "CALL.ENDED";
+} | {
+    type: "CALL.FAILED";
+    error?: unknown;
+} | {
+    type: "PRESENTATION.RESET";
+}, {}, never, {
+    type: EAction.LOG_TRANSITION;
+    params: {
+        from: string;
+        to: string;
+        event: string;
+    };
+} | {
+    type: EAction.LOG_STATE_CHANGE;
+    params: {
+        state: string;
+    };
+} | {
+    type: EAction.SET_ERROR;
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: EAction.CLEAR_ERROR;
+    params: import('xstate').NonReducibleUnknown;
+}, never, never, EState, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
+    id: "presentation";
+    states: {
+        readonly "presentation:idle": {};
+        readonly "presentation:starting": {};
+        readonly "presentation:active": {};
+        readonly "presentation:stopping": {};
+        readonly "presentation:failed": {};
+    };
+}>;
+export type TPresentationSnapshot = SnapshotFrom<typeof presentationMachine>;
+export type TPresentationActor = ActorRefFrom<typeof presentationMachine>;
+export declare class PresentationStateMachine extends BaseStateMachine<typeof presentationMachine, EState> {
+    constructor(callEvents: TCallEvents);
+    get isIdle(): boolean;
+    get isStarting(): boolean;
+    get isActive(): boolean;
+    get isStopping(): boolean;
+    get isFailed(): boolean;
+    get isPending(): boolean;
+    get isActiveOrPending(): boolean;
+    get lastError(): Error | undefined;
+    reset(): void;
+    send(event: TPresentationEvent): void;
+    private subscribeCallEvents;
+}
+export {};

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

@@ -1,12 +1,14 @@
 import { ApiManager } from '../ApiManager';
 import { AutoConnectorManager, IAutoConnectorOptions } from '../AutoConnectorManager';
 import { CallManager, TGetUri } from '../CallManager';
+import { ConferenceStateManager } from '../ConferenceStateManager';
 import { ConnectionManager } from '../ConnectionManager';
 import { ConnectionQueueManager } from '../ConnectionQueueManager';
 import { IncomingCallManager } from '../IncomingCallManager';
 import { PresentationManager, TContentHint, TOnAddedTransceiver } from '../PresentationManager';
 import { StatsManager } from '../StatsManager';
 import { VideoSendingBalancerManager } from '../VideoSendingBalancerManager';
+import { ISession } from '../session';
 import { TJsSIP } from '../types';
 import { IBalancerOptions } from '../VideoSendingBalancer';
 import { TEventMap, TEvents } from './events';
@@ -14,6 +16,7 @@ declare class SipConnector {
     readonly events: TEvents;
     readonly connectionManager: ConnectionManager;
     readonly connectionQueueManager: ConnectionQueueManager;
+    readonly conferenceStateManager: ConferenceStateManager;
     readonly callManager: CallManager;
     readonly autoConnectorManager: AutoConnectorManager;
     readonly apiManager: ApiManager;
@@ -21,6 +24,7 @@ declare class SipConnector {
     readonly presentationManager: PresentationManager;
     readonly statsManager: StatsManager;
     readonly videoSendingBalancerManager: VideoSendingBalancerManager;
+    readonly session: ISession;
     private readonly mainStreamHealthMonitor;
     private readonly mainStreamRecovery;
     private readonly preferredMimeTypesVideoCodecs?;
@@ -36,7 +40,7 @@ declare class SipConnector {
     get requestedConnection(): boolean;
     get isPendingConnect(): boolean;
     get isPendingInitUa(): boolean;
-    get connectionState(): import('../ConnectionManager/ConnectionStateMachine').EState;
+    get connectionState(): import('../session').EConnectionStatus;
     get isRegistered(): boolean;
     get isRegisterConfig(): boolean;
     get socket(): import('@krivega/jssip').WebSocketInterface | undefined;
@@ -69,7 +73,10 @@ declare class SipConnector {
     answerToIncomingCall: (params: Parameters<CallManager["answerToIncomingCall"]>[1]) => Promise<RTCPeerConnection>;
     declineToIncomingCall: IncomingCallManager['declineToIncomingCall'];
     getEstablishedRTCSession: CallManager['getEstablishedRTCSession'];
-    getCallConfiguration: CallManager['getCallConfiguration'];
+    getCallConfiguration: () => {
+        number: string | undefined;
+        answer: boolean | undefined;
+    };
     getRemoteStreams: CallManager['getRemoteStreams'];
     replaceMediaStream: CallManager['replaceMediaStream'];
     startPresentation(mediaStream: MediaStream, options?: {
@@ -92,7 +99,7 @@ declare class SipConnector {
         sendEncodings?: RTCRtpEncodingParameters[];
         onAddedTransceiver?: TOnAddedTransceiver;
     }): Promise<MediaStream | undefined>;
-    waitChannels(...args: Parameters<ApiManager['waitChannels']>): Promise<import('../ApiManager/types').TChannels>;
+    waitChannels(...args: Parameters<ApiManager['waitChannels']>): Promise<import('../ApiManager').TChannels>;
     waitSyncMediaState(...args: Parameters<ApiManager['waitSyncMediaState']>): Promise<{
         isSyncForced: boolean;
     }>;
@@ -110,6 +117,7 @@ declare class SipConnector {
     askPermissionToEnableCam(...args: Parameters<ApiManager['askPermissionToEnableCam']>): Promise<void>;
     private subscribeDisconnectedFromOutOfCall;
     private subscribeConnectedWithConfigurationFromOutOfCall;
+    private mayBeStopPresentationAndNotify;
     private subscribeToApiEvents;
     private readonly sendOffer;
     private setCodecPreferences;

package/dist/SipConnector/events.d.ts

@@ -8,7 +8,7 @@ import { TEventMap as TIncomingCallManagerEventMap } from '../IncomingCallManage
 import { TEventMap as TPresentationManagerEventMap } from '../PresentationManager/events';
 import { TEventMap as TStatsManagerEventMap } from '../StatsPeerConnection/events';
 import { TEventMap as TVideoBalancerManagerEventMap } from '../VideoSendingBalancerManager/events';
-export declare const EVENT_NAMES: readonly [...("connection:connecting" | "connection:connected" | "connection:registered" | "connection:disconnected" | "auto-connect:before-attempt" | "auto-connect:success" | "auto-connect:failed-all-attempts" | "auto-connect:cancelled-attempts" | "auto-connect:changed-attempt-status" | "auto-connect:stop-attempts-by-error" | "auto-connect:limit-reached-attempts" | "connection:disconnecting" | "connection:newRTCSession" | "connection:unregistered" | "connection:registrationFailed" | "connection:newMessage" | "connection:sipEvent" | "connection:connect-started" | "connection:connect-succeeded" | "connection:connected-with-configuration" | "connection:connect-failed" | "connection:connect-parameters-resolve-success" | "connection:connect-parameters-resolve-failed" | "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" | "call:call-status-changed" | "call:remote-streams-changed" | "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-participants" | "api:participant:move-request-to-spectators" | "api:participant:move-request-to-spectators-synthetic" | "api:participant:move-request-to-spectators-with-audio-id" | "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" | "api:newDTMF" | "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" | "stats:collected" | "video-balancer:balancing-scheduled" | "video-balancer:balancing-started" | "video-balancer:balancing-stopped" | "video-balancer:parameters-updated")[], "disconnected-from-out-of-call", "connected-with-configuration-from-out-of-call", "stopped-presentation-by-server-command"];
+export declare const EVENT_NAMES: readonly [...("call:connecting" | "call:accepted" | "call:ended" | "call:failed" | "connection:connecting" | "connection:connected" | "connection:registered" | "connection:disconnected" | "auto-connect:before-attempt" | "auto-connect:success" | "auto-connect:failed-all-attempts" | "auto-connect:cancelled-attempts" | "auto-connect:changed-attempt-status" | "auto-connect:stop-attempts-by-error" | "auto-connect:limit-reached-attempts" | "connection:disconnecting" | "connection:newRTCSession" | "connection:unregistered" | "connection:registrationFailed" | "connection:newMessage" | "connection:sipEvent" | "connection:connect-started" | "connection:connect-succeeded" | "connection:connected-with-configuration" | "connection:connect-failed" | "connection:connect-parameters-resolve-success" | "connection:connect-parameters-resolve-failed" | "call:peerconnection" | "call:sending" | "call:progress" | "call:confirmed" | "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" | "call:call-status-changed" | "call:remote-streams-changed" | "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-participants" | "api:participant:move-request-to-spectators" | "api:participant:move-request-to-spectators-synthetic" | "api:participant:move-request-to-spectators-with-audio-id" | "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" | "api:newDTMF" | "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" | "stats:collected" | "video-balancer:balancing-scheduled" | "video-balancer:balancing-started" | "video-balancer:balancing-stopped" | "video-balancer:parameters-updated")[], "disconnected-from-out-of-call", "connected-with-configuration-from-out-of-call", "stopped-presentation-by-server-command"];
 export type TEvent = (typeof EVENT_NAMES)[number];
 type PrefixedEventMap<T extends Record<string, unknown>, Prefix extends string> = {
     [K in keyof T as `${Prefix}:${string & K}`]: T[K];
@@ -20,5 +20,5 @@ type TSipConnectorEventMap = {
 };
 export type TEventMap = PrefixedEventMap<TAutoConnectorManagerEventMap, 'auto-connect'> & PrefixedEventMap<TConnectionManagerEventMap, 'connection'> & PrefixedEventMap<TCallManagerEventMap, 'call'> & PrefixedEventMap<TApiManagerEventMap, 'api'> & PrefixedEventMap<TIncomingCallManagerEventMap, 'incoming-call'> & PrefixedEventMap<TPresentationManagerEventMap, 'presentation'> & PrefixedEventMap<TStatsManagerEventMap, 'stats'> & PrefixedEventMap<TVideoBalancerManagerEventMap, 'video-balancer'> & TSipConnectorEventMap;
 export type TEvents = TypedEvents<TEventMap>;
-export declare const createEvents: () => TypedEvents<TEventMap, readonly ("connection:connecting" | "connection:connected" | "connection:registered" | "connection:disconnected" | "auto-connect:before-attempt" | "auto-connect:success" | "auto-connect:failed-all-attempts" | "auto-connect:cancelled-attempts" | "auto-connect:changed-attempt-status" | "auto-connect:stop-attempts-by-error" | "auto-connect:limit-reached-attempts" | "connection:disconnecting" | "connection:newRTCSession" | "connection:unregistered" | "connection:registrationFailed" | "connection:newMessage" | "connection:sipEvent" | "connection:connect-started" | "connection:connect-succeeded" | "connection:connected-with-configuration" | "connection:connect-failed" | "connection:connect-parameters-resolve-success" | "connection:connect-parameters-resolve-failed" | "call:peerconnection" | "call:connecting" | "call:sending" | "call:progress" | "call:accepted" | "call:confirmed" | "call:ended" | "call:failed" | "call:newDTMF" | "call:newInfo" | "call:hold" | "call:unhold" | "call:muted" | "call:unmuted" | "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" | "call:call-status-changed" | "call:remote-streams-changed" | "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-participants" | "api:participant:move-request-to-spectators" | "api:participant:move-request-to-spectators-synthetic" | "api:participant:move-request-to-spectators-with-audio-id" | "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" | "api:newDTMF" | "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" | "stats:collected" | "video-balancer:balancing-scheduled" | "video-balancer:balancing-started" | "video-balancer:balancing-stopped" | "video-balancer:parameters-updated" | keyof TSipConnectorEventMap)[]>;
+export declare const createEvents: () => TypedEvents<TEventMap, readonly ("call:connecting" | "call:accepted" | "call:ended" | "call:failed" | "connection:connecting" | "connection:connected" | "connection:registered" | "connection:disconnected" | "auto-connect:before-attempt" | "auto-connect:success" | "auto-connect:failed-all-attempts" | "auto-connect:cancelled-attempts" | "auto-connect:changed-attempt-status" | "auto-connect:stop-attempts-by-error" | "auto-connect:limit-reached-attempts" | "connection:disconnecting" | "connection:newRTCSession" | "connection:unregistered" | "connection:registrationFailed" | "connection:newMessage" | "connection:sipEvent" | "connection:connect-started" | "connection:connect-succeeded" | "connection:connected-with-configuration" | "connection:connect-failed" | "connection:connect-parameters-resolve-success" | "connection:connect-parameters-resolve-failed" | "call:peerconnection" | "call:sending" | "call:progress" | "call:confirmed" | "call:newDTMF" | "call:newInfo" | "call:hold" | "call:unhold" | "call:muted" | "call:unmuted" | "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" | "call:call-status-changed" | "call:remote-streams-changed" | "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-participants" | "api:participant:move-request-to-spectators" | "api:participant:move-request-to-spectators-synthetic" | "api:participant:move-request-to-spectators-with-audio-id" | "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" | "api:newDTMF" | "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" | "stats:collected" | "video-balancer:balancing-scheduled" | "video-balancer:balancing-started" | "video-balancer:balancing-stopped" | "video-balancer:parameters-updated" | keyof TSipConnectorEventMap)[]>;
 export {};