@rongcloud/plugin-wechat-rtc/dist/index.d.ts

@rongcloud/plugin-wechat-rtc

/*
 * RCRTC - v5.4.0
 * CommitId - 103afdd6e3b3ddcb859f48414541cb0a54c45266
 * Tue Jul 29 2025 14:45:21 GMT+0800 (China Standard Time)
 * ©2020 RongCloud, Inc. All rights reserved.
 */
import * as _rongcloud_engine from '@rongcloud/engine';
import { EventEmitter, ILogger, RTCMode as RTCMode$1, IRuntime, INaviInfo, BasicLogger, RTCPluginContext, Codec, IPromiseResult, ErrorCode, KVString, IAsyncRes, RCConnectionStatus, ConversationType, ISendMsgOptions, IReceivedMessage, RTCJoinType as RTCJoinType$1, LogLevel, EnableLogL, IPluginGenerator } from '@rongcloud/engine';

/**
 * 错误码，与移动端对齐
 * @description
 * 1. `51000 - 51999` 为 Android 专用段
 * 2. `52000 - 52999` 为 iOS 专用段
 * 3. `53000 - 53199` 为 Web RTC 专用段
 * 4. `53200 - 53499` 为 Web Call 专用段
 * 5. `53500 - 53999` 为 Web 保留段
 */
declare enum RCRTCCode {
    /** 成功 */
    SUCCESS = 10000,
    /** IM 服务未连接 */
    SIGNAL_DISCONNECTED = 50000,
    /** 参数错误 */
    PARAMS_ERROR = 50001,
    /** 加入房间错误，重复加入 RTC 房间内 */
    REPERT_JOIN_ROOM = 50002,
    /** 当前不在房间内 */
    NOT_IN_ROOM = 50003,
    /** MediaServer 未开启 */
    SERVICE_INVALID = 50004,
    /** RTC Token 无效 */
    RTC_TOKEN_INVALID = 50006,
    /** 底层信令调用错误 */
    SIGNAL_ERROR = 53001,
    /** 创建 Offer 失败 */
    CREATE_OFFER_FAILED = 53003,
    /** 网络请求失败 */
    REQUEST_FAILED = 53004,
    /** MCU 地址不可为空 */
    MCU_SERVER_NOT_FOUND = 53005,
    /** 直播订阅失败，当前存在已订阅资源 */
    BROADCAST_SUB_LIST_NOT_EMPTY = 53007,
    /** 房间已被销毁，需重新加入房间获取 Room 实例 */
    ROOM_HAS_BEEN_DESTROYED = 53008,
    /** 没有可用的音视频服务器地址 */
    NOT_OPEN_VIDEO_AUDIO_SERVER = 53009,
    /** 获取用户媒体资源流失败 */
    GET_USER_MEDIA_FAILED = 53010,
    /** 获取屏幕共享流失败 */
    GET_DISPLAY_MEDIA_FAILED = 53011,
    /** 权限问题导致获取媒体流被拒绝 */
    PERMISSION_DENIED = 53012,
    /** 创建自定义流失败 */
    CREATE_CUSTOM_TRACK_FAILED = 53013,
    /** 无效的 TAG 定义 */
    INVALID_TAGS = 53014,
    /** IM 连接无效，无法识别当前登录的用户身份 */
    INVALID_USER_ID = 53015,
    /** 创建文件流失败 */
    CREATE_FILE_TRACK_FAILED = 53016,
    /** 无效的 File 实例 */
    INVALID_FILE_INSTANCE = 53017,
    /** setRemoteDescription failed */
    SET_REMOTE_DESCRIPTION_FAILED = 53018,
    /** 浏览器不支持此方法 */
    BROWSER_NOT_SUPPORT = 53019,
    /** 媒体流无法播放，可能是远端流未订阅或本地流已销毁 */
    TRACK_NOT_READY = 53020,
    /** 视频流播放需时需传参 HTMLVideoElement 作为显示组件 */
    VIDEO_TRACK_MISS_MEDIA_ELEMENT = 53021,
    /** 媒体流播放失败 */
    TRACK_PLAY_ERROR = 53022,
    /** 观众加入直播房间信令错误 */
    SIGNAL_AUDIENCE_JOIN_ROOM_FAILED = 53023,
    /** 直播房间切换身份错误 */
    SIGNAL_ROOM_CHANGE_IDENTITY_FAILED = 53024,
    /** 公有云 SDK 包不允许使用私有云环境 */
    PACKAGE_ENVIRONMENT_ERROR = 53025,
    /** 单个用户发布资源超过限制 （ MediaServer 限制最多 10 个 track ） */
    PUBLISH_TRACK_LIMIT_EXCEEDED = 53026,
    /** 房间内无主播推 CDN */
    CDN_RESOURCE_IS_EMPTY = 53027,
    /** 无效的媒体类型 */
    INVALID_MEDIATYPE = 53028,
    /** 加入 RTC 房间 joinTYype 为 1 时，当前有其他端在房间时的应答码 */
    SIGNAL_JOIN_RTC_ROOM_REFUSED = 53029
}

/**
 * 媒体资源类型
 */
declare enum RCMediaType {
    /**
     * 音频流
     */
    AUDIO_ONLY = 0,
    /**
     * 视频流
     */
    VIDEO_ONLY = 1,
    /**
     * 音视频混合流，只在 web 端存在混合流的情况
     */
    AUDIO_VIDEO = 2
}

declare enum RCCommandKind {
    UNKNOWN = "UNKNOWN",
    ChangeEnableCommand = "ChangeEnableCommand",
    JoinRTCRoomCommand = "JoinRTCRoomCommand",
    RemoteUserCommand = "RemoteUserCommand",
    UnsubCommand = "UnsubCommand",
    PubCommand = "PubCommand",
    ReconnectCommand = "ReconnectCommand",
    UnpubCommand = "UnpubCommand",
    SubscribeCommand = "SubscribeCommand",
    RemoteResourceCommand = "RemoteResourceCommand",
    PullRTCRoomStatusCommand = "PullRTCRoomStatusCommand"
}

/**
 * 发布端推流、订阅端拉流的画面方向
 */
declare enum ORIENTATION {
    /**
     * 竖直
     */
    VERTICAL = "vertical",
    /**
     * 水平
     */
    HORIZONTAL = "horizontal"
}
/**
 * 发布端推流画面的宽高比
 */
declare enum ASPECT {
    /**
     * 3/4
     */
    THREEDIVIDEFOUR = 0.75,
    /**
     * 9/16
     */
    NINEDIVIDESIXTEEN = 0.5625
}
/**
 * 发布端推流时本地预览画面是否镜像
 */
