aliyun-rtc-sdk 6.11.5-beta.5 → 6.11.5

package/dist/types/index.d.ts

@@ -0,0 +1,3749 @@
+/// <reference types="dom-mediacapture-transform" />
+
+import { default as default_2 } from 'eventemitter3';
+import { IAudioConstraints } from 'media-device';
+import { IProfile } from 'aliyun-rts-sdk';
+import { IStreamConfig } from 'aliyun-rts-sdk';
+import { IVideoConstraints } from 'media-device';
+import { LocalStream } from 'aliyun-rts-sdk';
+import { LogReporter } from 'browser-log-reporter';
+import { RemoteStream } from 'aliyun-rts-sdk';
+
+declare interface AliEngineCameraCapturerConfiguration {
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    bitrate?: number;
+    cameraDirection?: AliRtcCameraDirection;
+    deviceId?: string;
+}
+
+declare enum AliRtcAudioTrack {
+    /** 无麦克风 */
+    AliRtcAudioTrackNo = 0,
+    /** 麦克风 */
+    AliRtcAudioTrackMic = 1,
+    /** 第二音频流 */
+    AliRtcAudioTrackDual = 2
+}
+
+export declare interface AliRtcAuthInfo {
+    /** 频道ID */
+    channelId: string;
+    /** 用户ID */
+    userId: string;
+    /** 应用ID */
+    appId: string;
+    /** 随机串 */
+    nonce?: string;
+    /** 时间戳 */
+    timestamp: number;
+    /** 令牌 */
+    token: string;
+    /** 会议id */
+    callid?: string;
+    /** 角色鉴权值 */
+    role?: AliRtcSdkTokenRole;
+}
+
+declare interface AliRtcBeautyConfig {
+    whiteningLevel: number;
+    /*! 磨皮等级[0-1.0] */
+    smoothnessLevel: number;
+}
+
+declare enum AliRtcCameraDirection {
+    /** 无效 */
+    CAMERA_INVALID = -1,
+    /** 后置 */
+    CAMERA_REAR = 0,
+    /** 前置 */
+    CAMERA_FRONT = 1
+}
+
+declare interface AliRtcCheckResult {
+    support: boolean;
+    detail: {
+        isWebRTCSupported: boolean;
+        isH264EncodeSupported: boolean;
+        isH264DecodeSupported: boolean;
+        isBrowserSupported: boolean;
+        isScreenShareSupported: boolean;
+        isSendMediaExtensionMsgSupported: boolean;
+    };
+}
+
+export declare enum AliRtcConnectionStatus {
+    /** 初始化完成 */
+    AliRtcConnectionStatusInit = 0,
+    /** 网络连接断开 */
+    AliRtcConnectionStatusDisconnected = 1,
+    /** 建立网络连接中 */
+    AliRtcConnectionStatusConnecting = 2,
+    /** 网络已连接 */
+    AliRtcConnectionStatusConnected = 3,
+    /** 重新建立网络连接中 */
+    AliRtcConnectionStatusReconnecting = 4,
+    /** 网络连接失败 */
+    AliRtcConnectionStatusFailed = 5
+}
+
+export declare enum AliRtcConnectionStatusChangeReason {
+    /** 未知原因 */
+    AliRtcConnectionChangedDummyReason = 0,
+    /** 媒体通道变更 */
+    AliRtcConnectionMediaPathChanged = 1,
+    /** 心跳超时 */
+    AliRtcConnectionSignalingHeartbeatTimeout = 2,
+    /** 心跳恢复 */
+    AliRtcConnectionSignalingHeartbeatAlive = 3,
+    /** DNS解析成功 */
+    AliRtcConnectionSignalingHttpDnsResolved = 4,
+    /** DNS解析失败 */
+    AliRtcConnectionSignalingHttpDnsFailure = 5,
+    /** GSLB请求失败 */
+    AliRtcConnectionSignalingGslbFailure = 6,
+    /** GSLB请求成功 */
+    AliRtcConnectionSignalingGslbSuccess = 7,
+    /** 加入频道失败 */
+    AliRtcConnectionSignalingJoinRoomFailure = 8,
+    /** 加入频道成功 */
+    AliRtcConnectionSignalingJoinRoomSuccess = 9,
+    /** 离开频道 */
+    AliRtcConnectionSignalingLeaveRoom = 10,
+    /** 信令建立连接 */
+    AliRtcConnectionSignalingConnecting = 11,
+    /** 网络连接中断 */
+    AliRtcConnectionChangedNetworkInterrupted = 12
+}
+
+declare type AliRtcDualVideoPluginOptions = VideoScalerOptions;
+
+export declare class AliRtcEngine extends default_2<AliRtcEngineEventListener> {
+    /**
+     * @ignore
+     */
+    static logName: string;
+    /**
+     * 检查浏览器是否支持 WebRTC
+     * @param {string} direction
+     * @returns {Promise<AliRtcCheckResult>}
+     */
+    static isSupported: (direction?: "sendonly" | "recvonly" | "sendrecv" | undefined) => Promise<AliRtcCheckResult>;
+    /**
+     * 检查浏览器是否支持开启大小流
+     * @returns {boolean}
+     */
+    static isDualVideoStreamSupported: typeof VideoScalerFactory.isSupport;
+    /**
+     * 获取摄像头列表
+     * @returns {Promise<string[]>}
+     */
+    static getCameraList: () => Promise<MediaDeviceInfo[]>;
+    static getMicrophoneList: () => Promise<MediaDeviceInfo[]>;
+    static getSpeakerList: () => Promise<MediaDeviceInfo[]>;
+    static getSdkVersion(): string;
+    /**
+     * 设置日志等级
+     * @param level
+     */
+    static setLogLevel(level: AliRtcLogLevel): void;
+    private static _instance?;
+    /**
+     * @brief 获取AliRtcEngine实例
+     * @param key key 可选参与，用于创建多个实例
+     * @details 该方法为同步调用，以单例的形式提供对象创建。
+     */
+    static getInstance(config?: AliRtcEngineConfig): AliRtcEngine;
+    static AliRtcSdkChannelProfile: typeof AliRtcSdkChannelProfile;
+    static AliRtcSdkClientRole: typeof AliRtcSdkClientRole;
+    static AliRtcVideoStreamType: typeof AliRtcVideoStreamType;
+    static AliRtcVideoTrack: typeof AliRtcVideoTrack;
+    static AliRtcAudioTrack: typeof AliRtcAudioTrack;
+    static AliRtcPublishState: typeof AliRtcPublishState;
+    static AliRtcSubscribeState: typeof AliRtcSubscribeState;
+    static AliRtcRawDataStreamType: typeof AliRtcRawDataStreamType;
+    static AliRtcLogLevel: typeof AliRtcLogLevel;
+    static AliRtcEngineLocalDeviceType: typeof AliRtcEngineLocalDeviceType;
+    static AliRtcEngineLocalDeviceExceptionType: typeof AliRtcEngineLocalDeviceExceptionType;
+    static AliRtcConnectionStatus: typeof AliRtcConnectionStatus;
+    static AliRtcConnectionStatusChangeReason: typeof AliRtcConnectionStatusChangeReason;
+    static AliRtcPlugin: typeof AliRtcPlugin;
+    static AliRtcPluginTrackType: typeof AliRtcPluginTrackType;
+    static AliRtcLiveTranscodingParam: typeof AliRtcLiveTranscodingParam;
+    static AliRtcLiveTranscodingEncodeParam: typeof AliRtcLiveTranscodingEncodeParam;
+    static AliRtcLiveTranscodingMixParam: typeof AliRtcLiveTranscodingMixParam;
+    static AliRtcLiveTranscodingSingleParam: typeof AliRtcLiveTranscodingSingleParam;
+    static AliRtcTranscodingClockWidget: typeof AliRtcTranscodingClockWidget;
+    static AliRtcTranscodingImage: typeof AliRtcTranscodingImage;
+    static AliRtcTranscodingText: typeof AliRtcTranscodingText;
+    static AliRtcTranscodingUser: typeof AliRtcTranscodingUser;
+    static AliRtcLiveTranscodingMixMode: typeof AliRtcLiveTranscodingMixMode;
+    static AliRtcLiveTranscodingStreamType: typeof AliRtcLiveTranscodingStreamType;
+    static AliRtcLiveTranscodingSourceType: typeof AliRtcLiveTranscodingSourceType;
+    static AliRtcLiveTranscodingTaskProfile: typeof AliRtcLiveTranscodingTaskProfile;
+    static AliRtcLiveTranscodingAudioSampleRate: typeof AliRtcLiveTranscodingAudioSampleRate;
+    static AliRtcLiveTranscodingSegmentType: typeof AliRtcLiveTranscodingSegmentType;
+    static AliRtcLiveTranscodingFontType: typeof AliRtcLiveTranscodingFontType;
+    static AliRtcLiveTranscodingCropMode: typeof AliRtcLiveTranscodingCropMode;
+    static AliRtcLiveTranscodingMediaProcessMode: typeof AliRtcLiveTranscodingMediaProcessMode;
+    static AliRtcLiveTranscodingState: typeof AliRtcLiveTranscodingState;
+    static AliRtcLiveTranscodingErrorCode: typeof AliRtcLiveTranscodingErrorCode;
+    static AliRtcTrascodingPublishTaskStatus: typeof AliRtcTrascodingPublishTaskStatus;
+    /**
+     * @brief 销毁 {@link AliRtcEngine}实例
+     * @details 调用该方法将会释放所有内部使用的资源,当完成音视频通信之后都建议调用该方法释放实例.调用该方法后，你将不能再使用 {@link AliRtcEngine} 的其他方法和任何回调，如需要再次使用需要重新调用 {@link AliRtcEngine.getInstance} 方法创建一个新的实例。
+     * @note 该方法为同步调用,需要等待内部资源释放之后才能执行其他方法
+     */
+    destroy(): void;
+    protected channelProfile: AliRtcSdkChannelProfile;
+    protected clientRole: AliRtcSdkClientRole;
+    protected signalingManager: SignalingManager;
+    protected userManager: UserManager;
+    protected liveTranscoding: AliRtcLiveTranscoding;
+    protected maxSignalingConnectRetryCount?: number;
+    protected reporter: Reporter;
+    protected webTrackingClient: WebTrackingClient;
+    protected connectState: AliRtcConnectionStatus;
+    protected networkError: boolean;
+    private audioMixerPlugin;
+    private dualVideoPlugin;
+    private _audioOnlyMode;
+    private _authInfoWillExpireTimer;
+    private _authInfoExpiredTimer;
+    private _serverCheckAuthInfoTimestamp;
+    private _localCheckAuthInfoTimestamp;
+    constructor(config?: AliRtcEngineConfig);
+    /**
+     * 获取当前频道号，已经入会成功返回频道号，否则返回undefined
+     */
+    get channel(): string | undefined;
+    /**
+     * 获取当前用户的 userId，已经入会成功返回自己的 userId，否则返回 undefined
+     */
+    get userId(): string | undefined;
+    get remoteUsers(): RemoteUser[];
+    get publisher(): LocalUser | undefined;
+    get publishAudioStream(): LocalStream | undefined;
+    get isPublishing(): boolean;
+    private get currentRoleCanPublish();
+    /**
+     * 重置 client 状态
+     * @returns {Promise<void>}
+     */
+    protected resetState(): Promise<void>;
+    /**
+     * 停止推流，底层调用 rts publishStop，不会导致 DC 马上关闭。适合暂时停推的场景
+     * @param {StopPublishOptions} options
+     * @returns {Promise<void>}
+     */
+    private stopPublish;
+    /**
+     * 监听 Publisher 事件
+     */
+    private addPublisherListeners;
+    /**
+     * 监听 UM 事件
+     */
+    private addUserManagerListeners;
+    /**
+     * 添加信令处理
+     * @returns {void}
+     */
+    private addSignalingManagerListeners;
+    private backToUnpublishStatus;
+    /**
+     * 处理入会远程的用户
+     * @param {JoinInfo[]} users
+     * @returns {void}
+     */
+    private handleUsersJoin;
+    /**
+     * 本地用户设备状态变化，通过信令发送给其他人
+     * @param {string} status
+     * @returns {void}
+     */
+    protected onLocalDeviceStatusChange(status: string): void;
+    /**
+     * 网络恢复后，重推；
+     */
+    private resumePublishForNetworkRecovery;
+    /**
+     * 处理房间信令重连成功/心跳恢复
+     * @returns {void}
+     */
+    protected onNetworkRecovery(users?: JoinInfo[]): Promise<void>;
+    private resumeSubList;
+    /**
+     * 处理网络异常
+     * @param {AliRtcError} err
+     * @returns {void}
+     */
+    protected onNetworkError(): void;
+    /**
+     * 处理错误
+     * @param {AliRtcError} err
+     * @returns {void}
+     */
+    protected onError(err: AliRtcError): void;
+    /**
+     * 是否开启大小流
+     * @param {boolean} enabled
+     * @param {AliRtcDualVideoPluginOptions} [options]
+     */
+    setEnableDualVideoStream(enabled: boolean, options?: AliRtcDualVideoPluginOptions): void;
+    /**
+     * 对本地流的操作预检查
+     */
+    private hadPushStream;
+    /**
+     * 获取当前使用的麦克风 deviceId
+     * @returns {string | undefined}
+     */
+    getCurrentMicDeviceId(): string | undefined;
+    /**
+     * 设置频道模式
+     * @param {AliRtcSdkChannelProfile} channelProfile 频道类型，默认值为 AliEngineCommunication
+     * @note 该接口只可以在加入频道之前调用，会议中不可以重新设置，离开频道后可以重新设置
+     */
+    setChannelProfile(channelProfile: AliRtcSdkChannelProfile): void;
+    /**
+     * 设置用户角色
+     * @param {AliRtcSdkClientRole} clientRole 用户角色类型，默认值为 {@link AliRtcSdkClientRole.AliRtcSdkLive}（观众角色）
+     * @note 非通信模式下角色类型才有效
+     */
+    setClientRole(clientRole: AliRtcSdkClientRole): Promise<void>;
+    /**
+     * 获取用户角色
+     * @returns {AliRtcSdkClientRole}
+     */
+    getCurrentClientRole(): AliRtcSdkClientRole;
+    /**
+     * 是否开启纯音频模式
+     * @param {boolean} audioOnly
+     * - true：只有音频推流和拉流
+     * - false（默认值）：音视频都支持
+     * @note 只可以在 {@link joinChannel} 之前设置
+     */
+    setAudioOnlyMode(audioOnly: boolean): void;
+    setAudioRedEnabled(audioRedEnabled: boolean): void;
+    /**
+     * 设定鉴权信息过期事件定时器
+     * @param expireTimestamp 鉴权信息过期时间
+     * @param serverTimestamp 入会时服务端时间
+     */
+    private setCheckAuthInfoTimer;
+    /**
+     * 清除鉴权信息过期事件定时器
+     */
+    private clearCheckAuthInfoTimer;
+    private startDefaultDevicesCapture;
+    /**
+     * @brief 加入频道
+     * @details 该方法让用户加入频道，一个频道内可以加入多个用户进行互相通话。
+     * @details 一般在调用该方法前会根据场景先选择频道模式，通过调用 {@link setChannelProfile} 实现，默认频道模式为通信模式 {@link AliRtcSdkChannelProfile.AliRtcSdkCommunication}
+     * ``` javascript
+     * // 设置频道为互动模式
+     * engine.setChannelProfile(AliRtcSdkChannelProfile.AliRtcInteractivelive);
+     * // 设置角色为主播角色
+     * engine.setClientRole(AliRtcSdkClientRole.AliRtcSdkInteractive);
+     * ```
+     * @param {AliRtcAuthInfo} authInfo    认证信息，从App Server获取。
+     * @param {string} userName    任意用于显示的用户名称。不是User ID
+     * @note
+     *    - 异步接口，方法执行成功则为成功入会
+     *    - 正常情况一个Appid对应一个App，只有同一个AppId的应用可进行互相童话,不同AppId和channelID不同都不能互通
+     *    - 当入会成功后，会触发远端用户收到 {@link AliRtcEngineEventListener.remoteUserOnLineNotify} 回调
+     *    - 如果已在会中想重新入会，需要先调用 {@link leaveChannel} 离会，且确保方法执行成功
+     *    - 用户加入频道后，默认订阅频道内所有其他用户的音视频流，默认推送音视频流到远端，因此将会产生计费，如果想要取消默认订阅可以 {@link joinChannel} 前调用 {@link setDefaultSubscribeAllRemoteAudioStreams} 和 {@link setDefaultSubscribeAllRemoteVideoStreams}
+     */
+    joinChannel(authInfo: AliRtcAuthInfo, userName: string): Promise<void>;
+    /**
+     * 离开频道
+     * @param {boolean} bye 是否因为被挤占而离开房间
+     * @note 如果当前不在频道内，调用 leaveChannel 不会对实例产生任何影响，但会产生消息，通知频道内其他用户
+     */
+    leaveChannel(bye?: boolean): Promise<void>;
+    /**
+     * 检查当前是否在频道中
+     * @returns {boolean}
+     * - true：在频道中
+     * - false：不在频道中
+     */
+    isInCall(): boolean;
+    /**
+     * 刷新鉴权信息
+     * @param {AliRtcRefreshAuthInfo} authInfo
+     */
+    refreshAuthInfo(authInfo: AliRtcRefreshAuthInfo): Promise<void>;
+    /**
+     * 检查当前是否纯音频模式
+     * @returns {boolean}
+     * - true：纯音频模式
+     * - false：音视频模式
+     */
+    isAudioOnly(): boolean;
+    /**
+     * @brief 是否推送音频流
+     * @param enabled 是否开启/关闭本地音频流推送
+     *  - true: 开启音频流推送
+     *  - false: 关闭音频流推送
+     * @note SDK默认设置推送音频流，在加入频道前也可以调用此接口修改默认值，并在加入频道成功时生效
+     */
+    publishLocalAudioStream(enabled: boolean): Promise<void>;
+    /**
+     * @brief 查询是否设置推送音频流
+     * @return
+     *  - true: 已设置推送
+     *  - false: 未设置推送
+     * @note SDK默认设置推送音频流，如果需要取消推送音频流，可以通过 {@link publishLocalAudioStream}方法设置为不推送
+     */
+    isLocalAudioStreamPublished(): boolean;
+    /**
+     * 设置是否默认接收音频流
+     * @param sub
+     * - true: 接收用户的音频流
+     * - false: 停止接收用户的音频流
+     * @note 入会前入会后均可调用。如果在加入频道后调用 setDefaultSubscribeAllRemoteAudioStreams(false)，会接收不到设置后加入频道的用户的音频流。
+     * @note 停止接收音频流后，如果想要恢复接收，请调用 {@link subscribeRemoteAudioStream}，并指定你想要接收的远端用户ID；
+     * @note 如果想恢复接收多个用户的音频流，则需要多次调用 {@link subscribeRemoteAudioStream}。setDefaultSubscribeAllRemoteAudioStreams(true) 只能恢复接收后面加入频道的用户的音频流。
+     */
+    setDefaultSubscribeAllRemoteAudioStreams(sub: boolean): void;
+    /**
+     * 停止/恢复接收所有远端音频流
+     * @param sub
+     * - true: 接收所有用户的音频流
+     * - false: 停止接收所有用户的音频流
+     * @note 该接口作为订阅远端音频流的总开关，如果设置为false，则不仅当前会议中所有远端音频流都会停止订阅，后续入会的新用户也将不再订阅（即使设置了setDefaultSubscribeAllRemoteAudioStreams(true))
+     */
+    subscribeAllRemoteAudioStreams(sub: boolean): void;
+    /**
+     * 手动拉音频流
+     * @param uid uid
+     * @param sub，默认为 true
+     * - true: 接收指定用户的音频流
+     * - false: 停止接收指定用户的音频流
+     * @note 如果之前有调用过 subscribeAllRemoteAudioStreams(false) 对所有远端音频进行静音，在调用本 API 之前请确保你已调用 subscribeAllRemoteAudioStreams(true)。
+     * @note {@link subscribeAllRemoteAudioStreams} 是全局控制，{@link subscribeRemoteAudioStream} 是精细控制。
+     */
+    subscribeRemoteAudioStream(uid: string, sub: boolean): void;
+    /**
+     * 手动恢复远端用户音频流
+     * @param uid
+     * 用于在自动播放失败等场景恢复播放
+     */
+    resumeRemoteAudioStream(uid: string): void;
+    /**
+     * @brief 是否推送本地视频流
+     * @param enabled 是否开启/关闭本地视频流推送
+     * - true: 开启视频流推送
+     * - false: 关闭视频流推送
+     * @note SDK默认设置推送视频流，在加入频道前也可以调用此接口修改默认值，并在加入频道成功时生效
+     */
+    publishLocalVideoStream(enabled: boolean): Promise<void>;
+    /**
+     * @brief 查询是否设置推送视频流
+     * @return
+     *  - true: 已设置推送
+     *  - false: 未设置推送
+     * @note SDK默认设置推送视频流，如果需要取消推送视频流，可以通过 {@link publishLocalVideoStream} 方法设置为不推送
+     */
+    isLocalVideoStreamPublished(): boolean;
+    /**
+     * 设置默认订阅的相机流格式，大流或小流，会覆盖单人的大小流设置
+     * @param {AliRtcVideoStreamType} streamType 流类型
+     * @note 仅支持传入 1 （默认大流）、2（默认小流），传入其他无效
+     * @note 当无默认类型的相机流，但有另一个，将拉取另一个
+     */
+    setRemoteDefaultVideoStreamType(streamType: AliRtcVideoStreamType): void;
+    /**
+     * 设置某一用户默认订阅的相机流格式，大流或小流
+     * @param userId 远端用户ID
+     * @param {AliRtcVideoStreamType} streamType 流类型
+     * @note 仅支持传入 1 （默认大流）、2（默认小流），传入其他无效
+     * @note 当无默认类型的相机流，但有另一个，将拉取另一个
+     */
+    setRemoteUserVideoStreamType(userId: string, streamType: AliRtcVideoStreamType): void;
+    /**
+     * 设置是否默认接收视频流
+     * @param sub
+     * - true: 接收用户的视频流
+     * - false: 不接收用户的视频流
+     * @note 入会前入会后均可调用。如果在加入频道后调用 setDefaultSubscribeAllRemoteVideoStreams(false)，会接收不到设置后加入频道的用户的视频流。
+     * @note 停止接收视频流后，如果想要恢复接收，请调用 {@link subscribeRemoteVideoStream}，并指定你想要接收的远端用户ID；
+     * @note 如果想恢复接收多个用户的视频流，则需要多次调用 {@link subscribeRemoteVideoStream}；setDefaultSubscribeAllRemoteVideoStreams(true) 只能恢复接收后面加入频道的用户的视频流。
+     */
+    setDefaultSubscribeAllRemoteVideoStreams(sub: boolean): void;
+    /**
+     * 停止/恢复接收所有远端视频流
+     * @param sub
+     * - true: 接收所有用户的视频流
+     * - false: 停止接收所有用户的视频流
+     * @note 该接口作为订阅远端视频流的总开关，如果设置为false，则不仅当前会议中所有远端视频流都会停止订阅，后续入会的新用户也将不再订阅（即使设置了setDefaultSubscribeAllRemoteVideoStreams(true)）
+     */
+    subscribeAllRemoteVideoStreams(sub: boolean): void;
+    /**
+     * 合并订阅远端音视频流
+     * @param uid uid
+     * @param videoTrack 视频流类型
+     * @param subVideo 是否订阅视频
+     * @param subAudio 是否订阅音频
+     * @return
+     */
+    subscribeRemoteMediaStream(uid: string, videoTrack: AliRtcVideoTrack, subVideo: boolean, subAudio: boolean): void;
+    /**
+     * @brief 手动恢复远端用户视频流
+     * @param uid
+     * @param videoTrack
+     * 用于在自动播放失败等场景恢复播放
+     */
+    resumeRemoteMediaStream(uid: string, videoTrack: AliRtcVideoTrack): void;
+    /**
+     * @brief 订阅目标频道，指定用户的流
+     * @param channelId 目标频道
+     * @param uid 用户ID，从App server分配的唯一标示符
+     * @param track 订阅的视频流类型
+     * @param sub_audio 是否订阅远端用户的音频流
+     * - true:订阅指定用户的音频流
+     * - false:停止订阅指定用户的音频流
+     * @param sub 是否订阅远端用户的流
+     * - true:订阅指定用户的流
+     * - false:停止订阅指定用户的流
+     */
+    /**
+     * @brief 获取远端在线用户列表
+     * @return 当前频道内所有在线用户userid列表
+     * @note 若当前频道ChannelProfile设置为 {@link AliRtcSdkChannelProfile.AliRtcSdkInteractiveLive} 模式，只有设置角色为 {@link AliRtcSdkClientRole.AliRtcSdkInteractive} 的用户为在线用户，本方法不返回角色为 {@link AliRtcSdkClientRole.AliRtcSdkLive} 的用户
+     */
+    getOnlineRemoteUsers(): string[];
+    /**
+     * @brief 查询远端用户状态
+     * @details 通过 uid 查询指定远端用户的状态信息.
+     * @param uid 用户ID。从App server分配的唯一标示符
+     * @return 返回一个远端用户对象。详见{@link RemoteUser}
+     */
+    getUserInfo(uid: string): AliRtcRemoteUserInfo | undefined;
+    /**
+     * @brief 查询用户是否在线
+     * @param uid 用户ID，从App server分配的唯一标示符。不可为NULL
+     * @return
+     *  - true: 用户在线
+     *  - false: 用户不在线
+     * @note 根据特定的UserID，查询该用户是否在线。
+     */
+    isUserOnline(uid: string): boolean;
+    /**
+     * @brief 开始屏幕共享
+     * @param config 开启屏幕共享的配置
+     * @note 可以通过 config 选择是否开启音频或使用外部自定义 MediaStream
+     * @note 自定义 MediaStream 仅支持一个视频流和一个音频流
+     */
+    startScreenShare(config?: AliRtcScreenShareStartConfig): Promise<void>;
+    /**
+     * @brief 停止屏幕共享
+     */
+    stopScreenShare(): Promise<void>;
+    /**
+     * @brief 设置屏幕流视频编码属性
+     * @details 该方法用于设置屏幕流视频编码属性对应的视频参数，如分辨率、帧率、码率、等 所有设置的参数都有相应的范围限制，如果设置的参数不在有效范围内，SDK会自动调节
+     * @param config 预定义的屏幕共享编码属性，
+     * @note
+     * - 该方法在入会前和入会后都可以调用，如果每次入会只需要设置一次屏幕流视频编码属性，建议在入会前调用
+     */
+    setScreenShareConfiguration(config: AliRtcScreenShareConfiguration): Promise<void>;
+    /**
+     * @breif 设置屏幕流采集内容提示
+     * @param contentHint 设置屏幕流内容提示，用于提升在不同内容场景下的视频编码质量 [参考文档](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/contentHint)
+     */
+    setScreenShareContentHint(contentHint: string): Promise<void>;
+    /**
+     * @brief 是否推送屏幕分享
+     * @param enabled 是否开启/关闭本地屏幕分享推送
+     *  - true: 开启屏幕分享推送
+     *  - false: 关闭屏幕分享推送
+     * @param config 开启屏幕共享的配置
+     * @note SDK默认设置推送屏幕分享，在加入频道前也可以调用此接口修改默认值，并在加入频道成功时生效
+     */
+    publishLocalScreenShareStream(enabled: boolean, config?: AliRtcScreenShareStartConfig): Promise<void>;
+    /**
+     * @brief 查询是否设置推送屏幕分享
+     * @return
+     - true: 已设置推送
+     - false: 未设置推送
+     * @note SDK默认设置不推送屏幕分享，如果需要推送屏幕共享，可以通过{@link startScreenShare}方法开启屏幕共享推送
+     */
+    isScreenSharePublished(): boolean;
+    /**
+     * @brief 设置共享音频的音量大小
+     * @param volume 共享音频音量大小,取值范围[0, 100]
+     */
+    setAudioShareVolume(volume: number): void;
+    /**
+     * 开启音量检测功能
+     * @param {number} interval 检测间隔，单位: ms
+     * @note 建议设置为300ms~500ms,取值 ≤0 表示不启用音量检测功能
+     */
+    enableAudioVolumeIndication(interval: number): void;
+    /**
+     * 停止/恢复本地音频数据发送
+     * @param {boolean} mute 停止或恢复本地音频数据发送
+     * - true：静音本地音频
+     * - false（默认值）：取消静音
+     */
+    muteLocalMic(mute?: boolean): void;
+    /**
+     * 停止/恢复远端指定用户的音频流的播放
+     * @param {string} uid 用户ID, 从 App server 分配的唯一标示符
+     * @param {boolean} mute 停止或恢复远端的音频播放
+     * - true：停止播放
+     * - false（默认值）：恢复播放
+     * @note 拉流和解码不受影响，支持 {@link joinChannel} 之前和之后设置
+     */
+    muteRemoteAudioPlaying(uid: string, mute?: boolean): void;
+    /**
+     * 停止/恢复远端的所有音频流的播放
+     * @param {boolean} mute 停止或恢复远端的音频播放
+     * - true：停止播放
+     * - false（默认值）：恢复播放
+     * @note 拉流和解码不受影响，支持 {@link joinChannel} 之前和之后设置
+     */
+    muteAllRemoteAudioPlaying(mute?: boolean): void;
+    /**
+     * @brief 开启音频采集
+     * @details 此接口可以控制提前打开音频采集，如果不设置，则SDK会自动控制音频采集设备：
+     * - 如果打开推送音频流{@link publishLocalAudioStream}，SDK在入会后会打开音频采集
+     * - 如果关闭推送音频流{@link publishLocalAudioStream}，SDK在入会后不会打开音频采集
+     * @param {IAudioConstraints} audioConstraints 音频采集参数
+     */
+    startAudioCapture(audioConstraints?: IAudioConstraints): Promise<void>;
+    /**
+     * 关闭音频采集
+     * @note 调用此接口后，入会后、离会再入会，采集设备保持关闭状态
+     */
+    stopAudioCapture(): void;
+    /**
+     * 切换麦克风
+     * @param {string} deviceId 麦克风设备ID
+     * @param {MediaStreamAudioTrack} audioTrack 音频轨道
+     * @note 传入 audioTrack 则会使用传入的音频轨道
+     */
+    switchMicrophone(deviceId: string, audioTrack?: MediaStreamAudioTrack): Promise<void>;
+    /**
+     * 设置录音音量
+     * @param {VolumeSettings} volumeSettings 录音音量，取值范围[0,100]
+     * - 0：静音
+     * - <100：减小音量
+     * - >100：放大音量
+     */
+    setRecordingVolume(volume: number): void;
+    /**
+     * 设置麦克风 profile
+     *
+     * @param {AudioProfileKey} profileKey
+     * @return {Promise<void>}
+     */
+    setAudioProfile(profileKey: AudioProfileKey): Promise<void>;
+    /**
+     * @brief 获取当前用户或远端用户的音频轨道
+     * @param {string} userId 远端用户 userId
+     * @return {MediaStreamTrack} 音频轨道
+     *
+     */
+    getAudioTrack(userId?: string): Promise<MediaStreamTrack | undefined>;
+    /**
+     * 为本地预览设置渲染元素和视频流
+     * @param {AliRtcLocalView} view 渲染元素，null 则为停止显示
+     * @param {AliRtcVideoTrack} track 视频流类型
+     */
+    setLocalViewConfig(view: AliRtcLocalView, track: AliRtcVideoTrack): Promise<void>;
+    /**
+     * @brief 采集偏好设置
+     * @param cameraCapturerConfiguration 偏好设置
+     *      - videoProfile: videoProfileKey 或 IProfile
+     *      - cameraDirection: 设置采集方向，前置或后置摄像头
+     *      - deviceId: 设置采集相机ID
+     */
+    setCameraCapturerConfiguration(cameraCapturerConfiguration: AliEngineCameraCapturerConfiguration): Promise<void>;
+    /**
+     * @breif 设置摄像头采集内容提示
+     * @param contentHint 设置视频内容提示，用于提升在不同内容场景下的视频编码质量 [参考文档](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/contentHint)
+     */
+    setCameraCapturerContentHint(contentHint: string): Promise<void>;
+    /**
+     * 禁用或启用摄像头采集
+     * @param enabled
+     * - true : 启用摄像头采集
+     * - false : 禁用摄像头采集
+     */
+    enableLocalVideo(enabled?: boolean): Promise<void>;
+    /**
+     * 是否将停止摄像头流数据发送
+     * @param mute
+     * - true：停止发送摄像头流数据
+     * - false：表示恢复正常
+     */
+    muteLocalCamera(mute: boolean): Promise<void>;
+    /**
+     * 是否将停止屏幕共享流数据发送
+     * @param mute
+     * - true：停止发送屏幕共享流数据
+     * - false：表示恢复正常
+     */
+    muteLocalScreen(mute: boolean): Promise<void>;
+    /**
+     * 设置远端视频显示视图
+     * @param {AliRtcLocalView} view 渲染元素
+     * @param {AliRtcVideoTrack} track 视频流类型
+     * @param {string} uid 用户ID, 从App server分配的唯一标示符
+     * @note 支持joinChannel之前和之后切换窗口。如果 view 传入 null，则停止显示
+     */
+    setRemoteViewConfig(view: AliRtcLocalView, uid: string, track: AliRtcVideoTrack): void;
+    /**
+     * 检查camera是否打开
+     * @return {boolean}
+     * - true: 摄像头已打开
+     * - false: 摄像头没有打开
+     * @note 该接口用于检查当前camera的状态
+     */
+    isCameraOn(): boolean;
+    /**
+     * 切换摄像头
+     * @param {string} deviceId 摄像头设备ID
+     * @param {MediaStreamVideoTrack} videoTrack 视频流
+     * @note 若不传 deviceId 则前后摄像头切换，传入 videoTrack 则会使用传入的 videoTrack
+     */
+    switchCamera(deviceId?: string, videoTrack?: MediaStreamVideoTrack): Promise<void>;
+    /**
+     * 获取摄像头设备ID
+     * @return {string} 摄像头设备ID
+     */
+    getCurrentCameraDeviceId(): string | undefined;
+    /**
+     * @brief 开启摄像头预览
+     * @details 开启摄像头预览并自动打开摄像头
+     * @note 如果没有调用{@link setLocalViewConfig}设置显示的view，则无法预览，但不影响推流。
+     * 可以在{@link joinChannel}之前就开启预览会自动打开摄像头。
+     */
+    startPreview(): Promise<void>;
+    /**
+     * @brief 开启屏幕共享预览
+     * @details 开启屏幕共享预览并自动打开屏幕共享
+     * @param config 开启屏幕共享的配置
+     * @note 如果没有调用{@link setLocalViewConfig}设置显示的view，则无法预览，但不影响推流。
+     * 可以在{@link joinChannel}之前就开启预览会自动打开屏幕共享。
+     */
+    startPreviewScreen(config?: AliRtcScreenShareStartConfig): Promise<void>;
+    /**
+     * @brief 停止本地视频预览
+     */
+    stopPreview(): Promise<void>;
+    /**
+     * @brief 停止本地屏幕共享预览
+     */
+    stopPreviewScreen(): Promise<void>;
+    /**
+     * @brief 获取当前用户或远端用户的视频轨道
+     * @param {AliRtcVideoTrackConfig} config 视频轨道配置
+     * @return {MediaStreamTrack} 视频轨道
+     *
+     */
+    getVideoTrack(config: AliRtcVideoTrackConfig): Promise<MediaStreamTrack | undefined>;
+    /**
+     * @brief 开启旁路直播
+     * @details SDK提供了开启旁路直播的功能，可以把实时音视频流经过混流、混音处理转为标准直播流并推送至指定CDN供应商
+     * @param streamUrl 推流地址
+     * @param transcoding 推流所需参数, 详细定义见{@link AliRtcLiveTranscodingParam}
+     */
+    startPublishLiveStream(streamUrl: string, transcoding: AliRtcLiveTranscodingParam): Promise<any>;
+    /**
+     * @brief 更新旁路直播相关参数
+     * @details SDK提供了更新旁路直播的功能，用于实时更新旁路直播参数
+     * @param streamUrl 推流地址
+     * @param transcoding 推流所需参数, 详细定义见{@link AliRtcLiveTranscodingParam}
+     */
+    updatePublishLiveStream(streamUrl: string, transcoding: AliRtcLiveTranscodingParam): Promise<any>;
+    /**
+     * @brief 更新旁路直播相关参数
+     * @details SDK提供了更新旁路直播的功能，用于实时更新旁路直播参数
+     * @param taskId 任务Id
+     * @param transcoding 推流所需参数, 详细定义见{@link AliRtcLiveTranscodingParam}
+     * @return
+     * - 0 : 成功
+     * - 非0 : 失败
+     *   - ERR_INNER(-1) : SDK内部错误，可能的情况为SDK未初始化或者SDK销毁后调用
+     *   - 其他 : 返回值参考官网错误码
+     */
+    updatePublishLiveStreamWithTaskId(taskId: string, transcoding: AliRtcLiveTranscodingParam): Promise<any>;
+    /**
+     * @brief 停止旁路直播
+     * @details SDK提供了停止旁路直播的功能
+     * @param streamUrl 推流地址
+     */
+    stopPublishLiveStream(streamUrl: string): Promise<any>;
+    /**
+     * @brief 停止旁路直播
+     * @details SDK提供了停止旁路直播的功能
+     * @param taskId 任务Id
+     */
+    stopPublishLiveStreamWithTaskId(taskId: string): Promise<any>;
+    /**
+     * 获取旁路直播状态
+     * @param streamUrl 推流地址
+     * @return 路直播状态
+     */
+    /**
+     * @brief 设置是否启用媒体扩展信息
+     * @param enabled 是否启用媒体扩展，需要在加入房间之前调用
+     */
+    setEnableMediaExtensionMsg(enabled: boolean): void;
+    /**
+     * @brief 发送媒体扩展信息
+     * @details SDK提供了发送和接收媒体扩展信息的功能，接收端参考 {@link AliRtcEngineEventListener.mediaExtensionMsgReceived}，使用场景：
+     * - 使用媒体扩展信息传递时间戳，计算端到端的网络延迟，或者跟自身其他业务做数据同步
+     * - 使用媒体扩展信息传递描述信息。目前可以传递最多 4k Byte数据，可以用来传输少量数据，建议使用Json或者纯字符串；
+     * - 内部使用SEI扩展协议来实现；
+     *
+     * @param message 媒体扩展信息，长度限制为最大4K字节
+     * @param repeatCount 重复次数，代表消息冗余度，用于防止网络丢包导致的消息丢失，-1为无限传输
+     *
+     * @note 启用此能力会增加客户端性能开销，如有需求需要在加入房间之前调用 setEnableMediaExtensionMsg
+     * @note 使用媒体扩展信息时需要复用音视频数据通道，因此必须控制自定义消息的发送频率和消息数据长度，使用限制如下：
+     * - 每秒最多发送profile条消息，因为sei信息是放到h264/h265流中传输，有视频帧编码才能附加扩展信息；
+     * - 为了不影响媒体数据的传输质量，自定义消息体长度限制为4k Byte，可以用来传输少量信息；
+     * - sendMediaExtensionMsg函数中repeatCount参数为自定义消息冗余度，若大于1，则会发送多次，
+     * - 防止网络丢包导致的消息丢失，此时房间里的其他人也会收到多次相同的消息，需要去重
+     * - 发送的自定义消息，在旁路直播时，房间里的订阅者也一样会收到
+     * - 同一时间只有一条MediaExtensionMsg在传输，多次调用sendMediaExtensionMsg，新调用的数据会覆盖前一次的数据；
+     */
+    sendMediaExtensionMsg(message: ArrayBuffer, repeatCount: number): Promise<void>;
+    /**
+     * @brief 发送媒体扩展信息
+     * @details SDK提供了发送和接收媒体扩展信息的功能，接收端参考 {@link AliRtcEngineEventListener.mediaExtensionMsgReceived}，使用场景：
+     * - 使用媒体扩展信息传递时间戳，计算端到端的网络延迟，或者跟自身其他业务做数据同步
+     * - 使用媒体扩展信息传递描述信息。目前可以传递最多 4k Byte数据，可以用来传输少量数据，建议使用Json或者纯字符串；
+     * - 内部使用SEI扩展协议来实现；
+     *
+     * @param message 媒体扩展信息，长度限制为最大4K字节
+     * @param repeatCount 重复次数，代表消息冗余度，用于防止网络丢包导致的消息丢失，-1为无限传输
+     * @param payloadType [5, 100..254]范围 payloadType=5等于使用sendMediaExtensionMsg 接口
+     *
+     * @note 启用此能力会增加客户端性能开销，如有需求需要在加入房间之前调用 setEnableMediaExtensionMsg
+     * @note 使用媒体扩展信息时需要复用音视频数据通道，因此必须控制自定义消息的发送频率和消息数据长度，使用限制如下：
+     * - 每秒最多发送profile条消息，因为sei信息是放到h264/h265流中传输，有视频帧编码才能附加扩展信息；
+     * - 为了不影响媒体数据的传输质量，自定义消息体长度限制为4k Byte，可以用来传输少量信息；
+     * - sendMediaExtensionMsg函数中repeatCount参数为自定义消息冗余度，若大于1，则会发送多次，
+     * - 防止网络丢包导致的消息丢失，此时房间里的其他人也会收到多次相同的消息，需要去重
+     * - 发送的自定义消息，在旁路直播时，房间里的订阅者也一样会收到
+     * - 同一时间只有一条MediaExtensionMsg在传输，多次调用sendMediaExtensionMsg，新调用的数据会覆盖前一次的数据；
+     */
+    sendMediaExtensionMsgEx(message: ArrayBuffer, repeatCount: number, payloadType: number): Promise<void>;
+    static Plugin: typeof AliRtcPlugin;
+    /**
+     * @brief 开启音视频处理算法插件
+     * @details RTC采用插件件形式提供音视频增强及特效能力，可通过[官网组件文档](https://help.aliyun.com/document_detail/261183.html) 进行组件下载，参考插件集成文档集成进RTC引擎；
+     * @param plugin 插件库
+     * @param option 插件初始化参数值，请阅读插件库接入文档
+     * @note
+     * - 入会前入会后均可调用；
+     * - 如果重复调用会报错；
+     */
+    enablePlugin(plugin: AliRtcPlugin, options?: any): void;
+    /**
+     * @brief 关闭音视频处理算法插件
+     * @param name 插件名称，通过 plugin.name 获取
+     * @note
+     *  - 入会前入会后均可调用；
+     *  - 重复调用返回错误；
+     */
+    removePlugin(name: string): void;
+    /**
+     * @brief 根据插件ID设置插件
+     * @param name 插件名称，通过 plugin.name 获取
+     * @param option 插件初始化参数值，请阅读插件库接入文档
+     */
+    setPluginOption(name: string, option: any): void;
+    /**
+     * @brief 根据插件ID获取插件内部信息
+     * @param name 插件名称，通过 plugin.name 获取
+     */
+    getPluginOption(name: string): any;
+    /**
+     * 美颜功能是否有效
+     * @return
+     * - true: 美颜功能有效
+     * - false: 无效
+     */
+    isBeautyAvailable(): boolean;
+    /**
+     * 美颜功能是否开启
+     * @return
+     * - true: 美颜功能已开启
+     * - false: 已关闭
+     */
+    isBeautyEnabled(): boolean;
+    /**
+     * @brief 开启或关闭美颜功能, 并设置美颜效果参数
+     * @param enable
+     * - true: 开启美颜功能
+     * - false: 关闭美颜功能
+     * @param config 美颜效果参数
+     */
+    setBeautyEffect(enable: boolean, config: AliRtcBeautyConfig): void;
+    /**
+     * @brief 开启/关闭虚拟背景替换功能
+     * @details 需要集成美颜插件；
+     * @param enable 是否开启；
+     * @param path 虚拟背景本地图片路径，支持JPG，PNG 格式；
+     *
+     * @note
+     * - 与背景虚化为替换关系，如开启虚拟背景开关后再次开启背景虚化，则只有背景虚化效果；
+     */
+    enableBackgroundExchange(enable: boolean, path: string): void;
+    /**
+     * @brief 开启/关闭虚拟背景虚化功能
+     * @details 需要集成美颜插件；
+     *  需要集成美颜插件，背景替换与背景虚化不可同时使用，如开启虚拟背景开关后再次开启背景虚化，则只有背景虚化效果；
+     * @param enable 是否开启；
+     *
+     * @note
+     * - 与虚拟背景为替换关系，如开启背景虚化开关后再次开启虚拟背景，则只有虚拟背景效果；
+     */
+    enableBackgroundBlur(enable: boolean): void;
+}
+
+declare interface AliRtcEngineConfig {
+    env?: AliRtcEnv;
+    webTrack?: boolean | AliRtcWebTrackConfig;
+    maxSignalingConnectRetryCount?: number;
+}
+
+declare interface AliRtcEngineEventListener {
+    /**
+     * @brief 网络连接状态改变
+     * @param status 连接状态
+     * @param reason 连接状态变化原因
+     */
+    connectionStatusChange: (status: AliRtcConnectionStatus, reason: AliRtcConnectionStatusChangeReason) => void;
+    /**
+     * @brief 本地设备异常回调
+     * @param deviceType 设备类型, 参考{@link AliRtcEngine.AliRtcEngineLocalDeviceType}
+     * @param exceptionType 设备异常类型, 参考{@link AliRtcEngine.AliRtcEngineLocalDeviceExceptionType}
+     * @param msg 异常时携带的信息
+     * @note 此回调标识了内部无法恢复了设备异常，收到此回调时用户需要检查设备是否可用
+     */
+    localDeviceException: (localDeviceType: AliRtcEngineLocalDeviceType, localDeviceExceptionType: AliRtcEngineLocalDeviceExceptionType, description: string) => void;
+    /**
+     * @brief 用户鉴权信息即将过期通知，收到后30秒鉴权过期
+     * @note 该回调在鉴权信息30秒前触发，收到该回调后应该及时更新鉴权信息，参考 {@link AliRtcEngine.refreshAuthInfo}
+     */
+    /**
+     * 被服务器踢出/会议结束频道的消息
+     * @param code 原因参考{@link AliRtcEngine.AliRtcOnByeType}
+     */
+    bye: (code: AliRtcOnByeType) => void;
+    /**
+     * @brief 远端用户（通信模式）/（互动模式，主播角色）加入频道回调
+     * @details 该回调在以下场景会被触发
+     * - 通信模式：远端用户加入频道会触发该回调，如果当前用户在加入频道前已有其他用户在频道中，当前用户加入频道后也会收到已加入频道用户的回调
+     * - 互动模式：
+     *   - 远端主播角色用户加入频道会触发该回调，如果当前用户在加入频道前已有其他主播在频道中，当前用户加入频道后也会收到已加入频道主播的回调
+     *   - 远端观众角色调用 {@link AliRtcEngine.setClientRole} 切换为主播角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkInteractive}，同时设置了推流时，会触发该回调
+     *
+     * @param uid 用户ID，从App server分配的唯一标示符
+     * @param elapsed 用户加入频道时的耗时
+     * @note 互动模式下回调行为
+     * - 主播间可以互相收到加入频道回调
+     * - 观众可以收到主播加入频道回调
+     * - 主播无法收到观众加入频道回调
+     */
+    remoteUserOnLineNotify: (uid: string, elapsed: number) => void;
+    /**
+     * @brief 远端用户（通信模式）/（互动模式，主播角色）离开频道回调
+     * @details 该回调在以下场景会被触发
+     * - 通信模式：远端用户离开频道会触发该回调
+     * - 互动模式：
+     *   - 远端主播角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkInteractive} 离开频道
+     *   - 远端主播切换调用 {@link AliRtcEngine.setClientRole} 切换为观众角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkLive}，会触发该回调
+     * - 通信模式和互动模式主播角色情况下，当长时间收不到远端用户数据，超时掉线时，会触发该回调
+     *
+     * @param uid 用户ID，从App server分配的唯一标示符
+     * @param reason 用户离线的原因，详见 {@link AliRtcEngine.AliRtcUserOfflineReason}
+     */
+    remoteUserOffLineNotify: (uid: string, aliRtcUserOfflineReason: AliRtcUserOfflineReason) => void;
+    /**
+     * @brief 远端用户的音视频流发生变化回调
+     * @details 该回调在以下场景会被触发
+     * - 当远端用户从未推流变更为推流（包括音频和视频）
+     * - 当远端用户从已推流变更为未推流（包括音频和视频）
+     * - 互动模式下，调用 {@link AliRtcEngine.setClientRole} 切换为主播角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkInteractive}，同时设置了推流时，会触发该回调
+     *
+     * @param uid 用户ID，从App server分配的唯一标示符
+     * @param audioTrack 音频流类型，详见 {@link AliRtcEngine.AliRtcAudioTrack}
+     * @param videoTrack 视频流类型，详见 {@link AliRtcEngine.AliRtcVideoTrack}
+     * @note 该回调仅在通信模式用户和互动模式下的主播角色才会触发
+     */
+    remoteTrackAvailableNotify: (uid: string, aliRtcAudioTrack: AliRtcAudioTrack, aliRtcVideoTrack: AliRtcVideoTrack) => void;
+    /**
+     * @brief 远端用户静音/取消静音回调
+     * @param uid 远端用户ID
+     * @param isMute 该用户是否静音
+     * - true: 静音
+     * - false: 取消静音
+     */
+    userAudioMuted: (uid: string, isMute: boolean) => void;
+    /**
+     * @brief 对端用户发送视频黑帧数据发送通知
+     * @param uid 执行muteVideo的用户ID
+     * @param isMute
+     * - true: 推流黑帧
+     * - false: 正常推流
+     * @note 该接口用于对端用户发送视频黑帧数据时的回调
+     */
+    userVideoMuted: (uid: string, isMute: boolean) => void;
+    /**
+     * @brief 对端用户发送屏幕黑帧数据发送通知
+     * @param uid 执行muteVideo的用户ID
+     * @param isMute
+     * - true: 推流黑帧
+     * - false: 正常推流
+     * @note 该接口用于对端用户发送屏幕黑帧数据时的回调
+     */
+    userScreenMuted: (uid: string, isMute: boolean) => void;
+    /**
+     * 音量反馈
+     * @param {Array} speakers 用户音量对象数组
+     * @param {string} speaker.userId 用户ID
+     * @param {number} speaker.volume 音量
+     * @note userId 为空字符串时代表是本地麦克风采集的音量
+     */
+    audioVolume: (speakers: {
+        userId: string;
+        volume: number;
+    }[]) => void;
+    /**
+     * 发布视频流的数据统计
+     * @param aliRtcStats 统计信息
+     */
+    aliRtcStats: (aliRtcStats: any) => void;
+    /**
+     * 音频推流变更回调
+     * @param track 流标识
+     * @param oldState 之前的推流状态
+     * @param newState 当前的推流状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
+     */
+    audioPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
+    /**
+     * 音频订阅情况变更回调
+     * @param uid 用户ID
+     * @param oldState 之前的订阅状态
+     * @param newState 当前的订阅状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
+     */
+    audioSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    /**
+     * 视频推流变更回调
+     * @param oldState 之前的推流状态
+     * @param newState 当前的推流状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
+     */
+    videoPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
+    /**
+     * 次要流推流变更回调
+     * @param oldState 之前的推流状态
+     * @param newState 当前的推流状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
+     */
+    dualStreamPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
+    /**
+     * 屏幕分享推流变更回调
+     * @param oldState 之前的推流状态
+     * @param newState 当前的推流状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
+     */
+    screenSharePublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
+    /**
+     * 相机流订阅情况变更回调
+     * @param uid 用户ID
+     * @param oldState 之前的订阅状态
+     * @param newState 当前的订阅状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
+     */
+    videoSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    /**
+     * 大小流订阅情况变更回调
+     * @param uid 用户ID
+     * @param oldStreamType 之前的订阅状态
+     * @param newStreamType 当前的订阅状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
+     */
+    subscribeStreamTypeChanged: (uid: string, oldStreamType: AliRtcVideoStreamType, newStreamType: AliRtcVideoStreamType, elapseSinceLastState: number, channel: string) => void;
+    /**
+     * 屏幕分享流订阅情况变更回调
+     * @param uid 用户ID
+     * @param oldState 之前的订阅状态
+     * @param newState 当前的订阅状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
+     */
+    screenShareSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    /**
+     * 收到媒体扩展信息回调
+     * @param uid 用户ID，媒体信息发送用户的ID
+     * @param message 媒体扩展信息
+     * @param payloadType payload类型，sendMediaExtensionMsg返回5，sendMediaExtensionMsgEx发送的会返回具体类型
+     * @note 当一端通过 {@link AliRtcEngine.sendMediaExtensionMsg} 发送信息后，其他端通过该回调接收数据
+     */
+    mediaExtensionMsgReceived: (uid: string, message: ArrayBuffer, payloadType: number) => void;
+    /**
+     * @brief 用户鉴权信息即将过期通知，收到后30秒鉴权过期
+     * @note 该回调在鉴权信息30秒前触发，收到该回调后应该及时更新鉴权信息，参考 {@link AliRtcEngine.refreshAuthInfo:}
+     */
+    authInfoWillExpire: () => void;
+    /**
+     * @brief 用户调用需要鉴权的接口，服务端返回信息过期
+     * @note 该回调触发代表鉴权信息已过期，想要继续在会中，需要重新入会，参考 {@link AliRtcEngine.joinChannel:name:onResultWithUserId:}
+     */
+    authInfoExpired: () => {};
+    /**
+     * 远程用户的音频自动播放失败
+     * @param uid
+     * @note 应该在收到该回调时弹出弹窗引导用户点击页面进行播放，用户点击页面后 SDK 会自动尝试播放
+     */
+    remoteAudioAutoPlayFail: (uid: string) => void;
+    /**
+     * 远程用户的视频自动播放失败
+     * @param uid
+     * @note 应该在收到该回调时弹出弹窗引导用户点击页面进行播放，用户点击页面后 SDK 会自动尝试播放
+     */
+    remoteVideoAutoPlayFail: (uid: string, videoTrack: AliRtcVideoTrack) => void;
+    /**
+     * 发布视频流的数据统计
+     * @param aliRtcStats 统计信息
+     */
+    rtcLocalVideoStats: (stats: AliRtcLocalVideoStats[]) => void;
+    /**
+     * 发布音频流的数据统计
+     * @param aliRtcStats 统计信息
+     */
+    rtcLocalAudioStats: (stats: AliRtcLocalAudioStats[]) => void;
+    /**
+     * 订阅视频流的数据统计
+     * @param aliRtcStats 统计信息
+     */
+    rtcRemoteVideoStats: (stats: AliRtcRemoteVideoStats[]) => void;
+    /**
+     * 订阅远端音频流的数据统计
+     * @param aliRtcStats 统计信息
+     */
+    rtcRemoteAudioStats: (stats: AliRtcRemoteAudioStats[]) => void;
+    /**
+     * @brief 错误通知
+     * @details 如果engine出现error，通过这个回调通知app
+     * @param error  错误类型，参考 {@link org::webrtc::alirtcInterface::ErrorCodeEnum}
+     * @param message 错误消息
+     */
+    onOccurError: (error: AliRtcError) => void;
+}
+
+export declare enum AliRtcEngineLocalDeviceExceptionType {
+    /** 未知异常类型 */
+    AliEngineLocalDeviceExceptionTypeUnknown = 0,
+    /** 麦克风打开失败 */
+    AliEngineLocalDeviceExceptionTypeMicOpenFail = 1,
+    /** 麦克风被打断 */
+    AliEngineLocalDeviceExceptionTypeMicInterrupt = 2,
+    /** 麦克风无权限 */
+    AliEngineLocalDeviceExceptionTypeMicAuthFail = 3,
+    /** 无可用麦克风 */
+    AliEngineLocalDeviceExceptionTypeMicNotAvailable = 4,
+    /** 扬声器打开失败 */
+    AliEngineLocalDeviceExceptionTypeSpeakerOpenFail = 5,
+    /** 扬声器被打断 */
+    AliEngineLocalDeviceExceptionTypeSpeakerInterrupt = 6,
+    /** 无可用扬声器 */
+    AliEngineLocalDeviceExceptionTypeSpeakerNotAvailable = 7,
+    /** 音频设备异常 */
+    AliEngineLocalDeviceExceptionTypeAudioDeviceException = 8,
+    /** 摄像头打开失败 */
+    AliEngineLocalDeviceExceptionTypeCameraOpenFail = 9,
+    /** 摄像头被打断 */
+    AliEngineLocalDeviceExceptionTypeCameraInterrupt = 10,
+    /** 摄像头无权限 */
+    AliEngineLocalDeviceExceptionTypeCameraAuthFail = 11,
+    /** 显示设备异常 */
+    AliEngineLocalDeviceExceptionTypeDisplayException = 12,
+    /** 视频设备异常 */
+    AliEngineLocalDeviceExceptionTypeVideoDeviceException = 13
+}
+
+export declare enum AliRtcEngineLocalDeviceType {
+    /** 未知设备类型 */
+    AliEngineLocalDeviceTypeUnknown = 0,
+    /** 麦克风设备 */
+    AliEngineLocalDeviceTypeMic = 1,
+    /** 扬声器设备 */
+    AliEngineLocalDeviceTypeSpeaker = 2,
+    /** 音频设备 */
+    AliEngineLocalDeviceTypeAudioDevice = 3,
+    /** 摄像头设备 */
+    AliEngineLocalDeviceTypeCamera = 4,
+    /** 显示设备 */
+    AliEngineLocalDeviceTypeDisplay = 5,
+    /** 视频设备 */
+    AliEngineLocalDeviceTypeVideoDevice = 6
+}
+
+declare enum AliRtcEnv {
+    pre = "pre",
+    prod = "prod"
+}
+
+declare class AliRtcError extends Error {
+    _code: number;
+    _extra?: any;
+    static fromError(error: any, code?: number, fallbackMessage?: string): AliRtcError;
+    constructor(code: number, message: string, extra?: any);
+    get code(): number;
+    set code(code: number);
+    get reason(): string;
+    get extra(): any;
+}
+
+export declare enum AliRtcErrorCode {
+    /****************************************************
+     * 入会错误码
+     ****************************************************/
+    /** 已经加入频道 */
+    ERR_JOIN_ALREADY_JOINED = 16843521,
+    /** AppId不存在，请在控制台创建应用 */
+    ERR_JOIN_BAD_APPID = 33620481,
+    /** AppId已失效，请在控制台重新启用应用 */
+    ERR_JOIN_INVALID_APPID = 33620482,
+    /**
+     * 频道不存在，请尝试重新加入频道
+     * 如会议发起者入会后又很快离会，第二个人随后入会，发现会议已经不存在了。
+     */
+    ERR_JOIN_BAD_CHANNEL = 33620484,
+    /** 频道已经失效（目前频道有效期为48小时），请重新生成频道鉴权令牌（Token） */
+    ERR_JOIN_INVALID_CHANNEL = 33620483,
+    /** Token无效。 请重新生成频道鉴权令牌（Token） */
+    ERR_JOIN_BAD_TOKEN = 33620485,
+    /** 加入频道超时，请检查网络连接是否正常 */
+    ERR_JOIN_TIMEOUT = 16908804,
+    /** 参数错误，{@link AliRtcAuthInfo}中的字段为空或者timestamp<=0，请检查字段是否完整 */
+    ERR_JOIN_ERR_JOIN_BAD_PARAMBAD = 16974081,
+    /** 加入频道失败 */
+    ERR_JOIN_CHANNEL_FAILED = 16974338,
+    /****************************************************
+     * 日志模块错误码
+     ****************************************************/
+    /** 日志模块已经初始化 */
+    ERR_LOG_ALREADY_INIT = 16974085,
+    /** 日志模块根路径错误，请检查路径是否存在或路径是否具有写入权限 */
+    ERR_LOG_ROOT_PATH_ERROR = 16974086,
+    /****************************************************
+     * 音频设备错误码
+     ****************************************************/
+    /**
+     * 采集设备初始化失败、采集设备媒体服务异常、音频设备被占用。
+     * - Mac端和Windows端查看系统设置中音频设备是否有能量条
+     * - iOS端和Android端确认是否被其他应用占用
+     * - 如果都正常，请重启设备
+     */
+    ERR_MIC_OPEN_FAIL = 17040388,
+    /**
+     * 播放设备初始化失败、播放设备媒体服务异常、音频设备被占用。
+     * - Mac端和Windows端查看系统设置中音频设备是否有能量条
+     * - iOS端和Android端确认是否被其他应用占用
+     * - 如果都正常，请重启设备
+     */
+    ERR_SPEAKER_OPEN_FAIL = 17040389,
+    /** 系统性能不足、采集设备媒体服务异常、音频设备被占用。建议重启应用或重启设备 */
+    ERR_MIC_INTERRUPT = 17040390,
+    /** 系统性能不足，播放设备媒体服务异常，音频设备被占用。建议重启应用或重启设备 */
+    ERR_SPEAKER_INTERRUPT = 17040391,
+    /** 麦克风设备未授权，建议去系统设置中，打开麦克风授权，并且重新加入频道 */
+    ERR_MIC_AUTH_FAIL = 17040392,
+    /** 无可用的音频采集设备，检查是否接入了可用的麦克风，并检查系统设置中，该设备是否被禁用 */
+    ERR_MIC_NOT_AVAILABLE = 17040393,
+    /** 无可用的音频播放设备，检查是否接入了可用的扬声器或耳机，并检查系统设置中，该设备是否被禁用 */
+    ERR_SPEAKER_NO_AVAILABLE = 17040400,
+    /****************************************************
+     * 视频设备错误码
+     ****************************************************/
+    /** 采集设备初始化失败，检查系统相机是否可用，移动端App是否占用了相机 */
+    ERR_CAMERA_OPEN_FAIL = 17039620,
+    /** 采集过程中出现异常，Mac、Winodows电脑相机采集灯熄灭，设备被强制中断。建议重新加入频道或者重启App */
+    ERR_CAMERA_INTERRUPT = 17039622,
+    /** 渲染设备初始化失败，检查Windows端显卡驱动是否需要升级，移动端手机型号或者Android平板盒子等外设是否支持OpenGL */
+    ERR_VIDEO_DISPLAY_OPEN_FAIL = 17039873,
+    /** 渲染过程中出现异常，系统异常错误导致渲染引擎报错，重新加入频道或者重启App */
+    ERR_VIDEO_DISPLAY_INTERRUPT = 1064992,
+    /****************************************************
+     * 网络错误码
+     ****************************************************/
+    /** 媒体通道建立失败，检查网络连接是否正常 */
+    ERR_ICE_CONNECTION_CONNECT_FAIL = 17105409,
+    /** 媒体通道重连失败，检查网络连接是否正常 */
+    ERR_ICE_CONNECTION_RECONNECT_FAI = 17105410,
+    /** 媒体通道mobility失败，应用层需要重走入会流程 */
+    ERR_ICE_CONNECTION_MOBILITY_FAIL = 17105411,
+    /** 信令心跳超时，检查网络连接是否正常 */
+    ERR_ICE_CONNECTION_HEARTBEAT_TIMEOUT = 16908812,
+    /**
+     * 低延时互动直播模式相关错误码
+     */
+    /** 低延时互动直播信令失败 */
+    ERR_LATENCY_LIVE_COMMUNICATION_FAILED = 17235971,
+    /** 低延时互动直播媒体设置错误 */
+    ERR_LATENCY_LIVE_MEIDASETTING_FAILED = 17235972,
+    /** 低延时互动直播当前房间没有主播推流 */
+    ERR_LATENCY_LIVE_NONE_BROADCASTER = 17235973,
+    /** 低延时互动直播错误，应用层需要重新创建新的SDK实例 */
+    ERR_LATENCY_LIVE_NEED_RESTART = 17235974,
+    /** 低延时互动直播错误，应用层需要稍等一定时间（自定义间隔）重新创建新的SDK实例 */
+    ERR_LATENCY_LIVE_NEED_RESTART_AGAIN_LATER = 17235975,
+    /** 低延迟互动直播服务不可用或者服务降级，客户端应该选择其它方式拉超大方会流，即不从cdn sfu拉流 */
+    ERR_LATENCY_LIVE_SERVICE_UNAVAILABLE = 17235976,
+    /** 低延迟互动直播网络中断错误，销毁当前sdk实例重新创建sdk后重新走订阅流程 */
+    ERR_LATENCY_LIVE_MEDIACONNECTION_INTERRUPTION = 17235977,
+    /****************************************************
+     * 推流相关错误码
+     ****************************************************/
+    /** 推流无效 */
+    ERR_SDK_PUBLISH_INVAILD = 16974597,
+    /** 未进入频道推流失败 */
+    ERR_SDK_PUBLISH_NOT_JOIN_CHANNEL = 16843782,
+    /** 推送音频流失败 */
+    ERR_SDK_PUBLISH_AUDIO_STRAM_FAILED = 16843856,
+    /** 推送视频流失败 */
+    ERR_SDK_PUBLISH_VIDEO_STRAM_FAILED = 16843857,
+    /** 推送小流失败 */
+    ERR_SDK_PUBLISH_DUAL_STRAM_FAILED = 16843858,
+    /** 推送屏幕共享失败 */
+    ERR_SDK_PUBLISH_SCEEN_SHARE_FAILED = 16843859,
+    /** 屏幕共享配置错误 */
+    ERR_SDK_PUBLISH_SCREEN_SHARE_CONFIG_ERROR = 16843860,
+    /****************************************************
+     * 订阅相关错误码
+     ****************************************************/
+    /** 订阅无效 */
+    ERR_SDK_SUBSCRIBE_INVAILD = 16974852,
+    /** 未进入频道订阅错误 */
+    ERR_SDK_SUBSCRIBE_NOT_JOIN_CHANNEL = 16844112,
+    /** 订阅音频流失败 */
+    ERR_SDK_SUBSCRIBE_AUDIO_STRAM_FAILED = 16844113,
+    /** 订阅视频流失败 */
+    ERR_SDK_SUBSCRIBE_VIDEO_STRAM_FAILED = 16844114,
+    /** 订阅小流失败 */
+    ERR_SDK_SUBSCRIBE_DUAL_STRAM_FAILED = 16844115,
+    /** 订阅屏幕共享失败 */
+    ERR_SDK_SUBSCRIBE_SCREEN_SHARE_FAILED = 16844116,
+    /****************************************************
+     * 其他错误码
+     ****************************************************/
+    /** SDK状态错误，建议销毁SDK重新创建实例。 */
+    ERR_SDK_INVALID_STATE = 16974340,
+    /** 参数不匹配 */
+    ERR_INVALID_ARGUMENTS = 16974083,
+    /** Session已经被移除，建议销毁实例之后重新创建实例并加入频道。 */
+    ERR_SESSION_REMOVED = 33620229,
+    /** 互动模式下设置角色错误 */
+    ERR_SDK_UPDATE_ROLE_CHANNEL = 16908801,
+    /** SDK内部错误 */
+    ERR_INNER = -1,
+    /************************************************************************************/
+    /******************************** 旁路直播错误码 start ********************************/
+    /************************************************************************************/
+    /**
+     * MPU任务发布成功
+     */
+    ERR_SDK_MPU_TASK_PUBLISH_OK = 0,
+    /**
+     * MPU任务流未找到
+     */
+    ERR_SDK_MPU_TASK_STREAM_NOT_FOUND = 17825793,
+    /**
+     * MPU任务流已存在
+     */
+    ERR_SDK_MPU_TASK_STREAM_ALREADY_EXIST = 17825794,
+    /**
+     * MPU任务无效参数
+     */
+    ERR_SDK_MPU_TASK_INVALID_PARAM = 17825795,
+    /**
+     * MPU任务内部错误
+     */
+    ERR_SDK_MPU_TASK_INTERNAL_ERROR = 17825796,
+    /**
+     * MPU任务rtmp服务错误
+     */
+    ERR_SDK_MPU_TASK_RTMP_SERVER_ERROR = 17825797,
+    /**
+     * MPU任务rtmp流地址错误
+     */
+    ERR_SDK_MPU_TASK_RTMP_STREAM_URL_ERROR = 17825798,
+    /**
+     * MPU任务发布超时
+     */
+    ERR_SDK_MPU_TASK_PUBLISH_TIMEOUT = 17825799,
+    /**
+     * MPU任务发布成功
+     */
+    ERR_SDK_MPU_TASK_NOT_AUTHORIZED = 17825800,
+    /************************************************************************************/
+    /******************************** 旁路直播错误码 end ********************************/
+    /************************************************************************************/
+    /************************************************************************************/
+    /******************************** 跨频道转推错误码 start ******************************/
+    /************************************************************************************/
+    /**
+     * 检测到本地状态不对，没入会，角色错误，频道模式错误
+     */
+    ERR_SDK_CHANNEL_RELAY_STATE_ERROR = 18874369,
+    /**
+     * 服务端返回436，源通道模式不匹配
+     */
+    ERR_SDK_CHANNEL_RELAY_SRC_NOT_ALLOW = 18874370,
+    /**
+     * 服务端返回437，目标通道不存在或者模式不匹配
+     */
+    ERR_SDK_CHANNEL_RELAY_JOIN_DEST_FAILED = 18874371,
+    /**
+     * 服务端返回438，token无效
+     */
+    ERR_SDK_CHANNEL_RELAY_TOKEN_INVALID = 18874372,
+    /**
+     * 服务端返651，session不是主播
+     */
+    ERR_SDK_CHANNEL_RELAY_ROLE_ERROR = 18874373,
+    /**
+     * 服务端400，参数错误
+     */
+    ERR_SDK_CHANNEL_RELAY_INVALID_PARAM = 18874374,
+    /**
+     * 服务端返回440，不能转推到本频道
+     */
+    ERR_SDK_CHANNEL_RELAY_TO_SELF_ERROR = 18874375
+}
+
+declare class AliRtcLiveTranscoding {
+    authInfo?: AliRtcAuthInfo;
+    private doRequest;
+    setAuthInfo(authInfo: AliRtcAuthInfo): void;
+    clear(): void;
+    startPublishLiveStream(streamUrl: string, transcodingParam: AliRtcLiveTranscodingParam): Promise<any>;
+    startPublishLiveStreamWithTaskId(taskId: string, transcodingParam: AliRtcLiveTranscodingParam): Promise<any>;
+    updatePublishLiveStream(streamUrl: string, transcodingParam: AliRtcLiveTranscodingParam): Promise<any>;
+    updatePublishLiveStreamWithTaskId(taskId: string, transcodingParam: AliRtcLiveTranscodingParam): Promise<any>;
+    stopPublishLiveStream(streamUrl: string): Promise<any>;
+    stopPublishLiveStreamWithTaskId(taskId: string): Promise<any>;
+    refreshAuthInfo(authInfo: AliRtcRefreshAuthInfo): void;
+}
+
+export declare enum AliRtcLiveTranscodingAudioSampleRate {
+    LiveTranscoding_HZ_48000 = 48000,
+    LiveTranscoding_HZ_44100 = 44100,
+    LiveTranscoding_HZ_32000 = 32000,
+    LiveTranscoding_HZ_16000 = 16000,
+    LiveTranscoding_HZ_8000 = 8000
+}
+
+export declare enum AliRtcLiveTranscodingCropMode {
+    /*! 缩放模式 */
+    LiveTranscodingOrigin = 0,
+    /*! 剪裁 */
+    LiveTranscodingCrop = 1,
+    /*! 填充 */
+    LiveTranscodingFill = 2
+}
+
+export declare class AliRtcLiveTranscodingEncodeParam {
+    videoWidth: number;
+    videoHeight: number;
+    videoFramerate: number;
+    videoBitrate: number;
+    videoGop: number;
+    audioSamplerate: AliRtcLiveTranscodingAudioSampleRate;
+    audioBitrate: number;
+    audioChannels: number;
+    constructor(videoWidth: number, videoHeight: number, videoFramerate?: number, videoBitrate?: number, videoGop?: number, audioSamplerate?: AliRtcLiveTranscodingAudioSampleRate, audioBitrate?: number, audioChannels?: number);
+}
+
+export declare enum AliRtcLiveTranscodingErrorCode {
+    LiveTranscodingErrorPublishOk = 0,
+    LiveTranscodingErrorStreamNotFound = 17825793,
+    LiveTranscodingErrorStreamAlreadyExist = 17825794,
+    LiveTranscodingErrorInvalidParam = 17825795,
+    LiveTranscodingErrorInternalError = 17825796,
+    LiveTranscodingErrorRtmpServerError = 17825797,
+    LiveTranscodingErrorRtmpStreamUrlError = 17825798,
+    LiveTranscodingErrorPublishTimeout = 17825799,
+    LiveTranscodingErrorNotAuthorized = 17825800
+}
+
+export declare enum AliRtcLiveTranscodingFontType {
+    NOTO_SERIF_CJKSC_REGULAR = 0,
+    ALIBABA_PUHUITI_REGULAR = 1,
+    ALIBABA_PUHUITI_BOLD = 2,
+    ALIBABA_PUHUITI_Heavy = 3,
+    ALIBABA_PUHUITI_LIGHT = 4,
+    ALIBABA_PUHUITI_MEDIUM = 5
+}
+
+export declare enum AliRtcLiveTranscodingMediaProcessMode {
+    /*! 通用模式 */
+    LiveTranscodingNormal = 0,
+    /*! 虚拟背景模式 */
+    LiveTranscodingVirtualBackground = 1
+}
+
+export declare enum AliRtcLiveTranscodingMixMode {
+    /*! 单路模式 */
+    LiveTranscodingSingle = 0,
+    /*! 混流模式 */
+    LiveTranscodingMix = 1
+}
+
+export declare class AliRtcLiveTranscodingMixParam {
+    taskProfile: AliRtcLiveTranscodingTaskProfile;
+    encodeParam?: AliRtcLiveTranscodingEncodeParam;
+    users: AliRtcTranscodingUser[];
+    backgroundColor: number;
+    backgrounds: AliRtcTranscodingImage[];
+    watermarks: AliRtcTranscodingImage[];
+    clockWidgets: AliRtcTranscodingClockWidget[];
+    cropMode?: AliRtcLiveTranscodingCropMode;
+    mediaProcessMode?: AliRtcLiveTranscodingMediaProcessMode;
+    constructor(taskProfile: AliRtcLiveTranscodingTaskProfile);
+}
+
+export declare class AliRtcLiveTranscodingParam {
+    /*! 旁路模式 */
+    mixMode: AliRtcLiveTranscodingMixMode;
+    /*! 路模式单路参数 */
+    singleParam?: AliRtcLiveTranscodingSingleParam;
+    /*! 旁路模式混流参数 */
+    mixParam?: AliRtcLiveTranscodingMixParam;
+    constructor(mixMode?: AliRtcLiveTranscodingMixMode, singleParam?: AliRtcLiveTranscodingSingleParam, mixParam?: AliRtcLiveTranscodingMixParam);
+    toJson(type: MPU_TASK_TRANSACTION_TYPE, authInfo: AliRtcAuthInfo, taskId: string, streamUrl?: string, messageId?: string): {
+        [key: string]: any;
+    };
+}
+
+export declare enum AliRtcLiveTranscodingSegmentType {
+    /*! 无人像分割 */
+    LiveTranscodingNoBody = 0,
+    /*! 人像分割 */
+    LiveTranscodingBody = 1
+}
+
+export declare class AliRtcLiveTranscodingSingleParam {
+    userId?: string;
+    streamType?: AliRtcLiveTranscodingStreamType;
+    sourceType?: AliRtcLiveTranscodingSourceType;
+    constructor(uid?: string, streamType?: AliRtcLiveTranscodingStreamType, sourceType?: AliRtcLiveTranscodingSourceType);
+}
+
+export declare enum AliRtcLiveTranscodingSourceType {
+    /*! 相机流 */
+    LiveTranscodingCamera = 0,
+    /*! 屏幕流 */
+    LiveTranscodingShareScreen = 1
+}
+
+export declare enum AliRtcLiveTranscodingState {
+    LiveTranscodingState_IDLE = 0,
+    LiveTranscodingState_CONNNECT = 1,
+    LiveTranscodingState_RUNNING = 2,
+    LiveTranscodingState_RECOVERING = 3,
+    LiveTranscodingState_FAILURE = 4,
+    LiveTranscodingState_END = 5
+}
+
+export declare enum AliRtcLiveTranscodingStreamType {
+    /*! 原始流 */
+    LiveTranscodingOrigin = 0,
+    /*! 音频 */
+    LiveTranscodingAudio = 1,
+    /*! 视频 */
+    LiveTranscodingVideo = 2
+}
+
+export declare enum AliRtcLiveTranscodingTaskProfile {
+    LiveTranscoding_Profile_1IN_1080P = 0,
+    LiveTranscoding_Profile_1IN_720P = 1,
+    LiveTranscoding_Profile_1IN_360P = 2,
+    LiveTranscoding_Profile_2IN_1080P = 3,
+    LiveTranscoding_Profile_2IN_720P = 4,
+    LiveTranscoding_Profile_2IN_360P = 5,
+    LiveTranscoding_Profile_4IN_1080P = 6,
+    LiveTranscoding_Profile_4IN_720P = 7,
+    LiveTranscoding_Profile_4IN_360P = 8,
+    LiveTranscoding_Profile_9IN_1080P = 9,
+    LiveTranscoding_Profile_9IN_720P = 10,
+    LiveTranscoding_Profile_9IN_360P = 11,
+    LiveTranscoding_Profile_12IN_1080P = 12,
+    LiveTranscoding_Profile_12IN_720P = 13,
+    LiveTranscoding_Profile_12IN_360P = 14,
+    LiveTranscoding_Profile_16IN_1080P = 15,
+    LiveTranscoding_Profile_16IN_720P = 16,
+    LiveTranscoding_Profile_16IN_360P = 17,
+    LiveTranscoding_Profile_Mixed = 9999
+}
+
+declare interface AliRtcLocalAudioStats {
+    track: AliRtcAudioTrack;
+    stats: any;
+}
+
+export declare class AliRtcLocalStreamInfo extends default_2<AliRtcLocalStreamListener> {
+    type: AliRtcRawDataStreamType;
+    originVideoTrack?: MediaStreamTrack;
+    videoSource?: VideoStreamSource;
+    private _videoMuted;
+    originAudioTrack?: MediaStreamTrack;
+    audioSource?: AudioStreamSource;
+    private _audioMuted;
+    private _targetVideoTrack?;
+    private _targetDualVideoTrack?;
+    private _targetAudioTrack?;
+    private _publishVideoStream?;
+    private _publishDualVideoStream?;
+    private _publishAudioStream?;
+    private _previewStream?;
+    plugins: AliRtcPlugin[];
+    private _profileManager?;
+    cameraVideoConstraints?: IVideoConstraints;
+    micAudioConstraints?: IAudioConstraints;
+    private get profileManager();
+    get audioProfile(): AudioProfileKey | undefined;
+    constructor(type: AliRtcRawDataStreamType);
+    private onVideoTrackEnded;
+    private onAudioTrackEnded;
+    updateSource(newStream: LocalStream, newVideoSource?: VideoStreamSource, newAudioSource?: AudioStreamSource): Promise<void>;
+    get currentProfile(): string | undefined;
+    get currentVideoTrack(): MediaStreamTrack | undefined;
+    get currentDualVideoTrack(): MediaStreamTrack | undefined;
+    get publishVideoStream(): LocalStream | undefined;
+    get publishDualVideoStream(): LocalStream | undefined;
+    get currentAudioTrack(): MediaStreamTrack | undefined;
+    get publishAudioStream(): LocalStream | undefined;
+    get previewStream(): LocalStream | undefined;
+    /**
+     * 更新 VideoTrack
+     * @param videoTrack
+     */
+    updateVideoTrack(videoTrack?: MediaStreamTrack, force?: boolean): Promise<void>;
+    /**
+     * 更新 DualVideoTrack
+     * @param videoTrack
+     * @param force
+     */
+    updateDualVideoTrack(videoTrack?: MediaStreamTrack, force?: boolean): Promise<void>;
+    /**
+     * 更新 AudioTrack
+     * @param audioTrack
+     */
+    updateAudioTrack(audioTrack?: MediaStreamTrack, force?: boolean): Promise<void>;
+    /**
+     * 设置音频流静音
+     * @param muted
+     */
+    setAudioMuted(muted: boolean): void;
+    get isAudioMuted(): boolean;
+    /**
+     * 设置视频流静音
+     * @param muted
+     */
+    setVideoMuted(muted: boolean): void;
+    get isVideoMuted(): boolean;
+    process(localStreamInfos: AliRtcLocalStreamInfo[]): Promise<void>;
+    /**
+     * 停止视频流
+     */
+    stopVideo(): void;
+    /**
+     * 停止音频流
+     */
+    stopAudio(): void;
+    /**
+     * 停止视频流和音频流
+     */
+    stop(): void;
+    /**
+     * 应该在执行完 plugin 后调用
+     * @param profileName
+     * @param profileValue
+     */
+    updateVideoProfile(profileName?: string, profileValue?: IProfile): Promise<void>;
+    get videoProfile(): string | undefined;
+    setVideoContentHint(hint?: string): void;
+    /**
+     * 应该在执行完 plugin 后调用
+     * @param profileName
+     */
+    updateAudioProfile(profileKey: AudioProfileKey): Promise<void>;
+    /**
+     * 复制视频 profile 到指定 LocalStream
+     * @param publishStream
+     */
+    cloneVideoProfile(publishStream: LocalStream): Promise<void>;
+    addPlugin(plugin: AliRtcPlugin): void;
+    removePlugin(plugin: AliRtcPlugin): boolean;
+}
+
+declare interface AliRtcLocalStreamListener {
+    videotrackended: () => void;
+    audiotrackended: () => void;
+}
+
+declare interface AliRtcLocalVideoStats {
+    track: AliRtcVideoTrack;
+    streamType?: AliRtcVideoStreamType;
+    stats: any;
+}
+
+declare type AliRtcLocalView = string | HTMLVideoElement | string[] | HTMLVideoElement[] | null;
+
+export declare enum AliRtcLogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    API = 2,
+    WARNING = 3,
+    ERROR = 4,
+    NONE = 5
+}
+
+/**
+ * @brief OnBye类型枚举
+ */
+declare enum AliRtcOnByeType {
+    /** 当前user被踢出channel */
+    AliRtcOnByeBeKickedOut = 1,
+    /** channel已结束，需要离开会议 */
+    AliRtcOnByeChannelTerminated = 2,
+    /** 相同userID在其他设备joinChannel，当前设备被下线 */
+    AliRtcOnByeUserReplaced = 3
+}
+
+export declare abstract class AliRtcPlugin extends default_2<AliRtcPluginListener> {
+    name: string;
+    options: any;
+    type: AliRtcPluginType;
+    streamType: AliRtcRawDataStreamType;
+    trackType: AliRtcPluginTrackType;
+    zIndex: number;
+    private _isEnable;
+    lastInputAudioTrack?: MediaStreamTrack;
+    lastOutputAudioTrack?: MediaStreamTrack;
+    lastInputVideoTrack?: MediaStreamTrack;
+    lastOutputVideoTrack?: MediaStreamTrack;
+    constructor(name: string, streamType?: AliRtcRawDataStreamType, trackType?: AliRtcPluginTrackType);
+    get initOptions(): {};
+    getOptions(): any;
+    abstract setOptions(options: any): void;
+    abstract isSupported(version: string): boolean;
+    init(): Promise<void>;
+    enable(): void;
+    disable(): void;
+    get isEnable(): boolean;
+    protected audioUpdated(streamInfo: AliRtcLocalStreamInfo): boolean;
+    protected videoUpdated(streamInfo: AliRtcLocalStreamInfo): boolean;
+    execute(streamInfo: AliRtcLocalStreamInfo, streamInfos: AliRtcLocalStreamInfo[]): Promise<void>;
+    abstract shouldUpdate(streamInfo: AliRtcLocalStreamInfo, streamInfos: AliRtcLocalStreamInfo[]): boolean;
+    abstract process(streamInfo: AliRtcLocalStreamInfo, streamInfos: AliRtcLocalStreamInfo[]): Promise<void>;
+    clear(_streamInfo?: AliRtcLocalStreamInfo): void;
+}
+
+declare interface AliRtcPluginListener {
+    enabled: () => void;
+    disabled: () => void;
+    updated: () => void;
+    ready: () => void;
+    overload: (info: any) => void;
+    error: (error: any) => void;
+    unsupported: () => void;
+}
+
+export declare enum AliRtcPluginTrackType {
+    AUDIO = 0,
+    VIDEO = 1,
+    BOTH = 2
+}
+
+export declare enum AliRtcPluginType {
+    PRE_PROCESSOR = 0,
+    POST_PROCESSOR = 1
+}
+
+export declare enum AliRtcPublishState {
+    /** 0: SDK初始推流状态 */
+    AliRtcStatePublishIdle = 0,
+    /** 1: 未推流状态，可能是因为:
+     * - 已设置停止推送媒体流
+     * - 推送媒体流失败
+     */
+    AliRtcStateNoPublish = 1,
+    /** 2: 推流链接建立过程中 */
+    AliRtcStatePublishing = 2,
+    /** 3: 推流成功 */
+    AliRtcStatePublished = 3
+}
+
+export declare enum AliRtcRawDataStreamType {
+    /** 相机流 */
+    AliRtcSdkStreamTypeCapture = 0,
+    /** 屏幕共享流 */
+    AliRtcSdkStreamTypeScreen = 1
+}
+
+export declare type AliRtcRefreshAuthInfo = Pick<AliRtcAuthInfo, 'userId' | 'nonce' | 'token' | 'timestamp' | 'role'>;
+
+declare interface AliRtcRemoteAudioStats {
+    uid: string;
+    track: AliRtcAudioTrack;
+    stats: any;
+}
+
+export declare class AliRtcRemoteUserInfo {
+    private remoteUser;
+    constructor(remoteUser: RemoteUser);
+    get userId(): string;
+    get displayName(): string;
+    get isMuteAudioPlaying(): boolean;
+    get hasAudio(): boolean;
+    get hasCamera(): boolean;
+    get hasCameraLarge(): boolean;
+    get hasCameraSmall(): boolean;
+    get hasScreenShare(): boolean;
+    get isAudioSubscribing(): boolean;
+    get isVideoSubscribing(): boolean;
+    get isVideoLargeSubscribing(): boolean;
+    get isVideoSmallSubscribing(): boolean;
+    get isScreenSubscribing(): boolean;
+}
+
+declare interface AliRtcRemoteVideoStats {
+    uid: string;
+    track: AliRtcVideoTrack;
+    streamType?: AliRtcVideoStreamType;
+    stats: any;
+}
+
+declare interface AliRtcScreenShareConfiguration {
+    frameRate?: number;
+    bitrate?: number;
+}
+
+declare interface AliRtcScreenShareStartConfig {
+    audio?: boolean;
+    videoTrack?: MediaStreamVideoTrack;
+    audioTrack?: MediaStreamAudioTrack;
+}
+
+export declare enum AliRtcSdkChannelProfile {
+    /** 普通通信模式 */
+    AliRtcSdkCommunication = "communication",
+    /** 直播模式(大方会模式) */
+    AliRtcSdkInteractiveLive = "interactive_live",
+    /** 低延迟互动直播模式 */
+    AliRtcSdkInteractiveWithLowLatencyLive = "cdn_live"
+}
+
+export declare enum AliRtcSdkClientRole {
+    /** 互动角色 */
+    AliRtcSdkInteractive = "interactive",
+    /** 观众角色 */
+    AliRtcSdkLive = "live"
+}
+
+/** 角色鉴权 主播pub｜观众sub｜转推流鉴权（跨房间转推中使用）relay */
+declare type AliRtcSdkTokenRole = 'pub' | 'sub' | 'relay';
+
+export declare enum AliRtcSubscribeState {
+    /** 初始状态 */
+    AliRtcStateSubscribeIdle = 0,
+    /** 未订阅 */
+    AliRtcStateNoSubscribe = 1,
+    /** 订阅中 */
+    AliRtcStateSubscribing = 2,
+    /** 已订阅 */
+    AliRtcStateSubscribed = 3
+}
+
+export declare class AliRtcTranscodingClockWidget {
+    x: number;
+    y: number;
+    fontSize: number;
+    zOrder: number;
+    fontColor: number;
+    fontType: AliRtcLiveTranscodingFontType;
+    constructor(x: number, y: number, fontSize: number);
+    constructor(x: number, y: number, fontSize: number, zOrder: number);
+    constructor(x: number, y: number, fontSize: number, zOrder: number, fontColor: number);
+    constructor(x: number, y: number, fontSize: number, zOrder: number, fontColor: number, fontType: AliRtcLiveTranscodingFontType);
+    toJson(videoWidth: number, videoHeight: number): {
+        x: number;
+        y: number;
+        fonttype: AliRtcLiveTranscodingFontType;
+        fontsize: number;
+        fontcolor: number;
+        zorder: number;
+    };
+}
+
+export declare class AliRtcTranscodingImage {
+    static DisplayType: typeof DisplayType;
+    url: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    alpha: number;
+    display: DisplayType;
+    zOrder: number;
+    constructor(url: string, x: number, y: number, width: number, height: number);
+    constructor(url: string, x: number, y: number, width: number, height: number, zOrder: number);
+    constructor(url: string, x: number, y: number, width: number, height: number, zOrder: number, alpha: number);
+    constructor(url: string, x: number, y: number, width: number, height: number, zOrder: number, alpha: number, display: DisplayType);
+    toJson(videoWidth: number, videoHeight: number): {
+        url: string;
+        alpha: number;
+        display: DisplayType;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zorder: number;
+    };
+}
+
+export declare class AliRtcTranscodingText {
+    text: string;
+    x: number;
+    y: number;
+    fontSize: number;
+    zOrder: number;
+    fontColor: number;
+    fontType: AliRtcLiveTranscodingFontType;
+    constructor(text: string, x: number, y: number, fontSize: number);
+    constructor(text: string, x: number, y: number, fontSize: number, zOrder: number);
+    constructor(text: string, x: number, y: number, fontSize: number, zOrder: number, fontColor: number);
+    constructor(text: string, x: number, y: number, fontSize: number, zOrder: number, fontColor: number, fontType: AliRtcLiveTranscodingFontType);
+    toJson(videoWidth: number, videoHeight: number): {
+        text: string;
+        x: number;
+        y: number;
+        fonttype: AliRtcLiveTranscodingFontType;
+        fontsize: number;
+        fontcolor: number;
+        zorder: number;
+    };
+}
+
+export declare class AliRtcTranscodingUser {
+    userId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    zOrder?: number;
+    sourceType?: AliRtcLiveTranscodingSourceType;
+    segmentType: AliRtcLiveTranscodingSegmentType;
+    images: AliRtcTranscodingImage[];
+    texts: AliRtcTranscodingText[];
+    constructor(userId: string, x: number, y: number, width: number, height: number);
+    constructor(userId: string, x: number, y: number, width: number, height: number, zOrder: number);
+    constructor(userId: string, x: number, y: number, width: number, height: number, zOrder: number, sourceType: AliRtcLiveTranscodingSourceType);
+    toJson(index: number, videoWidth: number, videoHeight: number, mediaProcessMode?: AliRtcLiveTranscodingMediaProcessMode): {
+        [key: string]: any;
+    };
+}
+
+export declare enum AliRtcTrascodingPublishTaskStatus {
+    /*! 任务开始 */
+    TrascodingPublishTaskStatusStart = 0,
+    /*! 任务更新 */
+    TrascodingPublishTaskStatusUpdate = 1,
+    /*! 任务已停止 */
+    TrascodingPublishTaskStatusStop = 2
+}
+
+declare enum AliRtcUserOfflineReason {
+    /** 用户主动离开 */
+    AliRtcUserOfflineQuit = 0,
+    /** 因过长时间收不到对方数据包，超时掉线 */
+    AliRtcUserOfflineDropped = 1,
+    /** 用户身份从主播切换为观众时触发 */
+    AliRtcUserOfflineBecomeAudience = 2
+}
+
+export declare enum AliRtcVideoStreamType {
+    /** 无，在OnSubscribeStreamTypeChanged回调表示当前未订阅 */
+    AliRtcVideoStreamTypeNone = 0,
+    /** 高码率，高分辨率流（大流） */
+    AliRtcVideoStreamTypeHigh = 1,
+    /** 低码率，低分辨率流（小流） */
+    AliRtcVideoStreamTypeLow = 2
+}
+
+export declare enum AliRtcVideoTrack {
+    /** 无视频流 **/
+    AliRtcVideoTrackNo = 0,
+    /** 相机流 **/
+    AliRtcVideoTrackCamera = 1,
+    /** 屏幕共享流 **/
+    AliRtcVideoTrackScreen = 2,
+    /** 相机流和屏幕共享流 **/
+    AliRtcVideoTrackBoth = 3
+}
+
+declare interface AliRtcVideoTrackConfig {
+    userId?: string;
+    streamType: AliRtcRawDataStreamType;
+}
+
+declare interface AliRtcWebTrackConfig {
+    biz: string;
+    extraParams?: string;
+}
+
+declare class AudioLevelMonitor extends default_2<AudioLevelMonitorListener> {
+    private audioContext;
+    private stream;
+    private sourceNode?;
+    private analyser?;
+    constructor();
+    getLevel(): number;
+    /**
+     * 开启监听 audio level 的变化
+     *
+     * @param {MediaStreamTrack} track 音频轨
+     * @param {number} [interval=1000] 检测间隔，单位毫秒，默认 1000ms
+     */
+    start(track: MediaStreamTrack, interval?: number): void;
+    stop(): void;
+    dispose(): void;
+}
+
+declare interface AudioLevelMonitorListener {
+    audioLevel: (level: number) => void;
+}
+
+/**
+ * ------------------    模式    ----- 采样率  -----  声道  -----  码率（kbps）  -----
+ *
+ * standard:           标准音质         48000       单声道          64
+ *
+ * high:                 高音质         48000       单声道         128
+ *
+ * standard-stereo:   立体声音质         48000       双声道         80
+ *
+ * high-stereo:       立体声高音质       48000       双声道         192
+ */
+declare type AudioProfileKey = 'standard' | 'high' | 'standard-stereo' | 'high-stereo';
+
+declare enum AudioStreamSource {
+    Microphone = 0,
+    Screen = 1,
+    Mixed = 2
+}
+
+declare enum ClientEventType {
+    PullStreamStats = "remoteStat",
+    RtsSubscribeExceeds = "rtsSubscribeExceeds",
+    UserJoined = "userJoined",
+    UserLeft = "userLeft",
+    Bye = "bye",
+    MuteAudio = "muteAudio",
+    UnmuteAudio = "unmuteAudio",
+    MuteVideo = "muteVideo",
+    UnmuteVideo = "unmuteVideo",
+    MuteScreen = "muteScreen",
+    UnmuteScreen = "unmuteScreen",
+    Error = "error"
+}
+
+declare enum CmdType {
+    Add = 0,
+    Del = 1,
+    Update = 2,
+    None = 100
+}
+
+declare enum CodecType {
+    OPUS = "opus",
+    H264 = "H264",
+    UNKONWN = ""
+}
+
+declare const _default: typeof AliRtcEngine;
+export default _default;
+
+declare interface DeviceStatus {
+    micOpen: boolean;
+    micInterrupted: boolean;
+    cameraOpen: boolean;
+    screenShare: boolean;
+    audioDisable: boolean;
+    videoDisable: boolean;
+    screenDisable: boolean;
+    backgroundMode: boolean;
+    accompanyPlaying: boolean;
+}
+
+declare enum DeviceStatusChange {
+    Local = "local-device-status-change",
+    Remote = "remote-device-status-change"
+}
+
+declare type DeviceStatusChangeType = ClientEventType.MuteAudio | ClientEventType.UnmuteAudio | ClientEventType.MuteScreen | ClientEventType.UnmuteScreen | ClientEventType.MuteVideo | ClientEventType.UnmuteVideo;
+
+declare enum DisplayType {
+    NOT_DISPLAY = 0,
+    ALWAYS = 1,
+    WHEN_NO_VIDEO = 2
+}
+
+declare enum EventId {
+    JoinChannel = 70012,
+    JoinChannelRes = 70013,
+    LeaveChannel = 70015,
+    EnvCheck = 100001,
+    Push = 10030,
+    Pull = 10050,
+    SubscribeStats = 10080
+}
+
+declare interface ISignalingInterface {
+    join(authInfo: AliRtcAuthInfo, userName: string, connectRetryCount?: number): Promise<JoinResult>;
+    leave(): Promise<SignalingResult>;
+    publish(publishInfo: PublishInfo): Promise<SignalingResult>;
+    roleUpdate(role: AliRtcSdkClientRole): Promise<SignalingResult>;
+    setChannelProfile(channelProfile: AliRtcSdkChannelProfile): void;
+    refreshUrl(info: RefreshInfo): Promise<RefreshUrlResult>;
+    refreshAuthInfo(authInfo: AliRtcAuthInfo): Promise<void>;
+    reportStatus(status: string): Promise<void>;
+    on(event: string, listener: Function): void;
+    reset(): void;
+}
+
+/**
+ * 服务端通知的远端用户信息
+ */
+declare interface JoinInfo {
+    displayname: string;
+    session: string;
+    userid: string;
+    callid: string;
+    clientrole?: string;
+    subscribe?: {
+        pullstreamurl: string;
+    };
+    tracks?: TrackInfo[];
+}
+
+declare interface JoinResult {
+    pushstreamurl: string;
+    tid: string;
+    users: JoinInfo[];
+    timestamp: number;
+}
+
+declare interface LeaveInfo {
+    userid: string;
+    leavecode: AliRtcUserOfflineReason;
+    reason: string;
+}
+
+declare class LocalProfileManager {
+    profile?: string;
+    profileMap: Map<string, IProfile>;
+    audioProfile?: AudioProfileKey;
+    contentHint?: string;
+    updateProfile(profileKey: string, profileValue?: IProfile): void;
+    get videoProfile(): string | undefined;
+    updateAudioProfile(profileKey: AudioProfileKey): void;
+    setContentHint(videoTrack: MediaStreamTrack | undefined, contentHint?: string): void;
+    /**
+     * 更新源流 Constraints
+     * 更新 PeerConnectiong Sender 相关配置
+     * @param stream
+     */
+    setVideoProfile(originVideoTrack: MediaStreamTrack | undefined, target: LocalStream | undefined, skipConstraints?: boolean): Promise<void>;
+}
+
+declare type LocalStreamConfig = Omit<_LocalStreamConfig, 'custom'>;
+
+declare interface _LocalStreamConfig extends IStreamConfig {
+    videoProfile?: string;
+    screenProfile?: string;
+}
+
+declare class LocalStreamManager extends default_2<LocalStreamManagerListener> {
+    /**
+     * @ignore
+     */
+    static logName: string;
+    private pluginManager;
+    private publishingCameraVideoStream;
+    private publishingScreenVideoStream;
+    cameraStreamInfo: AliRtcLocalStreamInfo;
+    screenStreamInfo: AliRtcLocalStreamInfo;
+    private streamInfos;
+    private _audioCaptureDisabled;
+    private _cameraCaptureDisabled;
+    private _publishLocalAudioStreamEnabled;
+    private _publishLocalVideoStreamEnabled;
+    private _publishLocalScreenStreamEnabled;
+    constructor(pluginManager: PluginManager);
+    get hasCamera(): boolean;
+    get audioCaptureDisabled(): boolean;
+    set audioCaptureDisabled(closed: boolean);
+    get cameraCaptureDisabled(): boolean;
+    setAudioMuted(muted: boolean): void;
+    get isAudioMuted(): boolean;
+    setCameraMuted(muted: boolean): void;
+    get isCameraMuted(): boolean;
+    setScreenMuted(muted: boolean): void;
+    get isScreenMuted(): boolean;
+    set cameraCaptureDisabled(closed: boolean);
+    get publishLocalAudioStreamEnabled(): boolean;
+    set publishLocalAudioStreamEnabled(enable: boolean);
+    get publishLocalVideoStreamEnabled(): boolean;
+    set publishLocalVideoStreamEnabled(enable: boolean);
+    get publishLocalScreenStreamEnabled(): boolean;
+    set publishLocalScreenStreamEnabled(enable: boolean);
+    private updateStreams;
+    private setAvailableCameraDeviceId;
+    private setAvailableMicrophoneDeviceId;
+    /**
+     * 创建 LocalStream
+     * @param {LocalStreamConfig} params 创建 LocalStream 的配置
+     * @returns {LocalStream} 当前创建的 LocalStream
+     */
+    createLocalStream(params: LocalStreamConfig): Promise<LocalStream | undefined>;
+    /**
+     * 停止推流，底层调用 rts publishStop，不会导致 DC 马上关闭。适合暂时停推的场景
+     * @param {StopPublishOptions} options
+     * @returns {Promise<PublishStreamInfo>} 如果返回了 audio，则表示需要更新音频流
+     */
+    stopLocalStream(options: StopPublishOptions): Promise<void>;
+    get publishStreams(): PublishStreamInfo;
+    createHTTPPublishStream(): Promise<{
+        publishStream: LocalStream | undefined;
+        videoSmallStream: LocalStream | undefined;
+        screenStream: LocalStream | undefined;
+        vMsid: string | undefined;
+    }>;
+    /**
+     * 停止所有流
+     */
+    stop(): void;
+    /**
+     * 设置摄像头流 profile
+     * @param {LocalStream | null} stream
+     * @param {string} profileKey
+     * @param {IProfile} profile
+     */
+    setVideoProfile(profileKey?: string, profile?: IProfile): Promise<void>;
+    /**
+     * 设置摄像头流 content hint
+     * @param {string} hint
+     * @note 不传则尝试复用之前的 hint
+     */
+    setVideoContentHint(hint?: string): void;
+    /**
+     * 设置音频流 profile
+     * @param {string} profileKey
+     */
+    setAudioProfile(profileKey: AudioProfileKey): Promise<void>;
+    /**
+     * 设置屏幕共享流 profile
+     * @param {LocalStream} stream
+     * @param {string} profileKey
+     * @param {IProfile} profile
+     */
+    setScreenProfile(profileKey?: string, profile?: IProfile): Promise<void>;
+    setScreenContentHint(hint?: string): void;
+    /**
+     * 设置 cameraVideoConstraints
+     * @param {IVideoConstraints} cameraVideoConstraints
+     */
+    setCameraVideoConstraints(cameraVideoConstraints: IVideoConstraints): void;
+    /**
+     * 设置 micAudioConstraints
+     * @param {IAudioConstraints} micAudioConstraints
+     */
+    setMicAudioConstraints(micAudioConstraints: IAudioConstraints): void;
+}
+
+declare interface LocalStreamManagerListener {
+    trackended: (type: TrackEvent_2) => {};
+    publishupdate: () => {};
+}
+
+declare class LocalUser extends User {
+    /**
+     * @ignore
+     */
+    static logName: string;
+    protected url: string;
+    private _isPublishing;
+    private publishPromise;
+    private previewElements;
+    private screenPreviewElements;
+    private streamManager;
+    protected streamTracks?: TrackInfo[];
+    protected publishId: string;
+    protected signalingManager: SignalingManager;
+    traceId: string;
+    private monitorTimerId?;
+    protected reporter: Reporter;
+    protected webTrackingClient: WebTrackingClient;
+    private audioPubState;
+    private videoPubState;
+    private videoSmallPubState;
+    private screenPubState;
+    constructor(config: LocalUserConfig);
+    get joined(): boolean;
+    get isPublishing(): boolean;
+    get publishStreams(): PublishStreamInfo;
+    get cameraTrack(): MediaStreamTrack | undefined;
+    get screenTrack(): MediaStreamTrack | undefined;
+    get audioTrack(): MediaStreamTrack | undefined;
+    get hasCamera(): boolean;
+    get hasMicrophone(): boolean;
+    get hasScreenShare(): boolean;
+    get hasCameraTrackInMS(): boolean;
+    get hasCameraDualTrackInMS(): boolean;
+    get hasScreenTrackInMS(): boolean;
+    get hasAudioTrackInMS(): boolean;
+    get cameraDirection(): string | undefined;
+    get audioCaptureDisabled(): boolean;
+    get cameraCaptureDisabled(): boolean;
+    get publishLocalVideoStreamEnabled(): boolean;
+    get publishLocalAudioStreamEnabled(): boolean;
+    get publishLocalScreenStreamEnabled(): boolean;
+    setPublishLocalAudioStreamEnabled(enable: boolean): void;
+    setPublishLocalVideoStreamEnabled(enable: boolean): void;
+    setPublishLocalScreenStreamEnabled(enable: boolean): void;
+    initInfo(authInfo: AliRtcAuthInfo, pushStreamUrl: string): void;
+    setVideoProfile(key: string, profile?: IProfile): Promise<void>;
+    setVideoContentHint(hint: string): void;
+    setScreenContentHint(hint: string): void;
+    setAudioProfile(profileKey: AudioProfileKey): Promise<void>;
+    setScreenProfile(key: string, profile?: IProfile): Promise<void>;
+    setCameraDirection(direction: AliRtcCameraDirection): void;
+    setCameraDeviceId(deviceId: string): void;
+    muteLocalCamera(mute: boolean): void;
+    muteLocalMic(mute: boolean): void;
+    muteLocalScreen(mute: boolean): void;
+    setMicrophoneDeviceId(deviceId: string): void;
+    updatePubId(): void;
+    clearPublishState(): void;
+    /**
+     * 销毁，停止推流
+     * @returns {Promise<void>}
+     */
+    clear(): Promise<void>;
+    resetElement(element: HTMLVideoElement): void;
+    setPreviewElement(previewParams: PreviewConfig): void;
+    /**
+     * 为本地预览设置渲染元素和视频流
+     * @param {AliRtcLocalView} view 渲染元素，null 则为停止显示
+     * @param {AliRtcVideoTrack} track 视频流类型
+     */
+    setViewConfig(elements: null | HTMLVideoElement[], track: AliRtcVideoTrack): void;
+    /**
+     * 开启摄像头采集
+     * @param params
+     * @returns
+     */
+    startCameraCapture(params: LocalStreamConfig): Promise<LocalStream | undefined>;
+    /**
+     * 关闭摄像头采集
+     * @note 调用此接口后，入会后、离会再入会，采集设备保持关闭状态
+     */
+    stopCameraCapture(): Promise<void>;
+    /**
+     * 关闭音频采集
+     * @note 调用此接口后，入会后、离会再入会，采集设备保持关闭状态
+     */
+    stopAudioCapture(): Promise<void>;
+    /**
+     * 预览本地流
+     * @param {PreviewConfig} previewParams
+     * @returns {Promise<MediaStream>}
+     */
+    preview(previewParams: PreviewConfig): Promise<MediaStream | undefined>;
+    /**
+     * 在所有预览容器中预览当前流
+     * @param {boolean} screen 是否指定预览辅流
+     */
+    previewAll(previewAllParams?: PreviewAllConfig): Promise<void>;
+    /**
+     * 停止预览本地流
+     */
+    stopPreview(previewParams?: StopPreviewConfig): void;
+    /**
+     * 恢复推流
+     * @returns {Promise<void>}
+     */
+    resumePublish(): Promise<void>;
+    createLocalStream(params: LocalStreamConfig): Promise<LocalStream | undefined>;
+    stopLocalStream(options: PublishOptions): Promise<void>;
+    private compareAndPublish;
+    /**
+     * 开始推流
+     * @param isResume 是否是恢复推流
+     * @returns
+     */
+    startPublish(isResume?: boolean): Promise<void>;
+    /**
+     * 对比本地流和正在推流，进行推流更新
+     * @param isResume 是否是恢复推流
+     */
+    publishUpdate(): Promise<PublishInfo | undefined>;
+    private syncPublishToRoomServer;
+    private refreshPushStreamUrl;
+    /**
+     * 推流，用于 rts subscribe/publish 被调用后，此时 DataChannel 已存在
+     * @param {LocalStream} stream
+     * @returns {Promise<PublishInfo>}
+     */
+    publishAdd(stream: LocalStream, extra: PublishExtraParams, isResume?: boolean, retryTimes?: number): Promise<PublishInfo>;
+    /**
+     * 替换推流 Track（仅限于替换已存在的 Track 类型）
+     * @param {LocalStream} stream
+     * @returns {Promise<PublishInfo>}
+     */
+    publishReplace(stream: LocalStream, extra?: PublishExtraParams): Promise<PublishInfo>;
+    /**
+     * 停止推某些轨，不销毁 DataChannel 和 LocalStream，用于非销毁场景
+     * @param {PublishOptions} options
+     * @returns {Promise<PublishInfo>}
+     */
+    publishDeleteTracks(options: PublishOptions): Promise<PublishInfo>;
+    /**
+     * 停止推流，不销毁  LocalStream，用于非销毁场景
+     * @returns {Promise<PublishInfo>}
+     */
+    publishStop(): Promise<PublishInfo>;
+    /**
+     * 停止推流，销毁 DataChannel，用于销毁的场景
+     * @returns {Promise<PublishInfo>}
+     */
+    unPublish(): Promise<PublishInfo>;
+    /**
+     * 事件通知本地的设备使用状态
+     */
+    reportSelfDeviceStatus(): void;
+    /**
+     * 从localStream 中获取当前的设备状态
+     * @returns {string}
+     */
+    private getDeviceStatus;
+    private onTrackEnd;
+    private resetPreviewElements;
+    private resetSecondayPreviewElements;
+    /**
+     * 停止本地流数据采集
+     */
+    private stopStreamMonitor;
+    /**
+     * 清除本地流
+     * @returns {void}
+     */
+    clearStream(): void;
+    /**
+     * 获取当前使用的摄像头 deviceId
+     * @returns {string | undefined}
+     */
+    getCurrentCameraDeviceId(): string | undefined;
+    /**
+     * 获取当前使用的摄像头 deviceId
+     * @returns {string | undefined}
+     */
+    getCurrentMicDeviceId(): string | undefined;
+    enableAudioVolumeIndication(interval: number): void;
+    sendSEI(message: ArrayBuffer, repeatCount: number, payloadType: number): Promise<void>;
+    getStats(): Promise<{
+        audio: AliRtcLocalAudioStats[];
+        video: AliRtcLocalVideoStats[];
+    }>;
+}
+
+declare interface LocalUserConfig {
+    rtsManager: RtsManager;
+    localStreamManager: LocalStreamManager;
+    reporter: Reporter;
+    webTrackingClient: WebTrackingClient;
+    signalingManager: SignalingManager;
+    pluginManager: PluginManager;
+    audioVolumeIndicationInterval: number;
+}
+
+/**
+ * 日志埋点类，调用LogReporter进行日志埋点
+ * 在入会之前，会将埋点缓存，入会后以每200ms一条的速度将缓存的埋点按顺序上报
+ */
+declare class LogClient {
+    protected reporter?: LogReporter;
+    protected param?: any;
+    protected msgCacheArr: any[];
+    protected index: number;
+    constructor();
+    start(info: AliRtcAuthInfo): void;
+    /**
+     * 断开连接
+     */
+    stop(): void;
+    /**
+     * 发送一条日志
+     * @param {any} log
+     */
+    sendReport(log: any): void;
+    /**
+     * 初始化公共参数
+     */
+    protected initParam(info: AliRtcAuthInfo): void;
+    /**
+     * 通过LogReporter发送日志
+     * @param log
+     */
+    protected realSendReport(log: any): void;
+}
+
+declare interface MediaTrackInfo {
+    ssrc: string;
+    msid: string;
+    red: number;
+    codec: CodecType;
+    sample?: number;
+    pt: number;
+    type?: CmdType;
+}
+
+declare enum MPU_TASK_TRANSACTION_TYPE {
+    MPU_TASK_TRANSACTION_START = 0,
+    MPU_TASK_TRANSACTION_UPDATE = 1,
+    MPU_TASK_TRANSACTION_STOP = 2,
+    MPU_TASK_TRANSACTION_LIST = 3,
+    MPU_TASK_TRANSACTION_POLLING = 4,
+    MPU_TASK_TRANSACTION_ACKNOWLEDGE = 5,
+    MPU_TASK_TRANSACTION_END = 6
+}
+
+declare enum MsidType {
+    Audio = "sophon_audio",
+    VideoLarge = "sophon_video_camera_large",
+    VideoSmall = "sophon_video_camera_small",
+    Screen = "sophon_video_screen_share"
+}
+
+declare class PluginManager extends default_2<PluginManagerListener> {
+    private plugins;
+    add(plugin: AliRtcPlugin, options: any): void;
+    remove(name: string): void;
+    get(name: string): AliRtcPlugin | undefined;
+    has(name: string): boolean;
+    getAll(): AliRtcPlugin[];
+}
+
+declare interface PluginManagerListener {
+    added: (plugin: AliRtcPlugin) => void;
+    removed: (plugin: AliRtcPlugin) => void;
+    updated: (plugin: AliRtcPlugin) => void;
+}
+
+declare interface PreviewAllConfig {
+    primary?: boolean;
+    screen?: boolean;
+}
+
+declare interface PreviewConfig {
+    videoElement: HTMLVideoElement;
+    screen?: boolean;
+}
+
+declare interface PublishExtraParams {
+    vMsid?: string;
+    aMsid?: string;
+    isVideoSmall?: boolean;
+    isScreen?: boolean;
+    isAudio?: boolean;
+}
+
+declare interface PublishInfo {
+    userid: string;
+    sessionid: string;
+    displayname: string;
+    pubid?: string;
+    resume?: boolean;
+    subscribe: {
+        signal: string;
+        pullstreamurl: string;
+    };
+    callid: string;
+    tracks: TrackInfo[];
+    traceid?: string;
+    signaltid?: string;
+}
+
+declare type PublishOptions = StreamOptions & {
+    vMsid?: string;
+};
+
+declare interface PublishStreamInfo {
+    audio?: LocalStream;
+    video?: LocalStream;
+    videoSmall?: LocalStream;
+    screen?: LocalStream;
+    videoProfile?: LocalProfileManager;
+    screenProfile?: LocalProfileManager;
+}
+
+declare interface PublishUser {
+    callid: string;
+    clientrole?: string;
+    displayname: string;
+    subscribe?: {
+        pullstreamurl: string;
+    };
+    pubid?: string;
+    tracks?: TrackInfo[];
+    userid: string;
+}
+
+declare interface RefreshInfo {
+    pushstreamurl?: string;
+    users?: RefreshUser[];
+}
+
+declare interface RefreshUrlResult extends SignalingResult {
+    pushstreamurl?: string;
+    users?: RefreshUser[];
+}
+
+declare interface RefreshUser {
+    userid: string;
+    subscribe: {
+        pullstreamurl: string;
+    };
+}
+
+declare interface RemoteMediaTrackInfo extends MediaTrackInfo {
+    subscribed?: boolean;
+}
+
+declare class RemoteStreamInfo extends default_2<StreamListener> {
+    /**
+     * @ignore
+     */
+    static logName: string;
+    protected audioInfo: RemoteMediaTrackInfo;
+    protected videoLargeInfo: RemoteMediaTrackInfo;
+    protected videoSmallInfo: RemoteMediaTrackInfo;
+    protected screenInfo: RemoteMediaTrackInfo;
+    protected audioVolume: number;
+    protected audioMuted: boolean;
+    protected userStatus?: DeviceStatus;
+    constructor();
+    /**
+     * 远端流音频轨道信息
+     * @returns
+     */
+    getAudioInfo(): RemoteMediaTrackInfo;
+    /**
+     * 远端流视频轨道信息
+     * @returns
+     */
+    getVideoSmallInfo(): RemoteMediaTrackInfo;
+    /**
+     * 远端流视频轨道信息
+     * @returns
+     */
+    getVideoLargeInfo(): RemoteMediaTrackInfo;
+    /**
+     * 远端流屏幕共享轨道信息
+     * @returns
+     */
+    getScreenInfo(): RemoteMediaTrackInfo;
+    /**
+     * 远端流是否包含音频轨道
+     * @returns
+     */
+    get hasAudio(): boolean;
+    /**
+     * 远端流是否包含视频轨道
+     * @returns
+     */
+    get hasVideo(): boolean;
+    /**
+     * 远端流是否包含视频大流轨道
+     * @returns
+     */
+    get hasVideoLarge(): boolean;
+    /**
+     * 远端流是否包含视频小流轨道
+     * @returns
+     */
+    get hasVideoSmall(): boolean;
+    /**
+     * 远端流是否包含屏幕共享轨道
+     * @returns
+     */
+    get hasScreen(): boolean;
+    /**
+     * 是否订阅远端流音频轨道
+     * @returns
+     */
+    get isAudioSubscribing(): boolean;
+    /**
+     * 是否订阅远端流视频轨道
+     * @returns
+     */
+    get isVideoSubscribing(): boolean;
+    /**
+     * 是否订阅远端流视频大流轨道
+     * @returns
+     */
+    get isVideoLargeSubscribing(): boolean;
+    /**
+     * 是否订阅远端流视频小流轨道
+     * @returns
+     */
+    get isVideoSmallSubscribing(): boolean;
+    /**
+     * 是否订阅远端流屏幕共享轨道
+     * @returns
+     */
+    get isScreenSubscribing(): boolean;
+    get audioCodec(): CodecType;
+    get videoCodec(): CodecType;
+    get audioTrackInfo(): AliRtcAudioTrack;
+    get videoTrackInfo(): AliRtcVideoTrack;
+    updateTracks(tracks?: TrackInfo[]): UpdateTracksResult;
+    protected updateRemoteTrackSsrc(audioSsrc: string, videoLargeSsrc: string, videoSmallSsrc: string, screenSsrc: string): void;
+    updateRemoteTrackSubState(option: SubscribeOptions): any;
+    /**
+     * 更新远端用户设备状态
+     * @param status
+     * @returns {boolean} 状态改变返回true，否则返回false
+     */
+    updateRemoteUserDeviceStatus(status: string): boolean;
+}
+
+declare interface RemoteSubscribeOptions {
+    remoteUser: RemoteUser;
+    options: SubscribeOptions;
+}
+
+declare class RemoteUser extends User {
+    /**
+     * @ignore
+     */
+    static logName: string;
+    remoteCallid: string;
+    remoteUserInfo: AliRtcRemoteUserInfo;
+    protected localUserId: string;
+    protected lastPubId: string;
+    protected stream?: RemoteStream;
+    protected screenStream?: RemoteStream;
+    private viewMap;
+    private audioTrack?;
+    private audioElement?;
+    protected subscribed: boolean;
+    protected mediaStream?: MediaStream;
+    protected secondaryMediaStream?: MediaStream;
+    protected prevSubConfig?: SubConfig;
+    protected signalingManager: SignalingManager;
+    protected reporter: Reporter;
+    protected webTrackingClient: WebTrackingClient;
+    private wantSubAudio;
+    private wantSubVideo;
+    private wantSubScreen;
+    private defaultVideoStreamType;
+    private audioMuted;
+    private audioSubState;
+    private videoSubState;
+    private videoLargeSubState;
+    private videoSmallSubState;
+    private screenSubState;
+    streamInfo: RemoteStreamInfo;
+    streamUrl: string;
+    constructor(config: RemoteUserConfig);
+    isWantSubAudio(): boolean;
+    setWantSubAudio(value: boolean): void;
+    isWantSubVideo(): boolean;
+    setWantSubVideo(value: boolean): void;
+    isWantSubScreen(): boolean;
+    setWantSubScreen(value: boolean): void;
+    setRemoteDefaultVideoStreamType(type: AliRtcVideoStreamType): void;
+    setAudioMuted(value: boolean): void;
+    getAudioMuted(): boolean;
+    get hasAudioTrack(): boolean;
+    get hasVideoTrack(): boolean;
+    get hasVideoLargeTrack(): boolean;
+    get hasVideoSmallTrack(): boolean;
+    get hasScreenTrack(): boolean;
+    get isAudioSubscribing(): boolean;
+    get isVideoSubscribing(): boolean;
+    get isVideoLargeSubscribing(): boolean;
+    get isVideoSmallSubscribing(): boolean;
+    get isScreenSubscribing(): boolean;
+    get audioEnabled(): boolean;
+    get videoEnabled(): boolean;
+    get screenEnabled(): boolean;
+    get getAudioTrack(): MediaStreamAudioTrack | undefined;
+    get getCameraStream(): RemoteStream | undefined;
+    get getScreenStream(): RemoteStream | undefined;
+    setViewConfig(view: AliRtcLocalView, track: AliRtcVideoTrack): void;
+    /**
+     * 销毁
+     * @returns {Promise<void>}
+     */
+    clear(needStopSub?: boolean): Promise<void>;
+    /**
+     * 更新远端用户的设备状态
+     * @param {string} status
+     * @returns {void}
+     */
+    updateRemoteUserDeviceStatus(status: string): void;
+    /**
+     * 更新远端用户的推流状态，已经停止推流的 tracks 要 delete，或者整体 stop
+     * @param {string} callid
+     * @param {string} pullStreamUrl
+     * @param {TrackInfo[]} tracks
+     * @returns {Promise<TrackChangeState>}
+     */
+    updateRemoteTracks(callid: string, pullStreamUrl: string, _pubid: string, tracks?: TrackInfo[]): Promise<UpdateTracksResult>;
+    /**
+     * 订阅远端流
+     * @param {SubscribeOptions} options
+     * @returns {Promise<void>} 返回可播放的 MediaStream，可能为空。如果同时订阅了主流和辅流，只会返回主流对应的 MediaStream
+     */
+    subscribe(options?: SubscribeOptions): Promise<void>;
+    /**
+     * 订阅远端流
+     * @param {SubscribeOptions} options 订阅配置
+     * @param {boolean} secondary 是否订阅辅流
+     * @returns {Promise<SubscribeResult>}
+     */
+    private subscribeProxy;
+    /**
+     * 移除对某些轨道的订阅
+     * @param {UnSubscribeOptions} options 取消订阅轨道配置
+     * @returns {Promise<SubscribeResult>}
+     */
+    private subscribeDeleteTracks;
+    /**
+     * 移除对某些轨道的订阅
+     * @param {Partial<ISubConfigItem>} deleteTrack 删除订阅配置
+     * @returns {Promise<SubscribeResult>}
+     */
+    private subscribeDeleteProxy;
+    /**
+     * 用保存的订阅参数恢复订阅
+     */
+    restore(): void;
+    resumeAudio(): Promise<void | undefined>;
+    resumeVideo(videoTrack?: AliRtcVideoTrack): Promise<void>;
+    resumePlay(): void;
+    /**
+     * 停止订阅远端流
+     * @param {string} userId
+     * @param {UnSubscribeOptions} options
+     * @returns {Promise<void>}
+     */
+    stopSubscribe(options?: UnSubscribeOptions): Promise<void>;
+    /**
+     * 停止对某个拉流 URL 的订阅
+     * @param {url} pullStreamUrl
+     * @returns {Promise<SubscribeResult>}
+     */
+    private doStopSubscribe;
+    private updateStream;
+    private updateScreenStream;
+    private clearStream;
+    private clearScreenStream;
+    /**
+     * 尝试更新订阅
+     * 1. 需要新增订阅的情况：想要订阅 & 没有正在订阅 & 远端有流
+     */
+    updateSubscribe(): {
+        addOption: SubscribeOptions;
+        deleteOption: SubscribeOptions;
+    };
+    private handleAutoPlayFailed;
+    private handleVideoPlayFailded;
+    private playAudio;
+    private stopPlayAudio;
+    playAll(isScreen?: boolean): void;
+    /**
+     * 播放
+     */
+    private play;
+    stopPlayAll(isScreen?: boolean): void;
+    /**
+     * 是否开启声音
+     * @param {boolean} enable
+     * @returns {void}
+     */
+    toggleAudio(enable?: boolean): void;
+    /**
+     * 是否开启画面
+     * @param {boolean} enable
+     * @returns {void}
+     */
+    toggleVideo(enable?: boolean): void;
+    /**
+     * 是否开启画面
+     * @param {boolean} enable
+     * @returns {void}
+     */
+    toggleScreen(enable?: boolean): void;
+    getStats(): Promise<{
+        audio: AliRtcRemoteAudioStats[];
+        video: AliRtcRemoteVideoStats[];
+    }>;
+    /**
+     * 开启音量检测
+     * @param {number} interval 时间间隔
+     */
+    enableAudioVolumeIndication(interval: number): void;
+}
+
+declare interface RemoteUserConfig {
+    userId: string;
+    displayName: string;
+    rtsManager: RtsManager;
+    usersViewMap: {
+        [key: string]: RemoteUserViewMap;
+    };
+    reporter: Reporter;
+    webTrackingClient: WebTrackingClient;
+    signalingManager: SignalingManager;
+    localUserId: string;
+    audioVolumeIndicationInterval: number;
+}
+
+declare interface RemoteUserMap {
+    [userId: string]: RemoteUser;
+}
+
+declare interface RemoteUserStatus {
+    userid: string;
+    status: string;
+}
+
+declare interface RemoteUserViewMap {
+    cameraViews: HTMLVideoElement[];
+    screenViews: HTMLVideoElement[];
+}
+
+/**
+ * 日志埋点类
+ * 每个埋点暴露对应的接口
+ */
+declare class Reporter {
+    protected logClient: LogClient;
+    constructor();
+    /**
+     * 开始建立连接
+     * @param authInfo
+     */
+    start(info: AliRtcAuthInfo): void;
+    /**
+     * 断开连接
+     */
+    stop(): void;
+    /**
+     * 加入房间成功埋点
+     * @param {number} joinTime
+     * @param {number} result
+     * @param {string} tid
+     */
+    reportJoin(joinTime: number, result: number, tid: string): void;
+    /**
+     * 调用 client.join 入会上报事件及用户等信息
+     * @param {string} usrid 用户id
+     * @param {string} usrn 用户名
+     * @param {string} channelid 频道id
+     */
+    reportJoinInvoked(usrid: string, usrn: string, channelid: string): void;
+    /**
+     * 上报ice状态变化
+     * @param {string} calid
+     * @param {string} icestate
+     * @param {number} evt_seq
+     */
+    reportIceState(calid: string, icestate: string, evt_seq: number): void;
+    /**
+     * 用户离开频道事件埋点
+     * @param {number} leaveTime
+     * @param {number} result
+     * @param {string} tid
+     */
+    reportLeave(leaveTime: number, result: number, tid: string): void;
+    /**
+     * 调用 client.leave 离会上报事件
+     */
+    reportLeaveInvoked(): void;
+    /**
+     * 推流事件上报
+     * @param {string} callid
+     * @param {boolean} isLargeVideo
+     * @param {boolean} isSmallVideo
+     * @param {boolean} isScreenShare
+     * @param {boolean} isAudio
+     * @param {number} result
+     * @param {string} tid
+     * @param {number} pubTime
+     */
+    reportPublish(callid: string, isLargeVideo: boolean, isSmallVideo: boolean, isScreenShare: boolean, isAudio: boolean, result: number | undefined, tid: string, pubTime: number): void;
+    /**
+     * 调用 client.publish 推流上报事件及流轨道等信息
+     * @param {boolean} [isLargeVideo] 是否推视频大流
+     * @param {boolean} [isSmallVideo] 是否推视频小流
+     * @param {boolean} [isScreenShare] 是否推屏幕流
+     * @param {boolean} [isAudio] 是否推音频流
+     */
+    reportPublishInvoked(isLargeVideo?: boolean, isSmallVideo?: boolean, isScreenShare?: boolean, isAudio?: boolean): void;
+    /**
+     * republish事件上报
+     * @param callid
+     * @param islarge       是否推大流
+     * @param isScreenShare 是否推屏幕流
+     * @param isAudio       是否推音频流
+     * @param result        推流结果(0成功，非0失败)
+     * @param tid           tid
+     * @param repubTime     repub耗时
+     * @param msg           详情描述
+     */
+    reportRepublish(callid: string, isLarge: boolean, isScreen: boolean, isAudio: boolean, result: number, tid: string, repubTime: number, msg: string): void;
+    /**
+     * 用户调用LocalStream.addTrack 或者 LocalStream.removeTrack
+     * @param callid
+     * @param trackType
+     * @param state       -1: remove 0: replace 1: add
+     */
+    reportRepublishInvoked(callid: string, trackType: string, state: 0 | 1 | -1): void;
+    /**
+     * 停止推流事件上报
+     * @param {string} callid
+     * @param {number} unpubTime
+     * @param {number} result
+     * @param {string} tid
+     */
+    reportUnpublish(callid: string, unpubTime: number, result: number, tid: string): void;
+    /**
+     * 调用 client.unpublish 停止推流上报事件
+     */
+    reportUnpublishInvoked(): void;
+    /**
+     * 订阅事件埋点
+     * @param {string} callid
+     * @param {string} remoteid
+     * @param {boolean} isLargeVideo
+     * @param {boolean} isSmallVideo
+     * @param {boolean} isScreenShare
+     * @param {boolean} isAudio
+     * @param {number} result
+     * @param {string} tid
+     * @param {number} subTime
+     */
+    reportSubscribe(callid: string, remoteid: string, isLargeVideo: boolean, isSmallVideo: boolean, isScreenShare: boolean, isAudio: boolean, result: number, tid: string, subTime: number, usrid: string): void;
+    /**
+     * 调用 client.subscribe 拉流上报事件及用户信息、流轨道等信息
+     * @param {string} rmtid 远程流所属的用户id
+     * @param {boolean} [isLargeVideo] 是否推视频大流
+     * @param {boolean} [isSmallVideo] 是否推视频小流
+     * @param {boolean} [isScreenShare] 是否推屏幕流
+     * @param {boolean} [isAudio] 是否推音频流
+     */
+    reportSubscribeInvoked(rmtid?: string, isLargeVideo?: boolean, isSmallVideo?: boolean, isScreenShare?: boolean, isAudio?: boolean): void;
+    /**
+     * 停止订阅事件埋点
+     * @param {string} callid
+     * @param {string} remoteid
+     * @param {number} unsubTime
+     * @param {number} result
+     * @param {string} tid
+     */
+    reportUnsubscribe(callid: string, remoteid: string, unsubTime: number, result: number, tid: string): void;
+    /**
+     * 调用 client.unsubscribe 停止拉流上报事件
+     * @param {string} rmtid 远程流所属的用户id
+     */
+    reportUnsubscribeInvoked(rmtid?: string): void;
+    /**
+     * 更新角色埋点
+     * @param {string|undefined} or 旧的角色
+     * @param {string} nr 新的角色
+     * @param {number} ctm 耗时
+     * @param {number} rslt 是否成功
+     */
+    reportRoleUpdate(or: string | undefined, nr: string, ctm: number, rslt: number): void;
+    /**
+     * 调用 client.setClientRole 更新角色上报事件
+     * @param {string} nr 新角色值
+     */
+    reportRoleUpdateInvoked(nr: string): void;
+    /**
+     * 设置camera videoprofile
+     */
+    reportVideoProfile(profile: string): void;
+    /**
+     * 设置screenshare videoprofile
+     */
+    reportScreenProfile(profile: string): void;
+    /**
+     * 错误事件埋点
+     * @param err
+     */
+    reportError(err: any): void;
+    /**
+     * 日志埋点
+     * 在埋点中增加tm字段，表示发生埋点的客户端本地时间
+     * @param {any} param 埋点内容
+     */
+    protected log(param: any): void;
+    /**
+     * 将Object转换成string
+     * @param {any} data
+     * @returns {string}
+     */
+    protected data2String(data: any): string;
+}
+
+/**
+ * RoomServerMessageCenter支持的事件
+ */
+declare interface RoomServerListener {
+    onJoinChannelResult: (data: any) => void;
+    onPublishResult: (code: number, tid: string, description: string) => void;
+    onNotifyJoin: (users: JoinInfo[]) => void;
+    onNotifyStatus: (users: RemoteUserStatus[]) => void;
+    onLeaveResult: (code: number, tid: string) => void;
+    onRoleUpdateResult: (code: number, tid: string, description: string) => void;
+    onRefreshUrlResult: (data: any) => void;
+    onNotifyLeave: (users: LeaveInfo[]) => void;
+    onNotifyPublish: (users: PublishUser[]) => void;
+    onStatusReport: (code: number, tid: string, description: string) => void;
+    onBye: (reason: AliRtcOnByeType, description: string) => void;
+    onKeepAliveRsp: () => void;
+    onConnectFail: (err: AliRtcError) => void;
+    onNetworkError: (err: AliRtcError) => void;
+    onAuthInvalid: () => void;
+    onReconnectStart: () => void;
+    onReconnectFail: (err: AliRtcError) => void;
+    onReconnectSuccess: (users: JoinInfo[]) => void;
+    onError: (err: AliRtcError) => void;
+}
+
+declare class RtsManager extends default_2<RtsManagerEventListener> {
+    /**
+     * @ignore
+     */
+    static logName: string;
+    private rts;
+    private encodedInsertableStreams;
+    private audioRedEnabled;
+    private localStreamManager;
+    private connecting;
+    private connected;
+    private connectionResolve?;
+    connectingPromise?: Promise<unknown>;
+    private dcResolve?;
+    dcConnectingPromise?: Promise<unknown>;
+    private _publishingTracks;
+    constructor(localStreamManager: LocalStreamManager);
+    setEncodedInsertableStreams(enable: boolean): void;
+    setAudioRedEnabled(enable: boolean): void;
+    destroy(): void;
+    private startConnect;
+    private setConnected;
+    get isConnecting(): boolean;
+    get isConnected(): boolean;
+    get publishingTracks(): TrackInfo[];
+    private getPubMsid;
+    private updatePublishingTracks;
+    private httpPublish;
+    private waitPublishSender;
+    private checkSubscribeStats;
+    getPublishVideoStats(streamUrl: string, msid?: string): Promise<unknown>;
+    getPublishAudioStats(streamUrl: string, msid?: string): Promise<unknown>;
+    publishAdd(streamUrl: string, stream: LocalStream, extra?: PublishExtraParams, isResume?: boolean, retryTimes?: number, waitSender?: boolean): Promise<string>;
+    publishDelete(streamUrl: string, options: PublishOptions): Promise<string>;
+    publishReplace(streamUrl: string, stream: LocalStream, extra?: PublishExtraParams): Promise<string>;
+    publishStop(streamUrl: string): Promise<string>;
+    unpublish(): Promise<void>;
+    /**
+     * 获取 sub/subAdd config
+     * @param {ISubscribeConfig | ISubConfigItem} options
+     * @returns {Omit<ISignalConfig | ISubConfigItem, 'url'>}
+     */
+    private getSubConfig;
+    private httpSubscribe;
+    private subscribeAdd;
+    subscibeDelete(subscribeOptions: RemoteSubscribeOptions): Promise<{
+        url: string;
+        stream: any;
+    } | undefined>;
+    subscibeStop(streamUrl: string): Promise<void>;
+    publish(streamUrl: string, isResume?: boolean): Promise<string>;
+    subscribe(remoteSubscribeOptions: RemoteSubscribeOptions): Promise<{
+        traceId: string;
+        stream: RemoteStream;
+    } | {
+        url: string;
+        stream: RemoteStream;
+        traceId?: string | undefined;
+    } | null>;
+    getSubscribeVideoStats(streamUrl: string, msid?: string): Promise<unknown>;
+    getSubscribeAudioStats(streamUrl: string, msid?: string): Promise<unknown>;
+    sendSEI(streamUrl: string, data: ArrayBuffer, repeatCount: number, payloadType: number): Promise<void>;
+}
+
+declare interface RtsManagerEventListener {
+    reconnecting: () => {};
+    disconnected: () => {};
+    connected: () => {};
+    subscribeexceeds: () => {};
+    seimessage: (url: string, payloadType: number, data: ArrayBuffer) => {};
+}
+
+declare class SignalingManager extends default_2<RoomServerListener> {
+    protected signaling?: ISignalingInterface;
+    protected authInfo?: AliRtcAuthInfo;
+    protected userName?: string;
+    protected channelProfile: AliRtcSdkChannelProfile;
+    protected clientRole: AliRtcSdkClientRole;
+    protected env: AliRtcEnv;
+    protected maxConnectRetryCount?: number;
+    constructor(channelProfile: AliRtcSdkChannelProfile, clientRole: AliRtcSdkClientRole, env?: AliRtcEnv);
+    reset(): void;
+    /**
+     * 向业务信令发送入会
+     * @param {AliRtcAuthInfo} authInfo
+     * @returns
+     */
+    join(authInfo: AliRtcAuthInfo, userName?: string, maxConnectRetryCount?: number): Promise<JoinResult>;
+    retryJoin(): void;
+    /**
+     * 向业务信令发送离会
+     * @returns
+     */
+    leave(): Promise<SignalingResult>;
+    /**
+     * 推流
+     * @param pubInfo
+     * @returns
+     */
+    publish(pubInfo: PublishInfo): Promise<SignalingResult>;
+    /**
+     * 通过透明通道发送设备状态
+     * @param {string} status
+     * @returns
+     */
+    reportStatus(status: string): Promise<void>;
+    /**
+     * 切换角色
+     * @param {AliRtcSdkClientRole} role
+     * @returns
+     */
+    setClientRole(role: AliRtcSdkClientRole): Promise<SignalingResult | undefined>;
+    /**
+     * 切换模式
+     * @param {AliRtcSdkChannelProfile} channelProfile
+     */
+    setChannelProfile(channelProfile: AliRtcSdkChannelProfile): void;
+    /**
+     * 更新推流url
+     * @param {RefreshInfo} info
+     * @returns
+     */
+    refreshUrl(info: RefreshInfo): Promise<RefreshUrlResult>;
+    refreshAuthInfo(authInfo: AliRtcRefreshAuthInfo): Promise<void>;
+    /**
+     * 监听业务信令相关的事件
+     */
+    protected initSignaling(): void;
+    /**
+     * 收到心跳消息
+     */
+    protected onKeepAliveRsp(): void;
+    /**
+     * 收到远端用户入会消息
+     * @param {JoinInfo[]} users
+     */
+    protected onNotifyJoin(users: JoinInfo[]): void;
+    /**
+     * 收到远端用户的透明通道消息
+     * @param {RemoteUserStatus[]} users
+     */
+    protected onNotifyStatus(users: RemoteUserStatus[]): void;
+    /**
+     * 收到远端用户的离会消息
+     * @param {LeaveInfo[]} users
+     */
+    protected onNotifyLeave(users: LeaveInfo[]): void;
+    /**
+     * 收到远端用户推流状态变化消息
+     * @param {PublishInfo[]} users
+     */
+    protected onNotifyPublish(users: PublishInfo[]): void;
+    /**
+     * 收到被踢掉消息
+     * @param {string} reason
+     * @param {string} description
+     */
+    protected onBye(reason: AliRtcOnByeType, description: string): void;
+    /**
+     * 收到连接失败消息
+     * @param {AliRtcError} err
+     */
+    protected onConnectFail(err: AliRtcError): void;
+    /**
+     * 收到网络异常消息
+     * @param {AliRtcError} err
+     */
+    protected onNetworkError(err: AliRtcError): void;
+    /**
+     * 收到网络异常消息
+     * @param {AliRtcError} _err
+     */
+    protected onAuthInvalid(_err: AliRtcError): void;
+    protected onReconnectStart(): void;
+    /**
+     * 收到重连成功消息
+     * @param {JoinInfo[]} users
+     */
+    protected onReconnectSuccess(users: JoinInfo[]): void;
+    /**
+     * 收到重连失败消息
+     */
+    protected onReconnectFail(err: AliRtcError): void;
+    /**
+     * 收到错误消息
+     * @param {AliRtcError} err
+     */
+    protected onError(err: AliRtcError): void;
+}
+
+declare interface SignalingResult {
+    tid: string;
+    code?: number;
+    message?: string;
+}
+
+declare interface StopPreviewConfig {
+    videoElement?: HTMLVideoElement;
+    primary?: boolean;
+    screen?: boolean;
+}
+
+declare type StopPublishOptions = StreamOptions;
+
+declare interface StreamListener {
+    [DeviceStatusChange.Remote]: (event: DeviceStatusChangeType) => void;
+    error: (err: AliRtcError) => void;
+}
+
+declare interface StreamOptions {
+    audio?: boolean;
+    video?: boolean;
+    screen?: boolean;
+}
+
+declare interface SubConfig {
+    isAudioSubscribing: boolean;
+    isVideoSubscribing: boolean;
+    isScreenSubscribing: boolean;
+    audioEnabled: boolean;
+    videoEnabled: boolean;
+    screenEnabled: boolean;
+}
+
+declare type SubscribeOptions = StreamOptions & {
+    vMsid?: string;
+};
+
+declare enum TrackEvent_2 {
+    VideoTrackEnded = "videoTrackEnded",
+    AudioTrackEnded = "audioTrackEnded",
+    ScreenTrackEnded = "screenTrackEnded"
+}
+
+declare interface TrackInfo {
+    ssrc: string;
+    codec: string;
+    msid?: MsidType;
+    type: string;
+    from?: string | undefined;
+    userdata?: string;
+    trackId?: string;
+    attr?: Record<string, any>;
+    pt?: number;
+}
+
+declare type UnSubscribeOptions = SubscribeOptions;
+
+declare interface UpdateTracksResult {
+    restoreSub?: boolean;
+}
+
+declare class User extends default_2<UserListener> {
+    protected uid: string;
+    protected name: string;
+    protected rtsManager: RtsManager;
+    callid: string;
+    protected audioLevelMonitor: AudioLevelMonitor;
+    protected audioVolumeIndicationInterval: number;
+    constructor(userId: string, displayname: string, rtsManager: RtsManager, interval: number);
+    get userId(): string;
+    get displayname(): string;
+    setUserInfo(uid: string, displayName: string): void;
+    refreshUserInfo(uid: string): void;
+    /**
+     * 获取音频 level
+     */
+    getAudioLevel(): number;
+    enableAudioVolumeIndication(interval: number): void;
+    /**
+     * 销毁用户，清空数据
+     */
+    clear(): void;
+}
+
+declare interface UserListener {
+    [DeviceStatusChange.Local]: (status: string) => void;
+    [DeviceStatusChange.Remote]: (event: DeviceStatusChangeType, userId: string) => void;
+    [ClientEventType.PullStreamStats]: (userId: string, stat: any, pullStreamUrl: string) => void;
+    [ClientEventType.RtsSubscribeExceeds]: (userId: string, options?: SubscribeOptions) => void;
+    [TrackEvent_2.VideoTrackEnded]: () => void;
+    [TrackEvent_2.AudioTrackEnded]: () => void;
+    [TrackEvent_2.ScreenTrackEnded]: () => void;
+    remoteTrackAvailableChange: (uid: string, aliRtcAudioTrack: AliRtcAudioTrack, aliRtcVideoTrack: AliRtcVideoTrack) => void;
+    audioSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number) => void;
+    videoSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number) => void;
+    screenSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number) => void;
+    audioPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number) => void;
+    videoPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number) => void;
+    dualStreamPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number) => void;
+    screenPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number) => void;
+    localDeviceException: (localDeviceType: AliRtcEngineLocalDeviceType, localDeviceExceptionType: AliRtcEngineLocalDeviceExceptionType, description: string) => void;
+    remoteAudioAutoPlayFail: (uid: string) => void;
+    remoteVideoAutoPlayFail: (uid: string, track: AliRtcVideoTrack) => void;
+    remoteSubscribeError: (error: AliRtcError) => void;
+}
+
+declare class UserManager extends default_2<UserManagerListener> {
+    /**
+     * @ignore
+     */
+    static logName: string;
+    protected self: LocalUser | undefined;
+    protected userMap: RemoteUserMap;
+    private usersViewMap;
+    rtsManager: RtsManager;
+    protected localStreamManager: LocalStreamManager;
+    protected authInfo?: AliRtcAuthInfo;
+    protected signalingManager: SignalingManager;
+    pluginManager: PluginManager;
+    protected reporter: Reporter;
+    protected webTrackingClient: WebTrackingClient;
+    private statsMonitorId?;
+    private autoSubAudio;
+    private autoSubVideo;
+    private autoSubScreen;
+    private wantSubAudio;
+    private wantSubVideo;
+    private wantSubScreen;
+    private defaultStreamType;
+    private audioMuted;
+    private audioVolumeIndicationInterval;
+    private indicationTimer;
+    constructor(config: UserManagerConfig);
+    private addSignalingManagerListener;
+    isAutoSubAudio(): boolean;
+    setAutoSubAudio(value: boolean): void;
+    isAutoSubVideo(): boolean;
+    setAutoSubVideo(value: boolean): void;
+    isAutoSubScreen(): boolean;
+    setAutoSubScreen(value: boolean): void;
+    isWantSubAudio(): boolean;
+    setWantSubAudio(value: boolean): void;
+    isWantSubVideo(): boolean;
+    setWantSubVideo(value: boolean): void;
+    isWantSubScreen(): boolean;
+    setWantSubScreen(value: boolean): void;
+    setRemoteDefaultVideoStreamType(type: AliRtcVideoStreamType): void;
+    setRemoteUserVideoStreamType(userId: string, type: AliRtcVideoStreamType): void;
+    setAudioMuted(mute: boolean): void;
+    setLocalViewConfig(view: AliRtcLocalView, track: AliRtcVideoTrack): void;
+    setRemoteViewConfig(uid: string, view: AliRtcLocalView, track: AliRtcVideoTrack): void;
+    get channel(): string | undefined;
+    get userId(): string | undefined;
+    get remoteUsers(): RemoteUser[];
+    /**
+     * 获取推流对象，只能是自己
+     */
+    get publisher(): LocalUser | undefined;
+    get isSubscribing(): boolean;
+    /**
+     * 处理远端用户推流状态变化
+     * @param {string} userId
+     * @param {string} displayname
+     * @param {string} callid
+     * @param {string} pullStreamUrl
+     * @param {TrackInfo[]} tracks
+     * @returns {void}
+     */
+    onRemotePublishStateChange(publishInfo: PublishUser): void;
+    /**
+     * 登陆成功后初始化用户管理，创建自己
+     * @param {AliRtcAuthInfo} authInfo
+     * @param {string} pushStreamUrl
+     * @returns {Promise<void>}
+     */
+    init(authInfo: AliRtcAuthInfo, data: JoinResult): void;
+    /**
+     * 离会后清除所有数据
+     * @returns {Promise<void>}
+     */
+    clear(): Promise<void>;
+    private startStatsMonitor;
+    private stopStatsMonitor;
+    /**
+     * 根据userId获取RemoteUser
+     * @param {string} userId
+     * @param {string} displayname
+     * @returns {RemoteUser}
+     */
+    getUser(userId: string, displayname: string): RemoteUser;
+    /**
+     * 添加远端用户
+     * @param {string} userId
+     * @param {string} displayName
+     * @returns {void}
+     */
+    addUser(userId: string, displayName: string): RemoteUser;
+    /**
+     * 执行添加远端用户
+     * @param {string} userId
+     * @param {string} displayName
+     * @returns {RemoteUser}
+     */
+    private executeAddUser;
+    /**
+     * 远端用户设备状态变化
+     * @param {DeviceStatusChangeType} event
+     * @param {string} userId
+     */
+    private onRemoteDeviceStatusChange;
+    /**
+     * 远端流数据采集上报
+     * @param {any} stat
+     */
+    private onRemoteStatReport;
+    /**
+     * rts 单 PC 订阅超限
+     */
+    private onSubscribeExceeds;
+    /**
+     * 移除远端用户
+     * @param {LeaveInfo} user
+     * @returns {Promise<void>}
+     */
+    removeLeftUser(user: LeaveInfo): Promise<void>;
+    /**
+     * 更新远端用户数据
+     * @param {JoinInfo[]} users
+     * @returns {{joinList: JoinInfo[], leaveList: LeaveInfo[], presentList: JoinInfo[]}}
+     */
+    updateUsers(users: JoinInfo[]): {
+        joinList: JoinInfo[];
+        leaveList: LeaveInfo[];
+        presentList: JoinInfo[];
+    };
+    /**
+     * 根据 userId 获取 RemoteUser
+     * @param {string} userId
+     * @returns {RemoteUser | undefined}
+     */
+    getRemoteUser(userId: string): RemoteUser | undefined;
+    /**
+     * 更新远端用户设备信息
+     * @param {RemoteUserStatus} user
+     * @returns {boolean} true: 用户状态改变  false: 用户状态没有改变
+     */
+    updateRemoteUserDeviceStatus(user: RemoteUserStatus): void;
+    updateAudioWant(uid: string, sub: boolean): void;
+    updateVideoWant(uid: string, sub: boolean): void;
+    updateScreenWant(uid: string, sub: boolean): void;
+    private stopIndication;
+    private startIndication;
+    enableAudioVolumeIndication(interval: number): void;
+    refreshAuthInfo(authInfo: AliRtcRefreshAuthInfo): void;
+    setEnableMediaExtensionMsg(enable: boolean): void;
+    setAudioRedEnabled(enable: boolean): void;
+}
+
+declare interface UserManagerConfig {
+    reporter: Reporter;
+    webTrackingClient: WebTrackingClient;
+    signalingManager: SignalingManager;
+}
+
+declare interface UserManagerListener {
+    [ClientEventType.RtsSubscribeExceeds]: (userId: string, options?: SubscribeOptions) => void;
+    [DeviceStatusChange.Remote]: (event: DeviceStatusChangeType, userId: string) => void;
+    [ClientEventType.PullStreamStats]: (userId: string, stat: any, pullStreamUrl: string) => void;
+    remoteTrackAvailableChange: (uid: string, aliRtcAudioTrack: AliRtcAudioTrack, aliRtcVideoTrack: AliRtcVideoTrack) => void;
+    audioSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    videoSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    screenSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    userAudioMuted: (uid: string, isMute: boolean) => void;
+    userVideoMuted: (uid: string, isMute: boolean) => void;
+    userScreenMuted: (userId: string, isMute: boolean) => void;
+    audioVolume: (speakers: {
+        userId: string;
+        volume: number;
+    }[]) => void;
+    rtcLocalVideoStats: (stats: AliRtcLocalVideoStats[]) => void;
+    rtcLocalAudioStats: (stats: AliRtcLocalAudioStats[]) => void;
+    rtcRemoteVideoStats: (stats: AliRtcRemoteVideoStats[]) => void;
+    rtcRemoteAudioStats: (stats: AliRtcRemoteAudioStats[]) => void;
+    remoteAudioAutoPlayFail: (uid: string) => void;
+    remoteVideoAutoPlayFail: (uid: string, track: AliRtcVideoTrack) => void;
+    remoteSubscribeError: (error: AliRtcError) => void;
+}
+
+declare interface VideoScaler {
+    getVideoTrack: () => MediaStreamTrack;
+    updateOptions: (options: VideoScalerOptions) => void;
+    dispose: () => void;
+}
+
+declare class VideoScalerFactory {
+    static isSupport(): boolean;
+    /**
+     * 获取实例
+     * @param {MediaStreamTrack} videoTrack
+     * @param {IProfile} profile
+     * @return {VideoScaler}
+     */
+    static getInstance(videoTrack: MediaStreamTrack, options: VideoScalerOptions): VideoScaler;
+}
+
+declare interface VideoScalerOptions {
+    width: number;
+    height: number;
+    frameRate: number;
+}
+
+declare enum VideoStreamSource {
+    Camera = 0,
+    Screen = 1,
+    Image = 2
+}
+
+declare interface WebTrackConfig {
+    biz: string;
+    extraParams?: string;
+}
+
+declare class WebTrackingClient {
+    protected index: number;
+    private tracker?;
+    private enable;
+    private commonParams;
+    constructor(config?: WebTrackConfig | boolean);
+    updateAuthInfo(info: AliRtcAuthInfo): void;
+    /**
+     * 调用加入房间API事件
+     * @param {AliRtcAuthInfo} authInfo 鉴权信息
+     */
+    reportJoinChannel(authInfo: AliRtcAuthInfo): void;
+    /**
+     * @method: 调用加入房间结果
+     * @param { rslt: 执行结果 code，0为成功，错误返回其他错误码 }
+         * @param { message: 执行结果，成功返回 success，失败返回失败 message }
+             * @param { ct: 耗时 }
+                 * @return {*}
+                 */
+             reportJoinChannelRes(rslt: number, message: string, ct: number): void;
+             /**
+              * 离会调用通知
+              */
+             reportLeaveChannel(): void;
+             /**
+              * 推流成功
+              * @param {string} calid（失败时为空）
+              * @param {boolean} isvl 是否推大流
+              * @param {boolean} isvs 是否推小流
+              * @param {boolean} isvss 是否推屏幕共享流
+              * @param {boolean} isaudio 是否推音频流
+              * @param {number} rslt 推流结果：成功0，失败错误码
+              * @param {string} tid 房间信令 tid
+              * @param {number} pubtm 执行推流到推流结束信令通知结束的耗时
+              * @param {number} est 开始时间
+              * @param {string} dctid 使用 datachannel 的 traceId
+              * @param {string} httptid 使用 http 建连的 traceId
+              * @param {string} url 推流地址
+              */
+             reportPush(calid: string, isvl: boolean, isvs: boolean, isvss: boolean, isaudio: boolean, rslt: number, tid: string, pubtm: number, est: number, dctid: string, httptid: string, url: string): void;
+             /**
+              * 拉流成功
+              * @param {string} calid 鉴权 callid (失败为空)
+              * @param {string} rmtid 远端用户 userId
+              * @param {boolean} isvl 是否拉视频大流
+              * @param {boolean} isvs 是否拉视频小流
+              * @param {boolean} isvss 是否拉屏幕分享流
+              * @param {boolean} isaudio 是否拉音频流
+              * @param {number} rslt 拉流结果：成功0，失败错误码
+              * @param {number} subtm 订阅耗时
+              * @param {string} dctid 使用 datachannel 的 traceId
+              * @param {string} httptid 使用 http 建连的 traceId
+              * @param {string} url 拉流地址
+              * @param {number} est 开始时间
+              */
+             reportPull(calid: string, rmtid: string, isvl: boolean, isvs: boolean, isvss: boolean, isaudio: boolean, rslt: number, subtm: number, dctid: string, httptid: string, url: string, est: number): void;
+             /**
+              * 上报订阅流的音频数据
+              * @param {string} rmtid 远端用户 userId
+              * @param {any} stats 流数据
+              */
+             reportSubscribeAudioStats(rmtid: string, stats: any): void;
+             /**
+              * 上报订阅流的视频数据
+              * @param {string} rmtid 远端用户 userId
+              * @param {any} stats 流数据
+              */
+             reportSubscribeVideoStats(rmtid: string, stats: any): void;
+             /**
+              * webTracking 埋点上报
+              * @param {string | number} msgId 事件标识
+              * @param {Record<string, any>} args 事件携带参数
+              * @param {Record<string, any>} params 单个打点携带的其他参数
+              */
+             protected report(msgId: string | number | EventId, args?: Record<string, any>, params?: Record<string, any>): void;
+             /**
+              * 上报环境监测的结果
+              */
+             static reportCheck(result: any, biz?: string): void;
+         }
+
+         export { }