sip-connector 15.0.0 → 15.2.0

package/dist/StatsPeerConnection/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const INTERVAL_COLLECT_STATISTICS = 1000;
+export declare enum EStatsTypes {
+    INBOUND_RTP = "inbound-rtp",
+    REMOTE_OUTBOUND_RTP = "remote-outbound-rtp",
+    MEDIA_SOURCE = "media-source",
+    OUTBOUND_RTP = "outbound-rtp",
+    REMOTE_INBOUND_RTP = "remote-inbound-rtp",
+    CODEC = "codec",
+    CANDIDATE_PAIR = "candidate-pair",
+    CERTIFICATE = "certificate",
+    TRANSPORT = "transport",
+    LOCAL_CANDIDATE = "local-candidate",
+    REMOTE_CANDIDATE = "remote-candidate"
+}

package/dist/StatsPeerConnection/eventNames.d.ts

@@ -0,0 +1,10 @@
+import { TypedEvents } from 'events-constructor';
+import { TInbound, TOutbound } from './typings';
+export type TEventMap = {
+    collected: {
+        outbound: TOutbound;
+        inbound: TInbound;
+    };
+};
+export declare const EVENT_NAMES: readonly ["collected"];
+export type TEvents = TypedEvents<TEventMap>;

package/dist/StatsPeerConnection/index.d.ts

@@ -0,0 +1,4 @@
+export { EStatsTypes } from './constants';
+export type { TEventMap } from './eventNames';
+export { default as StatsPeerConnection } from './StatsPeerConnection';
+export { default as hasAvailableStats } from './utils/hasAvailableStats';

package/dist/StatsPeerConnection/parseStatsReports.d.ts

@@ -0,0 +1,14 @@
+import { TInbound, TOutbound, TSynchronizationSources } from './typings';
+declare const parseStatsReports: ({ audioSenderStats, videoSenderFirstStats, videoSenderSecondStats, audioReceiverStats, videoReceiverFirstStats, videoReceiverSecondStats, synchronizationSources, }: {
+    audioSenderStats?: RTCStatsReport;
+    videoSenderFirstStats?: RTCStatsReport;
+    videoSenderSecondStats?: RTCStatsReport;
+    audioReceiverStats?: RTCStatsReport;
+    videoReceiverFirstStats?: RTCStatsReport;
+    videoReceiverSecondStats?: RTCStatsReport;
+    synchronizationSources: TSynchronizationSources;
+}) => {
+    inbound: TInbound;
+    outbound: TOutbound;
+};
+export default parseStatsReports;

package/dist/StatsPeerConnection/requestAllStatistics.d.ts

@@ -0,0 +1,11 @@
+import { TSynchronizationSources } from './typings';
+declare const requestAllStatistics: (peerConnection: RTCPeerConnection) => Promise<{
+    synchronizationSources: TSynchronizationSources;
+    audioSenderStats: RTCStatsReport | undefined;
+    videoSenderFirstStats: RTCStatsReport | undefined;
+    videoSenderSecondStats: RTCStatsReport | undefined;
+    audioReceiverStats: RTCStatsReport | undefined;
+    videoReceiverFirstStats: RTCStatsReport | undefined;
+    videoReceiverSecondStats: RTCStatsReport | undefined;
+}>;
+export default requestAllStatistics;

package/dist/StatsPeerConnection/typings.d.ts

