@vkontakte/calls-sdk 2.8.11-dev.a9627477.0 → 2.8.11-dev.ad82f51b.0

package/classes/CallRegistry.d.ts

@@ -12,7 +12,7 @@ export declare class CallRegistry {
     remove(id: string | null): void;
     get(id: string): HoldableConversation | undefined;
     getActive(): HoldableConversation | null;
-    getFirstHeld(): HoldableConversation | null;
+    getFirst(): HoldableConversation | null;
     getActiveId(): string | null;
     has(id: string): boolean;
     getAll(): HoldableConversation[];

package/classes/Conversation.d.ts

@@ -12,9 +12,8 @@ import UserType from '../enums/UserType';
 import { JSONObject } from '../static/Json';
 import { IAsrStartParams, IAsrStopParams } from '../types/Asr';
 import { AudienceModeHandsResponse } from '../types/AudienceMode';
-import { ConversationData, ConversationOnStartParams } from '../types/Conversation';
-import { ExternalId, ExternalParticipant, ExternalParticipantId, ExternalParticipantListChunk, ExternalUserId } from '../types/ExternalId';
-import type { FastJoinHandler } from '../types/FastJoin';
+import { ConversationData, ConversationOnJoinParams, ConversationOnStartParams } from '../types/Conversation';
+import { ExternalId, ExternalParticipant, ExternalParticipantId, ExternalParticipantListChunk } from '../types/ExternalId';
 import MediaModifiers from '../types/MediaModifiers';
 import MediaSettings, { IVideoDimentions } from '../types/MediaSettings';
 import { IAddMovieParams, IUpdateMovieData } from '../types/MovieShare';
@@ -43,6 +42,7 @@ export default class Conversation extends EventEmitter {
     private _participantState;
     private _participants;
     private _pendingParticipants;
+    private _directTransportIsMaster?;
     private _transport;
     private _debugInfo;
     private readonly _debug;
@@ -82,15 +82,7 @@ export default class Conversation extends EventEmitter {
     static getSyncedTime(): number;
     get debugSessionId(): string | null;
     onStart({ opponentIds, opponentType, mediaOptions, payload, joiningAllowed, requireAuthToJoin, onlyAdminCanShareMovie, externalIds, onFastStart, conversationId, }: ConversationOnStartParams): Promise<ConversationData>;
-    onJoin(joinArgs: {
-        conversationId?: string;
-        mediaOptions: MediaOption[];
-        chatId?: string;
-        joinLink?: string;
-        observedIds?: ExternalUserId[];
-        payload?: string;
-        onFastJoin?: FastJoinHandler;
-    }): Promise<ConversationData>;
+    onJoin(joinArgs: ConversationOnJoinParams): Promise<ConversationData>;
     private _onJoinPart2;
     private _extractExternalRooms;
     private _extractExternalRoomsData;
@@ -103,7 +95,6 @@ export default class Conversation extends EventEmitter {
     private _acceptConcurrent;
     private _getMainRoomParticipants;
     private _decodeExternalConversationParams;
-    private _logCallStartEvent;
     accept(mediaOptions: MediaOption[]): Promise<ConversationData>;
     decline(): Promise<void>;
     hangup(): Promise<void>;
@@ -113,11 +104,12 @@ export default class Conversation extends EventEmitter {
     setVolume(volume: number): void;
     updateStatisticsInterval(): void;
     private _openTransport;
+    private _allocateParticipantTransport;
     private _close;
     destroy(): Promise<void>;
     private _getConversationParams;
     private _setConversationParams;
-    private _addGeoParamsToEndpoint;
+    private _buildSignalingEndpoint;
     /**
      * @throws ErrorEvent
      */
@@ -144,7 +136,12 @@ export default class Conversation extends EventEmitter {
     private _registerParticipants;
     /** Установим состояние локальных мьютов */
     private _registerParticipantLocalMuteState;
-    private _getStatusByTransportState;
+    private _remoteParticipantSessionState;
+    private _buildConnectionStatus;
+    private _isParticipantSessionStateApplicable;
+    private _setTransportStatus;
+    private _setSessionState;
+    private _emitParticipantTransition;
     private _registerParticipantInCache;
     private _getExistedParticipantByIdOrCreate;
     private _getExternalIdByParticipantId;
@@ -184,6 +181,10 @@ export default class Conversation extends EventEmitter {
     private _cleanupParticipants;
     private _cleanupParticipantAgnosticStreams;
     private _cleanupTransport;
+    private _finishLifecycle;
+    private _getFirstMediaSentCallback;
+    private _stopFirstMediaSentProbe;
+    private _cleanupTransportForHold;
     private _cleanupSpeakerDetector;
     private _cleanupSpecListener;
     private _cleanupSignaling;
@@ -223,8 +224,6 @@ export default class Conversation extends EventEmitter {
     updateDisplayLayout(layouts: ParticipantLayout[]): Promise<void>;
     requestDisplayLayout(requests: DisplayLayoutRequest[]): Promise<void>;
     feedback(key: string): Promise<SignalingMessage>;
-    userFeedbackStats(userResponse: number, reason?: string, groupCallUsersCount?: number): void;
-    sendClientEvent(eventType: string, eventData?: Record<string, string | number | boolean>, immediately?: boolean): void;
     private _changeMediaSettings;
     private _stopStreaming;
     /**
@@ -320,11 +319,17 @@ export default class Conversation extends EventEmitter {
     private _changeMultipleParticipantState;
     private _invokeRolesChangedCallbackIfNeeded;
     private _onSignalingNotification;
+    private _onSignalingTopologyChanged;
     private _onPromotionApproved;
     private _onSignalingReconnect;
     private _onSignalingFailed;
     private _onAcceptedCall;
     private _onHungup;
+    private _onSessionState;
+    private _reconcileParticipantSessionStates;
+    private _updateParticipantExternalId;
+    private _updateParticipantSessionState;
+    private _emitParticipantEffectiveStatusIfSessionOverridesTransport;
     private _onAddedParticipant;
     private _onJoinedParticipant;
     private _onClosedConversation;

package/classes/StatsLogger.d.ts

@@ -1,6 +1,14 @@
 import BaseApi from '../abstract/BaseApi';
 import BaseLogger from '../abstract/BaseLogger';
 import StatLog from '../enums/StatLog';
+import TransportTopology from '../enums/TransportTopology';
+type ClientStatsPayload = Record<string, string | number | boolean | undefined | null>;
+export type LogClientStatsOptions = {
+    immediately?: boolean;
+    occurredAt?: number;
+    conversationId?: string | null;
+    deferUntilServerTime?: boolean;
+};
 /**
  * Класс отвечает за отправку различной информации в сервис статистики (события, статистика и подобное)
  */
@@ -8,22 +16,26 @@ export default class StatsLogger extends BaseLogger {
     private readonly _externalLogger;
     private readonly _api;
     private readonly _conversationIdProvider;
+    private readonly _topologyProvider;
     private readonly _batchInterval;
     private _batchedClientStats;
-    private _batchedClientEvents;
     private _batchTimeout;
     private _serverTimeDelta;
-    constructor(api: BaseApi, externalLogger: BaseLogger | null, conversationIdProvider: () => string | null);
+    private _waitingForServerTime;
+    private _deferredClientStats;
+    constructor(api: BaseApi, externalLogger: BaseLogger | null, conversationIdProvider: () => string | null, topologyProvider?: () => TransportTopology | undefined);
     log(name: StatLog, value?: string, immediately?: boolean): void;
-    logClientStats(data: Record<string, string | number | boolean | undefined | null>, immediately?: boolean): void;
-    logClientEvent(data: Record<string, string | number | boolean | undefined | null>, immediately?: boolean): void;
+    logClientStats(data: ClientStatsPayload, immediatelyOrOptions?: boolean | LogClientStatsOptions): void;
     destroy(): void;
+    private _logClientStats;
     private _getConversationId;
+    private _getCallTopology;
     private _sendBatch;
     private _startTimeout;
     private _stopTimeout;
     private _sendClientStats;
-    private _sendClientEvents;
     private _calculateServerTimeDelta;
+    private _flushDeferredClientStats;
     private _now;
 }
+export {};

package/classes/codec/WorkerBase.d.ts

@@ -12,5 +12,7 @@ export default abstract class WorkerBase {
     protected _sendToWorker(type: string, data?: {
         [key: string]: any;
     }, transfer?: any[]): void;
+    private _formatWorkerError;
+    private _formatWorkerMessageError;
     static isBrowserSupported(): boolean;
 }

package/classes/stat/CallLifecycleStats.d.ts

@@ -0,0 +1,47 @@
+import HangupReason from '../HangupReason';
+import StatsLogger from '../StatsLogger';
+export type CallLifecycleSource = 'outgoing' | 'incoming' | 'join' | 'anonym_join';
+export interface CallLifecycleInitializationParams {
+    source: CallLifecycleSource;
+    conversationId?: string;
+}
+export interface CallLifecycleClock {
+    wallNow(): number;
+    monotonicNow(): number;
+}
+export declare class CallLifecycleStats {
+    private readonly _logger;
+    private readonly _clock;
+    private _conversationId;
+    private _callStartLabel;
+    private _lifecycleStartedAtMonotonic;
+    private _warmupStartedAtMonotonic;
+    private _pendingEvents;
+    private _warmupCompleted;
+    private _callStarted;
+    private _accepted;
+    private _firstMediaSent;
+    private _finished;
+    private _destroyed;
+    constructor(logger: StatsLogger, clock?: CallLifecycleClock);
+    get firstMediaSentReported(): boolean;
+    get terminated(): boolean;
+    markInitializationStarted({ source, conversationId }: CallLifecycleInitializationParams): void;
+    bindConversationId(conversationId: string): void;
+    markWarmupStarted(): void;
+    markWarmupCompleted(): void;
+    markCallStarted(): void;
+    markOutgoingAccepted(): void;
+    markIncomingAccepted(concurrent: boolean): void;
+    markFirstMediaSent(): void;
+    markFinished(reason: HangupReason): void;
+    markTerminated(): void;
+    destroy(): void;
+    private _canRecord;
+    private _durationSince;
+    private _finish;
+    private _ensureConversationId;
+    private _record;
+    private _flushPendingEvents;
+    private _logEvent;
+}

package/classes/stat/ConversationStats.d.ts

@@ -1,21 +1,22 @@
 import BaseApi from '../../abstract/BaseApi';
 import BaseLogger from '../../abstract/BaseLogger';
+import TransportTopology from '../../enums/TransportTopology';
 import HangupReason from '../HangupReason';
 import StatsLogger from '../StatsLogger';
-import TransportTopology from '../../enums/TransportTopology';
+import { CallLifecycleStats } from './CallLifecycleStats';
 import { CodecStatsAggregator } from './CodecStatsAggregator';
 import { StatAggregator } from './StatAggregator';
 import { StatPings } from './StatPings';
 import { StatSignalingCommands } from './StatSignalingCommands';
 export declare class ConversationStats {
     readonly logger: StatsLogger;
+    readonly lifecycle: CallLifecycleStats;
     readonly statAggregator: StatAggregator;
     readonly codecStatsAggregator: CodecStatsAggregator;
     readonly pings: StatPings;
     readonly signalingCommands: StatSignalingCommands;
     constructor(api: BaseApi, externalLogger: BaseLogger | null, getConversationId: () => string | null, getTopology: () => TransportTopology | undefined);
-    logHangup(reason: HangupReason, topology?: TransportTopology): void;
-    flushCallMetrics(topology?: TransportTopology): void;
+    logHangup(reason: HangupReason): void;
+    flushCallMetrics(): void;
     destroy(): void;
-    private static correctHangupReason;
 }

package/classes/stat/FirstMediaSentProbe.d.ts

@@ -0,0 +1,13 @@
+export declare class FirstMediaSentProbe {
+    private readonly _peerConnection;
+    private readonly _onFirstMediaSent;
+    private readonly _pollIntervalMs;
+    private _timer;
+    private _state;
+    constructor(peerConnection: RTCPeerConnection, onFirstMediaSent: () => void, pollIntervalMs?: number);
+    start(): void;
+    destroy(): void;
+    private _getStatsReports;
+    private _poll;
+    private _scheduleNextPoll;
+}

package/classes/stat/StatPings.d.ts

@@ -1,6 +1,5 @@
 import { SignalingTransportType } from '../../enums/SignalingTransportStat';
 import StatsLogger from '../StatsLogger';
-import TransportTopology from '../../enums/TransportTopology';
 export declare class StatPings {
     private readonly _logger;
     private trackerByTransport;
@@ -12,6 +11,6 @@ export declare class StatPings {
      */
     mark(transport: SignalingTransportType): void;
     /** Отправляем данные в стату */
-    logMetrics(topology?: TransportTopology): void;
+    logMetrics(): void;
     destroy(): void;
 }

package/classes/stat/StatSignalingCommands.d.ts

@@ -1,12 +1,11 @@
 import { SignalingTransportType } from '../../enums/SignalingTransportStat';
 import StatsLogger from '../StatsLogger';
-import TransportTopology from '../../enums/TransportTopology';
 export declare class StatSignalingCommands {
     private readonly _logger;
     private trackerByCommand;
     constructor(logger: StatsLogger);
     mark(command: string, time: number, transport: SignalingTransportType): void;
     /** Отправляем данные в стату */
-    logMetrics(topology?: TransportTopology): void;
+    logMetrics(): void;
     destroy(): void;
 }

package/classes/transport/BaseTransport.d.ts

@@ -7,7 +7,13 @@ export default abstract class BaseTransport extends EventEmitter {
     protected readonly _mediaSource: MediaSource;
     protected _state: TransportState;
     protected _pc: RTCPeerConnection | null;
-    protected constructor(signaling: BaseSignaling, mediaSource: MediaSource);
+    private readonly _onFirstMediaSent;
+    private _firstMediaSentProbe;
+    private _firstMediaSentProbeStopped;
+    protected constructor(signaling: BaseSignaling, mediaSource: MediaSource, onFirstMediaSent?: (() => void) | null);
     getState(): TransportState;
+    stopFirstMediaSentProbe(): void;
     abstract close(error?: Error): void;
+    protected _startFirstMediaSentProbe(): void;
+    protected _disposeFirstMediaSentProbe(): void;
 }

package/classes/transport/DirectTransport.d.ts

@@ -27,6 +27,7 @@ export default class DirectTransport extends BaseTransport {
     private _iceRestartTimeout;
     private _reconnectionTimeout;
     private _reconnectionPrevented;
+    private _remoteHold;
     private _lastStat;
     private _fingerprint;
     private _neverConnected;
@@ -42,7 +43,7 @@ export default class DirectTransport extends BaseTransport {
     private readonly _logger;
     private readonly _statAggregator;
     private readonly _codecStatsAggregator;
-    constructor(participantId: ParticipantId, isMaster: boolean, signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null);
+    constructor(participantId: ParticipantId, isMaster: boolean, signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null, onFirstMediaSent?: (() => void) | null);
     get participantId(): ParticipantId;
     updateStatisticsInterval(): void;
     private _isDeadConnection;
@@ -50,6 +51,10 @@ export default class DirectTransport extends BaseTransport {
     updateSettings(settings: ServerSettings): void;
     preventRestart(): void;
     allowRestart(): void;
+    setRemoteHold(hold: boolean): void;
+    private _recreatePeerConnection;
+    private _createPeerConnection;
+    private _disposePeerConnection;
     setAnimojiTransport(receiver: AnimojiReceiver, sender: AnimojiSender): void;
     close(error?: Error): void;
     private _setState;

package/classes/transport/ServerTransport.d.ts

@@ -47,7 +47,7 @@ export default class ServerTransport extends BaseTransport {
     private readonly _logger;
     private readonly _statAggregator;
     private readonly _codecStatsAggregator;
-    constructor(signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null);
+    constructor(signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null, onFirstMediaSent?: (() => void) | null);
     updateStatisticsInterval(): void;
     open(observer?: boolean): void;
     close(error?: Error): void;

package/classes/transport/Transport.d.ts

@@ -48,13 +48,18 @@ export declare class Transport extends EventEmitter {
     private readonly _logger;
     private readonly _statAggregator;
     private readonly _codecStatsAggregator;
-    constructor(topology: TransportTopology, signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null);
+    private readonly _onFirstMediaSent;
+    private _firstMediaSentProbeStopped;
+    constructor(topology: TransportTopology, signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings, debug?: DebugLogger, logger?: StatsLogger | null, statAggregator?: StatAggregator | null, codecStatsAggregator?: CodecStatsAggregator | null, onFirstMediaSent?: (() => void) | null);
     updateSettings(settings: ServerSettings): void;
     updateStatisticsInterval(): void;
     allocate(participantId: ParticipantId, isMaster?: boolean): void;
     open(participantIds: ParticipantId[], peerId?: string | null, observer?: boolean, force?: boolean): void;
     close(participantId: ParticipantId): void;
     destroy(): void;
+    stopFirstMediaSentProbe(): void;
+    holdClose(): void;
+    setRemoteHold(hold: boolean): void;
     getTopology(): TransportTopology;
     isAllocated(participantId: ParticipantId): boolean;
     allocated(): string[];
@@ -67,6 +72,8 @@ export declare class Transport extends EventEmitter {
     private _setStates;
     private _setLocalState;
     private _onSignalingNotification;
+    private _handleFirstMediaSent;
+    private _getFirstMediaSentCallback;
     private _onTopologyChanged;
     private _createDirectTransport;
     private _createServerTransport;

package/default/Api.d.ts

@@ -1,10 +1,11 @@
-import BaseApi, { ClientEvent, ClientStats } from '../abstract/BaseApi';
+import BaseApi, { ClientStats } from '../abstract/BaseApi';
 import CallType from '../enums/CallType';
 import HangupType from '../enums/HangupType';
 import ConversationParams from '../types/ConversationParams';
 import ConversationResponse from '../types/ConversationResponse';
 import { ExternalId, ExternalParticipantId, ExternalUserId } from '../types/ExternalId';
 import { CompositeUserId, OkUserId, ParticipantId } from '../types/Participant';
+import PushData from '../types/PushData';
 export default class Api extends BaseApi {
     private _userId;
     private _uuid;
@@ -13,8 +14,12 @@ export default class Api extends BaseApi {
     protected _call(method: string, data?: any, noSession?: boolean): Promise<any>;
     userId(participantId: ParticipantId): Promise<ExternalParticipantId>;
     authorize(): Promise<void>;
+    private _getAnonymLoginCacheKey;
+    private _getCachedAnonymLogin;
+    private _setCachedAnonymLogin;
+    private _removeCachedAnonymLogin;
+    private _applyAnonymLogin;
     logClientStats(items: ClientStats[]): void;
-    logClientEvents(items: ClientEvent[]): void;
     uploadDebugLogs(conversationId: string, startTime: number, endTime: number, log: string): Promise<void>;
     joinConversation(conversationId: string, isVideo?: boolean, chatId?: string): Promise<ConversationResponse>;
     createConversation(conversationId: string, payload?: string, requireAuthToJoin?: boolean, { onlyAdminCanShareMovie, audienceMode, audioOnly, waitForAdmin, closedConversation, }?: {
@@ -60,4 +65,5 @@ export default class Api extends BaseApi {
     cleanup(): void;
     private _getExternalIdsByOkIds;
     getServerTime(): Promise<number>;
+    getInbounds(): Promise<PushData[]>;
 }

package/enums/SignalingNotification.d.ts

@@ -24,6 +24,7 @@ declare enum SignalingNotification {
     REALLOC_CON = "realloc-con",
     AUDIO_ACTIVITY = "audio-activity",
     SPEAKER_CHANGED = "speaker-changed",
+    SESSION_STATE = "session-state",
     STALLED_ACTIVITY = "stalled-activity",
     CHAT_MESSAGE = "chat-message",
     CUSTOM_DATA = "custom-data",

package/enums/Stat.d.ts

@@ -1,4 +1,10 @@
 declare const enum Stat {
+    CALL_INIT = "call_init",
+    CALL_WARMUP = "call_warmup",
+    CALL_START = "call_start",
+    CALL_ACCEPTED_OUTGOING = "call_accepted_outgoing",
+    CALL_ACCEPTED_INCOMING = "call_accepted_incoming",
+    FIRST_MEDIA_SENT = "first_media_sent",
     CALL_FINISH = "call_finish",// событие отправляемое в конце звонка
     CODEC_USAGE = "codec_usage",// событие когда меняется кодек
     SIGNALING_CONNECTED = "signaling_connected",// measure
@@ -7,7 +13,6 @@ declare const enum Stat {
     FIRST_MEDIA_RECEIVED = "first_media_received",
     CALL_DECLINED_OR_HANGED_LOCALLY = "CallDeclinedOrHangedLocally",
     USER_FEEDBACK_RECEIVED = "UserFeedbackReceived",
-    CALL_START = "call_start",
     SIGNALING_PING_SUMMARY = "signaling_ping_summary",
     SIGNALING_COMMAND_SUMMARY = "signaling_command_summary",
     WEBSOCKET_CONNECTED = "websocket_connected",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vkontakte/calls-sdk",
-  "version": "2.8.11-dev.a9627477.0",
+  "version": "2.8.11-dev.ad82f51b.0",
   "author": "vk.com",
   "description": "Library for video calls based on the vk.com platform",
   "homepage": "https://vk.com",

package/static/Params.d.ts

@@ -256,13 +256,6 @@ export type ParamsObject = {
     perfStatReportEnabled: boolean;
     /** @hidden */
     callStatReportEnabled: boolean;
-    /**
-     * Включает логирование событий продуктовой статистики.
-     *
-     * _По умолчанию: `false`_
-     * @hidden
-     */
-    clientEventsLoggingEnabled: boolean;
     /**
      * Отдавать приоритет кодеку H264 для исходящего видео
      *
@@ -500,6 +493,12 @@ export type ParamsObject = {
      * _По умолчанию: `false`_
      */
     transparentAudio: boolean;
+    /**
+     * Включить получение обновлений состояния медийной сессии участников
+     *
+     * _По умолчанию: `false`_
+     */
+    enableSessionStateUpdates: boolean;
     /**
      * Получен локальный стрим с камеры/микрофона
      */
@@ -977,7 +976,6 @@ export default abstract class Params {
     static get networkStatisticsInterval(): number;
     static get perfStatReportEnabled(): boolean;
     static get callStatReportEnabled(): boolean;
-    static get clientEventsLoggingEnabled(): boolean;
     static get enableLogPerfStatReport(): boolean;
     static get asrDataChannel(): boolean;
     static get consumerScreenDataChannelPacketSize(): number;
@@ -1021,6 +1019,7 @@ export default abstract class Params {
     static get webtransport(): boolean;
     static get webtransportFF(): boolean;
     static get transparentAudio(): boolean;
+    static get enableSessionStateUpdates(): boolean;
     static toJSON(): {
         apiKey: string;
         apiEnv: string;
@@ -1056,5 +1055,6 @@ export default abstract class Params {
         webtransport: boolean;
         webtransportFF: boolean;
         transparentAudio: boolean;
+        enableSessionStateUpdates: boolean;
     };
 }

package/static/ParticipantConnectionStatusUtils.d.ts

@@ -0,0 +1,16 @@
+import { ParticipantConnectionStatus, ParticipantSessionState } from '../types/Participant';
+import { ParticipantStatus } from './External';
+import TransportState from '../enums/TransportState';
+type StatusTransition = {
+    status: ParticipantStatus;
+    shouldNotify: boolean;
+};
+declare namespace ParticipantConnectionStatusUtils {
+    function create(status?: Partial<ParticipantConnectionStatus> | null): ParticipantConnectionStatus;
+    function fromTransportState(state?: TransportState): ParticipantStatus | null;
+    function computeEffective(status: ParticipantConnectionStatus): ParticipantStatus;
+    function setSessionState(status: ParticipantConnectionStatus, sessionState?: ParticipantSessionState, sessionStateConnectedBySpeaker?: boolean): StatusTransition;
+    function setTransport(status: ParticipantConnectionStatus, transport: ParticipantStatus): StatusTransition;
+    function setSessionStateApplicable(status: ParticipantConnectionStatus, applicable: boolean): StatusTransition;
+}
+export default ParticipantConnectionStatusUtils;

package/types/Conversation.d.ts

@@ -7,7 +7,8 @@ import MediaOption from '../enums/MediaOption';
 import UserRole from '../enums/UserRole';
 import { AsrInfo } from './Asr';
 import { IFeaturesPerRole } from './ConversationFeature';
-import { ExternalId, ExternalParticipantId } from './ExternalId';
+import { ExternalId, ExternalParticipantId, ExternalUserId } from './ExternalId';
+import { FastJoinHandler } from './FastJoin';
 import { FastStartHandler } from './FastStart';
 import MediaModifiers from './MediaModifiers';
 import MuteStates from './MuteStates';
@@ -84,6 +85,16 @@ export type ConversationOnStartParams = {
     onFastStart?: FastStartHandler;
     conversationId?: string;
 };
+export type ConversationOnJoinParams = {
+    conversationId?: string;
+    mediaOptions: MediaOption[];
+    chatId?: string;
+    joinLink?: string;
+    observedIds?: ExternalUserId[];
+    payload?: string;
+    onFastJoin?: FastJoinHandler;
+    anonymous?: boolean;
+};
 export type StartConversationParams = {
     opponentIds?: OkUserId[];
     opponentType: CallType;
@@ -94,7 +105,6 @@ export type StartConversationParams = {
     requireAuthToJoin?: boolean;
     onlyAdminCanShareMovie?: boolean;
     externalIds?: ExternalId[];
-    startedTime: number;
     onFastStart?: FastStartHandler;
     conversationId?: string;
 };

package/types/Participant.d.ts

@@ -44,6 +44,16 @@ export interface ParticipantStateMapped {
         ts: number;
     };
 }
+export interface ParticipantSessionState {
+    connected: boolean;
+}
+export interface ParticipantConnectionStatus {
+    transport: ParticipantStatus;
+    sessionState?: ParticipantSessionState;
+    sessionStateApplicable: boolean;
+    sessionStateConnectedBySpeaker: boolean;
+    lastEffective: ParticipantStatus;
+}
 /**
  * Состояния участников звонка
  */
@@ -63,7 +73,6 @@ export interface Participant {
     externalId: ExternalParticipantId;
     mediaSettings: MediaSettings;
     state: ParticipantState;
-    status: ParticipantStatus;
     remoteStream?: MediaStream | null;
     remoteAudioTrack?: MediaStreamTrack | null;
     secondStream?: MediaStream | null;
@@ -73,6 +82,7 @@ export interface Participant {
     roles: UserRole[];
     participantState: ParticipantStateMapped;
     isOnHold?: boolean;
+    connectionStatus: ParticipantConnectionStatus;
     networkRating: number;
     lastRequestedLayouts: {
         [key: StreamDescriptionString]: ParticipantLayout;

package/types/PushData.d.ts

@@ -1,8 +1,11 @@
+import IceServer from './IceServer';
 type PushData = {
     caller_id: string;
     caller_client_type?: string;
     conversation_id: string;
     endpoint: string;
+    wt_endpoint?: string;
+    turn_server?: IceServer;
     is_video: boolean;
     token: string;
     sdp_offer?: string;

package/types/SignalingMessage.d.ts

@@ -19,7 +19,7 @@ import MediaModifiers from './MediaModifiers';
 import MediaSettings from './MediaSettings';
 import { ISharedMovieInfo, ISharedMovieState, ISharedMovieStoppedInfo } from './MovieShare';
 import MuteStates from './MuteStates';
-import { CompositeUserId, OkUserId, ParticipantId, ParticipantListMarker as ParticipantParticipantListMarker, ParticipantListMarkers, ParticipantListType as ParticipantParticipantListType } from './Participant';
+import { CompositeUserId, OkUserId, ParticipantId, ParticipantListMarker as ParticipantParticipantListMarker, ParticipantListMarkers, ParticipantListType as ParticipantParticipantListType, ParticipantSessionState } from './Participant';
 import { MediaType, ParticipantStreamDescription } from './ParticipantStreamDescription';
 import { IRoomId } from './Room';
 import VideoSettings from './VideoSettings';
@@ -89,6 +89,7 @@ declare namespace SignalingMessage {
             state: Record<string, string>;
             stateUpdateTs: Record<string, number>;
         };
+        sessionState?: ParticipantSessionState;
         roles?: UserRole[];
         peerId?: PeerId;
         restricted?: boolean;
@@ -324,6 +325,13 @@ declare namespace SignalingMessage {
     export interface SpeakerChanged extends Notification {
         speaker: ParticipantId;
     }
+    export interface SessionState extends Notification {
+        connected: boolean;
+        participantId: OkUserId;
+        participantType: UserType;
+        deviceIdx?: number;
+        markers?: ParticipantListMarkers;
+    }
     export interface OptionsChanged extends Notification {
         options: ConversationOption[];
     }