@rongcloud/plugin-rtc 5.5.5-beem.1 → 5.5.5

package/dist/async-task-queue.d.ts

@@ -0,0 +1,9 @@
+export declare type AsyncTask<T = void> = () => Promise<T>;
+/**
+ * 将异步任务推送到异步队列，队列内任务先进先出，依次执行，执行完成后通过
+ * Promise.resolve 返回执行结果
+ * @param task 传参不能是 `async () => {}` 所定义的异步函数，
+ * 只能使用明确的 `() => Promise<T> | T` 形式，避免转义时微任务被提前执行
+ */
+export declare const push: <T>(task: AsyncTask<T>, name?: string) => Promise<T>;
+//# sourceMappingURL=async-task-queue.d.ts.map

package/dist/core/Invoker.d.ts

@@ -0,0 +1,55 @@
+import { BaseCommand } from './command/BaseCommand';
+import { RCRTCCode } from './enums/RCRTCCode';
+import PolarisReporter from './PolarisReporter';
+import { RCMediaService } from './service';
+import { ReadableStore, Store } from './Store';
+import RCRTCPeerCManager from './webrtc/RCRTCPeerCManager';
+import { RTCContext } from './codec/RTCContext';
+import { RTCMode } from './enums/RTCMode';
+export declare class BaseInvoker<STORE> {
+    /**
+     * 内存数据管理实例
+     */
+    protected readonly _store: STORE;
+    /**
+     * 命令终止时返回的错误码定义
+     */
+    private abortCode;
+    constructor(
+    /**
+     * 内存数据管理实例
+     */
+    _store: STORE, 
+    /**
+     * 命令终止时返回的错误码定义
+     */
+    abortCode: RCRTCCode);
+    private _queue;
+    private _busy;
+    private _next;
+    private _execute;
+    push<R>(command: BaseCommand<R, STORE>): Promise<R>;
+    private _isDestroyed;
+    /**
+     * 查找出 RCCommandKind.AsyncCommand 类型的 Command，并将其从队列中删除
+     * 并使用最新的一次 Command 接管它的 resolve & reject
+     * @param resolve
+     * @param reject
+     * @returns 具有两个属性的对象，resolve 和 reject。
+     */
+    private commandOffset;
+    isDestroyed(): boolean;
+    destroy(): void;
+}
+/**
+ * 房间任务队列管理
+ */
+export declare class Invoker extends BaseInvoker<Store> {
+    constructor(context: RTCContext, service: RCMediaService, peerMrg: RCRTCPeerCManager, roomId: string, crtUserId: string, mode: RTCMode, reporter: PolarisReporter, isUpgrade?: boolean, isMainRoom?: boolean);
+    /**
+     * 获取 store 存储实例，返回值类型 `ReadableStore`，避免非 command 定义中修改内存
+     */
+    get store(): ReadableStore;
+    destroy(): void;
+}
+//# sourceMappingURL=Invoker.d.ts.map

package/dist/core/PolarisReporter.d.ts

@@ -0,0 +1,36 @@
+import { IRuntime } from '@rongcloud/engine';
+import { IInnerRCRTCStateReport } from './interfaces';
+import RCAbstractRoom from './room/RCAbstractRoom';
+import RCAudienceLivingRoom from './room/RCAudienceLivingRoom';
+import { PolarisRole } from './enums/inner/PolarisRole';
+import { RTCContext } from './codec/RTCContext';
+export default 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;
+    /**
+     * 小流需去掉 _tiny，小流 resourceId 为 userId_tag_mediaType_tiny
+     */
+    private _getRealResourceId;
+    /**
+     * 生成北极星上报的 trackId
+     * @param resourceId userId_11_1_tiny 改为 userId_11_tiny_video
+     */
+    private _getPolarisTrackId;
+    sendR3R4Data(data: IInnerRCRTCStateReport): Promise<boolean>;
+    /**
+     * 加入房间
+     */
+    sendR1(): void;
+    /**
+     * RTC 和 LIVE 发布、取消发布
+     * RTC 订阅、取消订阅
+     */
+    sendR2(action: string, status: string, trackIds: string[]): void;
+}
+//# sourceMappingURL=PolarisReporter.d.ts.map

package/dist/core/RCAudienceClient.d.ts