@@ -0,0 +1,194 @@
+import { EStatsTypes } from './constants';
+export type TMedia = {
+    trackIdentifier?: string;
+    item?: RTCRtpSynchronizationSource;
+};
+export type TSynchronizationSources = {
+    audio: TMedia;
+    video: TMedia;
+};
+export type TCandidatePair = RTCIceCandidatePairStats & {
+    consentRequestsSent?: number;
+    nominated?: boolean;
+    packetsDiscardedOnSend?: number;
+    packetsSent?: number;
+    priority?: number;
+    writable?: boolean;
+};
+export type TCandidate = {
+    candidateType?: string;
+    ip?: string;
+    networkType?: string;
+    isRemote?: boolean;
+    address?: string;
+    component?: RTCIceComponent;
+    foundation?: string;
+    port?: number;
+    priority?: number;
+    protocol?: RTCIceProtocol;
+    relatedAddress?: string;
+    relatedPort?: number;
+    sdpMLineIndex?: number;
+    sdpMid?: string;
+    tcpType?: string;
+    usernameFragment?: string;
+};
+export type TOutboundRtp = RTCOutboundRtpStreamStats & {
+    active?: boolean;
+    encoderImplementation?: string;
+    frameHeight?: number;
+    contentType?: string;
+    frameWidth?: number;
+    framesPerSecond?: number;
+    framesSent?: number;
+    hugeFramesSent?: number;
+    keyFramesEncoded?: number;
+    headerBytesSent?: number;
+    qualityLimitationDurations?: {
+        bandwidth?: number;
+        cpu?: number;
+        none?: number;
+        other?: number;
+    };
+    qualityLimitationReason?: string;
+    qualityLimitationResolutionChanges?: number;
+    mediaSourceId?: string;
+    mediaType?: string;
+    mid?: string;
+    retransmittedBytesSent?: number;
+    retransmittedPacketsSent?: number;
+    totalEncodeTime?: number;
+    totalEncodedBytesTarget?: number;
+    totalPacketSendDelay?: number;
+    targetBitrate?: number;
+    trackId?: string;
+};
+export type TTransport = RTCTransportStats & {
+    dtlsRole?: string;
+    iceLocalUsernameFragment?: string;
+    iceRole?: string;
+    iceState?: string;
+    packetsSent?: number;
+    remoteCertificateId?: string;
+    selectedCandidatePairChanges?: number;
+};
+export type TInboundRtp = RTCInboundRtpStreamStats & {
+    audioLevel?: number;
+    bytesReceived?: number;
+    decoderImplementation?: string;
+    framesDropped?: number;
+    framesReceived?: number;
+    headerBytesReceived?: number;
+    jitterBufferDelay?: number;
+    jitterBufferEmittedCount?: number;
+    keyFramesDecoded?: number;
+    fecPacketsDiscarded?: number;
+    fecPacketsReceived?: number;
+    jitterBufferMinimumDelay?: number;
+    jitterBufferTargetDelay?: number;
+    lastPacketReceivedTimestamp?: number;
+    totalSamplesReceived?: number;
+};
+export type TMediaSource = {
+    audioLevel?: number;
+    frames?: number;
+    framesPerSecond?: number;
+    height?: number;
+    width?: number;
+    totalAudioEnergy?: number;
+    totalSamplesDuration?: number;
+    trackIdentifier?: string;
+};
+export type TCertificate = {
+    base64Certificate?: string;
+    fingerprint?: string;
+    fingerprintAlgorithm?: string;
+};
+export type TRemoteInboundRtp = {
+    codecId?: string;
+    fractionLost?: number;
+    jitter?: number;
+    localId?: string;
+    packetsLost?: number;
+    roundTripTime?: number;
+    roundTripTimeMeasurements?: number;
+    ssrc?: number;
+    totalRoundTripTime?: number;
+    transportId?: string;
+};
+export type TRemoteOutboundRtp = {
+    bytesSent?: number;
+    codecId?: string;
+    localId?: string;
+    packetsSent?: number;
+    remoteTimestamp?: number;
+    reportsSent?: number;
+    roundTripTimeMeasurements?: number;
+    ssrc?: number;
+    totalRoundTripTime?: number;
+    transportId?: string;
+};
+export type TOutboundVideo = {
+    outboundRtp?: TOutboundRtp;
+    mediaSource?: TMediaSource;
+    codec?: RTCRtpCodecParameters;
+    remoteInboundRtp?: TRemoteInboundRtp;
+};
+export type TOutboundAudio = {
+    outboundRtp?: TOutboundRtp;
+    mediaSource?: TMediaSource;
+    codec?: RTCRtpCodecParameters;
+    remoteInboundRtp?: TRemoteInboundRtp;
+};
+export type TAdditional = {
+    candidatePair?: TCandidatePair;
+    certificate?: TCertificate;
+    localCandidate?: TCandidate;
+    remoteCandidate?: TCandidate;
+    transport?: TTransport;
+};
+export type TInboundVideo = {
+    inboundRtp?: TInboundRtp;
+    codec?: RTCRtpCodecParameters;
+    synchronizationSources?: TMedia;
+};
+export type TInboundAudio = {
+    inboundRtp?: TInboundRtp;
+    codec?: RTCRtpCodecParameters;
+    remoteOutboundRtp?: TRemoteOutboundRtp;
+    synchronizationSources?: TMedia;
+};
+export type TInbound = {
+    video: TInboundVideo;
+    secondVideo: TInboundVideo;
+    audio: TInboundAudio;
+    additional: TAdditional;
+};
+export type TOutbound = {
+    video: TOutboundVideo;
+    secondVideo: TOutboundVideo;
+    audio: TOutboundAudio;
+    additional: TAdditional;
+};
+export type TAudioStatistics = {
+    [EStatsTypes.OUTBOUND_RTP]?: TOutboundRtp;
+    [EStatsTypes.CODEC]?: RTCRtpCodecParameters;
+    [EStatsTypes.MEDIA_SOURCE]?: TMediaSource;
+    [EStatsTypes.REMOTE_INBOUND_RTP]?: TRemoteInboundRtp;
+    [EStatsTypes.INBOUND_RTP]?: TInboundRtp;
+    [EStatsTypes.REMOTE_OUTBOUND_RTP]?: TRemoteOutboundRtp;
+};
+export type TVideoStatistics = {
+    [EStatsTypes.OUTBOUND_RTP]?: TOutboundRtp;
+    [EStatsTypes.CODEC]?: RTCRtpCodecParameters;
+    [EStatsTypes.MEDIA_SOURCE]?: TMediaSource;
+    [EStatsTypes.REMOTE_INBOUND_RTP]?: TRemoteInboundRtp;
+    [EStatsTypes.INBOUND_RTP]?: TInboundRtp;
+};
+export type TParsedStatistics = {
+    [EStatsTypes.CANDIDATE_PAIR]?: TCandidatePair;
+    [EStatsTypes.CERTIFICATE]?: TCertificate;
+    [EStatsTypes.LOCAL_CANDIDATE]?: TCandidate;
+    [EStatsTypes.REMOTE_CANDIDATE]?: TCandidate;
+    [EStatsTypes.TRANSPORT]?: TTransport;
+};

