@rongcloud/plugin-rtc 5.32.0-c-im-alpha.2 → 5.34.0-alpha.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _rongcloud_engine from '@rongcloud/engine';
-import { EventEmitter, BasicLogger, INaviInfo, LogL, EnableLogL, RTCPluginContext, Codec, IPromiseResult, ErrorCode, KVString, IRuntime, IAsyncRes, RCConnectionStatus, ConversationType, ISendMsgOptions, IReceivedMessage, RTCMode as RTCMode$1, IPluginGenerator } from '@rongcloud/engine';
+import { EventEmitter, BasicLogger, INaviInfo, RTCPluginContext, Codec, IPromiseResult, ErrorCode, KVString, IRuntime, IAsyncRes, RCConnectionStatus, ConversationType, ISendMsgOptions, IReceivedMessage, LogL, EnableLogL, RTCMode as RTCMode$1, IPluginGenerator } from '@rongcloud/engine';
 
 /**
  * 错误码，与移动端对齐
@@ -28,6 +28,10 @@ declare enum RCRTCCode {
     SERVICE_INVALID = 50004,
     /** RTC Token 无效 */
     RTC_TOKEN_INVALID = 50006,
+    /** 后台未开通语音识别服务 */
+    ASR_NOT_AVAILABLE = 50034,
+    /** 此房间未开启语音识别服务 */
+    ASR_NOT_START = 50035,
     /** 底层信令调用错误 */
     SIGNAL_ERROR = 53001,
     /** 创建 Offer 失败 */
@@ -598,6 +602,24 @@ declare enum RTCMode {
     CALL = 5
 }
 
+/**
+ * ASR 状态枚举
+ */
+declare enum RCRTCASRStatus {
+    /**
+     * 无效值
+     */
+    VOID = "0",
+    /**
+     * 打开
+     */
+    OPEN = "2",
+    /**
+     * 关闭
+     */
+    CLOSE = "1"
+}
+
 /**
  * 与 MediaServer 交互所需的 Request Header 信息
  */
