@vkontakte/calls-sdk 2.6.2-dev.d0c4f88.0 → 2.6.2-dev.e25d5b7.0

package/classes/Conversation.d.ts

@@ -12,10 +12,12 @@ import UpdateDisplayLayoutErrorReason from '../enums/UpdateDisplayLayoutErrorRea
 import UserRole from '../enums/UserRole';
 import UserType from '../enums/UserType';
 import { JSONObject } from '../static/Json';
+import { IFeaturesPerRole } from '../types/ConversationFeature';
+import { AsrInfo } from '../types/Asr';
 import { ExternalParticipant, ExternalParticipantId, ExternalParticipantListChunk, ExternalUserId } from '../types/ExternalId';
 import MediaModifiers from '../types/MediaModifiers';
 import { IVideoDimentions } from '../types/MediaSettings';
-import { IAddMovieParams } from '../types/MovieShare';
+import { IAddMovieParams, IUpdateMovieData } from '../types/MovieShare';
 import MuteStates from '../types/MuteStates';
 import { CompositeUserId, IGetParticipantsParameters, OkUserId, ParticipantId } from '../types/Participant';
 import { ParticipantLayout } from '../types/ParticipantLayout';
@@ -38,6 +40,7 @@ export declare type ConversationData = {
      */
     acceptTime: number | null;
     features: ConversationFeature[];
+    featuresPerRole?: IFeaturesPerRole | null;
     /**
      * ID звонка
      */
@@ -49,6 +52,7 @@ export declare type ConversationData = {
     needRate: boolean;
     recordInfo: RecordInfo | null;
     chatId: string | null;
+    asrInfo: AsrInfo | null;
     /**
      * Роли пользователя
      */
@@ -77,6 +81,7 @@ export default class Conversation extends EventEmitter {
     private readonly _signaling;
     private _mediaSource;
     private _conversation;
+    private _myLastRequestedLayouts;
     private _state;
     private _participantState;
     private _participants;
@@ -107,13 +112,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>;
@@ -158,7 +164,6 @@ export default class Conversation extends EventEmitter {
     private _registerParticipants;
     /** Установим состояние локальных мьютов */
     private _registerParticipantLocalMuteState;
-    private _getClientType;
     private _getStatusByTransportState;
     private _registerParticipantInCache;
     private _getExistedParticipantByIdOrCreate;
@@ -192,7 +197,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>;
@@ -204,6 +209,8 @@ 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;
@@ -212,14 +219,21 @@ export default class Conversation extends EventEmitter {
     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>;
+    startAsr(): Promise<void>;
+    stopAsr(): Promise<void>;
     muteParticipant(participantId: ParticipantId | null, muteStates: MuteStates, requestedMedia?: MediaOption[]): Promise<void>;
+    enableFeatureForRoles(feature: ConversationFeature, roles: UserRole[]): Promise<void>;
     pinParticipant(participantId: ParticipantId, unpin: boolean): Promise<void>;
     updateMediaModifiers(mediaModifiers: MediaModifiers): Promise<void>;
     changeOptions(changes: {
@@ -240,8 +254,12 @@ export default class Conversation extends EventEmitter {
         movieId: string;
         streamType: string;
     }>;
-    updateMovie(movieId: string, gain?: number, offset?: number, pause?: boolean): Promise<void>;
+    updateMovie(params: IUpdateMovieData): Promise<void>;
     removeMovie(movieId: string): Promise<void>;
+    updateRooms(rooms: SignalingMessage.Room[], assignRandomly: boolean): Promise<void>;
+    activateRooms(roomIds: number[], deactivate: boolean): Promise<void>;
+    switchRoom(toRoomId?: number, 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): Promise<SignalingMessage>;
     stopStream(): Promise<SignalingMessage>;
     recordSetRole(participantId: ParticipantId, role: RecordRole | null): Promise<void>;
@@ -282,6 +300,7 @@ export default class Conversation extends EventEmitter {
     private _onChatMessage;
     private _onCustomData;
     private _onRecordInfo;
+    private _onAsrInfo;
     private _onRolesChanged;
     /**
      * Клиент должен немедленно выключить микрофон и/или камеру
@@ -312,6 +331,13 @@ export default class Conversation extends EventEmitter {
     private _updateDisplayLayoutFromCache;
     private _setParticipantsStatus;
     private _onJoinLinkChanged;
+    private _onRoomsUpdated;
+    private _onRoomUpdated;
+    private _convertRoomToExternal;
+    private _onRoomParticipantsUpdated;
+    /** получили из сингналинга сообщение о реакции пользователей */
+    private _onFeedback;
+    private _isMe;
 }
 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 '../classes/screenshare/SharingStatReport';
 import { ParticipantIdRegistry } from './ParticipantIdRegistry';
 import { PerfStatReport } from './transport/PerfStatReporter';
 export declare class ProducerCommandSerializationService {
@@ -11,6 +12,7 @@ export declare class ProducerCommandSerializationService {
     private writeLayout;
     private writeStreamDesc;
     serializePerfStatReport(sequenceNumber: number, report: PerfStatReport): ArrayBuffer;
+    serializeSharingStatReport(sequenceNumber: number, report: SharingStatReport): ArrayBuffer;
     deserializeCommandResponse(data: BufferSource | Blob): Promise<SignalingMessage | undefined>;
     private deserializeUpdateDisplayLayoutResponse;
     private deserializeReportPerfStatResponse;

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

@@ -33,6 +33,7 @@ export default class ServerTransport extends EventEmitter {
     private _disabledSenders;
     private _rtpReceiversByStreamId;
     private _producerSessionId;
+    private _newAudioShareTrack;
     constructor(signaling: BaseSignaling, mediaSource: MediaSource, serverSettings: ServerSettings);
     getState(): TransportState;
     updateStatisticsInterval(): void;
@@ -68,6 +69,7 @@ export default class ServerTransport extends EventEmitter {
     private _detectStaleTracks;
     private _allocateConsumer;
     private _acceptProducer;
+    private handleTracks;
     _onSignalingNotification(message: SignalingMessage): Promise<void>;
     private _onProducerUpdated;
     private _onAddTrack;

package/default/Api.d.ts

@@ -16,8 +16,12 @@ export default class Api extends BaseApi {
     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<{
@@ -27,7 +31,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/Signaling.d.ts

@@ -2,6 +2,7 @@ import BaseSignaling, { AddParticipantParams } from '../abstract/BaseSignaling';
 import { ParticipantIdRegistry } from '../classes/ParticipantIdRegistry';
 import { PerfStatReport } from '../classes/transport/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';
@@ -11,13 +12,14 @@ import UserRole from '../enums/UserRole';
 import { JSONObject } from '../static/Json';
 import MediaModifiers from '../types/MediaModifiers';
 import MediaSettings from '../types/MediaSettings';
-import { IAddMovieParams, ISharedMovieState } from '../types/MovieShare';
+import { IAddMovieParams, IUpdateMovieData } from '../types/MovieShare';
 import MuteStates from '../types/MuteStates';
 import { CompositeUserId, ParticipantId } from '../types/Participant';
 import ParticipantLayout, { RequestKeyFrame, StopStream } from '../types/ParticipantLayout';
 import { ParticipantListChunkParameters } from '../types/ParticipantListChunk';
 import SignalingMessage from '../types/SignalingMessage';
 import { WaitingParticipantId } from '../types/WaitingHall';
+import { SharingStatReport } from '../classes/screenshare/SharingStatReport';
 export default class Signaling extends BaseSignaling {
     private socket;
     protected sequence: number;
@@ -98,8 +100,12 @@ export default class Signaling extends BaseSignaling {
         [streamDesc: string]: ParticipantLayout | StopStream | RequestKeyFrame;
     }): Promise<SignalingMessage>;
     addMovie(data: IAddMovieParams): Promise<SignalingMessage>;
-    updateMovie(data: ISharedMovieState): Promise<SignalingMessage>;
+    updateMovie(data: IUpdateMovieData): Promise<SignalingMessage>;
     removeMovie(data: any): Promise<SignalingMessage>;
+    updateRooms(rooms: SignalingMessage.Room[], assignRandomly: boolean): Promise<SignalingMessage>;
+    activateRooms(roomIds: number[], deactivate: boolean): Promise<SignalingMessage>;
+    switchRoom(toRoomId?: number, participantId?: ParticipantId): Promise<SignalingMessage>;
+    removeRooms(roomIds: number[]): Promise<SignalingMessage>;
     startStream(data: any): Promise<SignalingMessage>;
     stopStream(): Promise<SignalingMessage>;
     recordSetRole(participantId: ParticipantId, role: RecordRole | null): Promise<SignalingMessage>;
@@ -107,11 +113,13 @@ export default class Signaling extends BaseSignaling {
     switchTopology(topology: TransportTopology, force?: boolean): Promise<SignalingMessage>;
     requestRealloc(): Promise<SignalingMessage>;
     reportPerfStat(report: PerfStatReport): Promise<SignalingMessage>;
+    reportSharingStat(report: SharingStatReport): Promise<SignalingMessage>;
     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>;
     muteParticipant(participantId: ParticipantId | null, muteStates: MuteStates, requestedMedia: MediaOption[]): Promise<SignalingMessage>;
+    enableFeatureForRoles(feature: ConversationFeature, roles: UserRole[]): Promise<SignalingMessage>;
     pinParticipant(participantId: ParticipantId, unpin: boolean): Promise<SignalingMessage>;
     updateMediaModifiers(mediaModifiers: MediaModifiers): Promise<SignalingMessage>;
     changeOptions(changes: {
@@ -119,6 +127,7 @@ 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>;
+    feedback(key: string): Promise<SignalingMessage>;
     /**
      * Close a connection with a signaling server
      */
@@ -132,6 +141,8 @@ export default class Signaling extends BaseSignaling {
     readyToSend(): void;
     getParticipantListChunk(participantListChunkParameters: ParticipantListChunkParameters): Promise<SignalingMessage>;
     getParticipants(externalIds: SignalingMessage.ExternalId[]): Promise<SignalingMessage>;
+    startAsr(): Promise<SignalingMessage>;
+    stopAsr(): Promise<SignalingMessage>;
     protected _connect(connectionType: SignalingConnectionType): void;
     protected _disconnect(): void;
     private _onOpen;

package/enums/ConversationFeature.d.ts

@@ -1,5 +1,6 @@
 declare const enum ConversationFeature {
     ADD_PARTICIPANT = "ADD_PARTICIPANT",
-    RECORD = "RECORD"
+    RECORD = "RECORD",
+    MOVIE_SHARE = "MOVIE_SHARE"
 }
 export default ConversationFeature;

package/enums/ConversationOption.d.ts

@@ -5,7 +5,8 @@ declare enum ConversationOption {
     REQUIRE_AUTH_TO_JOIN = "REQUIRE_AUTH_TO_JOIN",
     AUDIENCE_MODE = "AUDIENCE_MODE",
     WAITING_HALL = "WAITING_HALL",
-    ASR = "ASR"
+    ASR = "ASR",
+    FEEDBACK = "FEEDBACK"
 }
 export default ConversationOption;
 export declare function compareOptions(oldOptions: ConversationOption[], newOptions: ConversationOption[]): boolean;

package/enums/LiveStatus.d.ts

@@ -0,0 +1,7 @@
+declare enum LiveStatus {
+    NOT_DEFINED = -1,
+    WAITING = 0,
+    ONLINE = 1,
+    ENDED = 2
+}
+export default LiveStatus;

package/enums/MediaOption.d.ts

@@ -4,6 +4,8 @@
 declare enum MediaOption {
     AUDIO = "AUDIO",
     VIDEO = "VIDEO",
-    SCREEN_SHARING = "SCREEN_SHARING"
+    SCREEN_SHARING = "SCREEN_SHARING",
+    MOVIE_SHARING = "MOVIE_SHARING",
+    AUDIO_SHARING = "AUDIO_SHARING"
 }
 export default MediaOption;

package/enums/RoomsEventType.d.ts

@@ -0,0 +1,6 @@
+declare enum RoomsEventType {
+    UPDATE = "UPDATE",
+    REMOVE = "REMOVE",
+    ACTIVATE = "ACTIVATE"
+}
+export default RoomsEventType;

package/enums/SignalingCommandType.d.ts

@@ -12,6 +12,7 @@ declare enum SignalingCommandType {
     CHANGE_STREAM_PRIORITIES = "change-streams-priorities",
     UPDATE_DISPLAY_LAYOUT = "update-display-layout",
     REPORT_PERF_STAT = "report-perf-stat",
+    REPORT_SHARING_STAT = "report-sharing-stat",
     RECORD_START = "record-start",
     RECORD_STOP = "record-stop",
     RECORD_SET_ROLE = "record-set-role",
@@ -24,6 +25,7 @@ declare enum SignalingCommandType {
     CUSTOM_DATA = "custom-data",
     GRANT_ROLES = "grant-roles",
     MUTE_PARTICIPANT = "mute-participant",
+    ENABLE_FEATURE_FOR_ROLES = "enable-feature-for-roles",
     PIN_PARTICIPANT = "pin-participant",
     UPDATE_MEDIA_MODIFIERS = "update-media-modifiers",
     CHANGE_OPTIONS = "change-options",
@@ -34,6 +36,15 @@ declare enum SignalingCommandType {
     REQUEST_TEST_MODE = "request-test-mode",
     ADD_MOVIE = "add-movie",
     UPDATE_MOVIE = "update-movie",
-    REMOVE_MOVIE = "remove-movie"
+    REMOVE_MOVIE = "remove-movie",
+    GET_ROOMS = "get_rooms",
+    GET_ROOM = "get_room",
+    UPDATE_ROOMS = "update-rooms",
+    ACTIVATE_ROOMS = "activate-rooms",
+    REMOVE_ROOMS = "remove-rooms",
+    SWITCH_ROOM = "switch-room",
+    FEEDBACK = "feedback",
+    ASR_START = "asr-start",
+    ASR_STOP = "asr-stop"
 }
 export default SignalingCommandType;

package/enums/SignalingNotification.d.ts

@@ -36,9 +36,16 @@ declare enum SignalingNotification {
     CHAT_ROOM_UPDATED = "chat-room-updated",
     PROMOTION_APPROVED = "promotion-approved",
     JOIN_LINK_CHANGED = "join-link-changed",
+    FEEDBACK = "feedback",
     MOVIE_UPDATE_NOTIFICATION = "movie-update-notification",
     MOVIE_SHARE_INFO = "movie-share-info",
     MOVIE_SHARE_STARTED = "movie-share-started",
-    MOVIE_SHARE_STOPPED = "movie-share-stopped"
+    MOVIE_SHARE_STOPPED = "movie-share-stopped",
+    ROOM_UPDATED = "room-updated",
+    ROOMS_UPDATED = "rooms-updated",
+    ROOM_PARTICIPANTS_UPDATED = "room-participants-updated",
+    FEATURES_PER_ROLE_CHANGED = "features-per-role-changed",
+    ASR_STARTED = "asr-started",
+    ASR_STOPPED = "asr-stopped"
 }
 export default SignalingNotification;

package/package.json

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