package/dist/StatsPeerConnection/utils/hasAvailableStats.d.ts

@@ -0,0 +1,2 @@
+declare const hasAvailableStats: () => boolean;
+export default hasAvailableStats;

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

@@ -0,0 +1,3 @@
+export { default as hasAvailableStats } from './hasAvailableStats';
+export { default as now } from './now';
+export { default as statsReportToObject } from './statsReportToObject';

package/dist/StatsPeerConnection/utils/now.d.ts

@@ -0,0 +1,2 @@
+declare const now: () => number;
+export default now;

package/dist/StatsPeerConnection/utils/statsReportToObject.d.ts

@@ -0,0 +1,4 @@
+declare const statsReportToObject: (results: ReadonlyMap<string, {
+    type: string;
+}>) => {};
+export default statsReportToObject;

package/dist/VideoSendingBalancer/CodecProvider.d.ts

@@ -0,0 +1,7 @@
+import { ICodecProvider } from './types';
+/**
+ * Реализация провайдера кодеков
+ */
+export declare class CodecProvider implements ICodecProvider {
+    getCodecFromSender(sender: RTCRtpSender): Promise<string>;
+}

package/dist/VideoSendingBalancer/ParametersSetterWithQueue.d.ts

@@ -0,0 +1,12 @@
+import { TOnSetParameters, TResultSetParametersToSender } from '../tools';
+import { IEncodingParameters, IParametersSetter } from './types';
+/**
+ * Обёртка для ParametersSetter с использованием TaskQueue
+ */
+export declare class ParametersSetterWithQueue implements IParametersSetter {
+    private readonly taskQueue;
+    private readonly onSetParameters?;
+    constructor(onSetParameters?: TOnSetParameters);
+    setEncodingsToSender(sender: RTCRtpSender, parameters: IEncodingParameters): Promise<TResultSetParametersToSender>;
+    stop(): void;
+}

package/dist/VideoSendingBalancer/SenderBalancer.d.ts