@@ -0,0 +1,90 @@
+import { IRuntime } from '@rongcloud/engine';
+import { IRCRTCReportListener, IRCRTCTrackEventListener, IRCRTCInitOptions } from './interfaces';
+import { RCRemoteTrack } from './tracks/RCRemoteTrack';
+import { RCLivingType } from './enums/RCLivingType';
+import { RCRTCCode } from './enums/RCRTCCode';
+import { RCMediaType } from './enums/RCMediaType';
+import { RTCContext } from './codec/RTCContext';
+/**
+ * 直播观众客户端
+ */
+export default class RCAudienceClient {
+    private readonly _context;
+    /**
+     * 是否使用多 peerConnection
+     */
+    private readonly _useMutilPeerC?;
+    private _pc;
+    private _service;
+    /**
+     * RTCToken
+     */
+    private _rtcToken;
+    /**
+     * 已订阅的资源信息
+     */
+    private _liveUrl;
+    /**
+     * 已订阅的远端流
+     */
+    private readonly _subTracks;
+    /**
+     * 客户端传入的数据上报事件
+     */
+    private _reportListener;
+    /**
+     * 使用的 peerConnection 对应 id
+     */
+    private _pcName;
+    /**
+     * peerConnection 管理类
+     */
+    private _peerCManager;
+    private readonly _clientSessionId;
+    constructor(_context: RTCContext, runtime: IRuntime, _initOption: IRCRTCInitOptions, 
+    /**
+     * 是否使用多 peerConnection
+     */
+    _useMutilPeerC?: boolean | undefined);
+    private _getReqHeaders;
+    private _clearSubscribeInfo;
+    private _livingType;
+    private _mediaType;
+    private _subTiny;
+    private _fromRetry;
+    private _reTryExchange;
+    /**
+     * 直播观众订阅主播资源，直播观众端无需加入房间
+     * @param liveUrl 直播资源地址
+     * @param livingType 直播类型，有效值为音频、音视频
+     * @param mediaType 订阅资源类型，其有效值为 `RCMediaType` 的枚举值
+     * @param subTiny 当值为 `true` 时将订阅小流，否则订阅大流。默认值为 `false`
+     */
+    subscribe(liveUrl: string, livingType: RCLivingType, mediaType: RCMediaType, subTiny?: boolean): Promise<{
+        code: RCRTCCode;
+        tracks: RCRemoteTrack[];
+    }>;
+    private __subscribe;
+    /**
+     * 取消订阅主播资源
+     * @param liveUrl
+     */
+    unsubscribe(): Promise<{
+        code: RCRTCCode;
+    }>;
+    private __unsubscribe;
+    /**
+     * 注册房间数据监控
+     * @param listener
+     * @description 该方法暂仅支持 Chrome 浏览器
+     */
+    registerReportListener(listener: IRCRTCReportListener | null): void;
+    private _appListener;
+    /**
+     * 注册流事件监听，多次注册会导致后者覆盖前者，可以通过使用 `registerTrackEventListener(null)` 取消注册
+     * @param listener
+     */
+    registerTrackEventListener(listener: IRCRTCTrackEventListener | null): void;
+    private _onTrackReady;
+}
+//# sourceMappingURL=RCAudienceClient.d.ts.map

package/dist/core/RCMediaStreamCapture.d.ts