declare enum LOCALMIRROR {
    /**
     * 前置摄像头镜像，后置摄像头不镜像
     */
    AUTO = "auto",
    /**
     * 前后置摄像头均镜像
     */
    ENABLE = "enable",
    /**
     * 前后置摄像头均不镜像
     */
    DISABLE = "disable"
}
/**
 * 发布端推流音频混响类型
 */
declare enum AUDIOREVERBTYPE {
    /**
     * 关闭
     */
    CLOSE = 0,
    /**
     * KTV
     */
    KTV = 1,
    /**
     * 小房间
     */
    LITTLEROOM = 2,
    /**
     * 大会堂
     */
    GREATHALL = 3,
    /**
     * 低沉
     */
    LOW = 4,
    /**
     * 洪亮
     */
    LOUD = 5,
    /**
     * 金属声
     */
    METALLIC = 6,
    /**
     * 磁性
     */
    MAGNETIC = 7
}
/**
 * 发布端推流美颜类型
 */
declare enum BEAUTYSTYLE {
    /**
     * 光滑
     */
    SMOOTH = "smooth",
    /**
     * 自然
     */
    NATURE = "nature"
}
/**
 * 发布端推流色彩滤镜
 */
declare enum FILTER {
    /**
     * 标准
     */
    STANDARD = "standard",
    /**
     * 粉嫩
     */
    PINK = "pink",
    /**
     * 怀旧
     */
    NOSTALGIA = "nostalgia",
    /**
     * 蓝调
     */
    BLUES = "blues",
    /**
     * 浪漫
     */
    ROMANTIC = "romantic",
    /**
     * 清凉
     */
    COOL = "cool",
    /**
     * 清新
     */
    FRESHER = "fresher",
    /**
     * 日系
     */
    SOLOR = "solor",
    /**
     * 唯美
     */
    AESTHETICISM = "aestheticism",
    /**
     * 美白
     */
    WHITENING = "whitening",
    /**
     * 樱红
     */
    CERISERED = "cerisered"
}
/**
 * 发布端推流画面填充模式
 */
declare enum OBJECTFIT {
    /**
     * 填充
     */
    CONTAIN = "contain",
    /**
     * 裁剪
     */
    FILLCROP = "fillCrop"
}
/**
 * 订阅端是否发送完整的 referrer
 */
declare enum REFERRERPOLICY {
    /**
     * 发送完成的 referrer
     */
    ORIGIN = "origin",
    /**
     * 不发送
     */
    NOREFERRER = "no-referrer"
}
/**
 * 订阅资源，播放远端声音的输出方式
 */
declare enum RCAudioOutputDevice {
    /**
     * 扬声器
     */
    SPEAKER = "speaker",
    /**
     * 听筒
     */
    EAR = "ear"
}
/**
 * 发布端推流的音量类型
 */
declare enum RCAudioVolumeType {
    /**
     * 自动
     */
    AUTO = "auto",
    /**
     * 媒体音量
     */
    MEDIA = "media",
    /**
     * 通话音量
     */
    VOICECALL = "voicecall"
}
/**
 * 摄像头前置或后置
 */
declare enum RCDevicePosition {
    /**
     * 前置
     */
    FRONT = "front",
    /**
     * 后置
     */
    BACK = "back"
}

declare enum RCKickReason {
    /**
     * Server 主动踢（掉 Server API 踢出）
     */
    SERVER_KICK = 1,
    /**
     * 其他设备登陆后，本端被踢
     */
    OTHER_KICK = 2
}

declare enum RCResourceState {
    /**
     * 资源可用
     */
    enable = 1,
    /**
     * 资源不可用
     */
    disable = 0
}

interface IRemoteStreamEventListener {
    /**
     * stream 有音频的情况下，增加视频发布
     */
    onVideoPublish(): void;
    /**
     * stream 有视频的情况下，增加音频发布
     */
    onAudioPublish(): void;
    /**
     * 仅视频取消发布，音频未取消发布
     */
    onVideoUnpublish(): void;
    /**
     * 仅音频取消发布，视频未取消发布
     */
    onAudioUnpublish(): void;
}
declare class RCRemoteStream extends EventEmitter {
    private readonly _logger;
    private readonly _userId;
    private readonly _tag;
    private _mediaType;
    private _ownerDisableVideo;
    private _ownerMuteAudio;
    private _isSubscribed;
    private _listener;
    private _rtmpUrl?;
    constructor(_logger: ILogger, _userId: string, _tag: string, _mediaType: RCMediaType);
    /**
     * @deprecated（v5.2.0）该方法已废弃，请通过监听房间 `onAudioMuteChange` 与 `onVideoMuteChange` 事件替代
     */
    registerStreamEventListener(listener: IRemoteStreamEventListener): void;
    /**
     * 调整 stream 的 mediaType 值
     * @param mediaType 媒体类型
     * @private
     */
    __innerSetMediaType(mediaType: RCMediaType): void;
    private _callListener;
    /**
     * 给 stream 赋值 rtmpUrl，设置拉流地址
     * @param rtmpUrl 拉流地址
     * @private
     */
    __innerSetRtmpUrl(rtmpUrl: string): void;
    /**
     * 设置音频资源是否被发布者禁用
     * @param enable 为 true 时，代表被禁用
     * @returns boolean 是否发生变更
     * @private
     */
    __innerSetOwnerMuteAudio(status: boolean): boolean;
    /**
     * 设置视频资源是否被发布者禁用
     * @param enable 为 true 时，代表被禁用
     * @returns boolean 是否发生变更
     * @private
     */
    __innerSetOwnerDisableVideo(status: boolean): boolean;
    /**
     * @private
     */
    __innerSetIsSubscribed(isSub: boolean): void;
    /**
     * 获取音频资源是否被发布者禁用
     * @returns boolean
     */
    isOwnerMuteAudio(): boolean;
    /**
     * 获取视频资源是否被发布者禁用
     * @returns boolean
     */
    isOwnerDisableVideo(): boolean;
    /**
     * stream 是否被订阅
     * @returns boolean
     */
    isSubscribed(): boolean;
    /**
     * stream 中是否有视频资源
     * @returns boolean
     */
    hasVideo(): boolean;
    /**
     * stream 中是否有音频资源
     * @returns boolean
     */
    hasAudio(): boolean;
    /**
     * 获取 stream 的拉流地址
     * @returns 返回拉流地址
     */
    getRTMPUrl(): string | undefined;
    /**
     * 获取 stream 的资源名称
     * @returns 返回资源名称
     */
    getTag(): string;
    /**
     * 获取 stream 的发布者
     * @returns 资源发布者用户 Id
     */
    getUserId(): string;
    /**
     * 获取 stream 的 Id，由“资源发布者的用户名_资源名”组成
     * @returns 返回 stream Id
     */
    getMsid(): string;
    /**
     * 获取 stream 里面的资源类型
     * @returns 返回媒体类型
     */
    getMediaType(): RCMediaType;
    /**
     * 本端静音
     */
    mute(): void;
    /**
     * 本端取消静音
     */
    unmute(): void;
    /**
     * 该接口已废弃，请使用 `room.setAudioOutputDevice(mode)` 替代
     * @param mode 包含扬声器或听筒
     * @deprecated 仅 iOS 设备下有效；部分 Android 设备因小程序底层 live-pusher 实现存在 Bug，调用无效。
     */
    setAudioOutputDevice(mode: RCAudioOutputDevice): void;
}

