@hysc/meeting 5.0.116 → 5.0.118

package/dist/index.d.mts

@@ -0,0 +1,4099 @@
+import * as lodash_es from 'lodash-es';
+import BCClient, { BCUser, BloudStream, ShareMediaOptions, Player, AudioPlayer } from '@hysc/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { BoomError } from '@hysc/utils';
+export { Logger } from '@hysc/utils';
+import { StreamCustomInfo } from '@hysc/bloud/src/core/Room';
+
+interface IMessageInfo {
+    userId?: string;
+    message: string;
+    role?: string;
+    isLocal?: boolean;
+    avatar?: string;
+    nickName?: string;
+    sendTime?: number;
+    isMeetingNotice?: boolean;
+    to?: string | undefined;
+    isDanger?: boolean;
+    seq?: number;
+    failed?: boolean;
+}
+declare class BMMessageInfo {
+    userId?: any;
+    message: string;
+    time: string;
+    timeStamp: number;
+    role?: string;
+    isLocal?: boolean;
+    avatar?: any;
+    nickName?: any;
+    isMeetingNotice: boolean;
+    to: string | undefined;
+    isDanger: boolean | undefined;
+    seq: number | undefined;
+    failed: boolean | undefined;
+    constructor(props: IMessageInfo);
+}
+
+/**
+ * 内置 user id 类型
+ */
+ declare type UserId = number | string;
+/**
+ * 用户角色
+ */
+ declare type Role = 'anchor' | 'audience';
+/**
+ * 房间类型
+ */
+ declare type RoomType = 'big' | 'normal';
+/**
+ * 视频编码
+ */
+ declare type Codec = 'h264' | 'vp8';
+/**
+ * 音频编码
+ */
+ declare type AudioCodec = 'opus';
+/**
+ * 直播模式
+ */
+ declare type Mode = 'rtc' | 'live';
+/**
+ * MediaStreamTrack 类型
+ */
+ declare type TrackType = 'audio' | 'video';
+/**
+ * 视频 Profile 枚举
+ */
+ declare type VideoProfile = '120p' | '180p' | '240p' | '360p' | '480p' | '720p' | '1080p' | '1440p' | '4k';
+/**
+ * 音频 Profile 枚举
+ */
+ declare type AudioProfile = 'standard' | 'standard-stereo' | 'high' | 'high-stereo';
+/**
+ * 屏幕分享 Profile 枚举
+ */
+ declare type ScreenProfile = '480p' | '480p_2' | '720p' | '720p_2' | '1080p' | '1080p_2';
+/**
+ * 视频自适应模式
+ * motion 流畅模式
+ * detail & text 清晰模式
+ * ‘’ 平衡模式
+ */
+ declare type VideoHint = '' | 'motion' | 'detail' | 'text';
+/**
+ * 音频自适应模式
+ * speech 演讲模式
+ * speech-recognition 语音识别模式
+ * music 音乐模式
+ * ‘’ 平衡模式
+ */
+ declare type AudioHint = '' | 'speech' | 'speech-recognition' | 'music';
+/**
+ * 设备接口
+ */
+declare interface Device {
+    /**
+     * 设备标识
+     */
+    deviceId: string;
+    /**
+     * 设备分组 id，来自同一个硬件的两个设备具有相同的 groupId
+     */
+    groupId: string;
+    /**
+     * 设备索引
+     */
+    index: number;
+    /**
+     * 设备名称
+     */
+    name: string;
+    /**
+     * 设备类型
+     */
+    kind: 'videoinput' | 'audioinput' | 'audiooutput';
+    /**
+     * 是否是系统默认设备
+     */
+    default: boolean;
+}
+/**
+ * 大流还是小流
+ */
+ declare type StreamSimulcastType = 'small' | 'big';
+/**
+ * 主流还是辅流
+ */
+ declare type StreamType$1 = 'main' | 'assist';
+declare module logger {
+  /**
+   * debug 级别
+   */
+  export  const DEBUG = 1;
+  /**
+   * info 级别
+   */
+  export  const INFO = 2;
+  /**
+   * info 级别
+   */
+  /**
+   * warn 级别
+   */
+  export  const WARN = 3;
+  /**
+   * error 级别
+   */
+  export  const ERROR = 4;
+  /**
+   * 关闭所有日志
+   */
+  export  const CLOSE = 5;
+  /**
+   * fatal 级别
+   * @internal
+   */
+  export  const FATAL = 6;
+  /**
+   * 设置日志输出级别
+   *
+   * @param level 日志输出级别
+   */
+  export  function setLevel(level: number): void;
+  /**
+   * 打印 debug 日志
+   *
+   * @param msg 日志内容
+   */
+  export  function debug(msg: string, tag?: string, userId?: UserId, args?: any[]): void;
+  /**
+   * 打印 info 日志
+   *
+   * @param msg 日志内容
+   */
+  export  function info(msg: string, tag?: string, userId?: UserId, args?: any[]): void;
+  /**
+   * 打印 call 日志
+   *
+   * @param msg
+   * @param args
+   */
+  /**
+   * 打印 warn 日志
+   *
+   * @param msg 日志内容
+   */
+  export  function warn(msg: string, tag?: string, userId?: UserId, args?: any[]): void;
+  /**
+   * 打印 error 日志
+   *
+   * @param msg 日志内容
+   */
+  export  function error(msg: string, tag?: string, userId?: UserId, args?: any[]): void;
+  /**
+   * 致命错误，中断程序
+   *
+   * @param msg 日志内容
+   */
+  export  function fatal(code: number, name?: string, message?: string): void;
+  /**
+   * 打开日志上传
+   *
+   */
+  export  function enableUploadLog(): void;
+  /**
+   * 关闭日志上传
+   *
+   */
+  export  function disableUploadLog(): void;
+  export  const LogMap: {
+      1: typeof debug;
+      2: typeof info;
+      3: typeof warn;
+      4: typeof error;
+  };
+}
+declare module ClientEvents {
+  /**
+   * 远端流添加事件，当远端用户发布流后会收到该通知
+   * ```javascript
+   * client.on('stream-added', event => {
+   *   const remoteStream = event.stream;
+   * });
+   * ```
+   */
+  export  const STREAM_ADDED = "stream-added";
+  /**
+   * 远端流移除事件，当远端用户取消发布流后会收到该通知。
+   * ```javascript
+   * client.on('stream-removed', event => {
+   *   const remoteStream = event.stream;
+   * });
+   * ```
+   */
+  export  const STREAM_REMOVED = "stream-removed";
+  /**
+   * 远端流更新事件，当远端用户添加、移除或更换音视频轨道后会收到该通知
+   * ```javascript
+   * client.on('stream-updated', event => {
+   *   const remoteStream = event.stream;
+   * });
+   * ```
+   */
+  export  const STREAM_UPDATED = "stream-updated";
+  /**
+   * 本地流推流成功事件，调用 publish() 成功后会触发该事件
+   * ```javascript
+   * client.on('stream-published', event => {
+   *   const localStream = event.stream;
+   * });
+   * ```
+   */
+  export  const STREAM_PUBLISHED = "stream-published";
+  /**
+   * 远端流订阅成功事件，调用 subscribe() 成功后会触发该事件
+   * ```javascript
+   * client.on('stream-subscribed', event => {
+   *   const remoteStream = event.stream;
+   * });
+   * ```
+   */
+  export  const STREAM_SUBSCRIBED = "stream-subscribed";
+  /**
+   * 远端用户禁用视频通知
+   * ```javascript
+   * client.on('mute-video', event => {
+   *   const stream = event.stream;
+   * });
+   * ```
+   */
+  export  const MUTE_VIDEO = "mute-video";
+  /**
+   * 远端用户取消禁用视频通知
+   * ```javascript
+   * client.on('unmute-video', event => {
+   *   const stream = event.stream;
+   * });
+   * ```
+   */
+  export  const UNMUTE_VIDEO = "unmute-video";
+  /**
+   * 远端用户禁用音频通知
+   * ```javascript
+   * client.on('mute-audio', event => {
+   *   const stream = event.stream;
+   * });
+   * ```
+   */
+  export  const MUTE_AUDIO = "mute-audio";
+  /**
+   * 远端用户取消禁用音频通知
+   * ```javascript
+   * client.on('mute-audio', event => {
+   *   const stream = event.stream;
+   * });
+   * ```
+   */
+  export  const UNMUTE_AUDIO = "unmute-audio";
+  /**
+   * 客户端错误事件，当出现不可恢复错误后 Client 会通过该事件上报
+   * ```javascript
+   * client.on('error', error => {
+   *   console.error('client error observed: ' + error);
+   *   const errorCode = error.getCode();
+   *   // 当出现客户端错误后，请调用 client.leave() 退房并尝试通过 client.join() 重新进房恢复通话。
+   * });
+   * ```
+   */
+  export  const ERROR = "error";
+  /**
+   * 用户进入房间通知
+   * ```javascript
+   * client.on('peer-joined', event => {
+   *   const userId = event.userId;
+   * });
+   * ```
+   */
+  export  const PEER_JOINED = "peer-joined";
+  /**
+   * 用户退出房间通知
+   * ```javascript
+   * client.on('peer-leaved', event => {
+   *   const userId = event.userId;
+   * });
+   * ```
+   */
+  export  const PEER_LEAVED = "peer-leaved";
+  /**
+   * client 被踢出房间通知，其他端以相同的 user_id 进入了房间
+   * ```javascript
+   * client.on('client-banned', () => {
+   *   console.log('你已被踢出！');
+   * });
+   * ```
+   */
+  export  const CLIENT_BANNED = "client-banned";
+  /**
+   * 用户被踢出房间通知，被管理员踢出
+   * ```javascript
+   * client.on('user-kicked', () => {
+   *   console.log('你已被踢出！');
+   * });
+   * ```
+   */
+  export  const USER_KICKED = "user-kicked";
+  /**
+   * token 即将过期
+   * ```javascript
+   * client.on('token-will-expire', () => {
+   *   console.log('你的 token 即将过期，请更新 token');
+   * });
+   * ```
+   */
+  export  const TOKEN_WILL_EXPIRE = "token-will-expire";
+  /**
+   * token 过期
+   * ```javascript
+   * client.on('token-expire', () => {
+   *   console.log('你的 token 已经过期，已自动退出房间');
+   * });
+   * ```
+   */
+  export  const TOKEN_EXPIRE = "token-expire";
+  /**
+   * 房间关闭
+   * ```javascript
+   * client.on('room-closed', () => {
+   *   console.log('房间已关闭，已自动退出');
+   * });
+   * ```
+   */
+  export  const ROOM_CLOSED = "room-closed";
+  /**
+   * 房间自动同步完成
+   * ```javascript
+   * client.on('sync-room-completed', () => {
+   *   console.log('房间自动同步完成');
+   * });
+   * ```
+   */
+  export  const SYNC_ROOM_COMPLETED = "sync-room-completed";
+}
+declare module StreamEvents {
+  /**
+   * videoTrack end 事件
+   * ```javascript
+   * stream.on('video-track-ended', () => {
+   *   console.log(`stream ${stream.getUserId()} video-track-ended`);
+   *  });
+   * ```
+   */
+  export  const VIDEO_TRACK_ENDED = "video-track-ended";
+  /**
+   * audioTrack end 事件
+   * ```javascript
+   * stream.on('audio-track-ended', () => {
+   *   console.log(`stream ${stream.getUserId()} audio-track-ended`);
+   *  });
+   * ```
+   */
+  export  const AUDIO_TRACK_ENDED = "audio-track-ended";
+  /**
+   * videoTrack mute 事件
+   * ```javascript
+   * stream.on('video-track-mute', () => {
+   *   console.log(`stream ${stream.getUserId()} video-track-mute`);
+   *  });
+   * ```
+   */
+  export  const VIDEO_TRACK_MUTE = "video-track-mute";
+  /**
+   * audioTrack mute 事件
+   * ```javascript
+   * stream.on('audio-track-mute', () => {
+   *   console.log(`stream ${stream.getUserId()} audio-track-mute`);
+   *  });
+   * ```
+   */
+  export  const AUDIO_TRACK_MUTE = "audio-track-mute";
+  /**
+   * videoTrack unmute 事件
+   * ```javascript
+   * stream.on('video-track-unmute', () => {
+   *   console.log(`stream ${stream.getUserId()} video-track-unmute`);
+   *  });
+   * ```
+   */
+  export  const VIDEO_TRACK_UNMUTE = "video-track-unmute";
+  /**
+   * audioTrack unmute 事件
+   * ```javascript
+   * stream.on('audio-track-unmute', () => {
+   *   console.log(`stream ${stream.getUserId()} audio-track-unmute`);
+   *  });
+   * ```
+   */
+  export  const AUDIO_TRACK_UNMUTE = "audio-track-unmute";
+  /**
+   * audioTrack unmute 事件
+   * ```javascript
+   * stream.on('audio-track-unmute', () => {
+   *   console.log(`stream ${stream.getUserId()} audio-track-unmute`);
+   *  });
+   * ```
+   */
+  /**
+   * track update 事件
+   * ```javascript
+   * stream.on('track-update', (event, data: {type: 'audio' | 'video', track: MediaStreamTrack}) => {
+   *   console.log(`stream ${stream.getUserId()} track-update`);
+   *  });
+   * ```
+   */
+  export  const TRACK_UPDATE = "track-update";
+  /**
+   * Audio/Video Player 状态变化事件 App 可根据状态变化来更新 UI，比如，通过监听 video player 状态变化来关闭或打开遮板
+   * ```javascript
+   * stream.on('player-state-changed', (event) => {
+   *   console.log(`${event.type} player is ${event.state} because of ${event.reason}`);
+   *  });
+   * ```
+   */
+  export  const PLAYER_STATE_CHANGED = "player-state-changed";
+  /**
+   * pc 连接错误，需要重新推拉流
+   * ```javascript
+   * stream.on('connect-error', event => {
+   *   console.error('stream pc connect error');
+   *   if (stream.isLocalStream()) {
+   *      client.publish(stream)
+   *   }
+   *   else {
+   *      client.subscribe(stream)
+   *   }
+   * });
+   * ```
+   */
+  export  const CONNECT_ERROR = "connect-error";
+  /**
+   * pc 连接成功
+   * ```javascript
+   * stream.on('connect-success', event => {
+   *   console.info('stream pc connect success');
+   * });
+   * ```
+   */
+  export  const CONNECT_SUCCESS = "connect-success";
+  /**
+   * pc 重连
+   * ```javascript
+   * stream.on('connect-reconnecting', event => {
+   *   console.info('stream pc connect reconnecting');
+   * });
+   * ```
+   */
+  export  const CONNECT_RECONNECTING = "connect-reconnecting";
+  /**
+   *  video 首帧渲染
+   * ```javascript
+   * stream.on('player-video-rendered', event => {
+   *    // 移除加载动画
+   * });
+   * ```
+   */
+  export  const PLAYER_VIDEO_RENDERED = "player-video-rendered";
+  /**
+   * audio 首帧渲染
+   * ```javascript
+   * stream.on('player-audio-rendered', event => {
+   *   // 移除加载动画
+   * });
+   * ```
+   */
+  export  const PLAYER_AUDIO_RENDERED = "player-audio-rendered";
+  /**
+   * audio 音量
+   * ```javascript
+   * stream.on('audio-level', event => {
+   *   // 移除加载动画
+   * });
+   * ```
+   */
+  export  const AUDIO_LEVEL = "audio-level";
+  /**
+   * 流销毁关闭
+   * ```javascript
+   * stream.on('close', event => {
+   * });
+   * ```
+   */
+  export  const CLOSE = "close";
+}
+ declare class RTCError extends Error {
+    /**
+     * 获取错误码
+     *
+     * @returns 错误码
+     */
+    getCode(): number;
+}
+/**
+ * 创建本地流配置项
+ */
+declare interface StreamDeviceOption {
+    /**
+     * 流类型，主流还是辅流，vloud 底层使用
+     */
+    type?: StreamType$1;
+
+  /**
+   * 流来源类型
+   */
+  sourceType: 'camera' | 'screen' | 'file'
+    /**
+     * 是否有视频
+     */
+    video?: boolean;
+    /**
+     * 是否有音频
+     */
+    audio?: boolean;
+    /**
+     * 是否是屏幕分享
+     */
+    screen?: boolean;
+    /**
+     * 麦克风设备标识
+     */
+    microphoneId?: string;
+    /**
+     * 摄像头设备标识
+     */
+    cameraId?: string;
+    /**
+     * 自定义音频源
+     */
+    audioSource?: MediaStreamTrack;
+    /**
+     * 自定义视频源
+     */
+    videoSource?: MediaStreamTrack;
+    /**
+     * 是否开启回声消除
+     */
+    echoCancellation?: boolean;
+    /**
+     * 是否开启自动增益
+     */
+    autoGainControl?: boolean;
+    /**
+     * 是否开启自动降噪
+     */
+    noiseSuppression?: boolean;
+    /**
+     * 自适应策略
+     * https://www.w3.org/TR/mst-content-hint/#video-content-hints
+     */
+    videoHint?: VideoHint;
+    /**
+     * 自适应策略
+     * https://www.w3.org/TR/mst-content-hint/#audio-content-hints
+     */
+    audioHint?: AudioHint;
+}
+declare interface StreamPlayOption {
+    /**
+     * video fit 类型
+     */
+    fit?: 'cover' | 'contain';
+    /**
+     * 静音播放
+     */
+    muted?: boolean;
+    /**
+     * 水平旋转
+     */
+    rotateX?: number;
+    /**
+     * 垂直旋转
+     */
+    rotateY?: number;
+    /**
+     * 背景颜色
+     */
+    backgroundColor?: string;
+
+    audio?: boolean
+}
+/**
+ * LocalStream stats 接口
+ */
+declare interface LocalStreamStats {
+    /**
+     * 视频丢包数
+     */
+    videoPacketsLost?: number;
+    /**
+     * 音频丢包数
+     */
+    audioPacketsLost?: number;
+    /**
+     * 视频发送字节数
+     */
+    videoBytesSent?: number;
+    /**
+     * 视频包发送数
+     */
+    videoPacketsSent?: number;
+    /**
+     * 音频发送字节数
+     */
+    audioBytesSent?: number;
+    /**
+     * 音频包发送数
+     */
+    audioPacketsSent?: number;
+    /**
+     * 视频宽度
+     */
+    width?: number;
+    /**
+     * 视频高度
+     */
+    height?: number;
+    /**
+     * rtt 网络延时
+     */
+    rtt?: number;
+    /**
+     * 编码帧数
+     */
+    framesEncoded?: number;
+    /**
+     * 发送帧数
+     */
+    framesSent?: number;
+}
+/**
+ * RemoteStream stats 接口
+ */
+declare interface RemoteStreamStats {
+    /**
+     * 视频丢包数
+     */
+    videoPacketsLost?: number;
+    /**
+     * 音频丢包数
+     */
+    audioPacketsLost?: number;
+    /**
+     * 视频接收字节数
+     */
+    videoBytesReceived?: number;
+    /**
+     * 音频包接收数
+     */
+    videoPacketsReceived?: number;
+    /**
+     * 音频接收字节数
+     */
+    audioBytesReceived?: number;
+    /**
+     * 音频包接收数
+     */
+    audioPacketsReceived?: number;
+    /**
+     * 视频宽度
+     */
+    width?: number;
+    /**
+     * 视频高度
+     */
+    height?: number;
+    /**
+     * rtt 网络延时
+     */
+    rtt?: number;
+    /**
+     * 解码帧数
+     */
+    framesDecoded?: number;
+}
+declare interface StreamCodecOption {
+    /**
+     * 视频宽度
+     */
+    width?: number;
+    /**
+     * 视频高度
+     */
+    height?: number;
+    /**
+     * 视频帧率
+     */
+    frameRate?: number;
+    /**
+     * 音频码率
+     */
+    /**
+     * 视频码率
+     */
+    bitrate?: number;
+    /**
+     * 设置 h264 profile，默认 42e01f
+     */
+    profile?: string;
+}
+declare interface SmallStreamCodecOption {
+    /**
+     * 视频宽度
+     */
+    width?: number;
+    /**
+     * 视频高度
+     */
+    height?: number;
+    /**
+     * 视频码率
+     */
+    bitrate?: number;
+}
+ declare abstract class Stream {
+    /**
+     * 本地流标识
+     */
+    static readonly STREAM_TYPE_LOCAL = 0;
+    /**
+     * 远端流标识
+     */
+    static readonly STREAM_TYPE_REMOTE = 1;
+    /**
+     * 创建流实例
+     *
+     * @param type 流类型
+     * @param uid 用户 id
+     * @param unumber 用户 number
+     * @param webrtcType webrtc 底层类型
+     * @param stream 底层流对象
+     * @returns Stream
+     */
+    constructor(type: number, sid?: string, uid?: UserId, webrtcType?: number, stream?: any, subStream?: any);
+    /**
+     * 判断是否是本地流
+     *
+     * @returns boolean
+     */
+    isLocalStream(): boolean;
+    /**
+     * 是否是屏幕分享流
+     *
+     * @returns boolean
+     */
+    isScreenStream(): boolean;
+    /**
+     * 流是否正在播放
+     *
+     * @returns boolean
+     */
+    isPlaying(): boolean;
+    /**
+     * 获取 userId
+     *
+     * @returns number
+     */
+    getUserId(): UserId;
+    /**
+     * 获取 stream id
+     *
+     * @returns string
+     */
+    getStreamId(): string;
+    /**
+     * 是否有视频
+     *
+     * @returns boolean
+     */
+    hasVideo(): boolean;
+    /**
+     * 是否有音频
+     *
+     * @returns boolean
+     */
+    hasAudio(): boolean;
+    /**
+     * 获取流视频是否挂起
+     *
+     * @returns boolean
+     */
+    getVideoOn(): boolean;
+    /**
+     * 获取流音频是否挂起
+     *
+     * @returns boolean
+     */
+    getAudioOn(): boolean;
+    /**
+     * 音频轨道
+     */
+    get audioTrack(): MediaStreamTrack;
+    /**
+     * 视频轨道
+     */
+    get videoTrack(): MediaStreamTrack;
+    /**
+     * 获取音频轨道
+     *
+     * @returns MediaStreamTrack
+     */
+    getAudioTrack(): MediaStreamTrack;
+    /**
+     * 获取视频轨道
+     *
+     * @returns MediaStreamTrack
+     */
+    getVideoTrack(): MediaStreamTrack;
+    /**
+     * 获取 MediaStream 实例
+     *
+     * @returns MediaStream
+     */
+    getMediaStream(): MediaStream;
+    /**
+     * 禁用视频轨道
+     *
+     * - 对于本地流，调用该方法会停止发送视频，远端会触发 Client.on('mute-video') 事件
+     * - 如果视频是从摄像头采集，此时摄像头灯仍然是亮着的。若想完全禁用视频轨道（即关闭摄像头）
+     * - 可以使用 removeTrack() 删除视频轨道然后调用 MediaStreamTrack.stop() 关闭视频轨道（关闭摄像头）
+     * - 对于远端流，调用该方法会停止播放视频，但是仍然接收视频数据。
+     *
+     * @returns boolean 是否成功
+     */
+    muteVideo(): Promise<boolean>;
+    /**
+     * 启用视频轨道
+     *
+     * - 对于本地流，调用该方法会触发远端 Client.on('unmute-video') 事件。
+     * - 视频轨道默认是开启的，若你调用 muteVideo() 后可用该方法重新启用视频。
+     *
+     * @returns boolean 是否成功
+     */
+    unmuteVideo(): Promise<boolean>;
+    /**
+     * 禁用音频轨道
+     *
+     * - 对于本地流，调用该方法会停止发送音频，远端会触发 Client.on('mute-audio') 事件。
+     * - 对于远端流，调用该方法会停止播放音频，但是仍然接收音频数据。
+     *
+     * @returns boolean 是否成功
+     */
+    muteAudio(): Promise<boolean>;
+    /**
+     * 启用音频轨道
+     *
+     * - 对于本地流，调用该方法会触发远端 Client.on('unmute-audio') 事件。
+     * - 音频轨道默认是开启的，若你调用 muteAudio() 后可用该方法重新启用音频。
+     *
+     * @returns boolean 是否成功
+     */
+    unmuteAudio(): Promise<boolean>;
+    /**
+     * 播放流
+     *
+     * @param videoId 挂载 dom
+     * @param options 播放选项
+     *
+     * @returns any
+     */
+    play(videoId: string | HTMLDivElement, options?: StreamPlayOption): Promise<any>;
+    /**
+     * 重新播放流
+     *
+     * @returns any
+     */
+    replay(): Promise<void>;
+    /**
+     * 恢复播放音视频
+     *
+     * - 在某些版本浏览器上移动传入 play() 的 div 容器可能会导致音视频播放器进入 ‘PAUSED’ 状态，此时 需要调用该接口恢复播放。
+     * - 由于浏览器自动播放策略的限制，在 play() 返回 PLAY_NOT_ALLOWED 错误后需要引导用户通过手势 调用该接口恢复播放
+     *
+     * @returns any
+     */
+    resume(): Promise<any>;
+    /**
+     * 停止播放流
+     *
+     * @returns void
+     */
+    stop(): void;
+    /**
+     * 销毁音视频流
+     *
+     * @returns void
+     */
+    destroy(): void;
+    /**
+     * 获取流的麦克风音量
+     *
+     * @returns number
+     */
+    getAudioLevel(): number;
+    /**
+     * 提交事件
+     *
+     * @param type 事件类型
+     * @param data 事件数据
+     *
+     * @returns void
+     */
+    fire(type: string, data?: any): void;
+    /**
+     * 设置事件监听
+     * 支持链式调用
+     * 支持命名空间 `type.namespace`，使用 `.` 来分隔 `type` 和 `namespace`
+     *
+     * @param type 事件类型
+     * @param listener 监听函数
+     *
+     * @returns Stream
+     */
+    on(type: 'video-track-ended', listener: typeof stream_event_video_track_ended): this;
+    on(type: 'video-track-mute', listener: typeof stream_event_video_track_mute): this;
+    on(type: 'video-track-unmute', listener: typeof stream_event_video_track_unmute): this;
+    on(type: 'audio-track-ended', listener: typeof stream_event_audio_track_ended): this;
+    on(type: 'audio-track-mute', listener: typeof stream_event_audio_track_mute): this;
+    on(type: 'audio-track-unmute', listener: typeof stream_event_audio_track_unmute): this;
+    on(type: 'track-update', listener: typeof stream_event_track_update): this;
+    on(type: 'player-state-changed', listener: typeof stream_event_player_state_changed): this;
+    on(type: 'connect-error', listener: typeof stream_event_connect_error): this;
+    on(type: string, listener: Function): this;
+    /**
+     * 设置一次事件监听
+     * 支持链式调用
+     * 支持命名空间 `type.namespace`，使用 `.` 来分隔 `type` 和 `namespace`
+     *
+     * @param type 事件类型
+     * @param listener 监听函数
+     *
+     * @returns Stream
+     */
+    one(type: 'video-track-ended', listener: typeof stream_event_video_track_ended): this;
+    one(type: 'video-track-mute', listener: typeof stream_event_video_track_mute): this;
+    one(type: 'video-track-unmute', listener: typeof stream_event_video_track_unmute): this;
+    one(type: 'audio-track-ended', listener: typeof stream_event_audio_track_ended): this;
+    one(type: 'audio-track-mute', listener: typeof stream_event_audio_track_mute): this;
+    one(type: 'audio-track-unmute', listener: typeof stream_event_audio_track_unmute): this;
+    one(type: 'track-update', listener: typeof stream_event_track_update): this;
+    one(type: 'player-state-changed', listener: typeof stream_event_player_state_changed): this;
+    one(type: 'connect-error', listener: typeof stream_event_connect_error): this;
+    one(type: string, listener: Function): this;
+    /**
+     * 取消事件监听
+     * 支持链式调用
+     *
+     * @param type 事件类型或者命名空间
+     * - 如果传入命名空间则解绑此命名空间的所有回调
+     * - 如果不传则解绑所有设置过的回调
+     * @param listener 绑定函数
+     * - 如果不传则解绑指定 `type` 的所有回调，否则只解绑指定 `type` 和 `listener` 的回调
+     *
+     * @returns Stream
+     */
+    off(type?: string, listener?: Function): this;
+    /**
+     * 获取当前播放的扬声器设备 id
+     *
+     * @returns string
+     */
+    getAudioDeviceId(): string;
+    /**
+     * 获取当前播放音量
+     *
+     * @returns number
+     */
+    getAudioVolume(): number;
+    /**
+     * 截取当前流的一帧视频数据（base64 png），该方法需要在 play() 后调用，并且 Stream 中有视频流才有效
+     *
+     * @returns string
+     */
+    getVideoFrame(): string;
+    /**
+     * 获取流的传输信息
+     */
+    abstract getStats(): Promise<LocalStreamStats | RemoteStreamStats>;
+}
+/**
+ * 本地流对象
+ */
+ declare class LocalStream extends Stream {
+    /**
+     * 创建本地流实例
+     *
+     * @param options 配置项
+     *
+     * @returns 本地流实例
+     */
+    constructor(options: StreamDeviceOption, id?: string);
+    /**
+     * 是否是屏幕分享流
+     *
+     * @returns boolean
+     */
+    isScreenStream(): boolean;
+    /**
+     * 设置视频 profile
+     *
+     * - 该方法需要在调用 init() 之前调用。
+     *
+     * @param profile
+     *
+     * @returns void
+     */
+    setVideoProfile(profile: VideoProfile): void;
+    /**
+     * 设置屏幕分享 profile
+     *
+     * - 该方法需要在调用 init() 之前调用。
+     *
+     * @param profile
+     *
+     * @returns void
+     */
+    setScreenProfile(profile: ScreenProfile): void;
+    /**
+     * 设置音频 profile
+     *
+     * @description 该方法需要在调用 init() 之前调用。
+     *
+     * @param profile
+     *
+     * @returns void
+     */
+    setAudioProfile(profile: AudioProfile): void;
+    /**
+     * 设置自定义视频编码配置
+     *
+     * - 该方法可以根据需要灵活设置本地流的视频分辨率、帧率和码率。
+     * - 该方法需要在调用 init() 之前调用。
+     *
+     * @param options 配置项
+     *
+     * @returns void
+     */
+    setVideoEncoderConfiguration(options: StreamCodecOption): void;
+    /**
+     * 初始化 LocalStream 实例
+     *
+     * @returns any
+     */
+    init(): Promise<any>;
+    /**
+     * 添加音频或视频轨道
+     *
+     * - 调用该方法将音频或视频轨道添加到本地流，若该本地流已经被发布，则会自动更新发往远端的音视频流，此时远端会收到 Client.on('stream-updated') 事件通知。
+     * - 请注意，一个 Stream 对象中最多只能同时包含一路音频轨道和一路视频轨道。如果你想要更换同类型的轨道，请使用 replaceTrack()。
+     * - 新的音视频轨道可以通过 createStream()/getAudioTrack()|getVideoTrack() 获取， 或者直接通过 getUserMedia()、captureStream() 获取。
+     *
+     * @param track 媒体轨道
+     *
+     * @returns any
+     */
+    addTrack(track: MediaStreamTrack): Promise<any>;
+    /**
+     * 移除视频轨道
+     *
+     * - 调用该方法会移除本地流中的视频轨道，若本地流已经被发布，则会自动更新发往远端的视频流，此时远端会收到 Client.on('stream-updated') 事件通知。
+     * - 请注意，一个已经发布的 Stream 对象中至少要有一个媒体轨道，如果你想完全删除本地流中的音视频轨道，请直接通过 unpublish() 取消发布， 然后再通过 close() 关闭本地流。
+     *
+     * @param track 媒体轨道
+     *
+     * @returns any
+     */
+    removeTrack(track: MediaStreamTrack): Promise<any>;
+    /**
+     * 更换音频或视频轨道
+     *
+     * - 调用该方法更换本地流中的同类型轨道，若本地流已经被发布，该方法会自动更新发往远端的音视频流，此时远端会收到 Client.on('stream-updated') 事件通知。
+     * - 新的音视频轨道可以通过 createStream()/getAudioTrack()|getVideoTrack() 获取， 或者直接通过 getUserMedia()、captureStream() 获取。
+     * - 如果需要更换媒体输入设备，推荐使用 switchDevice()。
+     * - 在更换视频轨道时，要求视频分辨率跟 setVideoProfile() 设置保持一致，否则会抛出异常
+     * - 支持 Chrome 65+、Safari 浏览器
+     *
+     * @param track 媒体轨道
+     *
+     * @returns any
+     */
+    replaceTrack(track: MediaStreamTrack): Promise<any>;
+    /**
+     * 切换媒体输入设备
+     *
+     * - 调用该方法可更换本地流的媒体输入设备
+     *
+     * @param type 切换类型
+     * @param deviceId
+     *
+     * @returns any
+     */
+    switchDevice(type: TrackType, deviceId: string): Promise<any>;
+    /**
+     * 播放本地流
+     *
+     * @param videoId 挂载 dom
+     * @param options 播放选项
+     *
+     * @returns any
+     */
+    play(videoId: string | HTMLDivElement, options?: StreamPlayOption): Promise<any>;
+    /**
+     * 获取流的传输信息
+     *
+     * @returns LocalStreamStats
+     */
+    getStats(): Promise<LocalStreamStats>;
+    /**
+     * 发送 sei 消息
+     * - 单次最大发送 1KB(Byte)，每秒最大调用次数 30 次，每秒最多发送 8KB。
+     * - 目前仅支持 Chrome 86+, Edge 86+, Opera 72+ 浏览器。
+     * - 由于 SEI 跟随视频帧一起发送，视频帧有丢失的可能，因此 SEI 也可能丢失。
+     *   可在使用频次限制范围内，增加发送次数，业务侧需要在接收端做消息去重。
+     * - 没有推视频流时，无法发送 SEI；没有订阅视频流时，无法接收 SEI。
+     * - 仅支持 H264 编码器发送 SEI。
+     * - 小流暂不支持 SEI 收发。
+     * - 设置 SEI payload type。SDK 默认使用自定义 payloadType 243，业务侧可使用该参数将 payloadType 设置为标准的 5
+     *   当业务侧使用 5 payloadType 时，需按照规范确保 buffer 的前 16 字节是业务侧自定义的 uuid。
+     *
+     * @param buffer
+     * @param options
+     */
+    sendSEIMessage(buffer: ArrayBuffer, options: {
+        payloadType?: number;
+    }): void;
+}
+/**
+ * 远端流对象
+ */
+ declare class RemoteStream extends Stream {
+    /**
+     * 创建远端流
+     *
+     * @param uid 用户 id
+     * @param unumber 用户 number
+     * @param webrtcType 底层类型
+     * @param stream 底层流
+     *
+     * @returns RemoteStream
+     */
+    constructor(uid: number, webrtcType?: number, stream?: any, subStream?: any, sid?: string);
+    /**
+     * 是否已订阅流
+     *
+     * @returns boolean
+     */
+    isSubscribed(): boolean;
+    /**
+     * 设置输出扬声器设备
+     *
+     * @param deviceId 扬声器标识
+     *
+     * @returns any
+     */
+    setAudioOutput(deviceId: string): Promise<any>;
+    /**
+     * 设置播放音量
+     *
+     * @param volume 播放音量
+     * - 取值范围：[0, 1]
+     * - 默认 1
+     * @returns any
+     */
+    setAudioVolume(volume: number): void;
+
+    getType(): string;
+    /**
+     * 播放远端流
+     *
+     * @param videoId 挂载 dom
+     * @param options 播放选项
+     *
+     * @returns any
+     */
+    play(videoId: string | HTMLDivElement, options?: StreamPlayOption): Promise<any>;
+    /**
+     * 获取流的传输信息
+     *
+     * @returns RemoteStreamStats
+     */
+    getStats(): Promise<RemoteStreamStats>;
+}
+/**
+ *
+ * @returns void
+ */
+declare function stream_event_video_track_ended(): void;
+/**
+ *
+ * @returns void
+ */
+declare function stream_event_audio_track_ended(): void;
+/**
+ *
+ * @returns void
+ */
+declare function stream_event_video_track_mute(): void;
+/**
+ *
+ * @returns void
+ */
+declare function stream_event_audio_track_mute(): void;
+/**
+ *
+ * @returns void
+ */
+declare function stream_event_video_track_unmute(): void;
+/**
+ *
+ * @returns void
+ */
+declare function stream_event_audio_track_unmute(): void;
+/**
+ * track 更新
+ *
+ * @param event Object
+ * - type track 类型
+ * - track 更新 track
+ *
+ * @returns void
+ */
+declare function stream_event_track_update(event: {
+    type: TrackType;
+    track: MediaStreamTrack;
+}): void;
+/**
+ * 播放状态改变
+ *
+ * @param event Object
+ * - type track 类型
+ * - state 播放状态
+ * - reason 原因
+ *
+ * @returns void
+ */
+declare function stream_event_player_state_changed(event: {
+    type: TrackType;
+    state: 'PAUSE' | 'PLAYING' | 'STOPPED';
+    reason: string;
+}): void;
+/**
+ * pc 连接失败
+ *
+ * @returns void
+ */
+declare function stream_event_connect_error(): void;
+/**
+ * client join 参数配置
+ */
+declare interface JoinConfig {
+    role?: Role;
+}
+/**
+ * 创建 Client 参数
+ */
+declare interface ClientOptions {
+    /**
+     * 用户 appId
+     */
+    appId: string;
+    /**
+     * 视频编码类型，默认 h264，目前只支持 h264
+     */
+    codec?: Codec;
+    /**
+     * 音频编码类型，默认 opus，目前只支持 opus
+     */
+    audioCodec?: AudioCodec;
+    /**
+     * 直播模式，默认 rtc 模式，目前只支持 rtc 模式
+     */
+    mode?: Mode;
+    /**
+     * 数据上报自定义字段
+     * 长度小于 64 个字符，超过的会被截断
+     */
+    comments?: string;
+    /**
+     * 用户角色，默认 anchor（主播）
+     */
+    role?: Role;
+    /**
+     * 仅推流
+     */
+    publishOnly?: boolean;
+    /**
+     * 是否使用 string 作为 userId 类型
+     * - 默认 false userId 为 int32 类型
+     */
+    useStringUserId?: boolean;
+    /**
+     * 音量获取间隔，默认 1000，最大 10000
+     * 若需要更小间隔则设置此属性值
+     */
+    audioLevelInterval?: number;
+    /**
+     * 房间类型
+     * - 默认正常房间，正常房间有进房人数限制，进房退房会广播给其他人
+     * - 设置 'big' 不限制进房人数，但不推流的 user 将不广播进房通知
+     */
+    roomType?: RoomType;
+    /**
+     * 大房间广播模式，大房间下生效
+     * - true 不广播
+     * - false 广播（默认）
+     */
+    silence?: boolean;
+    enableSEI?: boolean;
+}
+/**
+ * 订阅流参数
+ */
+declare interface SubscribeOptions {
+    /**
+     * 是否订阅视频
+     */
+    video: boolean;
+    /**
+     * 是否订阅音频
+     */
+    audio: boolean;
+    /**
+     * 订阅流类型，大流还是小流，默认大流
+     */
+    streamType?: StreamSimulcastType;
+
+  videoEnable?: boolean
+
+  audioEnable?: boolean
+}
+/**
+ * Client 对象
+ */
+ declare class Client {
+    /**
+     * 创建 Client 对象
+     *
+     * @param options 配置项
+     *
+     * @returns Client 实例
+     */
+    constructor(options: ClientOptions);
+    /**
+     * 加入一个音视频通话房间
+     *
+     * - 进房代表开始一个音视频通话会话，这时候 SDK 会监听远端用户进房退房情况，若有远端用户进房并且发布流，本地会收到 'stream-added' 事件。
+     * - 进房后用户可以通过 publish() 发布本地流，本地流发布成功后远端用户就会收到相应 'stream-added' 事件通知从而完成一个双向的音视频通话连接。
+     *
+     * @param roomId 房间 id
+     * @param userId 用户 id
+     * @param sig 动态口令
+     *
+     * @returns any
+     */
+    join(roomId: string, userId: UserId, sig: string, joinConfig?: JoinConfig): Promise<any>;
+    /**
+     * 退出当前音视频通话房间，结束一次音视频通话会话。
+     *
+     * - 退房前请确保已经通过 unpublish() 取消发布本地流，若未取消发布本地流，SDK 内部会自动取消发布本地流。 同时，退房会关闭所有远端流。
+     *
+     * @param type 离开原因，不传表示主动离开
+     *
+     * @returns any
+     */
+    leave(type?: string): Promise<any>;
+    /**
+     * 发布本地音视频流。
+     *
+     * - 该方法需要在 join() 进房后调用，一次音视频会话中只能发布一个本地流。若想发布另外一个本地流，可先通过 unpublish() 取消发布当前本地流后再发布新的本地流。
+     * - 在发布本地流后，可通过 removeTrack()、addTrack()、 replaceTrack() 来更新本地流中的某个音频或视频流。
+     * - 发布本地流后远端会收到 ‘stream-added’ 事件通知。
+     *
+     * @param stream 创建的本地流对象
+     *
+     * @returns any
+     */
+    publish(stream: LocalStream): Promise<any>;
+    /**
+     * 取消发布本地流。
+     *
+     * - 取消发布本地流后远端会收到 'stream-removed' 事件通知。
+     * - 请在 leave() 退房前取消已经发布的本地流。
+     *
+     * @param stream 取消发布的本地流对象
+     *
+     * @returns any
+     */
+    unpublish(stream: LocalStream): Promise<any>;
+    /**
+     * 订阅远端流
+     *
+     * - 可通过该订阅接口指明需要订阅音频、视频或者音视频流。
+     *
+     * @param stream 需要订阅的远端流对象，由 ‘stream-added’ 事件获得
+     * @param options 订阅选项，默认音视频都订阅
+     *
+     * @returns any
+     */
+    subscribe(stream: RemoteStream, options?: SubscribeOptions): Promise<any>;
+    /**
+     * 取消订阅远端流
+     *
+     * @param stream 需要取消订阅的远端流对象，由 ‘stream-added’ 事件获得
+     *
+     * @returns any
+     */
+    unsubscribe(stream: RemoteStream): Promise<any>;
+    /**
+     * - 开启大小流
+     * - 在发送视频端开启大小流传输模式。双流为视频大流和视频小流，其中视频大流指高分辨率、高码率的视频流，视频小流指低分辨率、低码率的视频流
+     * - 必须在发布之前进行设置，原因是为了避免在发布后进行设置导致大小流表现不一致
+     * - 开启大小流传输模式后建议不要对双流进行 track 操作（包括 addTrack / removeTrack / replaceTrack），否则会导致大流和小流的表现不一致
+     */
+    enableSmallStream(): Promise<any>;
+    /**
+     * - 关闭大小流
+     * - 必须在发布前或者结束发布之后进行操作，原因是为了避免在发布后进行设置导致大小流表现不一致
+     */
+    disableSmallStream(): Promise<any>;
+    /**
+     * - 接收端选择订阅大流还是小流
+     * - 只能在订阅之后设置
+     *
+     * @param stream 远端流
+     *
+     * @param streamType
+     * -
+     * - big 大流（默认）
+     * - small 小流
+     */
+    setRemoteVideoStreamType(stream: RemoteStream, streamType: StreamSimulcastType): Promise<any>;
+    /**
+     * 设置小流推流参数
+     *
+     * @param profile
+     */
+    setSmallStreamProfile(profile: SmallStreamCodecOption): void;
+    /**
+     * 拉取 users
+     *
+     * hasMoreUser 是否还有更多 user 没有拉取到本地
+     *
+     * 新拉取的 user 会触发 stream-added 和 peer-joined 事件
+     *
+     * @param count
+     */
+    pullUsers(count: number): Promise<{
+        hasMoreUser: boolean;
+    }>;
+    /**
+     * 查找指定 users 的流
+     *
+     * 返回 RemoteStream 数组，如果查询的 user 没有推流则不会出现在数组中
+     *
+     * @param userIds
+     */
+    queryUsers(userIds: UserId[]): Promise<RemoteStream[]>;
+    /**
+     * 提交事件
+     *
+     * @param type 事件类型
+     * @param data 事件数据
+     *
+     * @returns void
+     */
+    fire(type: string, data?: any): void;
+    /**
+     * 设置一次事件监听
+     * 支持链式调用
+     * 支持命名空间 `type.namespace`，使用 `.` 来分隔 `type` 和 `namespace`
+     *
+     * @param type 事件类型
+     * @param listener 监听函数
+     *
+     * @returns Client
+     */
+    on(type: 'stream-added', listener: typeof client_event_stream_added): this;
+    on(type: 'stream-removed', listener: typeof client_event_stream_removed): this;
+    on(type: 'stream-updated', listener: typeof client_event_stream_updated): this;
+    on(type: 'stream-published', listener: typeof client_event_stream_published): this;
+    on(type: 'stream-subscribed', listener: typeof client_event_stream_subscribed): this;
+    on(type: 'mute-video', listener: typeof client_event_mute_video): this;
+    on(type: 'unmute-video', listener: typeof client_event_unmute_video): this;
+    on(type: 'mute-audio', listener: typeof client_event_mute_audio): this;
+    on(type: 'unmute-audio', listener: typeof client_event_unmute_audio): this;
+    on(type: 'error', listener: typeof client_event_error): this;
+    on(type: 'peer-joined', listener: typeof client_event_peer_joined): this;
+    on(type: 'peer-leaved', listener: typeof client_event_peer_leaved): this;
+    on(type: 'client-banned', listener: typeof client_event_client_banned): this;
+    on(type: 'user-kicked', listener: typeof client_event_user_kicked): this;
+    on(type: 'room-closed', listener: typeof client_event_room_closed): this;
+    on(type: string, listener: Function): this;
+    /**
+     * 设置一次事件监听
+     * 支持链式调用
+     * 支持命名空间 `type.namespace`，使用 `.` 来分隔 `type` 和 `namespace`
+     *
+     * @param type 事件类型
+     * @param listener 监听函数
+     *
+     * @returns Client
+     */
+    one(type: 'stream-added', listener: typeof client_event_stream_added): this;
+    one(type: 'stream-removed', listener: typeof client_event_stream_removed): this;
+    one(type: 'stream-updated', listener: typeof client_event_stream_updated): this;
+    one(type: 'stream-published', listener: typeof client_event_stream_published): this;
+    one(type: 'stream-subscribed', listener: typeof client_event_stream_subscribed): this;
+    one(type: 'mute-video', listener: typeof client_event_mute_video): this;
+    one(type: 'unmute-video', listener: typeof client_event_unmute_video): this;
+    one(type: 'mute-audio', listener: typeof client_event_mute_audio): this;
+    one(type: 'unmute-audio', listener: typeof client_event_unmute_audio): this;
+    one(type: 'error', listener: typeof client_event_error): this;
+    one(type: 'peer-joined', listener: typeof client_event_peer_joined): this;
+    one(type: 'peer-leaved', listener: typeof client_event_peer_leaved): this;
+    one(type: 'client-banned', listener: typeof client_event_client_banned): this;
+    one(type: 'user-kicked', listener: typeof client_event_user_kicked): this;
+    one(type: 'room-closed', listener: typeof client_event_room_closed): this;
+    one(type: string, listener: Function): this;
+    /**
+     * 取消事件监听
+     * 支持链式调用
+     *
+     * @param type 事件类型或者命名空间
+     * - 如果传入命名空间则解绑此命名空间的所有回调
+     * - 如果不传则解绑所有设置过的回调
+     * @param listener 绑定函数
+     * - 如果不传则解绑指定 `type` 的所有回调，否则只解绑指定 `type` 和 `listener` 的回调
+     *
+     * @returns Client
+     */
+    off(type?: string, listener?: Function): this;
+    /**
+     * 设置 client 只用于推流，一般用于推多路流的时候
+     * 设置主 client 为 false，辅 client 为 true
+     * 这样辅 client 只用于推流，只会触发 ’stream-published‘ 事件，所有的流由主 client 来订阅
+     *
+     * @param value 是否只推流
+     *
+     * @returns void
+     */
+    setPublishOnly(value: boolean): void;
+    /**
+     * 销毁 client 实例
+     *
+     * @param force 同步销毁，不等待异步返回
+     *
+     * @returns any
+     */
+    destroy(force: boolean): Promise<any>;
+}
+/**
+ * @param event Object
+ * - stream 远端流实例
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_stream_added(event: {
+    stream: RemoteStream;
+}): void | false;
+/**
+ * @param event Object
+ * - stream 远端流实例
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_stream_removed(event: {
+    stream: RemoteStream;
+}): void | false;
+/**
+ * @param event Object
+ * - stream 远端流实例
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_stream_updated(event: {
+    stream: RemoteStream;
+}): void | false;
+/**
+ * @param event Object
+ * - stream 本地流实例
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_stream_published(event: {
+    stream: LocalStream;
+}): void | false;
+/**
+ * @param event Object
+ * - stream 远端流实例
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_stream_subscribed(event: {
+    stream: RemoteStream;
+}): void | false;
+/**
+ * @param event Object
+ * - stream 远端流实例
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_mute_video(event: {
+    stream: RemoteStream;
+}): void | false;
+/**
+ * @param event Object
+ * - stream 远端流实例
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_unmute_video(event: {
+    stream: RemoteStream;
+}): void | false;
+/**
+ * @param event Object
+ * - stream 远端流实例
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_mute_audio(event: {
+    stream: RemoteStream;
+}): void | false;
+/**
+ * @param event Object
+ * - stream 远端流实例
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_unmute_audio(event: {
+    stream: RemoteStream;
+}): void | false;
+/**
+ * @param event Object
+ * - stream 远端流实例
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_error(error: RTCError): void | false;
+/**
+ * @param event Object
+ * - userId 用户 id
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_peer_joined(event: {
+    userId: UserId;
+}): void | false;
+/**
+ * @param event Object
+ * - userId 用户 id
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_peer_leaved(event: {
+    userId: UserId;
+}): void | false;
+/**
+ * @param event Object
+ * - userId 用户 id
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_client_banned(error: RTCError): void | false;
+/**
+ * @param event Object
+ * - userId 用户 id
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_user_kicked(error: RTCError): void | false;
+/**
+ * @param event Object
+ * - userId 用户 id
+ *
+ * @returns
+ * 返回 false 会停止触发后面监听的事件
+ */
+declare function client_event_room_closed(error: RTCError): void | false;
+declare type _Client = Client;
+declare type _LocalStream = LocalStream;
+declare type _RemoteStream = RemoteStream;
+declare type _Device = Device;
+declare type _ClientOptions = ClientOptions;
+
+declare namespace BRTC {
+    type Client = _Client;
+    type LocalStream = _LocalStream;
+    type RemoteStream = _RemoteStream;
+    type Device = _Device;
+    type ClientOptions = _ClientOptions;
+
+    const Logger: typeof logger;
+    const Events: {
+        Client: typeof ClientEvents;
+        Stream: typeof StreamEvents;
+    };
+    /**
+     * 创建本地流实例
+     *
+     * @param options 配置项
+     */
+    function createStream(options: StreamDeviceOption): LocalStream;
+    /**
+     * 创建 Client 实例
+     *
+     * @param options 配置项
+     */
+    function createClient(options: ClientOptions): Client;
+    /**
+     * 判断是否支持 BRTC
+     *
+     * @returns
+     */
+    function checkSystemSupport(): Promise<boolean>;
+    /**
+     * 设置环境
+     */
+    function setEnv(env: string): void;
+    /**
+     * 判断是否支持屏幕分享
+     *
+     * @returns
+     */
+    function supportScreenSharing(): boolean;
+    /**
+     * 判断是否支持大小流
+     *
+     * @returns
+     */
+    function isSmallStreamSupported(): boolean;
+    /**
+     * 获取设备权限
+     */
+    function getPermissions(): Promise<any>;
+    /**
+     * 枚举音频输入设备
+     *
+     * @returns 设备列表
+     */
+    function enumAudioInputDevices(): Promise<Device[]>;
+    /**
+     * 枚举音频输出设备
+     *
+     * @returns 设备列表
+     */
+    function enumAudioOutputDevices(): Promise<Device[]>;
+    /**
+     * 枚举视频输入设备
+     *
+     * @returns 设备列表
+     */
+    function enumVideoDevices(): Promise<Device[]>;
+    /**
+     * BRTC 版本号
+     */
+    const version: string;
+}
+
+/**
+ * @name: stream
+ * @author: yangliye
+ * @date: 2022-04-25 13:42
+ * @description：stream
+ * @update: 2022-04-25 13:42
+ */
+
+declare type SingleLocalStream = LocalStream;
+declare type SingleRemoteStream = RemoteStream;
+declare type SingleStream = SingleLocalStream | SingleRemoteStream;
+
+declare type UpdateMasterType = {
+    master?: BMUser;
+    oldMaster?: BMUser;
+};
+declare type audioOffWatcherValue = {
+    audioOff: boolean;
+    selfopenaudio: boolean;
+};
+
+/**
+ * @name: BMSpeaker
+ * @author: liuxinghai
+ * @date: 2022-06-07 11:41
+ * @description：BMSpeaker
+ *    适配 brtc 流对象到 bloud 流对象接口，
+ *    用户辅助采用 bloud SpeakerDetector 做说话人检测
+ * @date: 2022-06-07 11:41
+ */
+declare class BMSpeaker {
+    user: BMUser;
+    stream: SingleStream;
+    constructor(user: BMUser, stream: SingleStream);
+    /**
+     * 获取对象 ID 标识，此处使用流 ID 标识
+     * @returns
+     */
+    getID(): string;
+    /**
+     * 获取用户 BMUser 对象
+     * @returns
+     */
+    getUser(): BMUser;
+}
+
+/**
+ * @name: getHTMLMediaStreamOptions
+ * @author: yangliye
+ * @date: 2022-09-15 14:58
+ * @description：getHTMLMediaStreamOptions
+ * @update: 2022-09-15 14:58
+ */
+interface Options {
+    videoElement: HTMLVideoElement;
+}
+interface Result {
+    video: boolean;
+    audio: boolean;
+    videoSource: MediaStreamTrack;
+    audioSource: MediaStreamTrack;
+    width: number;
+    height: number;
+}
+/**
+ * 获取video标签中的mediaStream
+ * @param opts
+ */
+declare function getHTMLMediaStreamOptions(opts: Options): Result | null;
+declare function getMediaStreamInfo(mediaStream: MediaStream, videoInfo: {
+    width: number;
+    height: number;
+}): {
+    video: boolean;
+    audio: boolean;
+    videoSource: MediaStreamTrack;
+    audioSource: MediaStreamTrack;
+    width: number;
+    height: number;
+} | null;
+
+/**
+ * @name: SingletonQueue
+ * @author: yangliye
+ * @date: 2023-05-18 09:47
+ * @description：SingletonQueue
+ * @update: 2023-05-18 09:47
+ */
+declare type CallBack = (arg: Map<string, PullItem>, ...args: any) => void;
+declare type PullItem = {
+    id: string;
+    isScreen: boolean;
+    isWeb?: boolean;
+    force?: boolean;
+};
+declare class SingletonQueue {
+    private static instance;
+    private _callback;
+    private pullMap;
+    constructor();
+    addUsers(userIds: PullItem[]): void;
+    removeUsers(userId: PullItem[]): void;
+    restart(): void;
+    setQueueProcessor(callback: CallBack): void;
+    removeQueueProcessor(): void;
+}
+
+/**
+ * @name: emitter
+ * @author: yangliye
+ * @date: 2022-05-24 15:15
+ * @description：emitter
+ * @update: 2022-05-24 15:15
+ */
+
+declare type UserSortType = {
+    isCommon: boolean;
+    shouldDelay: boolean;
+};
+
+interface ChangeIsGuest {
+    user: BMUser;
+    preIsGuest: boolean;
+    isGuest: boolean;
+}
+declare class BMUserVM {
+    userList: Map<string, BMUser>;
+    audiencesList: Map<string, BMUser>;
+    signalList: Map<string, BMUser>;
+    commonUserList: Map<string, BMUser>;
+    boomCore: BCClient;
+    room: BMRoom;
+    userListWatcher: BehaviorSubject<BMUser[]>;
+    audiencesListWatcher: BehaviorSubject<BMUser[]>;
+    commonUserListWatcher: BehaviorSubject<BMUser[]>;
+    signalListWatcher: BehaviorSubject<BMUser[]>;
+    masterUserWatcher: BehaviorSubject<BMUser | null>;
+    getForceUserWatcher: BehaviorSubject<boolean>;
+    localUser: BMUser;
+    commTimer: number;
+    constructor(boomCore: BCClient, localUser: BMUser, room: BMRoom);
+    handleUserRoleChange(info: ChangeIsGuest): Promise<void>;
+    /**
+     * 添加用户, 并返回已添加的用户对象
+     * @param bcUser bcUser对象
+     */
+    addUser(bcUser: BCUser): BMUser | null;
+    /**
+     * 移除用户
+     * @param userId 用户id
+     */
+    removeUser(userId: string): boolean;
+    /**
+     * 获取用户视频开启状态
+     * @param userId 用户id
+     */
+    videoEnable(userId: string): boolean;
+    /**
+     * 获取用户音频开启状态
+     * @param userId
+     */
+    audioEnable(userId: string): boolean;
+    /**
+     * 检测用户是不是主持人
+     * @param {string} userId 用户id
+     */
+    checkIsMaster(userId: any): boolean;
+    /**
+     * 检测当前用户是否有主持人权限
+     */
+    checkLocalHasMaster(): boolean;
+    /**
+     * 检测目标用户是否有主持人权限
+     */
+    checkUserHasMaster(userId: string): boolean;
+    /**
+     * 根据用户id获取user对象
+     * @param {string} userId
+     */
+    getUser(userId: string): BMUser | undefined;
+    getAllUsers(pageIndex: number, allUsers: Map<string, BCUser>, permission?: string, useNew?: boolean): Promise<void>;
+    /**
+     * 刚加入房间时初始化人数
+     */
+    initUserList(usersInRoom: Map<string, BCUser>): Promise<void>;
+    addBcUsersMap(users: Map<string, BCUser>, forceGetStream?: boolean): void;
+    addBCUser: (bcUser: BCUser, forceGetStream?: boolean) => BMUser | null;
+    /**
+     * 改变userList中的主持人,返回改变后的主持人用户对象,该方法只在change-master中调用, 不对外暴露
+     * @param userId
+     * @param oldMasterId
+     * @param isKeep
+     */
+    updateMaster(userId: string, oldMasterId: string, isKeep: boolean): UpdateMasterType;
+    /**
+       * 联席主持人设置嘉宾的操作
+       * @param userId
+       */
+    managerChangeToGuest(userId: string): BMUser | undefined;
+    /**
+     * 改变联席主持人,返回设置为联席主持人的bmuser对象
+     * @param userId
+     * @param status true:设置成联席主持人 false:取消联席主持人身份
+     * @param hasS
+     * @returns
+     */
+    updateManager(userId: string, status: boolean, hasS?: boolean): BMUser;
+    /**
+     * 获取我自己
+     */
+    getLocalUser(): BMUser;
+    updateUser(bmUser: BMUser, bcUser: BCUser): void;
+    updateLocalUserPermission(permission: string): void;
+    /**
+     * bcUser变成BMUser
+     * @param bcUser
+     * @returns
+     */
+    toBMUser(bcUser: BCUser): BMUser;
+    private sortUsers;
+    private sortAudiences;
+    private sortCommonUsers;
+    private sortSignalUsers;
+    private static filterUsers;
+    /**
+     * 排序变化之后的处理逻辑
+     */
+    updateAllSort: () => void;
+    updateSortByType: (userType: UserSortType) => void;
+    updateUserSort: lodash_es.DebouncedFunc<() => void>;
+    updateCommonUserSort: lodash_es.DebouncedFunc<() => void>;
+    updateDelayCommonUserSort: lodash_es.DebouncedFunc<() => void>;
+    updateAudienceUserSort: () => void;
+    updateSignalUserSort: () => void;
+    /**
+     * 初始化所有的用户
+     */
+    initUsers(): Promise<void>;
+    /**
+     * 把bloud用户转化为当前的BMUser 和创建对应的BMStreamModel
+     * @param page
+     * @param permission
+     * @param useNew 是否使用getUsersList
+     */
+    transBloudUsers: (page: number, permission?: string, useNew?: boolean, failedNum?: number) => Promise<void>;
+    /**
+     * 本地嘉宾用户降级为普通参会者之后要取消拉流
+     */
+    handleUnSubCommonUser(): void;
+    handleCommonUserChange(): void;
+    getUsers(page: number, pageSize: number, permission?: string): Promise<{
+        userList: BMUser[];
+        total: number;
+    }>;
+    getUsersList(page: number, pageSize: number, permission?: string, waitRoom?: boolean): Promise<{
+        userList: BMUser[];
+        total: number;
+        pageIndex: number;
+    }>;
+    getTotalUserNumber(): Promise<number>;
+    clearUsers(): void;
+    /**
+     * 参会者列表搜索(嘉宾及以上才能搜索)
+     * @param searchTxt 搜索文本
+     * @param pageSize 一页几个
+     * @param waitRoom 是否是等候室用户
+     */
+    searchUsers(searchTxt: string, pageSize: number): Promise<{
+        userList: BMUser[];
+        commonUserList: BMUser[];
+    }>;
+    /**
+     * 查找等候室用户
+     * @param searchTxt
+     * @param pageSize
+     */
+    searchWaitRoomUsers(searchTxt: string, pageSize: number): Promise<BMUser[]>;
+}
+
+declare class BMChatVM {
+    messageList: Array<BMMessageInfo>;
+    boomCore: BCClient;
+    userVM: BMUserVM;
+    bmRoom: BMRoom;
+    messageListWatcher: BehaviorSubject<Array<BMMessageInfo>>;
+    hasDangerMessageWatcher: Subject<boolean>;
+    constructor(boomCore: BCClient, userVM: BMUserVM, bmRoom: BMRoom);
+    /**
+     * 发送聊天消息
+     * @param talkMsg 聊天信息
+     */
+    sendMessage(talkMsg: string, userId: string | undefined, lostNet: boolean): Promise<void>;
+    addMessage(info: BMMessageInfo, isParticipantNotice: boolean): void;
+    notificationMessageList: lodash_es.DebouncedFunc<() => void>;
+    updateMessageListWatcher(messageList: Array<BMMessageInfo>): void;
+    /**
+     * 获取历史消息
+     */
+    getHistoryMessage(): Promise<BMMessageInfo[]>;
+}
+
+interface BloudStreamEventState {
+    userId: string;
+    streamId: string;
+    isScreen: boolean;
+    video: boolean;
+    audio: boolean;
+    customInfo?: StreamCustomInfo;
+}
+interface BloudStreamState {
+    video: boolean;
+    audio: boolean;
+    isScreen: boolean;
+    customInfo?: StreamCustomInfo;
+}
+
+declare class BMStreamModelVM {
+    streamModels: Map<string, BMStreamModel>;
+    /**
+     * 因为投屏码用户进来以后，他是不在小窗口展示的，所以要把投屏的用户过滤掉给业务的展示
+     */
+    streamModelsWatcher: BehaviorSubject<BMStreamModel[]>;
+    shareStreamModels: Map<string, BMStreamModel>;
+    shareStreamModelsWatcher: BehaviorSubject<BMStreamModel[]>;
+    localStreamErrorWatcher: Subject<string>;
+    localModel: BMStreamModel | null;
+    room: BMRoom | null;
+    bloudStream: BloudStream | null;
+    brtcStream: SingleLocalStream | undefined;
+    /**
+     * 后面打开摄像头存储的流，主要是关闭摄像头的时候得把它清除掉
+     */
+    videoStream: SingleLocalStream | null;
+    audioStream: SingleLocalStream | null;
+    audioStats: boolean;
+    videoStats: boolean;
+    /**
+     * 本地是否在屏幕共享
+     */
+    localIsShare: boolean;
+    isShareWatcher: Subject<boolean>;
+    _speaker_enable: boolean;
+    speakerEnableWatcher: BehaviorSubject<boolean>;
+    /**
+     * 混流
+     */
+    mixStreamModelWatcher: BehaviorSubject<BMStreamModel | null>;
+    canvasTimer: NodeJS.Timeout | null;
+    private _recorder;
+    private _isRecording;
+    private _slicingRecord;
+    isRecordingWatcher: BehaviorSubject<boolean>;
+    private _speaker;
+    private _speakerDetector;
+    private _speakers;
+    speakerWatcher: BehaviorSubject<BMUser | null>;
+    /**
+     * 窗口没有播放容器的错误处理
+     */
+    noContainerWatcher: Subject<BMStreamModel>;
+    /**
+     * 窗口没有大窗口播放容器的错误处理
+     */
+    noBigContainerWatcher: Subject<BMStreamModel>;
+    localStreamConnectErrorWatcher: Subject<BoomError>;
+    /**
+     * 共享屏幕相关错误
+     * 包括，共享客户端错误
+     * 共享屏幕流错误
+     */
+    localShareError: Subject<BoomError>;
+    /**
+     * 共享屏幕流是单独处理的逻辑，不是先创建streamModel然后在去查流，而是先去查流，在创建streamModel
+     */
+    shareBloudStateMap: Map<string, BloudStreamEventState>;
+    constructor();
+    private static filterStreamModels;
+    initWithRoom(room: BMRoom): this;
+    /**
+     * 设置扬声器是否打开
+     * @param enable
+     * @private
+     */
+    private setSpeakerEnable;
+    getStreamModels(): Array<BMStreamModel>;
+    /**
+     * 获取streamModel
+     * @param userId 用户Id
+     * @returns
+     */
+    getStreamModelByUId(userId: string): BMStreamModel | undefined;
+    getShareStreamModelByUId(userId: string): BMStreamModel | undefined;
+    getLocalStreamModel(): BMStreamModel | null;
+    createStreamModel(user: BMUser, stream?: SingleStream): BMStreamModel;
+    addStreamModel(streamModel: BMStreamModel): void;
+    addShareStreamModel(streamModel: BMStreamModel): void;
+    removeStreamModel(streamModel: BMStreamModel): void;
+    removeShareStreamModelByUId(uid: string): void;
+    removeShareStreamModel(streamModel: BMStreamModel): void;
+    /**`
+     * 通过用户id删除streamModel
+     * @param userId
+     * @returns
+     */
+    removeStreamModelByUId(userId: string): BMStreamModel | undefined;
+    remoteStreamPublished(stream: SingleRemoteStream): void;
+    /**
+     * 有人取消流触发，有人取消流之后brtc底层会把流销毁掉，除了流Id和userId，其他的信息都不稳定能取到
+     * @param stream
+     * @returns
+     */
+    remoteStreamUnpublished(stream: SingleRemoteStream): BMStreamModel | undefined;
+    sortStreamModels(): BMStreamModel[];
+    updateStreamModel(streamModel: BMStreamModel, stream: SingleStream): void;
+    updateShareStreamModel(streamModel: BMStreamModel, stream: SingleStream): void;
+    /**
+     * 开关本地摄像头
+     * @param status true:开,false:关
+     * @param videoTrack 开启美颜之后，需要传递这个参数，携带美颜之后的videoTrack
+     */
+    setLocalVideoEnable(status: boolean, videoTrack?: MediaStreamTrack): Promise<undefined>;
+    /**
+     * brtc流更新状态失败，这个时候重新推流
+     */
+    handleStreamUpdateFailed(): Promise<void>;
+    /**
+     * 开关本地麦克风
+     * @param status true:开,false:关
+     */
+    setLocalAudioEnable(status: boolean): Promise<undefined>;
+    /**
+     * 该方法只是在入会的时候，同时开启音频和视频的时候使用，其他时候禁止使用该方法
+     * 切换音频和视频状态请使用 setLocalAudioEnable 和 setLocalVideoEnable
+     * @param audio
+     * @param video
+     */
+    joinWithAudioAndAudio(audio: boolean, video: boolean): Promise<void>;
+    /**
+     * 切换扬声器
+     * @param device
+     * @param force 是否需要强制更新
+     */
+    changeSpeaker(device: Device, force?: boolean): Promise<void>;
+    /**
+     * 设置单个流的扬声器
+     * @param streamModel
+     */
+    changeSingleStreamSpeaker(streamModel: BMStreamModel): Promise<void>;
+    changeAudioInput(device: Device): Promise<boolean | undefined>;
+    changeVideoInput(device: Device): Promise<boolean | undefined>;
+    /**
+     * 是否静音扬声器
+     * @param enable
+     */
+    muteSpeaker(enable: boolean): Promise<undefined>;
+    /**
+     * 创建本地音频流
+     */
+    createLocalAudioStream(): Promise<void>;
+    /**
+     * 创建流并且发布
+     * @param audio 是否发布音频流
+     * @param video 是否发布视频流
+     * @param localModel 本地的streamModel
+     * @param videoTrack
+     * @private
+     */
+    private createStreamAndPublish;
+    publishBloudStream(audio: boolean, video: boolean): Promise<void>;
+    muteHandler(type: 'video' | 'audio'): void;
+    unpublishStream(): Promise<void>;
+    /**
+     * 更改音视频状态或者取消发布
+     * @param type 更改类型
+     * @param mute 是否取消发布
+     * @param localModel 本地的streamModel
+     * @private
+     */
+    private muteOrUnpublishStream;
+    toggleShareScreen(enable: boolean, opts: any, customShare?: Result): Promise<boolean>;
+    setShareScreenContentHint(contentHint: '' | 'motion' | 'detail' | 'text'): void;
+    updateModelSort: lodash_es.DebouncedFunc<() => void>;
+    handleNoContainer: (info: NoPlayerContainer) => void;
+    /**
+     * 创建canvas，目的是为了捕获空track流，给brtc使用
+     */
+    createCanvas(): void;
+    private canvasDisplay;
+    private static getCanvasStream;
+    private createVideoStream;
+    /**
+     * 启动录制
+     * @param {String} opts.filename - 录制文件名
+     * @param {Object} opts.capture - 采集属性
+     * @param {Number} opts.capture.width - 宽度
+     * @param {Number} opts.capture.height - 高度
+     * @param {Number} opts.capture.fps - 帧率
+     * @param {Number} opts.record - 编码属性
+     * @param {Number} opts.record.bitrate - 编码码率
+     * @param {String|undefined} opts.record.format - 编码格式
+     * @return {boolean}
+     */
+    startRecord(opts: any): Promise<boolean | undefined>;
+    /**
+     * 添加流对象到录制器，用于音频轨道录制
+     * @param stream
+     */
+    addToRecorder(stream: SingleStream): void;
+    /**
+     * 从录制器中删除流对象
+     * @param stream
+     */
+    removeFromRecorder(stream: any): void;
+    /**
+     * 停止录制
+     */
+    stopRecord(): Promise<void>;
+    /**
+     * 启用下一个录制分片
+     * @param filename - 下一分片文件名
+     */
+    sliceRecord(filename: string): Promise<boolean | undefined>;
+    /**
+     * 启动说话人检测器
+     */
+    startSpeakerDetector(): void;
+    addToDetector(speaker: BMSpeaker): void;
+    removeFromDetector(speakerId: string): void;
+    clearDetector(): void;
+    shareCustomMedia(enable: boolean, shareOptions: ShareMediaOptions): Promise<undefined>;
+    /**
+     * 根据videoElement 获取内部流数据
+     */
+    getHTMLMediaStream: typeof getHTMLMediaStreamOptions;
+    getMediaStream: typeof getMediaStreamInfo;
+    /**
+     * 更新流信息 会给服务端发送updateStream信令，会收到updateStream的广播
+     */
+    updateBloudStreamCustomStats(uid: string, streamId: string, streamInfo: StreamCustomInfo): Promise<any> | undefined;
+    /**
+     * 布局发生变化之后去调用一下这个方法去检测所有流的播放状态
+     * @param {string} status tag 用于区分是什么状态下调用的
+     */
+    checkStreamStats(status: string): void;
+    clearCache(): void;
+}
+
+/**
+ * @name: BMStreamModel
+ * @author: yangliye
+ * @date: 2022-04-25 11:14
+ * @description：BMStreamModel
+ * @update: 2022-04-25 11:14
+ */
+declare type StreamType = 'big' | 'small';
+interface ConnectErrorMessage {
+    stream: BMStreamModel;
+    isLocal: boolean;
+}
+interface NoPlayerContainer {
+    type: 'share' | 'normal';
+    container: 'small' | 'big';
+    id: string;
+}
+/**
+ * 播放器状态
+ */
+declare enum PlayerState {
+    NO_CONTAINER = 0,
+    NO_PLAYING = 1,
+    PLAYING = 2
+}
+declare class BMStreamModel {
+    private user;
+    private _stream;
+    bloudStream: BloudStreamState | undefined;
+    /**
+     * 流类型
+     */
+    streamType: number;
+    pullFailedNum: number;
+    _video_enable: boolean;
+    _audio_enable: boolean;
+    videoEnableWatcher: BehaviorSubject<boolean>;
+    audioEnableWatcher: BehaviorSubject<boolean>;
+    streamUpdateWatcher: Subject<boolean>;
+    isSubScribedWatcher: Subject<boolean>;
+    playStateChangeWatcher: Subject<BMStreamModel>;
+    /**
+     * 找不到播放器，说明当前的streamModel可能是销毁重建的，或者是业务上绑定失败的，这个时候给端上一个提示，让他重新绑定一下播放器
+     */
+    noContainerWatcher: Subject<boolean>;
+    noBigContainerWatcher: Subject<boolean>;
+    audioLevelWatcher: Subject<number>;
+    isCurrentDisplay: boolean;
+    /**
+     * 当前窗口是不是在展示中目标状态
+     */
+    isDisplay: boolean;
+    isDisplayObserve: Subject<boolean>;
+    isInBig: boolean;
+    isInBigObserve: Subject<boolean>;
+    _hasPulled: boolean;
+    playerId: string;
+    /**
+     * 手动拉流配置, 默认是false, 如果是走手动拉流，设置成true，说明拉他的流
+     * shouldPull 是否应该拉
+     */
+    shouldPull: boolean;
+    get hasPulled(): boolean;
+    set hasPulled(value: boolean);
+    /**
+     * 当前拉取的是大流还是小流
+     */
+    _pulledStreamType: StreamType;
+    get pulledStreamType(): StreamType;
+    set pulledStreamType(type: StreamType);
+    /**
+     * 要拉取的流的目标状态
+     */
+    pulledStreamGoal: StreamType;
+    bigPlayerId: string;
+    player: Player | undefined | null;
+    isPlayingBig: boolean;
+    /**
+     * 是否静音了扬声器，brtc不会处理业务上静音的逻辑，所以需要自己处理
+     * 如果静音了，就把所有的流都重新静音播放一遍
+     */
+    muted: boolean;
+    private checkVideoTimer;
+    checkCount: number;
+    private checkFailedCount;
+    /**
+     * streamModel的唯一标识，用来给业务绑定播放容器
+     */
+    get uuid(): string;
+    get isAudience(): boolean;
+    /**
+     * 因为直播模式中，观众默认是不展示的，只有开麦以后才会展示
+     * 所以这个地方要判断一下
+     */
+    get canShow(): boolean;
+    changeMute(mute: boolean): void;
+    handleSpeakerChange(): void;
+    /**
+     * 排序数字
+     * 窗口的排序使用二进制运算进行了优化，为了提高运行速度牺牲了一部分代码可读性
+     */
+    sortNum: number;
+    get isToupingma(): boolean;
+    get isMixer(): boolean;
+    get isSignal(): boolean;
+    /**
+     * 初始化展示的model
+     * @param user
+     * @param stream
+     */
+    constructor(user: BMUser, stream?: SingleStream);
+    /**
+     * 生成订阅信息
+     */
+    genReceiveSubMsg(): SubscribeOptions;
+    /**
+     * display属性改变调整
+     * @private
+     */
+    private handleDisplayChange;
+    /**
+     * 处理当前窗口是不是在大窗的逻辑
+     * @param display
+     * @private
+     */
+    private handleIsInBig;
+    /**
+     * 设置是否打开摄像头状态
+     * @param enable
+     * @private
+     */
+    setVideoEnable(enable: boolean): void;
+    /**
+     * 设置是否打开麦克风状态
+     * @param enable
+     * @private
+     */
+    setAudioEnable(enable: boolean): void;
+    /**
+     * 更新当前streamModel中的流
+     * @param stream
+     * @param needReProcess
+     * @param bmStreamVm
+     */
+    updateStream(stream: SingleStream | undefined, needReProcess: boolean | undefined, bmStreamVm: BMStreamModelVM): void;
+    /**
+     * 更新bloud的stream，设置流状态
+     * @param streamState
+     * @param bmStreamVM
+     * @param forceSearch
+     */
+    updateBloudStream(streamState: BloudStreamState | undefined, bmStreamVM: BMStreamModelVM, forceSearch?: boolean): void;
+    updateBloudCustomInfo(customInfo: StreamCustomInfo): void;
+    private onPlayerStateChange;
+    handleStreamConnectError: () => void;
+    /**
+     * 获取当前的streamId
+     */
+    get streamId(): string;
+    get bStreamId(): string;
+    /**
+     * 获取当前窗口绑定的用户id
+     */
+    get userId(): string;
+    /**
+     * 获取当前的流对象
+     */
+    get stream(): SingleStream | undefined;
+    /**
+     * 是否是本地流
+     */
+    get isLocal(): boolean;
+    /**
+     * 是否是屏幕共享的流
+     */
+    get isShare(): boolean;
+    get isWeb(): boolean;
+    /**
+     * 当前音频是否开启
+     */
+    get audioEnable(): boolean;
+    /**
+     * 当前视频是否开启
+     */
+    get videoEnable(): boolean;
+    private get brtcPlayerId();
+    private get selfPlayerId();
+    /**
+     * 获取当前流绑定的用户昵称
+     */
+    get nickname(): string;
+    /**
+     * 获取流的麦克风音量
+     */
+    get audioLevel(): number;
+    getUser(): BMUser;
+    /**
+     * 设置远端流的播放声音
+     * @param volume
+     */
+    setRemoteAudioLevel(volume: number): void;
+    /**
+     * 获取流的传输信息
+     */
+    getStats(): Promise<RemoteStreamStats> | Promise<LocalStreamStats> | undefined;
+    /**
+     * BIND_ELEMENT 事件
+     * @param eleId
+     */
+    bindElement: (eleId: string) => void;
+    bindBigElement: (eleId: string) => void;
+    sendMessage2Room: lodash_es.DebouncedFunc<() => void>;
+    emitBindElement: lodash_es.DebouncedFunc<() => void>;
+    emitBindBigElement: lodash_es.DebouncedFunc<() => void>;
+    /**
+     * 当前是不是正在播放
+     * @param containerId sdk绑定播放器容器id
+     * @param playerContainerId 播放器创建的容器id
+     */
+    currentIsPlaying: (containerId: string) => PlayerState;
+    /**
+     * 播放当前流
+     */
+    play: () => Promise<void>;
+    /**
+     * 在大窗口播放该流的时候调用这个方法
+     */
+    playInBig: () => Promise<void>;
+    private initBigPlayer;
+    /**
+     * 停止播放当前流
+     */
+    stop(): void;
+    /**
+     * 销毁当前流
+     */
+    destroy(): void;
+    /**
+     * 获取当前流是否正在播放
+     */
+    isPlaying(): boolean | undefined;
+    /**
+     * 重新播放
+     */
+    replay(): Promise<void> | undefined;
+    /**
+     * 恢复播放音视频
+     * 在某些版本浏览器上移动传入 play() 的 div 容器可能会导致音视频播放器进入 ‘PAUSED’ 状态，此时 需要调用该接口恢复播放。
+     * 由于浏览器自动播放策略的限制，在 play() 返回 PLAY_NOT_ALLOWED 错误后需要引导用户通过手势 调用该接口恢复播放
+     *
+     * @returns
+     */
+    resume(): void;
+    /**
+     * 是否有音频流
+     */
+    hasAudio(): boolean;
+    /**
+     * 是否有视频流
+     */
+    hasVideo(): boolean;
+    /**
+     * 更新当前model的用户信息
+     * @param user
+     */
+    updateUser(user: BMUser): void;
+    updateSortNum(force?: boolean): void;
+    setSortNum(sortNum: number, force: boolean): void;
+    getSortNum(): number;
+    /**
+   * 启动音频音量检测
+   */
+    collectAudioLevel: () => void;
+    private handleAudioLevel;
+    checkSmallVideo(): void;
+    checkBigVideo: lodash_es.DebouncedFunc<() => void>;
+    /**
+     * 播放黑窗处理，主要是做一个容错处理，又可能这股流拉下来或者存在订阅就出现问题的情况
+     * 播放时黑窗的，这个时候需要，检测，然后重新拉流
+     * @param videoContainer
+     */
+    private checkVideoDecodeFrame;
+    /**
+     * 发送订阅该流的请求
+     */
+    subscribeStream(): void;
+    unSubscribeStream(): void;
+    checkStreamIsPlaying: lodash_es.DebouncedFunc<() => void>;
+    /**
+     * 取消流的播放
+     * @param type big: 大窗口 small: 小窗口 all: 全部
+     */
+    unAttach(type: 'big' | 'small' | 'all'): void;
+}
+
+declare type Operation = 'none' | 'getMaster' | 'getManager' | 'removeMaster' | 'getGuest' | 'removeGuest' | 'removeManager' | 'changeNickName' | 'speakerEnable' | 'changeShare' | 'updateUser' | 'raiseHandsVideo' | 'raiseHandsAudio' | 'audienceEnableSpeaking' | 'inBackground' | 'raiseHand';
+interface IUserActionWatcher {
+    operation: Operation;
+    user: BMUser;
+}
+interface UserInfo {
+    avatar: string;
+    jointime: number;
+    nickname: string;
+    pos: string;
+    userId: string;
+    status?: {
+        audioRaiseHands: boolean;
+        videoRaiseHands: boolean;
+    };
+}
+declare class BMUser {
+    /**
+     * 用户id
+     */
+    userId: string;
+    /**
+     * 用户信息
+     */
+    userInfo: UserInfo;
+    nickName: string;
+    isMaster: boolean;
+    isManager: boolean;
+    mirror: boolean;
+    isLocal: boolean;
+    isToupingma: boolean;
+    hasMultiple: boolean;
+    isCreate: boolean;
+    hasShare: boolean;
+    audienceEnableSpeaking: boolean;
+    /** 头像 */
+    avatar: string;
+    private streamModels;
+    permission: any;
+    /**
+     * 监听器, 监听返回对象属性
+     * @property {string} operation
+     * 'getManager':获得管理员权限/成为联席主持人
+     * 'getMaster':成为主持人
+     * 'removeManager':取消管理员权限/取消联席主持人
+     * 'removeMaster':取消主持人
+     * 'changeNickName':改变昵称
+     * 'speakerEnable':扬声器开关状态改变
+     * 'changeShare': 是否在屏幕共享
+     * 'raiseHandsVideo': 是否视频举手
+     * 'raiseHandsAudio': 是否音频举手
+     * 'raiseHand':单纯的举手
+     * @property {BMUser} user
+     */
+    watcher: BehaviorSubject<IUserActionWatcher>;
+    /**
+     * 排序
+     */
+    sortNum: number;
+    /**
+     * 举手相关
+     */
+    raiseVideoHands: boolean;
+    raiseAudioHands: boolean;
+    raiseHand: boolean;
+    isAudience: boolean;
+    /**
+     * 是不是普通参会者
+     */
+    isCommonUser: boolean;
+    /**
+     * 如果改用户是移动端, 该值用于判断这个用户是否在后台
+     */
+    inBackground: boolean;
+    raiseHandTime: number;
+    /**
+     * 是不是web端入会
+     */
+    get isWeb(): boolean;
+    constructor(user: any, isLocal?: boolean);
+    setup(userId: string, userinfo: UserInfo, nickname: string): void;
+    getMainStreamModel(): BMStreamModel | undefined;
+    get nickname(): string;
+    getShareStreamModel(): BMStreamModel | undefined;
+    /**
+     * 获取用户麦克风开启状态
+     */
+    get audioEnable(): boolean;
+    get isMixer(): boolean;
+    /**
+     * 获取用户视频开启状态
+     */
+    get videoEnable(): boolean;
+    get isSharing(): boolean;
+    /**
+     * 是否是信号源
+     */
+    get isSignal(): boolean;
+    /**
+     * 检测当前用户是否有主持人权限
+     */
+    checkLocalHasMaster(): boolean;
+    /**
+     * 给用户添加流
+     * @param streamId
+     * @param stream 流
+     */
+    addStream(streamId: string, stream: BMStreamModel): void;
+    /**
+     * 删除流
+     * @param streamId
+     */
+    removeStream(streamId: string): void;
+    /**
+     * 获取用户id
+     */
+    getID(): string;
+    /**
+     * 获取用户昵称
+     */
+    getNickName(): string;
+    /**
+     * 获取用户信息
+     */
+    getUserInfo(): UserInfo;
+    /**
+     * 获取用户流信息
+     */
+    getStreams(): Map<string, BMStreamModel>;
+    /**
+     * updateUserInfo更新用户信息(除了isMaster,isMaster是通过change-master事件改变的)
+     * @param bcUser
+     * @param participant
+     * @param bmRoom
+     * @returns
+     */
+    updateUserInfo(bcUser: BCUser, participant: any, bmRoom: BMRoom): void;
+    /** 是否有管理权限, 是主持人或联席主持人之一 */
+    hasManager(): boolean;
+    /** 获取用户后面的身份标识 */
+    getNicknameSuffix(): string;
+    /**
+     * 更新当前用户的排序
+     */
+    updateSortNum(force?: boolean, shouldDelay?: boolean): void;
+    setSortNum(sortNum: number, force: boolean, shouldDelay: boolean): void;
+}
+
+/**
+ * @name: BMRoomInfo
+ * @author: yangliye
+ * @date: 2022-05-18 13:52
+ * @description：BMRoomInfo
+ * @update: 2022-05-18 13:52
+ */
+
+interface OperationCustomStats {
+    /**
+     * 是否允许点赞 0 不可用 1可用
+     */
+    giveLikeEnable: 0 | 1;
+    /**
+     * 聊天是否可以用 0 不可用 1可用 2仅主持人 3嘉宾
+     */
+    chatEnable: 0 | 1 | 2 | 3;
+    /**
+     * 上传文档权限 设置-文档上传模式 0仅主持人 1 嘉宾 2 全员
+     */
+    fileUpdateModel: FilePermission;
+    /**
+     * 文档查看权限 设置-文档查看模式 0仅主持人 1 嘉宾 2 全员
+     */
+    fileUpdateLook: FilePermission;
+    /**
+     * 文档下载权限 设置-文档下载模式 0仅主持人 1 嘉宾 2 全员
+     */
+    fileUpdateDown: FilePermission;
+    /**
+     * 文档编辑权限 设置-文档编辑模式 0仅主持人 1 嘉宾 2 全员
+     */
+    fileUpdateEdit: FilePermission;
+    /**
+     * 共享屏幕权限 设置-屏幕共享模式 0仅主持人  1全员
+     */
+    screenShareModel: 0 | 1;
+    /**
+     * 是否仅一人共享 1:是 2:否
+     */
+    onlyOnePersonShare: 0 | 1;
+    /**
+     * 云录对象
+     * recordStatus 录制状态:0=暂未开始,1=录制中，2=申请中
+     * userId:开启人
+     */
+    cloudRecord: CloudRecord;
+    /**
+     *  入会时麦克风权限 0全员 1嘉宾 2主持人
+     */
+    joinAudioEnable: 0 | 1 | 2;
+    /**
+     * 入会时开启摄像头权限 0全员 1嘉宾 2主持人
+     */
+    joinVideoEnable: 0 | 1 | 2;
+    /**
+     * 参会者列表权限 0全员 1嘉宾 2主持人
+     */
+    userListEnable: 0 | 1 | 2;
+    /**
+     * 会议中是否允许开启麦克风 0全员 1嘉宾 2主持人
+     */
+    audioEnable: 0 | 1 | 2;
+    /**
+     * 会议中是否允许开启摄像头 0全员 1嘉宾 2主持人
+     */
+    videoEnable: 0 | 1 | 2;
+    /**
+     * 是否允许自行改名 0全员 1嘉宾
+     */
+    modifyNameEnable: 0 | 1;
+    /**
+     * 是否允许开启虚拟背景 0全员 1嘉宾 2主持人
+     */
+    backgroundAIEnable: 0 | 1 | 2;
+    /**
+     * 是否允许举手 0禁止全员 1允许嘉宾 2全员可举手
+     */
+    raiseHandEnable: 0 | 1 | 2;
+    /**
+     * 入会提示音设置
+     */
+    joinCueVoice: 0 | 1;
+}
+declare class BMRoomInfo {
+    private room;
+    /**
+     * 房间名
+     */
+    private _roomName;
+    /**
+     * 消息序列号
+     */
+    msgSeq: string;
+    /**
+     * 房间 号
+     */
+    roomID: string;
+    /**
+     * 是否全员静音(业务端用)
+     */
+    audioOff: boolean;
+    /**
+     * 是否可以自行开启(业务端用)
+     */
+    selfopenaudio: boolean;
+    /**
+     * 是否锁定
+     */
+    lock: boolean;
+    /**
+     * 离开提示
+     */
+    private leaveNotice;
+    /**
+     * 全员静音状态下是否允许打开麦克风
+     * @private
+     */
+    private openSelf;
+    /**
+     * 通知公告信息
+     */
+    chatNotice: string;
+    /**
+       * 通知公告信息富文本
+       */
+    chatNoticeRich: string;
+    /**
+     * 所有的音频举手人员
+     */
+    private raiseHandsList;
+    raiseHandsWatcher: BehaviorSubject<BMUser[]>;
+    /**
+     * 所有的视频举手的人员
+     */
+    private raiseVideoHandsList;
+    raiseVideoHandsWatcher: BehaviorSubject<BMUser[]>;
+    /**
+    * 所有的举手的人员
+    */
+    private raiseSimpleHandsList;
+    raiseSimpleHandsWatcher: BehaviorSubject<BMUser[]>;
+    operationPermission: OperationCustomStats | undefined;
+    operationPermissionWatcher: Subject<OperationCustomStats>;
+    chatNoticeWatcher: Subject<unknown>;
+    totalUserWatcher: BehaviorSubject<number>;
+    totalWaitRoomUserWatcher: BehaviorSubject<number>;
+    isOpenWaitRoom: Subject<boolean>;
+    constructor();
+    get roomName(): string;
+    /**
+     * 判断是不是大房间使用
+     */
+    get isBigRoom(): boolean;
+    setup(info: any): void;
+    bindRoom(room: BMRoom): void;
+    initCustomStats(customStats: any): void;
+    updateOperationPermission(stats: any): void;
+    private handleInitParams;
+    audioOffWatcher: Subject<audioOffWatcherValue>;
+    lockWatcher: BehaviorSubject<boolean>;
+    leaveNoticeWatcher: BehaviorSubject<boolean>;
+    openSelfWatcher: BehaviorSubject<boolean>;
+    /**
+     * 设置是否全员静音
+     * @param audioOff
+     * @param selfopenaudio 是否可以自行开启
+     */
+    setAudioOff(audioOff: boolean, selfopenaudio: boolean): void;
+    /**
+     * 设置是否锁定
+     * @param lock
+     */
+    setlock(lock: boolean): void;
+    setLeaveNotice(leaveNotice: boolean): void;
+    setRaiseHandsList(userList: BMUser[]): void;
+    /**
+     * 音频举手处理
+     * @param user
+     */
+    addRaiseHandUser(user: BMUser): void;
+    /**
+     * 取消音频举手处理
+     * @param userId
+     */
+    removeRaiseHandUser(userId: string): void;
+    /**
+     * 视频申请处理
+     * @param user
+     */
+    addVideoRaiseHandUser(user: BMUser): void;
+    /**
+     * 取消视频申请处理
+     * @param userId
+     */
+    removeVideoRaiseHandUser(userId: string): void;
+    /**
+     * 举手处理
+     * @param user
+     */
+    addSimpleRaiseHandUser(user: BMUser): void;
+    /**
+     * 取消举手处理
+     * @param userId
+     */
+    removeSimpleRaiseHandUser(userId: string): void;
+    private setRaiseHandsWatcherValue;
+    private setVideoRaiseHandsWatcherValue;
+    private setSimpleRaiseHandsWatcherValue;
+}
+
+interface Tiles4 {
+    index: number;
+    nickname: string;
+    user: string;
+    stream: string;
+    isSubStream?: boolean;
+}
+interface HostLayout {
+    user: string;
+    layout: number;
+    activeSubtiles: boolean;
+    tiles: Tiles4[];
+}
+
+/**
+ * 0 仅支持人 1 嘉宾 2 全员
+ */
+declare type FilePermission = 0 | 1 | 2;
+declare type giveLikeItem = {
+    userId: string | undefined;
+    nickName: string | undefined;
+    time: number;
+    type: number;
+};
+declare type CloudRecord = {
+    recordStatus: 0 | 1 | 2;
+    userId: string;
+};
+declare type SupportVideoProfile = '180p' | '240p' | '360p' | '480p' | '720p';
+declare type SampleDeviceInfo = {
+    name: string;
+};
+interface DeviceList {
+    microphoneDeviceList: SampleDeviceInfo[];
+    speakerDeviceList: SampleDeviceInfo[];
+    videoDeviceList: SampleDeviceInfo[];
+    selectVideoDevice: SampleDeviceInfo;
+    selectMicrophoneDevice: SampleDeviceInfo;
+    selectSpeakerDevice: SampleDeviceInfo;
+    videoProfile: SupportVideoProfile;
+    echoCancellation: boolean;
+    noiseSuppression: boolean;
+    autoGainControl: boolean;
+    speakerVolume: number;
+}
+interface AudioProfileInfo {
+    /**
+     * 音频采集设备
+     */
+    microphoneDevice?: SampleDeviceInfo;
+    /**
+     * 音频输出设备
+     */
+    speakerDevice?: SampleDeviceInfo;
+    /**
+     * 回音消除
+     */
+    echoCancellation?: boolean;
+    /**
+     * 音频降噪
+     */
+    noiseSuppression?: boolean;
+    /**
+     * 声音增益
+     */
+    autoGainControl?: boolean;
+    /**
+     * 调整扬声器音量 0 - 100
+     */
+    speakerVolume?: number;
+    /**
+     * 调整麦克风音量 0 - 100
+     */
+    microVolume?: number;
+}
+declare class BMRoomVM {
+    roomInfo: BMRoomInfo;
+    boomCore: BCClient;
+    userVM: BMUserVM;
+    giveLikeListWatcher: Subject<Array<giveLikeItem>>;
+    giveLikeList: Array<giveLikeItem>;
+    private room;
+    tipQueueObj: any;
+    constructor(boomCore: BCClient, userVM: any, roomInfo: BMRoomInfo);
+    initWithRoom(room: BMRoom): void;
+    /**
+     * 踢出用户
+     * @param {String} userId 用户ID
+     * @param {boolean} withoutBlack
+     */
+    evictUser(userId: string, withoutBlack: boolean): Promise<any>;
+    /**
+     * 更新用户信息，端上会收到 participant-update 信令
+     * @param userId
+     * @param info
+     */
+    updateUser(userId: string, info: any): Promise<undefined>;
+    /**
+     * 改变主持人
+     * @param {String} userId 用户ID
+     * @param isKeep
+     */
+    changeMaster(userId: string, isKeep: boolean): Promise<any>;
+    updateManager(userId: string, status: boolean, hasS?: boolean): Promise<BMUser>;
+    /**
+      * 改变昵称 需要调用http请求
+      * @param {String} userId 用户ID
+      * @param {String} nickName 用户ID
+      */
+    changeNickName(userId: string, nickName: string): Promise<any>;
+    /**
+     * 主持人send-message
+     * @param message 发送的消息
+     * @param uid 指定的userId
+     */
+    sendMessageWithMaster(message: any, uid?: string): Promise<undefined>;
+    /**
+     * 开关对端麦克风-信令发送
+     * @param status true:开,false:关
+     * @param uid 用户id
+     * @param isNotCancelRootReport 当打开麦克风时, 是否不取消音频权限申请
+     */
+    setRemoteAudioEnable(status: boolean, uid: string, isNotCancelRootReport: boolean | undefined): Promise<void>;
+    /**
+     * 开关对端摄像头-信令发送
+     * @param status true:开,false:关
+     * @param uid 用户id
+     */
+    setRemoteVideoEnable(status: boolean, uid: string): Promise<void>;
+    /**
+     * 关闭对端共享屏幕
+     * @param uid 用户id
+     */
+    closeRemoteShare(uid: string): Promise<void>;
+    /**
+       * 提醒用户
+       * @param uid 用户id
+       * @param uid msg
+       */
+    tipUser(uid: string, msg: string, richMsg: object, time: any): Promise<void>;
+    /**
+     * 举手相关操作
+     * @param type 视频还是音频举手 audio/video
+     * @param raise 举手还是放下举手 true/false
+     */
+    raiseHands(type: 'audio' | 'video' | 'raiseHand', raise: boolean): Promise<void>;
+    /**
+     * 主持人处理举手操作
+     * @param raiseHandsType 0 音视频 1 音频 2 视频 3 单纯的举手
+     * @param raiseHands true 同意 false 拒绝
+     * @param uid 指定的用户Id
+     * @description 如果不指定用户ID就是广播处理所有的举手的人员
+     */
+    handleRaiseHands(raiseHandsType: 0 | 1 | 2 | 3, raiseHands: boolean, uid?: string): Promise<undefined>;
+    /**
+     * 更新自定义属性 updateCustomStats
+     * @param stats
+     * @param {boolean} replace 是否替换原数据
+     */
+    private updateCustomStats;
+    /**
+     * 发送聊天公告
+     * @param notice
+     */
+    sendChatNotice(notice: string, richNotice: object, showTipNotice: boolean): Promise<void>;
+    /**
+     * 是否允许点赞
+     * @param enable 0 不允许 1 允许
+     */
+    giveLikeEnable(enable: 0 | 1): Promise<void>;
+    /**
+     * 入会自动静音配置 0 关闭 1 开启自动静音 2 超过6个人入会自动静音
+     * @param enable
+     */
+    changeAutoMute(enable: 0 | 1 | 2): Promise<void>;
+    /**
+     * 允许成员接收进入/离开会议通知配置 0 关闭 1 开启自动静音
+     * @param enable
+     */
+    allUserReceiveJoinLeaveMessages(enable: 0 | 1): Promise<void>;
+    /**
+     * 成员入会时给主持人播放提示音配置 0 关闭 1 开启自动静音
+     * @param enable
+     */
+    userJoinMasterVoice(enable: 0 | 1): Promise<void>;
+    /**
+     * 观众点赞(走customMessage)
+     * @param type 1:点赞, 2:送花, 3:爱心, 4: 鼓掌, 5: 喝彩
+     */
+    userGiveLike(type: 1 | 2 | 3 | 4 | 5): Promise<void>;
+    /**
+     * 聊天是否可用
+     * @param enable 0 不允许 1 允许  2仅主持人 3嘉宾
+     */
+    chatEnable(enable: 0 | 1 | 2 | 3): Promise<void>;
+    /**
+     * 入会时是否允许开启麦克风
+     * @param enable 0全员 1嘉宾 2仅主持人 3全员禁止
+     */
+    joinAudioEnable(enable: 0 | 1 | 2 | 3): Promise<void>;
+    /**
+     * 入会时是否允许开启摄像头
+     * @param enable 0全员 1嘉宾 2仅主持人 3全员禁止
+     */
+    joinVideoEnable(enable: 0 | 1 | 2 | 3): Promise<void>;
+    /**
+     * 参会者列表权限
+     * @param enable 0全员 1嘉宾 2仅主持人
+     */
+    userListEnable(enable: 0 | 1 | 2): Promise<void>;
+    /**
+     * 会议中是否允许开麦克风
+     * @param enable 0全员 1嘉宾 2仅主持人
+     */
+    audioEnable(enable: 0 | 1 | 2): Promise<void>;
+    /**
+     * 会议中是否允许开启摄像头
+     * @param enable 0全员 1嘉宾 2仅主持人
+     */
+    videoEnable(enable: 0 | 1 | 2): Promise<void>;
+    /**
+     * 是否允许自行改名
+     * @param enable 0全员 1嘉宾
+     */
+    modifyNameEnable(enable: 0 | 1 | 2): Promise<void>;
+    /**
+     * 是否允许开启虚拟背景
+     * @param enable 0全员 1嘉宾 2仅主持人
+     */
+    backgroundAIEnable(enable: 0 | 1 | 2): Promise<void>;
+    /**
+     * 强制开启对方视频
+     * @param enable true开启 false关闭
+     */
+    forceOpenUserCamera(enable: true | false): Promise<void>;
+    /**
+     * 强制开启对方音频
+     * @param enable true开启 false关闭
+     */
+    forceOpenUserMic(enable: true | false): Promise<void>;
+    /**
+    * 入会提示音设置
+    * @param enable 0关闭 1开启
+    */
+    joinCueVoice(enable: 0 | 1): Promise<void>;
+    /**
+    * 是否全员可录制
+    * @param enable 0全员 1嘉宾 2仅主持人
+    */
+    recordEnable(enable: 0 | 1 | 2): Promise<void>;
+    /**
+   * 是否全员可录制
+   * @param enable 0禁止全员举手 1嘉宾可举手 2全员可举手
+   */
+    raiseHandEnable(enable: 0 | 1 | 2): Promise<void>;
+    /**
+    * 入会麦克风禁用
+    * @param enable 0全员禁止使用 1嘉宾和学员不可使用 2不开启
+    */
+    joinMicrophoneDisable(enable: 0 | 1 | 2): Promise<void>;
+    /**
+    * 入会摄像头禁用
+    * @param enable 0全员禁止使用 1嘉宾和学员不可使用 2不开启
+    */
+    joinCameraDisable(enable: 0 | 1 | 2): Promise<void>;
+    /**
+     * 上传文档权限
+     * @param permission 0 仅支持人 1 嘉宾 2 全员
+     */
+    changeFileUpdateModelPermission(permission: FilePermission): Promise<void>;
+    changeFileUpdateLookPermission(permission: FilePermission): Promise<void>;
+    changeFileUpdateDownPermission(permission: FilePermission): Promise<void>;
+    changeFileUpdateEditPermission(permission: FilePermission): Promise<void>;
+    /**
+     * 共享屏幕权限
+     * @param permission  0全员可共享 1允许嘉宾共享 2仅主持人可共享
+     */
+    changeScreenShareModelPermission(permission: 0 | 1 | 2): Promise<void>;
+    /**
+     * 是否仅一人共享权限
+     * @param permission  1: 是  2: 否
+     */
+    changeOnlyOnePersonSharePermission(permission: 0 | 1): Promise<void>;
+    /**
+     * 设为焦点主屏
+     * @param {string} userid 设为焦点主屏的userId
+     */
+    setForceOnUser(userid: string): Promise<void>;
+    /**
+     * 主持人上报布局状态
+     * @param layoutData
+     * @param replace
+     */
+    updateHostLayout(layoutData: HostLayout, replace?: boolean): Promise<void>;
+    checkDevices(userId: string): Promise<void>;
+    resp2CheckDevices(deviceList: DeviceList, userId: string): Promise<void>;
+    /**
+     * 调节对方的视频分辨率
+     * @param {SupportVideoProfile} videoInfo 调节对方视频信息
+     * @param {string} userId
+     */
+    changeRemoteVideoProfile(videoInfo: {
+        profile: SupportVideoProfile;
+        videoDevice: SampleDeviceInfo;
+    }, userId: string): Promise<any>;
+    /**
+     * 设置完本地的视频分辨率之后，给对方响应
+     * @param {boolean} status 设置是否成功
+     * @param {string} userId
+     */
+    resp2ChangeRemoteVideoProfile(status: boolean, userId: string, profile: string): Promise<any>;
+    /**
+     * 调节远端的音频参数
+     * @param {Object} profileInfo
+     * @param uid
+     */
+    changeRemoteAudioProfile(profileInfo: AudioProfileInfo, uid: string): Promise<any>;
+    /**
+     * 响应调节远端音频的结果
+     * @param status
+     * @param uid
+     */
+    resp2ChangeRemoteAudioProfile(status: boolean, uid: string): Promise<any>;
+}
+
+/**
+ * @name: BMLiveVM.ts
+ * @author: yangliye
+ * @date: 2022-07-15 13:53
+ * @description：处理直播相关的流处理
+ * @update: 2022-07-15 13:53
+ */
+
+declare class BMLiveVM {
+    private room;
+    constructor(room: BMRoom);
+    private get localBMUser();
+    private get localIsAudience();
+    /**
+     * 拉流处理
+     * @param bmStreamModel
+     */
+    handlePull(bmStreamModel: BMStreamModel): Promise<void>;
+    /**
+     * 切换大小流处理
+     * @param bmStreamModel
+     */
+    handleChangeStreamType(bmStreamModel: BMStreamModel): Promise<void>;
+    handlePlay(bmStreamModel: BMStreamModel, noPlayChanged: boolean): Promise<void>;
+    /**
+     * 处理观众端举手发言完了，然后在禁止发言，这个时候，没有必要在拉所有人的流，把除了混流的人的流都取消订阅，然后播放混流的声音
+     */
+    handleAudienceDisable(): Promise<void>;
+    /**
+     * 观众允许发言，允许发言之后，要把所有的流都拉，然后混流静音
+     */
+    handleAudienceEnable(): Promise<void>;
+}
+
+/**
+ * @name: AudioPlay.ts
+ * @author: yangliye
+ * @date: 2023-06-08 16:35
+ * @description：AudioPlay.ts
+ * @update: 2023-06-08 16:35
+ */
+
+declare class AudioPlay {
+    playMap: WeakSet<SingleStream>;
+    playerMap: Map<string, AudioPlayer>;
+    container: HTMLDivElement | undefined;
+    muted: boolean;
+    room: BMRoom;
+    playStateChangeWatcher: Subject<AudioPlayer>;
+    deviceId?: string;
+    constructor(containerId: string, room: BMRoom);
+    addStream(stream: SingleRemoteStream, force?: boolean): void;
+    removeStream(stream: SingleStream): void;
+    removeStreamByUid(uid: string): void;
+    play(stream: SingleRemoteStream): Promise<void>;
+    mute(mute: boolean): void;
+    setVolume(streamId: string, volume: number): void;
+    setDevice(deviceId: string, force?: boolean): Promise<void>;
+    addPlayerEvent(player: AudioPlayer): void;
+    clear(): void;
+    destroy(): void;
+}
+
+interface BMRoomProps {
+    initDevices: boolean;
+}
+interface MediaPermission {
+    microphone: boolean;
+    camera: boolean;
+    screen: boolean;
+}
+declare class BMRoom {
+    roomVM: BMRoomVM | null;
+    userVM: BMUserVM;
+    chatVM: BMChatVM;
+    bmStreamVm: BMStreamModelVM;
+    observes: any;
+    boomCore: BCClient;
+    videoDevices: Device[];
+    audioDevices: Device[];
+    audioOutputDevices: Device[];
+    selectVideoDevice: Device | null;
+    selectAudioDevice: Device | null;
+    selectAudioOutputDevice: Device | null;
+    streamQueue: SingletonQueue;
+    /**
+     * 这个参数是和业务相关的功能，业务上的参会者列表是可以配置的，如果设置了只展示一列，那么所有的用户都要存储
+     * 在commonUserList中
+     */
+    userListColumns: number;
+    /**
+     * 排序规则 1 是标品排序， 2 是中移排序
+     */
+    sortType: number;
+    /**
+     * brtc断网重连的时候,所有的订阅和播放相关的处理,都不需要
+     */
+    BRTCConnectFailed: boolean;
+    /**
+     * 本端推流失败次数
+     */
+    pubFailedNum: number;
+    streamConnectedErrorQueue: Array<ConnectErrorMessage>;
+    /**
+     * 会议模式
+     * 1 会议
+     * 2 直播
+     */
+    conferenceMode: 1 | 2;
+    /**
+     * 是不是大房间
+     */
+    isBig: boolean;
+    selectVideoDeviceWatcher: BehaviorSubject<Device | null>;
+    selectAudioDeviceWatcher: BehaviorSubject<Device | null>;
+    selectAudioOutputDeviceWatcher: BehaviorSubject<Device | null>;
+    audioDevicesWatcher: Subject<Device[]>;
+    videoDevicesWatcher: Subject<Device[]>;
+    audioOutputDevicesWatcher: Subject<Device[]>;
+    raiseHandleRespWatcher: Subject<{
+        raiseHandsType: 0 | 1 | 2 | 3;
+        raiseHands: boolean;
+    }>;
+    enableAudienceSpeakingWatcher: Subject<boolean>;
+    mediaPermission: MediaPermission;
+    videoProfile: VideoProfile;
+    audioProfile: AudioProfileInfo | null;
+    voiceMode: AudioHint;
+    setVoiceMode(mode: AudioHint): void;
+    /**
+     * brtc断网重连要给端上事件响应，所有端上把流单独做处理的，需要在收到这个事件之后，重新处理所有的effect
+     */
+    streamWSReconnectWatcher: Subject<boolean>;
+    /**
+     * bloud断网重连的时候的提示
+     */
+    bloudWSReconnectWatcher: Subject<boolean>;
+    netConnecting: boolean;
+    netConnectingWatcher: Subject<boolean>;
+    hasSyncPermission: boolean;
+    /**
+     * 会控底层相关处理, 比如是否取消自动拉流
+     */
+    private meetingControlOptions;
+    forceId: string;
+    /**
+     * bloud brtc 断网重连的处理
+     *  networkState 记录网络状态
+     *  handleReconnectedStream 防抖函数，当双方有连接断网重连之后，会执行这个方法
+     *
+     *  brtc 的sync-room 之后，本地会把所有的stream都销毁，清空，然后统一走一遍查询处理
+     *  绑定新的stream，这么做简单粗暴处理所有的brtc流，防止流重复问题i
+     */
+    networkState: {
+        bloud: boolean;
+        brtc: boolean;
+    };
+    brtcNetEnableWatcher: Subject<boolean>;
+    autoPlayAudio: boolean;
+    audioPlayer: AudioPlay;
+    private pubFailedTimer;
+    get isSingleColumns(): boolean;
+    /**
+     * 传递信息用的，主要是用于message信令往上层业务发送消息
+     */
+    messageWatcher: BehaviorSubject<any>;
+    roomInfo: BMRoomInfo;
+    localUser: BMUser;
+    bmLiveVM: BMLiveVM;
+    isInWaitRoom: boolean;
+    shouldPlayAudio: boolean;
+    constructor({ initDevices }?: BMRoomProps);
+    /**
+     * 是否自动播放声音
+     * @param value
+     */
+    setAutoPlayAudio(value: boolean): void;
+    setMediaPermission(permission: MediaPermission): void;
+    /**
+     * 是否应该播放声音
+     * @param value
+     */
+    setShouldPlayAudio(value: boolean): void;
+    handleReprocessStreamError: () => void;
+    initAudioPlayer(playerContainerId: string): void;
+    /**
+     * 初始化底层会控相关
+     * @param options
+     */
+    setupMeetingControlOptions(options: any): void;
+    /**
+     * 收到对某个流状态的订阅和取消状态
+     * @private
+     * @param event
+     */
+    private handleSubMessage;
+    /**
+     * 设置视频分辨率， 需要在入会之前调用
+     * @param profile 设置视频分辨率
+     */
+    setVideoProfile(profile: VideoProfile): void;
+    setUserListColumns(column: number): void;
+    setSortType(type: number): void;
+    /**
+     * 设置声音增益的属性，回音消除 音频降噪 声音增益等
+     * @param audioProfile
+     */
+    setAudioProfile(audioProfile: AudioProfileInfo): void;
+    /**
+     * 设置共享屏幕用户的brtc Sig
+     * @param sig
+     */
+    setSig(sig: string): void;
+    /**
+     * 初始化输入设备
+     */
+    initDevices(): Promise<{
+        videoDevices: Device[];
+        audioDevices: Device[];
+        audioOutputDevices: Device[];
+        selectVideoDevice: Device | null;
+        selectAudioDevice: Device | null;
+        selectAudioOutputDevice: Device | null;
+    }>;
+    /**
+     * 筛选出默认选中的设备，如果没有，选择第一个
+     * @param devices
+     */
+    private filterDevice;
+    /**
+     * 处理用户设备变化之后的逻辑
+     */
+    private handleMediaDevicesChange;
+    setSelectAudioDevice(device: Device): void;
+    setSelectVideoDevice(device: Device): void;
+    setSelectSpeakerDevice(device: Device): void;
+    /**
+     * 事件相关 observes执行subscribe, 即执行observes,并添加回调
+     * @param observeName observe名称
+     * @param subscribeParam subscribe的参数
+     */
+    observe(observeName: string, subscribeParam: any): any;
+    /**
+   * 加入一个音视频通话房间(初始化房间对象)
+   * 进房代表开始一个音视频通话会话，这时候 SDK 会监听远端用户进房退房情况，若有远端用户进房并且发布流，本地会收到 'stream-added' 事件。
+   * 进房后用户可以通过 publish() 发布本地流，本地流发布成功后远端用户就会收到相应 'stream-added' 事件通知从而完成一个双向的音视频通话连接。
+   *
+   * @param {Object} props room创建所需属性
+   * @param {String} props.roomId 房间号
+   * @param {Number} props.userId 用户id
+   * @param {String} props.host 会议内的请求地址
+   * @param {String} props.getProxiesUrl 获取ws请求地址的路径
+   * @param {String} props.secret 房间密码
+   * @param {Boolean} props.create 是否执行房间的创建, 默认为自适应, 有房间则创建, 没房间则不创建
+   * @param {String} props.customToken 用户token
+   * @param {Number} props.limit 人数最大值
+   * @param {Number} props.brtcAppId
+   * @param {String} props.collection 数据上报地址
+   * @param {Object} props.userinfo 用户信息
+   * @param {Number} props.userinfo.cver 客户端版本
+   * @param {String} props.userinfo.nickname 用户昵称
+   * @param {String} props.userinfo.avatar 用户头像
+   * @param {String} props.userinfo.pos 客户端类型
+   * @param {Number} props.type //1:单一模式, 2:混合模式
+   * @param {String} props.name //房间名
+   * @example
+   * {
+        room: '111111',//房间号
+        host: 'https://v3test.boom.cn',//会议内的请求地址
+        getProxiesUrl: '/api/conference/v1/auth/token',//获取ws地址的路径
+        secret: '',//房间密码
+        type: 1,
+        nickname: 'zzy',
+        collection: '',//数据上报地址
+        token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJsb2dpbiIsImlhdCI6MTY1MDA5ODkwMSwibmJmIjoxNjUwMDk4OTAxLCJqdGkiOiIiLCJzdWIiOjk4NSwicHJ2IjoiODdlN2UxYmVlMjcyMmJmMzk4NjQxN2IzMzUxZTVmMjYzODQwY2ExYyIsImF0dHIiOjAsImJkIjowfQ.b-J9TnmjOzaVUJeY83tY_d1rdu_ELAWx8iH3odBN5kE',//用户token
+        userinfo: {
+            userId: 985,//用户id
+            pos: 'web',
+            nickname: 'zzy',//用户昵称
+            avatar: '',//用户头像
+        }
+    }
+   */
+    join(props: any): Promise<undefined>;
+    /**
+     * 离开房间
+     * @returns
+     */
+    leave(): Promise<void>;
+    /**
+     * 释放房间,会议结束时调用
+     */
+    releaseRoom(): Promise<void>;
+    /**
+     * 启动录制
+     * @param {String} opts.filename - 录制文件名
+     * @param {Object} opts.capture - 采集属性
+     * @param {Number} opts.capture.width - 宽度
+     * @param {Number} opts.capture.height - 高度
+     * @param {Number} opts.capture.fps - 帧率
+     * @param {Number} opts.record - 编码属性
+     * @param {Number} opts.record.bitrate - 编码码率
+     * @param {String|undefined} opts.record.format - 编码格式
+     * @return {boolean}
+     */
+    startRecord(opts: any): Promise<boolean | undefined>;
+    /**
+     * 停止录制
+     */
+    stopRecord(): Promise<void>;
+    /**
+     * 启用下一个录制分片
+     * @param filename - 下一分片文件名
+     */
+    sliceRecord(filename: string): Promise<boolean | undefined>;
+    close(): void;
+    /**
+     * 开关对端摄像头
+     * @param status true:开,false:关
+     * @param uid 用户id
+     */
+    setRemoteVideoEnable(status: boolean, uid: string): Promise<void>;
+    /**
+     * 开关对端麦克风(现在还不知道怎么实现, 未找到实现逻辑)
+     * @param status true:开,false:关
+     * @param uid 用户id
+     * @param isNotCancelRootReport 当打开麦克风时, 是否不取消音频权限申请
+     */
+    setRemoteAudioEnable(status: boolean, uid: string, isNotCancelRootReport: boolean | undefined): Promise<void>;
+    /**
+     * 开关本地摄像头
+     * @param status true:开,false:关
+     * @param videoTrack
+     */
+    setLocalVideoEnable(status: boolean, videoTrack?: MediaStreamTrack): Promise<void>;
+    /**
+     * 开关本地麦克风
+     * @param status true:开,false:关
+     */
+    setLocalAudioEnable(status: boolean): Promise<void>;
+    /**
+     * 开关本地麦克风
+     * @param status true:开,false:关
+     */
+    setLocalSpeakerEnable(status: boolean): Promise<void>;
+    private _attachEvents;
+    /**
+     * 创建本地流
+     * @param options
+     * @param sid
+     */
+    createSingleLocalStream(options: {
+        video: boolean;
+        audio: boolean;
+        videoSource?: MediaStreamTrack | undefined;
+        audioSource?: MediaStreamTrack | undefined;
+    } | undefined, sid: string): Promise<SingleLocalStream>;
+    /**
+     * 这个方法只是为了生成brtc的流，目的是在用户只打开音频的情况下，然后在打开视频的时候，去创建一个只有视频的track的流
+     * @param options
+     * @param sid
+     * @returns
+     */
+    createPBSingleLocalStream(options?: {
+        video: boolean;
+        audio: boolean;
+    }, sid?: string): Promise<LocalStream>;
+    /**
+     * 枚举视频输入设备
+     *
+     * @returns 设备列表
+     */
+    enumVideoDevices: typeof BRTC.enumVideoDevices;
+    /**
+     * 枚举音频输入设备
+     *
+     * @returns 设备列表
+     */
+    enumAudioInputDevices: typeof BRTC.enumAudioInputDevices;
+    /**
+     * 枚举音频输出设备
+     *
+     * @returns 设备列表
+     */
+    enumAudioOutputDevices: typeof BRTC.enumAudioOutputDevices;
+    /**
+     * 检查音视频权限
+     */
+    getPermissions: typeof BRTC.getPermissions;
+    checkSystemSupport: typeof BRTC.checkSystemSupport;
+    createStream: typeof BRTC.createStream;
+    participantNotice: boolean;
+    /**
+     * 订阅远端流
+     * 可通过该订阅接口指明需要订阅音频、视频或者音视频流。
+     *
+     * @param remoteStream 需要订阅的远端流对象，由 ‘participant-published’ 事件获得
+     * @param options 订阅选项
+     * @returns
+     */
+    subscribe(remoteStream: SingleRemoteStream, options?: SubscribeOptions): Promise<any>;
+    /**
+     * 取消订阅远端流
+     *
+     * @param remoteStream 需要取消订阅的远端流对象
+     * @return
+     */
+    unsubscribe(remoteStream: SingleRemoteStream): Promise<any>;
+    /**
+     * 发布本地音视频流。
+     * 该方法需要在 join() 进房后调用，一次音视频会话中只能发布一个本地流。若想发布另外一个本地流，可先通过 unpublish() 取消发布当前本地流后再发布新的本地流。
+     * 在发布本地流后，可通过 removeTrack()、addTrack()、 replaceTrack() 来更新本地流中的某个音频或视频流。
+     * 发布本地流后远端会收到 ‘participant-published’ 事件通知。
+     *
+     * @param stream 创建的本地流对象
+     * @return
+     */
+    publish(stream: SingleLocalStream): Promise<unknown>;
+    /**
+     * 取消发布本地流。
+     * 取消发布本地流后远端会收到 'participant-unpublished' 事件通知。
+     * 请在 leave() 退房前取消已经发布的本地流。
+     *
+     * @param stream 取消发布的本地流对象
+     * @return
+     */
+    unpublish(stream: SingleLocalStream): Promise<any>;
+    /**
+     * 获取userList的用户对象
+     * @param userId
+     */
+    getUser(userId: string): BMUser | undefined;
+    /**
+     * 改变主持人,只有主持人权限和房间创建者可以改变主持人(房间创建者可以收回主持人)
+     * @param userId
+     * @param isKeep 是否保留转移人的联席主持人身份
+     */
+    changeMaster(userId: string, isKeep?: boolean): Promise<any>;
+    /**
+     * 改变联席主持人,返回设置为联席主持人的bmuser对象
+     * @param userId
+     * @param status true:设置成联席主持人 false:取消联席主持人身份
+     * @param hasS
+     */
+    updateManager(userId: string, status: boolean, hasS?: boolean): Promise<any>;
+    /**
+     * 获取房间主持人id
+     */
+    getMaster(): string;
+    /**
+     * 获取房间创建者
+     */
+    getCreator(): string;
+    /**
+     * 获取房间名称
+     */
+    getName(): string;
+    /**
+     * 踢出用户
+     * @param {String} userId 用户ID
+     * @param withoutBlack 是否拉进黑名单 true 可以再进来 false 进不来
+     */
+    evictUser(userId: string, withoutBlack: boolean): Promise<any>;
+    /**
+     * 更新用户信息
+     * @param {String} target - 目标用户id
+     * @param {String} info - 用户信息或者自定义的字段
+     */
+    updateUser(target: string, info: any): Promise<void>;
+    /**
+     * 获取最新消息序列号
+     */
+    getMsgSeq(): number;
+    /**
+     * 获取限制人数
+     */
+    getLimits(): number;
+    /**
+     * 是否允许房间加入成员
+     * @return {Boolean}
+     */
+    getSwitch(): Boolean;
+    /**
+     * 更新token
+     * @param {String} token
+     */
+    /**
+     * 同步房间信息，在事件 room-reconnected 触发后调用
+     * @return {Promise}
+     */
+    syncRoom(): Promise<any>;
+    /**
+     * 更新房间状态
+     * @param {Object} options - 更新房间信息参数
+     * @param {Boolean} options.audiooff - 房间是否开启全员静音，可选
+     * @param {Boolean} options.selfopenaudio - 房间是否允许成员自行开启语音
+     * @param {Boolean} options.videooff - 房间是否开启禁用摄像头，可选
+     * @param {Boolean} options.msgoff - 房间是否开启全员禁言，可选
+     * @param {Boolean} options.switch - 房间是否开启准入开关，可选
+     * @param {Boolean} options.lock - 房间是否锁定
+     * @param {Boolean} options.secret - 不为空时表示房间密码，为以`md5(${room}.${secret})`计算所得值为参数
+     * @param {Boolean} options.waitroom - 开关等候室 false 关闭
+     * @returns {Promise}
+     */
+    update(options: any): Promise<any>;
+    /**
+     * 获取用户列表
+     * @return {BMUser[]}
+     */
+    getUsers(): Map<string, BMUser>;
+    /**
+     * 获取用户总数
+     * @deprecated
+     * @return {Number}
+     */
+    getTotalUsers(): Number;
+    /**
+     * 发送消息，缓存至服务器，会生成序列号
+     * 端上会收到 new-message 信令
+     * @param {String} message - 待发送消息, 必须是 JSON 格式的字符串
+     * @param {String|undefined} to - 如果为空，则为广播消息，不为空，则为定向到to用户的私聊消息
+     */
+    sendMessage(message: string, to: string | undefined): Promise<any>;
+    /**
+     * 发送自定义消息 可绕过 W 权限
+     * @param {String} message - 待发送消息
+     * @param {String|undefined} to - 如果为空，则为广播消息，不为空，则定向到to用户的消息
+     */
+    customMessage(message: string, to: string | undefined): Promise<any>;
+    /**
+     * 获取指定消息列表
+     * @param {Number} startSeq - 起始序列号
+     * @param {Number} endSeq - 终止序列号
+     * @return {Promise<>}
+     */
+    getMessages(startSeq: number, endSeq: number): Promise<any>;
+    /**
+     * 获取本地用户对象
+     * @return {BMUser}
+     */
+    getLocalParticipant(): BMUser;
+    /**
+     * 是否开启全员静音
+     * @return {Boolean}
+     */
+    getAudioOff(): boolean;
+    /**
+     * 是否允许自行开启语音
+     */
+    getSelfOpenAudio(): boolean;
+    /**
+     * 是否开启全员禁用摄像头
+     * @return {Boolean}
+     */
+    getVideoOff(): boolean;
+    /**
+     * 是否开启全员禁言[禁止发送消息]
+     * @return {Boolean}
+     */
+    getMsgOff(): boolean;
+    /**
+     * 是否锁定房间
+     * @return {Boolean}
+     */
+    getLock(): boolean;
+    /**
+     * 获取房间信息
+     * @return {Object}
+     */
+    getRoomInfo(): BMRoomInfo;
+    /**
+     * 设置全员静音
+     * @param {Boolean} audiooff - 是否静音
+     * @param {Boolean} selfopenaudio - 是否允许自行开启
+     * @return {Promise}
+     */
+    setAudioOff(audiooff: boolean, selfopenaudio: boolean): Promise<any>;
+    /**
+     * 更新房间状态
+     * @param opts
+     */
+    updateRoom(opts: any): Promise<void>;
+    /**
+     * 设置全员禁用摄像头
+     * @param {Boolean} videooff - 是否禁用摄像头
+     * @return {Promise}
+     */
+    setVideoOff(videooff: boolean): Promise<any>;
+    /**
+     * 设置全员禁言
+     * @param {Boolean} msgoff - 是否禁言
+     * @return {Promise}
+     */
+    setMsgOff(msgoff: boolean): Promise<any>;
+    /**
+     * 设置是否允许加入成员
+     * @param {Boolean} switch_ - 是否开启
+     */
+    setSwitch(switch_: boolean): Promise<void>;
+    /**
+     * 设置是否锁定房间
+     * @param {Boolean} lock - 是否锁定
+     */
+    setLock(lock: boolean): Promise<boolean>;
+    /**
+     * 发送聊天室消息
+     * @param msg
+     * @param userId
+     * @param lostNet
+     */
+    sendChatMessage(msg: string, userId: string | undefined, lostNet: boolean): Promise<any>;
+    /**
+     * 获取聊天室消息
+     */
+    getChatMessage(): BMMessageInfo[];
+    /**
+     * 获取聊天室历史消息
+     */
+    getHistoryMessage(): Promise<BMMessageInfo[]>;
+    /**
+     * 更新房间自定义属性状态
+     * @param {Object} customStats - 更新自定义房间信息参数
+     * @param {Boolean} customStats.layoutMode - 0/1/2,   // 默认为0，0:自由模式，可随时切换；1:是使用 defaultLayout，布局内可控；2:是使用 mainLayout，主会场同内容
+     * @returns {Promise}
+     */
+    updateCustomStats(customStats: any): Promise<any>;
+    /**
+     * 获取自定义属性
+     */
+    getCustomStats(): any;
+    /**
+     * 获取会议时间进度,返回秒数
+     */
+    getDuration(): number;
+    /**
+     * 检测目标用户是否有主持人权限
+     */
+    checkUserHasMaster(userId: string): boolean;
+    changeNickName(userId: string, nickName: string): Promise<any>;
+    /**
+     * boom-web-sdk中，会存在缓存的情况
+     * 所以可能会出现设置已经不存在的窗口的值，去拉不存在的窗口的流
+     * 增加一层逻辑判断去处理该情况
+     */
+    streamModelExits(streamModel: BMStreamModel): boolean;
+    handleQueueTask: (streamModel: BMStreamModel, noPlayChanged?: boolean) => Promise<void>;
+    handleStreamTask(streamModel: BMStreamModel, noPlayChanged?: boolean): Promise<void>;
+    /**
+     * 处理拉流的逻辑
+     * @param streamModel
+     */
+    handlePull(streamModel: BMStreamModel): Promise<void>;
+    /**
+     * 手动订阅流的处理
+     */
+    manualSubscribeStreamModel(streamModel: BMStreamModel): void;
+    /**
+     * 取消订阅流的处理
+     * @param streamModel
+     */
+    handleUnsubscribe(streamModel: BMStreamModel): void;
+    /**
+     * 处理streamModel绑定 element 只处理播放逻辑
+     * @param sm
+     */
+    handleStreamBindElement(sm: BMStreamModel): void;
+    /**
+     * 处理streamModel 绑定另一个播放器(主要是大窗口), 只处理播放逻辑
+     * @param sm
+     */
+    handleStreamBindBigElement(sm: BMStreamModel): void;
+    handleUnsubscribeStream(streamModel: BMStreamModel): Promise<void>;
+    handleSubscribeSteam(streamModel: BMStreamModel): Promise<void>;
+    /**
+     * 处理大小流切换
+     * @param streamModel
+     */
+    handleChangeStreamType(streamModel: BMStreamModel): Promise<void>;
+    /**
+     * 处理播放相关的逻辑
+     * @param streamModel
+     * @param noPlayChanged
+     * @param shouldPlayBig
+     */
+    handlePlay(streamModel: BMStreamModel, noPlayChanged: boolean, shouldPlayBig?: boolean): Promise<void>;
+    handlePlayInBIg(streamModel: BMStreamModel): Promise<void>;
+    /**
+     * 处理brtc订阅这股流失败的处理
+     * @param streamModel
+     */
+    private handlePulledFailed;
+    /**
+     * 处理流出现connect-error的逻辑，本地流需要重新推流，远端流需要重新拉流
+     * @param event
+     */
+    private handleStreamConnectError;
+    republishLocalStream: lodash_es.DebouncedFunc<(stream: SingleLocalStream) => Promise<void>>;
+    /**
+     * 设置用户禁止/允许发言
+     * @param bmUser
+     * @param status
+     */
+    toggleAudienceSpeaking(bmUser: BMUser, status: boolean): void;
+    /**
+     * 更新用户的嘉宾身份 true 设置为嘉宾 false 设置为普通参会者
+     * S -> permission
+     * 普通参会者缺少S权限，嘉宾有S权限
+     * @param user
+     * @param status
+     */
+    updateUserIsGuest(user: BMUser, status: boolean): Promise<void>;
+    /**
+     * 联席主持人设置嘉宾的操作
+     * @param userId
+     */
+    managerChangeToGuest(userId: string): void;
+    /**
+     * 将用户移动到等候室
+     * @param target 用户id
+     * @param toWait 是否移动到等候室
+     * @param autoJoin 是否自动准入
+     */
+    moveUserRoom(target: string, toWait?: boolean, autoJoin?: boolean): Promise<any>;
+    /**
+     * 获取业务端是否开启参会者进入/离开直播通知
+     * @param status
+     */
+    getParticipantNotice(status: boolean): void;
+    /**
+     *私有化部署url地址
+     * @param url
+     */
+    setCustomUrl(url: string): void;
+    /**
+     * 重推本地流，在收到brtc的code 4001 之后，说明本地掉线了
+     * 需要重新推本地流
+     */
+    handleRePushSelf(): Promise<void>;
+    /**
+     * 重拉远端流
+     */
+    handleResetOtherStreamStatus(): void;
+    addUser2Queue(pullItem: PullItem): Promise<void>;
+    processUser: (uIds: Map<string, PullItem>) => Promise<void>;
+    queueProcessor: lodash_es.DebouncedFunc<(uIds: Map<string, PullItem>) => Promise<void>>;
+    queryBrtcStreams(uids: string[]): Promise<RemoteStream[]>;
+    handleAddStreams(streams: SingleRemoteStream[]): void;
+    getForceUser(forceId: string): Promise<void>;
+    getVersion(): string;
+}
+
+export { BMRoom as default };