@@ -0,0 +1,124 @@
+import { RCRTCCode } from './enums/RCRTCCode';
+import { ICameraVideoProfile, ICreateLocalTrackOptions, IMicphoneAudioProfile, IScreenVideoProfile } from './interfaces';
+import { RCCameraVideoTrack, RCLocalAudioTrack, RCLocalFileTrack, RCLocalTrack, RCLocalVideoTrack, RCMicphoneAudioTrack, RCScreenAudioTrack, RCScreenVideoTrack } from './tracks/RCLocalTrack';
+import { RTCContext } from './codec/RTCContext';
+export default class RCMediaStreamCapture {
+    protected readonly _context: RTCContext;
+    constructor(_context: RTCContext);
+    private _isElectron;
+    private _getMediaStream;
+    /**
+     * 如果用户设置了音频约束为true，那么我们将音频约束设置为一个空对象，
+     * 然后我们将检查浏览器是否支持noiseSuppression、autoGainControl和echoCancellation约束，
+     * 如果支持，那么我们将设置音频约束为真
+     * @param {any} constraints - 约束参数与 getUserMedia 方法中的约束参数相同。
+     * @returns 返回值是约束对象。
+     */
+    private setConstraintsConfig;
+    /**
+     * 从麦克风中捕获音轨数据
+     * @param tag
+     * @param options
+     * @returns
+     */
+    createMicrophoneAudioTrack(tag?: string, options?: IMicphoneAudioProfile): Promise<{
+        code: RCRTCCode;
+        track?: RCMicphoneAudioTrack;
+    }>;
+    /**
+     * 由摄像头捕获视轨数据
+     * @param tag
+     * @param options
+     * @returns
+     */
+    createCameraVideoTrack(tag?: string, options?: ICameraVideoProfile): Promise<{
+        code: RCRTCCode;
+        track?: RCCameraVideoTrack;
+    }>;
+    /**
+     * 通过摄像头与麦克风采集音视频轨道数据
+     * @param tag
+     * @param options
+     * @returns
+     */
+    createMicrophoneAndCameraTracks(tag?: string, options?: {
+        audio?: IMicphoneAudioProfile;
+        video?: ICameraVideoProfile;
+    }): Promise<{
+        code: RCRTCCode;
+        tracks: RCLocalTrack[];
+    }>;
+    /**
+     * 创建屏幕共享视频流，默认分辨率 `1280 * 720`，帧率 `15`
+     * @param tag 屏幕共享视轨数据标识
+     * @param options
+     * @description
+     * 支持 Electron 平台下通过制定 `chromeMediaSourceId` 的方式获取屏幕共享视频。
+     * 参考：https://www.electronjs.org/docs/api/desktop-capturer
+     */
+    createScreenVideoTrack(tag?: string, options?: IScreenVideoProfile): Promise<{
+        code: RCRTCCode;
+        track?: RCScreenVideoTrack;
+    }>;
+    /**
+     * 创建带音频的屏幕共享资源
+     * @param tag 屏幕共享视轨数据标识
+     * @param options
+     * @description electron 中 mac 系统暂不支持屏幕共享采集声音
+     * @returns 在可以取到音频的情况下，tracks 中包含音轨和视轨；取不到音视频时 tracks 仅返回视轨
+     */
+    createScreenWithAudioTracks(tag?: string, options?: IScreenVideoProfile): Promise<{
+        code: RCRTCCode;
+        tracks?: (RCScreenVideoTrack | RCScreenAudioTrack)[];
+    }>;
+    private _createScreenTracks;
+    /**
+     * 创建 RCLocalAudioTrack 实例
+     * @param tag
+     * @param track
+     * @returns
+     */
+    createLocalAudioTrack(tag: string, track: MediaStreamTrack): Promise<{
+        code: RCRTCCode;
+        track?: RCLocalAudioTrack;
+    }>;
+    /**
+     * 创建 RCLocalVideoTrack 实例
+     * @param tag 视轨数据标识
+     * @param track MediaStreamTrack 实例
+     * @returns
+     */
+    createLocalVideoTrack(tag: string, track: MediaStreamTrack): Promise<{
+        code: RCRTCCode;
+        track?: RCLocalVideoTrack;
+    }>;
+    /**
+     * 根据本地或网络媒体文件资源创建 `RCLocalFileTrack` 实例
+     * @param tag 资源标识
+     * @param file 网络文件地址，或通过 <input type='file'> 获取到的 File 实例
+     * @param options 可用于指定 `withoutVideo` 与 `withoutAudio` 以剔除视轨与音轨
+     */
+    createLocalFileTracks(tag: string, file: string | File, options?: ICreateLocalTrackOptions): Promise<{
+        code: RCRTCCode;
+        tracks: RCLocalFileTrack[];
+    }>;
+    /**
+     * 根据 MediaStream 实例对象创建 RCLocalTrack 实例
+     * @param tag 轨道标识
+     * @param stream MediaStream 实例
+     * @param options 可用于指定 `withoutVideo` 与 `withoutAudio` 以剔除视轨与音轨
+     * @returns
+     */
+    createLocalTracks(tag: string, stream: MediaStream, options?: ICreateLocalTrackOptions): Promise<{
+        code: RCRTCCode;
+        tracks: RCLocalTrack[];
+    }>;
+    /**
+     * 它接受一个 MediaStream 和一个可选的选项对象并返回一个 MediaStreamTracks 数组
+     * @param {MediaStream} stream - MediaStream - 从中获取曲目的流。
+     * @param {ICreateLocalTrackOptions} [options] - ICreateLocalTrackOptions
+     * @returns 一组 MediaStreamTrack 对象。
+     */
+    static getTracksWithOptions(stream: MediaStream, options?: ICreateLocalTrackOptions): Array<MediaStreamTrack | undefined>;
+}
+//# sourceMappingURL=RCMediaStreamCapture.d.ts.map

