@vkontakte/calls-sdk 2.6.2-dev.f69c395.0 → 2.6.3-beta.0

package/classes/Conversation.d.ts

@@ -12,9 +12,12 @@ import UpdateDisplayLayoutErrorReason from '../enums/UpdateDisplayLayoutErrorRea
 import UserRole from '../enums/UserRole';
 import UserType from '../enums/UserType';
 import { JSONObject } from '../static/Json';
+import { AsrInfo } from '../types/Asr';
+import { IFeaturesPerRole } from '../types/ConversationFeature';
 import { ExternalParticipant, ExternalParticipantId, ExternalParticipantListChunk, ExternalUserId } from '../types/ExternalId';
 import MediaModifiers from '../types/MediaModifiers';
 import { IVideoDimentions } from '../types/MediaSettings';
+import { IAddMovieParams, IUpdateMovieData } from '../types/MovieShare';
 import MuteStates from '../types/MuteStates';
 import { CompositeUserId, IGetParticipantsParameters, OkUserId, ParticipantId } from '../types/Participant';
 import { ParticipantLayout } from '../types/ParticipantLayout';
@@ -37,6 +40,7 @@ export declare type ConversationData = {
      */
     acceptTime: number | null;
     features: ConversationFeature[];
+    featuresPerRole?: IFeaturesPerRole | null;
     /**
      * ID звонка
      */
@@ -46,8 +50,9 @@ export declare type ConversationData = {
     direction: CallDirection;
     concurrent: boolean;
     needRate: boolean;
-    recordInfo: RecordInfo | null;
+    recordsInfoByRoom: Map<number | null, RecordInfo | null>;
     chatId: string | null;
+    asrInfo: AsrInfo | null;
     /**
      * Роли пользователя
      */
@@ -59,11 +64,12 @@ export declare type ConversationData = {
     pinnedParticipantId: ParticipantId | null;
     mediaModifiers: MediaModifiers;
     options: ConversationOption[];
-    muteStates: MuteStates;
+    muteStates: Map<number | null, MuteStates>;
     unmuteOptions: MediaOption[];
     networkRating: number;
     waitingHall: boolean;
     observer: boolean;
+    roomId: number | null;
 };
 export declare type ParticipantUpdateInfo = {
     participantStreamDescription: ParticipantStreamDescription | null;
@@ -76,6 +82,7 @@ export default class Conversation extends EventEmitter {
     private readonly _signaling;
     private _mediaSource;
     private _conversation;
+    private _myLastRequestedLayouts;
     private _state;
     private _participantState;
     private _participants;
@@ -106,13 +113,14 @@ export default class Conversation extends EventEmitter {
     static current(): Conversation | null;
     static hangupAfterInit(): void;
     static id(): string | null;
-    onStart(opponentIds: OkUserId[], opponentType: CallType, mediaOptions: MediaOption[], payload?: string, joiningAllowed?: boolean, requireAuthToJoin?: boolean): Promise<ConversationData>;
+    onStart(opponentIds: OkUserId[], opponentType: CallType, mediaOptions: MediaOption[], payload?: string, joiningAllowed?: boolean, requireAuthToJoin?: boolean, onlyAdminCanShareMovie?: boolean): Promise<ConversationData>;
     onJoin(joinArgs: {
         conversationId?: string;
         mediaOptions: MediaOption[];
         chatId?: string;
         joinLink?: string;
         observedIds?: ExternalUserId[];
+        payload?: string;
     }): Promise<ConversationData>;
     private _onJoinPart2;
     onPush(conversationId: string, type?: UserType, peerId?: number): Promise<void>;
@@ -151,10 +159,12 @@ export default class Conversation extends EventEmitter {
     private _processConnection;
     private _prepareParticipants;
     private _onConversationParticipantListChunk;
+    private _createParticipantListChunk;
     private _participantListChunkToExternalChunk;
     private _registerConnectionParticipants;
     private _registerParticipants;
-    private _getClientType;
+    /** Установим состояние локальных мьютов */
+    private _registerParticipantLocalMuteState;
     private _getStatusByTransportState;
     private _registerParticipantInCache;
     private _getExistedParticipantByIdOrCreate;
@@ -167,10 +177,28 @@ export default class Conversation extends EventEmitter {
      * Обрабатывает данные connection из сигналинга. Должен вызываться после `_registerParticipants`
      *
      * @param connection
+     */
+    private _processConnectionData;
+    /**
+     * Обрабатывает информацию о сессионных залах
+     *
+     * @param connection
+     */
+    private _processRooms;
+    /**
+     * Обрабатывает информацию о мьютах в основном и сессионных залах
+     * @param connection
      * @private
      * @hidden
      */
-    private _processConnectionData;
+    private _processMuteStates;
+    /**
+     * Обрабатывает информацию о записи/трансляции в основном и сессионных залах
+     * @param connection
+     * @private
+     * @hidden
+     */
+    private _processRecordInfos;
     private _allocateTransport;
     private _createSpeakerDetector;
     private _createSpecListener;
@@ -188,7 +216,7 @@ export default class Conversation extends EventEmitter {
     private _onAddParticipant;
     private _onRemoveParticipant;
     changeDevice(kind: MediaDeviceKind): Promise<void>;
-    toggleScreenCapturing(enabled: boolean): Promise<void>;
+    toggleScreenCapturing(screenEnabled: boolean, audioShareEnabled: boolean): Promise<void>;
     setVideoStream(stream: MediaStream, isScreen?: boolean): Promise<void>;
     setAudioStream(stream: MediaStream): Promise<void>;
     toggleLocalVideo(enabled: boolean): Promise<void>;
@@ -200,19 +228,32 @@ export default class Conversation extends EventEmitter {
     requestKeyFrame(participantStreamDescription: ParticipantStreamDescription): Promise<void | SignalingMessage>;
     requestTestMode(consumerCommand: string, producerCommand: string): Promise<void>;
     updateDisplayLayout(layouts: ParticipantLayout[]): Promise<void>;
+    /** @async */
+    feedback(key: string): Promise<SignalingMessage>;
     private _stopStreaming;
     private _sendUpdateDisplayLayout;
     private _cleanupCooldownQueue;
     private _onParticipantSourcesUpdate;
     private _onParticipantPromoted;
     private _onChatRoomUpdated;
+    private _onSharedMovieUpdate;
+    private _onSharedMovieInfoStarted;
+    private _processSharedMovieInfos;
+    private _processSharedMovieInfo;
+    private _processConnectionSharedMovieInfo;
+    private _onSharedMovieInfoStopped;
+    private _onFeaturesPerRoleChanged;
     private _waitForStreamIfNeeded;
     private _matchStreamDescription;
     private _getWaitingTime;
     private _isCallAdmin;
     private _checkAdminRole;
     grantRoles(participantId: CompositeUserId, roles: UserRole[], revoke: boolean): Promise<void>;
-    muteParticipant(participantId: ParticipantId | null, muteStates: MuteStates, requestedMedia?: MediaOption[]): Promise<void>;
+    startAsr(): Promise<void>;
+    stopAsr(): Promise<void>;
+    requestAsr(request: boolean): Promise<void>;
+    muteParticipant(participantId: ParticipantId | null, muteStates: MuteStates, requestedMedia?: MediaOption[], roomId?: number | null): Promise<void>;
+    enableFeatureForRoles(feature: ConversationFeature, roles: UserRole[]): Promise<void>;
     pinParticipant(participantId: ParticipantId, unpin: boolean): Promise<void>;
     updateMediaModifiers(mediaModifiers: MediaModifiers): Promise<void>;
     changeOptions(changes: {
@@ -229,15 +270,19 @@ export default class Conversation extends EventEmitter {
     customData(data: JSONObject, participantId?: ParticipantId | null): Promise<void>;
     createJoinLink(): Promise<string>;
     removeJoinLink(): Promise<never>;
-    addMovie(movieId: string): Promise<{
-        movieId: string;
+    addMovie({ movieId, gain, metadata }: IAddMovieParams): Promise<{
+        movieId: number;
         streamType: string;
     }>;
-    updateMovie(movieId: string, gain?: number, offset?: string, pause?: boolean): Promise<void>;
-    removeMovie(movieId: string): Promise<void>;
-    startStream(isRecord?: boolean, name?: string | null, movieId?: string | null, privacy?: 'PUBLIC' | 'FRIENDS' | 'DIRECT_LINK', groupId?: string | null): Promise<SignalingMessage>;
-    stopStream(): Promise<SignalingMessage>;
-    recordSetRole(participantId: ParticipantId, role: RecordRole | null): Promise<void>;
+    updateMovie(params: IUpdateMovieData): Promise<void>;
+    removeMovie(movieId: number): Promise<void>;
+    updateRooms(rooms: SignalingMessage.Room[], assignRandomly: boolean): Promise<void>;
+    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<SignalingMessage>;
+    stopStream(roomId?: number | null): Promise<SignalingMessage>;
+    recordSetRole(participantId: ParticipantId, role: RecordRole | null, roomId?: number | null): Promise<void>;
     getStreamInfo(): Promise<{
         movieId: any;
         preview: any;
@@ -275,11 +320,15 @@ export default class Conversation extends EventEmitter {
     private _onChatMessage;
     private _onCustomData;
     private _onRecordInfo;
+    _changeRecordInfoForRoom(): Promise<void>;
+    private _onAsrInfo;
+    private _onAsrTranscription;
     private _onRolesChanged;
     /**
      * Клиент должен немедленно выключить микрофон и/или камеру
      */
     private _onMuteParticipant;
+    private _changeMuteStatesForRoom;
     private _processMuteState;
     private _onPinParticipant;
     private _onOptionsChanged;
@@ -305,6 +354,23 @@ export default class Conversation extends EventEmitter {
     private _updateDisplayLayoutFromCache;
     private _setParticipantsStatus;
     private _onJoinLinkChanged;
+    private _onRoomsUpdated;
+    private _onRoomUpdated;
+    private _convertRoomToExternal;
+    private _onRoomParticipantsUpdated;
+    /**
+     * @param roomId
+     * @param isStartEvent в случае true будет отправлено стартовое событие установки id сессионного зала
+     * @private
+     */
+    private _onRoomSwitched;
+    private _refreshRooms;
+    /** получили из сингналинга сообщение о реакции пользователей */
+    private _onFeedback;
+    private _isMe;
+    private _getMuteStatesForRoomId;
+    private _getMuteStatesForCurrentRoom;
+    private _setMuteStatesForRoomId;
 }
 export declare class UpdateDisplayLayoutError extends Error {
     readonly participantErrors: {

package/classes/MediaSource.d.ts

@@ -13,7 +13,8 @@ export declare const enum MediaSourceEvent {
 export declare const enum MediaTrackKind {
     'audio' = "audio",
     'video' = "video",
-    'screen' = "screen"
+    'screen' = "screen",
+    'audioshare' = "audioshare"
 }
 export declare class MediaSource extends EventEmitter {
     /** Стрим с камеры и микрофона пользователя */
@@ -21,6 +22,7 @@ export declare class MediaSource extends EventEmitter {
     /** Последний сохраненный оригинальный видео трек с камеры */
     private _trackVideoStreamBackup;
     private _screenTrack;
+    private _audioShareTrack;
     /** Трек для отправки в медиа-канал. Может отличаться при скриншаринге в дата-канал */
     private _sendVideoTrack;
     private _mediaSettings;
@@ -58,16 +60,19 @@ export declare class MediaSource extends EventEmitter {
     private _changeAudioInput;
     private _changeScreen;
     private _disableScreenCapture;
+    private disableAudioShare;
+    private getSilentAudioShareTrack;
     private _replaceLocalTrack;
     private _stopLocalTrack;
     private _videoEffect;
     /** останавливает и удаляет сохраненный трек с камеры пользователя */
     private _stopAndRemoveTrackVideoStreamBackup;
     destroy(): void;
-    toggleScreenCapturing(enabled: boolean): Promise<void>;
+    toggleScreenCapturing(captureScreen: boolean, captureAudio: boolean): Promise<void>;
     toggleVideo(enabled: boolean): Promise<void>;
     toggleAudio(enabled: boolean): Promise<void>;
     setResolution(width: number, height: number): Promise<void>;
     updateNoiseSuppression(): Promise<void>;
     videoEffect(effect: IEffect | null): Promise<void>;
+    getAudioShareTrack(): MediaStreamTrack | null;
 }

package/classes/ProducerCommandSerializationService.d.ts

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

package/classes/asr/AsrCommandSerializer.d.ts

@@ -0,0 +1,3 @@
+export declare class AsrCommandSerializer {
+    requestAsr(request: boolean): ArrayBuffer;
+}

package/classes/asr/AsrReceiver.d.ts

@@ -0,0 +1,12 @@
+import { AsrTranscription } from '../../types/Asr';
+import { ParticipantIdRegistry } from '../ParticipantIdRegistry';
+export declare class AsrReceiver {
+    private readonly _datachannel;
+    private readonly _participantIdRegistry;
+    private readonly _asrCallback;
+    private readonly _textDecoder;
+    constructor(datachannel: RTCDataChannel, participantIdRegistry: ParticipantIdRegistry, callback: (asr: AsrTranscription) => void);
+    private static parse;
+    private _onDataChannelMessage;
+    destroy(): void;
+}

package/classes/codec/IEncoder.d.ts

@@ -4,6 +4,7 @@ export default interface IEncoder {
     requestFrame(keyFrame: boolean): void;
     isVP9(): boolean;
     destroy(): void;
+    setBitrate(bitrate: number, useCbr: boolean): void;
 }
 export interface FrameMessage {
     type: MessageType;
@@ -12,4 +13,6 @@ export interface FrameMessage {
     duration?: number;
     data?: ArrayBuffer;
     error?: string;
+    width?: number;
+    height?: number;
 }

package/classes/codec/LibVPxEncoder.d.ts

@@ -4,6 +4,8 @@ import WorkerBase from './WorkerBase';
 export default class LibVPxEncoder extends WorkerBase implements IEncoder {
     private readonly _sourceTrack;
     private readonly _onFrame;
+    private readonly _useCongestionControl;
+    private readonly _maxBitrate;
     private readonly _useImageCapture;
     private _video;
     private _imageCapture;
@@ -13,7 +15,7 @@ export default class LibVPxEncoder extends WorkerBase implements IEncoder {
     private _track;
     private _frameReadTimeout;
     private _lastFrame;
-    constructor(sourceTrack: MediaStreamTrack, onFrame: OnFrameCallback);
+    constructor(sourceTrack: MediaStreamTrack, onFrame: OnFrameCallback, useCongestionControl: boolean, maxBitrate: number);
     private _createDom;
     private _removeDom;
     private _createStream;
@@ -27,6 +29,7 @@ export default class LibVPxEncoder extends WorkerBase implements IEncoder {
     private _requestFrameVideo;
     private _requestFrameBitmap;
     requestFrame(keyFrame?: boolean): void;
+    setBitrate(bitrate: number, useCbr?: boolean): void;
     isVP9(): boolean;
     destroy(): void;
     static isBrowserSupported(): boolean;

package/classes/codec/Types.d.ts

@@ -6,9 +6,14 @@ export declare const enum MessageType {
     INIT = "init",
     READY = "ready",
     FRAME = "frame",
+    SET_BITRATE = "set_bitrate",
     ERROR = "error",
     DEBUG = "debug",
     LOG_ERROR = "log_error"
 }
-export declare type EncodedVideoFrame = Pick<EncodedVideoChunk, 'type' | 'timestamp' | 'duration' | 'byteLength' | 'data'>;
+export declare type EncodedVideoFrame = Pick<EncodedVideoChunk, 'type' | 'timestamp' | 'duration' | 'byteLength' | 'data'> & {
+    width: number;
+    height: number;
+};
 export declare type OnFrameCallback = (chunk: EncodedVideoFrame | null, error?: string) => void;
+export declare type OnCongestionCallback = (bitrate: number, useCbr: boolean) => void;

package/classes/codec/WebCodecsEncoder.d.ts

@@ -5,9 +5,12 @@ export default class WebCodecsEncoder extends WorkerBase implements IEncoder {
     private readonly _sourceTrack;
     private readonly _trackProcessor;
     private readonly _onFrame;
-    constructor(sourceTrack: MediaStreamTrack, onFrame: OnFrameCallback);
+    private readonly _useCongestionControl;
+    private readonly _maxBitrate;
+    constructor(sourceTrack: MediaStreamTrack, onFrame: OnFrameCallback, useCongestionControl: boolean, maxBitrate: number);
     init(): Promise<void>;
     requestFrame(keyFrame?: boolean): void;
+    setBitrate(bitrate: number, useCbr: boolean): void;
     isVP9(): boolean;
     destroy(): void;
     static isBrowserSupported(): boolean;

package/classes/screenshare/PacketHistory.d.ts

@@ -0,0 +1,30 @@
+declare type HistoryRecord = {
+    seq: number;
+    ts: number;
+    size: number;
+    sent: number;
+    start: boolean;
+    end: boolean;
+    ts2: number;
+    recv: number;
+};
+/**
+ * Class calculates server bitrate and delay, based on server cc feedback
+ * Ring buffer to keep sent packets info (HistoryRecord)
+ * Packet info is updated when cc feedback is received from server
+ */
+export default class PacketHistory {
+    private readonly _maxSize;
+    private _size;
+    private readonly _buffer;
+    private _head;
+    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;
+    getServerBitrateK(windowMs: number): number;
+    getCurrentDelay(): number;
+    getMaxBandwidth(): number;
+}
+export {};

package/classes/screenshare/PacketHistory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/classes/screenshare/ScreenCaptureSender.d.ts

@@ -1,10 +1,19 @@
+import BaseSignaling from '../../abstract/BaseSignaling';
 export default class ScreenCaptureSender {
     private readonly _encoder;
     private readonly _datachannel;
+    private readonly _signaling;
     private _destroyed;
     private _needKeyframe;
     private readonly DATA_SIZE;
-    constructor(track: MediaStreamTrack, datachannel: RTCDataChannel);
+    private _congestionControl;
+    private _frameNum;
+    private _width;
+    private _height;
+    private _feedback;
+    private _lastSharingStat;
+    private _congestionControlEnabled;
+    constructor(track: MediaStreamTrack, datachannel: RTCDataChannel, signaling: BaseSignaling);
     private _requestFrame;
     private _wrapHeader;
     private _stopPacket;
@@ -12,4 +21,9 @@ export default class ScreenCaptureSender {
     private _sendChunk;
     destroy(): void;
     static isBrowserSupported(): boolean;
+    private _onCongestionCallback;
+    private _onResize;
+    private _calcMinMaxBitrate;
+    private _checkCcFeedback;
+    private _sendSharingStat;
 }

package/classes/screenshare/ScreenCongestionControl.d.ts

@@ -0,0 +1,25 @@
+import { OnCongestionCallback } from '../codec/Types';
+import { SharingStatReport } from './SharingStatReport';
+export default class ScreenCongestionControl {
+    private readonly _onCongestion;
+    private readonly _ccEnabled;
+    private _minBitrate;
+    private _maxBitrate;
+    private _targetBitrate;
+    private _lastDown;
+    private _lastUp;
+    private _lastProbing;
+    private _lastCheckDelay;
+    private _upPenalty;
+    private _probing;
+    private _delayAvgShort;
+    private _delayAvgLong;
+    private _minDelay;
+    private _maxDelay;
+    private _largeDelayDuration;
+    constructor(onCongestion: OnCongestionCallback, minBitrate: number, maxBitrate: number, ccEnabled: boolean);
+    checkDelay(frameNum: number, delay: number, bitrateK: number): void;
+    private _calcDelay;
+    reconfigure(minBitrate: number, maxBitrate: number): void;
+    getStat(): SharingStatReport;
+}

package/classes/screenshare/SharingStatReport.d.ts

@@ -0,0 +1,6 @@
+export declare type SharingStatReport = {
+    minDelay: number;
+    maxDelay: number;
+    avgDelay: number;
+    largeDelayDuration: number;
+};

package/classes/screenshare/Utils.d.ts

@@ -15,3 +15,8 @@ export interface FrameChunk extends FrameChunkHeader {
 export declare function wrapHeader(timestamp: number, start: boolean, end: boolean, keyframe: boolean, sequence: number, isVP9: boolean, data: ArrayBuffer | null): ArrayBuffer;
 export declare function parseChunk(data: ArrayBuffer): FrameChunk;
 export declare function isKeyframeRequested(data?: ArrayBuffer): boolean;
+export interface CcFeedback {
+    seq: number;
+    ts2: number;
+}
+export declare function parseCcFeedback(data?: ArrayBuffer): CcFeedback;

package/classes/transport/ServerTransport.d.ts

@@ -13,6 +13,7 @@ export default class ServerTransport extends EventEmitter {
     private _producerCommand;
     private _producerScreen;
     private _consumerScreen;
+    private _asr;
     private _isOpen;
     private _observer;
     private _reconnectionPrevented;
@@ -27,12 +28,14 @@ export default class ServerTransport extends EventEmitter {
     private _lastStat;
     private _serverSettings;
     private _prevConsumerSettings;
+    private _asrTrack;
     private _captureSender;
     private _captureReceiver;
     private _participantIdRegistry;
     private _disabledSenders;
     private _rtpReceiversByStreamId;
     private _producerSessionId;
+    private _newAudioShareTrack;
     constructor(signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings);
     getState(): TransportState;
     updateStatisticsInterval(): void;
@@ -46,6 +49,7 @@ export default class ServerTransport extends EventEmitter {
     private static _closeDataChannel;
     private _createDataChannel;
     private _openConnection;
+    private _removeAsrTrack;
     private _reconnect;
     private _signalActiveParticipants;
     private _signalStalledParticipants;
@@ -68,12 +72,13 @@ export default class ServerTransport extends EventEmitter {
     private _detectStaleTracks;
     private _allocateConsumer;
     private _acceptProducer;
+    private handleTracks;
     _onSignalingNotification(message: SignalingMessage): Promise<void>;
+    private _onAsrTranscription;
     private _onProducerUpdated;
     private _onAddTrack;
     static _onSignalingStateChange(pc: RTCPeerConnection, event: any): void;
     private _onConnectionStateChange;
     private _onReplacedTrack;
-    private static _isUnifiedPlanSupported;
     getStreamWaitingTimeMs(streamId: string, targetRtpTimestamp: number): number;
 }

package/classes/transport/Transport.d.ts

@@ -16,7 +16,8 @@ export declare const enum TransportEvent {
     SIGNALLED_STALLED_PARTICIPANTS = "SIGNALLED_STALLED_PARTICIPANTS",
     TOPOLOGY_CHANGED = "TOPOLOGY_CHANGED",
     NETWORK_STATUS = "NETWORK_STATUS",
-    PEER_CONNECTION_CLOSED = "PEER_CONNECTION_CLOSED"
+    PEER_CONNECTION_CLOSED = "PEER_CONNECTION_CLOSED",
+    ASR_TRANSCRIPTION = "ASR_TRANSCRIPTION"
 }
 export declare const enum TransportState {
     IDLE = "IDLE",
@@ -81,5 +82,6 @@ export declare class Transport extends EventEmitter {
     private _onDirectRemoteDataStats;
     private _onServerRemoteTrackAdded;
     private _onServerRemoteTrackRemoved;
+    private _onAsrTranscription;
     getStreamWaitingTimeMs(streamId: string, targetRtpTimestamp: number): number;
 }

package/default/Api.d.ts

@@ -8,16 +8,25 @@ 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>;
     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): Promise<ConversationResponse>;
-    startConversation(conversationId: string, ids?: OkUserId[], type?: CallType, isVideo?: boolean, payload?: string, joiningAllowed?: boolean, requireAuthToJoin?: boolean): Promise<ConversationResponse>;
+    createConversation(conversationId: string, payload?: string, requireAuthToJoin?: boolean, { onlyAdminCanShareMovie }?: {
+        onlyAdminCanShareMovie?: boolean;
+    }): Promise<ConversationResponse>;
+    startConversation(conversationId: string, ids?: OkUserId[], type?: CallType, isVideo?: boolean, payload?: string, joiningAllowed?: boolean, requireAuthToJoin?: boolean, { onlyAdminCanShareMovie }?: {
+        onlyAdminCanShareMovie?: boolean;
+    }): Promise<ConversationResponse>;
+    private _preareStartConversationData;
     private _startConversation;
     createJoinLink(conversationId: string): Promise<{
         join_link: string;
@@ -26,7 +35,7 @@ export default class Api extends BaseApi {
         success: boolean;
     }>;
     getAnonymTokenByLink(joinLink: string, username?: string): Promise<string>;
-    joinConversationByLink(joinLink: string, isVideo?: boolean, observedIds?: ExternalUserId[]): Promise<ConversationResponse>;
+    joinConversationByLink(joinLink: string, isVideo?: boolean, observedIds?: ExternalUserId[], payload?: string): Promise<ConversationResponse>;
     /**
      * NB: Не сохраняет порядок возвращаемых ID
      * @hidden

package/default/Api.test.d.ts

@@ -0,0 +1 @@
+export {};