/**
 * RTC api ----> live-pusher、live-player 属性变化或调用 api
 */
interface ICoreContextEventListener {
    /**
     * 设置 livePusher 的推流 url
     * @param url
     */
    setPusherUrl?(url: string): void;
    /**
     * 显示推流组件 live-pusher
     */
    showComponent?(): void;
    /**
     * 预览
     */
    startPreview?(): void;
    /**
     * 停止预览
     */
    stopPreview?(): void;
    /**
     * 打开摄像头
     */
    openCamera?(): void;
    /**
     * 关闭摄像头
     */
    closeCamera?(): void;
    /**
     * 切换前后置摄像头
     */
    switchCamera?(): void;
    /**
     * 打开麦克风
     */
    openMicphone?(): void;
    /**
     * 关闭麦克风
     */
    closeMicphone?(): void;
    /**
     * 设置 liveplayer 观看 src
     * @param  src
     */
    setPlayerSrc?(msId: string, src: string): void;
    /**
     * 使 liveplayer 静音
     */
    mute?(msId: string): void;
    /**
     * 取消 liveplayer 静音
     */
    unmute?(msId: string): void;
    /**
     * 指定 liveplayer 的声音输出设备
     * @param mode 扬声器或听筒
     */
    setSoundMode?(mode: RCAudioOutputDevice): void;
}
/**
 * 小程序推流网络数据
 */
interface ILivePusherNetStatus {
    /**
     * 当前视频编/码器输出的比特率，单位 kbps
     */
    videoBitrate: number;
    /**
     * 当前音频编/码器输出的比特率，单位 kbps
     */
    audioBitrate: number;
    /**
     * 当前视频帧率
     */
    videoFPS: number;
    /**
     * 当前视频 GOP,也就是每两个关键帧(I帧)间隔时长，单位 s
     */
    videoGOP: number;
    /**
     * 当前的发送/接收速度
     */
    netSpeed: number;
    /**
     * 网络抖动情况，抖动越大，网络越不稳定
     */
    netJitter: number;
    /**
     * 网络质量：0：未定义 1：最好 2：好 3：一般 4：差 5：很差 6：不可用
     */
    netQualityLevel: number;
    /**
     * 视频画面的宽度
     */
    videoWidth: number;
    /**
     * 视频画面的高度
     */
    videoHeight: number;
    /**
     * 主播端堆积的视频帧数
     */
    videoCache: number;
    /**
     * 主播端堆积的音频帧数
     */
    audioCache: number;
}
/**
 * 小程序拉流网络数据
 */
interface ILivePlayerNetStatus extends ILivePusherNetStatus {
    /**
     * 解码器中缓存的视频帧数 (Android 端硬解码时存在）
     */
    vDecCacheSize: number;
    /**
     * 缓冲的总视频帧数，该数值越大，播放延迟越高
     */
    vSumCacheSize: number;
    /**
     * 音画同步错位时间（播放），单位 ms，此数值越小，音画同步越好
     */
    avPlayInterval: number;
    /**
     * 音画同步错位时间（网络），单位 ms，此数值越小，音画同步越好
     */
    avRecvInterval: number;
    /**
     * 音频缓冲时长阈值，缓冲超过该阈值后，播放器会开始调控延时
     */
    audioCacheThreshold: number;
}
/**
 * 小程序上下行网络数据
 */
interface IResourceNetStatus {
    /**
     * 上行网络数据
     */
    sender?: ILivePusherNetStatus;
    /**
     * 下行网络数据
     */
    receiver?: {
        [msid: string]: ILivePlayerNetStatus;
    };
}
/**
 * MediaServer 返回的媒体资源数据
 */
interface IResource {
    /**
     * 媒体类型
     */
    mediaType: RCMediaType.AUDIO_ONLY | RCMediaType.VIDEO_ONLY;
    /**
     * MediaStream Id，基本为 `userId` 与 `tag` 以 `_` 拼接而来。该值无法直接作为资源的唯一性标识属性，
     * 需与 mediaType 拼接使用
     */
    msid: string;
    /**
     * MediaServer 返回的资源地址
     * @example 举例如下：
     * `{"clusterId":"rtc-data-bdcbj.ronghub.com:80","serverId":"172.28.76.215:40080","resourceId":"13111111111_5vls_web_RongCloudRTC_1","connectionId":"AAYxMDAzNjgAFDEzMTExMTExMTExXzV2bHNfd2ViAAMzMzMA","ssrc":1716229921,"serviceProvider":"bdc","userTimestamp":1604994044706}`
     */
    uri: string;
    /**
     * 资源特征，simulcast 代表这道流支持大小流
     * @description 此参数存疑，MediaServer 似乎并未下发此字段，Web 端暂不启用
     * @deprecated
     */
    features?: ['simulcast'] | [];
    /**
     * 小程序发布的资源携带 rtmp 播放地址
     */
    rtmpUri?: string;
}
/**
 * 向房间内发布的媒体数据
 */
interface IPublishedResource extends IResource {
    /**
     * 资源禁用/启用标识，用于向 signal 同步本端资源状态，1 为启用，0 为禁用
     */
    state: RCResourceState;
    /**
     * 资源标识，同标识的资源将视作同道流，标识不可重复
     */
    tag: string;
}
/**
 * 房间资源数据
 */
type RoomData = {
    [userId: string]: IPublishedResource[];
};
/**
 * 房间资源、状态回调
 */
interface IRoomEventListener {
    /**
     * 当本端被剔出房间时触发
     * @description 被踢出房间可能是由于服务端超出一定时间未能收到 rtcPing 消息，所以认为己方离线。
     * 另一种可能是己方 rtcPing 失败次数超出上限
     * @param byServer 当值为 `false` 时，说明本端 rtcPing 超时；当值为 `true` 时，说明本端收到被踢出房间通知
     */
    onKickOff?(byServer: boolean, state?: RCKickReason): void;
    /**
     * 接收到房间信令时回调，用户可通过房间实例的 sendMessage 接口发送信令
     * @param name 信令名
     * @param content 信令内容
     * @param senderUserId 发送者 Id
     * @param messageUId 消息唯一标识
     */
    onMessageReceive?(name: string, content: any, senderUserId: string, messageUId: string): void;
    /**
     * 房间属性变更回调
     * @param name
     * @param content
     */
    onRoomAttributeChange?(name: string, content?: string): void;
    /**
     * 房间用户禁用/启用音频
     */
    onAudioMuteChange?(stream: RCRemoteStream): void;
    /**
     * 房间用户禁用/启用视频
     */
    onVideoMuteChange?(stream: RCRemoteStream): void;
    /**
     * 房间内用户发布资源
     */
    onStreamPublish?(streams: RCRemoteStream[]): void;
    /**
     * 房间用户取消发布资源
     */
    onStreamUnpublish?(streams: RCRemoteStream[]): void;
    /**
     * 人员加入
     * @param userIds 加入的人员 id 列表
     */
    onUserJoin?(userIds: string[]): void;
    /**
     * 人员退出
     * @param userIds
     */
    onUserLeave?(userIds: string[]): void;
}
/**
 * 订阅参数
 */