package/dist/core/RCRTCClient.d.ts

@@ -0,0 +1,148 @@
+import { ErrorCode, IRuntime } from '@rongcloud/engine';
+import RCLivingRoom from './room/RCLivingRoom';
+import RCRTCRoom from './room/RCRTCRoom';
+import RCAudienceClient from './RCAudienceClient';
+import { IJoinResCDNInfo, IRCRTCInitOptions } from './interfaces';
+import RCAbstractRoom from './room/RCAbstractRoom';
+import { RCRTCCode } from './enums/RCRTCCode';
+import { RCLivingType } from './enums/RCLivingType';
+import { RCRemoteTrack } from './tracks/RCRemoteTrack';
+import RCAudienceLivingRoom from './room/RCAudienceLivingRoom';
+import RCMediaStreamCapture from './RCMediaStreamCapture';
+import { RTCContext } from './codec/RTCContext';
+import { RTCMode } from './enums/RTCMode';
+import { RTCJoinType } from './enums/RTCJoinType';
+import { IRTCUserData, IRTCJoinedInfo } from './codec/interface';
+/**
+ * RTC 业务客户端
+ * @public
+ */
+export default class RCRTCClient extends RCMediaStreamCapture {
+    protected readonly _context: RTCContext;
+    private readonly _runtime;
+    private readonly _options;
+    private readonly _service;
+    constructor(_context: RTCContext, _runtime: IRuntime, _options: IRCRTCInitOptions);
+    private _handleMessage;
+    /**
+     * voip 变更、jwt 变更需要触发重走嗅探逻辑
+     */
+    private naviDataChange;
+    /**
+     * 获取加入的连麦房间
+     */
+    private _getJoinedPKRoomList;
+    /**
+     * 获取当前用户 Id，若 IM 未连接，这返回 `''`
+     * @returns
+     */
+    getCurrentId(): string;
+    private _crtRoom;
+    /**
+     * 加入普通音视频房间
+     * @param roomId
+     * @param joinType 多端处理方式
+     * @param outerUserDatas 业务层设置人员属性
+     * @param useMutilPeerC 是否使用多 peerConnection 发布资源
+     * @param roomType 加入房间的类型 默认参数 RTCMode.RTC
+     */
+    joinRTCRoom(roomId: string, joinType?: RTCJoinType, outerUserDatas?: IRTCUserData, useMutilPeerC?: boolean, roomType?: RTCMode): Promise<{
+        room?: RCRTCRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        tracks?: RCRemoteTrack[];
+    }>;
+    /**
+     * 加入跨AppKey音视频房间
+     * @param roomId
+     * @param joinType 多端处理方式
+     * @param outerUserDatas 业务层设置人员属性
+     * @param useMutilPeerC 是否使用多 peerConnection 发布资源
+     * @param roomType 加入房间的类型 默认参数 RTCMode.CROSS_MUTI
+     */
+    joinCrossRTCRoom(roomId: string, joinType?: RTCJoinType, outerUserDatas?: IRTCUserData, useMutilPeerC?: boolean, roomType?: RTCMode): Promise<{
+        room?: RCRTCRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        tracks?: RCRemoteTrack[];
+    }>;
+    /**
+     * 主播加入直播房间或观众上麦场景调用，观众上麦之前需先取消已订阅的直播间资源
+     * @param roomId 房间 Id
+     * @param livingType 直播间类型，`RCLivingType.AUDIO` 为音频直播，`RCLivingType.VIDEO` 为音视频直播
+     * @param joinType 多端处理方式，公有云暂不支持该字段
+     * @param outerUserDatas 业务层设置人员属性
+     */
+    joinLivingRoom(roomId: string, livingType: RCLivingType, joinType?: RTCJoinType, outerUserDatas?: IRTCUserData, useMutilPeerC?: boolean): Promise<{
+        room?: RCLivingRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        tracks?: RCRemoteTrack[];
+        CDNEnable?: boolean;
+    }>;
+    private _audience;
+    /**
+     * 获取直播观众客户端
+     */
+    getAudienceClient(useMutilPeerC?: boolean): RCAudienceClient;
+    private _onIMStatusChange;
+    private _onIMDisconnect;
+    private _onIMUninit;
+    /**
+     * 退出并销毁当前房间实例，退出后该房间的所有方法将不可用
+     */
+    leaveRoom(room: RCAbstractRoom): Promise<{
+        code: RCRTCCode;
+    }>;
+    private _crtAudienceLivingRoom;
+    /**
+     * 观众加入直播房间
+     * @param roomId 房间 ID
+     * @param livingType 直播类型（音频直播 or 音视频直播）
+     */
+    joinLivingRoomAsAudience(roomId: string, livingType: RCLivingType, useMutilPeerC?: boolean): Promise<{
+        room?: RCAudienceLivingRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        RTCTracks?: RCRemoteTrack[];
+        MCUTracks?: RCRemoteTrack[];
+        CDNUris?: IJoinResCDNInfo;
+    }>;
+    /**
+     * 观众退出并销毁当前房间实例，退出后该房间的所有方法将不可用
+     */
+    leaveLivingRoomAsAudience(room: RCAudienceLivingRoom): Promise<{
+        code: RCRTCCode;
+    }>;
+    /**
+     * 升级为主播房间
+     * @param room 观众房间实例
+     */
+    upgradeToAnchorRoom(room: RCAudienceLivingRoom): Promise<{
+        room?: RCLivingRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        tracks?: RCRemoteTrack[];
+    }>;
+    /**
+     * 降级为观众房间
+     * @param room 主播房间实例
+     */
+    downgradeToAudienceRoom(room: RCLivingRoom): Promise<{
+        room?: RCAudienceLivingRoom;
+        code: RCRTCCode;
+        userIds?: string[];
+        RTCTracks?: RCRemoteTrack[];
+        MCUTracks?: RCRemoteTrack[];
+        CDNUris?: IJoinResCDNInfo;
+    }>;
+    /**
+     * 获取在房间内用户信息
+     * @since version 5.2.1
+     */
+    getJoinedRoomInfo(): Promise<{
+        code: RCRTCCode | ErrorCode;
+        data?: IRTCJoinedInfo[];
+    }>;
+}
+//# sourceMappingURL=RCRTCClient.d.ts.map

