@rongcloud/plugin-rtc 5.4.1 → 5.4.2

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 /*
- * RCRTC - v5.4.1
- * CommitId - 375b5722ca190c0b24531066c28782c0c7fd7aae
- * Tue Jun 14 2022 18:18:59 GMT+0800 (China Standard Time)
+ * RCRTC - v5.4.2
+ * CommitId - 70db3a426400ee9ed6b37015c553787be663f508
+ * Tue Jul 12 2022 15:10:18 GMT+0800 (China Standard Time)
  * ©2020 RongCloud, Inc. All rights reserved.
  */
-import { EventEmitter, IReceivedMessage, RTCPluginContext, IRuntime, ErrorCode, RTCMode, IJoinRTCRoomData, KVString, IServerRTCRoomEntry, LogLevel, RTCJoinType, IRTCUserData, IRTCJoinedInfo, IPluginGenerator } from '@rongcloud/engine';
+import { EventEmitter, RTCMode, IRuntime, RTCPluginContext, IJoinRTCRoomData, IReceivedMessage, ErrorCode, RTCJoinType, IRTCUserData, KVString, IServerRTCRoomEntry, LogLevel, IRTCJoinedInfo, IPluginGenerator } from '@rongcloud/engine';
 export { RTCJoinType } from '@rongcloud/engine';
 
 /**
@@ -109,20 +109,6 @@ declare enum RCMediaType {
     AUDIO_VIDEO = 2
 }
 
-/**
- * 资源大小流标识枚举
- */
-declare enum RCStreamType {
-    /**
-     * 普通流（大流）
-     */
-    NORMAL = 1,
-    /**
-     * 小流
-     */
-    TINY = 2
-}
-
 declare enum RCFrameRate {
     FPS_10 = "FPS_10",
     FPS_15 = "FPS_15",
@@ -236,6 +222,12 @@ declare abstract class RCTrack extends EventEmitter {
      * 释放内存中的 video、audio 标签
      */
     __releaseMediaElement(): void;
+    /**
+     * 它检查元素是否是视频节点
+     * @param {any} element - 您要检查的元素是否为视频元素。
+     * @returns 一个布尔值。
+     */
+    private __validateVideoNodeName;
 }
 
 declare abstract class RCLocalTrack extends RCTrack {
@@ -365,6 +357,20 @@ declare class RCRemoteVideoTrack extends RCRemoteTrack {
     constructor(tag: string, userId: string, roomId?: string);
 }
 
+/**
+ * 资源大小流标识枚举
+ */
+declare enum RCStreamType {
+    /**
+     * 普通流（大流）
+     */
+    NORMAL = 1,
+    /**
+     * 小流
+     */
+    TINY = 2
+}
+
 interface IStatParser {
     /**
      * 取消发布后，需把 _latestPacketsSent 中 key 为 resourceId 存储的数据清除掉
@@ -442,2491 +448,2636 @@ declare enum RCRTCLiveRole {
 }
 
 /**
- * 直播间类型
+ * RTC 消息类型常量
+ * @private
  */
-declare enum RCLivingType {
+declare enum RCRTCMessageType {
     /**
-     * 音视频直播
+     * 增量资源发布消息
+     * @deprecated
      */
-    VIDEO = 0,
+    PUBLISH = "RCRTC:PublishResource",
     /**
-     * 音频直播
+     * 增量资源取消发布消息
+     * @deprecated
      */
-    AUDIO = 1
-}
-
-declare type IOnRecvPKMsg = (msg: IReceivedMessage) => void;
-interface IRoomPKEventListener {
+    UNPUBLISH = "RCRTC:UnpublishResource",
     /**
-     * 收到连麦邀请
+     * 增量资源状态变更消息
+     * @deprecated
      */
-    onRequestJoinOtherRoom: (info: IPKInviteInfo) => {};
+    MODIFY = "RCRTC:ModifyResource",
     /**
-     * 收到取消连麦邀请
+     * 全量资源变更消息
      */
-    onCancelRequestOtherRoom: (info: IPKInviteInfo) => {};
+    TOTAL_CONTENT_RESOURCE = "RCRTC:TotalContentResources",
     /**
-     * 收到连麦 PK 请求响应结果
+     * 房间人员变更
      */
-    onResponseJoinOtherRoom: (info: IPKInviteAnswerInfo) => {};
+    STATE = "RCRTC:state",
     /**
-     * 收到 PK 结束
+     * 房间属性变更
      */
-    onFinishOtherRoom: (info: IPKEndInfo) => {};
-}
-declare class RCLivingPKHandler {
-    private _PKInfo;
-    private readonly _context;
-    private readonly _runtime;
-    private readonly _service;
-    private readonly _initOptions;
+    ROOM_NOTIFY = "RCRTC:RoomNtf",
     /**
-     * 主直播房间
+     * 房间用户属性变更
      */
-    private readonly _mainLivingRoom;
-    private readonly _registerPKMsgListener;
+    USER_NOTIFY = "RCRTC:UserNtf",
     /**
-     * 加入 PK 房间回调
+     * 被服务踢出房间
      */
-    private readonly _onJoinedPKRoom;
+    KICK = "RCRTC:kick",
     /**
-     * 退出 PK 房间回调
+     * 跨房间连麦 PK 请求消息
      */
-    private readonly _onLeavePKRoom;
-    protected readonly _clientSessionId?: string | undefined;
+    PK_INVITE = "RCRTC:invite",
     /**
-     * PK 邀请超时时间，默认 30s
+     * 连麦请求超时
      */
-    private readonly _inviteTimeout;
+    PK_INVITE_TIMEOUT = "RCRTC:inviteTimeout",
     /**
-     * PK 房间信息
+     * 跨房间连麦 PK 取消请求消息
      */
-    private _appListener;
-    private _mainRoomId;
+    PK_CANCEL_INVITE = "RCRTC:cancelInvite",
     /**
-     * 跨房间连麦加入的 PK 房间
+     * 跨房间连麦 PK 请求响应消息
      */
-    private _joinedPKRooms;
-    constructor(_PKInfo: IPKInfo, _context: RTCPluginContext, _runtime: IRuntime, _service: RCMediaService, _initOptions: IRCRTCInitOptions, 
+    PK_INVITE_ANSWER = "RCRTC:answerInvite",
     /**
-     * 主直播房间
+     * 结束跨房间连麦 PK 消息
      */
-    _mainLivingRoom: RCLivingRoom, _registerPKMsgListener: (listener: IOnRecvPKMsg) => void, 
+    PK_END = "RCRTC:endInvite",
     /**
-     * 加入 PK 房间回调
+     * 连麦的房间不再了或离线了，主直播房间会收到的消息通知
      */
-    _onJoinedPKRoom: (roomId: string, room: RCLivingRoom) => void, 
+    OTHER_ROOM_OFFLINE = "RCRTC:otherRoomOffline"
+}
+
+declare enum RCInnerCDNPushMode {
+    AUTOMATIC = 0,
+    MANUAL = 1
+}
+
+declare enum RCInnerCDNBroadcast {
+    SPREAD = 0,
+    NO_SPREAD = -1
+}
+
+/**
+ * 与 MediaServer 交互所需的 Request Header 信息
+ */
+interface IRTCReqHeader {
     /**
-     * 退出 PK 房间回调
+     * RTC Token
+     * @todo 有效期问题处理
      */
-    _onLeavePKRoom: (roomId: string) => void, _clientSessionId?: string | undefined);
-    private _callAppListener;
+    Token: string;
     /**
-     * 收到连麦邀请
+     * 房间 Id
      */
-    private _onInvite;
+    RoomId: string;
     /**
-     * 收到取消连麦
+     * 用户 Id
      */
-    private _onCancelInvite;
-    private _onInviteTimeout;
+    UserId: string;
     /**
-     * 收到响应连麦
+     * 仅在直播模式下需要
      */
-    private _onInviteAnswer;
+    RoomType?: RTCMode;
     /**
-     * 收到连麦结束
+     * 开发者的 AppKey
      */
-    private _onPKEnd;
+    'App-Key': string;
     /**
-     * 处理跨房间连麦相关消息
+     * signal 会话 session id
      */
-    private _onRecvPKMsg;
+    'Session-Id'?: string;
     /**
-     * 注册跨房间连麦监听事件
+     * peerConnection Id
      */
-    registerRoomPKEventListener(listener: IRoomPKEventListener): void;
+    'Peer-Connection-Id'?: string;
     /**
-     * 发起跨房间连麦请求
-     * @param inviteeRoomId 被邀请者所处的房间 roomId
-     * @param inviteeUserId 被邀请者 userId
-     * @param options.autoMix 是否要把邀请者发布的资源，合并到被邀请者房间内的 MCU 流中
-     * @param options.extra 拓展字段，可随邀请连麦消息透传给被邀请者
+     * client-session-id 标识一个端用户进入房间后的唯一标识
      */
-    requestJoinOtherRoom(inviteeRoomId: string, inviteeUserId: string, options?: IReqResPKOptions): Promise<{
-        code: RCRTCCode | ErrorCode;
-    }>;
+    'Client-Session-Id'?: string;
+}
+interface IMCUReqHeaders {
+    'App-Key': string;
+    Token: string;
+    RoomId: string;
+    UserId: string;
+    SessionId: string;
+}
+/**
+ * exchange 接口中 pushOtherRooms 字段接口
+ */
+interface IPushOtherRooms {
     /**
-     * 取消跨房间连麦请求
-     * @param inviteeRoomId 被邀请者所处的房间 roomId
-     * @param inviteeUserId 被邀请者 userId
-     * @param extra 附加信息，可随取消邀请连麦消息透传给被邀请者
+     * 房间 Id
      */
-    cancelRequestJoinOtherRoom(inviteeRoomId: string, inviteeUserId: string, extra?: string): Promise<{
-        code: RCRTCCode | ErrorCode;
-    }>;
+    roomId: string;
     /**
-     * 响应跨房间连麦请求
-     * @param inviterRoomId 邀请者所处的房间 roomId
-     * @param inviterUserId 邀请者 userId
-     * @param agree 是否同意连麦
-     * @param options.autoMix 是否要把被邀请者发布的资源，合并到邀请者房间内的 MCU 流中
-     * @param options.extra 附加信息，可随响应连麦消息透传给邀请者
-     */
-    responseJoinOtherRoom(inviterRoomId: string, inviterUserId: string, agree: boolean, options?: IReqResPKOptions): Promise<{
-        code: RCRTCCode | ErrorCode;
-    }>;
+    * 是否默认合流
+    */
+    autoMix: boolean;
     /**
-     * 结束跨房间连麦
-     * @param roomId 需要结束连麦的房间 roomId
-     */
-    private _quitRoomPK;
-    private _relaseCrtRoom;
+    * 房间 Id 对应的 SessionId
+    */
+    sessionId: string;
+}
+/**
+ * exchange 接口的请求体结构
+ */
+interface IExchangeReqBody {
     /**
-     * 加入副直播房间
-     * @roomId 副房间的 roomId
+     * local description
      */
-    joinOtherRoom(roomId: string): Promise<{
-        code: RCRTCCode;
-        room?: RCLivingRoom;
-        userIds?: string[];
-        tracks?: RCRemoteTrack[];
-        CDNEnable?: boolean;
-    }>;
+    sdp: IOfferInfo;
     /**
-     * 退出副房间
-     * @param room 要退出的副房间的 room 实例
-     * @param isQuitPK 是否要结束连麦
+     * 订阅列表
      */
-    leaveOtherRoom(room: RCLivingRoom, isQuitPK?: boolean): Promise<{
-        code: RCRTCCode;
-    }>;
-    private _leaveOtherRoom;
+    subscribeList: {
+        /**
+         * 流资源 uri
+         */
+        uri: string;
+        /**
+         * 大小流订阅，`1` 为大流，`2` 为小流，默认使用大流
+         */
+        simulcast: RCStreamType;
+        /**
+         * 分辨率信息
+         */
+        resolution: string;
+    }[];
     /**
-     * 获取连麦信息
-     * @param roomId 连麦房间的 roomId
+     * 透传参数，一般用于传递参数给其他服务，如 MCU/Record 等，MediaServer 仅透传不处理
+     * @example `{"resolutionInfo":[{"trackId":"021ad6e8-a50c-479c-96c8-5f3f09d2352d","simulcast":1,"resolution":"640x480"}]}`
      */
-    getPKInfo(roomId: string): {
-        inviteSessionId: string;
-        inviterRoomId: string;
-        inviterUserId: string;
-        inviterUserAutoMix?: boolean | undefined; /**
-         * 加入副直播房间
-         * @roomId 副房间的 roomId
-         */
-        inviteeRoomId: string;
-        inviteeUserAutoMix?: boolean | undefined;
-    };
+    extend: string;
     /**
-     * 获取所有连麦信息
+     * 跨房间连麦时其他房间的推流信息
      */
-    getAllPKInfo(): IPKInfo;
+    pushOtherRooms?: IPushOtherRooms[];
     /**
-     * 获取已加入的副房间
+     * server 根据网络动态切换大小流开关，默认为 `false`
      */
-    getJoinedPKRooms(): {
-        [roomId: string]: RCLivingRoom;
-    };
+    switchstream: boolean;
 }
-
-declare class RCRTCPeerCManager {
+interface ILiveUrls {
     /**
-     * 是否使用多 peerConnection
+     * MCU 服务地址，直播模式中用于向 MCU 服务提交 CDN 及合流配置
      */
-    private readonly _useMutilPeerC;
+    configUrl: string;
     /**
-     * roomId 或观众端 userId
+     * 观众端订阅地址，由业务层分发
      */
-    private readonly _roomId;
+    liveUrl: string;
     /**
-     * 断线重连每一条 peerConnection
+     * 自动推 CDN 模式下，发布资源后返回的 CDN 信息
      */
-    private readonly _reTryExchange;
+    pull_url?: string;
+}
+interface IRTCResponse {
     /**
-     * 北极星上报模块
+     * 请求响应码，只有在 resultCode 值为 `10000` 时才为正常响应
      */
-    private readonly _polarisReport?;
+    resultCode: RCRTCCode;
     /**
-     * 存储创建的所有 peerC，key 为 pcName，/exchange 请求中 request header 中的 Peer-Connection-Id 值
-     */
-    private _mutilPeerC;
-    constructor(
+   * 与 resultCode 相应的可读性文字信息
+   */
+    message: string;
     /**
-     * 是否使用多 peerConnection
+     * 客户端发送的 Request-Id
      */
-    _useMutilPeerC: boolean, 
+    'Request-Id': string;
+}
+/**
+ * /exchange 响应结果
+ */
+interface IExchangeResponse extends IRTCResponse {
     /**
-     * roomId 或观众端 userId
+     * 数据中心地址，当存在此值时，后续所有请求发送到该地址。该地址不携带协议头，故需要补全 `https://` 协议头
      */
-    _roomId: string, 
+    clusterId: string;
     /**
-     * 断线重连每一条 peerConnection
+     * 发布的资源列表
      */
-    _reTryExchange: Function, 
+    publishList: IResource[];
     /**
-     * 北极星上报模块
+     * @deprecated 目前并未使用，服务器返回值为 ''
      */
-    _polarisReport?: PolarisReporter | undefined);
+    roomId: '';
     /**
-     * 根据 track 判断是否为上行
+     * 远端 SDP 数据
      */
-    private _isPub;
+    sdp: {
+        type: 'answer';
+        sdp: string;
+    };
     /**
-     * 按 tag 分 tracks
+     * 直播模式推流数据，仅在直播模式有值
      */
-    private _groupTracksByTag;
+    urls?: ILiveUrls;
     /**
-     * 按规则生成 pcName
-     * 单 peerC roomId_pub
-     * 多 peerC 上行: roomId_tag、下行: roomId_sub
-     * 观众加房间: roomId_sub
-     * 观众不加房间: userId_sub
-     * @param isPub 是否为上行、下行
-     * @param tag 多 peerC 时，上行需资源标识
+     * 跨房间连麦响应数据
      */
-    private _genPCName;
+    otherRoomsRes?: {
+        [roomId: string]: ILiveUrls;
+    };
     /**
-     * 创建一个 peerC
-     * @param pcName 使用的 peerConnection 名称
-     * @param tracks 本次要操作的资源
+     * 直播 mcu 资源
+     * 主播发布为具体资源，会议模式为空数组
      */
-    private _createOnePeerCItem;
+    mcuPublishList?: IResource[];
     /**
-     * 创建一组 peerC
-     * @param pcName
-     * @returns
+     * 订阅成功的资源
      */
-    createPeerCList(tracks: TrackParam[]): IMutilPeerC[];
+    subscribedList?: {
+        mediaType: RCMediaType.AUDIO_ONLY | RCMediaType.VIDEO_ONLY;
+        msid: string;
+        userId: string;
+        simulcast?: RCStreamType;
+    }[];
+}
+interface IBroadcastSubReqBody {
     /**
-     * 移除所有 peerConnection 的上行资源
+     * 客户端 offer
      */
-    private _removeAllLocalTrack;
+    sdp: {
+        type: 'offer';
+        sdp: string;
+    };
     /**
-     * 销毁某一个 peerConnection
+     * 直播信息
      */
-    destroyPeerC(pcName: string): void;
+    liveUrl?: string;
     /**
-     * 销毁所有 peerConnection
+     * 订阅的资源类型，默认为 `RCMediaType.AUDIO_VIDEO`
      */
-    private _destroyAllPeerC;
+    mediaType?: RCMediaType;
     /**
-     * 获取某一个 peerC
+     * 订阅大/小流，默认订阅大流
      */
-    getPCItemByPCName(pcName: string): {
-        /**
-         * RCRTCPeerConnection 对象
-         */
-        pc: RCRTCPeerConnection;
-        /**
-         * 存放 peerConnection 上本次要发布、取消发布、订阅、取消订阅的 track
-         */
-        tracks: TrackParam[];
+    simulcast?: RCStreamType;
+    /**
+     * 允许 server 根据网络状况动态切换大小流，默认为 false
+     */
+    switchstream: boolean;
+    /**
+     * 订阅列表
+     */
+    subscribeList?: {
         /**
-         * 当前 peerC 是否为发上行的 peerConnection
+         * 流资源 uri
          */
-        isPub: boolean;
+        uri: string;
         /**
-         * peerConnection 上行资源，暂不需要
+         * 大小流订阅，`1` 为大流，`2` 为小流，默认使用大流
          */
-        publishList?: IPublishedResource[] | undefined;
+        simulcast: RCStreamType;
         /**
-         * peerConnection 下行资源，暂不需要
+         * 分辨率信息
          */
-        subscribeList?: ISubscribeAttr[] | undefined;
-    };
+        resolution: string;
+    }[];
     /**
-     * 根据 trackId 获取 peerConnection 对象
+     * 是否采用新版本模式，加入房间
      */
-    getPCByTrackId(trackId: string, isPub?: boolean): RCRTCPeerConnection;
+    newVersionFlag?: boolean;
+}
+interface IBroadcastSubRespBody extends IRTCResponse {
     /**
-     * 获取所有的 peerConnection
+     * 已订阅的资源列表
      */
-    getPCList(): RCRTCPeerConnection[];
+    subscribedList: IResource[];
     /**
-     * 获取存储的多 peerConnection 数据
+     * 远端 SDP
      */
-    getMutilPeerCData(): {
-        [key: string]: {
-            /**
-             * RCRTCPeerConnection 对象
-             */
-            pc: RCRTCPeerConnection;
-            /**
-             * 存放 peerConnection 上本次要发布、取消发布、订阅、取消订阅的 track
-             */
-            tracks: TrackParam[];
-            /**
-             * 当前 peerC 是否为发上行的 peerConnection
-             */
-            isPub: boolean;
-            /**
-             * peerConnection 上行资源，暂不需要
-             */
-            publishList?: IPublishedResource[] | undefined;
-            /**
-             * peerConnection 下行资源，暂不需要
-             */
-            subscribeList?: ISubscribeAttr[] | undefined;
-        };
+    sdp: {
+        type: 'answer';
+        sdp: string;
     };
-    setPeerCData(pcName: string, key: string, value: any): void;
-    /**
-     * 销毁资源
-     */
-    clear(): void;
 }
-
-interface IPubSuccessRes {
-    code: RCRTCCode;
-    liveUrl?: string;
-    failedTracks?: {
-        code: RCRTCCode;
-        tracks: RCLocalTrack[];
-    }[];
+/**
+ * 获取 CDN 资源拉流地址请求 headers
+ */
+interface ICDNPlayUrlReqHeaders extends IMCUReqHeaders {
 }
 /**
- * 房间抽象基类
+ * 获取 CDN 资源拉流地址响应
  */
-declare abstract class RCAbstractRoom {
-    protected readonly _context: RTCPluginContext;
-    private readonly _runtime;
-    readonly _roomId: string;
-    protected readonly _roomMode: RTCMode;
-    protected readonly _service: RCMediaService;
-    protected readonly _initOptions: IRCRTCInitOptions;
-    private readonly _ntfClearRoomItem;
-    protected _isMainRoom?: boolean | undefined;
-    /**
-     * 是否使用多 peerConnection
-     */
-    protected readonly _useMutilPeerC?: boolean | undefined;
-    protected readonly _clientSessionId?: string | undefined;
+interface ICDNPlayUrlResponse extends IRTCResponse {
+    data: {
+        fps: number;
+        h: number;
+        'pull_url': string;
+        w: number;
+    };
+}
+/**
+ * cdn_uris 里面包含的字段
+ */
+interface ICDNUris {
     /**
-     * 房间资源数据
+     * 是否扩散
      */
-    protected readonly _roomResources: RoomData;
+    broadcast: RCInnerCDNBroadcast;
     /**
-     * 远端 track
+     * 拉流资源的宽度
      */
-    private _remoteTracks;
+    w?: number;
     /**
-     * 已订阅参数
+     * 拉流资源的高度
      */
-    protected readonly _subscribedList: ISubscribeAttr[];
+    h?: number;
     /**
-     * 房间保活 rtcPing
-     */
-    private readonly _pinger;
+    * 帧率
+    */
+    fps?: number;
     /**
-     * 与 MediaServer 交互需要的 token 信息
+     * 获取拉流地址的 url
      */
-    protected readonly _token: string;
+    url: string;
     /**
-     * 每次加入房间后都会改变
+     * 开启、停用 CDN
      */
-    private readonly _sessionId;
+    enableInnerCDN?: boolean;
     /**
-     * PeerConnection 连接实例
+     * 推送模式，手动 or 自动
      */
-    protected _destroyed: boolean;
+    'push_mode': RCInnerCDNPushMode;
+    'pull_safe': boolean;
+}
+
+/**
+ * 直播布局模式定义
+ */
+declare enum MixLayoutMode {
     /**
-     * 北极星上报实例
+     * 自定义布局
      */
-    protected _polarisReport: PolarisReporter | null;
+    CUSTOMIZE = 1,
     /**
-     * 音量上报实例
+     * 悬浮布局（默认）
      */
-    private _audioLevelReport;
+    SUSPENSION = 2,
     /**
-     * peerConnection 管理类
+     * 自适应布局
      */
-    protected _peerCManager: RCRTCPeerCManager | null;
-    constructor(_context: RTCPluginContext, _runtime: IRuntime, _roomId: string, data: IJoinRTCRoomData, _roomMode: RTCMode, _service: RCMediaService, _initOptions: IRCRTCInitOptions, _ntfClearRoomItem: Function, isUpgrade?: boolean, _isMainRoom?: boolean | undefined, 
+    ADAPTATION = 3
+}
+
+/**
+ * 合流布局对视频的填充模式
+ */
+declare enum MixVideoRenderMode {
     /**
-     * 是否使用多 peerConnection
+     * 裁剪（默认）
      */
-    _useMutilPeerC?: boolean | undefined, _clientSessionId?: string | undefined);
-    private _initRemoteTracks;
-    private _handlePingResult;
+    CROP = 1,
     /**
-     * 设置房间上行资源的总码率配置
-     * @description
-     * * 自 v5.1.0 版本开始，推荐使用 `RCLocalTrack.setBitrate` 对不同流分别指定码率。
-     * * 该方法仅在 SDP `plan-b` 协议下（Chrome 92 与 Safari 11 之前的版本）有效。
-     * @param max 音视频发送码率上限，不可小于 200 且不可小于 `min`
-     * @param min 音视频发送码率下限，默认值为 1，且不可小于 1，不可大于 `max`
-     * @param start 起始码率，默认为码率上限的 70%
+     * 不裁剪
      */
-    setBitrate(max: number, min: number, start?: number): void;
-    private _onTrackReady;
-    protected _callAppListener(eventType: keyof IRoomEventListener, ...attrs: any[]): void;
-    private _onUserUnpublish;
-    private _onTrackUnpublish;
-    private _unpublishPrev;
-    __parseInnerMessage(message: IReceivedMessage): boolean;
-    private msgTaskQueue;
+    WHOLE = 2
+}
+
+declare enum RCInnerCDNModel {
+    OPEN = 1,
+    STOP = 2
+}
+
+declare enum RCMixInputFilterMode {
+    /** 全合流，后续加入房间的用户会自动合流 */
+    AUDIO_VIDEO_ALL = 0,
+    /** 全不合流，后续加入本房间的用户 */
+    AUDIO_VIDEO_NO = 1,
+    /** 音频全订阅, 视频全不订阅 */
+    AUDIO_ALL_VIDEO_NO = 2,
+    /** 视频全订阅, 音频全不订阅 */
+    AUDIO_NO_VIDEO_ALL = 3,
     /**
-     * 被踢出房间通知
-     * @param byServer
-     * * 当值为 false 时，说明本端 rtcPing 超时
-     * * 当值为 true 时，说明本端收到被踢出房间通知
+     * 根据设置的音频合流列表和视频合流列表合并媒体流
      */
-    private _kickoff;
-    private _rtcpeerClosed;
+    AUDIO_VIDEO_INPUT = 4,
+    /** 音频全订阅，视频根据设置的视频合流列表 */
+    AUDIO_ALL_VIDEO_INPUT = 5,
+    /** 音频全不订阅, 视频根据input里面的视频项订阅 */
+    AUDIO_NO_VIDEO_INPUT = 6,
+    /** 视频全订阅, 音频根据input里面的音频项订阅 */
+    AUDIO_INPUT_VIDEO_ALL = 7,
+    /** 视频全不订阅, 音频根据input里面的音频项订阅 */
+    AUDIO_INPUT_VIDEO_NO = 8,
+    /** 按房间列表订阅音视频(保留当前已经订阅的, 但没在房间列表里的音视频) */
+    ROOM_AUDIO_VIDEO_APPEND = 9,
+    /** 按房间列表订阅音视频(清理当前已经订阅的, 但没在房间列表里的音视频) */
+    ROOM_AUDIO_VIDEO_NOT_APPEND = 10,
+    /** 按房间列表订阅音频, 不订阅视频(保留当前已经订阅的, 但没在房间列表里的音频) */
+    ROOM_AUDIO_APPEND = 11,
+    /** 按房间列表订阅音视, 不订阅视频(清理当前已经订阅的, 但没在房间列表里的音频) */
+    ROOM_AUDIO_NOT_APPEND = 12,
+    /** 按房间列表订阅视频, 不订阅音频(保留当前已经订阅的, 但没在房间列表里的视频) */
+    ROOM_VIDEO_APPEND = 13,
+    /** 按房间列表订阅视频, 不订阅音频(清理当前已经订阅的, 但没在房间列表里的视频) */
+    ROOM_VIDEO_NOT_APPEND = 14
+}
+
+/**
+ * 合流后的 video 输出编码配置，包含分辨率、帧率、码率配置项
+ */
+interface IMCUOutputVideoAttrs {
     /**
-     * 处理资源变更事件
-     * @param content
-     * @param messageType 消息类型
-     * @param userId 消息发送者
+     * 视频分辨率宽度
+     */
+    width?: number;
+    /**
+     * 视频分辨率高度
+     */
+    height?: number;
+    /**
+     * 帧率
+     */
+    fps?: number;
+    /**
+     * 码率
      */
-    protected _resourceHandle(content: {
+    bitrate?: number;
+}
+/**
+ * 合并入 MCU 的音频流
+ */
+interface IMCUInputAudio {
+    user_id: string;
+    stream_id: string;
+}
+/**
+ * 自定义布局中的单一视频流布局
+ */
+interface IMCUInputVideoLayout {
+    user_id: string;
+    stream_id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * 图片配置，用于水印、视频流背景图
+ */
+interface IPictureAttrs {
+    /**
+     * 资源下载地址，需包含协议
+     */
+    uri: string;
+    /**
+     * 相对于整体画布的起始位置 x 坐标
+     */
+    x: number;
+    /**
+     * 相对于整体画布的起始位置 y 坐标
+     */
+    y: number;
+    /**
+     * 相对于整体画布的宽（百分比），有效值 `0.0` - `1.0`
+     */
+    w: number;
+    /**
+     * 相对于整体画布的高（百分比），有效值 `0.0` - `1.0`
+     */
+    h: number;
+}
+/**
+ * 合流后的 Video 输出配置，包含背景图、背景色、大小流编码等配置项
+ */
+interface IMCUOutputVideoConfig {
+    /**
+     * 标准流输出定义
+     */
+    normal?: IMCUOutputVideoAttrs;
+    /**
+     * 小流输出定义
+     */
+    tiny?: IMCUOutputVideoAttrs;
+    exparams?: {
+        /**
+         * 合流布局时，对视频流的填充方式
+         */
+        renderMode: MixVideoRenderMode;
+    };
+    /**
+     * 背景色，如 `'0xf1a2c3'`
+     */
+    backgroundColor?: string;
+    /**
+     * 背景图
+     */
+    backgroundPicture?: {
         /**
-         * 旧版本兼容参数，当收到非 `RTCMessageName.TOTAL_CONTENT_RESOURCE` 时：
-         * * ignore 值为 `true` 表示该消息由 signal server 向旧版本 RTCLib 提供的兼容消息，无需处理
-         * * 否则认为该消息是由旧版本 RTCLib 主动发出的增量变更消息，需要处理
+         * 填充模式：
+         * 1. 按比例裁剪
+         * 2. 不裁剪，按比例压缩
          */
-        ignore?: boolean;
+        fillMode: 1 | 2;
         /**
-         * 发布到房间内的资源列表，`RTCMessageName.TOTAL_CONTENT_RESOURCE` 消息携带全量数据，否则为增量数据
+         * 资源列表
          */
-        uris: IPublishedResource[];
-    }, messageType: string, userId: string): Promise<void>;
-    private _onTrackPublish;
+        picture: IPictureAttrs[];
+    };
+}
+/**
+ * 合流后的媒体输出定义
+ */
+interface IMCUOutputConfig {
     /**
-     * 处理 `RCRTCMessageType.STATE` 消息
-     * @param content
+     * 输出视频配置
      */
-    private _stateHandle;
+    video: IMCUOutputVideoConfig;
     /**
-     * 获取房间 Id
+     * 输出音频配置
      */
-    getRoomId(): string;
+    audio?: {
+        /**
+         * 音频码率
+         */
+        bitrate: number;
+    };
     /**
-     * 获取当前 userId
+     * CDN 推流地址列表
      */
-    getCrtUserId(): string;
+    cdn?: {
+        /**
+         * 推流地址，如：`'rtmp://xxxx'`
+         */
+        pushurl: string;
+    }[];
+}
+/**
+ * 时间戳参数，用于水印
+ */
+interface ITimestampAttrs {
     /**
-     * 获取 _pc 实例
+     * 时区
      */
-    __getPC(): RCRTCPeerConnection[];
+    timezone: number;
     /**
-     * 获取远程用户列表，不包含当前用户
+     * 字体像素大小
      */
-    getRemoteUserIds(): string[];
+    fontSize: number;
     /**
-     * 获取所有房间已发布的远端资源列表
-     * @returns
+     * 字体颜色
      */
-    getRemoteTracks(): RCRemoteTrack[];
+    color: 'black' | 'white';
     /**
-     * 获取远端用户的资源列表
-     * @param userId
-     * @returns
+     * 透明度，有效值 `0.0` 至 `1.0`
      */
-    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
+    alpha: number;
     /**
-     * 获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新
+     * 相较于整体画布的 x 坐标（百分比），有效值 `0.0` 至 `1.0`
      */
-    getSessionId(): string;
+    x: number;
     /**
-     * 向房间内发消息
-     * @param name 消息名称
-     * @param content 消息内容
+     * 相较于整体画布的 y 坐标（百分比），有效值 `0.0` 至 `1.0`
      */
-    sendMessage(name: string, content: any): Promise<{
-        code: RCRTCCode;
-    }>;
+    y: number;
+}
+/**
+ * 文本参数，用于水印
+ */
+interface ITextAttrs {
     /**
-     * 设置房间属性
-     * @param key 属性名
-     * @param value 属性值
-     * @param message 是否在设置属性的时候携带消息内容，传空则不往房间中发送消息
-     * @param isInner RTC 业务内部使用参数，用户忽略
+     * 文字内容
      */
-    setRoomAttribute(key: string, value: string, message?: {
-        name: string;
-        content: string;
-    }, isInner?: boolean): Promise<{
-        code: RCRTCCode;
-    }>;
+    content: string;
     /**
-     * 删除房间属性
-     * @param keys 待删除的属性名数组
-     * @param message 是否在删除属性的时候携带消息内容，传空则不往房间中发送消息
-     * @param isInner RTC 业务内部使用参数，用户忽略
+     * 文字像素
      */
-    deleteRoomAttributes(keys: string[], message?: {
-        name: string;
-        content: string;
-    }, isInner?: boolean): Promise<{
-        code: RCRTCCode;
-    }>;
+    fontSize: number;
     /**
-     * 获取房间属性
-     * @param keys 要查询的属性名数组，当数组长度为空时，取所有已设置的 kv 值
-     * @param isInner RTC 业务内部使用参数，用户忽略
+     * 文字颜色
      */
-    getRoomAttributes(keys?: string[], isInner?: boolean): Promise<{
-        code: RCRTCCode;
-        data?: KVString;
-    }>;
+    color: 'black' | 'white';
     /**
-     * 设置当前用户属性（暂不开放）
-     * @param key 属性名
-     * @param value 属性值
-     * @param message 是否在设置属性的时候携带消息内容，传空则不往房间中发送消息
+     * 透明度，有效值 `0.0` 至 `1.0`
      */
-    private _setUserAttributeValue;
+    alpha: number;
     /**
-     * 删除当前用户属性（暂不开放）
-     * @param keys 待删除的属性名数组
-     * @param message 是否在删除属性的时候携带消息内容，传空则不往房间中发送消息
+     * 相较于整体画布的 x 坐标（百分比），有效值 `0.0` 至 `1.0`
      */
-    private _deleteUserAttributes;
+    x: number;
     /**
-     * 获取当前用户属性（暂不开放）
-     * @param keys 要查询的属性名数组
+     * 相较于整体画布的 y 坐标（百分比），有效值 `0.0` 至 `1.0`
      */
-    private _getUserAttributes;
+    y: number;
+}
+/**
+ * 屏幕水印配置
+ */
+interface IWaterMarkConfig {
     /**
-     * 查询房间是否已销毁
+     * 时间戳水印配置
      */
-    isDestroyed(): boolean;
+    timestamp?: ITimestampAttrs;
     /**
-     * 退出并销毁当前房间实例，退出后该房间的所有方法将不可用
+     * 图片水印配置
      */
-    __destroy(quitRoom: boolean): Promise<void>;
+    picture?: IPictureAttrs[];
     /**
-     * 退出房间之前禁用所有远端资源，避免退出动作耗时过长，
-     * 导致在未完全退出的过程中仍能听到房间内的声音问题
+     * 文字水印配置
      */
-    private _muteRemoteTracksBeforeQuit;
-    private _leaveHandle;
+    text: ITextAttrs[];
+}
+/**
+ * 合流前的单一视频流水印配置
+ */
+interface IMCUSignalScreenWaterMarkConfig extends IWaterMarkConfig {
     /**
-     * 释放 PCManager 上的资源
+     * 媒体流的 msid
      */
-    private _releasePCManager;
-    private _onLocalTrackDestroied;
+    streamId: string;
+}
+interface IMCUWaterMarkConfig {
     /**
-     * 本端流状态修改，需通知房间内其他成员
-     * @param localTrack
+     * 合流后的屏幕水印配置
      */
-    private _onLocalTrackMuted;
+    mixScreen: IWaterMarkConfig;
     /**
-     * 从 pc 移除当次发布失败的资源
+     * 合流前的单人视频流水印配置
      */
-    private _removePubFailedTracks;
+    signalScreen: IMCUSignalScreenWaterMarkConfig[];
+}
+/**
+ * 发布到服务器的 MCU 配置数据
+ */
+interface IMCUConfig {
     /**
-     * 增量发布资源，若发布的资源 tag 及媒体类型重复，后者将覆盖前者进行发布。
-     * @param tracks 待发布的 RCLocalTrack 实例
-     * @returns
+     * 为向后兼容，当前为常量 1
      */
-    publish(tracks: (RCLocalTrack | IPublishAttrs)[]): Promise<IPubSuccessRes>;
-    private __publish;
+    version: 1;
     /**
-     * 处理批量 /exhcange 的返回数据，作为一次 publish 接口返回
-     * @param pubResList 每一个 tag 的发布结果[]
+     * 布局模式，在只配置推流 CDN 时，该值不存在
      */
-    private _mergePublishRes;
+    mode: MixLayoutMode;
     /**
-     * 获取跨房间连麦需携带参数 pushOtherRooms 的值
+     * 渲染到主位置上的流 Id，当该值为空时，输出到主位置的流按发布时间顺序优先选择最早发布的流
      */
-    protected _getPushOtherRoomsParams(): IPushOtherRooms[];
+    host_stream_id?: string;
     /**
-     * ice 断线后，尝试重新走 exchange
+     * 自定义布局输入定义，只有在 mode 值为 `MixLayoutMode.CUSTOMIZE` 时需传值
      */
-    protected _reTryExchange(pcName: string, isPub: boolean): Promise<void>;
-    protected _exchangeHandle(body: IExchangeReqBody, pcName: string): Promise<{
-        code: RCRTCCode;
-        data?: IExchangeResponse | undefined;
-    }>;
-    protected _getRTCReqestHeaders(pcName: string): IRTCReqHeader;
+    input?: {
+        video?: IMCUInputVideoLayout[];
+        audio?: IMCUInputAudio[];
+    };
+    /**
+     * 合流后的媒体输出配置
+     */
+    output?: IMCUOutputConfig;
+    /**
+     * 水印配置
+     */
+    waterMark?: IMCUWaterMarkConfig;
+    /**
+     * MCU 拉流配置，决定 MCU 从 MediaServer 拉流的方式
+     */
+    inputFilterMode?: RCMixInputFilterMode;
+    /**
+     * MCU 混入列表中房间内的资源
+     */
+    mixRooms?: string[];
+}
+/**
+ * 设置开启、停用内置 CDN 数据
+ */
+interface ISetEnableCDN {
+    version: 2;
+    output: {
+        /**
+         * 手动开启/停用内置 CDN
+         */
+        inCDNModel: RCInnerCDNModel;
+    };
+}
+
+declare class RCMediaService {
+    private readonly _runtime;
+    private readonly _context;
     /**
-     * 获取 exchange 接口的请求体数据
-     * @param subscribeList 订阅清单
-     * @param iceRestart
+     * 自定义 MediaServer 地址，当有值时，不再使用导航内的地址
      */
-    protected _createExchangeParams(subscribeList: ISubscribeAttr[], iceRestart: boolean, pc: RCRTCPeerConnection): Promise<IExchangeReqBody>;
+    private readonly _msUrl?;
     /**
-     * 获取已发布资源的 state 数据
-     * @param trackId
+     * 请求超时时长
      */
-    private _getResourceState;
+    private readonly _timeout;
     /**
-     * 增量取消资源发布，若相应资源中存在小流资源，则同时取消发布
-     * @param tracks 取消发布的 RCLocalTrack 列表
+     * navi 中获取的媒体服务地址
      */
-    unpublish(tracks: RCLocalTrack[]): Promise<IPubSuccessRes>;
-    private __unpublish;
-    private _mergeUnpublishRes;
+    private readonly _msInNavi;
     /**
-     * 根据资源 Id 获取资源数据
-     * @param resourceId
+     * 已失败的请求地址
      */
-    private _getResourceById;
+    private readonly _failedMs;
     /**
-     * resourceId 有效性验证
-     * @param resourceId
+     * 服务器指纹数据，客户端不得修改，直接透传
      */
-    protected _isValidResourceId(resourceId: string): boolean;
+    private _rtcFinger;
     /**
-     * 订阅资源
-     * @param tracks
+     * 服务器接口返回的 clusterId 数据，当此数据有值时，后续所有请求向此服务发送
      */
-    subscribe(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
-        code: RCRTCCode;
-        failedList?: ISubscribeAttr[];
-    }>;
-    private __subscribe;
+    private _clusterId;
     /**
-     * 取消订阅资源
-     * @param tracks 预取消远端资源
+     * MCU 服务地址
      */
-    unsubscribe(tracks: RCRemoteTrack[]): Promise<{
-        code: RCRTCCode;
-        failedList?: ISubscribeAttr[];
-    }>;
-    private __unsubscribe;
-    protected _assertRoomDestroyed(): RCRTCCode | undefined;
+    private _configUrl;
+    constructor(_runtime: IRuntime, _context: RTCPluginContext, 
     /**
-     * 获取已发布的本地资源
-     * @param trackId
-     * @returns
+     * 自定义 MediaServer 地址，当有值时，不再使用导航内的地址
      */
-    getLocalTrack(trackId: string): RCLocalTrack | null;
+    _msUrl?: string | undefined, 
     /**
-     * 获取所有已发布的资源
+     * 请求超时时长
      */
-    getLocalTracks(): RCLocalTrack[];
+    _timeout?: number);
+    getNaviMS(): string[];
     /**
-     * 根据 trackId 获取房间内的远端资源
-     * @param trackId
-     * @returns
+     * 发送请求，请求发送若失败，会继续尝试使用后续可用地址直到无地址可用，此时认为请求失败
+     * @param path
+     * @param header
+     * @param body
      */
-    getRemoteTrack(trackId: string): RCRemoteTrack | null;
+    private _request;
     /**
-     * 强制修改订阅列表，仅订阅数组中的资源，取消订阅其他已订阅资源。
-     * 当参数为 `[]` 时，意味着不再订阅任何资源
-     * @param tracks 变更的资源列表
+     * 资源协商接口，订阅、发布、变更资源均可以使用此接口。该接口通过 sdp 字段交换 SDP 信息，
+     * 并通过 subscribeList 和 publishList 表明最终发布和订阅的资源。本端产出 offer，服务器产出 answer
+     * 每次接口调用，都会全量覆盖发布和订阅的资源。
+     * @param header
+     * @param body
      */
-    updateSubList(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
+    exchange(headers: IRTCReqHeader, body: IExchangeReqBody): Promise<{
         code: RCRTCCode;
+        data?: IExchangeResponse | undefined;
     }>;
-    private _updateSubListHandle;
-    private _appListener;
-    /**
-     * 注册事件监听器，多次注册会导致后者覆盖前者，可以通过使用 `registerRoomEventListener(null)` 取消注册
-     * @param listener
-     */
-    registerRoomEventListener(listener: IRoomEventListener | null): void;
-    private _reportListener;
-    /**
-     * 注册房间数据监控
-     * @param listener
-     * @description 该方法暂仅支持 Chrome 浏览器
-     */
-    registerReportListener(listener: IRCRTCReportListener | null): void;
     /**
-     * 音量上报
-     * @param handler 业务端传入的音量上报事件
-     * @param gap 上报时间间隔
+     * 退出房间
      */
-    onAudioLevelChange(handler: IAudioLevelChangeHandler | null, gap?: number): void;
+    exit(headers: IRTCReqHeader): Promise<RCRTCCode>;
     /**
-     * 断线重连后尝试补发断线过程中的通知信息
+     * 观众端订阅主播资源
      */
-    __onReconnected(livingType?: RCLivingType): Promise<{
-        data: IJoinRTCRoomData | undefined;
-    } | void>;
-    private _onAudioMuteChange;
-    private _onVideoMuteChange;
+    broadcastSubscribe(headers: IRTCReqHeader, body: IBroadcastSubReqBody): Promise<{
+        code: RCRTCCode;
+        data?: IBroadcastSubRespBody | undefined;
+    }>;
     /**
-     * 观众切换为主播后直接处理人员变更及资源变更
+     * 观众端退出订阅
      */
-    protected _afterChangedRole(data: IJoinRTCRoomData): void;
+    broadcastExit(headers: IRTCReqHeader): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * 销毁远端资源
+     * 直播推流、自定义布局配置
      */
-    private _removeRemoteTracks;
+    setMcuConfig(headers: IMCUReqHeaders, body: IMCUConfig | ISetEnableCDN): Promise<{
+        code: RCRTCCode;
+        res?: any;
+    }>;
     /**
-     * 存储连麦监听事件
+     * 房间内观众获取 CDN 资源信息、拉流地址
      */
-    private _onRecvPKMsg;
+    getCDNResourceInfo(headers: ICDNPlayUrlReqHeaders, url: string): Promise<{
+        code: RCRTCCode;
+        res?: ICDNPlayUrlResponse;
+    }>;
+}
+
+/**
+ * 直播间类型
+ */
+declare enum RCLivingType {
     /**
-     * 注册 PK 业务监听方法
+     * 音视频直播
      */
-    protected _registerPKMsgListener(listener: IOnRecvPKMsg | null): void;
+    VIDEO = 0,
     /**
-     * 退出 PK 房间
+     * 音频直播
      */
-    protected _quitAllPKRoom(): void;
-    getClientSessionId(): string | undefined;
-}
-
-declare class RCLocalMediaStream {
-    readonly msid: string;
-    readonly mediaStream: MediaStream;
-    readonly tinyStream: MediaStream;
-    readonly tag: string;
-    constructor(msid: string);
+    AUDIO = 1
 }
 
-interface IAudienceRoomEventListener extends IRCRTCTrackEventListener {
+declare class RCRTCPeerCManager {
     /**
-     * 主播加入
-     * @param userIds 加入主播的 id 列表
+     * 是否使用多 peerConnection
      */
-    onAnchorJoin?(userId: string[]): void;
+    private readonly _useMutilPeerC;
     /**
-     * 主播退出
-     * @param userIds 退出主播的 id 列表
+     * roomId 或观众端 userId
      */
-    onAnchorLeave?(userId: string[]): void;
+    private readonly _roomId;
     /**
-     * 房间内合流发布资源
-     * @param tracks 新发布的合流音轨与视轨数据列表，包含新发布的 RCRemoteAudioTrack 与 RCRemoteVideoTrack 实例
-     * @description
-     * 当房间内某个主播第一次发布资源时触发
+     * 断线重连每一条 peerConnection
      */
-    onTrackPublish?(tracks: RCRemoteTrack[]): void;
+    private readonly _reTryExchange;
     /**
-     * 房间内取消合流发布资源
-     * @param tracks 被取消发布的合流音轨与视轨数据列表
-     * @description
-     * 当房间内全部主播退出房间时，SDK 内部会取消对资源的订阅，业务层仅需处理 UI 业务
+     * 当前用户 id
      */
-    onTrackUnpublish?(tracks: RCRemoteTrack[]): void;
+    private readonly _currentUserId;
     /**
-     * 房间内主播发布资源
-     * @param tracks 主播新发布的音轨与视轨数据列表，包含新发布的 RCRemoteAudioTrack 与 RCRemoteVideoTrack 实例
+     * 北极星上报模块
      */
-    onAnchorTrackPublish?(tracks: RCRemoteTrack[]): void;
+    private readonly _polarisReport?;
     /**
-     * 房间内主播取消发布资源
-     * @param tracks 被主播取消发布的音轨与视轨数据列表
-     * @description 当资源被取消发布时，SDK 内部会取消对相关资源的订阅，业务层仅需处理 UI 业务
+     * 存储创建的所有 peerC，key 为 pcName，/exchange 请求中 request header 中的 Peer-Connection-Id 值
      */
-    onAnchorTrackUnpublish?(tracks: RCRemoteTrack[]): void;
+    private _mutilPeerC;
+    constructor(
     /**
-     * 房间主播禁用/启用音频
-     * @param audioTrack RCRemoteAudioTrack 类实例
+     * 是否使用多 peerConnection
      */
-    onAudioMuteChange?(audioTrack: RCRemoteAudioTrack): void;
+    _useMutilPeerC: boolean, 
     /**
-    * 房间主播禁用/启用视频
-    * @param videoTrack RCRemoteVideoTrack 类实例对象
-    */
-    onVideoMuteChange?(videoTrack: RCRemoteVideoTrack): void;
+     * roomId 或观众端 userId
+     */
+    _roomId: string, 
     /**
-     * 房间内主播把发布的资源推至 CDN
+     * 断线重连每一条 peerConnection
      */
-    onCDNInfoEnable?(CDNInfo: {
-        resolution: RCResolution;
-        fps: RCFrameRate;
-    }): void;
+    _reTryExchange: Function, 
     /**
-     * 主播停止推 CDN
+     * 当前用户 id
      */
-    onCDNInfoDisable?(): void;
+    _currentUserId: string, 
     /**
-     * 主播改变推 CDN 的分辨率或帧率
+     * 北极星上报模块
      */
-    onCDNInfoChange?(CDNInfo: {
-        resolution: RCResolution;
-        fps: RCFrameRate;
-    }): void;
-}
-/**
- * 观众直播房间类
- * 处理：
- * 1、通知观众房间内 人员变更、资源变更
- * 2、观众订阅、取消订阅资源
- */
-declare class RCAudienceLivingRoom {
-    private readonly _context;
-    private readonly _runtime;
-    private readonly _initOptions;
-    readonly _roomId: string;
-    private readonly _joinResData;
-    readonly _livingType: RCLivingType;
-    private _useMutilPeerC?;
-    protected readonly _clientSessionId?: string | undefined;
-    private readonly _service;
+    _polarisReport?: PolarisReporter | undefined);
+    get useMutilPeerC(): boolean;
     /**
-     * 主播列表
+     * 根据 track 判断是否为上行
      */
-    private _roomAnchorList;
+    private _isPub;
     /**
-     * 合流、分流资源
+     * 按 tag 分 tracks
      */
-    private _roomRes;
+    private _groupTracksByTag;
     /**
-     * 主播分流资源
+     * 按规则生成 pcName
+     * 单 peerC roomId_pub
+     * 多 peerC 上行: roomId_tag、下行: roomId_sub
+     * 观众加房间: roomId_sub
+     * 观众不加房间: userId_sub
+     * @param isPub 是否为上行、下行
+     * @param tag 多 peerC 时，上行需资源标识
      */
-    private _roomAnchorRes;
+    private _genPCName;
     /**
-     * 合流、分流 remoteTracks
+     * 创建一个 peerC
+     * @param pcName 使用的 peerConnection 名称
+     * @param tracks 本次要操作的资源
      */
-    private _remoteTracks;
-    private _appListener;
-    private _pc;
-    private _subscribedList;
-    private _sessionId;
-    private _destroyed;
+    private _createOnePeerCItem;
     /**
-     * 北极星上报实例
+     * 创建一组 peerC
+     * @param pcName
+     * @returns
      */
-    protected _polarisReport: PolarisReporter | null;
+    createPeerCList(tracks: TrackParam[]): IMutilPeerC[];
     /**
-     * 音量上报实例
+     * 移除所有 peerConnection 的上行资源
      */
-    private _audioLevelReport;
+    private _removeAllLocalTrack;
     /**
-     * cdn_uris 资源
+     * 销毁某一个 peerConnection
      */
-    private _CDNUris;
+    destroyPeerC(pcName: string): void;
     /**
-     * 使用的 peerConnection 对应 id
+     * 销毁所有 peerConnection
      */
-    private _pcName;
-    /**
-     * peerConnection 管理类
-    */
-    private _peerCManager;
-    constructor(_context: RTCPluginContext, _runtime: IRuntime, _initOptions: IRCRTCInitOptions, _roomId: string, _joinResData: {
-        token: string;
-        kvEntries: IServerRTCRoomEntry[];
-    }, _livingType: RCLivingType, _useMutilPeerC?: boolean | undefined, _clientSessionId?: string | undefined);
+    private _destroyAllPeerC;
     /**
-     * 解析服务端返回的 KV 数据，赋值 room 内数据
+     * 获取某一个 peerC
      */
-    private _setInitData;
-    protected _assertRoomDestroyed(): RCRTCCode | undefined;
+    getPCItemByPCName(pcName: string): {
+        /**
+         * RCRTCPeerConnection 对象
+         */
+        pc: RCRTCPeerConnection;
+        /**
+         * 存放 peerConnection 上本次要发布、取消发布、订阅、取消订阅的 track
+         */
+        tracks: TrackParam[];
+        /**
+         * 当前 peerC 是否为发上行的 peerConnection
+         */
+        isPub: boolean;
+        /**
+         * peerConnection 上行资源，暂不需要
+         */
+        publishList?: IPublishedResource[] | undefined;
+        /**
+         * peerConnection 下行资源，暂不需要
+         */
+        subscribeList?: ISubscribeAttr[] | undefined;
+    };
     /**
-     * @description 信令数据处理
-     * @param roomId 数据对应的房间 Id
-     * @param singalData 拉取到的数据
-     * * key RC_ANCHOR_LIST value: 为主播 ID 集合
-     * * key RC_RES_`userId` value: 为主播发布的资源
-     * * key RC_RTC_SESSIONID value: sessionId
-     * * key RC_CDN value: CDN 资源数据
+     * 根据 trackId 获取 peerConnection 对象
      */
-    private singalDataChange;
+    getPCByTrackId(trackId: string, isPub?: boolean): RCRTCPeerConnection;
     /**
-     * 计算加入离开的主播 ID 列表
+     * 获取所有的 peerConnection
      */
-    private _diffAnchorList;
-    private _handleNewJoinedAnchor;
-    private _handleLeftedAnchor;
+    getPCList(): RCRTCPeerConnection[];
     /**
-     * 计算新发布和取消发布的合流资源
+     * 获取存储的多 peerConnection 数据
      */
-    private _diffRoomResource;
-    /**
-     * 计算主播发布和取消发布的资源，以及资源的状态变更
-    */
-    private _diffAnchorResource;
-    private _onUserUnpublish;
-    private _callAppListener;
+    getMutilPeerCData(): {
+        [key: string]: {
+            /**
+             * RCRTCPeerConnection 对象
+             */
+            pc: RCRTCPeerConnection;
+            /**
+             * 存放 peerConnection 上本次要发布、取消发布、订阅、取消订阅的 track
+             */
+            tracks: TrackParam[];
+            /**
+             * 当前 peerC 是否为发上行的 peerConnection
+             */
+            isPub: boolean;
+            /**
+             * peerConnection 上行资源，暂不需要
+             */
+            publishList?: IPublishedResource[] | undefined;
+            /**
+             * peerConnection 下行资源，暂不需要
+             */
+            subscribeList?: ISubscribeAttr[] | undefined;
+        };
+    };
+    setPeerCData(pcName: string, key: string, value: any): void;
     /**
-     * ice 断线后，尝试重新走 exchange
-    */
-    private _reTryExchange;
+     * 销毁资源
+     */
+    clear(): void;
+}
+
+declare abstract class ReadableStore {
+    readonly context: RTCPluginContext;
+    readonly service: RCMediaService;
+    readonly peerMgr: RCRTCPeerCManager;
+    readonly roomId: string;
+    readonly crtUserId: string;
+    readonly roomMode: RTCMode;
+    readonly polarisReport: PolarisReporter;
+    readonly isUpgrade?: boolean | undefined;
+    readonly isMainRoom?: boolean | undefined;
     /**
-     * 获取 subscribe 接口的请求体数据
-     * @param subscribeList 订阅清单
-     * @param publishedStreams 已发布流
-     * @param iceRestart
+     * 房间资源数据
      */
-    protected _createSubscribeParams(subscribeList: ISubscribeAttr[], publishedStreams: {
-        [msid: string]: RCLocalMediaStream;
-    }, iceRestart: boolean): Promise<{
-        reqBody: IBroadcastSubReqBody;
-        offer: RTCSessionDescriptionInit;
-        dynamicBitrate: {
-            min: number;
-            max: number;
-        };
-    }>;
-    private _subscribeHandle;
+    protected _roomResources: RoomData;
     /**
-     * 添加 peerConnection 事件
+     * 远端 track
      */
-    private _addPeerCEvent;
-    private _getReqHeaders;
-    private _exchangeHandle;
-    private _updateSubListHandle;
+    protected _remoteTracks: {
+        [trackId: string]: RCRemoteTrack;
+    };
     /**
-     * 对比 cdn_uris 资源
-     * @param newCDNUris 新的 cdn_uris 数据
+     * 已订阅参数
      */
-    private _diffCDNUris;
+    protected readonly _subscribedList: ISubscribeAttr[];
     /**
-     * 获取 CDN 资源对应的拉流地址
-     * _CDNUris 无 url 时，说明未开启 CDN 推送
-     * @returns CDNPlayUrl
+     * 与 MediaServer 交互需要的 token 信息
      */
-    private _getCDNPlayUrl;
+    protected _token: string;
     /**
-     * 获取 CDN 资源对应的拉流地址
-     * @returns CDNPlayUrl
+     * 每次加入房间后都会改变
      */
-    getCDNPlayUrl(resolution?: RCResolution, fps?: RCFrameRate): Promise<{
-        code: RCRTCCode;
-        CDNPlayUrl?: string;
-    }>;
+    protected _sessionId: string;
     /**
-     * 订阅资源
-     * @param tracks
+     * cdn_uris 信令扩散数据
      */
-    subscribe(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
-        code: RCRTCCode;
-        failedList?: ISubscribeAttr[];
-    }>;
-    private __unsubscribe;
+    protected _CDNUris: ICDNUris | null;
+    protected _CDNEnable: boolean;
+    protected _destroyed: boolean;
+    constructor(context: RTCPluginContext, service: RCMediaService, peerMgr: RCRTCPeerCManager, roomId: string, crtUserId: string, roomMode: RTCMode, polarisReport: PolarisReporter, isUpgrade?: boolean | undefined, isMainRoom?: boolean | undefined);
+    get useMutilPeerC(): boolean;
+    getResourcesByUserId(userId: string): IPublishedResource[] | undefined;
+    getRemoteTrack(trackId: string): RCRemoteTrack | undefined;
+    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
+    getRemoteTracks(): {
+        [trackId: string]: RCRemoteTrack;
+    };
+    getSessionId(): string;
+    getAllUserIds(): string[];
+    getRemoteUserIds(): string[];
+    getSubscribedList(): ISubscribeAttr[];
+    getPublishedResourceByTrackId(trackId: string): IPublishedResource | undefined;
+    getToken(): string;
+    getLocalTrack(trackId: string): RCLocalTrack | null;
+    getLocalTracks(): RCLocalTrack[];
+    getTrackState(trackId: string): 0 | 1;
+    getCDNEnable(): boolean;
+    getCDNUris(): ICDNUris | null;
+}
+declare class Store extends ReadableStore {
+    private _initRemoteTracks;
+    initWithRoomData(data: IJoinRTCRoomData): void;
+    assignRoomData(data: RoomData): void;
+    setResourcesByUserId(userId: string, arr: IPublishedResource[]): void;
+    removeRemoteTrack(trackId: string): void;
+    removeResourcesByUserId(userId: string): void;
+    addRemoteTrack(track: RCRemoteTrack): void;
+    removeRemoteTracks(): void;
+    setCDNEnabel(bool: boolean): void;
+    setCDNUris(uris: ICDNUris | null): void;
+}
+
+declare enum CommandPriority {
+    LOW = 0,
+    NORMAL = 1,
+    HIGH = 2
+}
+/**
+ * 命令基类
+ */
+declare abstract class BaseCommand<RES, STORE = Store> {
     /**
-     * 取消订阅资源
-     * @param tracks
+     * 执行指令
+     * @param store
      */
-    unsubscribe(tracks: RCRemoteTrack[]): Promise<{
-        code: RCRTCCode;
-        failedList?: ISubscribeAttr[];
-    }>;
+    abstract execute(store: STORE, invoker: BaseInvoker<STORE>): Promise<RES>;
     /**
-     * 退出房间并销毁当前房间实例，退出后该房间的所有方法将不可用
+     * 获取指令优先级，必要时可 override 此函数
      */
-    __destroy(quitRoom: boolean): Promise<void>;
+    get priority(): CommandPriority;
+}
+
+declare class BaseInvoker<STORE> {
     /**
-     * 根据 trackId 获取房间内的远端资源
-     * @param trackId
+     * 内存数据管理实例
      */
-    getRemoteTrack(trackId: string): RCRemoteTrack;
+    protected readonly _store: STORE;
     /**
-     * 获取 _pc 实例
+     * 命令终止时返回的错误码定义
      */
-    __getPC(): RCRTCPeerConnection[];
+    private abortCode;
+    constructor(
     /**
-     * TODO 待优化
-     * @param trackId
+     * 内存数据管理实例
      */
-    getLocalTrack(trackId: string): RCRemoteTrack;
+    _store: STORE, 
     /**
-     * 断线重连后处理逻辑, SDK 内部处理调用
+     * 命令终止时返回的错误码定义
      */
-    __onReconnected(): Promise<void>;
+    abortCode: RCRTCCode);
+    private _queue;
+    private _busy;
+    private _next;
+    private _execute;
+    push<R>(command: BaseCommand<R, STORE>): Promise<R>;
+    private _isDestroyed;
+    isDestroyed(): boolean;
+    destroy(): void;
+}
+/**
+ * 房间任务队列管理
+ */
+declare class Invoker extends BaseInvoker<Store> {
+    constructor(context: RTCPluginContext, service: RCMediaService, peerMrg: RCRTCPeerCManager, roomId: string, crtUserId: string, mode: RTCMode, reporter: PolarisReporter, isUpgrade?: boolean, isMainRoom?: boolean);
     /**
-     * 观众房间事件注册
-     * @param tag 参数描述
+     * 获取 store 存储实例，返回值类型 `ReadableStore`，避免非 command 定义中修改内存
      */
-    registerRoomEventListener(listener: IAudienceRoomEventListener | null): void;
+    get store(): ReadableStore;
+    destroy(): void;
+}
+
+declare type ExchangeHooksRes = {
+    headers: IRTCReqHeader;
+    pushOtherRooms: IPushOtherRooms[];
+};
+declare type ExchangeHooks = (pcName: string) => ExchangeHooksRes;
+
+declare type IOnRecvPKMsg = (msg: IReceivedMessage) => void;
+interface IRoomPKEventListener {
     /**
-     * 音量上报
-     * @param handler 业务端传入的音量上报事件
-     * @param gap 上报时间间隔
+     * 收到连麦邀请
      */
-    onAudioLevelChange(handler: IAudioLevelChangeHandler | null, gap?: number): void;
-    private _reportListener;
+    onRequestJoinOtherRoom: (info: IPKInviteInfo) => {};
     /**
-     * 注册房间数据监控
-     * @param listener
+     * 收到取消连麦邀请
      */
-    registerReportListener(listener: IRCRTCReportListener | null): void;
+    onCancelRequestOtherRoom: (info: IPKInviteInfo) => {};
     /**
-     * 获取房间 Id
+     * 收到连麦 PK 请求响应结果
      */
-    getRoomId(): string;
+    onResponseJoinOtherRoom: (info: IPKInviteAnswerInfo) => {};
     /**
-     * 获取当前 userId
+     * 收到 PK 结束
      */
-    getCrtUserId(): string;
+    onFinishOtherRoom: (info: IPKEndInfo) => {};
+}
+declare class RCLivingPKHandler {
+    private _invoker;
+    private _PKInfo;
+    private _hooks;
+    private readonly _context;
+    private readonly _runtime;
+    private readonly _service;
+    private readonly _initOptions;
     /**
-     * 获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新
+     * 主直播房间
      */
-    getSessionId(): string;
+    private readonly _mainLivingRoom;
+    private readonly _registerPKMsgListener;
     /**
-     * 获取远程主播用户列表
+     * 加入 PK 房间回调
      */
-    getRemoteUserIds(): string[];
+    private readonly _onJoinedPKRoom;
+    protected readonly _clientSessionId?: string | undefined;
     /**
-     * 获取远端用户的资源列表
-     * @param userId
-     * @returns
+     * PK 邀请超时时间，默认 30s
      */
-    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
+    private readonly _inviteTimeout;
+    private _appListener;
+    private _mainRoomId;
     /**
-     * 获取房间内所有已发布的远端资源列表, 包含合流资源
-     * @returns
+     * 跨房间连麦加入的 PK 房间
      */
-    getRemoteTracks(): RCRemoteTrack[];
+    private _joinedPKRooms;
+    constructor(_invoker: Invoker, _PKInfo: IPKInfo, _hooks: ExchangeHooks, _context: RTCPluginContext, _runtime: IRuntime, _service: RCMediaService, _initOptions: IRCRTCInitOptions, 
     /**
-     * 获取远端 RTC tracks
+     * 主直播房间
      */
-    getRemoteRTCTracks(): RCRemoteTrack[];
+    _mainLivingRoom: RCLivingRoom, _registerPKMsgListener: (listener: IOnRecvPKMsg) => void, 
     /**
-     * 获取远端 MCU tracks
+     * 加入 PK 房间回调
      */
-    getRemoteMCUTracks(): RCRemoteTrack[];
+    _onJoinedPKRoom: (roomId: string, room: RCLivingRoom) => void, _clientSessionId?: string | undefined);
+    private _callAppListener;
     /**
-     * 获取房间内 CDN 信息
+     * 收到连麦邀请
      */
-    getCDNInfo(): {
-        resolution: RCResolution;
-        fps: RCFrameRate;
-        CDNEnable: boolean | undefined;
-    } | {
-        CDNEnable: boolean;
-        resolution?: undefined;
-        fps?: undefined;
-    };
-    getClientSessionId(): string | undefined;
-}
-
-/**
- * 北极星上报角色
- */
-declare enum PolarisRole {
+    private _onInvite;
     /**
-     * 会议参会者、主播
+     * 收到取消连麦
      */
-    MeetingOrAnchor = 1,
+    private _onCancelInvite;
+    private _onInviteTimeout;
     /**
-     * 观众
+     * 收到响应连麦
      */
-    Audience = 2
-}
-
-declare class PolarisReporter {
-    private readonly _context;
-    private readonly _runtime;
-    private readonly _roomId;
-    private readonly _crtRTCRoom;
-    private readonly _userRole;
-    constructor(_context: RTCPluginContext, _runtime: IRuntime, _roomId: string, _crtRTCRoom: RCAbstractRoom | RCAudienceLivingRoom, _userRole?: PolarisRole);
-    private _send;
-    private _getClientID;
+    private _onInviteAnswer;
+    private createLeaveOtherRoomCommand;
     /**
-     * 小流需去掉 _tiny，小流 resourceId 为 userId_tag_mediaType_tiny
+     * 收到连麦结束
      */
-    private _getRealResourceId;
+    private _onPKEnd;
     /**
-     * 生成北极星上报的 trackId
-     * @param resourceId userId_11_1_tiny 改为 userId_11_tiny_video
+     * 处理跨房间连麦相关消息
      */
-    private _getPolarisTrackId;
-    sendR3R4Data(data: IInnerRCRTCStateReport): Promise<boolean>;
+    private _onRecvPKMsg;
     /**
-     * 加入房间
+     * 注册跨房间连麦监听事件
      */
-    sendR1(): void;
+    registerRoomPKEventListener(listener: IRoomPKEventListener): void;
     /**
-     * RTC 和 LIVE 发布、取消发布
-     * RTC 订阅、取消订阅
+     * 发起跨房间连麦请求
+     * @param inviteeRoomId 被邀请者所处的房间 roomId
+     * @param inviteeUserId 被邀请者 userId
+     * @param options.autoMix 是否要把邀请者发布的资源，合并到被邀请者房间内的 MCU 流中
+     * @param options.extra 拓展字段，可随邀请连麦消息透传给被邀请者
      */
-    sendR2(action: string, status: string, trackIds: string[]): void;
-}
-
-/**
- * PC 实例管理类
- */
-declare class RCRTCPeerConnection extends EventEmitter {
+    requestJoinOtherRoom(inviteeRoomId: string, inviteeUserId: string, options?: IReqResPKOptions): Promise<{
+        code: RCRTCCode | ErrorCode;
+    }>;
     /**
-     * peerConnection 对应名称
-    */
-    private readonly _pcName;
+     * 取消跨房间连麦请求
+     * @param inviteeRoomId 被邀请者所处的房间 roomId
+     * @param inviteeUserId 被邀请者 userId
+     * @param extra 附加信息，可随取消邀请连麦消息透传给被邀请者
+     */
+    cancelRequestJoinOtherRoom(inviteeRoomId: string, inviteeUserId: string, extra?: string): Promise<{
+        code: RCRTCCode | ErrorCode;
+    }>;
     /**
-     * _reTryExchange 方法
+     * 响应跨房间连麦请求
+     * @param inviterRoomId 邀请者所处的房间 roomId
+     * @param inviterUserId 邀请者 userId
+     * @param agree 是否同意连麦
+     * @param options.autoMix 是否要把被邀请者发布的资源，合并到邀请者房间内的 MCU 流中
+     * @param options.extra 附加信息，可随响应连麦消息透传给邀请者
      */
-    private readonly _reTryExchange;
+    responseJoinOtherRoom(inviterRoomId: string, inviterUserId: string, agree: boolean, options?: IReqResPKOptions): Promise<{
+        code: RCRTCCode | ErrorCode;
+    }>;
     /**
-     * 北极星上传实例
+     * 加入副直播房间
+     * @roomId 副房间的 roomId
      */
-    private readonly _polarisReport?;
-    static __INNER_EVENT_TRACK_READY__: string;
-    private readonly _rtcPeerConn;
-    private readonly _sdpStrategy;
-    reportParser: IStatParser | null;
-    private pubLocalTracks;
-    private _reTryExchangeTimer;
-    private _reportStatsTimer;
-    private _reportR3R4ToPolarisTimer;
-    constructor(
+    joinOtherRoom(roomId: string): Promise<{
+        code: RCRTCCode;
+        room?: RCLivingRoom;
+        userIds?: string[];
+        tracks?: RCRemoteTrack[];
+        CDNEnable?: boolean;
+    }>;
     /**
-     * peerConnection 对应名称
-    */
-    _pcName: string, 
+     * 退出副房间
+     * @param room 要退出的副房间的 room 实例
+     * @param isQuitPK 是否要结束连麦
+     */
+    leaveOtherRoom(room: RCLivingRoom, isQuitPK?: boolean): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * _reTryExchange 方法
+     * 获取连麦信息
+     * @param roomId 连麦房间的 roomId
      */
-    _reTryExchange: Function, 
+    getPKInfo(roomId: string): {
+        inviteSessionId: string;
+        inviterRoomId: string;
+        inviterUserId: string;
+        inviterUserAutoMix?: boolean | undefined;
+        inviteeRoomId: string;
+        inviteeUserAutoMix?: boolean | undefined;
+    };
     /**
-     * 北极星上传实例
+     * 获取所有连麦信息
      */
-    _polarisReport?: PolarisReporter | undefined);
-    getLocalTracks(): RCLocalTrack[];
-    private _onConnectionStateChange;
-    private _onICEConnectionStateChange;
-    private _onTrackReady;
-    setBitrate(max: number, min: number, start?: number): Promise<void>;
-    createOffer(iceRestart: boolean): Promise<IOfferInfo>;
-    setRemoteAnswer(answer: string): Promise<RCRTCCode>;
-    getLocalTrack(trackId: string): RCLocalTrack | null;
-    addLocalTrack(track: RCLocalTrack): void;
-    removeLocalTrackById(trackId: string): void;
-    removeAllLocalTrack(): void;
-    removeLocalTrack(track: RCLocalTrack): void;
-    private _updateRecvTransceiverMap;
-    updateSubRemoteTracks(remoteTracks: RCRemoteTrack[]): void;
+    getAllPKInfo(): IPKInfo;
     /**
-     * 获取当前已发布视频流信息
+     * 获取已加入的副房间
      */
-    getOutboundVideoInfo(): OutboundVideoInfo[];
-    private _onLocalTrackMuted;
-    private _onLocalTrackDestroied;
-    private _reportListener;
+    getJoinedPKRooms(): {
+        [roomId: string]: RCLivingRoom;
+    };
+}
+
+declare type ResourceMsgContent = {
     /**
-     * 注册连接数据监控，开启质量数据上报定时器
-     * @param listener
+     * 旧版本兼容参数，当收到非 `RTCMessageName.TOTAL_CONTENT_RESOURCE` 时：
+     * * ignore 值为 `true` 表示该消息由 signal server 向旧版本 RTCLib 提供的兼容消息，无需处理
+     * * 否则认为该消息是由旧版本 RTCLib 主动发出的增量变更消息，需要处理
      */
-    registerReportListener(listener: IRCRTCReportListener | null): void;
-    private _createRCRTCStateReport;
+    ignore?: boolean;
     /**
-     * 获取 peerConnection stats 数据并格式化
-     * @returns 返回格式化后的数据
+     * 发布到房间内的资源列表，`RTCMessageName.TOTAL_CONTENT_RESOURCE` 消息携带全量数据，否则为增量数据
      */
-    private _getStatsData;
-    getAudioLevelReportData(): Promise<{
-        trackId: string;
-        audioLevel: number | null;
-    }[] | undefined>;
+    uris: IPublishedResource[];
+    cdn_uris?: ICDNUris[];
+};
+
+/**
+ * 房间抽象基类
+ */
+declare abstract class RCAbstractRoom extends EventEmitter {
+    protected readonly _context: RTCPluginContext;
+    protected readonly _runtime: IRuntime;
+    readonly _roomId: string;
+    protected readonly _service: RCMediaService;
+    protected readonly _initOptions: IRCRTCInitOptions;
     /**
-     * 通知用户质量数据、peerConnection 北极星数据上报
-     * @todo
+     * 是否使用多 peerConnection
      */
-    private _reportHandle;
+    protected readonly _useMutilPeerC?: boolean | undefined;
+    protected readonly _clientSessionId: string;
     /**
-     * 北极星上报 R3、R4 数据
+     * 房间保活 rtcPing
      */
-    private _sendR3R4Data;
+    private _pinger;
     /**
-     * 2s 给北极星上报一次 R3、R4
+     * 北极星上报实例
      */
-    __reportR3R4ToPolaris(): Promise<void>;
-    getRTCPeerConn(): RTCPeerConnection;
-    destroy(): void;
-    clearReTryExchangeTimer(): void;
-}
-
-interface IRCTrackBitrate {
+    protected _polarisReport: PolarisReporter | null;
     /**
-     * 最大码率
+     * 音量上报实例
      */
-    max: number;
+    private _audioLevelReport;
     /**
-     * 最小码率
+     * peerConnection 管理类
      */
-    min: number;
+    protected _peerCManager: RCRTCPeerCManager | null;
+    protected readonly _invoker: Invoker;
+    protected readonly _store: ReadableStore;
+    constructor(_context: RTCPluginContext, _runtime: IRuntime, _roomId: string, _roomMode: RTCMode, _service: RCMediaService, _initOptions: IRCRTCInitOptions, isUpgrade?: boolean, isMainRoom?: boolean, 
     /**
-     * 上行起始码率
+     * 是否使用多 peerConnection
      */
-    start?: number;
-}
-/**
- * MediaServer 返回的媒体资源数据
- */
-interface IResource {
+    _useMutilPeerC?: boolean | undefined, _clientSessionId?: string);
+    __innerInit(mode: RTCMode, joinType?: RTCJoinType, livingType?: RCLivingType, innerUserDatas?: IRTCUserData, outerUserDatas?: IRTCUserData): Promise<{
+        code: RCRTCCode | ErrorCode;
+        data?: IJoinRTCRoomData;
+    }>;
+    protected _initWithRoomData(offlineKickTime: number): void;
+    private _handlePingResult;
     /**
-     * 媒体类型
+     * 设置房间上行资源的总码率配置
+     * @description
+     * * 自 v5.1.0 版本开始，推荐使用 `RCLocalTrack.setBitrate` 对不同流分别指定码率。
+     * * 该方法仅在 SDP `plan-b` 协议下（Chrome 92 与 Safari 11 之前的版本）有效。
+     * @param max 音视频发送码率上限，不可小于 200 且不可小于 `min`
+     * @param min 音视频发送码率下限，默认值为 1，且不可小于 1，不可大于 `max`
+     * @param start 起始码率，默认为码率上限的 70%
      */
-    mediaType: RCMediaType.AUDIO_ONLY | RCMediaType.VIDEO_ONLY;
+    setBitrate(max: number, min: number, start?: number): void;
+    private _onTrackReady;
+    protected _callAppListener(eventType: keyof IRoomEventListener, ...attrs: any[]): void;
+    private _onTrackUnpublish;
+    __parseInnerMessage(message: IReceivedMessage): boolean;
     /**
-     * MediaStream Id，基本为 `userId` 与 `tag` 以 `_` 拼接而来。该值无法直接作为资源的唯一性标识属性，
-     * 需与 mediaType 拼接使用
+     * 被踢出房间通知
+     * @param byServer
+     * * 当值为 false 时，说明本端 rtcPing 超时
+     * * 当值为 true 时，说明本端收到被踢出房间通知
      */
-    msid: string;
+    private _kickoff;
+    private _rtcpeerClosed;
     /**
-     * MediaServer 返回的资源地址
-     * @example 举例如下：
-     * `{"clusterId":"rtc-data-bdcbj.ronghub.com:80","serverId":"172.28.76.215:40080","resourceId":"13111111111_5vls_web_RongCloudRTC_1","connectionId":"AAYxMDAzNjgAFDEzMTExMTExMTExXzV2bHNfd2ViAAMzMzMA","ssrc":1716229921,"serviceProvider":"bdc","userTimestamp":1604994044706}`
+     * 处理资源变更事件
+     * @param content
+     * @param messageType 消息类型
+     * @param userId 消息发送者
      */
-    uri: string;
+    protected _resourceHandle(content: ResourceMsgContent, messageType: RCRTCMessageType.PUBLISH | RCRTCMessageType.UNPUBLISH | RCRTCMessageType.MODIFY | RCRTCMessageType.TOTAL_CONTENT_RESOURCE, userId: string): Promise<void>;
+    private _onTrackPublish;
     /**
-     * 资源特征，simulcast 代表这道流支持大小流
-     * @description 此参数存疑，MediaServer 似乎并未下发此字段，Web 端暂不启用
-     * @deprecated
+     * 处理 `RCRTCMessageType.STATE` 消息
+     * @param content
      */
-    features?: ['simulcast'] | [];
-}
-/**
- * 向房间内发布的媒体数据
- */
-interface IPublishedResource extends IResource {
+    private _stateHandle;
     /**
-     * 资源禁用/启用标识，用于向 signal 同步本端资源状态，1 为启用，0 为禁用
+     * 获取房间 Id
      */
-    state: 0 | 1;
+    getRoomId(): string;
     /**
-     * 资源标识，同标识的资源将视作同道流，标识不可重复
+     * 获取当前 userId
      */
-    tag: string;
-}
-interface ISubscribeAttr {
+    getCrtUserId(): string;
     /**
-     * 要订阅的音视轨数据 Id
+     * 获取 _pc 实例
      */
-    track: RCRemoteTrack;
+    __getPC(): RCRTCPeerConnection[];
     /**
-     * 订阅小流，默认为 `false`
+     * 获取远程用户列表，不包含当前用户
      */
-    subTiny?: boolean;
-}
-/**
- * 视频配置
- */
-interface IVideoProfile {
+    getRemoteUserIds(): string[];
     /**
-     * 视频帧率
+     * 获取所有房间已发布的远端资源列表
+     * @returns
      */
-    frameRate: RCFrameRate;
+    getRemoteTracks(): RCRemoteTrack[];
     /**
-     * 视频分辨率
+     * 获取远端用户的资源列表
+     * @param userId
+     * @returns
      */
-    resolution: RCResolution;
-}
-/**
- * 屏幕共享流配置
- */
-interface IScreenVideoProfile extends IVideoProfile {
+    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
     /**
-     * Electron 平台下通过 `desktopCapturer.getSources` 获取到的 sourceId，在 Electron 环境下为必填项。
-     * @see `https://www.electronjs.org/docs/api/desktop-capturer`
+     * 获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新
      */
-    chromeMediaSourceId?: string;
-}
-/**
- * 待发布资源数据
- */
-interface IPublishAttrs {
+    getSessionId(): string;
     /**
-     * 待发布的轨道数据
+     * 向房间内发消息
+     * @param name 消息名称
+     * @param content 消息内容
      */
-    track: RCLocalTrack;
+    sendMessage(name: string, content: any): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * 是否同时发布小流
+     * 设置房间属性
+     * @param key 属性名
+     * @param value 属性值
+     * @param message 是否在设置属性的时候携带消息内容，传空则不往房间中发送消息
+     * @param isInner RTC 业务内部使用参数，用户忽略
      */
-    pubTiny?: boolean | IVideoProfile;
-}
-/**
- * peerConnection 抛出给用户的 track 字段
- */
-interface IRCTrackStat {
+    setRoomAttribute(key: string, value: string, message?: {
+        name: string;
+        content: string;
+    }, isInner?: boolean): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * stat id
-    */
-    id?: string;
+     * 删除房间属性
+     * @param keys 待删除的属性名数组
+     * @param message 是否在删除属性的时候携带消息内容，传空则不往房间中发送消息
+     * @param isInner RTC 业务内部使用参数，用户忽略
+     */
+    deleteRoomAttributes(keys: string[], message?: {
+        name: string;
+        content: string;
+    }, isInner?: boolean): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * 资源 Id
+     * 获取房间属性
+     * @param keys 要查询的属性名数组，当数组长度为空时，取所有已设置的 kv 值
+     * @param isInner RTC 业务内部使用参数，用户忽略
      */
-    trackId: string;
+    getRoomAttributes(keys?: string[], isInner?: boolean): Promise<{
+        code: RCRTCCode;
+        data?: KVString;
+    }>;
     /**
-     * 资源类型
+     * 设置当前用户属性（暂不开放）
+     * @param key 属性名
+     * @param value 属性值
+     * @param message 是否在设置属性的时候携带消息内容，传空则不往房间中发送消息
      */
-    kind: 'audio' | 'video';
+    private _setUserAttributeValue;
     /**
-     * 丢包率，有效值 `0` - `1`
+     * 删除当前用户属性（暂不开放）
+     * @param keys 待删除的属性名数组
+     * @param message 是否在删除属性的时候携带消息内容，传空则不往房间中发送消息
      */
-    packetsLostRate: number | null;
+    private _deleteUserAttributes;
     /**
-     * 是否是远端资源
+     * 获取当前用户属性（暂不开放）
+     * @param keys 要查询的属性名数组
      */
-    remoteResource: boolean;
+    private _getUserAttributes;
     /**
-     * 音量
+     * 查询房间是否已销毁
      */
-    audioLevel?: number | null;
+    isDestroyed(): boolean;
     /**
-     * 视频高度
+     * 退出并销毁当前房间实例，退出后该房间的所有方法将不可用
      */
-    frameHeight?: number | null;
+    __destroy(quitRoom: boolean): Promise<void>;
     /**
-     * 视频宽度
+     * 退出房间之前禁用所有远端资源，避免退出动作耗时过长，
+     * 导致在未完全退出的过程中仍能听到房间内的声音问题
      */
-    frameWidth?: number | null;
+    private _muteRemoteTracksBeforeQuit;
+    private _leaveHandle;
     /**
-     * 视频帧率
+     * 释放 PCManager 上的资源
      */
-    frameRate?: number | null;
+    private _releasePCManager;
+    private _onLocalTrackDestroied;
     /**
-     * 码率
+     * 本端流状态修改，需通知房间内其他成员
+     * @param localTrack
      */
-    bitrate: number;
+    private _onLocalTrackMuted;
     /**
-     * 网络抖动，单位 ms
-     * @description 下行数据中，同道流中只有一个 track 会有值，另一轨道数据值为 `0`
+     * 增量发布资源，若发布的资源 tag 及媒体类型重复，后者将覆盖前者进行发布。
+     * @param tracks 待发布的 RCLocalTrack 实例
+     * @returns
      */
-    jitter: number | null;
-}
-/**
- * peerConnection 抛出给用户的 iceCandidatePair 字段
- */
-interface IRCCandidatePairStat {
+    publish(tracks: (RCLocalTrack | IPublishAttrs)[]): Promise<IPubSuccessRes>;
     /**
-     * 本端 IP
+     * 获取跨房间连麦需携带参数 pushOtherRooms 的值
      */
-    IP: string;
+    protected _getPushOtherRoomsParams(): IPushOtherRooms[];
     /**
-     * 本地 UDP 端口
+     * ice 断线后，尝试重新走 exchange
      */
-    port: number;
+    protected _reTryExchange(pcName: string, isPub: boolean): Promise<void>;
+    protected _getRTCReqestHeaders(pcName: string): IRTCReqHeader;
     /**
-     * 本地网络类型
+     * 增量取消资源发布，若相应资源中存在小流资源，则同时取消发布
+     * @param tracks 取消发布的 RCLocalTrack 列表
      */
-    networkType: string | null;
+    unpublish(tracks: RCLocalTrack[]): Promise<IPubSuccessRes>;
     /**
-     * 远端 IP
+     * 根据资源 Id 获取资源数据
+     * @param trackId
      */
-    remoteIP: string;
+    private _getResourceById;
     /**
-     * 远端 UDP 端口
+     * resourceId 有效性验证
+     * @param resourceId
      */
-    remotePort: number;
+    protected _isValidResourceId(resourceId: string): boolean;
+    private _subhook;
+    private _pubhook;
     /**
-     * 协议
+     * 订阅资源
+     * @param tracks
      */
-    protocol: string;
+    subscribe(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
     /**
-     * 发送总码率，单位 kbps
+     * 取消订阅资源
+     * @param tracks 预取消远端资源
      */
-    bitrateSend: number;
+    unsubscribe(tracks: RCRemoteTrack[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
     /**
-     * 接收总码率，单位 kbps
+     * 获取已发布的本地资源
+     * @param trackId
+     * @returns
      */
-    bitrateRecv: number;
+    getLocalTrack(trackId: string): RCLocalTrack | null;
     /**
-     * （Round-Trip-Time）往返时延，单位 ms
+     * 获取所有已发布的资源
      */
-    rtt: number | null;
+    getLocalTracks(): RCLocalTrack[];
     /**
-     * 可用上行带宽，单位 bit
+     * 根据 trackId 获取房间内的远端资源
+     * @param trackId
+     * @returns
      */
-    availableOutgoingBitrate: number | null;
+    getRemoteTrack(trackId: string): RCRemoteTrack | null;
     /**
-     * 可用下行带宽，在无下行资源时，其值为 `0`，单位: `bit`
+     * 强制修改订阅列表，仅订阅数组中的资源，取消订阅其他已订阅资源。
+     * 当参数为 `[]` 时，意味着不再订阅任何资源
+     * @param tracks 变更的资源列表
      */
-    availableIncomingBitrate: number | null;
-}
-/**
- * iceCandidatePair 所有字段
- * 含 peerConnection 抛出给用户的 iceCandidatePair 字段
- * 含 北极星上报 R3、R4 所需的 totalPacketsLost
- */
-interface IInnerIcePair extends IRCCandidatePairStat {
+    updateSubList(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
+    private _appListener;
     /**
-     * 上、下行总丢包率
+     * 注册事件监听器，多次注册会导致后者覆盖前者，可以通过使用 `registerRoomEventListener(null)` 取消注册
+     * @param listener
      */
-    totalPacketsLost?: number;
-}
-/**
- * send track 所有字段
- * 含 peerConnection 抛出给用户的 track 字段
- * 含 北极星上报 R3 track 所需字段
- */
-interface ISendTrackState extends IRCTrackStat {
+    registerRoomEventListener(listener: IRoomEventListener | null): void;
+    private _reportListener;
     /**
-     * （Round-Trip-Time）往返时延，单位 ms
+     * 注册房间数据监控
+     * @param listener
+     * @description 该方法暂仅支持 Chrome 浏览器
      */
-    rtt: number | null;
+    registerReportListener(listener: IRCRTCReportListener | null): void;
     /**
-     * 编码方式
+     * 音量上报
+     * @param handler 业务端传入的音量上报事件
+     * @param gap 上报时间间隔
      */
-    encoderImplementation: string | null;
+    onAudioLevelChange(handler: IAudioLevelChangeHandler | null, gap?: number): void;
     /**
-     * PLI 请求数
+     * 断线重连后尝试补发断线过程中的通知信息
      */
-    pliCount: number;
+    __onReconnected(livingType?: RCLivingType): Promise<{
+        data: IJoinRTCRoomData | undefined;
+    } | void>;
+    private _onAudioMuteChange;
+    private _onVideoMuteChange;
     /**
-     * nack 数量
+     * 存储连麦监听事件
      */
-    nackCount: number;
+    private _onRecvPKMsg;
     /**
-     * 第一个关键帧是否正常收到
+     * 注册 PK 业务监听方法
      */
-    googFirsSent: number;
+    protected _registerPKMsgListener(listener: IOnRecvPKMsg | null): void;
     /**
-     * 音频采样率
+     * 退出 PK 房间
      */
-    samplingRate: number;
+    protected _quitAllPKRoom(): void;
+    getClientSessionId(): string;
+}
+
+declare class RCLocalMediaStream {
+    readonly msid: string;
+    readonly mediaStream: MediaStream;
+    readonly tinyStream: MediaStream;
+    readonly tag: string;
+    constructor(msid: string);
+}
+
+interface IAudienceRoomEventListener extends IRCRTCTrackEventListener {
     /**
-     * 接收卡顿(间隔时间, 单位: ms)
+     * 主播加入
+     * @param userIds 加入主播的 id 列表
      */
-    googRenderDelayMs: number;
+    onAnchorJoin?(userId: string[]): void;
     /**
-     * 流状态(0:不可用, 1:可用)
+     * 主播退出
+     * @param userIds 退出主播的 id 列表
      */
-    trackState: TrackState;
-}
-/**
- * receive track 所有字段
- * 含 peerConnection 抛出给用户的 track 字段
- * 含 北极星上报 R4 track 所需字段
- */
-interface IRecvTrackState extends IRCTrackStat {
+    onAnchorLeave?(userId: string[]): void;
     /**
-     * 解码方式
+     * 房间内合流发布资源
+     * @param tracks 新发布的合流音轨与视轨数据列表，包含新发布的 RCRemoteAudioTrack 与 RCRemoteVideoTrack 实例
+     * @description
+     * 当房间内某个主播第一次发布资源时触发
      */
-    codecImplementationName: string | null;
-    samplingRate: number;
-    nackCount: number;
-    pliCount: number;
-    rtt: number | null;
-    googFirsReceived: number;
-    googRenderDelayMs: number;
-    trackState: TrackState;
-}
-/**
- * peerConnection stats 解析出来业务所需的所有字段
- */
-interface IInnerRCRTCStateReport {
-    timestamp: number;
-    iceCandidatePair?: IInnerIcePair;
-    senders: ISendTrackState[];
-    receivers: IRecvTrackState[];
-}
-/**
- * /**
- * peerConnection stats 抛给用户的字段
- */
-interface IRCRTCStateReport {
-    pcName?: string;
+    onTrackPublish?(tracks: RCRemoteTrack[]): void;
     /**
-     * 报告生成时间戳
+     * 房间内取消合流发布资源
+     * @param tracks 被取消发布的合流音轨与视轨数据列表
+     * @description
+     * 当房间内全部主播退出房间时，SDK 内部会取消对资源的订阅，业务层仅需处理 UI 业务
      */
-    timestamp: number;
+    onTrackUnpublish?(tracks: RCRemoteTrack[]): void;
     /**
-     * 对等连接状态数据
+     * 房间内主播发布资源
+     * @param tracks 主播新发布的音轨与视轨数据列表，包含新发布的 RCRemoteAudioTrack 与 RCRemoteVideoTrack 实例
      */
-    iceCandidatePair?: IRCCandidatePairStat;
+    onAnchorTrackPublish?(tracks: RCRemoteTrack[]): void;
     /**
-     * 上行状态数据
+     * 房间内主播取消发布资源
+     * @param tracks 被主播取消发布的音轨与视轨数据列表
+     * @description 当资源被取消发布时，SDK 内部会取消对相关资源的订阅，业务层仅需处理 UI 业务
      */
-    senders: IRCTrackStat[];
+    onAnchorTrackUnpublish?(tracks: RCRemoteTrack[]): void;
     /**
-     * 下行状态数据
+     * 房间主播禁用/启用音频
+     * @param audioTrack RCRemoteAudioTrack 类实例
      */
-    receivers: IRCTrackStat[];
-}
-interface IRCRTCReportListener {
+    onAudioMuteChange?(audioTrack: RCRemoteAudioTrack): void;
     /**
-     * RTCPeerConnection 的详细状态数据
-     * @param report
+    * 房间主播禁用/启用视频
+    * @param videoTrack RCRemoteVideoTrack 类实例对象
+    */
+    onVideoMuteChange?(videoTrack: RCRemoteVideoTrack): void;
+    /**
+     * 房间内主播把发布的资源推至 CDN
      */
-    onStateReport?(report: IRCRTCStateReport): void;
+    onCDNInfoEnable?(CDNInfo: {
+        resolution: RCResolution;
+        fps: RCFrameRate;
+    }): void;
     /**
-     * ICE 连接状态变更通知
-     * @since version 5.1.5
+     * 主播停止推 CDN
      */
-    onICEConnectionStateChange?(state: RTCIceConnectionState, pcName?: string): void;
+    onCDNInfoDisable?(): void;
     /**
-     * @deprecated
+     * 主播改变推 CDN 的分辨率或帧率
      */
-    onConnectionStateChange?(state: RTCPeerConnectionState, pcName?: string): void;
+    onCDNInfoChange?(CDNInfo: {
+        resolution: RCResolution;
+        fps: RCFrameRate;
+    }): void;
 }
-interface IRCRTCTrackEventListener {
+/**
+ * 观众直播房间类
+ * 处理：
+ * 1、通知观众房间内 人员变更、资源变更
+ * 2、观众订阅、取消订阅资源
+ */
+declare class RCAudienceLivingRoom {
+    private readonly _context;
+    private readonly _runtime;
+    private readonly _initOptions;
+    private readonly _roomId;
+    private readonly _joinResData;
+    readonly livingType: RCLivingType;
+    private _useMutilPeerC?;
+    protected readonly _clientSessionId: string;
+    private readonly _service;
     /**
-     * 订阅的音视频流通道已建立, track 已可以进行播放
-     * @param track RCRemoteTrack 类实例
+     * 主播列表
      */
-    onTrackReady?(track: RCRemoteTrack): void;
-}
-interface IRoomEventListener extends IRCRTCTrackEventListener {
+    private _roomAnchorList;
     /**
-     * 当 RTCPeerConnection 连接被异常关闭时触发，此时需业务层重新加入房间并重新发布、订阅资源。
-     * 引起连接异常中断的原因包括但不限于：电脑休眠、浏览器页面长期后台运行等
-     * @since 5.1.5
+     * 合流、分流资源
      */
-    onRTCPeerConnectionCloseByException?(): void;
+    private _roomRes;
     /**
-     * 当本端被剔出房间时触发
-     * @description 被踢出房间可能是由于服务端超出一定时间未能收到 rtcPing 消息，所以认为己方离线。
-     * 另一种可能是己方 rtcPing 失败次数超出上限
-     * @param byServer 当值为 `false` 时，说明本端 rtcPing 超时；当值为 `true` 时，说明本端收到被踢出房间通知
+     * 主播分流资源
      */
-    onKickOff?(byServer: boolean, state?: RCKickReason): void;
+    private _roomAnchorRes;
     /**
-     * 接收到房间信令时回调，用户可通过房间实例的 sendMessage 接口发送信令
-     * @param name 信令名
-     * @param content 信令内容
-     * @param senderUserId 发送者 Id
-     * @param messageUId 消息唯一标识
+     * 合流、分流 remoteTracks
      */
-    onMessageReceive?(name: string, content: any, senderUserId: string, messageUId: string): void;
+    private _remoteTracks;
+    private _appListener;
+    private _pc;
+    private _subscribedList;
+    private _sessionId;
+    private _destroyed;
     /**
-     * 房间属性变更回调
-     * @param name
-     * @param content
+     * 北极星上报实例
      */
-    onRoomAttributeChange?(name: string, content?: string): void;
+    protected _polarisReport: PolarisReporter | null;
     /**
-     * 房间用户禁用/启用音频
-     * @param audioTrack RCRemoteAudioTrack 类实例
+     * 音量上报实例
      */
-    onAudioMuteChange?(audioTrack: RCRemoteAudioTrack): void;
+    private _audioLevelReport;
     /**
-     * 房间用户禁用/启用视频
-     * @param videoTrack RCRemoteVideoTrack 类实例对象
+     * cdn_uris 资源
      */
-    onVideoMuteChange?(videoTrack: RCRemoteVideoTrack): void;
+    private _CDNUris;
     /**
-     * 房间内用户发布资源
-     * @param tracks 新发布的音轨与视轨数据列表，包含新发布的 RCRemoteAudioTrack 与 RCRemoteVideoTrack 实例
+     * 使用的 peerConnection 对应 id
      */
-    onTrackPublish?(tracks: RCRemoteTrack[]): void;
+    private _pcName;
     /**
-     * 房间用户取消发布资源
-     * @param tracks 被取消发布的音轨与视轨数据列表
-     * @description 当资源被取消发布时，SDK 内部会取消对相关资源的订阅，业务层仅需处理 UI 业务
+     * peerConnection 管理类
+    */
+    private _peerCManager;
+    constructor(_context: RTCPluginContext, _runtime: IRuntime, _initOptions: IRCRTCInitOptions, _roomId: string, _joinResData: {
+        token: string;
+        kvEntries: IServerRTCRoomEntry[];
+    }, livingType: RCLivingType, _useMutilPeerC?: boolean | undefined, _clientSessionId?: string);
+    /**
+     * 解析服务端返回的 KV 数据，赋值 room 内数据
      */
-    onTrackUnpublish?(tracks: RCRemoteTrack[]): void;
+    private _setInitData;
+    protected _assertRoomDestroyed(): RCRTCCode | undefined;
     /**
-     * 人员加入
-     * @param userIds 加入的人员 id 列表
+     * @description 信令数据处理
+     * @param roomId 数据对应的房间 Id
+     * @param singalData 拉取到的数据
+     * * key RC_ANCHOR_LIST value: 为主播 ID 集合
+     * * key RC_RES_`userId` value: 为主播发布的资源
+     * * key RC_RTC_SESSIONID value: sessionId
+     * * key RC_CDN value: CDN 资源数据
      */
-    onUserJoin?(userIds: string[]): void;
+    private singalDataChange;
     /**
-     * 人员退出
-     * @param userIds
+     * 计算加入离开的主播 ID 列表
      */
-    onUserLeave?(userIds: string[]): void;
+    private _diffAnchorList;
+    private _handleNewJoinedAnchor;
+    private _handleLeftedAnchor;
     /**
-     * 主播开启、停止推 CDN 状态通知
+     * 计算新发布和取消发布的合流资源
      */
-    onCDNEnableChange?(enable: boolean): void;
+    private _diffRoomResource;
     /**
-     * RTC 每次 Ping 的结果
-     * @since version: 5.1.5
+     * 计算主播发布和取消发布的资源，以及资源的状态变更
+    */
+    private _diffAnchorResource;
+    private _onUserUnpublish;
+    private _callAppListener;
+    /**
+     * ice 断线后，尝试重新走 exchange
+    */
+    private _reTryExchange;
+    /**
+     * 获取 subscribe 接口的请求体数据
+     * @param subscribeList 订阅清单
+     * @param publishedStreams 已发布流
+     * @param iceRestart
      */
-    onPing?(result: RCRTCPingResult): void;
+    protected _createSubscribeParams(subscribeList: ISubscribeAttr[], publishedStreams: {
+        [msid: string]: RCLocalMediaStream;
+    }, iceRestart: boolean): Promise<{
+        reqBody: IBroadcastSubReqBody;
+        offer: RTCSessionDescriptionInit;
+        dynamicBitrate: {
+            min: number;
+            max: number;
+        };
+    }>;
+    private _subscribeHandle;
     /**
-     * 主播和观众切换身份通知
+     * 添加 peerConnection 事件
      */
-    onSwitchRole?(userId: string, role: RCRTCLiveRole): void;
-}
-/**
- * RTCClient 初始化配置
- * @public
- */
-interface IRCRTCInitOptions {
+    private _addPeerCEvent;
+    private _getReqHeaders;
+    private _exchangeHandle;
+    private _updateSubListHandle;
     /**
-     * 自定义 MediaServer Url，公有云用户无需关注
-     * @description
-     * 1. 仅当 `location.hostname` 为 `localhost` 时，`http` 协议地址有效，否则必须使用 `https` 协议地址
-     * 2. 当该值有效时，将不再从 IMLib 导航数据中获取 mediaServer 地址
+     * 对比 cdn_uris 资源
+     * @param newCDNUris 新的 cdn_uris 数据
      */
-    mediaServer?: string;
+    private _diffCDNUris;
     /**
-     * 输出日志等级，生产环境默认使用 WARN，开发环境默认为 DEBUG
-     * @description
-     * * 0 - DEBUG
-     * * 1 - INFO
-     * * 2 - WARN
-     * * 3 - ERROR
+     * 获取 CDN 资源对应的拉流地址
+     * _CDNUris 无 url 时，说明未开启 CDN 推送
+     * @returns CDNPlayUrl
      */
-    logLevel?: LogLevel;
+    private _getCDNPlayUrl;
     /**
-     * 修改默认的 log 输出函数
+     * 获取 CDN 资源对应的拉流地址
+     * @returns CDNPlayUrl
      */
-    logStdout?: (logLevel: LogLevel, content: string) => void;
+    getCDNPlayUrl(resolution?: RCResolution, fps?: RCFrameRate): Promise<{
+        code: RCRTCCode;
+        CDNPlayUrl?: string;
+    }>;
     /**
-     * 与 MediaServer 的 http 请求超时时间，单位为毫秒，默认值为 `5000`，有效值 `5000-30000`。
-     * 优先级：用户配置 > 导航配置 > 默认时间。
+     * 订阅资源
+     * @param tracks
      */
-    timeout?: number;
+    subscribe(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
+    private __unsubscribe;
     /**
-     * 房间 Ping 间隔时长，默认 `10000` ms，有效值 `3000`-`10000`
+     * 取消订阅资源
+     * @param tracks
      */
-    pingGap?: number;
+    unsubscribe(tracks: RCRemoteTrack[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
     /**
-     * 优化使用的 SDP 协议版本，仅当运行时浏览器支持相应 SDP 协议版本时生效
+     * 退出房间并销毁当前房间实例，退出后该房间的所有方法将不可用
      */
-    sdpSemantics?: ISdpSemantics;
+    __destroy(quitRoom: boolean): Promise<void>;
     /**
-     * 观众拉内置 CDN 资源的直播拉流协议，默认为 RCInnerCDNPullKind.FLV
+     * 根据 trackId 获取房间内的远端资源
+     * @param trackId
      */
-    pullInnerCDNProtocol?: RCInnerCDNPullKind;
+    getRemoteTrack(trackId: string): RCRemoteTrack;
     /**
-     * 观众拉内置 CDN 资源时是否使用 https，默认为 RCInnerCDNPullIsHttps.HTTPS
+     * 获取 _pc 实例
      */
-    pullInnerCDNUseHttps?: RCInnerCDNPullIsHttps;
-}
-interface ICameraVideoProfile extends IVideoProfile {
-    cameraId?: string;
-    faceMode?: 'user' | 'environment';
-}
-interface IMicphoneAudioProfile {
-    micphoneId?: string;
-    sampleRate?: number;
-}
-interface ICreateLocalTrackOptions {
+    __getPC(): RCRTCPeerConnection[];
     /**
-     * 剔除音轨
+     * TODO 待优化
+     * @param trackId
      */
-    withoutAudio?: boolean;
+    getLocalTrack(trackId: string): RCRemoteTrack;
     /**
-     * 剔除视轨
+     * 断线重连后处理逻辑, SDK 内部处理调用
      */
-    withoutVideo?: boolean;
-}
-/**
- * 音量上报事件接口
- */
-interface IAudioLevelChangeHandler {
-    (audioLevelReportList: {
-        track: RCLocalAudioTrack | RCRemoteAudioTrack;
-        audioLevel: number;
-    }[]): void;
-}
-/**
- * 房间资源数据
- */
-declare type RoomData = {
-    [userId: string]: IPublishedResource[];
-};
-/**
- * IMutilPeerC 中的 track 类型
- */
-declare type TrackParam = RCLocalTrack | IPublishAttrs | RCRemoteTrack | ISubscribeAttr;
-/**
- * RCRTCPeerCManager 创建的一条 pcItem 上的数据类型
- */
-interface IMutilPeerC {
+    __onReconnected(): Promise<void>;
     /**
-     * pcName，/exchange 请求中 request header 中的 Peer-Connection-Id 值
+     * 观众房间事件注册
+     * @param tag 参数描述
      */
-    pcName: string;
+    registerRoomEventListener(listener: IAudienceRoomEventListener | null): void;
     /**
-     * RCRTCPeerConnection 对象
+     * 音量上报
+     * @param handler 业务端传入的音量上报事件
+     * @param gap 上报时间间隔
      */
-    pc: RCRTCPeerConnection;
+    onAudioLevelChange(handler: IAudioLevelChangeHandler | null, gap?: number): void;
+    private _reportListener;
     /**
-     * 存放 peerConnection 上本次要发布、取消发布、订阅、取消订阅的 track
+     * 注册房间数据监控
+     * @param listener
      */
-    tracks: TrackParam[];
-}
-interface IPKInfo {
-    [roomId: string]: {
-        inviteSessionId: string;
-        inviterRoomId: string;
-        inviterUserId: string;
-        inviterUserAutoMix?: boolean;
-        inviteeRoomId: string;
-        inviteeUserAutoMix?: boolean;
-    };
-}
-/**
- * 业务层发起连麦、响应连麦可选参数定义
- */
-interface IReqResPKOptions {
-    autoMix?: boolean;
-    extra?: string;
-}
-interface IPKInviterBaseInfo {
+    registerReportListener(listener: IRCRTCReportListener | null): void;
     /**
-     * 邀请者房间 ID
+     * 获取房间 Id
      */
-    inviterRoomId: string;
+    getRoomId(): string;
     /**
-     * 邀请者用户 ID
+     * 获取当前 userId
      */
-    inviterUserId: string;
-}
-interface IPKInviteeBaseInfo {
+    getCrtUserId(): string;
     /**
-     * 被邀请者房间 ID
+     * 获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新
      */
-    inviteeRoomId: string;
+    getSessionId(): string;
     /**
-     * 被邀请者用户 ID
+     * 获取远程主播用户列表
      */
-    inviteeUserId: string;
-}
-/**
- * 业务层监听收到连麦邀请、取消连麦的字段
- */
-interface IPKInviteInfo extends IPKInviterBaseInfo {
+    getRemoteUserIds(): string[];
     /**
-     * 邀请额外信息
+     * 获取远端用户的资源列表
+     * @param userId
+     * @returns
      */
-    extra?: string;
-}
-/**
- * 业务层监听收到连麦应答的字段
- */
-interface IPKInviteAnswerInfo extends IPKInviterBaseInfo, IPKInviteeBaseInfo {
+    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
     /**
-     * 是否同意邀请
+     * 获取房间内所有已发布的远端资源列表, 包含合流资源
+     * @returns
      */
-    agree: boolean;
+    getRemoteTracks(): RCRemoteTrack[];
     /**
-     * 响应额外信息
+     * 获取远端 RTC tracks
      */
-    extra?: string;
-}
-/**
- * 业务层监听收到连麦结束的字段
- */
-interface IPKEndInfo {
+    getRemoteRTCTracks(): RCRemoteTrack[];
     /**
-     * 发起结束的房间 ID
+     * 获取远端 MCU tracks
      */
-    endRoomId: string;
+    getRemoteMCUTracks(): RCRemoteTrack[];
     /**
-     * 发起结束的用户 ID
+     * 获取房间内 CDN 信息
      */
-    endUserId: string;
-}
-/**
- * 观众加房间返回给客户的 CDN 信息
- */
-interface IJoinResCDNInfo {
-    resolution?: RCResolution;
-    fps?: RCFrameRate;
-    CDNEnable?: boolean;
-}
-
-declare enum RCInnerCDNPushMode {
-    AUTOMATIC = 0,
-    MANUAL = 1
-}
-
-declare enum RCInnerCDNBroadcast {
-    SPREAD = 0,
-    NO_SPREAD = -1
+    getCDNInfo(): {
+        resolution: RCResolution;
+        fps: RCFrameRate;
+        CDNEnable: boolean | undefined;
+    } | {
+        CDNEnable: boolean;
+        resolution?: undefined;
+        fps?: undefined;
+    };
+    getClientSessionId(): string;
 }
 
 /**
- * 与 MediaServer 交互所需的 Request Header 信息
+ * 北极星上报角色
  */
-interface IRTCReqHeader {
-    /**
-     * RTC Token
-     * @todo 有效期问题处理
-     */
-    Token: string;
-    /**
-     * 房间 Id
-     */
-    RoomId: string;
+declare enum PolarisRole {
     /**
-     * 用户 Id
+     * 会议参会者、主播
      */
-    UserId: string;
+    MeetingOrAnchor = 1,
     /**
-     * 仅在直播模式下需要
+     * 观众
      */
-    RoomType?: RTCMode;
+    Audience = 2
+}
+
+declare class PolarisReporter {
+    private readonly _context;
+    private readonly _runtime;
+    private readonly _roomId;
+    private readonly _crtRTCRoom;
+    private readonly _userRole;
+    constructor(_context: RTCPluginContext, _runtime: IRuntime, _roomId: string, _crtRTCRoom: RCAbstractRoom | RCAudienceLivingRoom, _userRole?: PolarisRole);
+    private _send;
+    private _getClientID;
     /**
-     * 开发者的 AppKey
+     * 小流需去掉 _tiny，小流 resourceId 为 userId_tag_mediaType_tiny
      */
-    'App-Key': string;
+    private _getRealResourceId;
     /**
-     * signal 会话 session id
+     * 生成北极星上报的 trackId
+     * @param resourceId userId_11_1_tiny 改为 userId_11_tiny_video
      */
-    'Session-Id'?: string;
+    private _getPolarisTrackId;
+    sendR3R4Data(data: IInnerRCRTCStateReport): Promise<boolean>;
     /**
-     * peerConnection Id
+     * 加入房间
      */
-    'Peer-Connection-Id'?: string;
+    sendR1(): void;
     /**
-     * client-session-id 标识一个端用户进入房间后的唯一标识
+     * RTC 和 LIVE 发布、取消发布
+     * RTC 订阅、取消订阅
      */
-    'Client-Session-Id'?: string;
-}
-interface IMCUReqHeaders {
-    'App-Key': string;
-    Token: string;
-    RoomId: string;
-    UserId: string;
-    SessionId: string;
+    sendR2(action: string, status: string, trackIds: string[]): void;
 }
+
 /**
- * exchange 接口中 pushOtherRooms 字段接口
+ * PC 实例管理类
  */
-interface IPushOtherRooms {
-    /**
-     * 房间 Id
-     */
-    roomId: string;
-    /**
-    * 是否默认合流
-    */
-    autoMix: boolean;
+declare class RCRTCPeerConnection extends EventEmitter {
     /**
-    * 房间 Id 对应的 SessionId
+     * peerConnection 对应名称
     */
-    sessionId: string;
-}
-/**
- * exchange 接口的请求体结构
- */
-interface IExchangeReqBody {
-    /**
-     * local description
-     */
-    sdp: IOfferInfo;
+    private readonly _pcName;
     /**
-     * 订阅列表
+     * _reTryExchange 方法
      */
-    subscribeList: {
-        /**
-         * 流资源 uri
-         */
-        uri: string;
-        /**
-         * 大小流订阅，`1` 为大流，`2` 为小流，默认使用大流
-         */
-        simulcast: RCStreamType;
-        /**
-         * 分辨率信息
-         */
-        resolution: string;
-    }[];
+    private readonly _reTryExchange;
     /**
-     * 透传参数，一般用于传递参数给其他服务，如 MCU/Record 等，MediaServer 仅透传不处理
-     * @example `{"resolutionInfo":[{"trackId":"021ad6e8-a50c-479c-96c8-5f3f09d2352d","simulcast":1,"resolution":"640x480"}]}`
+     * 当前用户 id
      */
-    extend: string;
+    private readonly _currentUserId;
     /**
-     * 跨房间连麦时其他房间的推流信息
+     * 北极星上传实例
      */
-    pushOtherRooms?: IPushOtherRooms[];
+    private readonly _polarisReport?;
+    static __INNER_EVENT_TRACK_READY__: string;
+    private readonly _rtcPeerConn;
+    private readonly _sdpStrategy;
+    reportParser: IStatParser | null;
+    private pubLocalTracks;
+    private _reTryExchangeTimer;
+    private _reportStatsTimer;
+    private _reportR3R4ToPolarisTimer;
+    constructor(
     /**
-     * server 根据网络动态切换大小流开关，默认为 `false`
-     */
-    switchstream: boolean;
-}
-interface ILiveUrls {
+     * peerConnection 对应名称
+    */
+    _pcName: string, 
     /**
-     * MCU 服务地址，直播模式中用于向 MCU 服务提交 CDN 及合流配置
+     * _reTryExchange 方法
      */
-    configUrl: string;
+    _reTryExchange: Function, 
     /**
-     * 观众端订阅地址，由业务层分发
+     * 当前用户 id
      */
-    liveUrl: string;
+    _currentUserId: string, 
     /**
-     * 自动推 CDN 模式下，发布资源后返回的 CDN 信息
+     * 北极星上传实例
      */
-    pull_url?: string;
-}
-interface IRTCResponse {
+    _polarisReport?: PolarisReporter | undefined);
+    getName(): string;
+    getLocalTracks(): RCLocalTrack[];
+    private _onConnectionStateChange;
+    private _onICEConnectionStateChange;
+    private _onTrackReady;
+    setBitrate(max: number, min: number, start?: number): Promise<void>;
+    createOffer(iceRestart: boolean): Promise<IOfferInfo>;
+    setRemoteAnswer(answer: string): Promise<RCRTCCode>;
+    getLocalTrack(trackId: string): RCLocalTrack | null;
+    addLocalTrack(track: RCLocalTrack): void;
+    removeLocalTrackById(trackId: string): void;
+    removeAllLocalTrack(): void;
+    removeLocalTrack(track: RCLocalTrack): void;
+    private _updateRecvTransceiverMap;
+    updateSubRemoteTracks(remoteTracks: RCRemoteTrack[]): void;
     /**
-     * 请求响应码，只有在 resultCode 值为 `10000` 时才为正常响应
+     * 获取当前已发布视频流信息
      */
-    resultCode: RCRTCCode;
-    /**
-   * 与 resultCode 相应的可读性文字信息
-   */
-    message: string;
+    getOutboundVideoInfo(): OutboundVideoInfo[];
+    private _onLocalTrackMuted;
+    private _onLocalTrackDestroied;
+    private _reportListener;
     /**
-     * 客户端发送的 Request-Id
+     * 注册连接数据监控，开启质量数据上报定时器
+     * @param listener
      */
-    'Request-Id': string;
-}
-/**
- * /exchange 响应结果
- */
-interface IExchangeResponse extends IRTCResponse {
+    registerReportListener(listener: IRCRTCReportListener | null): void;
+    private _createRCRTCStateReport;
     /**
-     * 数据中心地址，当存在此值时，后续所有请求发送到该地址。该地址不携带协议头，故需要补全 `https://` 协议头
+     * 获取 peerConnection stats 数据并格式化
+     * @returns 返回格式化后的数据
      */
-    clusterId: string;
+    private _getStatsData;
+    getAudioLevelReportData(): Promise<{
+        trackId: string;
+        audioLevel: number | null;
+    }[] | undefined>;
     /**
-     * 发布的资源列表
+     * 通知用户质量数据、peerConnection 北极星数据上报
+     * @todo
      */
-    publishList: IResource[];
+    private _reportHandle;
     /**
-     * @deprecated 目前并未使用，服务器返回值为 ''
+     * 北极星上报 R3、R4 数据
      */
-    roomId: '';
+    private _sendR3R4Data;
     /**
-     * 远端 SDP 数据
+     * 2s 给北极星上报一次 R3、R4
      */
-    sdp: {
-        type: 'answer';
-        sdp: string;
-    };
+    __reportR3R4ToPolaris(): Promise<void>;
+    getRTCPeerConn(): RTCPeerConnection;
+    destroy(): void;
+    clearReTryExchangeTimer(): void;
+}
+
+interface IRCTrackBitrate {
     /**
-     * 直播模式推流数据，仅在直播模式有值
+     * 最大码率
      */
-    urls?: ILiveUrls;
+    max: number;
     /**
-     * 跨房间连麦响应数据
+     * 最小码率
      */
-    otherRoomsRes?: {
-        [roomId: string]: ILiveUrls;
-    };
+    min: number;
     /**
-     * 直播 mcu 资源
-     * 主播发布为具体资源，会议模式为空数组
+     * 上行起始码率
      */
-    mcuPublishList?: IResource[];
+    start?: number;
+}
+/**
+ * MediaServer 返回的媒体资源数据
+ */
+interface IResource {
     /**
-     * 订阅成功的资源
+     * 媒体类型
      */
-    subscribedList?: {
-        mediaType: RCMediaType.AUDIO_ONLY | RCMediaType.VIDEO_ONLY;
-        msid: string;
-        userId: string;
-        simulcast?: RCStreamType;
-    }[];
-}
-interface IBroadcastSubReqBody {
+    mediaType: RCMediaType.AUDIO_ONLY | RCMediaType.VIDEO_ONLY;
     /**
-     * 客户端 offer
+     * MediaStream Id，基本为 `userId` 与 `tag` 以 `_` 拼接而来。该值无法直接作为资源的唯一性标识属性，
+     * 需与 mediaType 拼接使用
      */
-    sdp: {
-        type: 'offer';
-        sdp: string;
-    };
+    msid: string;
     /**
-     * 直播信息
+     * MediaServer 返回的资源地址
+     * @example 举例如下：
+     * `{"clusterId":"rtc-data-bdcbj.ronghub.com:80","serverId":"172.28.76.215:40080","resourceId":"13111111111_5vls_web_RongCloudRTC_1","connectionId":"AAYxMDAzNjgAFDEzMTExMTExMTExXzV2bHNfd2ViAAMzMzMA","ssrc":1716229921,"serviceProvider":"bdc","userTimestamp":1604994044706}`
      */
-    liveUrl?: string;
+    uri: string;
     /**
-     * 订阅的资源类型，默认为 `RCMediaType.AUDIO_VIDEO`
+     * 资源特征，simulcast 代表这道流支持大小流
+     * @description 此参数存疑，MediaServer 似乎并未下发此字段，Web 端暂不启用
+     * @deprecated
      */
-    mediaType?: RCMediaType;
+    features?: ['simulcast'] | [];
+}
+/**
+ * 向房间内发布的媒体数据
+ */
+interface IPublishedResource extends IResource {
     /**
-     * 订阅大/小流，默认订阅大流
+     * 资源禁用/启用标识，用于向 signal 同步本端资源状态，1 为启用，0 为禁用
      */
-    simulcast?: RCStreamType;
+    state: 0 | 1;
     /**
-     * 允许 server 根据网络状况动态切换大小流，默认为 false
+     * 资源标识，同标识的资源将视作同道流，标识不可重复
      */
-    switchstream: boolean;
+    tag: string;
+}
+interface ISubscribeAttr {
     /**
-     * 订阅列表
+     * 要订阅的音视轨数据 Id
      */
-    subscribeList?: {
-        /**
-         * 流资源 uri
-         */
-        uri: string;
-        /**
-         * 大小流订阅，`1` 为大流，`2` 为小流，默认使用大流
-         */
-        simulcast: RCStreamType;
-        /**
-         * 分辨率信息
-         */
-        resolution: string;
-    }[];
+    track: RCRemoteTrack;
     /**
-     * 是否采用新版本模式，加入房间
+     * 订阅小流，默认为 `false`
      */
-    newVersionFlag?: boolean;
+    subTiny?: boolean;
 }
-interface IBroadcastSubRespBody extends IRTCResponse {
+/**
+ * 视频配置
+ */
+interface IVideoProfile {
     /**
-     * 已订阅的资源列表
+     * 视频帧率
      */
-    subscribedList: IResource[];
+    frameRate: RCFrameRate;
     /**
-     * 远端 SDP
+     * 视频分辨率
      */
-    sdp: {
-        type: 'answer';
-        sdp: string;
-    };
+    resolution: RCResolution;
 }
 /**
- * 获取 CDN 资源拉流地址请求 headers
+ * 屏幕共享流配置
  */
-interface ICDNPlayUrlReqHeaders extends IMCUReqHeaders {
+interface IScreenVideoProfile extends IVideoProfile {
+    /**
+     * Electron 平台下通过 `desktopCapturer.getSources` 获取到的 sourceId，在 Electron 环境下为必填项。
+     * @see `https://www.electronjs.org/docs/api/desktop-capturer`
+     */
+    chromeMediaSourceId?: string;
 }
 /**
- * 获取 CDN 资源拉流地址响应
+ * 待发布资源数据
  */
-interface ICDNPlayUrlResponse extends IRTCResponse {
-    data: {
-        fps: number;
-        h: number;
-        'pull_url': string;
-        w: number;
-    };
+interface IPublishAttrs {
+    /**
+     * 待发布的轨道数据
+     */
+    track: RCLocalTrack;
+    /**
+     * 是否同时发布小流
+     */
+    pubTiny?: boolean | IVideoProfile;
 }
 /**
- * cdn_uris 里面包含的字段
+ * peerConnection 抛出给用户的 track 字段
  */
-interface ICDNUris {
+interface IRCTrackStat {
     /**
-     * 是否扩散
+     * stat id
+    */
+    id?: string;
+    /**
+     * 资源 Id
      */
-    broadcast: RCInnerCDNBroadcast;
+    trackId: string;
     /**
-     * 拉流资源的宽度
+     * 资源类型
      */
-    w?: number;
+    kind: 'audio' | 'video';
     /**
-     * 拉流资源的高度
+     * 丢包率，有效值 `0` - `1`
      */
-    h?: number;
+    packetsLostRate: number | null;
     /**
-    * 帧率
-    */
-    fps?: number;
+     * 是否是远端资源
+     */
+    remoteResource: boolean;
     /**
-     * 获取拉流地址的 url
+     * 音量
      */
-    url: string;
+    audioLevel?: number | null;
     /**
-     * 开启、停用 CDN
+     * 视频高度
      */
-    enableInnerCDN?: boolean;
+    frameHeight?: number | null;
     /**
-     * 推送模式，手动 or 自动
+     * 视频宽度
      */
-    'push_mode': RCInnerCDNPushMode;
-    'pull_safe': boolean;
-}
-
-/**
- * 直播布局模式定义
- */
-declare enum MixLayoutMode {
+    frameWidth?: number | null;
     /**
-     * 自定义布局
+     * 视频帧率
      */
-    CUSTOMIZE = 1,
+    frameRate?: number | null;
     /**
-     * 悬浮布局（默认）
+     * 码率
      */
-    SUSPENSION = 2,
+    bitrate: number;
     /**
-     * 自适应布局
+     * 网络抖动，单位 ms
+     * @description 下行数据中，同道流中只有一个 track 会有值，另一轨道数据值为 `0`
      */
-    ADAPTATION = 3
+    jitter: number | null;
 }
-
 /**
- * 合流布局对视频的填充模式
+ * peerConnection 抛出给用户的 iceCandidatePair 字段
  */
-declare enum MixVideoRenderMode {
+interface IRCCandidatePairStat {
     /**
-     * 裁剪（默认）
+     * 本端 IP
      */
-    CROP = 1,
+    IP: string;
     /**
-     * 不裁剪
+     * 本地 UDP 端口
      */
-    WHOLE = 2
-}
-
-declare enum RCInnerCDNModel {
-    OPEN = 1,
-    STOP = 2
-}
-
-declare enum RCMixInputFilterMode {
-    /** 全合流，后续加入房间的用户会自动合流 */
-    AUDIO_VIDEO_ALL = 0,
-    /** 全不合流，后续加入本房间的用户 */
-    AUDIO_VIDEO_NO = 1,
-    /** 音频全订阅, 视频全不订阅 */
-    AUDIO_ALL_VIDEO_NO = 2,
-    /** 视频全订阅, 音频全不订阅 */
-    AUDIO_NO_VIDEO_ALL = 3,
+    port: number;
     /**
-     * 根据设置的音频合流列表和视频合流列表合并媒体流
+     * 本地网络类型
      */
-    AUDIO_VIDEO_INPUT = 4,
-    /** 音频全订阅，视频根据设置的视频合流列表 */
-    AUDIO_ALL_VIDEO_INPUT = 5,
-    /** 音频全不订阅, 视频根据input里面的视频项订阅 */
-    AUDIO_NO_VIDEO_INPUT = 6,
-    /** 视频全订阅, 音频根据input里面的音频项订阅 */
-    AUDIO_INPUT_VIDEO_ALL = 7,
-    /** 视频全不订阅, 音频根据input里面的音频项订阅 */
-    AUDIO_INPUT_VIDEO_NO = 8,
-    /** 按房间列表订阅音视频(保留当前已经订阅的, 但没在房间列表里的音视频) */
-    ROOM_AUDIO_VIDEO_APPEND = 9,
-    /** 按房间列表订阅音视频(清理当前已经订阅的, 但没在房间列表里的音视频) */
-    ROOM_AUDIO_VIDEO_NOT_APPEND = 10,
-    /** 按房间列表订阅音频, 不订阅视频(保留当前已经订阅的, 但没在房间列表里的音频) */
-    ROOM_AUDIO_APPEND = 11,
-    /** 按房间列表订阅音视, 不订阅视频(清理当前已经订阅的, 但没在房间列表里的音频) */
-    ROOM_AUDIO_NOT_APPEND = 12,
-    /** 按房间列表订阅视频, 不订阅音频(保留当前已经订阅的, 但没在房间列表里的视频) */
-    ROOM_VIDEO_APPEND = 13,
-    /** 按房间列表订阅视频, 不订阅音频(清理当前已经订阅的, 但没在房间列表里的视频) */
-    ROOM_VIDEO_NOT_APPEND = 14
-}
-
-/**
- * 合流后的 video 输出编码配置，包含分辨率、帧率、码率配置项
- */
-interface IMCUOutputVideoAttrs {
+    networkType: string | null;
     /**
-     * 视频分辨率宽度
+     * 远端 IP
      */
-    width?: number;
+    remoteIP: string;
     /**
-     * 视频分辨率高度
+     * 远端 UDP 端口
      */
-    height?: number;
+    remotePort: number;
     /**
-     * 帧率
+     * 协议
      */
-    fps?: number;
+    protocol: string;
     /**
-     * 码率
+     * 发送总码率，单位 kbps
      */
-    bitrate?: number;
-}
-/**
- * 合并入 MCU 的音频流
- */
-interface IMCUInputAudio {
-    user_id: string;
-    stream_id: string;
+    bitrateSend: number;
+    /**
+     * 接收总码率，单位 kbps
+     */
+    bitrateRecv: number;
+    /**
+     * （Round-Trip-Time）往返时延，单位 ms
+     */
+    rtt: number | null;
+    /**
+     * 可用上行带宽，单位 bit
+     */
+    availableOutgoingBitrate: number | null;
+    /**
+     * 可用下行带宽，在无下行资源时，其值为 `0`，单位: `bit`
+     */
+    availableIncomingBitrate: number | null;
 }
 /**
- * 自定义布局中的单一视频流布局
+ * iceCandidatePair 所有字段
+ * 含 peerConnection 抛出给用户的 iceCandidatePair 字段
+ * 含 北极星上报 R3、R4 所需的 totalPacketsLost
  */
-interface IMCUInputVideoLayout {
-    user_id: string;
-    stream_id: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
+interface IInnerIcePair extends IRCCandidatePairStat {
+    /**
+     * 上、下行总丢包率
+     */
+    totalPacketsLost?: number;
 }
 /**
- * 图片配置，用于水印、视频流背景图
+ * send track 所有字段
+ * 含 peerConnection 抛出给用户的 track 字段
+ * 含 北极星上报 R3 track 所需字段
  */
-interface IPictureAttrs {
-    /**
-     * 资源下载地址，需包含协议
-     */
-    uri: string;
+interface ISendTrackState extends IRCTrackStat {
     /**
-     * 相对于整体画布的起始位置 x 坐标
+     * （Round-Trip-Time）往返时延，单位 ms
      */
-    x: number;
+    rtt: number | null;
     /**
-     * 相对于整体画布的起始位置 y 坐标
+     * 编码方式
      */
-    y: number;
+    encoderImplementation: string | null;
     /**
-     * 相对于整体画布的宽（百分比），有效值 `0.0` - `1.0`
+     * PLI 请求数
      */
-    w: number;
+    pliCount: number;
     /**
-     * 相对于整体画布的高（百分比），有效值 `0.0` - `1.0`
+     * nack 数量
      */
-    h: number;
-}
-/**
- * 合流后的 Video 输出配置，包含背景图、背景色、大小流编码等配置项
- */
-interface IMCUOutputVideoConfig {
+    nackCount: number;
     /**
-     * 标准流输出定义
+     * 第一个关键帧是否正常收到
      */
-    normal?: IMCUOutputVideoAttrs;
+    googFirsSent: number;
     /**
-     * 小流输出定义
+     * 音频采样率
      */
-    tiny?: IMCUOutputVideoAttrs;
-    exparams?: {
-        /**
-         * 合流布局时，对视频流的填充方式
-         */
-        renderMode: MixVideoRenderMode;
-    };
+    samplingRate: number;
     /**
-     * 背景色，如 `'0xf1a2c3'`
+     * 接收卡顿(间隔时间, 单位: ms)
      */
-    backgroundColor?: string;
+    googRenderDelayMs: number;
     /**
-     * 背景图
+     * 流状态(0:不可用, 1:可用)
      */
-    backgroundPicture?: {
-        /**
-         * 填充模式：
-         * 1. 按比例裁剪
-         * 2. 不裁剪，按比例压缩
-         */
-        fillMode: 1 | 2;
-        /**
-         * 资源列表
-         */
-        picture: IPictureAttrs[];
-    };
+    trackState: TrackState;
 }
 /**
- * 合流后的媒体输出定义
+ * receive track 所有字段
+ * 含 peerConnection 抛出给用户的 track 字段
+ * 含 北极星上报 R4 track 所需字段
  */
-interface IMCUOutputConfig {
-    /**
-     * 输出视频配置
-     */
-    video: IMCUOutputVideoConfig;
-    /**
-     * 输出音频配置
-     */
-    audio?: {
-        /**
-         * 音频码率
-         */
-        bitrate: number;
-    };
+interface IRecvTrackState extends IRCTrackStat {
     /**
-     * CDN 推流地址列表
+     * 解码方式
      */
-    cdn?: {
-        /**
-         * 推流地址，如：`'rtmp://xxxx'`
-         */
-        pushurl: string;
-    }[];
+    codecImplementationName: string | null;
+    samplingRate: number;
+    nackCount: number;
+    pliCount: number;
+    rtt: number | null;
+    googFirsReceived: number;
+    googRenderDelayMs: number;
+    trackState: TrackState;
 }
 /**
- * 时间戳参数，用于水印
+ * peerConnection stats 解析出来业务所需的所有字段
  */
-interface ITimestampAttrs {
+interface IInnerRCRTCStateReport {
+    timestamp: number;
+    iceCandidatePair?: IInnerIcePair;
+    senders: ISendTrackState[];
+    receivers: IRecvTrackState[];
+}
+/**
+ * /**
+ * peerConnection stats 抛给用户的字段
+ */
+interface IRCRTCStateReport {
+    pcName?: string;
     /**
-     * 时区
+     * 报告生成时间戳
      */
-    timezone: number;
+    timestamp: number;
     /**
-     * 字体像素大小
+     * 对等连接状态数据
      */
-    fontSize: number;
+    iceCandidatePair?: IRCCandidatePairStat;
     /**
-     * 字体颜色
+     * 上行状态数据
      */
-    color: 'black' | 'white';
+    senders: IRCTrackStat[];
     /**
-     * 透明度，有效值 `0.0` 至 `1.0`
+     * 下行状态数据
      */
-    alpha: number;
+    receivers: IRCTrackStat[];
+}
+interface IRCRTCReportListener {
     /**
-     * 相较于整体画布的 x 坐标（百分比），有效值 `0.0` 至 `1.0`
+     * RTCPeerConnection 的详细状态数据
+     * @param report
      */
-    x: number;
+    onStateReport?(report: IRCRTCStateReport): void;
     /**
-     * 相较于整体画布的 y 坐标（百分比），有效值 `0.0` 至 `1.0`
+     * ICE 连接状态变更通知
+     * @since version 5.1.5
      */
-    y: number;
+    onICEConnectionStateChange?(state: RTCIceConnectionState, pcName?: string): void;
+    /**
+     * @deprecated
+     */
+    onConnectionStateChange?(state: RTCPeerConnectionState, pcName?: string): void;
 }
-/**
- * 文本参数，用于水印
- */
-interface ITextAttrs {
+interface IRCRTCTrackEventListener {
     /**
-     * 文字内容
+     * 订阅的音视频流通道已建立, track 已可以进行播放
+     * @param track RCRemoteTrack 类实例
      */
-    content: string;
+    onTrackReady?(track: RCRemoteTrack): void;
+}
+interface IRoomEventListener extends IRCRTCTrackEventListener {
     /**
-     * 文字像素
+     * 当 RTCPeerConnection 连接被异常关闭时触发，此时需业务层重新加入房间并重新发布、订阅资源。
+     * 引起连接异常中断的原因包括但不限于：电脑休眠、浏览器页面长期后台运行等
+     * @since 5.1.5
      */
-    fontSize: number;
+    onRTCPeerConnectionCloseByException?(): void;
     /**
-     * 文字颜色
+     * 当本端被剔出房间时触发
+     * @description 被踢出房间可能是由于服务端超出一定时间未能收到 rtcPing 消息，所以认为己方离线。
+     * 另一种可能是己方 rtcPing 失败次数超出上限
+     * @param byServer 当值为 `false` 时，说明本端 rtcPing 超时；当值为 `true` 时，说明本端收到被踢出房间通知
      */
-    color: 'black' | 'white';
+    onKickOff?(byServer: boolean, state?: RCKickReason): void;
     /**
-     * 透明度，有效值 `0.0` 至 `1.0`
+     * 接收到房间信令时回调，用户可通过房间实例的 sendMessage 接口发送信令
+     * @param name 信令名
+     * @param content 信令内容
+     * @param senderUserId 发送者 Id
+     * @param messageUId 消息唯一标识
      */
-    alpha: number;
+    onMessageReceive?(name: string, content: any, senderUserId: string, messageUId: string): void;
     /**
-     * 相较于整体画布的 x 坐标（百分比），有效值 `0.0` 至 `1.0`
+     * 房间属性变更回调
+     * @param name
+     * @param content
      */
-    x: number;
+    onRoomAttributeChange?(name: string, content?: string): void;
     /**
-     * 相较于整体画布的 y 坐标（百分比），有效值 `0.0` 至 `1.0`
+     * 房间用户禁用/启用音频
+     * @param audioTrack RCRemoteAudioTrack 类实例
      */
-    y: number;
-}
-/**
- * 屏幕水印配置
- */
-interface IWaterMarkConfig {
+    onAudioMuteChange?(audioTrack: RCRemoteAudioTrack): void;
     /**
-     * 时间戳水印配置
+     * 房间用户禁用/启用视频
+     * @param videoTrack RCRemoteVideoTrack 类实例对象
      */
-    timestamp?: ITimestampAttrs;
+    onVideoMuteChange?(videoTrack: RCRemoteVideoTrack): void;
     /**
-     * 图片水印配置
+     * 房间内用户发布资源
+     * @param tracks 新发布的音轨与视轨数据列表，包含新发布的 RCRemoteAudioTrack 与 RCRemoteVideoTrack 实例
      */
-    picture?: IPictureAttrs[];
+    onTrackPublish?(tracks: RCRemoteTrack[]): void;
     /**
-     * 文字水印配置
+     * 房间用户取消发布资源
+     * @param tracks 被取消发布的音轨与视轨数据列表
+     * @description 当资源被取消发布时，SDK 内部会取消对相关资源的订阅，业务层仅需处理 UI 业务
      */
-    text: ITextAttrs[];
-}
-/**
- * 合流前的单一视频流水印配置
- */
-interface IMCUSignalScreenWaterMarkConfig extends IWaterMarkConfig {
+    onTrackUnpublish?(tracks: RCRemoteTrack[]): void;
     /**
-     * 媒体流的 msid
+     * 人员加入
+     * @param userIds 加入的人员 id 列表
      */
-    streamId: string;
-}
-interface IMCUWaterMarkConfig {
+    onUserJoin?(userIds: string[]): void;
     /**
-     * 合流后的屏幕水印配置
+     * 人员退出
+     * @param userIds
      */
-    mixScreen: IWaterMarkConfig;
+    onUserLeave?(userIds: string[]): void;
     /**
-     * 合流前的单人视频流水印配置
+     * 主播开启、停止推 CDN 状态通知
      */
-    signalScreen: IMCUSignalScreenWaterMarkConfig[];
-}
-/**
- * 发布到服务器的 MCU 配置数据
- */
-interface IMCUConfig {
+    onCDNEnableChange?(enable: boolean): void;
     /**
-     * 为向后兼容，当前为常量 1
+     * RTC 每次 Ping 的结果
+     * @since version: 5.1.5
      */
-    version: 1;
+    onPing?(result: RCRTCPingResult): void;
     /**
-     * 布局模式，在只配置推流 CDN 时，该值不存在
+     * 主播和观众切换身份通知
      */
-    mode: MixLayoutMode;
+    onSwitchRole?(userId: string, role: RCRTCLiveRole): void;
+}
+/**
+ * RTCClient 初始化配置
+ * @public
+ */
+interface IRCRTCInitOptions {
     /**
-     * 渲染到主位置上的流 Id，当该值为空时，输出到主位置的流按发布时间顺序优先选择最早发布的流
+     * 自定义 MediaServer Url，公有云用户无需关注
+     * @description
+     * 1. 仅当 `location.hostname` 为 `localhost` 时，`http` 协议地址有效，否则必须使用 `https` 协议地址
+     * 2. 当该值有效时，将不再从 IMLib 导航数据中获取 mediaServer 地址
      */
-    host_stream_id?: string;
+    mediaServer?: string;
     /**
-     * 自定义布局输入定义，只有在 mode 值为 `MixLayoutMode.CUSTOMIZE` 时需传值
+     * 输出日志等级，生产环境默认使用 WARN，开发环境默认为 DEBUG
+     * @description
+     * * 0 - DEBUG
+     * * 1 - INFO
+     * * 2 - WARN
+     * * 3 - ERROR
      */
-    input?: {
-        video?: IMCUInputVideoLayout[];
-        audio?: IMCUInputAudio[];
-    };
+    logLevel?: LogLevel;
     /**
-     * 合流后的媒体输出配置
+     * 修改默认的 log 输出函数
      */
-    output?: IMCUOutputConfig;
+    logStdout?: (logLevel: LogLevel, content: string) => void;
     /**
-     * 水印配置
+     * 与 MediaServer 的 http 请求超时时间，单位为毫秒，默认值为 `5000`，有效值 `5000-30000`。
+     * 优先级：用户配置 > 导航配置 > 默认时间。
      */
-    waterMark?: IMCUWaterMarkConfig;
+    timeout?: number;
     /**
-     * MCU 拉流配置，决定 MCU 从 MediaServer 拉流的方式
+     * 房间 Ping 间隔时长，默认 `10000` ms，有效值 `3000`-`10000`
      */
-    inputFilterMode?: RCMixInputFilterMode;
+    pingGap?: number;
     /**
-     * MCU 混入列表中房间内的资源
+     * 优化使用的 SDP 协议版本，仅当运行时浏览器支持相应 SDP 协议版本时生效
      */
-    mixRooms?: string[];
-}
-/**
- * 设置开启、停用内置 CDN 数据
- */
-interface ISetEnableCDN {
-    version: 2;
-    output: {
-        /**
-         * 手动开启/停用内置 CDN
-         */
-        inCDNModel: RCInnerCDNModel;
-    };
-}
-
-declare class RCMediaService {
-    private readonly _runtime;
-    private readonly _context;
+    sdpSemantics?: ISdpSemantics;
     /**
-     * 自定义 MediaServer 地址，当有值时，不再使用导航内的地址
+     * 观众拉内置 CDN 资源的直播拉流协议，默认为 RCInnerCDNPullKind.FLV
      */
-    private readonly _msUrl?;
+    pullInnerCDNProtocol?: RCInnerCDNPullKind;
     /**
-     * 请求超时时长
+     * 观众拉内置 CDN 资源时是否使用 https，默认为 RCInnerCDNPullIsHttps.HTTPS
      */
-    private readonly _timeout;
+    pullInnerCDNUseHttps?: RCInnerCDNPullIsHttps;
+}
+interface ICameraVideoProfile extends IVideoProfile {
+    cameraId?: string;
+    faceMode?: 'user' | 'environment';
+}
+interface IMicphoneAudioProfile {
+    micphoneId?: string;
+    sampleRate?: number;
+}
+interface ICreateLocalTrackOptions {
     /**
-     * navi 中获取的媒体服务地址
+     * 剔除音轨
      */
-    private readonly _msInNavi;
+    withoutAudio?: boolean;
     /**
-     * 已失败的请求地址
+     * 剔除视轨
      */
-    private readonly _failedMs;
+    withoutVideo?: boolean;
+}
+/**
+ * 音量上报事件接口
+ */
+interface IAudioLevelChangeHandler {
+    (audioLevelReportList: {
+        track: RCLocalAudioTrack | RCRemoteAudioTrack;
+        audioLevel: number;
+    }[]): void;
+}
+/**
+ * 房间资源数据
+ */
+declare type RoomData = {
+    [userId: string]: IPublishedResource[];
+};
+/**
+ * IMutilPeerC 中的 track 类型
+ */
+declare type TrackParam = RCLocalTrack | IPublishAttrs | RCRemoteTrack | ISubscribeAttr;
+/**
+ * RCRTCPeerCManager 创建的一条 pcItem 上的数据类型
+ */
+interface IMutilPeerC {
     /**
-     * 服务器指纹数据，客户端不得修改，直接透传
+     * pcName，/exchange 请求中 request header 中的 Peer-Connection-Id 值
      */
-    private _rtcFinger;
+    pcName: string;
     /**
-     * 服务器接口返回的 clusterId 数据，当此数据有值时，后续所有请求向此服务发送
+     * RCRTCPeerConnection 对象
      */
-    private _clusterId;
+    pc: RCRTCPeerConnection;
     /**
-     * MCU 服务地址
+     * 存放 peerConnection 上本次要发布、取消发布、订阅、取消订阅的 track
      */
-    private _configUrl;
-    constructor(_runtime: IRuntime, _context: RTCPluginContext, 
+    tracks: TrackParam[];
+}
+interface IPKInfo {
+    [roomId: string]: {
+        inviteSessionId: string;
+        inviterRoomId: string;
+        inviterUserId: string;
+        inviterUserAutoMix?: boolean;
+        inviteeRoomId: string;
+        inviteeUserAutoMix?: boolean;
+    };
+}
+/**
+ * 业务层发起连麦、响应连麦可选参数定义
+ */
+interface IReqResPKOptions {
+    autoMix?: boolean;
+    extra?: string;
+}
+interface IPKInviterBaseInfo {
     /**
-     * 自定义 MediaServer 地址，当有值时，不再使用导航内的地址
+     * 邀请者房间 ID
      */
-    _msUrl?: string | undefined, 
+    inviterRoomId: string;
     /**
-     * 请求超时时长
+     * 邀请者用户 ID
      */
-    _timeout?: number);
-    getNaviMS(): string[];
+    inviterUserId: string;
+}
+interface IPKInviteeBaseInfo {
     /**
-     * 发送请求，请求发送若失败，会继续尝试使用后续可用地址直到无地址可用，此时认为请求失败
-     * @param path
-     * @param header
-     * @param body
+     * 被邀请者房间 ID
      */
-    private _request;
+    inviteeRoomId: string;
     /**
-     * 资源协商接口，订阅、发布、变更资源均可以使用此接口。该接口通过 sdp 字段交换 SDP 信息，
-     * 并通过 subscribeList 和 publishList 表明最终发布和订阅的资源。本端产出 offer，服务器产出 answer
-     * 每次接口调用，都会全量覆盖发布和订阅的资源。
-     * @param header
-     * @param body
+     * 被邀请者用户 ID
      */
-    exchange(headers: IRTCReqHeader, body: IExchangeReqBody): Promise<{
-        code: RCRTCCode;
-        data?: IExchangeResponse | undefined;
-    }>;
+    inviteeUserId: string;
+}
+/**
+ * 业务层监听收到连麦邀请、取消连麦的字段
+ */
+interface IPKInviteInfo extends IPKInviterBaseInfo {
     /**
-     * 退出房间
+     * 邀请额外信息
      */
-    exit(headers: IRTCReqHeader): Promise<RCRTCCode>;
+    extra?: string;
+}
+/**
+ * 业务层监听收到连麦应答的字段
+ */
+interface IPKInviteAnswerInfo extends IPKInviterBaseInfo, IPKInviteeBaseInfo {
     /**
-     * 观众端订阅主播资源
+     * 是否同意邀请
      */
-    broadcastSubscribe(headers: IRTCReqHeader, body: IBroadcastSubReqBody): Promise<{
-        code: RCRTCCode;
-        data?: IBroadcastSubRespBody | undefined;
-    }>;
+    agree: boolean;
     /**
-     * 观众端退出订阅
+     * 响应额外信息
      */
-    broadcastExit(headers: IRTCReqHeader): Promise<{
-        code: RCRTCCode;
-    }>;
+    extra?: string;
+}
+/**
+ * 业务层监听收到连麦结束的字段
+ */
+interface IPKEndInfo {
     /**
-     * 直播推流、自定义布局配置
+     * 发起结束的房间 ID
      */
-    setMcuConfig(headers: IMCUReqHeaders, body: IMCUConfig | ISetEnableCDN): Promise<{
-        code: RCRTCCode;
-        res?: any;
-    }>;
+    endRoomId: string;
     /**
-     * 房间内观众获取 CDN 资源信息、拉流地址
+     * 发起结束的用户 ID
      */
-    getCDNResourceInfo(headers: ICDNPlayUrlReqHeaders, url: string): Promise<{
+    endUserId: string;
+}
+/**
+ * 观众加房间返回给客户的 CDN 信息
+ */
+interface IJoinResCDNInfo {
+    resolution?: RCResolution;
+    fps?: RCFrameRate;
+    CDNEnable?: boolean;
+}
+interface IPubSuccessRes {
+    code: RCRTCCode;
+    liveUrl?: string;
+    failedTracks?: {
         code: RCRTCCode;
-        res?: ICDNPlayUrlResponse;
-    }>;
+        tracks: RCLocalTrack[];
+    }[];
 }
 
 /**
@@ -2944,37 +3095,26 @@ declare enum BackgroundPictureFillMode {
 }
 
 declare class RCMCUConfigBuilder {
+    private _invoker;
     /**
      * flush 提交回调
      */
-    private readonly _onFlush;
     /**
      * trackId 有效性验证方法
      */
     private readonly _isValidTrackId;
-    /**
-     * 扩散 cdn_uris
-     */
-    private readonly _sendCDNInfoSignal;
     /**
      * mcu 配置数据，每次向服务器提交全量数据
      */
     private _values;
-    constructor(
+    constructor(_invoker: Invoker, 
     /**
      * flush 提交回调
      */
-    _onFlush: (config: IMCUConfig) => Promise<{
-        code: RCRTCCode;
-    }>, 
     /**
      * trackId 有效性验证方法
      */
-    _isValidTrackId: (trackId: string) => boolean, 
-    /**
-     * 扩散 cdn_uris
-     */
-    _sendCDNInfoSignal: () => void);
+    _isValidTrackId: (trackId: string) => boolean);
     /**
      * 设置合流后的主位置显示的视频流
      * @param videoTrackId 视频流资源 Id
@@ -3141,6 +3281,7 @@ declare class RCMCUConfigBuilder {
     flush(reset?: boolean): Promise<{
         code: RCRTCCode;
     }>;
+    __innerGetValues(): IMCUConfig;
 }
 
 /**
@@ -3148,29 +3289,32 @@ declare class RCMCUConfigBuilder {
  */
 declare class RCLivingRoom extends RCAbstractRoom {
     private _livingType;
-    /**
-     * 是否是主房间
-     */
-    protected _isMainRoom: boolean;
     readonly _mcuConfigBuilder: RCMCUConfigBuilder;
     /**
-     * cdn_uris 信令扩散数据
+     * 跨房间连麦管理器
      */
-    private _CDNUris;
-    private _CDNEnable;
+    private _roomPKHandler;
+    constructor(context: RTCPluginContext, runtime: IRuntime, roomId: string, service: RCMediaService, initOptions: IRCRTCInitOptions, _livingType: RCLivingType, isUpgrade?: boolean, isMainRoom?: boolean, 
     /**
-     * 跨房间连麦管理器
+     * 是否使用多 peerConnection
      */
-    private readonly _roomPKHandler;
-    constructor(context: RTCPluginContext, runtime: IRuntime, roomId: string, data: IJoinRTCRoomData, service: RCMediaService, initOptions: IRCRTCInitOptions, clientEvent: Function, _livingType: RCLivingType, isUpgrage: boolean | undefined, 
+    useMutilPeerC?: boolean, _clientSessionId?: string);
+    private _initAfterCatchRoomData;
     /**
-     * 是否是主房间
+     * @override
      */
-    _isMainRoom: boolean, 
+    __innerInit(mode: RTCMode, joinType?: RTCJoinType, livingType?: RCLivingType, innerUserDatas?: IRTCUserData, outerUserDatas?: IRTCUserData): Promise<{
+        code: RCRTCCode | ErrorCode;
+        data?: IJoinRTCRoomData;
+    }>;
+    __innerInitByIdentityChange(): Promise<ErrorCode>;
     /**
-     * 是否使用多 peerConnection
+     * 增量发布资源，若发布的资源 tag 及媒体类型重复，后者将覆盖前者进行发布。
+     * @param tracks 待发布的 RCLocalTrack 实例
+     * @returns
      */
-    useMutilPeerC?: boolean, _clientSessionId?: string);
+    publish(tracks: (RCLocalTrack | IPublishAttrs)[]): Promise<IPubSuccessRes>;
+    unpublish(tracks: RCLocalTrack[]): Promise<IPubSuccessRes>;
     /**
      * resourceId 有效性验证
      * @param resourceId
@@ -3183,58 +3327,19 @@ declare class RCLivingRoom extends RCAbstractRoom {
     getMCUConfigBuilder(): RCMCUConfigBuilder | {
         code: RCRTCCode;
     };
-    /**
-     * 接收 MCU 配置并向 MediaServer 提交
-     * @param data
-     */
-    private _onMCUConfigFlush;
-    /**
-     * 主播端断线重连后，需更新内存中的 CDN 数据
-     * 判断房间内 CDN 状态是否和内存数据一致，不一致时需通知到客户端
-     */
-    __onReconnected(): Promise<void>;
     /**
      * 开启/停用推 CDN
      */
     enableInnerCDN(enable: boolean): Promise<{
         code: RCRTCCode;
     }>;
-    /**
-     * 开启、停用 CDN 推资源后发信令
-     */
-    private _sendCDNInfoSignal;
-    /**
-     * 扩散 cdn_uris 资源
-     */
-    private _spreadCDNInfo;
-    /**
-     * 给房间设置 CDN 数据
-     */
-    private _setRoomCDNInfo;
     /**
      * 资源变化时触发
      * 直播房间需单独处理 cdn_uris
      */
-    protected _resourceHandle(content: {
-        /**
-         * 旧版本兼容参数，当收到非 `RTCMessageName.TOTAL_CONTENT_RESOURCE` 时：
-         * * ignore 值为 `true` 表示该消息由 signal server 向旧版本 RTCLib 提供的兼容消息，无需处理
-         * * 否则认为该消息是由旧版本 RTCLib 主动发出的增量变更消息，需要处理
-         */
-        ignore?: boolean;
-        /**
-         * 发布到房间内的资源列表，`RTCMessageName.TOTAL_CONTENT_RESOURCE` 消息携带全量数据，否则为增量数据
-         */
-        uris: IPublishedResource[];
+    protected _resourceHandle(content: ResourceMsgContent & {
         cdn_uris?: ICDNUris[];
-    }, messageType: string, userId: string): Promise<void>;
-    /**
-     * 重写父类 _exchangeHandle 方法
-     */
-    protected _exchangeHandle(body: IExchangeReqBody, pcName: string): Promise<{
-        code: RCRTCCode;
-        data?: IExchangeResponse | undefined;
-    }>;
+    }, messageType: RCRTCMessageType.PUBLISH | RCRTCMessageType.UNPUBLISH | RCRTCMessageType.MODIFY | RCRTCMessageType.TOTAL_CONTENT_RESOURCE, userId: string): Promise<void>;
     /**
      * 观众切换为主播后直接处理人员变更及资源变更
      */
@@ -3243,28 +3348,20 @@ declare class RCLivingRoom extends RCAbstractRoom {
      * 返回 CDN 是否可用
      * @returns boolean
      */
-    __getCDNEnable(): boolean | undefined;
+    __getCDNEnable(): boolean;
     /**
      * 返回 CDN 推送模式: 自动 or 手动
-     * @returns boolean
      */
     __getCDNPushMode(): RCInnerCDNPushMode | undefined;
     /**
+     * @override
      * 加入 PK 房间回调
      */
     private _onJoinedPKRoom;
-    /**
-     * 离开 PK 房间后，如果参与过连麦，pushOtherRooms 需去掉退出的连麦房间配置，重新和 mediaServer 交互
-     */
-    private _onLeavePKRoom;
     /**
      * @override
      */
     protected _getPushOtherRoomsParams(): IPushOtherRooms[];
-    /**
-     * 携带 pushOtherRooms 与 mediaServer 重新交互
-     */
-    private _exchangeWithPushOtherRoom;
     /**
      * 获取 PK 业务处理器
      * @since version 5.3.0
@@ -3280,14 +3377,14 @@ declare class RCLivingRoom extends RCAbstractRoom {
     /**
      * 是否是主房间
      */
-    isMainRoom(): boolean;
+    isMainRoom(): boolean | undefined;
 }
 
 /**
  * 普通音视频房间
  */
 declare class RCRTCRoom extends RCAbstractRoom {
-    constructor(context: RTCPluginContext, runtime: IRuntime, roomId: string, data: IJoinRTCRoomData, service: RCMediaService, initOptions: IRCRTCInitOptions, clientEvent: Function, 
+    constructor(context: RTCPluginContext, runtime: IRuntime, roomId: string, service: RCMediaService, initOptions: IRCRTCInitOptions, isUpgrade?: boolean, isMainRoom?: boolean, 
     /**
      * 是否使用多 peerConnection
      */
@@ -3303,7 +3400,6 @@ declare class RCAudienceClient {
      * 是否使用多 peerConnection
      */
     private readonly _useMutilPeerC?;
-    private readonly _clientSessionId?;
     private _pc;
     private _service;
     /**
@@ -3330,11 +3426,12 @@ declare class RCAudienceClient {
      * peerConnection 管理类
      */
     private _peerCManager;
+    private readonly _clientSessionId;
     constructor(_context: RTCPluginContext, runtime: IRuntime, _initOption: IRCRTCInitOptions, 
     /**
      * 是否使用多 peerConnection
      */
-    _useMutilPeerC?: boolean | undefined, _clientSessionId?: string | undefined);
+    _useMutilPeerC?: boolean | undefined);
     private _getReqHeaders;
     private _clearSubscribeInfo;
     private _livingType;
@@ -3392,7 +3489,6 @@ declare class RCRTCClient {
      * 获取加入的连麦房间
      */
     private _getJoinedPKRoomList;
-    private _getPKRoomIds;
     /**
      * 获取当前用户 Id，若 IM 未连接，这返回 `''`
      * @returns
@@ -3411,7 +3507,6 @@ declare class RCRTCClient {
         userIds?: string[];
         tracks?: RCRemoteTrack[];
     }>;
-    private _joinRTCRoom;
     /**
      * 主播加入直播房间或观众上麦场景调用，观众上麦之前需先取消已订阅的直播间资源
      * @param roomId 房间 Id
@@ -3426,7 +3521,6 @@ declare class RCRTCClient {
         tracks?: RCRemoteTrack[];
         CDNEnable?: boolean;
     }>;
-    private _joinLivingRoom;
     private _audience;
     /**
      * 获取直播观众客户端
@@ -3441,11 +3535,6 @@ declare class RCRTCClient {
     leaveRoom(room: RCAbstractRoom): Promise<{
         code: RCRTCCode;
     }>;
-    private _leaveRoom;
-    /**
-     * 清除 _crtRoom 的引用
-     */
-    private _releaseCrtRoomObj;
     private _getMediaStream;
     /**
      * 从麦克风中捕获音轨数据