interface ISubParams {
    /**
     * 订阅的远端流
     */
    stream: RCRemoteStream;
    /**
     * 是否订阅小流，默认订阅小流
     */
    subTiny?: boolean;
}

/**
 * 音视频模式
 */
declare enum RTCMode {
    /**
     * 普通音视频模式
     */
    RTC = 0,
    /**
     * 直播模式
     */
    LIVE = 2,
    /**
     * 跨应用多人房间
     */
    CROSS_MUTI = 7,
    /**
     * SIP 呼叫
     * @private
     */
    SIP = 4,
    /**
     * 内部 Callplus 呼叫类型，请勿使用
     * @private
     */
    CALL = 5
}

/**
 * 资源大小流标识枚举
 */
declare enum RCStreamType {
    /**
     * 普通流（大流）
     */
    NORMAL = 1,
    /**
     * 小流
     */
    TINY = 2
}

/**
 * 和 mediaServer 交互时的 requestHeader
 */
interface IRTCReqHeader {
    /**
      * 开发者的 AppKey
      */
    'App-Key': string;
    /**
      * 用户 Id
      */
    UserId: string;
    /**
     * RTC Token，放房间时 signal 返回
     */
    Token: string;
    /**
      * 房间 Id
      */
    RoomId: string;
    /**
      * 普通音视频模式或直播模式，仅在直播模式下需要
      */
    RoomType?: RTCMode$1;
}
/**
 * exchange 请求的发布字段
 */
interface IExchangePub {
    /**
     * 资源 msid，为 userId_tag
     */
    msid: string;
    /**
     * 媒体类型，音频或视频
     */
    mediaType: RCMediaType;
    /**
     * 视频分辨率
     */
    resolution?: string;
}
/**
 * exchange 请求的订阅字段
 */
interface IExchangeSub {
    /**
     * 资源 URI
     */
    uri: string;
    /**
     * 资源大小流，为空时服务默认为小流
     */
    simulcast?: RCStreamType;
}
/**
 * 发布、订阅的请求体
 */
interface IExchangeReqBody {
    /**
     * 本地发布的资源列表
     */
    rtmp: IExchangePub[];
    /**
     * 要订阅的资源列表
     */
    subscribeList: IExchangeSub[];
}
/**
 * 发布、订阅响应结构
 */
interface IExchangeResponse {
    /**
     * 服务返回的状态码
     */
    resultCode: RCRTCCode;
    /**
     * mediaServer 返回的发布资源数据
     */
    publishList: {
        /**
         * 媒体类型
         */
        mediaType: RCMediaType.AUDIO_ONLY | RCMediaType.VIDEO_ONLY;
        /**
         * 资源 stream id，userId_tag
         */
        msid: string;
        /**
         * mediaServer 流资源 uri
         * "{\"private_cluster_id\":\"rtc-media-ucbj2-pri.ronghub.com\",\"clusterId\":\"rtc-media-ucbj2.ronghub.com:80\",\"serverId\":\"10.100.100.35:40080\",\"resourceId\":\"11_RongCloudRTC_0\",\"connectionId\":\"AAY2NjM0NjMAAjExAAhtaW5pMDIzNAA=\",\"ssrc\":1200299529,\"serviceProvider\":\"ucloud\",\"userTimestamp\":1650597058583,\"isLiveStream\":false,\"liveType\":0}"
         */
        uri: string;
    }[];
    /**
     * 小程序服务返回的发布资源数据
     * 小程序中发布资源，实际推入 rtmpPublishList - uri 内的 rtmp 地址
     */
    rtmpPublishList: {
        /**
         * 媒体类型
         */
        mediaType: RCMediaType.AUDIO_ONLY | RCMediaType.VIDEO_ONLY;
        /**
         * 资源 stream id，userId_tag
         */
        msid: string;
        /**
         * 发布资源推流 rtmp 地址
         * "rtmp://rtc-mini-rtmp-ucbj2.ronghub.com/wechat?token=mGWeZkdJmMgKQgdZuuIs5_Ht2l5OnK4nidcKke568y_rJOFy9-21Ym-2AiV_Ow55-48gdlojo23oQ2ZlbqGhuGL3sGUmgpTk_y1bANUV8Io/hxFsncMZo5IR3a5vvqciNQ"
         */
        uri: string;
    }[];
    /**
     * 小程序服务返回的订阅资源数据
     * 小程序中订阅的资源，实际通过 rtmpSubscribeList - uri 内的 rtmp 地址拉流
     */
    rtmpSubscribeList: {
        /**
         * 媒体类型
         */
        mediaType: RCMediaType.AUDIO_ONLY | RCMediaType.VIDEO_ONLY;
        /**
         * 资源 stream id，userId_tag
         */
        msid: string;
        /**
         * 订阅资源的拉流 rtmp 地址
         * "rtmp://rtc-mini-rtmp-ucbj2.ronghub.com/wechat?token=mGWeZkdJmMgKQgdZuuIs5_Ht2l5OnK4nidcKke568y_rJOFy9-21Ym-2AiV_Ow55-48gdlojo23oQ2ZlbqGhuGL3sGUmgpTk_y1bANUV8Io/hxFsncMZo5IR3a5vvqciNQ"
         */
        uri: string;
    }[];
}