@@ -0,0 +1,52 @@
+import { TResultSetParametersToSender } from '../tools';
+import { ICodecProvider, IMainCamHeaders, IParametersSetter, ISenderFinder } from './types';
+/**
+ * Бизнес-логика балансировки отправителей
+ * Отвечает за определение стратегии и применение параметров к отправителю
+ */
+export declare class SenderBalancer {
+    private readonly ignoreForCodec?;
+    private readonly senderFinder;
+    private readonly codecProvider;
+    private readonly parametersSetter;
+    private readonly resultNoChanged;
+    constructor({ senderFinder, codecProvider, parametersSetter, }: {
+        senderFinder: ISenderFinder;
+        codecProvider: ICodecProvider;
+        parametersSetter: IParametersSetter;
+    }, options: {
+        ignoreForCodec?: string;
+    });
+    /**
+     * Выполняет балансировку на основе заголовков от сервера
+     * @param connection - RTCPeerConnection для получения отправителей
+     * @param headers - Заголовки от сервера с командами управления
+     * @returns Promise с результатом балансировки
+     */
+    balance(connection: RTCPeerConnection, headers?: IMainCamHeaders): Promise<TResultSetParametersToSender>;
+    /**
+     * Обрабатывает отправитель в зависимости от команды управления
+     * @param context - Контекст балансировки
+     * @returns Promise с результатом обработки
+     */
+    private processSender;
+    /**
+     * Понижает разрешение отправителя (пауза камеры)
+     * @param context - Контекст балансировки
+     * @returns Promise с результатом
+     */
+    private downgradeResolutionSender;
+    /**
+     * Устанавливает битрейт на основе разрешения трека
+     * @param context - Контекст балансировки
+     * @returns Promise с результатом
+     */
+    private setBitrateByTrackResolution;
+    /**
+     * Устанавливает разрешение отправителя на основе заголовка
+     * @param resolutionMainCam - Разрешение главной камеры
+     * @param context - Контекст балансировки
+     * @returns Promise с результатом
+     */
+    private setResolutionSender;
+}

package/dist/VideoSendingBalancer/SenderFinder.d.ts

@@ -0,0 +1,7 @@
+import { ISenderFinder } from './types';
+/**
+ * Реализация поиска видео отправителя
+ */
+export declare class SenderFinder implements ISenderFinder {
+    findVideoSender(senders: RTCRtpSender[]): RTCRtpSender | undefined;
+}

package/dist/VideoSendingBalancer/TaskQueue.d.ts

@@ -0,0 +1,20 @@
+import { ITaskQueue } from './types';
+/**
+ * Очередь задач с правильной обработкой ошибок
+ * Обеспечивает последовательное выполнение задач и логирование ошибок
+ */
+export declare class TaskQueue<T> implements ITaskQueue<T> {
+    private readonly stackPromises;
+    /**
+     * Добавляет задачу в очередь и возвращает Promise с результатом
+     * @param task - Функция для выполнения
+     * @returns Promise с результатом выполнения задачи
+     */
+    add(task: () => Promise<T>): Promise<T>;
+    stop(): void;
+    /**
+     * Выполняет задачи из очереди с обработкой ошибок
+     * @returns Promise с результатом выполнения
+     */
+    private run;
+}

package/dist/VideoSendingBalancer/VideoSendingBalancer.d.ts

@@ -0,0 +1,44 @@
+import { SipConnector } from '../SipConnector';
+import { TResultSetParametersToSender } from '../tools';
+import { IBalancerOptions } from './types';
+/**
+ * Контроллер/фасад для балансировки видеопотоков
+ * Координирует работу обработчика событий, балансировщика и очереди задач
+ */
+declare class VideoSendingBalancer {
+    private readonly eventHandler;
+    private readonly senderBalancer;
+    private readonly parametersSetterWithQueue;
+    private serverHeaders?;
+    constructor(sipConnector: SipConnector, { ignoreForCodec, onSetParameters }?: IBalancerOptions);
+    /**
+     * Подписывается на события управления главной камерой
+     */
+    subscribe(): void;
+    /**
+     * Отписывается от событий и сбрасывает состояние
+     */
+    unsubscribe(): void;
+    /**
+     * Сбрасывает состояние балансировщика
+     */
+    reset(): void;
+    /**
+     * Перебалансирует текущее состояние
+     * @returns Promise с результатом балансировки
+     */
+    reBalance(): Promise<TResultSetParametersToSender>;
+    /**
+     * Выполняет балансировку на основе текущего состояния
+     * @returns Promise с результатом балансировки
+     */
+    private balanceByTrack;
+    /**
+     * Обработчик событий управления главной камерой
+     * @param headers - Заголовки от сервера
+     */
+    private readonly handleMainCamControl;
+}
+declare const resolveVideoSendingBalancer: (sipConnector: SipConnector, options?: IBalancerOptions) => VideoSendingBalancer;
+export default VideoSendingBalancer;
+export { resolveVideoSendingBalancer };

