@vkontakte/calls-sdk 2.8.12-dev.c0dd153e.0 → 2.8.12-dev.c58bce06.0

package/classes/AudioFix.d.ts

@@ -1,5 +1,5 @@
 import { type DebugLogger } from '../static/Debug';
-import StatsLogger from './StatsLogger';
+import StatEventCollector from './stat/StatEventCollector';
 import { MediaSource } from './MediaSource';
 export default class AudioFix {
     private _fixNoPacketsApplied;
@@ -15,7 +15,7 @@ export default class AudioFix {
     private _lastPacketsSentTime;
     private _toggleAudioPromise;
     private _fixNoPacketsAppliedVideo;
-    constructor(mediaSource: MediaSource, debug?: DebugLogger, logger?: StatsLogger | null);
+    constructor(mediaSource: MediaSource, debug?: DebugLogger, logger?: StatEventCollector | null);
     private _fixAudioDeviceNoPackets;
     private _fixAudioDeviceTooManyPackets;
     fix(rtps: any[]): void;

package/classes/AudioOutput.d.ts

@@ -1,20 +1,21 @@
 import { type DebugLogger } from '../static/Debug';
 import { ParticipantId } from '../types/Participant';
-import StatsLogger from './StatsLogger';
+import StatEventCollector from './stat/StatEventCollector';
 import { StatFirstMediaReceived } from './stat/StatFirstMediaReceived';
 /**
  * Единый AudioOutput поддерживающий p2p, audioMix и transparent-audio
  */
 export default class AudioOutput {
     protected _audioElement: HTMLAudioElement | null;
+    protected readonly _debug: DebugLogger;
+    private readonly _preparedAudioElement;
     private _audioTracks;
     private readonly _allowMultipleTracks;
     private _volume;
     private readonly _features;
     private readonly _statFirstMediaReceived;
-    protected readonly _debug: DebugLogger;
     private readonly _logger;
-    constructor(statFirstMediaReceived: StatFirstMediaReceived, allowMultipleTracks?: boolean, debug?: DebugLogger, logger?: StatsLogger | null);
+    constructor(statFirstMediaReceived: StatFirstMediaReceived, allowMultipleTracks?: boolean, debug?: DebugLogger, logger?: StatEventCollector | null);
     add(participantId: ParticipantId, track: MediaStreamTrack): void;
     remove(participantId: ParticipantId, track: MediaStreamTrack): void;
     get volume(): number;
@@ -25,6 +26,8 @@ export default class AudioOutput {
     protected _getTracks(): MediaStreamTrack[];
     protected _initAudioElement(): void;
     protected _stopAudioElement(): void;
+    private _createAudioElement;
+    private _prepareAudioElement;
     private _addTrackToAudioElement;
     private _removeTrackFromAudioElement;
     private _clearTracks;

package/classes/CallRegistry.d.ts

@@ -1,4 +1,4 @@
-import Conversation from './Conversation';
+import type Conversation from './conversation';
 import MediaSettings from '../types/MediaSettings';
 export interface HoldableConversation extends Conversation {
     id: string;
@@ -6,8 +6,11 @@ export interface HoldableConversation extends Conversation {
 }
 export declare class CallRegistry {
     private _conversations;
+    private _reserved;
     private _activeId;
     private _mutex;
+    private _pendingRemovals;
+    reserve(id: string): void;
     add(conversation: HoldableConversation): void;
     remove(id: string | null): void;
     get(id: string): HoldableConversation | undefined;
@@ -21,6 +24,7 @@ export declare class CallRegistry {
     setHold(id: string): Promise<void>;
     switchCall(id: string): Promise<void>;
     clear(): void;
+    private _flushPendingRemovals;
 }
 declare const callRegistry: CallRegistry;
 export { callRegistry };

package/classes/ExternalIdCache.d.ts

@@ -1,6 +1,7 @@
 import { ExternalId, ExternalParticipantId } from '../types/ExternalId';
 import { CompositeUserId, OkUserId, ParticipantId } from '../types/Participant';
 export declare class ExternalIdCache {
+    private static _normalizeType;
     private _okIdToExternalId;
     private _externalIdToOkId;
     private _decorativeIdToInitialId;

package/classes/MediaSource.d.ts

@@ -4,7 +4,7 @@ import MediaOption from '../enums/MediaOption';
 import { type DebugLogger } from '../static/Debug';
 import MediaSettings, { IVideoDimentions } from '../types/MediaSettings';
 import { ScreenCaptureSettings } from '../types/ScreenCaptureSettings';
-import StatsLogger from './StatsLogger';
+import StatEventCollector from './stat/StatEventCollector';
 export declare const enum MediaSourceEvent {
     SOURCE_CHANGED = "SOURCE_CHANGED",
     SOURCE_READY = "SOURCE_READY",
@@ -58,7 +58,9 @@ export declare class MediaSource extends EventEmitter {
     private readonly _videoEffectsFpsLimiter?;
     private readonly _debug;
     private readonly _logger;
-    constructor(debug?: DebugLogger, logger?: StatsLogger | null);
+    private _cameraTrackSetAt;
+    private _cameraMuteRecoveredAt;
+    constructor(debug?: DebugLogger, logger?: StatEventCollector | null);
     get cameraVideoTrack(): MediaStreamTrack | null;
     set cameraVideoTrack(track: MediaStreamTrack | null);
     request(mediaOptions?: MediaOption[], needEmptyTracks?: boolean): Promise<void>;
@@ -97,6 +99,8 @@ export declare class MediaSource extends EventEmitter {
     protected getSilentAudioShareTrack(): MediaStreamTrack;
     protected getBlackScreenShareTrack(): MediaStreamTrack;
     protected _replaceLocalTrack(newTrack: MediaStreamTrack, sendTrack?: MediaStreamTrack): Promise<void>;
+    protected _replaceTrack(oldTrack: MediaStreamTrack, newTrack: MediaStreamTrack, sendTrack?: MediaStreamTrack): Promise<void>;
+    protected _addLocalTrack(newTrack: MediaStreamTrack, sendTrack?: MediaStreamTrack): Promise<void>;
     private _setEffect;
     private _stopEffect;
     destroy(): void;

package/classes/SpecListener.d.ts

@@ -2,7 +2,7 @@ import { type DebugLogger } from '../static/Debug';
 import MediaSettings from '../types/MediaSettings';
 import { Participant, ParticipantId } from '../types/Participant';
 import EventEmitter from './EventEmitter';
-import StatsLogger from './StatsLogger';
+import StatEventCollector from './stat/StatEventCollector';
 import { Transport } from './transport/Transport';
 import { VolumesDetector } from './VolumesDetector';
 export default class SpecListener extends EventEmitter {
@@ -14,7 +14,7 @@ export default class SpecListener extends EventEmitter {
     private _connectionTimeout;
     private _connectionTimeoutSuppressed;
     private _volumeTimeout;
-    constructor(transport: Transport, volumesDetector: VolumesDetector, participants: Record<ParticipantId, Participant>, debug?: DebugLogger, logger?: StatsLogger | null);
+    constructor(transport: Transport, volumesDetector: VolumesDetector, participants: Record<ParticipantId, Participant>, debug?: DebugLogger, logger?: StatEventCollector | null);
     destroy(): void;
     onChangeRemoteMediaSettings(participantId: ParticipantId, mediaSettings: MediaSettings): void;
     onParticipantHoldChanged(): void;

package/classes/codec/LibVPxDecoder.d.ts

@@ -1,9 +1,9 @@
 import { type DebugLogger } from '../../static/Debug';
-import StatsLogger from '../StatsLogger';
+import StatEventCollector from '../stat/StatEventCollector';
 import IDecoder from './IDecoder';
 import WorkerBase from './WorkerBase';
 export default class LibVPxDecoder extends WorkerBase implements IDecoder {
-    constructor(debug?: DebugLogger, logger?: StatsLogger | null);
+    constructor(debug?: DebugLogger, logger?: StatEventCollector | null);
     init(onFrameImage: (image: ImageData) => void, onFrameError: (error: unknown) => void, onKeyFrameRequested: () => void): Promise<void>;
     decodeFrame(timestamp: number, data: Uint8Array, isVP9: boolean, keyFrame?: boolean): void;
     destroy(): void;

package/classes/codec/LibVPxEncoder.d.ts

@@ -1,5 +1,5 @@
 import { type DebugLogger } from '../../static/Debug';
-import StatsLogger from '../StatsLogger';
+import StatEventCollector from '../stat/StatEventCollector';
 import IEncoder from './IEncoder';
 import { OnFrameCallback } from './Types';
 import WorkerBase from './WorkerBase';
@@ -15,7 +15,7 @@ export default class LibVPxEncoder extends WorkerBase implements IEncoder {
     private _canvasCtx;
     private _frameReadTimeout;
     private _lastFrame;
-    constructor(sourceTrack: MediaStreamTrack, onFrame: OnFrameCallback, useCongestionControl: boolean, maxBitrate: number, debug?: DebugLogger, logger?: StatsLogger | null);
+    constructor(sourceTrack: MediaStreamTrack, onFrame: OnFrameCallback, useCongestionControl: boolean, maxBitrate: number, debug?: DebugLogger, logger?: StatEventCollector | null);
     private _createDom;
     private _removeDom;
     private _createStream;

package/classes/codec/WebCodecsDecoder.d.ts

@@ -1,9 +1,9 @@
 import { type DebugLogger } from '../../static/Debug';
-import StatsLogger from '../StatsLogger';
+import StatEventCollector from '../stat/StatEventCollector';
 import IDecoder from './IDecoder';
 import WorkerBase from './WorkerBase';
 export default class WebCodecsDecoder extends WorkerBase implements IDecoder {
-    constructor(debug?: DebugLogger, logger?: StatsLogger | null);
+    constructor(debug?: DebugLogger, logger?: StatEventCollector | null);
     init(onFrameImage: (frame: VideoFrame) => void, onFrameError: (error: unknown) => void, onKeyFrameRequested: () => void): Promise<void>;
     decodeFrame(timestamp: number, data: Uint8Array, isVP9: boolean, keyFrame?: boolean): void;
     destroy(): void;

package/classes/codec/WebCodecsEncoder.d.ts

@@ -1,5 +1,5 @@
 import { type DebugLogger } from '../../static/Debug';
-import StatsLogger from '../StatsLogger';
+import StatEventCollector from '../stat/StatEventCollector';
 import IEncoder from './IEncoder';
 import { OnFrameCallback } from './Types';
 import WorkerBase from './WorkerBase';
@@ -11,7 +11,7 @@ export default class WebCodecsEncoder extends WorkerBase implements IEncoder {
     private readonly _maxBitrate;
     private readonly _useCbr;
     private readonly _frameRate;
-    constructor(sourceTrack: MediaStreamTrack, onFrame: OnFrameCallback, useCongestionControl: boolean, maxBitrate: number, useCbr: boolean, frameRate: number, debug?: DebugLogger, logger?: StatsLogger | null);
+    constructor(sourceTrack: MediaStreamTrack, onFrame: OnFrameCallback, useCongestionControl: boolean, maxBitrate: number, useCbr: boolean, frameRate: number, debug?: DebugLogger, logger?: StatEventCollector | null);
     init(): Promise<void>;
     requestFrame(keyFrame?: boolean): void;
     setBitrate(bitrate: number, useCbr: boolean, fps: number): void;

package/classes/codec/WorkerBase.d.ts

@@ -1,10 +1,10 @@
 import { type DebugLogger } from '../../static/Debug';
-import StatsLogger from '../StatsLogger';
+import StatEventCollector from '../stat/StatEventCollector';
 export default abstract class WorkerBase {
     protected _worker: Worker | null;
     protected readonly _debug: DebugLogger;
-    protected readonly _logger: StatsLogger | null;
-    protected constructor(debug?: DebugLogger, logger?: StatsLogger | null);
+    protected readonly _logger: StatEventCollector | null;
+    protected constructor(debug?: DebugLogger, logger?: StatEventCollector | null);
     protected _createWorker(workerFunctionData: string, onFrame: (data: any) => void, workerArgs?: any[], initArgs?: {
         [key: string]: any;
     }, transfer?: any[]): Promise<void>;

package/classes/{Conversation.d.ts → conversation/Conversation.d.ts}

@@ -1,33 +1,34 @@
 import type { IEffect } from '@vkontakte/calls-video-effects';
 import type { RGBTuple } from '@vkontakte/calls-vmoji';
-import BaseApi from '../abstract/BaseApi';
-import BaseLogger from '../abstract/BaseLogger';
-import { AddParticipantParams } from '../abstract/BaseSignaling';
-import ConversationFeature from '../enums/ConversationFeature';
-import ConversationOption from '../enums/ConversationOption';
-import MediaOption from '../enums/MediaOption';
-import UpdateDisplayLayoutErrorReason from '../enums/UpdateDisplayLayoutErrorReason';
-import UserRole from '../enums/UserRole';
-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 MediaModifiers from '../types/MediaModifiers';
-import MediaSettings, { IVideoDimentions } from '../types/MediaSettings';
-import { IAddMovieParams, IUpdateMovieData } from '../types/MovieShare';
-import MuteStates from '../types/MuteStates';
-import { CompositeUserId, IGetParticipantsParameters, ParticipantId, ParticipantStateData } from '../types/Participant';
-import { DisplayLayoutRequest, ParticipantLayout } from '../types/ParticipantLayout';
-import { ParticipantListChunkParameters } from '../types/ParticipantListChunk';
-import ParticipantPriority from '../types/ParticipantPriority';
-import { ParticipantStreamDescription } from '../types/ParticipantStreamDescription';
-import { ScreenCaptureSettings } from '../types/ScreenCaptureSettings';
-import SignalingMessage from '../types/SignalingMessage';
-import { WaitingHallResponse } from '../types/WaitingHall';
-import EventEmitter from './EventEmitter';
+import BaseApi from '../../abstract/BaseApi';
+import BaseLogger from '../../abstract/BaseLogger';
+import { AddParticipantParams } from '../../abstract/BaseSignaling';
+import ConversationFeature from '../../enums/ConversationFeature';
+import ConversationOption from '../../enums/ConversationOption';
+import MediaOption from '../../enums/MediaOption';
+import UpdateDisplayLayoutErrorReason from '../../enums/UpdateDisplayLayoutErrorReason';
+import UserRole from '../../enums/UserRole';
+import UserType from '../../enums/UserType';
+import { DebugMessageType } from '../../static/Debug';
+import { JSONObject } from '../../static/Json';
+import { IAsrStartParams, IAsrStopParams } from '../../types/Asr';
+import { AudienceModeHandsResponse } from '../../types/AudienceMode';
+import { ConversationData, ConversationOnJoinParams, ConversationOnStartParams } from '../../types/Conversation';
+import { ExternalId, ExternalParticipant, ExternalParticipantId, ExternalParticipantListChunk } from '../../types/ExternalId';
+import type { FastHangupHandler, HangupParams } from '../../types/FastHangup';
+import MediaModifiers from '../../types/MediaModifiers';
+import MediaSettings, { IVideoDimentions } from '../../types/MediaSettings';
+import { IAddMovieParams, IUpdateMovieData } from '../../types/MovieShare';
+import MuteStates from '../../types/MuteStates';
+import { CompositeUserId, IGetParticipantsParameters, OkUserId, ParticipantId, ParticipantStateData } from '../../types/Participant';
+import { DisplayLayoutRequest, ParticipantLayout } from '../../types/ParticipantLayout';
+import { ParticipantListChunkParameters } from '../../types/ParticipantListChunk';
+import ParticipantPriority from '../../types/ParticipantPriority';
+import { ParticipantStreamDescription } from '../../types/ParticipantStreamDescription';
+import { ScreenCaptureSettings } from '../../types/ScreenCaptureSettings';
+import SignalingMessage from '../../types/SignalingMessage';
+import { WaitingHallResponse } from '../../types/WaitingHall';
+import EventEmitter from '../EventEmitter';
 export default class Conversation extends EventEmitter {
     private readonly _api;
     private readonly _signaling;
@@ -42,7 +43,6 @@ export default class Conversation extends EventEmitter {
     private _waitingHallHoldPending;
     private _participantState;
     private _participants;
-    private _pendingParticipants;
     private _directTransportIsMaster?;
     private _transport;
     private _debugInfo;
@@ -57,10 +57,15 @@ export default class Conversation extends EventEmitter {
     private _serverSettings;
     private _serverTimeOffset;
     private _delayedHangup;
+    private _onFastHangup?;
+    private _hangupEmitted;
+    private _hangupPromise;
     private _abortController;
     private _registeredPeerReceived;
     private _calleeUnavailableTimer;
+    private _reservedId;
     private readonly _onUnload;
+    private readonly _onRestore;
     private readonly _audioOutput;
     private readonly _stats;
     private _lastStalled;
@@ -75,29 +80,25 @@ export default class Conversation extends EventEmitter {
     private readonly _statFirstMediaReceived;
     constructor(api: BaseApi, externalLogger: BaseLogger | null);
     static current(): Conversation | null;
-    static hangupAfterInit(): void;
+    static hangupAfterInit(onFastHangup?: FastHangupHandler): void;
     static id(): string | null;
     get id(): string;
     get externalId(): ExternalParticipantId | undefined;
     get mediaSettings(): MediaSettings | undefined;
     get isCallHeld(): boolean;
     static debugSessionId(): string | null;
+    static debugMessage(type: DebugMessageType, ...args: any[]): boolean;
+    static debugMessageWithContext(type: DebugMessageType, conversationId: string, ...args: any[]): boolean;
     static getSyncedTime(): number;
     get debugSessionId(): string | null;
+    getCachedRawOkIdByExternalId(externalId: ExternalId): OkUserId | null;
+    private _buildInternalParams;
     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;
-    onPush(conversationId: string, type?: UserType, peerId?: number, conversationParams?: string, wsEndpoint?: string): Promise<void>;
+    onPush(conversationId: string, type?: UserType, peerId?: number, conversationParams?: string, wsEndpoint?: string, userId?: number): Promise<void>;
     private _isInWaitingHall;
     private _isWaitForAdmin;
     private _isRestricted;
@@ -106,10 +107,9 @@ 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>;
+    decline(params?: HangupParams): Promise<void>;
+    hangup(params?: HangupParams): Promise<void>;
     addParticipant(participantIds: ExternalId[], params?: AddParticipantParams): Promise<void>;
     addParticipantLegacy(participantIds: CompositeUserId[], params?: AddParticipantParams): Promise<void>;
     removeParticipant(participantId: CompositeUserId, ban?: boolean): Promise<void>;
@@ -117,8 +117,14 @@ export default class Conversation extends EventEmitter {
     updateStatisticsInterval(): void;
     private _openTransport;
     private _allocateParticipantTransport;
+    private _closeParticipantTransport;
+    private _cleanupRegistry;
+    private _emitHangupOnce;
+    private _sendHangupApi;
     private _close;
-    destroy(): Promise<void>;
+    private _sendHangup;
+    destroy(): void;
+    private _destroy;
     private _getConversationParams;
     private _setConversationParams;
     private _buildSignalingEndpoint;
@@ -160,6 +166,7 @@ export default class Conversation extends EventEmitter {
     private _getExistedParticipantByIdOrCreate;
     private _getExternalIdByParticipantId;
     private _getExternalIdsByOkIdsFromCache;
+    private _getOrCacheExternalIdByCompositeId;
     private _registerParticipantAndSetMarkersIfChunkEnabled;
     private _warnParticipantNotInConversation;
     private _denormalizeMarkers;
@@ -196,10 +203,13 @@ 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;
+    private _disposeSignaling;
     private _onAddParticipant;
     private _onRemoveParticipant;
     changeDevice(kind: MediaDeviceKind): Promise<void>;
@@ -217,6 +227,8 @@ export default class Conversation extends EventEmitter {
     setAnimojiFill(fill: RGBTuple | string): void;
     setVideoStream(stream: MediaStream, isScreen?: boolean): Promise<void>;
     setAudioStream(stream: MediaStream): Promise<void>;
+    private readonly _toggleLocalVideo;
+    private readonly _toggleLocalAudio;
     toggleLocalVideo(enabled: boolean): Promise<void>;
     toggleLocalAudio(enabled: boolean): Promise<void>;
     /**
@@ -232,7 +244,7 @@ export default class Conversation extends EventEmitter {
     private _getWaitingForPromotionStatus;
     putHandsDown(): Promise<void>;
     requestKeyFrame(participantStreamDescription: ParticipantStreamDescription): Promise<void | SignalingMessage>;
-    requestTestMode(consumerCommand: string, producerCommand: string): Promise<void>;
+    requestTestMode(consumerCommand: string, producerCommand: string): Promise<void | SignalingMessage>;
     updateDisplayLayout(layouts: ParticipantLayout[]): Promise<void>;
     requestDisplayLayout(requests: DisplayLayoutRequest[]): Promise<void>;
     feedback(key: string): Promise<SignalingMessage>;
@@ -361,7 +373,7 @@ export default class Conversation extends EventEmitter {
     private _onRecordInfo;
     private _onStopRecordInfo;
     private _changePinnedParticipantForRoom;
-    _changeRecordInfoForRoom(): Promise<void>;
+    _changeRecordInfoForRoom(): void;
     private _changeAsrInfoForRoom;
     private _changeUrlSharingInfoForRoom;
     private _onParticipantAnimojiChanged;
@@ -413,6 +425,8 @@ export default class Conversation extends EventEmitter {
     private _toggleJoinAvailability;
     private _updateDisplayLayoutFromCache;
     private _setParticipantsStatus;
+    private _setParticipantsStalled;
+    private _updateParticipantsStatus;
     private _onJoinLinkChanged;
     private _onRoomsUpdated;
     private _onRoomUpdated;
@@ -436,7 +450,6 @@ export default class Conversation extends EventEmitter {
     private _setMuteStatesForRoomId;
     private _forceOpenTransportForAloneInCall;
     private _registerParticipant;
-    private _getParticipants;
     private _getParticipant;
 }
 declare function _resetPendingInstance(): void;

package/classes/conversation/Conversation.testUtils.d.ts

@@ -0,0 +1,148 @@
+import { FetchMock } from 'vitest-fetch-mock';
+import { Mock } from 'vitest';
+import { Client, Server } from 'mock-socket';
+import { ISharedMovieInfo, OkUserId } from '../../CallsSDK';
+import Api from '../../default/Api';
+import CallDirection from '../../enums/CallDirection';
+import ConversationOption from '../../enums/ConversationOption';
+import TransportState from '../../enums/TransportState';
+import TransportTopology from '../../enums/TransportTopology';
+import { ParticipantStatus } from '../../static/External';
+import { ExternalParticipantId } from '../../types/ExternalId';
+import { ParticipantListMarkers } from '../../types/Participant';
+import SignalingMessage from '../../types/SignalingMessage';
+import Conversation from './Conversation';
+declare function createParams(): {
+    apiKey: string;
+    apiEnv: string;
+    onLocalStream: Mock<import("@vitest/spy").Procedure>;
+    onLocalStatus: Mock<import("@vitest/spy").Procedure>;
+    onConversation: Mock<import("@vitest/spy").Procedure>;
+    onLocalSharedMovieInfo: Mock<import("@vitest/spy").Procedure>;
+    onRemoteSharedMovieInfo: Mock<import("@vitest/spy").Procedure>;
+    onRemoteSharedUrl: Mock<import("@vitest/spy").Procedure>;
+    onCallState: Mock<import("@vitest/spy").Procedure>;
+    onOptionsChanged: Mock<import("@vitest/spy").Procedure>;
+    onPinnedParticipant: Mock<import("@vitest/spy").Procedure>;
+    onRemoteMediaSettings: Mock<import("@vitest/spy").Procedure>;
+    onRemoteParticipantState: Mock<import("@vitest/spy").Procedure>;
+    onLocalPin: Mock<import("@vitest/spy").Procedure>;
+    onDebugMessage: Mock<import("@vitest/spy").Procedure>;
+    onHangup: Mock<import("@vitest/spy").Procedure>;
+    onRemoteRemoved: Mock<import("@vitest/spy").Procedure>;
+    onConversationParticipantListChunk: Mock<import("@vitest/spy").Procedure>;
+    onRoomParticipantsUpdated: Mock<import("@vitest/spy").Procedure>;
+    onChatRoomUpdated: Mock<import("@vitest/spy").Procedure>;
+    onRemoteStatus: Mock<import("@vitest/spy").Procedure>;
+    onSpeakerChanged: Mock<import("@vitest/spy").Procedure>;
+};
+export type ConversationTestParams = ReturnType<typeof createParams>;
+export type ConversationTestTools = {
+    readonly endpointURL: string;
+    readonly fetchMocker: FetchMock;
+    readonly params: ConversationTestParams;
+    readonly server: Server;
+    readonly wsBaseURL: string;
+    createConnectionMessage(data?: Partial<SignalingMessage.Connection>): SignalingMessage.Connection;
+    createConversation(options?: {
+        api?: Api;
+    }): Conversation;
+    createExternalIdMock(id: string, data?: Partial<ExternalParticipantId>): ExternalParticipantId;
+    createMarkers(data?: Partial<ParticipantListMarkers>): ParticipantListMarkers;
+    createMovieShareInfo(initiatorId: string, data?: Partial<ISharedMovieInfo> | null): ISharedMovieInfo;
+    createParticipant(id: number, data?: Partial<SignalingMessage.Participant>): SignalingMessage.Participant & Required<Pick<SignalingMessage.Participant, 'markers'>>;
+    createParticipantWithMarkers(id: number, data?: Partial<SignalingMessage.Participant>): SignalingMessage.Participant & Required<Pick<SignalingMessage.Participant, 'markers'>>;
+    createPromoteParticipantMessage(): SignalingMessage.PromoteParticipant;
+    createSignallingConversation(okUserId: OkUserId, peerId: SignalingMessage.PeerId, data?: Partial<SignalingMessage.Conversation>): SignalingMessage.Conversation;
+    createWaitingHallConversationData(): ReturnType<typeof createWaitingHallConversationData>;
+    emitMessageOnConnection(wsServer: Server, message?: SignalingMessage.Connection): void;
+    enableParticipantListChunk(): void;
+    expectRemoteStatus(status: ParticipantStatus, participantId?: string): Promise<void>;
+    expectRemoteStatusCall(status: ParticipantStatus, participantId?: string): void;
+    forgetConversation(conversation: Conversation): void;
+    getActiveSocket(wsServer: Server): Client;
+    hasRemoteStatusCall(status: ParticipantStatus, participantId?: string): boolean;
+    isCapabilityEnabled(predicateIndex: number, wsServer: Server): boolean;
+    parseUrlSearch(search: string): Record<string, string>;
+    resetRemoteStatusCallbacks(): void;
+    respondOnGetParticipantListChunkWith(data: Partial<SignalingMessage.ParticipantListChunk>): void;
+    sendAcceptedCall(participant: SignalingMessage.Participant): void;
+    sendHungup(participant: SignalingMessage.Participant): void;
+    sendSessionState(participant: SignalingMessage.Participant | number, connected: boolean, data?: Partial<SignalingMessage.SessionState>): void;
+    setApiAuth(data?: {
+        sessionKey?: string;
+        sessionSecretKey?: string;
+    }): void;
+    setTransportState(conversation: Conversation, state: TransportState): void;
+    socketRespondWith(socket: Client, command: string, response: SignalingMessage): void;
+    socketSendNotification(socket: Client, notification: string, response?: SignalingMessage): void;
+    startConversation(message?: SignalingMessage.Connection): Promise<Conversation>;
+    startConversationWithParticipants(participants: SignalingMessage.Participant[], peerId?: SignalingMessage.PeerId): Promise<Conversation>;
+    startConversationWithRemoteParticipant(remoteParticipantData?: Partial<SignalingMessage.Participant>): Promise<{
+        conversation: Conversation;
+        meParticipant: SignalingMessage.Participant;
+        remoteParticipant: SignalingMessage.Participant;
+    }>;
+    stubApiRequest(endpoint: string, method: string, data: object): void;
+    waitFor(fn: () => Promise<boolean> | boolean, message?: string, timeout?: number): Promise<true>;
+    flushSdkCallbacks(): Promise<null>;
+};
+export declare function defineConversationTests(name: string, defineTests: (tools: ConversationTestTools) => void): void;
+export declare function createExternalIdMock(id: string, data?: Partial<ExternalParticipantId>): ExternalParticipantId;
+export declare function enableParticipantListChunk(): void;
+export declare function setApiAuth(data?: {
+    sessionKey?: string;
+    sessionSecretKey?: string;
+}): void;
+export declare function setTransportState(conversation: Conversation, state: TransportState): void;
+export declare function socketRespondWith(socket: Client, command: string, response: SignalingMessage): void;
+export declare function socketSendNotification(socket: Client, notification: string, response?: SignalingMessage): void;
+export declare function createWaitingHallConversationData(): {
+    acceptTime: null;
+    asrInfo: null;
+    asrInfoByRoom: Map<any, any>;
+    audienceMode: boolean;
+    chatId: null;
+    compositeUserId: string;
+    concurrent: boolean;
+    direction: CallDirection;
+    externalId: ExternalParticipantId;
+    features: never[];
+    featuresPerRole: null;
+    id: string;
+    mediaModifiers: {
+        denoise: boolean;
+        denoiseAnn: boolean;
+    };
+    muteStates: Map<any, any>;
+    muteStatesPersonal: {};
+    needRate: boolean;
+    networkRating: number;
+    observer: boolean;
+    options: ConversationOption[];
+    participantsLimit: number;
+    pinnedParticipantIdByRoom: Map<any, any>;
+    recordsInfoByRoom: Map<any, any>;
+    restricted: boolean;
+    roles: never[];
+    roomId: number | null;
+    topology: TransportTopology;
+    urlSharingInfoByRoom: Map<any, any>;
+    userId: number;
+    waitForAdmin: boolean;
+    waitingHall: boolean;
+};
+export declare function createPromoteParticipantMessage(): SignalingMessage.PromoteParticipant;
+export declare function emitMessageOnConnection(wsServer: Server, message?: SignalingMessage.Connection): void;
+export declare function getActiveSocket(wsServer: Server): Client;
+export declare function isCapabilityEnabled(predicateIndex: number, wsServer: Server): boolean;
+export declare function parseUrlSearch(search: string): Record<string, string>;
+export declare function flushSdkCallbacks(): Promise<null>;
+export declare function waitFor(fn: () => Promise<boolean> | boolean, message?: string, timeout?: number): Promise<true>;
+export declare function createSignallingConversation(okUserId: OkUserId, peerId: SignalingMessage.PeerId, data?: Partial<SignalingMessage.Conversation>): SignalingMessage.Conversation;
+export declare function createConnectionMessage(data?: Partial<SignalingMessage.Connection>): SignalingMessage.Connection;
+export declare function createParticipant(id: number, data?: Partial<SignalingMessage.Participant>): SignalingMessage.Participant & Required<Pick<SignalingMessage.Participant, 'markers'>>;
+export declare function createParticipantWithMarkers(id: number, data?: Partial<SignalingMessage.Participant>): SignalingMessage.Participant & Required<Pick<SignalingMessage.Participant, 'markers'>>;
+export declare function createMarkers(data?: Partial<ParticipantListMarkers>): ParticipantListMarkers;
+export declare function createMovieShareInfo(initiatorId: string, data?: Partial<ISharedMovieInfo> | null): ISharedMovieInfo;
+export {};

package/classes/{ConversationResponseValidator.d.ts → conversation/ConversationResponseValidator.d.ts}

@@ -1,3 +1,3 @@
-import ConversationResponse from '../types/ConversationResponse';
+import ConversationResponse from '../../types/ConversationResponse';
 export type ConversationResponseSource = 'startConversation' | 'joinConversation' | 'joinConversationByLink' | 'fastStart' | 'fastJoin';
 export declare function assertValidConversationResponse(response: ConversationResponse | null | undefined, source: ConversationResponseSource): void;

package/classes/{DisplayLayoutRequester.d.ts → conversation/DisplayLayoutRequester.d.ts}

@@ -1,11 +1,11 @@
-import BaseApi from '../abstract/BaseApi';
-import type { DebugLogger } from '../static/Debug';
-import { DisplayLayoutRequest, ParticipantLayout } from '../types/ParticipantLayout';
-import { Participant, ParticipantId } from '../types/Participant';
+import BaseApi from '../../abstract/BaseApi';
+import type { DebugLogger } from '../../static/Debug';
+import { DisplayLayoutRequest, ParticipantLayout } from '../../types/ParticipantLayout';
+import { Participant, ParticipantId } from '../../types/Participant';
 type DisplayLayoutRequesterParams = {
     api: BaseApi;
     debug: DebugLogger;
-    getParticipants: () => Promise<Record<ParticipantId, Participant>>;
+    getParticipants: () => Record<ParticipantId, Participant>;
     isMe: (participantId: ParticipantId) => boolean;
     updateDisplayLayout: (layouts: ParticipantLayout[]) => Promise<void>;
 };

package/classes/conversation/index.d.ts

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

package/classes/screenshare/ScreenCaptureReceiver.d.ts

@@ -1,6 +1,6 @@
 import { type DebugLogger } from '../../static/Debug';
 import { ParticipantId } from '../../types/Participant';
-import StatsLogger from '../StatsLogger';
+import StatEventCollector from '../stat/StatEventCollector';
 import { ParticipantIdRegistry } from '../ParticipantIdRegistry';
 import { StatAggregator } from '../stat/StatAggregator';
 import { IOnStat } from './BaseStreamBuilder';
@@ -14,7 +14,7 @@ export default class ScreenCaptureReceiver {
     private readonly _debug;
     private readonly _logger;
     private readonly _statAggregator;
-    constructor(datachannel: RTCDataChannel, participantIdRegistry: ParticipantIdRegistry, onStream: (streamId: string, stream: MediaStream) => void, onEos: (streamId: string) => void, onStat: IOnStat, statAggregator?: StatAggregator | null, debug?: DebugLogger, logger?: StatsLogger | null);
+    constructor(datachannel: RTCDataChannel, participantIdRegistry: ParticipantIdRegistry, onStream: (streamId: string, stream: MediaStream) => void, onEos: (streamId: string) => void, onStat: IOnStat, statAggregator?: StatAggregator | null, debug?: DebugLogger, logger?: StatEventCollector | null);
     private _onDataChannelMessage;
     /**
      * Отправить запрос ключевого кадра в datachannel.