declare class IReadableStore {
    protected _appkey: string;
    protected _crtRoomId: string;
    protected _crtUserId: string;
    /**
     * 房间内资源数据，对象 key 为 userId，value 为本人发布的资源
     */
    protected _roomResource: RoomData;
    /**
     * 订阅成功的参数列表
     */
    protected _subscribeParams: ISubParams[];
    /**
     * 房间是否被销毁状态
     */
    protected _roomIsDestroyed: boolean;
    /**
     * 所有远端 RCRemoteStream，包含订阅和未订阅的 RCRemoteStream
     * key 为 msId，value 为 RCRemoteStream
     */
    protected _remoteStreams: {
        [msId: string]: RCRemoteStream;
    };
    /**
     * 当前用户发布的参数
     */
    protected _publishParams: {
        tag: string;
        mediaType: RCMediaType;
    } | null;
    /**
     * 加房间返回的 token
     */
    protected _crtRoomToken: string;
    /**
     * 当前会话 id
     */
    protected _crtSeesionId: string;
    /**
     * 当前房间是否发布过视频
     */
    protected _isPubVideo: boolean;
    /**
     * 当前房间是否发布过音频
     */
    protected _isPubAudio: boolean;
    /**
     * 当前房间发布的资源类型
     */
    protected _pubMediaType: RCMediaType;
    /**
     * 当前房间是否打开摄像头
     */
    protected _isOpenCamera: boolean;
    /**
     * 当前房间是否打开麦克风
     */
    protected _isOpenMic: boolean;
    protected _roomStatusVersion: number;
    protected _supportNtf: boolean;
    constructor(_appkey: string, _crtRoomId: string, _crtUserId: string);
    /**
     * 获取房间内所有资源数据
     * @returns
     */
    getRoomResource(): RoomData;
    /**
     * 获取房间内某个人发布的资源数据
     * @param userId 用户 Id
     * @returns
     */
    getResourceByUserId(userId: string): IPublishedResource[];
    /**
     * 根据 userId_tag_mediaType 获取对应的 uri 数据
     * @param userId 用户 Id
     * @param tag 资源名称
     * @param mediaType 资源类型，音频或视频
     * @returns
     */
    getUriByResourceId(userId: string, tag: string, mediaType: RCMediaType): string;
    /**
     * 获取发布资源的参数
     * @returns
     */
    getPublishParams(): {
        tag: string;
        mediaType: RCMediaType;
    } | null;
    /**
     * 获取订阅资源的参数
     * @returns
     */
    getSubscribedParams(): ISubParams[];
    /**
     * 获取订阅的 RCRemoteStream
     * @returns
     */
    getSubscribeStreams(): {
        [msId: string]: RCRemoteStream;
    };
    /**
     * 获取所有远端 RCRemoteStream
     * @returns
     */
    getRemoteStreams(): {
        [msId: string]: RCRemoteStream;
    };
    getRemoteStream(msid: string): RCRemoteStream | undefined;
    getAllUserIds(): string[];
    /**
     * 获取远端所有人员
     * @returns
     */
    getRemoteUserIds(crtUserId: string): string[];
    /**
     * 获取某个用户发布的所有 RCRemoteStream
     * @param userId 用户 Id
     * @returns
     */
    getRemoteStreamByUserId(userId: string): RCRemoteStream[];
    /**
     * 获取房间 token
     */
    getCrtRoomToken(): string;
    /**
     * 获取当前会话 id
     */
    getCrtSessionId(): string;
    /**
     * 获取当前房间 roomId
     */
    getRoomId(): string;
    get mode(): RTCMode;
    /**
     * 获取当前房间是否发布过视频
     */
    getIsPubVideo(): boolean;
    /**
     * 获取当前房间是否发布过音频
     */
    getIsPubAudio(): boolean;
    /**
     * 获取当前房间发布的资源类型
     */
    getPubMediaType(): RCMediaType;
    /**
     * 获取当前用户 Id
     */
    getCrtUserId(): string;
    getHttpHeaders(): IRTCReqHeader;
    getRoomStatusVersion(): number;
    getSupportNtf(): boolean;
}

declare class Store extends IReadableStore {
    /**
     * 设置房间内的所有资源
     * @param resource 房间内所有资源数据
     */
    setRoomResource(resource: RoomData): void;
    assignRoomData(data: RoomData): void;
    /**
     * 主动发布、取消发布、改变资源状态，
     * 或收到有人员加入时(房间内人员数据依赖 _roomResource 的key 值)
     * 设置这个人对应的资源数据
     * @param userId 用户 Id
     * @param resource 用户资源数据
     */
    setResourcesByUserId(userId: string, resource: IPublishedResource[]): void;
    /**
     * 收到某个人退出房间，需删除房间内这个人的资源数据
     * @param userId 用户 Id
     */
    deleteResourceByUserId(userId: string): void;
    /**
     * 收到某个人的某条资源被取消发布或状态被变更时，更新他的某条资源数据
     * @param userId 用户 Id
     * @param index 用户资源的索引
     * @param resource 为 null 时，代表删除
     */
    updateResourceByUserId(userId: string, index: number, resource: IPublishedResource | null): void;
    /**
     * 发布、取消发布后设置发布参数
     * @param tag 为空时代表被取消发布
     * @param mediaType 资源类型
     */
    setPublishParams(tag?: string, mediaType?: RCMediaType): void;
    /**
     * 订阅完成后，设置已订阅参数
     * @param subParams 已订阅参数
     */
    setSubscribeParams(subParams: ISubParams[]): void;
    addSubscribeParams(subParams: ISubParams[]): void;
    /**
     * 取消订阅后，删除取消订阅的参数
     * @param unsubStreams 取消订阅的参数
     */
    deleteSubscribeParams(unsubStreams: RCRemoteStream[]): void;
    /**
     * 订阅资源，更新 stream 的 rtmpUrl 之后
     * 或收到远端发布资源时，设置远端 stream
     * @param msId stream Id
     * @param stream
     */
    setRemoteStream(msId: string, stream: RCRemoteStream): void;
    /**
     * 收到远端取消发布资源时，更新远端 stream
     * @param streams stream 列表
     */
    deleteRemoteStreams(streams: RCRemoteStream[]): void;
    /**
     * 收到有人离开房间时，删除这个人对应的远端 stream
     * @param userId 用户 Id
     */
    deleteRemoteStreamByUserId(userId: string): void;
    /**
     * 设置房间 token
     */
    setCrtRoomToken(roomToken: string): void;
    /**
     * 设置当前会话 id
     */
    setCrtSessionId(sessionId: string): void;
    /**
     * 设置当前房间是否发布过视频
     */
    setIsPubVideo(isPubVideo: boolean): void;
    /**
     * 设置当前房间是否发布过音频
     */
    setIsPubAudio(isPubAudio: boolean): void;
    /**
     * 设置当前房间发布的资源类型
     */
    setPubMediaType(mediaType: RCMediaType): void;
    setRoomStatusVersion(version: number): void;
}