package/dist/VideoSendingBalancer/VideoSendingEventHandler.d.ts

@@ -0,0 +1,25 @@
+import { SipConnector } from '../SipConnector';
+import { IEventHandler, IMainCamHeaders } from './types';
+/**
+ * Обработчик событий управления главной камерой
+ * Отвечает за подписку и отписку от событий SipConnector
+ */
+export declare class VideoSendingEventHandler implements IEventHandler {
+    private readonly sipConnector;
+    private currentHandler?;
+    constructor(sipConnector: SipConnector);
+    /**
+     * Подписывается на события управления главной камерой
+     * @param handler - Обработчик события
+     */
+    subscribe(handler: (headers: IMainCamHeaders) => void): void;
+    /**
+     * Отписывается от событий управления главной камерой
+     */
+    unsubscribe(): void;
+    /**
+     * Получает соединение из SipConnector
+     * @returns RTCPeerConnection или undefined
+     */
+    getConnection(): RTCPeerConnection | undefined;
+}

package/dist/VideoSendingBalancer/calcBitrate/calcMaxBitrateByWidth.d.ts

@@ -0,0 +1,4 @@
+export declare const MINIMUM_BITRATE: number;
+export declare const MAXIMUM_BITRATE: number;
+declare const calcMaxBitrateByWidth: (maxWidth: number) => number;
+export default calcMaxBitrateByWidth;

package/dist/VideoSendingBalancer/calcBitrate/calcMaxBitrateByWidthAndCodec.d.ts

@@ -0,0 +1,4 @@
+export declare const getMinimumBitrate: (codec?: string) => number;
+export declare const getMaximumBitrate: (codec?: string) => number;
+declare const calcMaxBitrateByWidthAndCodec: (maxWidth: number, codec?: string) => number;
+export default calcMaxBitrateByWidthAndCodec;

package/dist/VideoSendingBalancer/calcBitrate/index.d.ts

@@ -0,0 +1 @@
+export { default as calcMaxBitrateByWidthAndCodec, getMaximumBitrate, getMinimumBitrate, } from './calcMaxBitrateByWidthAndCodec';

package/dist/VideoSendingBalancer/calcResolution/calcScaleResolutionDownBy.d.ts

@@ -0,0 +1,6 @@
+import { TSize } from '../../types';
+declare const calcScaleResolutionDownBy: ({ videoTrack, targetSize, }: {
+    videoTrack: MediaStreamVideoTrack;
+    targetSize: TSize;
+}) => number;
+export default calcScaleResolutionDownBy;

package/dist/VideoSendingBalancer/calcResolution/index.d.ts

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

package/dist/VideoSendingBalancer/index.d.ts

@@ -0,0 +1,3 @@
+export { calcMaxBitrateByWidthAndCodec } from './calcBitrate';
+export { calcScaleResolutionDownBy } from './calcResolution';
+export { resolveVideoSendingBalancer, default as VideoSendingBalancer, } from './VideoSendingBalancer';

package/dist/VideoSendingBalancer/types.d.ts

@@ -0,0 +1,36 @@
+import { EEventsMainCAM } from '../ApiManager';
+import { TOnSetParameters, TResultSetParametersToSender } from '../tools';
+export interface IBalancerOptions {
+    ignoreForCodec?: string;
+    onSetParameters?: TOnSetParameters;
+}
+export interface IMainCamHeaders {
+    mainCam?: EEventsMainCAM;
+    resolutionMainCam?: string;
+}
+export interface IBalancingContext {
+    sender: RTCRtpSender;
+    videoTrack: MediaStreamVideoTrack;
+    codec?: string;
+}
+export interface ISenderFinder {
+    findVideoSender: (senders: RTCRtpSender[]) => RTCRtpSender | undefined;
+}
+export interface ICodecProvider {
+    getCodecFromSender: (sender: RTCRtpSender) => Promise<string>;
+}
+export interface IEncodingParameters {
+    scaleResolutionDownBy: number;
+    maxBitrate: number;
+}
+export interface IParametersSetter {
+    setEncodingsToSender: (sender: RTCRtpSender, parameters: IEncodingParameters, onSetParameters?: TOnSetParameters) => Promise<TResultSetParametersToSender>;
+}
+export interface IEventHandler {
+    subscribe: (handler: (headers: IMainCamHeaders) => void) => void;
+    unsubscribe: () => void;
+    getConnection: () => RTCPeerConnection | undefined;
+}
+export interface ITaskQueue<T> {
+    add: (task: () => Promise<T>) => Promise<T>;
+}

