export declare enum BCEvent {
    /**
     * 房间建立连接成功后的事件
     * ```javascript
     * boomCore.on('room-connected', () => {
     *   console.log('房间建立成功');
     * });
     * ```
     */
    ROOM_CONNECTED = "room-connected",
    ROOM_RECONNECTING = "room-reconnecting",
    /**
     * 房间信令重连成功后的事件
     * ```javascript
     * boomCore.on('room-reconnected', () => {
     *   console.log('房间重新建立成功');
     * });
     * ```
     */
    ROOM_RECONNECTED = "room-reconnected",
    ROOM_SYNC = "room-synced",
    /**
     * 用户加入房间成功后的事件
     * ```javascript
     * boomCore.on('participant-joined', () => {
     *   console.log('有用户加入房间');
     * });
     * ```
     */
    JOINUSER = "participant-joined",
    /**
     * 用户离开房间成功后的事件
     * ```javascript
     * boomCore.on('participant-left', () => {
     *   console.log('有用户离开房间');
     * });
     * ```
     */
    LEAVEUSER = "participant-left",
    /**
     * 房间发生错误后的事件
     * ```javascript
     * boomCore.on('room-error', () => {
     *   console.log('房间发生错误');
     * });
     * ```
     */
    ROOMERROR = "room-error",
    /**
     * 用户退出推流事件
     * ```javascript
     * @property {Participant} participant - 退出推流用户
     * @property {String[]} streams - 退出推流ID列表
     * boomCore.on('participant-unpublished', () => {
     *   console.log('用户退出推流事');
     * });
     * ```
     */
    UNPUBLISH = "participant-unpublished",
    /**
     * 用户推流事件
     * ```javascript
     * @property {Participant} participant - 用户
     * @property {Stream[]} streams - 主码流列表
     * @property {Stream[]} subStreams - 子码流列表
     * boomCore.on('participant-published', () => {
     *   console.log('用户推流');
     * });
     * ```
     */
    PUBLISHED = "participant-published",
    /**
     * 房间消息发送事件
     * ```javascript
     * boomCore.on('new-message', () => {
     *   console.log('房间消息发送');
     * });
     * ```
     */
    SENDMESSAGE = "new-message",
    /**
     * 房间消息接收事件
     * ```javascript
     * boomCore.on('custom-message', () => {
     *   console.log('房间消息接收');
     * });
     * ```
     */
    CUSTOMMESSAGE = "custom-message",
    /**
     * 用户推流出错事件
     * ```javascript
     * boomCore.on('error-media', () => {
     *   console.log('用户推流出错');
     * });
     * ```
     */
    STREAMERROR = "error-media",
    /**
     * 推流中断事件
     * ```javascript
     * boomCore.on('stream-disconnected', () => {
     *   console.log('推流中断');
     * });
     * ```
     */
    STREAMDISCONNECTED = "stream-disconnected",
    /**
     * 用户被踢出后事件
     * ```javascript
     * boomCore.on('participant-evicted', () => {
     *   console.log('用户被踢出');
     * });
     * ```
     */
    EVICTED = "participant-evicted",
    /**
     * 房间属性更新后的事件
     * ```javascript
     * boomCore.on('update-stats', () => {
     *   console.log('房间信息改变');
     * });
     * ```
     */
    UPDATESTATS = "update-stats",
    /**
     * 房间自定义属性更新后的事件
     * ```javascript
     * boomCore.on('update-custom-stats', () => {
     *   console.log('房间信息改变');
     * });
     * ```
     */
    CUSTOMSTATS = "update-custom-stats",
    /**
     * 用户信息改变后的事件
     * ```javascript
     * boomCore.on('participant-update', () => {
     *   console.log('用户信息改变');
     * });
     * ```
     */
    UPDATEUSER = "participant-update",
    /**
     * 房间管理员改变后的事件
     * ```javascript
     * boomCore.on('change-master', () => {
     *   console.log('房间管理员改变');
     * });
     * ```
     */
    CHANGEMASTER = "change-master",
    /**
     * 用户在其它端登陆后的事件
     * ```javascript
     * boomCore.on('user-rejoined', () => {
     *   console.log('用户在其它端登陆');
     * });
     * ```
     */
    USERREJOINED = "user-rejoined",
    /**
     * token即将过期的事件
     * ```javascript
     * boomCore.on('token-will-expire', () => {
     *   console.log('token即将过期');
     * });
     * ```
     */
    TOKENWILLEXPIRE = "token-will-expire",
    /**
     * token过期的事件
     * ```javascript
     * boomCore.on('token-expire', () => {
     *   console.log('token过期');
     * });
     * ```
     */
    TOKENEXPIRE = "token-expire",
    /**
     * 候选人进入事件
     * ```javascript
     * boomCore.on('onIceCandidate', () => {
  
     * });
     * ```
     */
    ICECANDIDATE = "onIceCandidate",
    /**
     * 流更新事件事件
     * ```javascript
     @param stream 流对象
     * boomCore.on('stream-update', (stream) => {
  
     * });
     * ```
     */
    STREAMUPDATE = "stream-update",
    UPDATE = "update",
    /**
     * 流智能分析数据完成后
     * @property {Stream} stream - 流对象
     * @property {Object} data - 智能分析数据，除type外依不同算法不同
     * @property {String} data.type - 智能分析类型，用于区分不同算法
     * boomCore.on('analysis-data', (params) => {
  
     * });
     * ```
     */
    ANALYSISDATA = "analysis-data",
    /**
     * 流智能分析数据出错
     * @property {Stream} stream - 流对象
     * @property {Object} analyze - 智能分析参数(待确认)
     * boomCore.on('analysis-error', (params) => {
  
     * });
     * ```
     */
    ANALYSISERROR = "analysis-error",
    /**
     * 流启动智能分析
     * @property {Stream} stream - 流对象
     * @property {Object} analyze   - 智能分析参数
     * @property {String} analyze.type  - 智能分析类型，用于区分不同算法
     * @property {Number} analyze.width - 智能分析输入宽度
     * @property {Number} analyze.height    - 智能分析输入高度
     * @property {Object} analyze.params    - 智能分析算法参数，算法参数部分置于此处
     * @property {String} analyze.params.type   - 智能分析算法名
     * @property {Number} analyze.params.fps    - 智能分析处理帧率
     * boomCore.on('start-analyze', (params) => {
  
     * });
     * ```
     */
    STARTANALYSIS = "start-analyze",
    /**
     * 流停止智能分析
     * @property {Stream} stream - 流对象
     * @property {Object} analyze   - 智能分析参数
     * @property {String} analyze.type  - 智能分析类型，用于区分不同算法
     * boomCore.on('stop-analyze', (params) => {
  
     * });
     * ```
     */
    STOPANALYSIS = "stop-analyze",
    /**
     * 房间数据上报
     * @property {Object} info - 上报数据
     * boomCore.on('stop-analyze', (info) => {
  
     * });
     * ```
     */
    REPORTINFO = "info-reported",
    /**
     * 远端流添加事件，当远端用户发布流后会收到该通知
     * ```javascript
     * client.on('stream-added', event => {
     *   const remoteStream = event.stream;s
     * });
     * ```
     */
    STREAM_ADDED = "stream-added",
    /**
     * 远端流移除事件，当远端用户取消发布流后会收到该通知。
     * ```javascript
     * client.on('stream-removed', event => {
     *   const remoteStream = event.stream;
     * });
     * ```
     */
    STREAM_REMOVED = "stream-removed",
    /**
     * 远端流更新事件，当远端用户添加、移除或更换音视频轨道后会收到该通知
     * ```javascript
     * client.on('stream-updated', event => {
     *   const remoteStream = event.stream;
     * });
     * ```
     */
    STREAM_UPDATED = "stream-updated",
    BLOUD_STREAM_UPDATED = "bloud-stream-update",
    MOVE_USER_ROOM = "move-user-room",
    /**
     * 本地流推流成功事件，调用 publish() 成功后会触发该事件
     * ```javascript
     * client.on('stream-published', event => {
     *   const localStream = event.stream;
     * });
     * ```
     */
    STREAM_PUBLISHED = "stream-published",
    /**
     * 远端流订阅成功事件，调用 subscribe() 成功后会触发该事件
     * ```javascript
     * client.on('stream-subscribed', event => {
     *   const remoteStream = event.stream;
     * });
     * ```
     */
    STREAM_SUBSCRIBED = "stream-subscribed",
    /**
     * 远端用户禁用视频通知
     * ```javascript
     * client.on('mute-video', event => {
     *   const stream = event.stream;
     * });
     * ```
     */
    MUTE_VIDEO = "mute-video",
    /**
     * 远端用户取消禁用视频通知
     * ```javascript
     * client.on('unmute-video', event => {
     *   const stream = event.stream;
     * });
     * ```
     */
    UNMUTE_VIDEO = "unmute-video",
    /**
     * 远端用户禁用音频通知
     * ```javascript
     * client.on('mute-audio', event => {
     *   const stream = event.stream;
     * });
     * ```
     */
    MUTE_AUDIO = "mute-audio",
    /**
     * 远端用户取消禁用音频通知
     * ```javascript
     * client.on('mute-audio', event => {
     *   const stream = event.stream;
     * });
     * ```
     */
    UNMUTE_AUDIO = "unmute-audio",
    /**
     * 客户端错误事件，当出现不可恢复错误后 Client 会通过该事件上报
     * ```javascript
     * client.on('error', error => {
     *   console.error('client error observed: ' + error);
     *   const errorCode = error.getCode();
     *   // 当出现客户端错误后，请调用 client.leave() 退房并尝试通过 client.join() 重新进房恢复通话。
     * });
     * ```
     */
    ERROR = "error",
    /**
     * 用户进入房间通知
     * ```javascript
     * client.on('peer-joined', event => {
     *   const userId = event.userId;
     * });
     * ```
     */
    PEER_JOINED = "peer-joined",
    /**
     * 用户退出房间通知
     * ```javascript
     * client.on('peer-leaved', event => {
     *   const userId = event.userId;
     * });
     * ```
     */
    PEER_LEAVED = "peer-leaved",
    /**
     * client 被踢出房间通知，其他端以相同的 user_id 进入了房间
     * ```javascript
     * client.on('client-banned', () => {
     *   console.log('你已被踢出！');
     * });
     * ```
     */
    CLIENT_BANNED = "client-banned",
    /**
     * 用户被踢出房间通知，被管理员踢出
     * ```javascript
     * client.on('user-kicked', () => {
     *   console.log('你已被踢出！');
     * });
     * ```
     */
    USER_KICKED = "user-kicked",
    /**
     * token 即将过期
     * ```javascript
     * client.on('token-will-expire', () => {
     *   console.log('你的 token 即将过期，请更新 token');
     * });
     * ```
     */
    TOKEN_WILL_EXPIRE = "token-will-expire",
    /**
     * token 过期
     * ```javascript
     * client.on('token-expire', () => {
     *   console.log('你的 token 已经过期，已自动退出房间');
     * });
     * ```
     */
    TOKEN_EXPIRE = "token-expire",
    /**
     * 房间关闭
     * ```javascript
     * client.on('room-closed', () => {
     *   console.log('房间已关闭，已自动退出');
     * });
     * ```
     */
    ROOM_CLOSED = "room-closed",
    /**
     * 房间网络异常
     * bloud -> disconnect -> ee.emit('network-error')
     */
    NETWORK_ERROR = "network-error",
    BRTC_SYNC_ROOM_COMPLETED = "sync-room-completed",
    BRTC_ROOM_ROCONNECTING = "brtc-room-reconnecting",
    BRTC_ROOM_RECONNECTED = "brtc-room-reconnected",
    JOIN_READY = "join-ready",
    BRTC_SHARE_SYNC_ROOM_COMPLETED = "brtc-share-sync-room-completed",
    LEAVE_USERS = "leaveUsers",
    ROOM_ERROR = "error-room",
    UPDATE_STREAM = "update-stream"
}
export default BCEvent;