declare class RCMediaService {
    /**
     * 运行时环境
     */
    private readonly _runtime;
    private readonly _logger;
    /**
     * 小程序和 mediaServer 交互地址，只有一个数据中心
     */
    private readonly _msUrl;
    /**
     * 请求超时时间，默认为 5s
     */
    private readonly _timeout;
    /**
     * 发送请求需要的 requestHeader
     */
    private readonly _store;
    constructor(
    /**
     * 运行时环境
     */
    _runtime: IRuntime, _logger: ILogger, 
    /**
     * 小程序和 mediaServer 交互地址，只有一个数据中心
     */
    _msUrl: string, 
    /**
     * 请求超时时间，默认为 5s
     */
    _timeout: number, 
    /**
     * 发送请求需要的 requestHeader
     */
    _store: IReadableStore);
    private _request;
    /**
     * 发布、订阅时和 mediaServer 交互，获取发布、订阅的 rtmp 地址
     * @param body
     * @returns
     */
    exchange(body: IExchangeReqBody): Promise<{
        code: RCRTCCode;
        data?: IExchangeResponse | undefined;
    }>;
    /**
     * 退出房间，终止和 mediaServer 的交互
     * @param headers
     * @returns
     */
    exit(): Promise<{
        code: RCRTCCode;
        data?: IExchangeResponse | undefined;
    }>;
}

/**
 * 多端登录时，加入房间时的踢人策略
 */
declare enum RTCJoinType {
    /**
     * 踢出已存在于房间的设备，以便于当前设备加入房间
     */
    KICK = 0,
    /**
     * 保持已存在于房间的设备，拒绝当前设备加入房间
     */
    REFUSE = 1,
    /**
     * 两个设备共存，但发布的资源会相互覆盖，以最后发布的为准
     */
    COEXIST = 2
}

declare enum RTCApiType {
    ROOM = 1,
    PERSON = 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"];
};
type RTCKeyMaps = typeof keymaps;

/**
 * 通知拉取到的房间增量数据列表中每一项数据的动作
 */
declare enum PullRoomStatusEvent {
    /**
     * 人员加入
     */
    JOIN = 0,
    /**
     * 人员离开
     */
    LEAVE = 1,
    /**
     * 人员离线
     */
    OFFLINE = 2,
    /**
     * 资源变动
     */
    RESOURCECHANGE = 3
}

/**
 * 设置 RTC 人员 inner、outer 数据
 */
interface IRTCUserData {
    [key: string]: string;
}
interface IRtcTokenData {
    rtcToken: string;
}
/**
 * 加入 RTC 房间的用户信息
 */
interface IRTCJoinedInfo {
    /**
     * 设备 ID
     */
    deviceId: string;
    /**
     * RTC 房间 ID
     */
    roomId: string;
    /**
     * 加入的时间戳
     */
    joinTime: number;
}
interface IRTCRoomInfo {
    roomId: string;
    roomData: unknown[];
    userCount: number;
    list: unknown[];
}
interface IServerRTCRoomEntry {
    key: string;
    value: string;
    status: number;
    timestamp: number;
    uid: string;
}
interface IRTCUsers {
    users: {
        [userId: string]: {
            /**
             * 发布的资源数据，是一个 JSON 字符串，解析后为发布的资源列表
             */
            uris?: string;
            /**
             * 加房间的身份标识，保存主房间 roomId
             */
            extra?: string;
        };
    };
}
interface IJoinRTCRoomData extends IRTCUsers {
    token: string;
    sessionId: string;
    roomInfo: {
        key: string;
        value: string;
    }[];
    kvEntries: IServerRTCRoomEntry[];
    offlineKickTime: number;
    codeFormat?: string;
    roomCreateTime?: number;
    userJoinTime?: number;
    version: number;
}
interface IRTCNaviInfo extends INaviInfo {
    /**
     * jwt token
    */
    jwt?: string;
    /**
     * http3 上报域名
    */
    logServer?: string;
    /**
     * 数据中心
    */
    dc?: string;
    /**
     *  openGzip  开启标识,默认是false,开启使用true
    */
    openGzip?: boolean;
}
/**
 * 通知拉取到的房间增量数据
 */
interface IRoomStatus {
    /**
     * 用户 id
     */
    userId: string;
    /**
     * 本次变更的动作类型
     */
    event: PullRoomStatusEvent;
    /**
     * 本次变更的版本号
     */
    time: number;
    /**
     * 用户变更的资源，event 为人员加入或资源变动时有值
     * key 包含 uris、cdn_uris、mcu_uris
     * value 为字符串数组
     */
    userData: {
        key: string;
        value: string;
    }[];
    /**
     * 切换角色，0 代表非切换身份发生的加入、退出房间行为
     */
    switchRoleType: 0;
    /**
     * 额外的信息
     */
    extra: string;
}
/**
 * 通知拉取到的房间全量数据
 */
interface IPullRTCRoomUsersData {
    /**
     * 用户 id
     */
    userId: string;
    /**
     * 房间内所有资源数据
     * key 包含 uris、cdn_uris、mcu_uris
     * value 为字符串数组
     */
    userData: {
        key: string;
        value: string;
    }[];
}
/**
 * 通知拉取到的房间数据
 */
interface IPullRTCRoomStatus {
    /**
     * 是否是全量数据
     */
    bFullStatus: boolean;
    /**
     * 当前房间的最大版本号
     */
    version: number;
    /**
     * 如果是全量数据，usersData 不为空,给的是房间全部的人以及发布的资源
     */
    usersData: IPullRTCRoomUsersData[];
    /**
     * 房间增量数据
     */
    roomStatus: IRoomStatus[];
}

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>;
    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>;
    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>;
    getRTCToken(roomId: string, mode: number, broadcastType?: number): IPromiseResult<IRtcTokenData>;
    setRTCState(roomId: string, report: string): Promise<ErrorCode>;
    getRTCUserList(roomId: string): IPromiseResult<IRTCUsers>;
    getRTCJoinedUserInfo(userId: string): Promise<IAsyncRes<IRTCJoinedInfo[]>>;
    /**
     * 通知拉取房间数据
     * @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;
    }>;
    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;
}

/**
 * 命令执行上下文
 */
declare class CommandExecuteContext extends EventEmitter {
    /**
     * 日志工具
     */
    readonly logger: ILogger;
    /**
     * IM 信令上下文
     */
    readonly context: RTCContext;
    /**
     * 运行时
     */
    readonly runtime: IRuntime;
    /**
     * 内存只读模块
     */
    readonly store: Store;
    /**
     * RTC Service 请求工具
     */
    readonly service: RCMediaService;
    constructor(
    /**
     * 日志工具
     */
    logger: ILogger, 
    /**
     * IM 信令上下文
     */
    context: RTCContext, 
    /**
     * 运行时
     */
    runtime: IRuntime, 
    /**
     * 内存只读模块
     */
    store: Store, 
    /**
     * RTC Service 请求工具
     */
    service: RCMediaService);
}

declare enum CommandPriority {
    LOW = 0,
    NORMAL = 1,
    HIGH = 2
}
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>>;
    /**
     * 获取指令优先级，必要时可 override 此函数
     */
    get priority(): CommandPriority;
    /**
     * 它返回命令的种类。
     * @returns 命令的种类。
     */
    abstract get kind(): RCCommandKind;
}