package/dist/__fixtures__/BaseSession.mock.d.ts

@@ -1,6 +1,6 @@
-import { AnswerOptions, ExtraHeaders, HoldOptions, MediaStreamTypes, NameAddrHeader, OnHoldResult, RTCPeerConnectionDeprecated, RTCSession, ReferOptions, RenegotiateOptions, SessionDirection, SessionStatus, TerminateOptions, URI, C as constants } from '@krivega/jssip';
 import { Events } from 'events-constructor';
 import { SESSION_JSSIP_EVENT_NAMES } from './eventNames';
+import { AnswerOptions, ExtraHeaders, HoldOptions, MediaStreamTypes, NameAddrHeader, OnHoldResult, RTCPeerConnectionDeprecated, RTCSession, ReferOptions, RenegotiateOptions, SessionDirection, SessionStatus, TerminateOptions, URI, C as constants } from '@krivega/jssip';
 export type TEventHandlers = Record<string, (data: unknown) => void>;
 declare class BaseSession implements RTCSession {
     originator: string;

package/dist/__fixtures__/RTCPeerConnectionMock.d.ts

@@ -1,7 +1,7 @@
-import { RTCPeerConnectionDeprecated } from '@krivega/jssip';
 import { Events } from 'events-constructor';
-import { MediaStreamTrackMock } from 'webrtc-mock';
 import { default as RTCRtpSenderMock } from './RTCRtpSenderMock';
+import { RTCPeerConnectionDeprecated } from '@krivega/jssip';
+import { MediaStreamTrackMock } from 'webrtc-mock';
 export declare enum EEvent {
     TRACK = "track"
 }

package/dist/__fixtures__/RTCRtpSenderMock.d.ts

@@ -1,4 +1,5 @@
 declare class RTCRtpSenderMock implements RTCRtpSender {
+    stats: RTCStatsReport;
     dtmf: RTCDTMFSender | null;
     track: MediaStreamTrack | null;
     transport: RTCDtlsTransport | null;

package/dist/__fixtures__/RTCSessionMock.d.ts

@@ -1,5 +1,5 @@
-import { IncomingInfoEvent, NameAddrHeader } from '@krivega/jssip';
-import { TEventHandlers, default as BaseSession } from './BaseSession.mock';
+import { NameAddrHeader, IncomingInfoEvent } from '@krivega/jssip';
+import { default as BaseSession, TEventHandlers } from './BaseSession.mock';
 export declare const FAILED_CONFERENCE_NUMBER = "777";
 export declare const createDeclineStartPresentationError: () => Error;
 declare class RTCSessionMock extends BaseSession {

package/dist/__fixtures__/UA.mock.d.ts

@@ -1,8 +1,8 @@
-import { DisconnectEvent, UA as IUA, IncomingRequest, UAConfiguration, UAConfigurationParams, UAEventMap } from '@krivega/jssip';
 import { Events } from 'events-constructor';
-import { TEventHandlers } from './BaseSession.mock';
 import { default as Registrator } from './Registrator.mock';
 import { default as RTCSessionMock } from './RTCSessionMock';
+import { DisconnectEvent, UA as IUA, IncomingRequest, UAConfiguration, UAConfigurationParams, UAEventMap } from '@krivega/jssip';
+import { TEventHandlers } from './BaseSession.mock';
 export declare const PASSWORD_CORRECT = "PASSWORD_CORRECT";
 export declare const PASSWORD_CORRECT_2 = "PASSWORD_CORRECT_2";
 export declare const NAME_INCORRECT = "NAME_INCORRECT";

package/dist/__fixtures__/eventNames.d.ts

@@ -2,7 +2,7 @@ export declare const UA_SYNTHETICS_EVENT_NAMES: readonly ["incomingCall", "decli
 export declare const UA_JSSIP_EVENT_NAMES: readonly ["connecting", "connected", "disconnected", "newRTCSession", "registered", "unregistered", "registrationFailed", "newMessage", "sipEvent"];
 export declare const SESSION_SYNTHETICS_EVENT_NAMES: readonly ["availableSecondRemoteStream", "notAvailableSecondRemoteStream", "mustStopPresentation", "shareState", "enterRoom", "useLicense", "peerconnection:confirmed", "peerconnection:ontrack", "channels", "ended:fromserver", "main-cam-control", "admin-start-main-cam", "admin-stop-main-cam", "admin-stop-mic", "admin-start-mic", "admin-force-sync-media-state", "participant:move-request-to-spectators", "participant:move-request-to-participants"];
 export declare const SESSION_JSSIP_EVENT_NAMES: readonly ["ended", "connecting", "sending", "reinvite", "replaces", "refer", "progress", "accepted", "confirmed", "peerconnection", "failed", "muted", "unmuted", "newDTMF", "newInfo", "hold", "unhold", "update", "sdp", "icecandidate", "getusermediafailed", "peerconnection:createofferfailed", "peerconnection:createanswerfailed", "peerconnection:setlocaldescriptionfailed", "peerconnection:setremotedescriptionfailed", "presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed"];
-export declare const UA_EVENT_NAMES: ("connecting" | "connected" | "disconnected" | "newRTCSession" | "registered" | "unregistered" | "registrationFailed" | "newMessage" | "sipEvent" | "channels:notify" | "participant:added-to-list-moderators" | "participant:removed-from-list-moderators" | "participant:move-request-to-stream" | "participation:accepting-word-request" | "participation:cancelling-word-request" | "webcast:started" | "webcast:stopped" | "account:changed" | "account:deleted" | "conference:participant-token-issued" | "incomingCall" | "declinedIncomingCall" | "terminatedIncomingCall" | "failedIncomingCall")[];
+export declare const UA_EVENT_NAMES: ("connecting" | "channels:notify" | "participant:added-to-list-moderators" | "participant:removed-from-list-moderators" | "participant:move-request-to-stream" | "participation:accepting-word-request" | "participation:cancelling-word-request" | "webcast:started" | "webcast:stopped" | "account:changed" | "account:deleted" | "conference:participant-token-issued" | "connected" | "disconnected" | "newRTCSession" | "registered" | "unregistered" | "registrationFailed" | "newMessage" | "sipEvent" | "incomingCall" | "declinedIncomingCall" | "terminatedIncomingCall" | "failedIncomingCall")[];
 export declare const SESSION_EVENT_NAMES: readonly ["ended", "connecting", "sending", "reinvite", "replaces", "refer", "progress", "accepted", "confirmed", "peerconnection", "failed", "muted", "unmuted", "newDTMF", "newInfo", "hold", "unhold", "update", "sdp", "icecandidate", "getusermediafailed", "peerconnection:createofferfailed", "peerconnection:createanswerfailed", "peerconnection:setlocaldescriptionfailed", "peerconnection:setremotedescriptionfailed", "presentation:start", "presentation:started", "presentation:end", "presentation:ended", "presentation:failed", "availableSecondRemoteStream", "notAvailableSecondRemoteStream", "mustStopPresentation", "shareState", "enterRoom", "useLicense", "peerconnection:confirmed", "peerconnection:ontrack", "channels", "ended:fromserver", "main-cam-control", "admin-start-main-cam", "admin-stop-main-cam", "admin-stop-mic", "admin-start-mic", "admin-force-sync-media-state", "participant:move-request-to-spectators", "participant:move-request-to-participants"];
 export type TEventUA = (typeof UA_EVENT_NAMES)[number];
 export type TEventSession = (typeof SESSION_EVENT_NAMES)[number];

package/dist/__fixtures__/jssip.mock.d.ts

@@ -1,6 +1,6 @@
-import { RTCSession, UA } from '@krivega/jssip';
 import { default as UAMock } from './UA.mock';
 import { default as WebSocketInterfaceMock } from './WebSocketInterface.mock';
+import { RTCSession, UA } from '@krivega/jssip';
 declare const jssip: {
     triggerNewInfo: (rtcSession: RTCSession, extraHeaders: [string, string][]) => void;
     triggerNewSipEvent: (ua: UA, extraHeaders: [string, string][]) => void;