package/dist/core/Store.d.ts

@@ -0,0 +1,86 @@
+import { IPublishedResource, ISubscribeAttr, RoomData } from './interfaces';
+import PolarisReporter from './PolarisReporter';
+import { RCMediaService } from './service';
+import { ICDNUris } from './service/interface';
+import { RCLocalTrack } from './tracks/RCLocalTrack';
+import { RCRemoteAudioTrack, RCRemoteTrack, RCRemoteVideoTrack } from './tracks/RCRemoteTrack';
+import RCRTCPeerCManager from './webrtc/RCRTCPeerCManager';
+import { RTCContext } from './codec/RTCContext';
+import { RTCMode } from './enums/RTCMode';
+import { IJoinRTCRoomData } from './codec/interface';
+export declare const StoreEvent: {};
+export declare abstract class ReadableStore {
+    readonly context: RTCContext;
+    readonly service: RCMediaService;
+    readonly peerMgr: RCRTCPeerCManager;
+    readonly roomId: string;
+    readonly crtUserId: string;
+    readonly roomMode: RTCMode;
+    readonly polarisReport: PolarisReporter;
+    readonly isUpgrade?: boolean | undefined;
+    readonly isMainRoom?: boolean | undefined;
+    /**
+     * 房间资源数据
+     */
+    protected _roomResources: RoomData;
+    /**
+     * 远端 track
+     */
+    protected _remoteTracks: {
+        [trackId: string]: RCRemoteAudioTrack | RCRemoteVideoTrack;
+    };
+    /**
+     * 已订阅参数
+     */
+    protected _subscribedList: ISubscribeAttr[];
+    protected _collectSubscribeList: ISubscribeAttr[];
+    /**
+     * 与 MediaServer 交互需要的 token 信息
+     */
+    protected _token: string;
+    /**
+     * 每次加入房间后都会改变
+     */
+    protected _sessionId: string;
+    /**
+     * cdn_uris 信令扩散数据
+     */
+    protected _CDNUris: ICDNUris | null;
+    protected _CDNEnable: boolean;
+    protected _destroyed: boolean;
+    constructor(context: RTCContext, service: RCMediaService, peerMgr: RCRTCPeerCManager, roomId: string, crtUserId: string, roomMode: RTCMode, polarisReport: PolarisReporter, isUpgrade?: boolean | undefined, isMainRoom?: boolean | undefined);
+    get useMutilPeerC(): boolean;
+    getResourcesByUserId(userId: string): IPublishedResource[] | undefined;
+    getRemoteTrack(trackId: string): RCRemoteTrack | undefined;
+    getRemoteTracksByUserId(userId: string): RCRemoteTrack[];
+    getRemoteTracks(): {
+        [trackId: string]: RCRemoteAudioTrack | RCRemoteVideoTrack;
+    };
+    getSessionId(): string;
+    getAllUserIds(): string[];
+    getRemoteUserIds(): string[];
+    getSubscribedList(): ISubscribeAttr[];
+    getCollectSubscribeList(): ISubscribeAttr[];
+    getPublishedResourceByTrackId(trackId: string): IPublishedResource | undefined;
+    getToken(): string;
+    getLocalTrack(trackId: string): RCLocalTrack | null;
+    getLocalTracks(): RCLocalTrack[];
+    getTrackState(trackId: string): 0 | 1;
+    getCDNEnable(): boolean;
+    getCDNUris(): ICDNUris | null;
+}
+export declare class Store extends ReadableStore {
+    private _initRemoteTracks;
+    initWithRoomData(data: IJoinRTCRoomData): void;
+    assignRoomData(data: RoomData): void;
+    setResourcesByUserId(userId: string, arr: IPublishedResource[]): void;
+    removeRemoteTrack(trackId: string): void;
+    removeResourcesByUserId(userId: string): void;
+    addRemoteTrack(track: RCRemoteTrack): void;
+    removeRemoteTracks(): void;
+    setCDNEnabel(bool: boolean): void;
+    setCDNUris(uris: ICDNUris | null): void;
+    resetSubscribedList(subscribeList: ISubscribeAttr[]): void;
+    resetCollectSubscribeList(collectSubscribeList: ISubscribeAttr[]): void;
+}
+//# sourceMappingURL=Store.d.ts.map