/**
 * @typeParams T - 事务执行上下文类型
 * @typeParams S - 内存读写模块类型
 */
declare class BaseInvoker<T, S> {
    protected readonly _logger: ILogger;
    /**
     * 内存数据管理实例
     */
    protected readonly _context: T;
    /**
     * 内存读写模块
     */
    protected readonly _store: S;
    /**
     * 命令终止时返回的错误码定义
     */
    private abortCode;
    constructor(_logger: ILogger, 
    /**
     * 内存数据管理实例
     */
    _context: T, 
    /**
     * 内存读写模块
     */
    _store: S, 
    /**
     * 命令终止时返回的错误码定义
     */
    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);
    get store(): IReadableStore;
}

declare class RCRTCRoom extends EventEmitter {
    protected readonly _context: RTCContext;
    protected readonly _logger: ILogger;
    private readonly _runtime;
    protected readonly _initOptions: IRCRTCInitOptions;
    protected readonly _roomId: string;
    private _isOpenCamera;
    private _isOpenMic;
    private _mediaServer;
    private _resourceListener;
    private _store;
    protected readonly _invoker: Invoker;
    protected _commandCtx: CommandExecuteContext;
    /**
     * 房间保活 rtcPing
     */
    private readonly _pinger;
    constructor(_context: RTCContext, _logger: ILogger, _runtime: IRuntime, _initOptions: IRCRTCInitOptions, _roomId: string);
    /**
     * 拉取房间数据
     * @param roomId 房间 id
     */
    private _startPullRTCRoomStatus;
    private _handlePingResult;
    /**
     * @private
     */
    __innerInitialize(joinType?: RTCJoinType$1): Promise<RCRTCCode>;
    protected _callAppListener(eventType: keyof IRoomEventListener, ...attrs: any[]): void;
    private _bindRoomEvent;
    private _operateDeviceByMediaType;
    private _onStreamPublish;
    private _onStreamUnpublish;
    private _onAudioMuteChange;
    private _onVideoMuteChange;
    private _onUserJoin;
    private _onUserLeave;
    private _kickOff;
    /**
     * @private
     */
    __parseInnerMessage(message: IReceivedMessage): void;
    /**
     * 注册房间事件
     * @param listener 房间人员、资源变动监听
     */
    registerRoomEventListener(listener: IRoomEventListener | null): void;
    /**
     * 业务层注册的上下行数据上报事件
     */
    private _reportListener;
    /**
     * 注册小程序网络状态和资源数据事件
     * @param listener 小程序网络状态和资源数据监听
     */
    registerReportListener(listenerEvent: ((data: IResourceNetStatus) => void) | null): void;
    /**
     * 上报给业务层的上下行数据
     */
    private _netStatusData;
    /**
     * 接收推流组件上报的网络数据
     * @param data 推流组件的网络数据
     */
    private _pusherNetStatusListener;
    /**
     * 接收拉流组件上报的网络数据
     * @param msid 拉流组件 id，即 stream 的 msid
     * @param data 拉流组件的网络数据
     */
    private _playerNetStatusListener;
    /**
     * 注册本端麦克风采集的音量通知
     */
    onLocalAudioLevelChange(listenerEvent: ((volume: number) => void) | null): void;
    /**
     * 注册远端订阅资源的音量通知
     */
    onRemoteAudioLevelChange(listenerEvent: ((msid: string, volume: number) => void) | null): void;
    /**
     * 开启视频预览
     */
    startPreview(): void;
    /**
     * 关闭视频预览
     */
    stopPreview(): void;
    /**
     * 开启摄像头
     * 未发布视频时，该方法仅打开摄像头硬件设备
     * 发布过视频时，打开摄像头硬件设备后，修改视频资源状态为可用，订阅端可以看到发布的视频
     */
    openCamera(): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 关闭摄像头
     * 未发布视频时，该方法仅关闭摄像头硬件设备
     * 发布过视频时，关闭摄像头硬件设备后，修改视频资源状态为不可用，订阅端看到发布的视频为黑屏
     */
    closeCamera(): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 切换前后置摄像头
     */
    switchCamera(): void;
    /**
     * 开启麦克风
     * 未发布音频时，该方法仅打开麦克风硬件设备
     * 发布过视频时，打开麦克风硬件设备后，修改音频资源状态为可用，订阅端可以听到发布的声音
     */
    openMicphone(): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 关闭麦克风
     * 未发布音频时，该方法仅关闭麦克风硬件设备
     * 发布过视频时，关闭麦克风硬件设备后，修改音频资源状态为不可用，订阅端听不到发布的声音
     */
    closeMicphone(): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 发布资源
     * @param tag 资源标识，可不传，默认为 RongCloudRTC
     * @param mediaType 资源类型，代表发布音频、视频或音视频，可不传，默认为 RCMediaType.AUDIO_VIDEO
     * @returns 发布资源状态码
     */
    publishStream(tag?: string, mediaType?: RCMediaType): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 取消发布
     * @returns 取消发布的状态码
     */
    unpublishStream(): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 订阅资源
     * @param subParams 订阅参数列表
     * * ISubParams.stream 从房间数据或房间发布资源事件监听中拿到的 RCRemoteStream 对象
     * * ISubParams.subTiny 是否订阅小流，可不传，默认为小流，boolean 类型，true 代表订阅小流
     * @returns 订阅的状态码
     */
    subscribe(subParams: ISubParams[] | RCRemoteStream[]): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 取消订阅
     * @param streams 一组远端 stream 对象
     * @returns 取消订阅的状态码
     */
    unsubscribe(streams: RCRemoteStream[]): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 取消订阅时，需更新下行网络数据
     * @param streams 取消订阅的资源列表
     */
    private _deleteReceiverNetStatus;
    private _deleteSerderNetStatus;
    /**
     * @private
     * im 重新连接之后的处理
     */
    __onReconnected(): void;
    /**
     * 离开房间
     * @private
     */
    __leaveHandle(quitRoom: boolean): Promise<void>;
    /**
     * 摄像头是否开启
     */
    isCameraOpen(): boolean;
    /**
     * 麦克风是否开启
     */
    isMicphoneOpen(): boolean;
    /**
     * 房间是否被销毁
     */
    isDestroyed(): boolean;
    /**
     * 获取房间 Id
     * @returns 返回房间 Id
     */
    getRoomId(): string;
    getSessionId(): string;
    /**
     * 获取当前用户
     * @returns 返回当前用户 Id
     */
    getCrtUserId(): string;
    /**
     * 获取房间内其他人员
     */
    getRemoteUserIds(): string[];
    /**
     * 获取远端发布的所有资源列表 streams
     */
    getRemoteStreams(): RCRemoteStream[];
    /**
     * 根据 userId 获取此用户在房间内发布的资源列表
     * @param userId 远端用户 Id
     */
    getRemoteStreamsByUserId(userId: string): RCRemoteStream[];
    /**
     * 向房间内发消息
     * @param name 消息名称
     * @param content 消息内容
     */
    sendMessage(name: string, content: any): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 设置房间属性
     * @param key 属性名
     * @param value 属性值
     * @param message 是否在设置属性的时候携带消息内容，传空则不往房间中发送消息
     * @param isInner RTC 业务内部使用参数，用户忽略
     */
    setRoomAttribute(key: string, value: string, message?: {
        name: string;
        content: any;
    }, isInner?: boolean): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 删除房间属性
     * @param keys 待删除的属性名数组
     * @param message 是否在删除属性的时候携带消息内容，传空则不往房间中发送消息
     * @param isInner RTC 业务内部使用参数，用户忽略
     */
    deleteRoomAttributes(keys: string[], message: {
        name: string;
        content: any;
    }, isInner?: boolean): Promise<{
        code: RCRTCCode;
    }>;
    /**
     * 获取房间属性
     * @param keys 要查询的属性名数组，当数组长度为空时，取所有已设置的 kv 值
     * @param isInner RTC 业务内部使用参数，用户忽略
     */
    getRoomAttributes(keys?: string[], isInner?: boolean): Promise<{
        code: RCRTCCode;
        data?: undefined;
    } | {
        code: RCRTCCode;
        data: _rongcloud_engine.KVString | undefined;
    }>;
    /**
     * 切换声音输出设备，房间内所有远端流的音频输出设备将被切换
     * @param mode
     * @deprecated 仅 iOS 设备下有效；部分 Android 设备因小程序底层 live-pusher 实现存在 Bug，调用无效。
     */
    setAudioOutputDevice(mode: RCAudioOutputDevice): void;
    /**
     * 获取当前的声音输出设备配置
     * @returns
     */
    getAudioOutputDevice(): RCAudioOutputDevice;
}

