@vkontakte/calls-sdk 2.8.2-dev.f5b551c.0 → 2.8.2

package/classes/AudioOutput.d.ts

@@ -1,14 +1,19 @@
+type ParticipantAudioOutput = {
+    audioElement?: HTMLAudioElement;
+    audioTrack?: MediaStreamTrack;
+};
 export default class AudioOutput {
-    private _output;
+    protected _output: ParticipantAudioOutput | null;
     private _volume;
     private readonly _features;
     add(track: MediaStreamTrack): void;
     remove(track: MediaStreamTrack): void;
     get volume(): number;
     set volume(volume: number);
-    private _initAudioElement;
-    private _stopAudioElement;
+    protected _initAudioElement(): void;
+    protected _stopAudioElement(): void;
     destroy(): void;
     /** изменяем устройство для воспроизведения аудио */
     changeOutput(): Promise<void>;
 }
+export {};

package/classes/Conversation.d.ts

@@ -6,12 +6,12 @@ import CallType from '../enums/CallType';
 import ConversationFeature from '../enums/ConversationFeature';
 import ConversationOption from '../enums/ConversationOption';
 import MediaOption from '../enums/MediaOption';
-import RecordRole from '../enums/RecordRole';
 import UpdateDisplayLayoutErrorReason from '../enums/UpdateDisplayLayoutErrorReason';
 import UserRole from '../enums/UserRole';
 import UserType from '../enums/UserType';
 import { JSONObject } from '../static/Json';
-import { IAsrStartParams } from '../types/Asr';
+import { IAsrStartParams, IAsrStopParams } from '../types/Asr';
+import { AudienceModeHandsResponse } from '../types/AudienceMode';
 import { ConversationData } from '../types/Conversation';
 import { ExternalParticipant, ExternalParticipantId, ExternalParticipantListChunk, ExternalUserId } from '../types/ExternalId';
 import MediaModifiers from '../types/MediaModifiers';
@@ -27,13 +27,6 @@ import { ScreenCaptureSettings } from '../types/ScreenCaptureSettings';
 import SignalingMessage from '../types/SignalingMessage';
 import { WaitingHallResponse } from '../types/WaitingHall';
 import EventEmitter from './EventEmitter';