package/dist/core/codec/RTCContext.d.ts

@@ -0,0 +1,76 @@
+import { AbsCodec, ErrorCode, IAsyncRes, IPromiseResult, KVString, RTCPluginContext, ConversationType, ISendMsgOptions, IReceivedMessage, ConnectionStatus } from '@rongcloud/engine';
+import { RTCMode } from '../enums/RTCMode';
+import { RTCJoinType } from '../enums/RTCJoinType';
+import { RTCApiType } from '../enums/inner/RTCApiType';
+import { RTCIdentityChangeType } from '../enums/inner/RTCIdentityChangeType';
+import { IChrmKVPullData } from '../interfaces';
+import { RTCKeyMaps } from './proto';
+import { IRTCUserData, IJoinRTCRoomData, IRTCRoomInfo, IRTCUsers, IRtcTokenData, IServerRTCRoomEntry, IReqRoomPKOptions, ICancelRoomPKOptions, IResRoomPKOptions, IEndRoomPKOptions, IRTCJoinedInfo } from './interface';
+export declare class RTCContext {
+    private context;
+    private codec;
+    constructor(context: RTCPluginContext, codec: AbsCodec<RTCKeyMaps>);
+    joinRTCRoom(roomId: string, mode: RTCMode, broadcastType?: number, joinType?: RTCJoinType, innerUserDatas?: IRTCUserData, outerUserDatas?: IRTCUserData): 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, message: {
+        name: string;
+        content: string;
+    }, valueInfo: string, objectName: string, mcuValInfo?: 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>;
+    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>>;
+    decodeRtcNotify(buffer: Uint8Array): {
+        time: any;
+        type: any;
+        roomId: any;
+    };
+    getCurrentId(): string;
+    getNaviInfo(): import("@rongcloud/engine").INaviInfo | null;
+    getConnectionStatus(): ConnectionStatus;
+    getAppkey(): string;
+    rtcPing(roomId: string, roomMode: number, broadcastType?: number): Promise<ErrorCode>;
+    sendMessage(conversationType: ConversationType, targetId: string, options: ISendMsgOptions): IPromiseResult<IReceivedMessage>;
+    registerRTCSignalListener(listener?: ((buffer: Uint8Array) => void) | undefined): void;
+    registerConnectionStateChangeListener(listener: (status: ConnectionStatus) => void): void;
+    registerDisconnectListener(listener: () => void): void;
+    registerDestroyListener(listener: () => void): void;
+    registerMessageListener(listener: (message: IReceivedMessage) => boolean): void;
+    getCoreVersion(): string;
+    getPluginContext(): RTCPluginContext;
+}
+//# sourceMappingURL=RTCContext.d.ts.map