/**
 * 加房间返回的 data 数据接口
 */
interface IJoinRTCRoomResp {
    /**
     * 当前加入的房间实例
     */
    room: RCRTCRoom;
    /**
     * 房间内的其他人员用户 Id 列表
     */
    userIds: string[];
    /**
     * 房间内其他人发布的所有资源
     */
    streams: RCRemoteStream[];
}

interface IRCRTCInitOptions {
    /**
     * @deprecated
     */
    logLevel?: LogLevel;
    /**
     * 输出日志等级，生产环境默认使用 WARN，开发环境默认为 DEBUG
     * @description
     * * 4 - DEBUG
     * * 3 - INFO
     * * 2 - WARN
     * * 1 - ERROR
     */
    logOutputLevel?: EnableLogL;
    /**
     * @deprecated
     */
    logStdout?: (level: LogLevel, content: string) => void;
    /**
     * 与 MediaServer 的 http 请求超时时间，单位为毫秒，默认值为 `5000`，有效值 `5000-30000`。
     * 优先级：用户配置 > 导航配置 > 默认时间。
     */
    timeout?: number;
    /**
     * 房间 Ping 间隔时长，默认 `10000` ms，有效值 `3000`-`10000`
     */
    pingGap?: number;
    /**
     * MediaServer 地址，私有云环境需指定
     */
    mediaServer?: string;
}
declare class RCRTCClient {
    private readonly _context;
    private readonly _logger;
    private readonly _runtime;
    private readonly _options;
    private _crtRoom;
    constructor(_context: RTCContext, _logger: ILogger, _runtime: IRuntime, _options: IRCRTCInitOptions);
    private _onIMStatusChange;
    private _onIMDisconnect;
    private _onIMUninit;
    private _handleMessage;
    /**
     * 加入 RTC 房间
     * @param roomId 房间 Id
     * @param _ 参数已废弃
     * @param joinType 加入房间时的多端处理方式：
     * - RTCJoinType.KICK：踢出其他端
     * - RTCJoinType.REFUSE：拒绝当前端加入
     * - RTCJoinType.COEXIST: 多端共存，但发布资源时，以最后发布端为准，资源会相互覆盖
     */
    joinRTCRoom(roomId: string, _: any, joinType?: RTCJoinType$1): Promise<{
        code: RCRTCCode;
        data?: IJoinRTCRoomResp;
    }>;
    /**
     * 离开房间
     * @param room 加入房间返回的房间实例
     */
    leaveRoom(room: RCRTCRoom): Promise<void>;
}

declare class Context<T> {
    private _listeners;
    addEventListener(listener: T): void;
    dispatch(eventType: keyof T, ...attrs: any[]): void;
}
/**
 * 负责 RTCLIb 数据到 rc-liveplayer 和 rc-livepusher 流向
 */
declare class RCCoreContext extends Context<ICoreContextEventListener> {
    private _soundMode;
    setSoundMode(mode: RCAudioOutputDevice): void;
    getSoundMode(): RCAudioOutputDevice;
}
/**
 * 负责 rc-livepusher 事件数据到 RTCLib 的流向
 */
declare class RCPusherContext extends EventEmitter {
    setNetStatusListener(listenerEvent: ((data: ILivePusherNetStatus) => void) | null): void;
    setLocalAudioLevelListener(listenerEvent: ((volume: number) => void) | null): void;
}
/**
 * 负责 rc-liveplayer 事件数据到 RTCLib 流向
 */
declare class RCPlayerContext extends EventEmitter {
    setNetStatusListener(listenerEvent: ((id: string, data: ILivePlayerNetStatus) => void) | null): void;
    setRemoteAudioLevelListener(listenerEvent: ((id: string, volume: number) => void) | null): void;
}
declare const getCoreContext: () => RCCoreContext;
declare const getPusherContext: () => RCPusherContext;
declare const getPlayerContext: () => RCPlayerContext;
declare global {
    var coreContext: RCCoreContext;
    var pusherContext: RCPusherContext;
    var playerContext: RCPlayerContext;
}

/**
 * RTC 插件生成器
 * @public
 */
declare const installer: IPluginGenerator<RCRTCClient, IRCRTCInitOptions>;

export { ASPECT, AUDIOREVERBTYPE, BEAUTYSTYLE, FILTER, IJoinRTCRoomResp, ILivePlayerNetStatus, ILivePusherNetStatus, IRCRTCInitOptions, IRemoteStreamEventListener, IResourceNetStatus, IRoomEventListener, ISubParams, LOCALMIRROR, OBJECTFIT, ORIENTATION, RCAudioOutputDevice, RCAudioVolumeType, RCDevicePosition, RCKickReason, RCMediaType, RCRTCClient, RCRTCCode, RCRTCRoom, RCRemoteStream, REFERRERPOLICY, getCoreContext as __innerGetCoreContext__, getPlayerContext as __innerGetPlayerContext__, getPusherContext as __innerGetPusherContext__, installer };