@hysc/meeting 7.0.0 → 7.0.116

package/dist/index.d.mts

@@ -1,4099 +0,0 @@
-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 };