-export type ParticipantUpdateInfo = {
-    participantStreamDescription: ParticipantStreamDescription | null;
-    streamId: string;
-    rtpTimestamp: number | null;
-    sequenceNumber: number;
-    fastScreenShare: boolean;
-};
 export default class Conversation extends EventEmitter {
     private readonly _api;
     private readonly _signaling;
@@ -83,6 +76,9 @@ export default class Conversation extends EventEmitter {
     private _onJoinPart2;
     onPush(conversationId: string, type?: UserType, peerId?: number): Promise<void>;
     private _isInWaitingHall;
+    private _isRestricted;
+    private _isAudienceMode;
+    private _isAudienceModeListener;
     private _acceptConcurrent;
     accept(mediaOptions: MediaOption[]): Promise<ConversationData>;
     decline(): Promise<void>;
@@ -129,7 +125,6 @@ export default class Conversation extends EventEmitter {
     private _getExternalIdByParticipantId;
     private _registerParticipantAndSetMarkersIfChunkEnabled;
     private _warnParticipantNotInConversation;
-    private _setParticipantMarkers;
     private _denormalizeMarkers;
     /**
      * Обрабатывает данные connection из сигналинга. Должен вызываться после `_registerParticipants`
@@ -181,7 +176,7 @@ export default class Conversation extends EventEmitter {
     private _onAddParticipant;
     private _onRemoveParticipant;
     changeDevice(kind: MediaDeviceKind): Promise<void>;
-    stopVideoTrack(): void;
+    stopVideoTrack(): void | undefined;
     toggleScreenCapturing(settings: ScreenCaptureSettings): Promise<void>;
     disableScreenCapturing(): Promise<void>;
     toggleAnimojiCapturing(state: boolean): void;
@@ -212,6 +207,7 @@ export default class Conversation extends EventEmitter {
     private _sendUpdateDisplayLayout;
     private _cleanupCooldownQueue;
     private _onParticipantSourcesUpdate;
+    private _onParticipantSourcesSuspend;
     private _onParticipantPromoted;
     private _onChatRoomUpdated;
     private _onSharedMovieUpdate;
@@ -219,18 +215,20 @@ export default class Conversation extends EventEmitter {
     private _processSharedMovieInfos;
     private _processSharedMovieInfo;
     private _processConnectionSharedMovieInfo;
+    private _processConnectionAsrInfo;
     private _onSharedMovieInfoStopped;
     private _onFeaturesPerRoleChanged;
     private _waitForStreamIfNeeded;
     private _matchStreamDescription;
+    private _handleParticipantSuspend;
     private _getWaitingTime;
     private _isCallAdmin;
     private _checkAdminRole;
-    grantRoles(participantId: CompositeUserId, roles: UserRole[], revoke: boolean): Promise<void>;
+    grantRoles(participantId: ParticipantId, roles: UserRole[], revoke: boolean): Promise<void>;
     startAsr(params: IAsrStartParams): Promise<void>;
-    stopAsr(): Promise<void>;
+    stopAsr(params?: IAsrStopParams): Promise<void>;
     requestAsr(request: boolean): Promise<void>;
-    muteParticipant(participantId: ParticipantId | null, muteStates: MuteStates, requestedMedia?: MediaOption[], roomId?: number | null): Promise<void>;
+    muteParticipant(participantId: string | null | undefined, muteStates: MuteStates, requestedMedia?: MediaOption[], roomId?: number | null): Promise<void>;
     enableFeatureForRoles(feature: ConversationFeature, roles: UserRole[]): Promise<void>;
     pinParticipant(participantId: ParticipantId, unpin: boolean, roomId?: number | null): Promise<void>;
     updateMediaModifiers(mediaModifiers: MediaModifiers): Promise<void>;
@@ -242,12 +240,16 @@ export default class Conversation extends EventEmitter {
      * @hidden
      */
     getWaitingHall(pageMarker: string | null, count?: number, backward?: boolean): Promise<WaitingHallResponse>;
+    private _resolveExternalIds;
+    getAudienceModeHands(): Promise<AudienceModeHandsResponse>;
     promoteParticipant(participantId: CompositeUserId, demote?: boolean): Promise<void>;
+    requestPromotion(demote?: boolean): Promise<void>;
+    acceptPromotion(reject?: boolean): Promise<void>;
     chatMessage(message: string, participantId?: CompositeUserId | null): Promise<void>;
     chatHistory(count: number): Promise<void>;
     customData(data: JSONObject, participantId?: ParticipantId | null): Promise<void>;
     createJoinLink(): Promise<string>;
-    removeJoinLink(): Promise<never>;
+    removeJoinLink(): Promise<undefined>;
     addMovie({ movieId, gain, metadata }: IAddMovieParams): Promise<{
         movieId: number;
         streamType: string;
@@ -258,9 +260,10 @@ export default class Conversation extends EventEmitter {
     activateRooms(roomIds: number[], deactivate: boolean): Promise<void>;
     switchRoom(toRoomId: number | null, participantId?: ParticipantId): Promise<void>;
     removeRooms(roomIds: number[]): Promise<void>;
-    startStream(isRecord?: boolean, name?: string | null, movieId?: string | null, privacy?: 'PUBLIC' | 'FRIENDS' | 'DIRECT_LINK', groupId?: string | null, roomId?: number | null): Promise<never>;
-    stopStream(roomId?: number | null): Promise<never>;
-    recordSetRole(participantId: ParticipantId, role: RecordRole | null, roomId?: number | null): Promise<void>;
+    startStream(isRecord?: boolean, name?: string | null, movieId?: string | null, privacy?: 'PUBLIC' | 'FRIENDS' | 'DIRECT_LINK', groupId?: string | null, roomId?: number | null): Promise<undefined>;
+    stopStream(roomId?: number | null): Promise<undefined>;
+    publishStream(roomId?: number | null): Promise<undefined>;
+    recordSetConf(king?: ParticipantId, pawns?: ParticipantId[], hideParticipantCount?: boolean, roomId?: number | null): Promise<void>;
     getStreamInfo(): Promise<{
         movieId: any;
         preview: any;
@@ -268,8 +271,8 @@ export default class Conversation extends EventEmitter {
     setLocalResolution({ video, effect }: {
         video: IVideoDimentions;
         effect?: IVideoDimentions;
-    }): Promise<void>;
-    videoEffect(effect: IEffect | null): Promise<void>;
+    }): Promise<void | undefined>;
+    videoEffect(effect: IEffect | null): Promise<void | undefined>;
     getParticipants(parameters: IGetParticipantsParameters): Promise<ExternalParticipant[]>;
     getParticipantListChunk(participantListChunkParameters: ParticipantListChunkParameters): Promise<ExternalParticipantListChunk>;
     private _getInitialParticiapntListChunk;
@@ -279,6 +282,7 @@ export default class Conversation extends EventEmitter {
     private _changeRemoteParticipantState;
     private _invokeRolesChangedCallbackIfNeeded;
     private _onSignalingNotification;
+    private _onPromotionApproved;
     private _onSignalingReconnect;
     private _onSignalingFailed;
     private _onAcceptedCall;
@@ -301,8 +305,10 @@ export default class Conversation extends EventEmitter {
     private _onRecordInfo;
     private _changePinnedParticipantForRoom;
     _changeRecordInfoForRoom(): Promise<void>;
+    private _changeAsrInfoForRoom;
     private _onParticipantAnimojiChanged;
-    private _onAsrInfo;
+    private _onAsrStart;
+    private _onAsrStop;
     private _onAsrTranscription;
     private _onRolesChanged;
     /**

package/classes/FpsMeter.d.ts

@@ -0,0 +1,10 @@
+export default class FpsMeter {
+    private _counter;
+    private _interval;
+    private _lastCalculationTime;
+    private readonly _onCalculated;
+    constructor(callback?: Function | null, intervalMs?: number);
+    increment(value?: number): void;
+    calculate(): number;
+    destroy(): void;
+}

package/classes/MediaSource.d.ts

@@ -20,7 +20,7 @@ export declare const enum MediaTrackKind {
 }
 export declare class MediaSource extends EventEmitter {
     /** Стрим с камеры и микрофона пользователя */
-    private _stream;
+    protected _stream: MediaStream | null;
     private _screenTrack;
     private _audioShareTrack;
     /** Трек для отправки в медиа-канал. Может отличаться при скриншаринге в дата-канал */
@@ -67,8 +67,8 @@ export declare class MediaSource extends EventEmitter {
     private _disableScreenCapture;
     private disableAudioShare;
     private stopAudioShareTrack;
-    private getSilentAudioShareTrack;
-    private _replaceLocalTrack;
+    protected getSilentAudioShareTrack(): MediaStreamTrack;
+    protected _replaceLocalTrack(newTrack: MediaStreamTrack, sendTrack?: MediaStreamTrack): Promise<void>;
     private _setEffect;
     private _stopEffect;
     destroy(): void;

package/classes/ParticipantIdRegistry.d.ts

@@ -1,5 +1,9 @@
 import { ParticipantStreamDescription } from '../types/ParticipantStreamDescription';
 import SignalingMessage from '../types/SignalingMessage';
+export type IParticipantSuspendInfoParse = [
+    number,
+    boolean
+];
 export declare class ParticipantIdRegistry {
     private streamDescriptionByCompactId;
     private compactIdByStreamDescription;
@@ -7,4 +11,5 @@ export declare class ParticipantIdRegistry {
     getCompactId(streamDescription: string): number | undefined;
     handleMessage(data: ArrayBuffer): SignalingMessage | null;
     private _createParticipantSourcesUpdateNotification;
+    private _createParticipantSourcesSuspendNotification;
 }

package/classes/ProducerCommandSerializationService.d.ts

@@ -1,4 +1,5 @@
 import ParticipantLayout, { RequestKeyFrame, StopStream } from '../types/ParticipantLayout';
+import { RequestAsr } from '../types/RequestAsr';
 import SignalingMessage from '../types/SignalingMessage';
 import { PerfStatReport } from '../types/PerfStatReporter';
 import { SharingStatReport } from './screenshare/SharingStatReport';
@@ -13,6 +14,7 @@ export declare class ProducerCommandSerializationService {
     private writeStreamDesc;
     serializePerfStatReport(sequenceNumber: number, report: PerfStatReport): ArrayBuffer;
     serializeSharingStatReport(sequenceNumber: number, report: SharingStatReport): ArrayBuffer;
+    serializeRequestAsr(sequenceNumber: number, params: RequestAsr): ArrayBuffer;
     deserializeCommandResponse(data: BufferSource | Blob): Promise<SignalingMessage | undefined>;
     private deserializeUpdateDisplayLayoutResponse;
     private deserializeReportPerfStatResponse;

package/classes/codec/IEncoder.d.ts

@@ -5,7 +5,7 @@ export default interface IEncoder {
     requestFrame(keyFrame: boolean): void;
     isVP9(): boolean;
     destroy(): void;
-    setBitrate(bitrate: number, useCbr: boolean): void;
+    setBitrate(bitrate: number, useCbr: boolean, fps: number): void;
 }
 export interface FrameMessage {
     type: MessageType;

package/classes/codec/LibVPxEncoder.d.ts

@@ -29,7 +29,7 @@ export default class LibVPxEncoder extends WorkerBase implements IEncoder {
     private _requestFrameVideo;
     private _requestFrameBitmap;
     requestFrame(keyFrame?: boolean): void;
-    setBitrate(bitrate: number, useCbr?: boolean): void;
+    setBitrate(bitrate: number, useCbr: boolean, fps: number): void;
     isVP9(): boolean;
     destroy(): void;
     static isBrowserSupported(): boolean;

package/classes/codec/Types.d.ts

@@ -11,9 +11,19 @@ export declare const enum MessageType {
     DEBUG = "debug",
     LOG_ERROR = "log_error"
 }
-export type EncodedVideoFrame = Pick<EncodedVideoChunk, 'type' | 'timestamp' | 'duration' | 'byteLength' | 'data'> & {
+export type EncodedVideoFrame = Pick<EncodedVideoChunk, 'type' | 'duration' | 'byteLength' | 'data'> & {
     width: number;
     height: number;
+    timestamp: number;
 };
+export interface EncodedVideoFrameChunk {
+    sequence: number;
+    timestamp: number;
+    data: ArrayBuffer;
+    frameSize: number;
+    isFirst: boolean;
+    isLast: boolean;
+    isKey: boolean;
+}
 export type OnFrameCallback = (chunk: EncodedVideoFrame | null, error?: string) => void;
-export type OnCongestionCallback = (bitrate: number, useCbr: boolean) => void;
+export type OnCongestionCallback = (bitrate: number, useCbr: boolean, fps: number) => void;

package/classes/codec/WebCodecsEncoder.d.ts

@@ -12,7 +12,7 @@ export default class WebCodecsEncoder extends WorkerBase implements IEncoder {
     constructor(sourceTrack: MediaStreamTrack, onFrame: OnFrameCallback, useCongestionControl: boolean, maxBitrate: number, useCbr: boolean, frameRate: number);
     init(): Promise<void>;
     requestFrame(keyFrame?: boolean): void;
-    setBitrate(bitrate: number, useCbr: boolean): void;
+    setBitrate(bitrate: number, useCbr: boolean, fps: number): void;
     isVP9(): boolean;
     destroy(): void;
     static isBrowserSupported(): boolean;

package/classes/screenshare/PacketHistory.d.ts

@@ -21,10 +21,11 @@ export default class PacketHistory {
     private _tail;
     constructor(maxSize: number);
     add(seq: number, ts: number, size: number, start: boolean, end: boolean): number;
-    update(seq: number, ts2: number): HistoryRecord;
-    get(seq: number): HistoryRecord;
+    update(seq: number, ts2: number): HistoryRecord | null;
+    get(seq: number): HistoryRecord | null;
     getServerBitrateK(windowMs: number): number;
     getCurrentDelay(): number;
     getMaxBandwidth(): number;
+    clear(): void;
 }
 export {};

package/classes/screenshare/ScreenCaptureSender.d.ts

@@ -12,19 +12,29 @@ export default class ScreenCaptureSender {
     private _width;
     private _height;
     private _feedback;
+    private _lastSentFrameSeq;
+    private _lastDeliveredFrameSeq;
     private _lastSharingStat;
-    private _congestionControlEnabled;
+    private readonly _congestionControlEnabled;
+    private readonly _queue;
+    private readonly _fpsMeter;
     constructor(track: MediaStreamTrack, datachannel: RTCDataChannel, signaling: BaseSignaling, fastSharing: boolean);
+    private _handleQueue;
+    /**
+     * Очищает очередь до опорного кадра
+     * @returns Есть ли в очереди опорный кадр
+     * @hidden
+     */
+    private _cleanupQueue;
     private _requestFrame;
+    private _sliceFrame;
     private _wrapHeader;
     private _stopPacket;
-    private _send;
-    private _sendChunk;
+    private _sendFrameChunk;
     destroy(): void;
     static isBrowserSupported(): boolean;
     private _onCongestionCallback;
     private _onResize;
     private _calcMinMaxBitrate;
-    private _checkCcFeedback;
     private _sendSharingStat;
 }

package/classes/screenshare/ScreenCongestionControl.d.ts

@@ -6,6 +6,7 @@ export default class ScreenCongestionControl {
     private readonly _fastSharing;
     private readonly _trendDelayThreshold;
     private readonly _highDelayThreshold;
+    private readonly _targetFps;
     private _minBitrate;
     private _maxBitrate;
     private _targetBitrate;
@@ -20,10 +21,14 @@ export default class ScreenCongestionControl {
     private _minDelay;
     private _maxDelay;
     private _largeDelayDuration;
-    constructor(onCongestion: OnCongestionCallback, minBitrate: number, maxBitrate: number, ccEnabled: boolean, fastSharing: boolean, delayThreshold: number);
+    private _lastFpsCalcMs;
+    private _frames;
+    private _fps;
+    constructor(onCongestion: OnCongestionCallback, minBitrate: number, maxBitrate: number, ccEnabled: boolean, fastSharing: boolean, delayThreshold: number, targetFps: number);
     checkDelay(frameNum: number, delay: number, bitrateK: number): void;
     private _setBitrate;
     private _calcDelay;
     reconfigure(minBitrate: number, maxBitrate: number): void;
-    getStat(): SharingStatReport;
+    getStat(): SharingStatReport | null;
+    private _calcFps;
 }

package/classes/screenshare/StreamBuilder.d.ts

@@ -5,6 +5,7 @@ export default class StreamBuilder extends BaseStreamBuilder {
     private readonly _decoder;
     private _decoderReady;
     private _decoderQueue;
+    private readonly _fpsMeter;
     constructor(participantId: ParticipantId, onStream: IOnStream, onStat: IOnStat);
     protected _processFrame(frame: FrameData): void;
     private _decodeQueue;

package/classes/screenshare/Utils.d.ts

@@ -19,4 +19,4 @@ export interface CcFeedback {
     seq: number;
     ts2: number;
 }
-export declare function parseCcFeedback(data?: ArrayBuffer): CcFeedback;
+export declare function parseCcFeedback(data?: ArrayBuffer): CcFeedback | null;

package/classes/stat/StatAggregator.d.ts

@@ -1,5 +1,5 @@
 import { ICallStatLog } from '../../types/PerfStatReporter';
-import { IEventualStatLog } from '../../types/Logger';
+import { IEventualStatLog } from '../../types/IEventualStatLog';
 export declare class StatAggregator {
     private static _instance;
     private readonly _eventualLogs;

package/classes/transport/ServerTransport.d.ts

@@ -20,6 +20,7 @@ export default class ServerTransport extends BaseTransport {
     private _settingsInterval;
     private _statBytes;
     private _ssrcMap;
+    private _ssrcMapUpdated;
     private _perfStatReporter;
     private _producerOfferIsProcessing;
     private _producerNextOffer;
@@ -43,6 +44,7 @@ export default class ServerTransport extends BaseTransport {
     allowRestart(): void;
     updateSettings(settings: ServerSettings): void;
     setAnimojiTransport(receiver: AnimojiReceiver, sender: AnimojiSender): void;
+    private _createPerfStatsReporter;
     private _closeConnection;
     private static _closeDataChannel;
     private _createDataChannel;

package/classes/transport/Statistics.d.ts

@@ -1,5 +1,23 @@
 import { ParticipantId } from '../../types/Participant';
-import { StatItem } from '../../types/Statistics';
+import { StatItem, StatRtp, StatTransport } from '../../types/Statistics';
+export declare const NO_STAT_REQUEST_DELAY = 1000;
+export declare function distinctById(items: RTCStats[]): RTCStats[];
+export declare function rtcStatsToArray(stats: RTCStatsReport[]): RTCStats[];
+/**
+ * Extracts transport statistics from the gives stats
+ * @hidden
+ */
+export declare function extractTransport(stats: RTCStats[]): StatTransport;
+/**
+ * Extracts media statistics from the given stats
+ * @hidden
+ */
+export declare function extractRtps(stats: RTCStats[], ssrcMap: Record<string, string>): StatRtp[];
+/**
+ * Computes delta (the difference) between two stat reports.
+ * @hidden
+ */
+export declare function delta(current: StatItem, previous: StatItem): StatItem;
 export declare function collectStats(pc: RTCPeerConnection, previous: StatItem | null, ssrcMap?: Record<string, string>): Promise<StatItem>;
 export declare function setMark(name: string): void;
 export declare function clearMark(name: string): void;

package/classes/transport/Transport.d.ts

@@ -61,7 +61,7 @@ export declare class Transport extends EventEmitter {
     isAllocated(participantId: ParticipantId): boolean;
     allocated(): string[];
     opened(): string[];
-    getState(): TransportState;
+    getState(): TransportState | undefined;
     getStates(): Record<string, TransportState>;
     setAnimojiSvg(participantId: ParticipantId, svgData: AnimojiSvgData): void;
     private _setStates;
@@ -89,6 +89,7 @@ export declare class Transport extends EventEmitter {
     private _onServerRemoteTrackAdded;
     private _onServerRemoteTrackRemoved;
     private _onAsrTranscription;
+    private _onSourceChanged;
     private _onAnimojiStream;
     /** Обработчик, досылающий MediaSourceEvent.SOURCE_CHANGED событие до аллокации транспортов */
     private _onAnimojiStatus;

package/constants/Rooms.d.ts

@@ -0,0 +1 @@
+export declare const MAIN_ROOM_ID: number | null;

package/default/Api.d.ts

@@ -2,30 +2,28 @@ import BaseApi, { LogItem } from '../abstract/BaseApi';
 import CallType from '../enums/CallType';
 import ConversationParams from '../types/ConversationParams';
 import ConversationResponse from '../types/ConversationResponse';
-import { ExternalId, ExternalUserId } from '../types/ExternalId';
-import { CompositeUserId, OkUserId } from '../types/Participant';
+import { ExternalId, ExternalParticipantId, ExternalUserId } from '../types/ExternalId';
+import { CompositeUserId, OkUserId, ParticipantId } from '../types/Participant';
 export default class Api extends BaseApi {
     private _userId;
     private _uuid;
     private _externalUidsCache;
-    private _extrnalUidsBatchPromise?;
-    private _extrnalUidsBatch;
-    private _extrnalUidsBatchTimeout;
     private _callUnsafe;
-    private _call;
-    userId(compositeUserId: CompositeUserId): Promise<ExternalId>;
+    protected _call(method: string, data?: any, noSession?: boolean): Promise<any>;
+    userId(compositeUserId: ParticipantId): Promise<ExternalParticipantId>;
     prepareUserIds(ids: OkUserId[]): Promise<void>;
-    private _prepareUserIdsByOkIdsBatched;
     authorize(): Promise<void>;
     log(items: LogItem[]): void;
     init(): void;
     joinConversation(conversationId: string, isVideo?: boolean, chatId?: string): Promise<ConversationResponse>;
-    createConversation(conversationId: string, payload?: string, requireAuthToJoin?: boolean, { onlyAdminCanShareMovie }?: {
+    createConversation(conversationId: string, payload?: string, requireAuthToJoin?: boolean, { onlyAdminCanShareMovie, audienceMode, }?: {
         onlyAdminCanShareMovie?: boolean;
-    }): Promise<ConversationResponse>;
+        audienceMode?: boolean;
+    }, speakerIds?: OkUserId[]): Promise<ConversationResponse>;
     startConversation(conversationId: string, ids?: OkUserId[], type?: CallType, isVideo?: boolean, payload?: string, joiningAllowed?: boolean, requireAuthToJoin?: boolean, { onlyAdminCanShareMovie }?: {
         onlyAdminCanShareMovie?: boolean;
     }): Promise<ConversationResponse>;
+    protected _ensureUuid(): void;
     private _preareStartConversationData;
     private _startConversation;
     createJoinLink(conversationId: string): Promise<{
@@ -38,16 +36,18 @@ export default class Api extends BaseApi {
     joinConversationByLink(joinLink: string, isVideo?: boolean, observedIds?: ExternalUserId[], payload?: string): Promise<ConversationResponse>;
     /**
      * NB: Не сохраняет порядок возвращаемых ID
+     * Этот метод принимает именно ExternalId, т.к. для OkUserId не принципиально наличие deviceIdx
      * @hidden
      */
-    getOkIdsByExternalIds(externalIds: (string | ExternalId)[]): Promise<OkUserId[]>;
+    getOkIdsByExternalIds(externalIds: ExternalId[]): Promise<OkUserId[]>;
+    getParticipantIdsByExternalIds(externalIds: ExternalId[]): Promise<Map<ExternalId, ParticipantId>>;
     /**
      * NB: Не сохраняет порядок возвращаемых ID
      * @hidden
      */
-    getExternalIdsByOkIds(uids: OkUserId[]): Promise<ExternalId[]>;
-    getCachedOkIdByExternalId(externalId: ExternalId): CompositeUserId | null;
-    cacheExternalId(participantId: CompositeUserId, externalId: ExternalId): void;
+    getExternalIdsByOkIds(uids: OkUserId[]): Promise<ExternalParticipantId[]>;
+    getCachedOkIdByExternalId(externalId: ExternalId): ParticipantId | null;
+    cacheExternalId(participantId: CompositeUserId, externalId: ExternalParticipantId): void;
     getConversationParams(conversationId?: string): Promise<ConversationParams>;
     getUserId(): OkUserId | null;
     setUserId(userId: OkUserId): void;

package/default/ApiExternal.d.ts

@@ -0,0 +1,11 @@
+import { IApiEnv } from '../types/Params';
+export declare class ApiExternal {
+    private readonly _uuid;
+    private readonly _apiKey;
+    private readonly _callToken;
+    private readonly _apiEnv;
+    private _sessionKey;
+    constructor(apiEvn: IApiEnv, apiKey: string, callToken: string);
+    authorize(): Promise<boolean>;
+    hangupConversation(conversationId: string): Promise<void>;
+}

package/default/Signaling.d.ts

@@ -1,18 +1,15 @@
 import BaseSignaling, { AddParticipantParams } from '../abstract/BaseSignaling';
 import { ParticipantIdRegistry } from '../classes/ParticipantIdRegistry';
 import { SharingStatReport } from '../classes/screenshare/SharingStatReport';
-import { StreamDescriptionString } from '../types/ParticipantStreamDescription';
-import { PerfStatReport } from '../types/PerfStatReporter';
 import { TransportTopology } from '../classes/transport/Transport';
 import ConversationFeature from '../enums/ConversationFeature';
 import ConversationOption from '../enums/ConversationOption';
 import MediaOption from '../enums/MediaOption';
-import RecordRole from '../enums/RecordRole';
 import SignalingCommandType from '../enums/SignalingCommandType';
 import SignalingConnectionType from '../enums/SignalingConnectionType';
 import UserRole from '../enums/UserRole';
 import { JSONObject } from '../static/Json';
-import { IAsrStartParams } from '../types/Asr';
+import { IAsrStartParams, IAsrStopParams } from '../types/Asr';
 import MediaModifiers from '../types/MediaModifiers';
 import MediaSettings from '../types/MediaSettings';
 import { IAddMovieParams, IUpdateMovieData } from '../types/MovieShare';
@@ -20,8 +17,10 @@ import MuteStates from '../types/MuteStates';
 import { CompositeUserId, ParticipantId } from '../types/Participant';
 import ParticipantLayout, { RequestKeyFrame, StopStream } from '../types/ParticipantLayout';
 import { ParticipantListChunkParameters } from '../types/ParticipantListChunk';
+import { StreamDescriptionString } from '../types/ParticipantStreamDescription';
+import { PerfStatReport } from '../types/PerfStatReporter';
 import SignalingMessage from '../types/SignalingMessage';
-import { IStartStreamData, IStopStreamData } from '../types/Streams';
+import { IRecordConfData, IStartStreamData, IStopStreamData, IPublishStreamData } from '../types/Streams';
 import { WaitingParticipantId } from '../types/WaitingHall';
 export default class Signaling extends BaseSignaling {
     private socket;
@@ -29,7 +28,6 @@ export default class Signaling extends BaseSignaling {
     private lastStamp;
     private websocketCommandsQueue;
     private datachannelCommandsQueue;
-    private asrCommandsQueue;
     private incomingCache;
     private responseHandlers;
     private reconnectCount;
@@ -47,10 +45,8 @@ export default class Signaling extends BaseSignaling {
     private participantIdRegistry;
     private producerNotificationDataChannel;
     private producerCommandDataChannel;
-    private asrDataChannel;
     private producerCommandDataChannelEnabled;
     private producerCommandSerializationService;
-    private asrCommandSerializer;
     private static readonly RECONNECT_DELAY;
     private static readonly RECONNECT_MAX_DELAY;
     private static readonly RECONNECT_MAX_COUNT;
@@ -86,7 +82,7 @@ export default class Signaling extends BaseSignaling {
     getNextCommandSequenceNumber(): number;
     hangup(reason: string): Promise<SignalingMessage | void>;
     sendCandidate(participantId: ParticipantId, candidate: RTCIceCandidate): Promise<SignalingMessage>;
-    requestTestMode(consumerCommand: string, producerCommand: string): Promise<SignalingMessage>;
+    requestTestMode(consumerCommand: string, producerCommand: string | null): Promise<SignalingMessage>;
     sendSdp(participantId: ParticipantId, sdp: RTCSessionDescription): Promise<SignalingMessage>;
     acceptCall(mediaSettings: MediaSettings): Promise<SignalingMessage>;
     changeMediaSettings(mediaSettings: MediaSettings): Promise<SignalingMessage>;
@@ -118,7 +114,8 @@ export default class Signaling extends BaseSignaling {
     removeRooms(roomIds: number[]): Promise<SignalingMessage>;
     startStream(data: IStartStreamData): Promise<SignalingMessage>;
     stopStream(data?: IStopStreamData): Promise<SignalingMessage>;
-    recordSetRole(participantId: ParticipantId, role: RecordRole | null, roomId?: number | null): Promise<SignalingMessage>;
+    publishStream(data?: IPublishStreamData): Promise<SignalingMessage>;
+    recordSetConf(conf?: IRecordConfData): Promise<SignalingMessage>;
     getRecordStatus(): Promise<SignalingMessage>;
     switchTopology(topology: TransportTopology, force?: boolean): Promise<SignalingMessage>;
     requestRealloc(): Promise<SignalingMessage>;
@@ -127,7 +124,7 @@ export default class Signaling extends BaseSignaling {
     chatMessage(message: string, participantId?: CompositeUserId | null): Promise<SignalingMessage>;
     chatHistory(count: number): Promise<SignalingMessage>;
     customData(data: JSONObject, participantId: ParticipantId | null): Promise<SignalingMessage>;
-    grantRoles(participantId: CompositeUserId, roles: UserRole[], revoke: boolean): Promise<SignalingMessage>;
+    grantRoles(participantId: ParticipantId, roles: UserRole[], revoke: boolean): Promise<SignalingMessage>;
     muteParticipant(participantId: ParticipantId | null, muteStates: MuteStates, requestedMedia: MediaOption[], roomId?: number | null): Promise<SignalingMessage>;
     enableFeatureForRoles(feature: ConversationFeature, roles: UserRole[]): Promise<SignalingMessage>;
     pinParticipant(participantId: ParticipantId, unpin: boolean, roomId: number | null): Promise<SignalingMessage>;
@@ -137,7 +134,10 @@ export default class Signaling extends BaseSignaling {
     }): Promise<SignalingMessage>;
     getWaitingHall(fromId?: WaitingParticipantId | null, count?: number, backward?: boolean): Promise<SignalingMessage>;
     promoteParticipant(participantId: CompositeUserId, demote?: boolean): Promise<SignalingMessage>;
+    requestPromotion(demote?: boolean): Promise<SignalingMessage>;
+    acceptPromotion(reject?: boolean): Promise<SignalingMessage>;
     feedback(key: string): Promise<SignalingMessage>;
+    getHandQueue(): Promise<SignalingMessage>;
     /**
      * Close a connection with a signaling server
      */
@@ -152,9 +152,8 @@ export default class Signaling extends BaseSignaling {
     getParticipantListChunk(participantListChunkParameters: ParticipantListChunkParameters): Promise<SignalingMessage>;
     getParticipants(externalIds: SignalingMessage.ExternalId[]): Promise<SignalingMessage>;
     startAsr(params: IAsrStartParams): Promise<SignalingMessage>;
-    stopAsr(): Promise<SignalingMessage>;
+    stopAsr(params?: IAsrStopParams): Promise<SignalingMessage>;
     requestAsr(request: boolean): Promise<SignalingMessage>;
-    setAsrDataChannel(dataChannel: RTCDataChannel): void;
     protected _connect(connectionType: SignalingConnectionType): void;
     protected _disconnect(code?: number): void;
     private _onOpen;
@@ -168,7 +167,6 @@ export default class Signaling extends BaseSignaling {
     protected _closeSocket(error?: Error | null): void;
     protected _reconnect(): void;
     private _handleCommandResponse;
-    private _serializeAsrCommand;
     private _handleCommandsQueue;
     private _serializeBinary;
     private _serializeJson;

package/enums/FatalError.d.ts

@@ -2,6 +2,7 @@
  * Типы ошибок
  */
 declare enum FatalError {
+    MIC_CAMERA_PERMISSION = "mic_camera",
     CAMERA_PERMISSION = "camera",
     MIC_PERMISSION = "mic",
     CAMERA_ACCESS = "cameralock",