@@ -702,6 +724,10 @@ interface IExchangeReqBody {
      * 是否支持 ipv6
      */
     ipType: number;
+    /**
+     * asr 开关状态
+     */
+    asr_status: RCRTCASRStatus;
 }
 interface ILiveUrls {
     /**
@@ -890,6 +916,11 @@ interface ICDNUris {
     'pull_safe': boolean;
 }
 
+declare enum RCRTCAISwitchType {
+    OPEN = 1,
+    CLOSE = 0
+}
+
 /**
  * 设置 RTC 人员 inner、outer 数据
  */
@@ -1078,6 +1109,10 @@ interface IRTCNaviInfo extends INaviInfo {
      *  openGzip  开启标识,默认是false,开启使用true
     */
     openGzip?: boolean;
+    /**
+     * AI 开关是否打开，1: 打开，0: 关闭
+     */
+    rtcAISwitch?: RCRTCAISwitchType;
 }
 
 declare abstract class ReadableStore {
@@ -1124,6 +1159,32 @@ declare abstract class ReadableStore {
     protected _trackIdSSRCMap: Map<number, string>;
     protected _roomStatusVersion: number;
     protected _supportNtf: boolean;
+    /**
+     * asr 的打开状态
+     */
+    protected _asrStatus: RCRTCASRStatus;
+    /**
+     * asr 是否被启用
+     */
+    protected _asrEnable: boolean;
+    /**
+     * asr 输入语言，用于精准识别语音
+     */
+    protected _srcLanguage: string;
+    /**
+     * asr sei uris 信息
+     */
+    protected _asrSeiUris: {
+        [userId: string]: IPublishedResource[];
+    };
+    /**
+     * 是否开启实时翻译
+     */
+    protected _isStartRealTranslate: boolean;
+    /**
+     * 翻译目标语言
+     */
+    protected _translationLang: string;
     constructor(_logger: BasicLogger, clientSessionId: string, appkey: string, roomId: string, crtUserId: string, roomMode: RTCMode, isUpgrade?: boolean | undefined, isMainRoom?: boolean | undefined);
     getResourcesByUserId(userId: string): IPublishedResource[] | undefined;
     getRemoteTrack(trackId: string): RCRemoteAudioTrack | RCRemoteVideoTrack | undefined;
@@ -1144,6 +1205,13 @@ declare abstract class ReadableStore {
     getTrackIdBySSRC(ssrc: number): string | undefined;
     getRTCRequestHeader(): IRTCReqHeader;
     getSupportNtf(): boolean;
+    getASRIsAvailable(): boolean;
+    getASRStatus(): RCRTCASRStatus;
+    getASREnable(): boolean;
+    getSrcLanguage(): string;
+    getASRSeiUris(): IPublishedResource[];
+    getIsStartRealTranslate(): boolean;
+    getTranslationLang(): string;
 }
 declare class Store extends ReadableStore {
     /**
@@ -1164,6 +1232,197 @@ declare class Store extends ReadableStore {
     resetSubscribedList(subscribeList: ISubscribeAttr[]): void;
     resetCollectSubscribeList(collectSubscribeList: ISubscribeAttr[]): void;
     setRoomStatusVersion(version: number): void;
+    setASRStatus(status: RCRTCASRStatus): void;
+    setASREnable(enable: boolean): void;
+    setSrcLanguage(srcLanguage: string): void;
+    setASRSeiUris(uris: IPublishedResource[]): void;
+    addSeiRemoteTrack(uris: IPublishedResource[]): void;
+    removeSeiRemoteTrack(): void;
+    setIsStartRealTranslate(isStart: boolean): void;
+    setTranslationLang(lang: string): void;
+}
+
+/**
+ * 多端登录时，加入房间时的踢人策略
+ */
+declare enum RTCJoinType {
+    /**
+     * 踢出已存在于房间的设备，以便于当前设备加入房间
+     */
+    KICK = 0,
+    /**
+     * 保持已存在于房间的设备，拒绝当前设备加入房间
+     */
+    REFUSE = 1
+}
+
+declare enum RTCApiType {
+    ROOM = 1,
+    PERSON = 2
+}
+
+declare enum RTCIdentityChangeType {
+    AnchorToViewer = 1,
+    ViewerToAnchor = 2
+}
+
+declare const keymaps: {
+    readonly RtcInput: readonly ["roomType", "broadcastType", "extraInnerData", "needSysChatroom", "identityChangeType", "joinType", "innerDatas", "outerDatas", "supportNtf"];
+    readonly RtcOutput: readonly ["version"];
+    readonly RtcUserListOutput: readonly ["users", "token", "sessionId", "roomInfo", "version"];
+    readonly SetUserStatusInput: readonly ["status"];
+    readonly RtcSetDataInput: readonly ["interior", "target", "key", "value", "objectName", "content"];
+    readonly RtcUserSetDataInput: readonly ["valueInfo", "objectName", "content"];
+    readonly RtcDataInput: readonly ["interior", "target", "key", "objectName", "content"];
+    readonly RtcSetOutDataInput: readonly ["target", "valueInfo", "objectName", "content"];
+    readonly MCFollowInput: readonly ["state"];
+    readonly RtcTokenOutput: readonly ["rtcToken"];
+    readonly RtcQryOutput: readonly ["outInfo"];
+    readonly RtcQryUserOutDataInput: readonly ["userId"];
+    readonly RtcUserOutDataOutput: readonly ["user"];
+    readonly RtcQueryListInput: readonly ["order"];
+    readonly RtcRoomInfoOutput: readonly ["roomId", "roomData", "userCount", "list"];
+    readonly RtcValueInfo: readonly ["key", "value"];
+    readonly RtcKeyDeleteInput: readonly ["key"];
+    readonly RtcNotifyMsg: readonly ["type", "time", "roomId"];
+    readonly RtcPullKV: readonly ["timestamp", "roomId"];
+    readonly RtcKVOutput: readonly ["entries", "bFullUpdate", "syncTime"];
+    readonly RtcQueryUserJoinedInput: readonly ["userId"];
+    readonly RtcQueryUserJoinedOutput: readonly ["info"];
+    readonly RtcInviteInput: readonly ["invitedUserId", "timeoutTime", "invitedRoomId", "inviteInfo", "inviteSessionId"];
+    readonly RtcCancelInviteInput: readonly ["invitedUserId", "invitedRoomId", "inviteInfo", "inviteSessionId"];
+    readonly RtcInviteAnswerInput: readonly ["inviteUserId", "answerCode", "inviteRoomId", "inviteSessionId", "content", "key", "value"];
+    readonly RtcEndInviteInput: readonly ["inviteRoomId", "inviteSessionId", "inviteContent", "inviteRoomKeys"];
+    readonly RtcRoomStatusInput: readonly ["version"];
+    readonly RtcRoomStatusOutput: readonly ["bFullStatus", "version", "usersData", "roomStatus"];
+    readonly RtcReportSDKInput: readonly ["sdkInfo"];
+    readonly RCRTCPBPolaris: readonly ["type", "appKey", "sessionId", "roomId", "roomCreateTime", "userId", "userRole", "joinTime", "signalDataCenter", "r1Info", "r2Info", "r3Info", "r4Info"];
+    readonly RCRTCPBR1Info: readonly ["joinTime", "rtcVersion", "imVersion", "platform", "device", "os", "browserName", "browserVersion"];
+    readonly RCRTCPBR2Info: readonly ["joinTime", "sendTime", "rtcActionType", "rtcActionStatus", "trackId"];
+    readonly RCRTCPBR3Info: readonly ["info"];
+    readonly RCRTCPBR4Info: readonly ["info"];
+    readonly RCRTCPBStatusInfo: readonly ["joinTime", "receiveTime", "totalBitRate", "appCPUUsage", "systemCPUUsage", "systemCPUFrequency", "networkStatus", "googleRTTNetwork", "ipAddress", "useReceiveBroadBand", "useSendBroadBand", "packetLossCount", "streams"];
+    readonly RCRTCPBStreamInfo: readonly ["trackId", "codeName", "volume", "samplingRate", "bitRate", "packetLossRate", "frameRate", "resolution", "blockTime", "jitterData", "nAckCount", "pliCount", "googleRTTTotalTime", "isReceiveFirstFrameRate", "codeType", "isEnabled"];
+    readonly AsrTextMsg: readonly ["bms", "t", "isEnd", "msgId", "lang"];
+    readonly AsrResTextMsg: readonly ["type", "uid", "asr"];
+};
+declare type RTCKeyMaps = typeof keymaps;
+
+/**
+ * 自定义上报北极星数据响应 code
+*/
+declare enum RCSendCode {
+    NOT_REPORT = -1,
+    REPORT_SUCCESS = 10000,
+    REPORT_FAIL = 0,
+    PB_ERROR = 40001
+}
+
+declare class RTCContext {
+    private context;
+    logger: BasicLogger;
+    private codec;
+    roomCreateTime: number | undefined;
+    userJoinTime: number | undefined;
+    constructor(context: RTCPluginContext, logger: BasicLogger, codec: Codec<RTCKeyMaps>);
+    joinRTCRoom(roomId: string, mode: RTCMode, broadcastType?: number, joinType?: RTCJoinType, innerUserDatas?: IRTCUserData, outerUserDatas?: IRTCUserData, supportNtf?: boolean): IPromiseResult<IJoinRTCRoomData>;
+    quitRTCRoom(roomId: string): Promise<ErrorCode>;
+    getRTCRoomInfo(roomId: string): IPromiseResult<IRTCRoomInfo>;
+    /**
+     * 移动端用来获取副房间资源
+     */
+    getRTCUserInfoList(roomId: string): IPromiseResult<IRTCUsers>;
+    getRTCUserInfo(roomId: string): IPromiseResult<unknown>;
+    removeRTCUserInfo(roomId: string, keys: string[]): Promise<ErrorCode>;
+    setRTCData(roomId: string, key: string, value: string, isInner: boolean, apiType: RTCApiType, message?: {
+        name: string;
+        content: string;
+    }): Promise<ErrorCode>;
+    /**
+     * 全量订阅资源修改
+     * @param roomId 房间 Id
+     * @param message 向前兼容的消息内容
+     * @param valueInfo 全量资源数据
+     * @param objectName 全量 URI 消息名
+     */
+    setRTCTotalRes(roomId: string, messageList: {
+        name: string;
+        content: string;
+    }[], valueInfo: string, objectName: string, mcuValInfo?: string, cdnValInfo?: string): Promise<ErrorCode>;
+    setRTCCDNUris(roomId: string, objectName: string, CDNUris: string): Promise<ErrorCode>;
+    getRTCData(roomId: string, keys: string[], isInner: boolean, apiType: RTCApiType): IPromiseResult<KVString>;
+    removeRTCData(roomId: string, keys: string[], isInner: boolean, apiType: RTCApiType, message?: {
+        name: string;
+        content: string;
+    }): Promise<ErrorCode>;
+    setRTCOutData(roomId: string, rtcData: unknown, type: number, message: unknown): Promise<ErrorCode>;
+    getRTCOutData(roomId: string, userIds: string[]): IPromiseResult<unknown>;
+    getRTCToken(roomId: string, mode: number, broadcastType?: number): IPromiseResult<IRtcTokenData>;
+    setRTCState(roomId: string, report: string): Promise<ErrorCode>;
+    /**
+     * 通过 http 方式上报 rtc state
+    */
+    setRTCStateByHttp(logServer: string, runtime: IRuntime, report: IRCRTCReportData, reportType: string): Promise<RCSendCode | RCRTCCode>;
+    getRTCUserList(roomId: string): IPromiseResult<IRTCUsers>;
+    joinLivingRoomAsAudience(roomId: string, mode: RTCMode, broadcastType?: number): Promise<IAsyncRes<{
+        token: string;
+        kvEntries: IServerRTCRoomEntry[];
+    }>>;
+    quitLivingRoomAsAudience(roomId: string): Promise<ErrorCode>;
+    rtcIdentityChange(roomId: string, changeType: RTCIdentityChangeType, broadcastType?: number): Promise<IAsyncRes<IJoinRTCRoomData>>;
+    requestRoomPK(options: IReqRoomPKOptions): Promise<ErrorCode>;
+    cancelRoomPK(options: ICancelRoomPKOptions): Promise<ErrorCode>;
+    responseRoomPK(options: IResRoomPKOptions): Promise<ErrorCode>;
+    endRoomPK(options: IEndRoomPKOptions): Promise<ErrorCode>;
+    getRTCJoinedUserInfo(userId: string): Promise<IAsyncRes<IRTCJoinedInfo[]>>;
+    pullRTCRoomEntry(roomId: string): Promise<IAsyncRes<IChrmKVPullData>>;
+    /**
+     * 通知拉取房间数据
+     * @param roomId 房间 id
+     * @param version 本地最大得房间数据版本号
+     */
+    pullRTCRoomStatus(roomId: string, version: number): Promise<{
+        code: ErrorCode;
+        data?: IPullRTCRoomStatus;
+    }>;
+    decodeRtcNotify(buffer: Uint8Array): {
+        time: number;
+        type: any;
+        roomId: any;
+    };
+    getCurrentId(): string;
+    getNaviInfo(): IRTCNaviInfo | null;
+    getConnectionStatus(): RCConnectionStatus;
+    getAppkey(): string;
+    /** web 端发 rtcPing */
+    webRtcPing(roomId: string, roomMode: RTCMode, broadcastType?: number): Promise<{
+        code: ErrorCode;
+        data?: {
+            version: number;
+        };
+    }>;
+    /**
+     * 协议栈 rtcping 依赖 imlib 编解码数据
+     * web 单独走 imlib 提供的 rtcSignaling 方法，减少对 imlib 的依赖
+     */
+    rtcPing(roomId: string, roomMode: RTCMode, broadcastType?: number): Promise<_rongcloud_engine.RCResult<any>> | Promise<{
+        code: ErrorCode;
+        data?: {
+            version: number;
+        } | undefined;
+    }>;
+    sendMessage(conversationType: ConversationType, targetId: string, options: ISendMsgOptions): IPromiseResult<IReceivedMessage>;
+    registerRTCSignalListener(listener?: ((buffer: Uint8Array) => void) | undefined): void;
+    registerConnectionStateChangeListener(listener: (status: RCConnectionStatus, code: ErrorCode) => void): void;
+    registerDisconnectListener(listener: () => void): void;
+    registerDestroyListener(listener: () => void): void;
+    registerMessageListener(listener: (message: IReceivedMessage) => boolean): void;
+    getCoreVersion(): string;
+    getPluginContext(): RTCPluginContext;
+    reportSDKInfo(versionInfo: {
+        [name: string]: string;
+    }): void;
+    decodeAsrText(buffer: Uint8Array): (RCRTCASRContent | RCRTCRealtimeTranslationContent)[];
 }
 
 declare type ISdpSemantics = 'plan-b' | 'unified-plan';
@@ -1925,6 +2184,28 @@ interface IRoomEventListener extends IRCRTCTrackEventListener {
      * 主播和观众切换身份通知
      */
     onSwitchRole?(userId: string, role: RCRTCLiveRole): void;
+    /**
+     * 语音识别服务开启通知
+     * 如需要语音识别内容和语音实时翻译，可在此时机依次调用 room 的
+     * setSrcLanguageCode 方法，设置输入语言代码，用于语音识别精准识别
+     * setEnableASR 方法，设置房间内的语音识别资源为可用，语音识别内容通过 `onReceiveASRContent` 回调给业务层
+     * startRealtimeTranslation 方法，开启语音实时翻译，实时翻译内容通过 `onReceiveRealtimeTranslationContent` 回调给业务层
+     */
+    onReceiveStartASR?(): void;
+    /**
+     * 语音识别服务停止通知
+     */
+    onReceiveStopASR?(): void;
+    /**
+     * 语音识别内容回调
+     * @param asrContent
+     */
+    onReceiveASRContent?(asrContent: RCRTCASRContent): void;
+    /**
+     * 语音翻译结果回调
+     * @param content
+     */
+    onReceiveRealtimeTranslationContent?(content: RCRTCRealtimeTranslationContent): void;
 }
 /**
  * RTCClient 初始化配置
@@ -2220,6 +2501,37 @@ interface IPullRTCRoomUsersData {
         value: string;
     }[];
 }
+/**
+ * ASR 内容
+ */
+interface RCRTCASRContent {
+    /**
+     * 当前语音识别关联用户的 ID,
+     */
+    userID: string;
+    /**
+     * 当前语音识别的 ID, 用于关联当前语音识别结果
+     */
+    msgId: string;
+    /**
+     * 当前语音识别的时间戳, 单位为秒
+     */
+    timeUTC: number;
+    /**
+     * 当前语音识别结果
+     */
+    msg: string;
+    /**
+     * 当前语音识别是否结束, 如果为 true, 则表示当前语音识别已结束
+     */
+    isEnd: boolean;
+}
+interface RCRTCRealtimeTranslationContent extends RCRTCASRContent {
+    /**
+     * 当前语音翻译的目标语言码
+     */
+    destLangCode: string;
+}
 
 /**
  * 直播布局模式定义
@@ -2498,193 +2810,13 @@ interface ISetEnableCDN {
 }
 
 /**
- * 多端登录时，加入房间时的踢人策略
+ * mediaServer 交互数据
  */
-declare enum RTCJoinType {
-    /**
-     * 踢出已存在于房间的设备，以便于当前设备加入房间
-     */
-    KICK = 0,
-    /**
-     * 保持已存在于房间的设备，拒绝当前设备加入房间
-     */
-    REFUSE = 1
-}
-
-declare enum RTCApiType {
-    ROOM = 1,
-    PERSON = 2
-}
-
-declare enum RTCIdentityChangeType {
-    AnchorToViewer = 1,
-    ViewerToAnchor = 2
-}
-
-declare const keymaps: {
-    readonly RtcInput: readonly ["roomType", "broadcastType", "extraInnerData", "needSysChatroom", "identityChangeType", "joinType", "innerDatas", "outerDatas", "supportNtf"];
-    readonly RtcOutput: readonly ["version"];
-    readonly RtcUserListOutput: readonly ["users", "token", "sessionId", "roomInfo", "version"];
-    readonly SetUserStatusInput: readonly ["status"];
-    readonly RtcSetDataInput: readonly ["interior", "target", "key", "value", "objectName", "content"];
-    readonly RtcUserSetDataInput: readonly ["valueInfo", "objectName", "content"];
-    readonly RtcDataInput: readonly ["interior", "target", "key", "objectName", "content"];
-    readonly RtcSetOutDataInput: readonly ["target", "valueInfo", "objectName", "content"];
-    readonly MCFollowInput: readonly ["state"];
-    readonly RtcTokenOutput: readonly ["rtcToken"];
-    readonly RtcQryOutput: readonly ["outInfo"];
-    readonly RtcQryUserOutDataInput: readonly ["userId"];
-    readonly RtcUserOutDataOutput: readonly ["user"];
-    readonly RtcQueryListInput: readonly ["order"];
-    readonly RtcRoomInfoOutput: readonly ["roomId", "roomData", "userCount", "list"];
-    readonly RtcValueInfo: readonly ["key", "value"];
-    readonly RtcKeyDeleteInput: readonly ["key"];
-    readonly RtcNotifyMsg: readonly ["type", "time", "roomId"];
-    readonly RtcPullKV: readonly ["timestamp", "roomId"];
-    readonly RtcKVOutput: readonly ["entries", "bFullUpdate", "syncTime"];
-    readonly RtcQueryUserJoinedInput: readonly ["userId"];
-    readonly RtcQueryUserJoinedOutput: readonly ["info"];
-    readonly RtcInviteInput: readonly ["invitedUserId", "timeoutTime", "invitedRoomId", "inviteInfo", "inviteSessionId"];
-    readonly RtcCancelInviteInput: readonly ["invitedUserId", "invitedRoomId", "inviteInfo", "inviteSessionId"];
-    readonly RtcInviteAnswerInput: readonly ["inviteUserId", "answerCode", "inviteRoomId", "inviteSessionId", "content", "key", "value"];
-    readonly RtcEndInviteInput: readonly ["inviteRoomId", "inviteSessionId", "inviteContent", "inviteRoomKeys"];
-    readonly RtcRoomStatusInput: readonly ["version"];
-    readonly RtcRoomStatusOutput: readonly ["bFullStatus", "version", "usersData", "roomStatus"];
-    readonly RtcReportSDKInput: readonly ["sdkInfo"];
-    readonly RCRTCPBPolaris: readonly ["type", "appKey", "sessionId", "roomId", "roomCreateTime", "userId", "userRole", "joinTime", "signalDataCenter", "r1Info", "r2Info", "r3Info", "r4Info"];
-    readonly RCRTCPBR1Info: readonly ["joinTime", "rtcVersion", "imVersion", "platform", "device", "os", "browserName", "browserVersion"];
-    readonly RCRTCPBR2Info: readonly ["joinTime", "sendTime", "rtcActionType", "rtcActionStatus", "trackId"];
-    readonly RCRTCPBR3Info: readonly ["info"];
-    readonly RCRTCPBR4Info: readonly ["info"];
-    readonly RCRTCPBStatusInfo: readonly ["joinTime", "receiveTime", "totalBitRate", "appCPUUsage", "systemCPUUsage", "systemCPUFrequency", "networkStatus", "googleRTTNetwork", "ipAddress", "useReceiveBroadBand", "useSendBroadBand", "packetLossCount", "streams"];
-    readonly RCRTCPBStreamInfo: readonly ["trackId", "codeName", "volume", "samplingRate", "bitRate", "packetLossRate", "frameRate", "resolution", "blockTime", "jitterData", "nAckCount", "pliCount", "googleRTTTotalTime", "isReceiveFirstFrameRate", "codeType", "isEnabled"];
-};
-declare type RTCKeyMaps = typeof keymaps;
-
-/**
- * 自定义上报北极星数据响应 code
-*/
-declare enum RCSendCode {
-    NOT_REPORT = -1,
-    REPORT_SUCCESS = 10000,
-    REPORT_FAIL = 0,
-    PB_ERROR = 40001
-}
-
-declare class RTCContext {
-    private context;
-    logger: BasicLogger;
-    private codec;
-    roomCreateTime: number | undefined;
-    userJoinTime: number | undefined;
-    constructor(context: RTCPluginContext, logger: BasicLogger, codec: Codec<RTCKeyMaps>);
-    joinRTCRoom(roomId: string, mode: RTCMode, broadcastType?: number, joinType?: RTCJoinType, innerUserDatas?: IRTCUserData, outerUserDatas?: IRTCUserData, supportNtf?: boolean): IPromiseResult<IJoinRTCRoomData>;
-    quitRTCRoom(roomId: string): Promise<ErrorCode>;
-    getRTCRoomInfo(roomId: string): IPromiseResult<IRTCRoomInfo>;
-    /**
-     * 移动端用来获取副房间资源
-     */
-    getRTCUserInfoList(roomId: string): IPromiseResult<IRTCUsers>;
-    getRTCUserInfo(roomId: string): IPromiseResult<unknown>;
-    removeRTCUserInfo(roomId: string, keys: string[]): Promise<ErrorCode>;
-    setRTCData(roomId: string, key: string, value: string, isInner: boolean, apiType: RTCApiType, message?: {
-        name: string;
-        content: string;
-    }): Promise<ErrorCode>;
-    /**
-     * 全量订阅资源修改
-     * @param roomId 房间 Id
-     * @param message 向前兼容的消息内容
-     * @param valueInfo 全量资源数据
-     * @param objectName 全量 URI 消息名
-     */
-    setRTCTotalRes(roomId: string, messageList: {
-        name: string;
-        content: string;
-    }[], valueInfo: string, objectName: string, mcuValInfo?: string, cdnValInfo?: string): Promise<ErrorCode>;
-    setRTCCDNUris(roomId: string, objectName: string, CDNUris: string): Promise<ErrorCode>;
-    getRTCData(roomId: string, keys: string[], isInner: boolean, apiType: RTCApiType): IPromiseResult<KVString>;
-    removeRTCData(roomId: string, keys: string[], isInner: boolean, apiType: RTCApiType, message?: {
-        name: string;
-        content: string;
-    }): Promise<ErrorCode>;
-    setRTCOutData(roomId: string, rtcData: unknown, type: number, message: unknown): Promise<ErrorCode>;
-    getRTCOutData(roomId: string, userIds: string[]): IPromiseResult<unknown>;
-    getRTCToken(roomId: string, mode: number, broadcastType?: number): IPromiseResult<IRtcTokenData>;
-    setRTCState(roomId: string, report: string): Promise<ErrorCode>;
-    /**
-     * 通过 http 方式上报 rtc state
-    */
-    setRTCStateByHttp(logServer: string, runtime: IRuntime, report: IRCRTCReportData, reportType: string): Promise<RCSendCode | RCRTCCode>;
-    getRTCUserList(roomId: string): IPromiseResult<IRTCUsers>;
-    joinLivingRoomAsAudience(roomId: string, mode: RTCMode, broadcastType?: number): Promise<IAsyncRes<{
-        token: string;
-        kvEntries: IServerRTCRoomEntry[];
-    }>>;
-    quitLivingRoomAsAudience(roomId: string): Promise<ErrorCode>;
-    rtcIdentityChange(roomId: string, changeType: RTCIdentityChangeType, broadcastType?: number): Promise<IAsyncRes<IJoinRTCRoomData>>;
-    requestRoomPK(options: IReqRoomPKOptions): Promise<ErrorCode>;
-    cancelRoomPK(options: ICancelRoomPKOptions): Promise<ErrorCode>;
-    responseRoomPK(options: IResRoomPKOptions): Promise<ErrorCode>;
-    endRoomPK(options: IEndRoomPKOptions): Promise<ErrorCode>;
-    getRTCJoinedUserInfo(userId: string): Promise<IAsyncRes<IRTCJoinedInfo[]>>;
-    pullRTCRoomEntry(roomId: string): Promise<IAsyncRes<IChrmKVPullData>>;
-    /**
-     * 通知拉取房间数据
-     * @param roomId 房间 id
-     * @param version 本地最大得房间数据版本号
-     */
-    pullRTCRoomStatus(roomId: string, version: number): Promise<{
-        code: ErrorCode;
-        data?: IPullRTCRoomStatus;
-    }>;
-    decodeRtcNotify(buffer: Uint8Array): {
-        time: number;
-        type: any;
-        roomId: any;
-    };
-    getCurrentId(): string;
-    getNaviInfo(): IRTCNaviInfo | null;
-    getConnectionStatus(): RCConnectionStatus;
-    getAppkey(): string;
-    /** web 端发 rtcPing */
-    webRtcPing(roomId: string, roomMode: RTCMode, broadcastType?: number): Promise<{
-        code: ErrorCode;
-        data?: {
-            version: number;
-        };
-    }>;
-    /**
-     * 协议栈 rtcping 依赖 imlib 编解码数据
-     * web 单独走 imlib 提供的 rtcSignaling 方法，减少对 imlib 的依赖
-     */
-    rtcPing(roomId: string, roomMode: RTCMode, broadcastType?: number): Promise<{
-        code: ErrorCode;
-        data?: {
-            version: number;
-        } | undefined;
-    }> | Promise<_rongcloud_engine.RCResult<any>>;
-    sendMessage(conversationType: ConversationType, targetId: string, options: ISendMsgOptions): IPromiseResult<IReceivedMessage>;
-    registerRTCSignalListener(listener?: ((buffer: Uint8Array) => void) | undefined): void;
-    registerConnectionStateChangeListener(listener: (status: RCConnectionStatus, code: ErrorCode) => void): void;
-    registerDisconnectListener(listener: () => void): void;
-    registerDestroyListener(listener: () => void): void;
-    registerMessageListener(listener: (message: IReceivedMessage) => boolean): void;
-    getCoreVersion(): string;
-    getPluginContext(): RTCPluginContext;
-    reportSDKInfo(versionInfo: {
-        [name: string]: string;
-    }): void;
-}
-
-/**
- * mediaServer 交互数据
- */
-interface IMediaServerQualityData {
-    rsid: string;
-    rsdur: number;
-    msa: string;
-    rscod: number;
+interface IMediaServerQualityData {
+    rsid: string;
+    rsdur: number;
+    msa: string;
+    rscod: number;
 }
 /**
  * signal 交互数据
@@ -2700,204 +2832,71 @@ declare enum RCRTCResourceAction {
     UNSUB = "unsub"
 }
 
-declare class RCMediaService {
-    private readonly _runtime;
-    private readonly _context;
+declare enum RCCommandKind {
     /**
-     * 自定义 MediaServer 地址，当有值时，不再使用导航内的地址
+     * 发信令取消加入房间之前的资源
      */
-    private readonly _msUrl?;
+    UNPUBLISH_PREV = "UnpublishPrevCommand",
     /**
-     * 请求超时时长
+     * 拉取房间内数据
      */
-    private readonly _timeout;
+    PULL_RTCROOM_STATUS = "PullRTCRoomStatusCommand",
     /**
-     * 已失败的请求地址
+     * 加入房间
      */
-    private readonly _failedMs;
+    JOINROOM = "JoinRoomCommand",
     /**
-     * 服务器指纹数据，客户端不得修改，直接透传
+     * 解析远端资源数据
      */
-    private _rtcFinger;
+    PARSE_REMOTERES = "ParseRemoteResCommand",
     /**
-     * 服务器接口返回的 clusterId 数据，当此数据有值时，后续所有请求向此服务发送
+     * 解析远端人员数据
      */
-    private _clusterId;
+    PARSE_USERSTATE = "ParseUserStateCommand",
     /**
-     * MCU 服务地址
+     * 本端 track 禁用/启用
      */
-    private _configUrl;
+    LOCAL_TRACK_MUTE = "LocalTrackMuteCommand",
     /**
-     * 排好序的探测地址
+     * 发布资源
      */
-    private static msInDetector;
-    private static detectorTime;
-    private static detectValidMinute;
-    private _msList;
-    private _qualityMsList;
-    private readonly _logger;
-    constructor(_runtime: IRuntime, _context: RTCContext, 
+    PUBLISH = "PublishCommand",
     /**
-     * 自定义 MediaServer 地址，当有值时，不再使用导航内的地址
+     * 恢复 ice 连接
      */
-    _msUrl?: string | undefined, 
+    RETRY_EXCHANGE = "RetryExchangeCommand",
     /**
-     * 请求超时时长
+     * 取消发布
      */
-    _timeout?: number);
+    UNPUBLISH = "UnpublishCommand",
     /**
-     * 是否需要嗅探
-     * im 未连接，无 navi 数据时，不需要嗅探
-     * 客户端手动配置 mediaServer 时，不需要嗅探
-     * navi 数据中 detectionServer 为空时，不需要嗅探
-     * navi 数据中 jwt 为空时，不需要嗅探
-     * 在探测有效期内不需要嗅探
-     * RCMediaService.detectorTime 为 0 时，代表未探测过，需要嗅探
+     * 订阅
      */
-    isNededDetector(): boolean;
-    detectorMediaSever(): void;
+    SUBSCRIBE = "SubscribeCommand",
     /**
-     *  地址探测
-     *  RTC 初始化时检测是否可以拿到 navi，可以拿到开始嗅探
-     *  拿不到等 IM 链接成功后，再回调中调用开始嗅探
+     * 取消订阅
      */
-    private _startDetector;
+    UNSUBSCRIBE = "UnsubscribeCommand",
     /**
-     * 清空 msList 列表，重新请求导航后需清空 msList 列表
+     * 全量订阅
      */
-    clearMSList(): void;
-    getMsList(): string[];
+    UPDATE_SUBSCRIBE_LIST = "UpdateSubscribeListCommand",
     /**
-     * _mslist 列表排序：[_clusterId, ping1DetectorUrl, 主域名, ping2DetectorUrl, ..., pingNDetectorUrl, 备用域名list ]
-     * ping1 ：ping 结果返回最快值
+     * im 重连房间内人员、资源处理
      */
-    private _sortMediaServiceList;
+    ON_SIGNAL_RECONNECTED = "OnSignalReconnectedCommand",
     /**
-     * 配置 gzip 请求头和请求体
+     * 退出副房间
      */
-    private _openGzip;
+    LEAVE_OTHER_ROOM = "LeaveOtherRoomCommand",
     /**
-     * 处理 request 成功的结果
+     * 主播、观众切换身份
      */
-    private _dealRequestSuccessResult;
+    RTC_IDENTITY_CHANGE = "RTCIdentityChangeCommand",
     /**
-     * 发送请求，请求发送若失败，会继续尝试使用后续可用地址直到无地址可用，此时认为请求失败
-     * @param path
-     * @param header
-     * @param body
+     * 开/关 CDN
      */
-    private _request;
-    /**
-     * 资源协商接口，订阅、发布、变更资源均可以使用此接口。该接口通过 sdp 字段交换 SDP 信息，
-     * 并通过 subscribeList 和 publishList 表明最终发布和订阅的资源。本端产出 offer，服务器产出 answer
-     * 每次接口调用，都会全量覆盖发布和订阅的资源。
-     * @param header
-     * @param body
-     */
-    exchange(headers: IRTCReqHeader, body: IExchangeReqBody, traceId: string, isNeedUpdateMsas?: boolean): Promise<{
-        code: RCRTCCode;
-        data?: IExchangeResponse | undefined;
-        qualityMsList?: IMediaServerQualityData[] | undefined;
-    }>;
-    /**
-     * 退出房间
-     */
-    exit(headers: IRTCReqHeader): Promise<RCRTCCode>;
-    /**
-     * 观众端订阅主播资源
-     */
-    broadcastSubscribe(headers: IRTCReqHeader, body: IBroadcastSubReqBody): Promise<{
-        code: RCRTCCode;
-        data?: IBroadcastSubRespBody | undefined;
-        qualityMsList?: IMediaServerQualityData[] | undefined;
-    }>;
-    /**
-     * 观众端退出订阅
-     */
-    broadcastExit(headers: IRTCReqHeader): Promise<{
-        code: RCRTCCode;
-    }>;
-    /**
-     * 直播推流、自定义布局配置
-     */
-    setMcuConfig(headers: IMCUReqHeaders, body: IMCUConfig | ISetEnableCDN): Promise<{
-        code: RCRTCCode;
-        res?: any;
-    }>;
-    /**
-     * 房间内观众获取 CDN 资源信息、拉流地址
-     */
-    getCDNResourceInfo(headers: ICDNPlayUrlReqHeaders, url: string, traceId: string): Promise<{
-        code: RCRTCCode;
-        res?: ICDNPlayUrlResponse;
-    }>;
-}
-
-declare enum RCCommandKind {
-    /**
-     * 发信令取消加入房间之前的资源
-     */
-    UNPUBLISH_PREV = "UnpublishPrevCommand",
-    /**
-     * 拉取房间内数据
-     */
-    PULL_RTCROOM_STATUS = "PullRTCRoomStatusCommand",
-    /**
-     * 加入房间
-     */
-    JOINROOM = "JoinRoomCommand",
-    /**
-     * 解析远端资源数据
-     */
-    PARSE_REMOTERES = "ParseRemoteResCommand",
-    /**
-     * 解析远端人员数据
-     */
-    PARSE_USERSTATE = "ParseUserStateCommand",
-    /**
-     * 本端 track 禁用/启用
-     */
-    LOCAL_TRACK_MUTE = "LocalTrackMuteCommand",
-    /**
-     * 发布资源
-     */
-    PUBLISH = "PublishCommand",
-    /**
-     * 恢复 ice 连接
-     */
-    RETRY_EXCHANGE = "RetryExchangeCommand",
-    /**
-     * 取消发布
-     */
-    UNPUBLISH = "UnpublishCommand",
-    /**
-     * 订阅
-     */
-    SUBSCRIBE = "SubscribeCommand",
-    /**
-     * 取消订阅
-     */
-    UNSUBSCRIBE = "UnsubscribeCommand",
-    /**
-     * 全量订阅
-     */
-    UPDATE_SUBSCRIBE_LIST = "UpdateSubscribeListCommand",
-    /**
-     * im 重连房间内人员、资源处理
-     */
-    ON_SIGNAL_RECONNECTED = "OnSignalReconnectedCommand",
-    /**
-     * 退出副房间
-     */
-    LEAVE_OTHER_ROOM = "LeaveOtherRoomCommand",
-    /**
-     * 主播、观众切换身份
-     */
-    RTC_IDENTITY_CHANGE = "RTCIdentityChangeCommand",
-    /**
-     * 开/关 CDN
-     */
-    ENABLE_INNER_CDN = "EnableInnerCDNCommand",
+    ENABLE_INNER_CDN = "EnableInnerCDNCommand",
     /**
      * 携带副房间信息重新发 /exchange 请求
      */
@@ -2964,1325 +2963,1546 @@ declare class ReportMediaActionLogger {
     recordQualityIceStatusData(iceCandidatePair: IRCCandidatePairStat, status: RTCIceConnectionState, time: number): void;
 }
 
-declare class RCLocalMediaStream {
-    readonly msid: string;
-    readonly mediaStream: MediaStream;
-    readonly tinyStream: MediaStream;
-    readonly tag: string;
-    constructor(msid: string);
-}
-
 /**
- * 直播间类型
+ * RTC 消息类型常量
+ * @private
  */
-declare enum RCLivingType {
+declare enum RCRTCMessageType {
     /**
-     * 音视频直播
+     * 增量资源发布消息
+     * @deprecated
      */
-    VIDEO = 0,
+    PUBLISH = "RCRTC:PublishResource",
     /**
-     * 音频直播
+     * 增量资源取消发布消息
+     * @deprecated
      */
-    AUDIO = 1
-}
-
-interface IAudienceRoomEventListener extends IRCRTCTrackEventListener {
+    UNPUBLISH = "RCRTC:UnpublishResource",
     /**
-     * 主播加入
-     * @param userIds 加入主播的 id 列表
+     * 增量资源状态变更消息
+     * @deprecated
      */
-    onAnchorJoin?(userId: string[]): void;
+    MODIFY = "RCRTC:ModifyResource",
     /**
-     * 主播退出
-     * @param userIds 退出主播的 id 列表
+     * 全量资源变更消息
      */
-    onAnchorLeave?(userId: string[]): void;
+    TOTAL_CONTENT_RESOURCE = "RCRTC:TotalContentResources",
     /**
-     * 房间内合流发布资源
-     * @param tracks 新发布的合流音轨与视轨数据列表，包含新发布的 RCRemoteAudioTrack 与 RCRemoteVideoTrack 实例
-     * @description
-     * 当房间内某个主播第一次发布资源时触发
+     * 房间人员变更
      */
-    onTrackPublish?(tracks: RCRemoteTrack[]): void;
+    STATE = "RCRTC:state",
     /**
-     * 房间内取消合流发布资源
-     * @param tracks 被取消发布的合流音轨与视轨数据列表
-     * @description
-     * 当房间内全部主播退出房间时，SDK 内部会取消对资源的订阅，业务层仅需处理 UI 业务
+     * 房间属性变更
      */
-    onTrackUnpublish?(tracks: RCRemoteTrack[]): void;
+    ROOM_NOTIFY = "RCRTC:RoomNtf",
     /**
-     * 房间内主播发布资源
-     * @param tracks 主播新发布的音轨与视轨数据列表，包含新发布的 RCRemoteAudioTrack 与 RCRemoteVideoTrack 实例
+     * 房间用户属性变更
      */
-    onAnchorTrackPublish?(tracks: RCRemoteTrack[]): void;
+    USER_NOTIFY = "RCRTC:UserNtf",
     /**
-     * 房间内主播取消发布资源
-     * @param tracks 被主播取消发布的音轨与视轨数据列表
-     * @description 当资源被取消发布时，SDK 内部会取消对相关资源的订阅，业务层仅需处理 UI 业务
+     * 被服务踢出房间
      */
-    onAnchorTrackUnpublish?(tracks: RCRemoteTrack[]): void;
+    KICK = "RCRTC:kick",
     /**
-     * 房间主播禁用/启用音频
-     * @param audioTrack RCRemoteAudioTrack 类实例
+     * 跨房间连麦 PK 请求消息
      */
-    onAudioMuteChange?(audioTrack: RCRemoteAudioTrack): void;
+    PK_INVITE = "RCRTC:invite",
     /**
-    * 房间主播禁用/启用视频
-    * @param videoTrack RCRemoteVideoTrack 类实例对象
-    */
-    onVideoMuteChange?(videoTrack: RCRemoteVideoTrack): void;
+     * 连麦请求超时
+     */
+    PK_INVITE_TIMEOUT = "RCRTC:inviteTimeout",
     /**
-     * 房间内主播把发布的资源推至 CDN
+     * 跨房间连麦 PK 取消请求消息
      */
-    onCDNInfoEnable?(CDNInfo: {
-        resolution: RCResolution;
-        fps: RCFrameRate;
-    }): void;
+    PK_CANCEL_INVITE = "RCRTC:cancelInvite",
     /**
-     * 主播停止推 CDN
+     * 跨房间连麦 PK 请求响应消息
      */
-    onCDNInfoDisable?(): void;
+    PK_INVITE_ANSWER = "RCRTC:answerInvite",
     /**
-     * 主播改变推 CDN 的分辨率或帧率
+     * 结束跨房间连麦 PK 消息
      */
-    onCDNInfoChange?(CDNInfo: {
-        resolution: RCResolution;
-        fps: RCFrameRate;
-    }): void;
-}
-/**
- * 观众直播房间类
- * 处理：
- * 1、通知观众房间内 人员变更、资源变更
- * 2、观众订阅、取消订阅资源
- */
-declare class RCAudienceLivingRoom {
-    private readonly _context;
-    private readonly _runtime;
-    private readonly _initOptions;
-    private readonly _roomId;
-    private readonly _joinResData;
-    readonly livingType: RCLivingType;
-    protected readonly _clientSessionId: string;
-    private readonly _service;
+    PK_END = "RCRTC:endInvite",
     /**
-     * 主播列表
+     * 连麦的房间不再了或离线了，主直播房间会收到的消息通知
      */
-    private _roomAnchorList;
+    OTHER_ROOM_OFFLINE = "RCRTC:otherRoomOffline",
     /**
-     * 合流、分流资源
+     * 订阅、取消订阅动作成功
      */
-    private _roomRes;
+    ROOM_TASK_FINISH = "RCRTC:roomTaskFinish",
     /**
-     * 主播分流资源
+     * ASR 状态变更
      */
-    private _roomAnchorRes;
+    ASR_STATUS = "RCRTC:AsrStatus",
     /**
-     * 合流、分流 remoteTracks
+     * ASR SEI 变更
      */
-    private _remoteTracks;
-    private _appListener;
-    private readonly _pc;
-    private _subscribedList;
-    private _sessionId;
-    private _destroyed;
+    ASR_SEI = "RCRTC:PublishSeiAi"
+}
+
+/**
+ * 直播间类型
+ */
+declare enum RCLivingType {
     /**
-     * 北极星上报实例
+     * 音视频直播
      */
-    protected readonly _polarisReport: PolarisReporter;
+    VIDEO = 0,
     /**
-     * 音量上报实例
+     * 音频直播
      */
-    private readonly _audioLevelReport;
+    AUDIO = 1
+}
+
+declare type IOnRecvPKMsg = (msg: IReceivedMessage) => void;
+interface IRoomPKEventListener {
     /**
-     * cdn_uris 资源
+     * 收到连麦邀请
      */
-    private _CDNUris;
-    private _isPulling;
-    private _pullTime;
-    private readonly _store;
-    private _crtUserId;
-    private readonly _reportMediaActionLogger;
+    onRequestJoinOtherRoom: (info: IPKInviteInfo) => {};
     /**
-     * track 对应的 mediaServer 信息
+     * 收到取消连麦邀请
      */
-    private _trackMediaMap;
-    private readonly _logger;
-    constructor(_context: RTCContext, _runtime: IRuntime, _initOptions: IRCRTCInitOptions, _roomId: string, _joinResData: {
-        token: string;
-        kvEntries: IServerRTCRoomEntry[];
-    }, livingType: RCLivingType, _clientSessionId?: string);
-    private _startPull;
+    onCancelRequestOtherRoom: (info: IPKInviteInfo) => {};
     /**
-     * 解析服务端返回的 KV 数据，赋值 room 内数据
+     * 收到连麦 PK 请求响应结果
      */
-    private _setInitData;
-    protected _assertRoomDestroyed(): RCRTCCode | undefined;
+    onResponseJoinOtherRoom: (info: IPKInviteAnswerInfo) => {};
     /**
-     * @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 资源数据
+     * 收到 PK 结束
      */
-    private singalDataChange;
+    onFinishOtherRoom: (info: IPKEndInfo) => {};
+}
+declare class RCLivingPKHandler {
+    private _invoker;
+    private _PKInfo;
+    private readonly _context;
+    private readonly _runtime;
+    private readonly _service;
+    private readonly _initOptions;
     /**
-     * 计算加入离开的主播 ID 列表
+     * 主直播房间
      */
-    private _diffAnchorList;
-    private _handleNewJoinedAnchor;
-    private _handleLeftedAnchor;
+    private readonly _mainLivingRoom;
+    private readonly _registerPKMsgListener;
     /**
-     * 计算新发布和取消发布的合流资源
+     * 加入 PK 房间回调
      */
-    private _diffRoomResource;
+    private readonly _onJoinedPKRoom;
+    protected readonly _clientSessionId?: string | undefined;
     /**
-     * 处理主播资源的新增发布
+     * PK 邀请超时时间，默认 30s
      */
-    private _dealPublished;
+    private readonly _inviteTimeout;
+    private _appListener;
+    private _mainRoomId;
     /**
-     * 处理主播资源的取消发布
+     * 跨房间连麦加入的 PK 房间
      */
-    private _dealUnpublished;
+    private _joinedPKRooms;
+    private readonly _logger;
+    constructor(_invoker: Invoker, _PKInfo: IPKInfo, _context: RTCContext, _runtime: IRuntime, _service: RCMediaService, _initOptions: IRCRTCInitOptions, 
     /**
-     * 处理主播资源的变更
+     * 主直播房间
      */
-    private _dealModified;
+    _mainLivingRoom: RCLivingRoom, _registerPKMsgListener: (listener: IOnRecvPKMsg) => void, 
     /**
-     * 计算主播发布和取消发布的资源，以及资源的状态变更
-    */
-    private _diffAnchorResource;
-    private _onUserUnpublish;
+     * 加入 PK 房间回调
+     */
+    _onJoinedPKRoom: (roomId: string, traceId: string) => Promise<void>, _clientSessionId?: string | undefined);
     private _callAppListener;
     /**
-     * ice 断线后，尝试重新走 exchange
-    */
-    private _reTryExchange;
+     * 收到连麦邀请
+     */
+    private _onInvite;
     /**
-     * 获取 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 _onCancelInvite;
+    private _onInviteTimeout;
+    /**
+     * 收到响应连麦
+     */
+    private _onInviteAnswer;
+    private createLeaveOtherRoomCommand;
+    /**
+     * 收到连麦结束
+     */
+    private _onPKEnd;
+    /**
+     * 处理跨房间连麦相关消息
+     */
+    private _onRecvPKMsg;
+    /**
+     * 注册跨房间连麦监听事件
+     */
+    registerRoomPKEventListener(listener: IRoomPKEventListener): void;
+    /**
+     * 发起跨房间连麦请求
+     * @param inviteeRoomId 被邀请者所处的房间 roomId
+     * @param inviteeUserId 被邀请者 userId
+     * @param options.autoMix 是否将本房间资源合并到被邀请者所处房间的 MCU 合流中
+     * @param options.extra 拓展字段，可随邀请连麦消息透传给被邀请者
+     */
+    requestJoinOtherRoom(inviteeRoomId: string, inviteeUserId: string, options?: IReqResPKOptions): Promise<{
+        code: RCRTCCode | ErrorCode;
     }>;
-    private _subscribeHandle;
     /**
-     * 添加 peerConnection 事件
+     * 取消跨房间连麦请求
+     * @param inviteeRoomId 被邀请者所处的房间 roomId
+     * @param inviteeUserId 被邀请者 userId
+     * @param extra 附加信息，可随取消邀请连麦消息透传给被邀请者
+     */
+    cancelRequestJoinOtherRoom(inviteeRoomId: string, inviteeUserId: string, extra?: string): Promise<{
+        code: RCRTCCode | ErrorCode;
+    }>;
+    /**
+     * 响应跨房间连麦请求
+     * @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;
+    }>;
+    /**
+     * 加入副直播房间
+     * @roomId 副房间的 roomId
+     */
+    joinOtherRoom(roomId: string): Promise<{
+        code: RCRTCCode;
+        room?: RCLivingRoom;
+        userIds?: string[];
+        tracks?: RCRemoteTrack[];
+        CDNEnable?: boolean;
+    }>;
+    /**
+     * 退出副房间
+     * @param room 要退出的副房间的 room 实例
+     * @param isQuitPK 是否要结束连麦
+     */
+    leaveOtherRoom(room: RCLivingRoom, isQuitPK?: boolean): Promise<{
+        code: RCRTCCode;
+    }>;
+    /**
+     * 获取连麦信息
+     * @param roomId 连麦房间的 roomId
+     */
+    getPKInfo(roomId: string): {
+        inviteSessionId: string;
+        inviterRoomId: string;
+        inviterUserId: string;
+        inviterUserAutoMix?: boolean | undefined;
+        inviteeRoomId: string;
+        inviteeUserAutoMix?: boolean | undefined;
+    };
+    /**
+     * 获取所有连麦信息
+     */
+    getAllPKInfo(): IPKInfo;
+    /**
+     * 获取已加入的副房间
+     */
+    getJoinedPKRooms(): {
+        [roomId: string]: RCLivingRoom;
+    };
+}
+
+declare type ResourceMsgContent = {
+    /**
+     * 旧版本兼容参数，当收到非 `RTCMessageName.TOTAL_CONTENT_RESOURCE` 时：
+     * * ignore 值为 `true` 表示该消息由 signal server 向旧版本 RTCLib 提供的兼容消息，无需处理
+     * * 否则认为该消息是由旧版本 RTCLib 主动发出的增量变更消息，需要处理
+     */
+    ignore?: boolean;
+    /**
+     * 发布到房间内的资源列表，`RTCMessageName.TOTAL_CONTENT_RESOURCE` 消息携带全量数据，否则为增量数据
+     */
+    uris: IPublishedResource[];
+    cdn_uris?: ICDNUris[];
+};
+
+/**
+ * 房间抽象基类
+ */
+declare abstract class RCAbstractRoom extends EventEmitter {
+    protected readonly _context: RTCContext;
+    protected readonly _runtime: IRuntime;
+    readonly _roomId: string;
+    protected readonly _service: RCMediaService;
+    protected readonly _initOptions: IRCRTCInitOptions;
+    protected readonly _clientSessionId: string;
+    /**
+     * 房间保活 rtcPing
+     */
+    private readonly _pinger;
+    /**
+     * 北极星上报实例
+     */
+    protected readonly _polarisReport: PolarisReporter;
+    /**
+     * 音量上报实例
+     */
+    private readonly _audioLevelReport;
+    protected readonly _peerConnection: RCRTCPeerConnection;
+    protected readonly _invoker: Invoker;
+    protected readonly _store: ReadableStore;
+    private readonly _reportMediaActionLogger;
+    protected readonly _logger: BasicLogger;
+    protected readonly _executeCtx: CommandExecuteContext;
+    /**
+     * RCRTCRoom 类的构造函数。
+     * @param {RTCContext} _context - RTC上下文，
+     * @param {IRuntime} _runtime - 运行时
+     * @param {string} _roomId - 房间号
+     * @param {RTCMode} _roomMode - RTC模式，
+     * @param {RCMediaService} _service - RCMediaService
+     * @param {IRCRTCInitOptions} _initOptions - IRCRTCInitOptions
+     * @param {boolean} [isUpgrade] - 是否是升级，如果是升级则不会创建新的peerConnection
+     * @param {boolean} [isMainRoom] - 无论是主房间，主房间都是用户创建的房间，子房间是用户创建的房间。
+     * @param {string} _clientSessionId - 客户端会话 ID，用于标识客户端。
+     */
+    constructor(_context: RTCContext, _runtime: IRuntime, _roomId: string, _roomMode: RTCMode, _service: RCMediaService, _initOptions: IRCRTCInitOptions, isUpgrade?: boolean, isMainRoom?: boolean, _clientSessionId?: string, encrypt?: boolean);
+    /**
+     * 注册 RCRTCPeerConnection 事件监听器
+     */
+    private _setPeerConnectionListener;
+    /** 注册命令执行中的事件监听器 */
+    private setCommandEventListener;
+    /**
+     * 拉取房间数据
+     * @param roomId 房间 id
+     */
+    private _startPullRTCRoomStatus;
+    /**
+     * @private
+     */
+    __innerInit(mode: RTCMode, joinType?: RTCJoinType, livingType?: RCLivingType, innerUserDatas?: IRTCUserData, outerUserDatas?: IRTCUserData, traceId?: string): Promise<{
+        code: RCRTCCode | ErrorCode;
+        data?: IJoinRTCRoomData;
+    }>;
+    protected _initWithRoomData(offlineKickTime: number): void;
+    private _handlePingResult;
+    /**
+     * 设置房间上行资源的总码率配置
+     * @deprecated use RCLocalTrack.setBitrate instead of setBitrate
+     * @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 _onTrackUnpublish;
+    /**
+     * @private
+     */
+    __parseInnerMessage(message: IReceivedMessage, traceId: string): void;
+    /**
+     * 被踢出房间通知
+     * @param byServer
+     * * 当值为 false 时，说明本端 rtcPing 超时
+     * * 当值为 true 时，说明本端收到被踢出房间通知
+     * @private
+     */
+    __kickoff(byServer: boolean, content?: IRCRTCKickContent): Promise<void>;
+    private _rtcpeerClosed;
+    private _onReceiveAsrSeiContent;
+    /**
+     * 处理资源变更事件
+     * @param content
+     * @param messageType 消息类型
+     * @param userId 消息发送者
      */
-    private _addPeerCEvent;
-    private _getReqHeaders;
-    private _exchangeHandle;
-    private _dealSubscribeResult;
+    protected _resourceHandle(content: ResourceMsgContent, messageType: RCRTCMessageType.PUBLISH | RCRTCMessageType.UNPUBLISH | RCRTCMessageType.MODIFY | RCRTCMessageType.TOTAL_CONTENT_RESOURCE, userId: string, sentTime: number, traceId: string): Promise<void>;
+    private _onTrackPublish;
     /**
-     * 去重、转化参数格式为 ISubscribeAttr
+     * 处理 `RCRTCMessageType.STATE` 消息
+     * @param content
      */
-    private _getParams;
-    private _reportPubOrSubQualityData;
-    private _updateSubListHandle;
+    private _stateHandle;
     /**
-     * 对比 cdn_uris 资源
-     * @param newCDNUris 新的 cdn_uris 数据
+     * 处理人员应用层事件
      */
-    private _diffCDNUris;
+    private _dealUserAppListener;
     /**
-     * 获取 CDN 资源对应的拉流地址
-     * _CDNUris 无 url 时，说明未开启 CDN 推送
-     * @returns CDNPlayUrl
+     * 获取房间 Id
      */
-    private _getCDNPlayUrl;
+    getRoomId(): string;
     /**
-     * 获取 CDN 资源对应的拉流地址
-     * @returns CDNPlayUrl
+     * 获取当前 userId
      */
-    getCDNPlayUrl(resolution?: RCResolution, fps?: RCFrameRate): Promise<{
-        code: RCRTCCode;
-        CDNPlayUrl?: string;
-    }>;
+    getCrtUserId(): string;
     /**
-     * 订阅资源
-     * @param tracks
+     * 获取远程用户列表，不包含当前用户
      */
-    subscribe(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
-        code: RCRTCCode;
-        failedList?: ISubscribeAttr[];
-    }>;
-    private __unsubscribe;
+    getRemoteUserIds(): string[];
     /**
-     * 取消订阅资源
-     * @param tracks
+     * 获取所有房间已发布的远端资源列表
+     * @returns
      */
-    unsubscribe(tracks: RCRemoteTrack[]): Promise<{
-        code: RCRTCCode;
-        failedList?: ISubscribeAttr[];
-    }>;
+    getRemoteTracks(): RCRemoteTrack[];
     /**
-     * 退出房间并销毁当前房间实例，退出后该房间的所有方法将不可用
-     * @private
+     * 获取远端用户的资源列表
+     * @param userId
+     * @returns
      */
-    __destroy(quitRoom: boolean): Promise<void>;
+    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
     /**
-     * 根据 trackId 获取房间内的远端资源
-     * @param trackId
+     * 获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新
      */
-    getRemoteTrack(trackId: string): RCRemoteTrack;
+    getSessionId(): string;
     /**
-     * TODO 待优化
-     * @param trackId
+     * 向房间内发消息
+     * @param name 消息名称
+     * @param content 消息内容
      */
-    getLocalTrack(trackId: string): RCRemoteTrack;
+    sendMessage(name: string, content: any): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * 断线重连后处理逻辑, SDK 内部处理调用
-     * @private
+     * 设置房间属性
+     * @param key 属性名
+     * @param value 属性值
+     * @param message 是否在设置属性的时候携带消息内容，传空则不往房间中发送消息
+     * @param isInner RTC 业务内部使用参数，用户忽略
      */
-    __onReconnected(): Promise<void>;
+    setRoomAttribute(key: string, value: string, message?: {
+        name: string;
+        content: string;
+    }, isInner?: boolean): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * 观众房间事件注册
-     * @param tag 参数描述
+     * 删除房间属性
+     * @param keys 待删除的属性名数组
+     * @param message 是否在删除属性的时候携带消息内容，传空则不往房间中发送消息
+     * @param isInner RTC 业务内部使用参数，用户忽略
      */
-    registerRoomEventListener(listener: IAudienceRoomEventListener | null): void;
+    deleteRoomAttributes(keys: string[], message?: {
+        name: string;
+        content: string;
+    }, isInner?: boolean): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * 音量上报
-     * @param handler 业务端传入的音量上报事件
-     * @param _  - 参数已废弃
+     * 获取房间属性
+     * @param keys 要查询的属性名数组，当数组长度为空时，取所有已设置的 kv 值
+     * @param isInner RTC 业务内部使用参数，用户忽略
      */
-    onAudioLevelChange(handler: IAudioLevelChangeHandler | null, _?: number): void;
-    private _reportListener;
+    getRoomAttributes(keys?: string[], isInner?: boolean): Promise<{
+        code: RCRTCCode;
+        data?: KVString;
+    }>;
     /**
-     * 注册房间数据监控
-     * @param listener
+     * 设置当前用户属性（暂不开放）
+     * @param key 属性名
+     * @param value 属性值
+     * @param message 是否在设置属性的时候携带消息内容，传空则不往房间中发送消息
      */
-    registerReportListener(listener: IRCRTCReportListener | null): void;
+    private _setUserAttributeValue;
     /**
-     * 获取房间 Id
+     * 删除当前用户属性（暂不开放）
+     * @param keys 待删除的属性名数组
+     * @param message 是否在删除属性的时候携带消息内容，传空则不往房间中发送消息
      */
-    getRoomId(): string;
+    private _deleteUserAttributes;
     /**
-     * 获取当前 userId
+     * 获取当前用户属性（暂不开放）
+     * @param keys 要查询的属性名数组
      */
-    getCrtUserId(): string;
+    private _getUserAttributes;
     /**
-     * 获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新
+     * 查询房间是否已销毁
      */
-    getSessionId(): string;
+    isDestroyed(): boolean;
     /**
-     * 获取远程主播用户列表
+     * 退出并销毁当前房间实例，退出后该房间的所有方法将不可用
+     * @private
      */
-    getRemoteUserIds(): string[];
+    __destroy(quitRoom: boolean): Promise<void>;
     /**
-     * 获取远端用户的资源列表
-     * @param userId
-     * @returns
+     * 退出房间之前禁用所有远端资源，避免退出动作耗时过长，
+     * 导致在未完全退出的过程中仍能听到房间内的声音问题
      */
-    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
+    private _muteRemoteTracksBeforeQuit;
+    private _leaveHandle;
     /**
-     * 获取房间内所有已发布的远端资源列表, 包含合流资源
-     * @returns
+     * 释放 PCManager 上的资源
      */
-    getRemoteTracks(): RCRemoteTrack[];
+    private _releasePCManager;
+    private _onLocalTrackDestroied;
     /**
-     * 获取远端 RTC tracks
+     * 本端流状态修改，需通知房间内其他成员
+     * @param localTrack
      */
-    getRemoteRTCTracks(): RCRemoteTrack[];
+    private _onLocalTrackMuted;
     /**
-     * 获取远端 MCU tracks
+     * 增量发布资源，若发布的资源 tag 及媒体类型重复，后者将覆盖前者进行发布。
+     * @param tracks 待发布的 RCLocalTrack 实例
+     * @returns
      */
-    getRemoteMCUTracks(): RCRemoteTrack[];
+    publish(tracks: (RCLocalTrack | IPublishAttrs)[]): Promise<IPubSuccessRes>;
     /**
-     * 获取房间内 CDN 信息
+     * 获取跨房间连麦需携带参数 pushOtherRooms 的值
      */
-    getCDNInfo(): {
-        resolution: RCResolution;
-        fps: RCFrameRate;
-        CDNEnable: boolean | undefined;
-    } | {
-        CDNEnable: boolean;
-        resolution?: undefined;
-        fps?: undefined;
-    };
-    getClientSessionId(): string;
-}
-
-/**
- * 北极星上报角色
- */
-declare enum PolarisRole {
+    protected _getPushOtherRoomsParams(): IPushOtherRooms[];
     /**
-     * 会议参会者、主播
+     * ice 断线后，尝试重新走 exchange
      */
-    MeetingOrAnchor = 1,
+    protected _reTryExchange(): Promise<ICommandResult<void>>;
     /**
-     * 观众
+     * 增量取消资源发布，若相应资源中存在小流资源，则同时取消发布
+     * @param tracks 取消发布的 RCLocalTrack 列表
      */
-    Audience = 2
-}
-
-declare class PolarisReporter {
-    private readonly _context;
-    private readonly _runtime;
-    private readonly _roomId;
-    private readonly _crtRTCRoom;
-    private readonly _userRole;
-    constructor(_context: RTCContext, _runtime: IRuntime, _roomId: string, _crtRTCRoom: RCAbstractRoom | RCAudienceLivingRoom, _userRole?: PolarisRole);
-    private _send;
-    private _getClientID;
+    unpublish(tracks: RCLocalTrack[]): Promise<IPubSuccessRes>;
     /**
-     * 小流需去掉 _tiny，小流 resourceId 为 userId_tag_mediaType_tiny
+     * resourceId 有效性验证
+     * @param resourceId
      */
-    private _getRealResourceId;
+    protected _isValidResourceId(resourceId: string): boolean;
     /**
-     * 生成北极星上报的 trackId
-     * @param resourceId userId_11_1_tiny 改为 userId_11_tiny_video
+     * 订阅资源
+     * @param tracks
      */
-    private _getPolarisTrackId;
+    subscribe(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
     /**
-     * 上下行 track 包含的公共字段
+     * 取消订阅资源
+     * @param tracks 预取消远端资源
      */
-    private _getBaseData;
-    private _getAudioLevel;
-    private _getBitrate;
-    private _getPacketsLostRate;
-    private _getFrameRate;
-    private _getResolution;
-    private _getJitter;
-    private _getNackCount;
-    private _getPliCount;
-    private _getRTT;
-    private _getTrackState;
+    unsubscribe(tracks: RCRemoteTrack[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
     /**
-     * 发送上行音视频资源数据
-     * @param data peerConnection stats 解析出来业务所需的所有字段
+     * 强制修改订阅列表，仅订阅数组中的资源，取消订阅其他已订阅资源。
+     * 当参数为 `[]` 时，意味着不再订阅任何资源
+     * @param tracks 变更的资源列表
      */
-    sendR3Data(data: IInnerRCRTCStateReport): Promise<RCSendCode>;
+    updateSubList(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
     /**
-     * 发送下行音视频资源数据
-     * @param data peerConnection stats 解析出来业务所需的所有字段
+     * 获取已发布的本地资源
+     * @param trackId
+     * @returns
      */
-    sendR4Data(data: IInnerRCRTCStateReport): Promise<RCSendCode>;
+    getLocalTrack(trackId: string): RCLocalTrack | null;
     /**
-     * 加入房间
+     * 获取所有已发布的资源
      */
-    sendR1(): void;
+    getLocalTracks(): RCLocalTrack[];
     /**
-     * RTC 和 LIVE 发布、取消发布
-     * RTC 订阅、取消订阅
+     * 根据 trackId 获取房间内的远端资源
+     * @param trackId
+     * @returns
      */
-    sendR2(action: string, status: string, trackIds: string[]): void;
-}
-
-/**
- * PC 实例管理类
- */
-declare class RCRTCPeerConnection extends EventEmitter {
-    private _logger;
+    getRemoteTrack(trackId: string): RCRemoteAudioTrack | RCRemoteVideoTrack | null;
     /**
-     * _reTryExchange 方法
+     * 获取当前已经订阅的全量资源
+     * returns subscribedTracks ISubscribeAttr[]
      */
-    private readonly _reTryExchange;
+    get subscribedTracks(): ISubscribeAttr[];
+    private _appListener;
     /**
-     * 当前用户 id
+     * 注册事件监听器，多次注册会导致后者覆盖前者，可以通过使用 `registerRoomEventListener(null)` 取消注册
+     * @param listener
      */
-    private readonly _currentUserId;
+    registerRoomEventListener(listener: IRoomEventListener | null): void;
     /**
-     * store 实例
+     * 注册房间数据监控
+     * @param listener
+     * @description 该方法暂仅支持 Chrome 浏览器
      */
-    private readonly _store;
+    registerReportListener(listener: IRCRTCReportListener | null): void;
     /**
-     * 北极星上传实例
+     * 音量上报
+     * @param handler 音量事件监听函数
+     * @param _ - 参数已废弃，SDK 默认以每秒一次进行回调~~上报时间间隔~~
      */
-    private readonly _polarisReport?;
+    onAudioLevelChange(handler: IAudioLevelChangeHandler | null, _?: number): void;
     /**
-     * 是否是房间内观众
+     * 断线重连后尝试补发断线过程中的通知信息
      */
-    private readonly _isRoomAudience;
-    static __INNER_EVENT_TRACK_READY__: string;
-    static __INNER_AUDIOLEVEL_CHANGE__: string;
-    static __INNER_ICE_STATE_CHANGE__: string;
-    static __INNER_ICE_CONNECTED__: string;
-    private readonly _rtcPeerConn;
-    private readonly _sdpStrategy;
-    reportParser: IStatParser | null;
-    private pubLocalTracks;
-    private _reTryExchangeTimer;
-    private _reportStatsTimer;
-    private _reportR3R4ToPolarisTimer;
-    private _isDestroyed;
-    private _formatStatsData?;
-    constructor(_logger: BasicLogger, 
     /**
-     * _reTryExchange 方法
+     * @private
+     * @param livingType
      */
-    _reTryExchange: () => Promise<ICommandResult<void>>, 
+    __onReconnected(livingType?: RCLivingType): void;
+    private _onAudioMuteChange;
+    private _onVideoMuteChange;
     /**
-     * 当前用户 id
+     * 存储连麦监听事件
      */
-    _currentUserId: string, 
+    private _onRecvPKMsg;
     /**
-     * store 实例
+     * 注册 PK 业务监听方法
      */
-    _store: ReadableStore, 
+    protected _registerPKMsgListener(listener: IOnRecvPKMsg | null): void;
     /**
-     * 北极星上传实例
+     * 退出 PK 房间
      */
-    _polarisReport?: PolarisReporter | undefined, 
+    protected _quitAllPKRoom(): Promise<void>;
+    getClientSessionId(): string;
     /**
-     * 是否是房间内观众
+     * 切换已发布视频或音频的媒体设备
+     * @param oldTrack 已经发布的视频轨道或音频轨道
+     * @param newTrack 从新设备获取的视频轨道或音频轨道
+     * @returns code 切换结果，RCRTCCode.SUCCESS 表示切换成功
      */
-    _isRoomAudience?: boolean, 
+    changeMediaDevice(oldTrack: RCCameraVideoTrack | RCMicphoneAudioTrack, newTrack: RCCameraVideoTrack | RCMicphoneAudioTrack): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * 是否启用自定义加密
+     * 设置输入语言代码，用于语音识别精准识别
+     * @param srcLanguage 语言代码
+     * @description 需要在 `setEnableASR` 开启语音识别接口之前调用
+     * @return
      */
-    encrypt?: boolean);
-    getLocalTracks(): RCLocalTrack[];
-    private _onConnectionStateChange;
-    private startAutoExecute;
-    private stopAutoExecute;
-    private _onICEConnectionStateChange;
-    private _inRetry;
-    private _handleRetry;
-    private _onTrackReady;
+    setSrcLanguageCode(srcLanguage: string): Promise<ICommandResult<unknown>>;
     /**
-     * @deprecated use RCLocalTrack.setBitrate instead of setBitrate
+     * 开启房间内的语音识别服务
+     * @returns
      */
-    setBitrate(max: number, min: number, start?: number): Promise<void>;
+    startASR(): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * `createOffer` 是一个创建报价并记录报价 SDP 和 SDP 语义的函数
-     * @param {boolean} iceRestart - 布尔值
-     * @returns 具有两个属性的对象：
-     *   - sdp：SDP 字符串
-     *   - 语义：SDP 语义
+     * 关闭房间内的语音识别服务
+     * @returns
      */
-    createOffer(iceRestart: boolean): Promise<IOfferInfo>;
-    private _firstConnectFromPub;
+    stopASR(): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * @param answer
-     * @param fromPub 是否来自于发布动作，用来对外通知连接成功后统计
+     * 是否有语音识别资源
+     * @returns
      */
-    setRemoteAnswer(answer: string, fromPub?: boolean): Promise<RCRTCCode>;
-    getLocalTrack(trackId: string): RCLocalTrack | null;
+    asrIsAvailable(): boolean;
     /**
-     * 它将本地轨道添加到对等连接。
-     * @param {RCLocalTrack} track - 要添加的本地轨道。
+     * 设置房间内的语音识别资源是否可用
+     * @param enable 为 ture 时，sdk 会获取语音识别资源并解析，通过房间监听事件 `onReceiveASRContent` 事件，抛出语音识别内容
+     * @description
+     * @returns
      */
-    addLocalTrack(track: RCLocalTrack): void;
+    setEnableASR(enable: boolean): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * 按 ID 删除本地轨道
-     * @param {string} trackId - 要移除的轨道的 ID。
-     * @returns 正在删除的轨道。
+     * 开启语音实时翻译
+     * @param destLangCode 翻译的目标语言
+     * @description 执行时机：需在房间监听事件 `onReceiveStartASR` 中执行。
+     * @description 执行条件：房间内语音识别资源被设置为可用
+     * @returns
      */
-    removeLocalTrackById(trackId: string): void;
+    startRealtimeTranslation(destLangCode: string): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * 它会删除所有本地Track。
+     * 关闭语音实时翻译
+     * @returns
      */
-    removeAllLocalTrack(): void;
+    stopRealtimeTranslation(): Promise<{
+        code: RCRTCCode;
+    }>;
+}
+
+declare class RCLocalMediaStream {
+    readonly msid: string;
+    readonly mediaStream: MediaStream;
+    readonly tinyStream: MediaStream;
+    readonly tag: string;
+    constructor(msid: string);
+}
+
+interface IAudienceRoomEventListener extends IRCRTCTrackEventListener {
     /**
-     * 从对等连接中删除本地轨道。
-     * @param {RCLocalTrack} track - 要删除的本地轨道。
+     * 主播加入
+     * @param userIds 加入主播的 id 列表
      */
-    removeLocalTrack(track: RCLocalTrack, isRemoveTiny?: boolean): void;
-    private _updateRecvTransceiverMap;
-    updateSubRemoteTracks(remoteTracks: RCRemoteTrack[]): void;
+    onAnchorJoin?(userId: string[]): void;
     /**
-     * 获取当前已发布视频流信息
+     * 主播退出
+     * @param userIds 退出主播的 id 列表
      */
-    getOutboundVideoInfo(): OutboundVideoInfo[];
-    private _onLocalTrackMuted;
-    private _onLocalTrackDestroied;
-    private _reportListener;
+    onAnchorLeave?(userId: string[]): void;
     /**
-     * 注册连接数据监控，开启质量数据上报定时器
-     * @param listener
+     * 房间内合流发布资源
+     * @param tracks 新发布的合流音轨与视轨数据列表，包含新发布的 RCRemoteAudioTrack 与 RCRemoteVideoTrack 实例
+     * @description
+     * 当房间内某个主播第一次发布资源时触发
      */
-    registerReportListener(listener: IRCRTCReportListener | null): void;
+    onTrackPublish?(tracks: RCRemoteTrack[]): void;
     /**
-     * 组装上行质量报告数据
+     * 房间内取消合流发布资源
+     * @param tracks 被取消发布的合流音轨与视轨数据列表
+     * @description
+     * 当房间内全部主播退出房间时，SDK 内部会取消对资源的订阅，业务层仅需处理 UI 业务
      */
-    private _createSenderReport;
+    onTrackUnpublish?(tracks: RCRemoteTrack[]): void;
     /**
-     * 组装下行质量报告数据
+     * 房间内主播发布资源
+     * @param tracks 主播新发布的音轨与视轨数据列表，包含新发布的 RCRemoteAudioTrack 与 RCRemoteVideoTrack 实例
      */
-    private _createReceiverReport;
-    private _createRCRTCStateReport;
+    onAnchorTrackPublish?(tracks: RCRemoteTrack[]): void;
     /**
-     * 获取 peerConnection stats 数据并格式化
-     * @returns 返回格式化后的数据
+     * 房间内主播取消发布资源
+     * @param tracks 被主播取消发布的音轨与视轨数据列表
+     * @description 当资源被取消发布时，SDK 内部会取消对相关资源的订阅，业务层仅需处理 UI 业务
      */
-    private _getStatsData;
+    onAnchorTrackUnpublish?(tracks: RCRemoteTrack[]): void;
     /**
-     * 通知用户质量数据、peerConnection 北极星数据上报
+     * 房间主播禁用/启用音频
+     * @param audioTrack RCRemoteAudioTrack 类实例
      */
-    private _reportHandle;
+    onAudioMuteChange?(audioTrack: RCRemoteAudioTrack): void;
     /**
-     * 获取合流音源信息
-     */
-    private _getLiveAudioState;
+    * 房间主播禁用/启用视频
+    * @param videoTrack RCRemoteVideoTrack 类实例对象
+    */
+    onVideoMuteChange?(videoTrack: RCRemoteVideoTrack): void;
     /**
-     * 北极星上报 R3、R4 数据
+     * 房间内主播把发布的资源推至 CDN
      */
-    private _sendR3R4Data;
+    onCDNInfoEnable?(CDNInfo: {
+        resolution: RCResolution;
+        fps: RCFrameRate;
+    }): void;
     /**
-     * 2s 给北极星上报一次 R3、R4
+     * 主播停止推 CDN
      */
-    __reportR3R4ToPolaris(): Promise<void>;
-    getRTCPeerConn(): RTCPeerConnection;
+    onCDNInfoDisable?(): void;
     /**
-     * 关闭 RTCPeerConnection 连接。其生命周期：
-     * 1. 连接生命周期与房间实例一致（包含观众加房间），仅在退出房间时进行关闭。
-     * 2. 观众客户端（观众不加房间）订阅时创建，取消订阅时销毁
+     * 主播改变推 CDN 的分辨率或帧率
      */
-    destroy(): void;
-    clearReTryExchangeTimer(): void;
-    isDestroyed(): boolean;
+    onCDNInfoChange?(CDNInfo: {
+        resolution: RCResolution;
+        fps: RCFrameRate;
+    }): void;
 }
-
 /**
- * 命令执行上下文
+ * 观众直播房间类
+ * 处理：
+ * 1、通知观众房间内 人员变更、资源变更
+ * 2、观众订阅、取消订阅资源
  */
-declare class CommandExecuteContext extends EventEmitter {
+declare class RCAudienceLivingRoom {
+    private readonly _context;
+    private readonly _runtime;
+    private readonly _initOptions;
+    private readonly _roomId;
+    private readonly _joinResData;
+    readonly livingType: RCLivingType;
+    protected readonly _clientSessionId: string;
+    private readonly _service;
+    /**
+     * 主播列表
+     */
+    private _roomAnchorList;
+    /**
+     * 合流、分流资源
+     */
+    private _roomRes;
     /**
-     * 日志工具
+     * 主播分流资源
      */
-    readonly logger: BasicLogger;
+    private _roomAnchorRes;
     /**
-     * MediaServer 请求实例
+     * 合流、分流 remoteTracks
      */
-    readonly service: RCMediaService;
+    private _remoteTracks;
+    private _appListener;
+    private readonly _pc;
+    private _subscribedList;
+    private _sessionId;
+    private _destroyed;
     /**
-     * IM 信令上下文
+     * 北极星上报实例
      */
-    readonly context: RTCContext;
+    protected readonly _polarisReport: PolarisReporter;
     /**
-     * 运行时
+     * 音量上报实例
      */
-    readonly runtime: IRuntime;
+    private readonly _audioLevelReport;
     /**
-     * PeerConenction 连接实例
+     * cdn_uris 资源
      */
-    readonly peer: RCRTCPeerConnection;
+    private _CDNUris;
+    private _isPulling;
+    private _pullTime;
+    private readonly _store;
+    private _crtUserId;
+    private readonly _reportMediaActionLogger;
     /**
-     * 内存只读模块
+     * track 对应的 mediaServer 信息
      */
-    readonly store: ReadableStore;
+    private _trackMediaMap;
+    private readonly _logger;
+    constructor(_context: RTCContext, _runtime: IRuntime, _initOptions: IRCRTCInitOptions, _roomId: string, _joinResData: {
+        token: string;
+        kvEntries: IServerRTCRoomEntry[];
+    }, livingType: RCLivingType, _clientSessionId?: string);
+    private _startPull;
     /**
-     * 北极星统计工具
+     * 解析服务端返回的 KV 数据，赋值 room 内数据
      */
-    readonly polarisReport: PolarisReporter;
+    private _setInitData;
+    protected _assertRoomDestroyed(): RCRTCCode | 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 资源数据
      */
-    readonly reportMediaActionLogger: ReportMediaActionLogger;
-    constructor(
+    private singalDataChange;
     /**
-     * 日志工具
+     * 计算加入离开的主播 ID 列表
      */
-    logger: BasicLogger, 
+    private _diffAnchorList;
+    private _handleNewJoinedAnchor;
+    private _handleLeftedAnchor;
     /**
-     * MediaServer 请求实例
+     * 计算新发布和取消发布的合流资源
      */
-    service: RCMediaService, 
+    private _diffRoomResource;
     /**
-     * IM 信令上下文
+     * 处理主播资源的新增发布
      */
-    context: RTCContext, 
+    private _dealPublished;
     /**
-     * 运行时
+     * 处理主播资源的取消发布
      */
-    runtime: IRuntime, 
+    private _dealUnpublished;
     /**
-     * PeerConenction 连接实例
+     * 处理主播资源的变更
      */
-    peer: RCRTCPeerConnection, 
+    private _dealModified;
     /**
-     * 内存只读模块
+     * 计算主播发布和取消发布的资源，以及资源的状态变更
+    */
+    private _diffAnchorResource;
+    private _onUserUnpublish;
+    private _callAppListener;
+    /**
+     * ice 断线后，尝试重新走 exchange
+    */
+    private _reTryExchange;
+    /**
+     * 获取 subscribe 接口的请求体数据
+     * @param subscribeList 订阅清单
+     * @param publishedStreams 已发布流
+     * @param iceRestart
      */
-    store: ReadableStore, 
+    protected _createSubscribeParams(subscribeList: ISubscribeAttr[], publishedStreams: {
+        [msid: string]: RCLocalMediaStream;
+    }, iceRestart: boolean): Promise<{
+        reqBody: IBroadcastSubReqBody;
+        offer: RTCSessionDescriptionInit;
+        dynamicBitrate: {
+            min: number;
+            max: number;
+        };
+    }>;
+    private _subscribeHandle;
     /**
-     * 北极星统计工具
+     * 添加 peerConnection 事件
      */
-    polarisReport: PolarisReporter, 
+    private _addPeerCEvent;
+    private _getReqHeaders;
+    private _exchangeHandle;
+    private _dealSubscribeResult;
     /**
-     * 行为数据采集工具
+     * 去重、转化参数格式为 ISubscribeAttr
      */
-    reportMediaActionLogger: ReportMediaActionLogger);
+    private _getParams;
+    private _reportPubOrSubQualityData;
+    private _updateSubListHandle;
     /**
-     * 代理房间实例以获取跨房间连麦时的推送配置
+     * 对比 cdn_uris 资源
+     * @param newCDNUris 新的 cdn_uris 数据
      */
-    getPushOtherRooms: () => IPushOtherRooms[];
-}
-
-/**
- * @typeParams T - 事务执行上下文类型
- * @typeParams S - 内存读写模块类型
- */
-declare class BaseInvoker<T, S> {
-    protected readonly _logger: BasicLogger;
+    private _diffCDNUris;
     /**
-     * 内存数据管理实例
+     * 获取 CDN 资源对应的拉流地址
+     * _CDNUris 无 url 时，说明未开启 CDN 推送
+     * @returns CDNPlayUrl
      */
-    protected readonly _context: T;
+    private _getCDNPlayUrl;
     /**
-     * 内存读写模块
+     * 获取 CDN 资源对应的拉流地址
+     * @returns CDNPlayUrl
      */
-    protected readonly _store: S;
+    getCDNPlayUrl(resolution?: RCResolution, fps?: RCFrameRate): Promise<{
+        code: RCRTCCode;
+        CDNPlayUrl?: string;
+    }>;
     /**
-     * 命令终止时返回的错误码定义
+     * 订阅资源
+     * @param tracks
      */
-    private abortCode;
-    constructor(_logger: BasicLogger, 
+    subscribe(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
+    private __unsubscribe;
     /**
-     * 内存数据管理实例
+     * 取消订阅资源
+     * @param tracks
      */
-    _context: T, 
+    unsubscribe(tracks: RCRemoteTrack[]): Promise<{
+        code: RCRTCCode;
+        failedList?: ISubscribeAttr[];
+    }>;
     /**
-     * 内存读写模块
+     * 退出房间并销毁当前房间实例，退出后该房间的所有方法将不可用
+     * @private
      */
-    _store: S, 
+    __destroy(quitRoom: boolean): Promise<void>;
     /**
-     * 命令终止时返回的错误码定义
+     * 根据 trackId 获取房间内的远端资源
+     * @param trackId
      */
-    abortCode: RCRTCCode);
-    private _queue;
-    private _busy;
-    private _next;
-    private _execute;
-    push<R>(command: BaseCommand<R, T, S>): Promise<ICommandResult<R>>;
-    private _isDestroyed;
-    isDestroyed(): boolean;
-    destroy(): void;
-}
-/**
- * 房间任务队列管理
- */
-declare class Invoker extends BaseInvoker<CommandExecuteContext, Store> {
-    constructor(context: CommandExecuteContext, store: Store);
+    getRemoteTrack(trackId: string): RCRemoteTrack;
     /**
-     * 获取 store 存储实例，返回值类型 `ReadableStore`，避免非 command 定义中修改内存
+     * TODO 待优化
+     * @param trackId
      */
-    get store(): ReadableStore;
-    destroy(): void;
-}
-
-declare enum CommandPriority {
-    LOW = 0,
-    NORMAL = 1,
-    HIGH = 2
-}
-declare type ICommandResult<R = void> = {
-    code: number;
-    data?: R;
-};
-/**
- * 命令基类
- * @typeParams R - 返回值类型声明
- * @typeParams T - 命令执行上下文类型
- * @typeParams S - 内存数据缓存模块
- */
-declare abstract class BaseCommand<R = void, T = CommandExecuteContext, S = Store> {
+    getLocalTrack(trackId: string): RCRemoteTrack;
     /**
-     * 事务执行函数
-     * @param context - 事务执行上下文
-     * @param store - 内存读写模块
-     * @param invoker - 任务队列
+     * 断线重连后处理逻辑, SDK 内部处理调用
+     * @private
      */
-    abstract execute(context: T, store: S, invoker: BaseInvoker<T, S>): Promise<ICommandResult<R>>;
+    __onReconnected(): Promise<void>;
     /**
-     * 获取指令优先级，必要时可 override 此函数
+     * 观众房间事件注册
+     * @param tag 参数描述
      */
-    get priority(): CommandPriority;
+    registerRoomEventListener(listener: IAudienceRoomEventListener | null): void;
     /**
-     * 它返回命令的种类。
-     * @returns 命令的种类。
+     * 音量上报
+     * @param handler 业务端传入的音量上报事件
+     * @param _  - 参数已废弃
      */
-    get kind(): RCCommandKind;
-}
-
-/**
- * RTC 消息类型常量
- * @private
- */
-declare enum RCRTCMessageType {
+    onAudioLevelChange(handler: IAudioLevelChangeHandler | null, _?: number): void;
+    private _reportListener;
     /**
-     * 增量资源发布消息
-     * @deprecated
+     * 注册房间数据监控
+     * @param listener
      */
-    PUBLISH = "RCRTC:PublishResource",
+    registerReportListener(listener: IRCRTCReportListener | null): void;
     /**
-     * 增量资源取消发布消息
-     * @deprecated
+     * 获取房间 Id
      */
-    UNPUBLISH = "RCRTC:UnpublishResource",
+    getRoomId(): string;
     /**
-     * 增量资源状态变更消息
-     * @deprecated
+     * 获取当前 userId
      */
-    MODIFY = "RCRTC:ModifyResource",
+    getCrtUserId(): string;
     /**
-     * 全量资源变更消息
+     * 获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新
      */
-    TOTAL_CONTENT_RESOURCE = "RCRTC:TotalContentResources",
+    getSessionId(): string;
     /**
-     * 房间人员变更
+     * 获取远程主播用户列表
      */
-    STATE = "RCRTC:state",
+    getRemoteUserIds(): string[];
     /**
-     * 房间属性变更
+     * 获取远端用户的资源列表
+     * @param userId
+     * @returns
      */
-    ROOM_NOTIFY = "RCRTC:RoomNtf",
+    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
     /**
-     * 房间用户属性变更
+     * 获取房间内所有已发布的远端资源列表, 包含合流资源
+     * @returns
      */
-    USER_NOTIFY = "RCRTC:UserNtf",
+    getRemoteTracks(): RCRemoteTrack[];
     /**
-     * 被服务踢出房间
+     * 获取远端 RTC tracks
      */
-    KICK = "RCRTC:kick",
+    getRemoteRTCTracks(): RCRemoteTrack[];
     /**
-     * 跨房间连麦 PK 请求消息
+     * 获取远端 MCU tracks
      */
-    PK_INVITE = "RCRTC:invite",
+    getRemoteMCUTracks(): RCRemoteTrack[];
     /**
-     * 连麦请求超时
+     * 获取房间内 CDN 信息
      */
-    PK_INVITE_TIMEOUT = "RCRTC:inviteTimeout",
+    getCDNInfo(): {
+        resolution: RCResolution;
+        fps: RCFrameRate;
+        CDNEnable: boolean | undefined;
+    } | {
+        CDNEnable: boolean;
+        resolution?: undefined;
+        fps?: undefined;
+    };
+    getClientSessionId(): string;
+}
+
+/**
+ * 北极星上报角色
+ */
+declare enum PolarisRole {
     /**
-     * 跨房间连麦 PK 取消请求消息
+     * 会议参会者、主播
      */
-    PK_CANCEL_INVITE = "RCRTC:cancelInvite",
+    MeetingOrAnchor = 1,
     /**
-     * 跨房间连麦 PK 请求响应消息
+     * 观众
      */
-    PK_INVITE_ANSWER = "RCRTC:answerInvite",
+    Audience = 2
+}
+
+declare class PolarisReporter {
+    private readonly _context;
+    private readonly _runtime;
+    private readonly _roomId;
+    private readonly _crtRTCRoom;
+    private readonly _userRole;
+    constructor(_context: RTCContext, _runtime: IRuntime, _roomId: string, _crtRTCRoom: RCAbstractRoom | RCAudienceLivingRoom, _userRole?: PolarisRole);
+    private _send;
+    private _getClientID;
     /**
-     * 结束跨房间连麦 PK 消息
+     * 小流需去掉 _tiny，小流 resourceId 为 userId_tag_mediaType_tiny
      */
-    PK_END = "RCRTC:endInvite",
+    private _getRealResourceId;
     /**
-     * 连麦的房间不再了或离线了，主直播房间会收到的消息通知
+     * 生成北极星上报的 trackId
+     * @param resourceId userId_11_1_tiny 改为 userId_11_tiny_video
      */
-    OTHER_ROOM_OFFLINE = "RCRTC:otherRoomOffline",
+    private _getPolarisTrackId;
     /**
-     * 订阅、取消订阅动作成功
+     * 上下行 track 包含的公共字段
      */
-    ROOM_TASK_FINISH = "RCRTC:roomTaskFinish"
-}
-
-declare type IOnRecvPKMsg = (msg: IReceivedMessage) => void;
-interface IRoomPKEventListener {
+    private _getBaseData;
+    private _getAudioLevel;
+    private _getBitrate;
+    private _getPacketsLostRate;
+    private _getFrameRate;
+    private _getResolution;
+    private _getJitter;
+    private _getNackCount;
+    private _getPliCount;
+    private _getRTT;
+    private _getTrackState;
     /**
-     * 收到连麦邀请
+     * 发送上行音视频资源数据
+     * @param data peerConnection stats 解析出来业务所需的所有字段
      */
-    onRequestJoinOtherRoom: (info: IPKInviteInfo) => {};
+    sendR3Data(data: IInnerRCRTCStateReport): Promise<RCSendCode>;
     /**
-     * 收到取消连麦邀请
+     * 发送下行音视频资源数据
+     * @param data peerConnection stats 解析出来业务所需的所有字段
      */
-    onCancelRequestOtherRoom: (info: IPKInviteInfo) => {};
+    sendR4Data(data: IInnerRCRTCStateReport): Promise<RCSendCode>;
     /**
-     * 收到连麦 PK 请求响应结果
+     * 加入房间
      */
-    onResponseJoinOtherRoom: (info: IPKInviteAnswerInfo) => {};
+    sendR1(): void;
     /**
-     * 收到 PK 结束
+     * RTC 和 LIVE 发布、取消发布
+     * RTC 订阅、取消订阅
      */
-    onFinishOtherRoom: (info: IPKEndInfo) => {};
+    sendR2(action: string, status: string, trackIds: string[]): void;
 }
-declare class RCLivingPKHandler {
-    private _invoker;
-    private _PKInfo;
-    private readonly _context;
-    private readonly _runtime;
-    private readonly _service;
-    private readonly _initOptions;
+
+/**
+ * PC 实例管理类
+ */
+declare class RCRTCPeerConnection extends EventEmitter {
+    readonly _context: RTCContext;
+    private _logger;
     /**
-     * 主直播房间
+     * _reTryExchange 方法
      */
-    private readonly _mainLivingRoom;
-    private readonly _registerPKMsgListener;
+    private readonly _reTryExchange;
     /**
-     * 加入 PK 房间回调
+     * 当前用户 id
      */
-    private readonly _onJoinedPKRoom;
-    protected readonly _clientSessionId?: string | undefined;
+    private readonly _currentUserId;
     /**
-     * PK 邀请超时时间，默认 30s
+     * store 实例
      */
-    private readonly _inviteTimeout;
-    private _appListener;
-    private _mainRoomId;
+    private readonly _store;
     /**
-     * 跨房间连麦加入的 PK 房间
+     * 北极星上传实例
      */
-    private _joinedPKRooms;
-    private readonly _logger;
-    constructor(_invoker: Invoker, _PKInfo: IPKInfo, _context: RTCContext, _runtime: IRuntime, _service: RCMediaService, _initOptions: IRCRTCInitOptions, 
+    private readonly _polarisReport?;
     /**
-     * 主直播房间
+     * 是否是房间内观众
      */
-    _mainLivingRoom: RCLivingRoom, _registerPKMsgListener: (listener: IOnRecvPKMsg) => void, 
+    private readonly _isRoomAudience;
+    static __INNER_EVENT_TRACK_READY__: string;
+    static __INNER_AUDIOLEVEL_CHANGE__: string;
+    static __INNER_ICE_STATE_CHANGE__: string;
+    static __INNER_ICE_CONNECTED__: string;
+    static __INNER_SEI_CONTENT__: string;
+    private readonly _rtcPeerConn;
+    private readonly _sdpStrategy;
+    reportParser: IStatParser | null;
+    private pubLocalTracks;
+    private _reTryExchangeTimer;
+    private _reportStatsTimer;
+    private _reportR3R4ToPolarisTimer;
+    private _isDestroyed;
+    private _formatStatsData?;
+    constructor(_context: RTCContext, _logger: BasicLogger, 
     /**
-     * 加入 PK 房间回调
+     * _reTryExchange 方法
      */
-    _onJoinedPKRoom: (roomId: string, traceId: string) => Promise<void>, _clientSessionId?: string | undefined);
-    private _callAppListener;
+    _reTryExchange: () => Promise<ICommandResult<void>>, 
     /**
-     * 收到连麦邀请
+     * 当前用户 id
      */
-    private _onInvite;
+    _currentUserId: string, 
     /**
-     * 收到取消连麦
+     * store 实例
      */
-    private _onCancelInvite;
-    private _onInviteTimeout;
+    _store: ReadableStore, 
     /**
-     * 收到响应连麦
+     * 北极星上传实例
      */
-    private _onInviteAnswer;
-    private createLeaveOtherRoomCommand;
+    _polarisReport?: PolarisReporter | undefined, 
     /**
-     * 收到连麦结束
+     * 是否是房间内观众
      */
-    private _onPKEnd;
+    _isRoomAudience?: boolean, 
     /**
-     * 处理跨房间连麦相关消息
+     * 是否启用自定义加密
      */
-    private _onRecvPKMsg;
+    encrypt?: boolean);
+    getLocalTracks(): RCLocalTrack[];
+    private _decodeSeiData;
+    private _onConnectionStateChange;
+    private startAutoExecute;
+    private stopAutoExecute;
+    private _onICEConnectionStateChange;
+    private _inRetry;
+    private _handleRetry;
+    private _onTrackReady;
     /**
-     * 注册跨房间连麦监听事件
+     * @deprecated use RCLocalTrack.setBitrate instead of setBitrate
      */
-    registerRoomPKEventListener(listener: IRoomPKEventListener): void;
+    setBitrate(max: number, min: number, start?: number): Promise<void>;
     /**
-     * 发起跨房间连麦请求
-     * @param inviteeRoomId 被邀请者所处的房间 roomId
-     * @param inviteeUserId 被邀请者 userId
-     * @param options.autoMix 是否将本房间资源合并到被邀请者所处房间的 MCU 合流中
-     * @param options.extra 拓展字段，可随邀请连麦消息透传给被邀请者
+     * `createOffer` 是一个创建报价并记录报价 SDP 和 SDP 语义的函数
+     * @param {boolean} iceRestart - 布尔值
+     * @returns 具有两个属性的对象：
+     *   - sdp：SDP 字符串
+     *   - 语义：SDP 语义
      */
-    requestJoinOtherRoom(inviteeRoomId: string, inviteeUserId: string, options?: IReqResPKOptions): Promise<{
-        code: RCRTCCode | ErrorCode;
-    }>;
+    createOffer(iceRestart: boolean): Promise<IOfferInfo>;
+    private _firstConnectFromPub;
     /**
-     * 取消跨房间连麦请求
-     * @param inviteeRoomId 被邀请者所处的房间 roomId
-     * @param inviteeUserId 被邀请者 userId
-     * @param extra 附加信息，可随取消邀请连麦消息透传给被邀请者
+     * @param answer
+     * @param fromPub 是否来自于发布动作，用来对外通知连接成功后统计
      */
-    cancelRequestJoinOtherRoom(inviteeRoomId: string, inviteeUserId: string, extra?: string): Promise<{
-        code: RCRTCCode | ErrorCode;
-    }>;
+    setRemoteAnswer(answer: string, fromPub?: boolean): Promise<RCRTCCode>;
+    getLocalTrack(trackId: string): RCLocalTrack | null;
     /**
-     * 响应跨房间连麦请求
-     * @param inviterRoomId 邀请者所处的房间 roomId
-     * @param inviterUserId 邀请者 userId
-     * @param agree 是否同意连麦
-     * @param options.autoMix 是否将本房间资源合并到邀请者所处房间的 MCU 合流中
-     * @param options.extra 附加信息，可随响应连麦消息透传给邀请者
+     * 它将本地轨道添加到对等连接。
+     * @param {RCLocalTrack} track - 要添加的本地轨道。
      */
-    responseJoinOtherRoom(inviterRoomId: string, inviterUserId: string, agree: boolean, options?: IReqResPKOptions): Promise<{
-        code: RCRTCCode | ErrorCode;
-    }>;
+    addLocalTrack(track: RCLocalTrack): void;
     /**
-     * 加入副直播房间
-     * @roomId 副房间的 roomId
+     * 按 ID 删除本地轨道
+     * @param {string} trackId - 要移除的轨道的 ID。
+     * @returns 正在删除的轨道。
      */
-    joinOtherRoom(roomId: string): Promise<{
-        code: RCRTCCode;
-        room?: RCLivingRoom;
-        userIds?: string[];
-        tracks?: RCRemoteTrack[];
-        CDNEnable?: boolean;
-    }>;
+    removeLocalTrackById(trackId: string): void;
+    /**
+     * 它会删除所有本地Track。
+     */
+    removeAllLocalTrack(): void;
     /**
-     * 退出副房间
-     * @param room 要退出的副房间的 room 实例
-     * @param isQuitPK 是否要结束连麦
+     * 从对等连接中删除本地轨道。
+     * @param {RCLocalTrack} track - 要删除的本地轨道。
      */
-    leaveOtherRoom(room: RCLivingRoom, isQuitPK?: boolean): Promise<{
-        code: RCRTCCode;
-    }>;
+    removeLocalTrack(track: RCLocalTrack, isRemoveTiny?: boolean): void;
+    private _updateRecvTransceiverMap;
+    updateSubRemoteTracks(remoteTracks: RCRemoteTrack[]): void;
     /**
-     * 获取连麦信息
-     * @param roomId 连麦房间的 roomId
+     * 获取当前已发布视频流信息
      */
-    getPKInfo(roomId: string): {
-        inviteSessionId: string;
-        inviterRoomId: string;
-        inviterUserId: string;
-        inviterUserAutoMix?: boolean | undefined;
-        inviteeRoomId: string;
-        inviteeUserAutoMix?: boolean | undefined;
-    };
+    getOutboundVideoInfo(): OutboundVideoInfo[];
+    private _onLocalTrackMuted;
+    private _onLocalTrackDestroied;
+    private _reportListener;
     /**
-     * 获取所有连麦信息
+     * 注册连接数据监控，开启质量数据上报定时器
+     * @param listener
      */
-    getAllPKInfo(): IPKInfo;
+    registerReportListener(listener: IRCRTCReportListener | null): void;
     /**
-     * 获取已加入的副房间
+     * 组装上行质量报告数据
      */
-    getJoinedPKRooms(): {
-        [roomId: string]: RCLivingRoom;
-    };
-}
-
-declare type ResourceMsgContent = {
+    private _createSenderReport;
     /**
-     * 旧版本兼容参数，当收到非 `RTCMessageName.TOTAL_CONTENT_RESOURCE` 时：
-     * * ignore 值为 `true` 表示该消息由 signal server 向旧版本 RTCLib 提供的兼容消息，无需处理
-     * * 否则认为该消息是由旧版本 RTCLib 主动发出的增量变更消息，需要处理
+     * 组装下行质量报告数据
      */
-    ignore?: boolean;
+    private _createReceiverReport;
+    private _createRCRTCStateReport;
     /**
-     * 发布到房间内的资源列表，`RTCMessageName.TOTAL_CONTENT_RESOURCE` 消息携带全量数据，否则为增量数据
+     * 获取 peerConnection stats 数据并格式化
+     * @returns 返回格式化后的数据
      */
-    uris: IPublishedResource[];
-    cdn_uris?: ICDNUris[];
-};
-
-/**
- * 房间抽象基类
- */
-declare abstract class RCAbstractRoom extends EventEmitter {
-    protected readonly _context: RTCContext;
-    protected readonly _runtime: IRuntime;
-    readonly _roomId: string;
-    protected readonly _service: RCMediaService;
-    protected readonly _initOptions: IRCRTCInitOptions;
-    protected readonly _clientSessionId: string;
+    private _getStatsData;
     /**
-     * 房间保活 rtcPing
+     * 通知用户质量数据、peerConnection 北极星数据上报
      */
-    private readonly _pinger;
+    private _reportHandle;
     /**
-     * 北极星上报实例
+     * 获取合流音源信息
      */
-    protected readonly _polarisReport: PolarisReporter;
+    private _getLiveAudioState;
     /**
-     * 音量上报实例
+     * 北极星上报 R3、R4 数据
      */
-    private readonly _audioLevelReport;
-    protected readonly _peerConnection: RCRTCPeerConnection;
-    protected readonly _invoker: Invoker;
-    protected readonly _store: ReadableStore;
-    private readonly _reportMediaActionLogger;
-    protected readonly _logger: BasicLogger;
-    protected readonly _executeCtx: CommandExecuteContext;
+    private _sendR3R4Data;
     /**
-     * RCRTCRoom 类的构造函数。
-     * @param {RTCContext} _context - RTC上下文，
-     * @param {IRuntime} _runtime - 运行时
-     * @param {string} _roomId - 房间号
-     * @param {RTCMode} _roomMode - RTC模式，
-     * @param {RCMediaService} _service - RCMediaService
-     * @param {IRCRTCInitOptions} _initOptions - IRCRTCInitOptions
-     * @param {boolean} [isUpgrade] - 是否是升级，如果是升级则不会创建新的peerConnection
-     * @param {boolean} [isMainRoom] - 无论是主房间，主房间都是用户创建的房间，子房间是用户创建的房间。
-     * @param {string} _clientSessionId - 客户端会话 ID，用于标识客户端。
+     * 2s 给北极星上报一次 R3、R4
      */
-    constructor(_context: RTCContext, _runtime: IRuntime, _roomId: string, _roomMode: RTCMode, _service: RCMediaService, _initOptions: IRCRTCInitOptions, isUpgrade?: boolean, isMainRoom?: boolean, _clientSessionId?: string, encrypt?: boolean);
+    __reportR3R4ToPolaris(): Promise<void>;
+    getRTCPeerConn(): RTCPeerConnection;
     /**
-     * 注册 RCRTCPeerConnection 事件监听器
+     * 关闭 RTCPeerConnection 连接。其生命周期：
+     * 1. 连接生命周期与房间实例一致（包含观众加房间），仅在退出房间时进行关闭。
+     * 2. 观众客户端（观众不加房间）订阅时创建，取消订阅时销毁
      */
-    private _setPeerConnectionListener;
-    /** 注册命令执行中的事件监听器 */
-    private setCommandEventListener;
+    destroy(): void;
+    clearReTryExchangeTimer(): void;
+    isDestroyed(): boolean;
+}
+
+/**
+ * 命令执行上下文
+ */
+declare class CommandExecuteContext extends EventEmitter {
     /**
-     * 拉取房间数据
-     * @param roomId 房间 id
+     * 日志工具
      */
-    private _startPullRTCRoomStatus;
+    readonly logger: BasicLogger;
     /**
-     * @private
+     * MediaServer 请求实例
      */
-    __innerInit(mode: RTCMode, joinType?: RTCJoinType, livingType?: RCLivingType, innerUserDatas?: IRTCUserData, outerUserDatas?: IRTCUserData, traceId?: string): Promise<{
-        code: RCRTCCode | ErrorCode;
-        data?: IJoinRTCRoomData;
-    }>;
-    protected _initWithRoomData(offlineKickTime: number): void;
-    private _handlePingResult;
+    readonly service: RCMediaService;
     /**
-     * 设置房间上行资源的总码率配置
-     * @deprecated use RCLocalTrack.setBitrate instead of setBitrate
-     * @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%
+     * IM 信令上下文
      */
-    setBitrate(max: number, min: number, start?: number): void;
-    private _onTrackReady;
-    protected _callAppListener(eventType: keyof IRoomEventListener, ...attrs: any[]): void;
-    private _onTrackUnpublish;
+    readonly context: RTCContext;
     /**
-     * @private
+     * 运行时
      */
-    __parseInnerMessage(message: IReceivedMessage, traceId: string): void;
+    readonly runtime: IRuntime;
     /**
-     * 被踢出房间通知
-     * @param byServer
-     * * 当值为 false 时，说明本端 rtcPing 超时
-     * * 当值为 true 时，说明本端收到被踢出房间通知
-     * @private
+     * PeerConenction 连接实例
      */
-    __kickoff(byServer: boolean, content?: IRCRTCKickContent): Promise<void>;
-    private _rtcpeerClosed;
+    readonly peer: RCRTCPeerConnection;
     /**
-     * 处理资源变更事件
-     * @param content
-     * @param messageType 消息类型
-     * @param userId 消息发送者
+     * 内存只读模块
      */
-    protected _resourceHandle(content: ResourceMsgContent, messageType: RCRTCMessageType.PUBLISH | RCRTCMessageType.UNPUBLISH | RCRTCMessageType.MODIFY | RCRTCMessageType.TOTAL_CONTENT_RESOURCE, userId: string, sentTime: number, traceId: string): Promise<void>;
-    private _onTrackPublish;
+    readonly store: ReadableStore;
     /**
-     * 处理 `RCRTCMessageType.STATE` 消息
-     * @param content
+     * 北极星统计工具
      */
-    private _stateHandle;
+    readonly polarisReport: PolarisReporter;
     /**
-     * 处理人员应用层事件
+     * 行为数据采集工具
      */
-    private _dealUserAppListener;
+    readonly reportMediaActionLogger: ReportMediaActionLogger;
+    constructor(
     /**
-     * 获取房间 Id
+     * 日志工具
      */
-    getRoomId(): string;
+    logger: BasicLogger, 
     /**
-     * 获取当前 userId
+     * MediaServer 请求实例
      */
-    getCrtUserId(): string;
+    service: RCMediaService, 
     /**
-     * 获取远程用户列表，不包含当前用户
+     * IM 信令上下文
      */
-    getRemoteUserIds(): string[];
+    context: RTCContext, 
     /**
-     * 获取所有房间已发布的远端资源列表
-     * @returns
+     * 运行时
      */
-    getRemoteTracks(): RCRemoteTrack[];
+    runtime: IRuntime, 
     /**
-     * 获取远端用户的资源列表
-     * @param userId
-     * @returns
+     * PeerConenction 连接实例
      */
-    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
+    peer: RCRTCPeerConnection, 
     /**
-     * 获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新
+     * 内存只读模块
      */
-    getSessionId(): string;
+    store: ReadableStore, 
     /**
-     * 向房间内发消息
-     * @param name 消息名称
-     * @param content 消息内容
+     * 北极星统计工具
      */
-    sendMessage(name: string, content: any): Promise<{
-        code: RCRTCCode;
-    }>;
+    polarisReport: PolarisReporter, 
     /**
-     * 设置房间属性
-     * @param key 属性名
-     * @param value 属性值
-     * @param message 是否在设置属性的时候携带消息内容，传空则不往房间中发送消息
-     * @param isInner RTC 业务内部使用参数，用户忽略
+     * 行为数据采集工具
      */
-    setRoomAttribute(key: string, value: string, message?: {
-        name: string;
-        content: string;
-    }, isInner?: boolean): Promise<{
-        code: RCRTCCode;
-    }>;
+    reportMediaActionLogger: ReportMediaActionLogger);
     /**
-     * 删除房间属性
-     * @param keys 待删除的属性名数组
-     * @param message 是否在删除属性的时候携带消息内容，传空则不往房间中发送消息
-     * @param isInner RTC 业务内部使用参数，用户忽略
+     * 代理房间实例以获取跨房间连麦时的推送配置
      */
-    deleteRoomAttributes(keys: string[], message?: {
-        name: string;
-        content: string;
-    }, isInner?: boolean): Promise<{
-        code: RCRTCCode;
-    }>;
+    getPushOtherRooms: () => IPushOtherRooms[];
+}
+
+declare enum CommandPriority {
+    LOW = 0,
+    NORMAL = 1,
+    HIGH = 2
+}
+declare type ICommandResult<R = void> = {
+    code: number;
+    data?: R;
+};
+/**
+ * 命令基类
+ * @typeParams R - 返回值类型声明
+ * @typeParams T - 命令执行上下文类型
+ * @typeParams S - 内存数据缓存模块
+ */
+declare abstract class BaseCommand<R = void, T = CommandExecuteContext, S = Store> {
+    /**
+     * 事务执行函数
+     * @param context - 事务执行上下文
+     * @param store - 内存读写模块
+     * @param invoker - 任务队列
+     */
+    abstract execute(context: T, store: S, invoker: BaseInvoker<T, S>): Promise<ICommandResult<R>>;
     /**
-     * 获取房间属性
-     * @param keys 要查询的属性名数组，当数组长度为空时，取所有已设置的 kv 值
-     * @param isInner RTC 业务内部使用参数，用户忽略
+     * 获取指令优先级，必要时可 override 此函数
      */
-    getRoomAttributes(keys?: string[], isInner?: boolean): Promise<{
-        code: RCRTCCode;
-        data?: KVString;
-    }>;
+    get priority(): CommandPriority;
     /**
-     * 设置当前用户属性（暂不开放）
-     * @param key 属性名
-     * @param value 属性值
-     * @param message 是否在设置属性的时候携带消息内容，传空则不往房间中发送消息
+     * 它返回命令的种类。
+     * @returns 命令的种类。
      */
-    private _setUserAttributeValue;
+    get kind(): RCCommandKind;
+}
+
+/**
+ * @typeParams T - 事务执行上下文类型
+ * @typeParams S - 内存读写模块类型
+ */
+declare class BaseInvoker<T, S> {
+    protected readonly _logger: BasicLogger;
     /**
-     * 删除当前用户属性（暂不开放）
-     * @param keys 待删除的属性名数组
-     * @param message 是否在删除属性的时候携带消息内容，传空则不往房间中发送消息
+     * 内存数据管理实例
      */
-    private _deleteUserAttributes;
+    protected readonly _context: T;
     /**
-     * 获取当前用户属性（暂不开放）
-     * @param keys 要查询的属性名数组
+     * 内存读写模块
      */
-    private _getUserAttributes;
+    protected readonly _store: S;
     /**
-     * 查询房间是否已销毁
+     * 命令终止时返回的错误码定义
      */
-    isDestroyed(): boolean;
+    private abortCode;
+    constructor(_logger: BasicLogger, 
     /**
-     * 退出并销毁当前房间实例，退出后该房间的所有方法将不可用
-     * @private
+     * 内存数据管理实例
      */
-    __destroy(quitRoom: boolean): Promise<void>;
+    _context: T, 
     /**
-     * 退出房间之前禁用所有远端资源，避免退出动作耗时过长，
-     * 导致在未完全退出的过程中仍能听到房间内的声音问题
+     * 内存读写模块
      */
-    private _muteRemoteTracksBeforeQuit;
-    private _leaveHandle;
+    _store: S, 
     /**
-     * 释放 PCManager 上的资源
+     * 命令终止时返回的错误码定义
      */
-    private _releasePCManager;
-    private _onLocalTrackDestroied;
+    abortCode: RCRTCCode);
+    private _queue;
+    private _busy;
+    private _next;
+    private _execute;
+    push<R>(command: BaseCommand<R, T, S>): Promise<ICommandResult<R>>;
+    private _isDestroyed;
+    isDestroyed(): boolean;
+    destroy(): void;
+}
+/**
+ * 房间任务队列管理
+ */
+declare class Invoker extends BaseInvoker<CommandExecuteContext, Store> {
+    constructor(context: CommandExecuteContext, store: Store);
     /**
-     * 本端流状态修改，需通知房间内其他成员
-     * @param localTrack
+     * 获取 store 存储实例，返回值类型 `ReadableStore`，避免非 command 定义中修改内存
      */
-    private _onLocalTrackMuted;
+    get store(): ReadableStore;
+    destroy(): void;
+}
+
+declare enum RCRTCRealtimeTranslationType {
+    OPEN = 1,
+    CLOSE = 0
+}
+
+declare class RCMediaService {
+    private readonly _runtime;
+    private readonly _context;
     /**
-     * 增量发布资源，若发布的资源 tag 及媒体类型重复，后者将覆盖前者进行发布。
-     * @param tracks 待发布的 RCLocalTrack 实例
-     * @returns
+     * 自定义 MediaServer 地址，当有值时，不再使用导航内的地址
      */
-    publish(tracks: (RCLocalTrack | IPublishAttrs)[]): Promise<IPubSuccessRes>;
+    private readonly _msUrl?;
     /**
-     * 获取跨房间连麦需携带参数 pushOtherRooms 的值
+     * 请求超时时长
      */
-    protected _getPushOtherRoomsParams(): IPushOtherRooms[];
+    private readonly _timeout;
     /**
-     * ice 断线后，尝试重新走 exchange
+     * 已失败的请求地址
      */
-    protected _reTryExchange(): Promise<ICommandResult<void>>;
+    private readonly _failedMs;
     /**
-     * 增量取消资源发布，若相应资源中存在小流资源，则同时取消发布
-     * @param tracks 取消发布的 RCLocalTrack 列表
+     * 服务器指纹数据，客户端不得修改，直接透传
      */
-    unpublish(tracks: RCLocalTrack[]): Promise<IPubSuccessRes>;
+    private _rtcFinger;
     /**
-     * resourceId 有效性验证
-     * @param resourceId
+     * 服务器接口返回的 clusterId 数据，当此数据有值时，后续所有请求向此服务发送
      */
-    protected _isValidResourceId(resourceId: string): boolean;
+    private _clusterId;
     /**
-     * 订阅资源
-     * @param tracks
+     * MCU 服务地址
      */
-    subscribe(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
-        code: RCRTCCode;
-        failedList?: ISubscribeAttr[];
-    }>;
+    private _configUrl;
     /**
-     * 取消订阅资源
-     * @param tracks 预取消远端资源
+     * 排好序的探测地址
      */
-    unsubscribe(tracks: RCRemoteTrack[]): Promise<{
-        code: RCRTCCode;
-        failedList?: ISubscribeAttr[];
-    }>;
+    private static msInDetector;
+    private static detectorTime;
+    private static detectValidMinute;
+    private _msList;
+    private _qualityMsList;
+    private readonly _logger;
+    constructor(_runtime: IRuntime, _context: RTCContext, 
     /**
-     * 强制修改订阅列表，仅订阅数组中的资源，取消订阅其他已订阅资源。
-     * 当参数为 `[]` 时，意味着不再订阅任何资源
-     * @param tracks 变更的资源列表
+     * 自定义 MediaServer 地址，当有值时，不再使用导航内的地址
      */
-    updateSubList(tracks: (RCRemoteTrack | ISubscribeAttr)[]): Promise<{
-        code: RCRTCCode;
-        failedList?: ISubscribeAttr[];
-    }>;
+    _msUrl?: string | undefined, 
     /**
-     * 获取已发布的本地资源
-     * @param trackId
-     * @returns
+     * 请求超时时长
      */
-    getLocalTrack(trackId: string): RCLocalTrack | null;
+    _timeout?: number);
     /**
-     * 获取所有已发布的资源
+     * 是否需要嗅探
+     * im 未连接，无 navi 数据时，不需要嗅探
+     * 客户端手动配置 mediaServer 时，不需要嗅探
+     * navi 数据中 detectionServer 为空时，不需要嗅探
+     * navi 数据中 jwt 为空时，不需要嗅探
+     * 在探测有效期内不需要嗅探
+     * RCMediaService.detectorTime 为 0 时，代表未探测过，需要嗅探
      */
-    getLocalTracks(): RCLocalTrack[];
+    isNededDetector(): boolean;
+    detectorMediaSever(): void;
     /**
-     * 根据 trackId 获取房间内的远端资源
-     * @param trackId
-     * @returns
+     *  地址探测
+     *  RTC 初始化时检测是否可以拿到 navi，可以拿到开始嗅探
+     *  拿不到等 IM 链接成功后，再回调中调用开始嗅探
      */
-    getRemoteTrack(trackId: string): RCRemoteAudioTrack | RCRemoteVideoTrack | null;
+    private _startDetector;
     /**
-     * 获取当前已经订阅的全量资源
-     * returns subscribedTracks ISubscribeAttr[]
+     * 清空 msList 列表，重新请求导航后需清空 msList 列表
      */
-    get subscribedTracks(): ISubscribeAttr[];
-    private _appListener;
+    clearMSList(): void;
+    getMsList(): string[];
     /**
-     * 注册事件监听器，多次注册会导致后者覆盖前者，可以通过使用 `registerRoomEventListener(null)` 取消注册
-     * @param listener
+     * _mslist 列表排序：[_clusterId, ping1DetectorUrl, 主域名, ping2DetectorUrl, ..., pingNDetectorUrl, 备用域名list ]
+     * ping1 ：ping 结果返回最快值
      */
-    registerRoomEventListener(listener: IRoomEventListener | null): void;
+    private _sortMediaServiceList;
     /**
-     * 注册房间数据监控
-     * @param listener
-     * @description 该方法暂仅支持 Chrome 浏览器
+     * 配置 gzip 请求头和请求体
      */
-    registerReportListener(listener: IRCRTCReportListener | null): void;
+    private _openGzip;
     /**
-     * 音量上报
-     * @param handler 音量事件监听函数
-     * @param _ - 参数已废弃，SDK 默认以每秒一次进行回调~~上报时间间隔~~
+     * 处理 request 成功的结果
      */
-    onAudioLevelChange(handler: IAudioLevelChangeHandler | null, _?: number): void;
+    private _dealRequestSuccessResult;
     /**
-     * 断线重连后尝试补发断线过程中的通知信息
+     * 发送请求，请求发送若失败，会继续尝试使用后续可用地址直到无地址可用，此时认为请求失败
+     * @param path
+     * @param header
+     * @param body
      */
+    private _request;
     /**
-     * @private
-     * @param livingType
+     * 资源协商接口，订阅、发布、变更资源均可以使用此接口。该接口通过 sdp 字段交换 SDP 信息，
+     * 并通过 subscribeList 和 publishList 表明最终发布和订阅的资源。本端产出 offer，服务器产出 answer
+     * 每次接口调用，都会全量覆盖发布和订阅的资源。
+     * @param header
+     * @param body
      */
-    __onReconnected(livingType?: RCLivingType): void;
-    private _onAudioMuteChange;
-    private _onVideoMuteChange;
+    exchange(headers: IRTCReqHeader, body: IExchangeReqBody, traceId: string, isNeedUpdateMsas?: boolean): Promise<{
+        code: RCRTCCode;
+        data?: IExchangeResponse | undefined;
+        qualityMsList?: IMediaServerQualityData[] | undefined;
+    }>;
     /**
-     * 存储连麦监听事件
+     * 退出房间
      */
-    private _onRecvPKMsg;
+    exit(headers: IRTCReqHeader): Promise<RCRTCCode>;
     /**
-     * 注册 PK 业务监听方法
+     * 观众端订阅主播资源
      */
-    protected _registerPKMsgListener(listener: IOnRecvPKMsg | null): void;
+    broadcastSubscribe(headers: IRTCReqHeader, body: IBroadcastSubReqBody): Promise<{
+        code: RCRTCCode;
+        data?: IBroadcastSubRespBody | undefined;
+        qualityMsList?: IMediaServerQualityData[] | undefined;
+    }>;
     /**
-     * 退出 PK 房间
+     * 观众端退出订阅
      */
-    protected _quitAllPKRoom(): Promise<void>;
-    getClientSessionId(): string;
+    broadcastExit(headers: IRTCReqHeader): Promise<{
+        code: RCRTCCode;
+    }>;
     /**
-     * 切换已发布视频或音频的媒体设备
-     * @param oldTrack 已经发布的视频轨道或音频轨道
-     * @param newTrack 从新设备获取的视频轨道或音频轨道
-     * @returns code 切换结果，RCRTCCode.SUCCESS 表示切换成功
+     * 直播推流、自定义布局配置
      */
-    changeMediaDevice(oldTrack: RCCameraVideoTrack | RCMicphoneAudioTrack, newTrack: RCCameraVideoTrack | RCMicphoneAudioTrack): Promise<{
+    setMcuConfig(headers: IMCUReqHeaders, body: IMCUConfig | ISetEnableCDN): Promise<{
+        code: RCRTCCode;
+        res?: any;
+    }>;
+    /**
+     * 房间内观众获取 CDN 资源信息、拉流地址
+     */
+    getCDNResourceInfo(headers: ICDNPlayUrlReqHeaders, url: string, traceId: string): Promise<{
+        code: RCRTCCode;
+        res?: ICDNPlayUrlResponse;
+    }>;
+    updateASRStatus(headers: IRTCReqHeader, body: {
+        'asr_status': RCRTCASRStatus;
+    }, traceId: string): Promise<{
         code: RCRTCCode;
+        data?: {
+            resultCode: number;
+        } | undefined;
+        qualityMsList?: IMediaServerQualityData[] | undefined;
+    }>;
+    operateRealtimeTranslation(headers: IRTCReqHeader, body: {
+        status: RCRTCRealtimeTranslationType;
+        destLanguage?: string;
+    }, traceId: string): Promise<{
+        code: RCRTCCode;
+        data?: {
+            resultCode: number;
+        } | undefined;
+        qualityMsList?: IMediaServerQualityData[] | undefined;
     }>;
 }
 
@@ -5052,4 +5272,4 @@ declare const helper: {
     ifSupportScreenShare: typeof ifSupportScreenShare;
 };
 
-export { BackgroundPictureFillMode, IAudienceRoomEventListener, IAudioLevelChangeHandler, ICameraVideoProfile, ICreateLocalTrackOptions, IJoinRTCRoomOptions, IJoinResCDNInfo, ILiveAudioState, IMCUOutputConfig, IMCUOutputVideoConfig, IMicphoneAudioProfile, IPKEndInfo, IPKInviteAnswerInfo, IPKInviteInfo, IPubSuccessRes, IPublishAttrs, IPublishedResource, IRCCandidatePairStat, IRCEncryptorHooks, IRCRTCInitOptions, IRCRTCReportListener, IRCRTCStateReport, IRCTrackStat, IRTCUserData, IReqResPKOptions, IRoomEventListener, IRoomPKEventListener, IScreenVideoProfile, ISubscribeAttr, IVideoProfile, MixLayoutMode, MixVideoRenderMode, RCAbstractRoom, RCAudienceClient, RCAudienceLivingRoom, RCAudioBitrate, RCCameraVideoTrack, RCEncryptFunction, RCFrameRate, RCInnerCDNPullIsHttps, RCInnerCDNPullKind, RCKickReason, RCLivingRoom, RCLivingType, RCLocalAudioTrack, RCLocalFileAudioTrack, RCLocalFileTrack, RCLocalFileVideoTrack, RCLocalTrack, RCLocalVideoTrack, RCMCUConfigBuilder, RCMediaStreamCapture, RCMediaType, RCMicphoneAudioTrack, RCRTCClient, RCRTCCode, RCRTCLiveRole, RCRTCPingResult, RCRTCRoom, RCRemoteAudioTrack, RCRemoteTrack, RCRemoteVideoTrack, RCResolution, RCScreenAudioTrack, RCScreenVideoTrack, RCTag, RCTrack, RCVideoBitrate, RTCJoinType, RTCMode, device, helper, installer };
+export { BackgroundPictureFillMode, IAudienceRoomEventListener, IAudioLevelChangeHandler, ICameraVideoProfile, ICreateLocalTrackOptions, IJoinRTCRoomOptions, IJoinResCDNInfo, ILiveAudioState, IMCUOutputConfig, IMCUOutputVideoConfig, IMicphoneAudioProfile, IPKEndInfo, IPKInviteAnswerInfo, IPKInviteInfo, IPubSuccessRes, IPublishAttrs, IPublishedResource, IRCCandidatePairStat, IRCEncryptorHooks, IRCRTCInitOptions, IRCRTCReportListener, IRCRTCStateReport, IRCTrackStat, IRTCUserData, IReqResPKOptions, IRoomEventListener, IRoomPKEventListener, IScreenVideoProfile, ISubscribeAttr, IVideoProfile, MixLayoutMode, MixVideoRenderMode, RCAbstractRoom, RCAudienceClient, RCAudienceLivingRoom, RCAudioBitrate, RCCameraVideoTrack, RCEncryptFunction, RCFrameRate, RCInnerCDNPullIsHttps, RCInnerCDNPullKind, RCKickReason, RCLivingRoom, RCLivingType, RCLocalAudioTrack, RCLocalFileAudioTrack, RCLocalFileTrack, RCLocalFileVideoTrack, RCLocalTrack, RCLocalVideoTrack, RCMCUConfigBuilder, RCMediaStreamCapture, RCMediaType, RCMicphoneAudioTrack, RCRTCASRContent, RCRTCClient, RCRTCCode, RCRTCLiveRole, RCRTCPingResult, RCRTCRealtimeTranslationContent, RCRTCRoom, RCRemoteAudioTrack, RCRemoteTrack, RCRemoteVideoTrack, RCResolution, RCScreenAudioTrack, RCScreenVideoTrack, RCTag, RCTrack, RCVideoBitrate, RTCJoinType, RTCMode, device, helper, installer };