aliyun-rtc-sdk 7.1.3 → 7.1.5

package/dist/plugins/audioProcessPlugin.d.ts

@@ -1437,6 +1437,7 @@ interface PackageAdaptInfo {
 }
 interface JoinResult {
     l1ip?: string;
+    l1subip?: string;
     pushstreamurl: string;
     tid: string;
     users: JoinInfo[];
@@ -1786,1722 +1787,1737 @@ interface LogInfo {
     [key: string]: string | number;
 }
 
-declare enum AliRtcLogLevel {
-    DEBUG = 0,
-    INFO = 1,
-    API = 2,
-    WARNING = 3,
-    ERROR = 4,
-    NONE = 5
+interface VideoScalerOptions {
+    width: number;
+    height: number;
+    frameRate: number;
 }
-
-interface AliRtcScreenShareStartConfig {
-    audio?: boolean;
-    videoTrack?: MediaStreamVideoTrack;
-    audioTrack?: MediaStreamAudioTrack;
+interface VideoScaler {
+    getVideoTrack: () => MediaStreamTrack;
+    updateOptions: (options: VideoScalerOptions) => void;
+    dispose: () => void;
 }
 
-declare enum AliRtcLiveTranscodingMixMode {
-    /*! 单路模式 */
-    LiveTranscodingSingle = 0,
-    /*! 混流模式 */
-    LiveTranscodingMix = 1
-}
-declare enum AliRtcLiveTranscodingStreamType {
-    /*! 原始流 */
-    LiveTranscodingOrigin = 0,
-    /*! 音频 */
-    LiveTranscodingAudio = 1,
-    /*! 视频 */
-    LiveTranscodingVideo = 2
-}
-declare enum AliRtcLiveTranscodingSourceType {
-    /*! 相机流 */
-    LiveTranscodingCamera = 0,
-    /*! 屏幕流 */
-    LiveTranscodingShareScreen = 1
-}
-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 enum AliRtcLiveTranscodingAudioSampleRate {
-    LiveTranscoding_HZ_48000 = 48000,
-    LiveTranscoding_HZ_44100 = 44100,
-    LiveTranscoding_HZ_32000 = 32000,
-    LiveTranscoding_HZ_16000 = 16000,
-    LiveTranscoding_HZ_8000 = 8000
-}
-declare enum AliRtcLiveTranscodingSegmentType {
-    /*! 无人像分割 */
-    LiveTranscodingNoBody = 0,
-    /*! 人像分割 */
-    LiveTranscodingBody = 1
-}
-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
-}
-declare enum AliRtcLiveTranscodingCropMode {
-    /*! 缩放模式 */
-    LiveTranscodingOrigin = 0,
-    /*! 剪裁 */
-    LiveTranscodingCrop = 1,
-    /*! 填充 */
-    LiveTranscodingFill = 2
-}
-declare enum AliRtcLiveTranscodingMediaProcessMode {
-    /*! 通用模式 */
-    LiveTranscodingNormal = 0,
-    /*! 虚拟背景模式 */
-    LiveTranscodingVirtualBackground = 1
-}
-declare enum AliRtcLiveTranscodingState {
-    LiveTranscodingState_IDLE = 0,
-    LiveTranscodingState_CONNNECT = 1,
-    LiveTranscodingState_RUNNING = 2,
-    LiveTranscodingState_RECOVERING = 3,
-    LiveTranscodingState_FAILURE = 4,
-    LiveTranscodingState_END = 5
-}
-declare enum AliRtcLiveTranscodingErrorCode {
-    LiveTranscodingErrorPublishOk = 0,
-    LiveTranscodingErrorStreamNotFound = 17825793,
-    LiveTranscodingErrorStreamAlreadyExist = 17825794,
-    LiveTranscodingErrorInvalidParam = 17825795,
-    LiveTranscodingErrorInternalError = 17825796,
-    LiveTranscodingErrorRtmpServerError = 17825797,
-    LiveTranscodingErrorRtmpStreamUrlError = 17825798,
-    LiveTranscodingErrorPublishTimeout = 17825799,
-    LiveTranscodingErrorNotAuthorized = 17825800
+declare class VideoScalerFactory {
+    static isSupport(): boolean;
+    /**
+     * 获取实例
+     * @param {MediaStreamTrack} videoTrack
+     * @param {IProfile} profile
+     * @return {VideoScaler}
+     */
+    static getInstance(videoTrack: MediaStreamTrack, options: VideoScalerOptions): VideoScaler;
 }
-declare enum AliRtcTrascodingPublishTaskStatus {
-    /*! 任务开始 */
-    TrascodingPublishTaskStatusStart = 0,
-    /*! 任务更新 */
-    TrascodingPublishTaskStatusUpdate = 1,
-    /*! 任务已停止 */
-    TrascodingPublishTaskStatusStop = 2
+
+interface AudioLevelMonitorListener {
+    audioLevel: (level: number) => void;
 }
-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 class AudioLevelMonitor extends EventEmitter$1<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 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);
+declare class LocalProfileManager {
+    private defaultProfile;
+    profile?: string;
+    profileMap: Map<string, IProfile>;
+    audioProfile?: AudioProfileKey;
+    contentHint?: string;
+    constructor(defaultProfile?: IProfile);
+    updateProfile(profileKey: string, profileValue?: Partial<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 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;
-    };
+interface PublishStreamInfo {
+    audio?: LocalStream;
+    video?: LocalStream;
+    videoSmall?: LocalStream;
+    screen?: LocalStream;
+    videoProfile?: LocalProfileManager;
+    screenProfile?: LocalProfileManager;
 }
 
-declare enum DisplayType {
-    NOT_DISPLAY = 0,
-    ALWAYS = 1,
-    WHEN_NO_VIDEO = 2
+interface PluginManagerListener {
+    added: (plugin: AliRtcPlugin) => void;
+    removed: (plugin: AliRtcPlugin) => void;
+    updated: (plugin: AliRtcPlugin) => void;
 }
-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;
-    };
+declare class PluginManager extends EventEmitter$1<PluginManagerListener> {
+    private plugins;
+    add(plugin: AliRtcPlugin, options?: any): void;
+    remove(name: string): void;
+    removeAll(): void;
+    get(name: string): AliRtcPlugin | undefined;
+    has(name: string): boolean;
+    getAll(): AliRtcPlugin[];
 }
 
-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;
-    };
-}
-
-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;
-    };
-}
-
-declare class LiveTranscodingMixParam {
-    taskProfile: AliRtcLiveTranscodingTaskProfile;
-    encodeParam?: AliRtcLiveTranscodingEncodeParam;
-    users: AliRtcTranscodingUser[];
-    backgroundColor: number;
-    backgrounds: AliRtcTranscodingImage[];
-    watermarks: AliRtcTranscodingImage[];
-    clockWidgets: AliRtcTranscodingClockWidget[];
-    cropMode?: AliRtcLiveTranscodingCropMode;
-    mediaProcessMode?: AliRtcLiveTranscodingMediaProcessMode;
-    constructor(taskProfile: AliRtcLiveTranscodingTaskProfile);
-}
-
-declare class AliRtcLiveTranscodingSingleParam {
-    userId?: string;
-    streamType?: AliRtcLiveTranscodingStreamType;
-    sourceType?: AliRtcLiveTranscodingSourceType;
-    constructor(uid?: string, streamType?: AliRtcLiveTranscodingStreamType, sourceType?: AliRtcLiveTranscodingSourceType);
-}
-
-declare class AliRtcLiveTranscodingParam {
-    /*! 旁路模式 */
-    mixMode: AliRtcLiveTranscodingMixMode;
-    /*! 路模式单路参数 */
-    singleParam?: AliRtcLiveTranscodingSingleParam;
-    /*! 旁路模式混流参数 */
-    mixParam?: LiveTranscodingMixParam;
-    constructor(mixMode?: AliRtcLiveTranscodingMixMode, singleParam?: AliRtcLiveTranscodingSingleParam, mixParam?: LiveTranscodingMixParam);
-    toJson(type: MPU_TASK_TRANSACTION_TYPE, authInfo: AliRtcAuthInfo, taskId: string, streamUrl?: string, messageId?: string): {
-        [key: string]: any;
-    };
-}
-
-interface AliRtcLocalAudioStats {
-    track: AliRtcAudioTrack;
-    stats: any;
-}
-
-interface AliRtcLocalVideoStats {
-    track: AliRtcVideoTrack;
-    streamType?: AliRtcVideoStreamType;
-    stats: any;
-}
-
-interface AliRtcRemoteAudioStats {
-    uid: string;
-    track: AliRtcAudioTrack;
-    stats: any;
-}
-
-interface AliRtcRemoteVideoStats {
-    uid: string;
-    track: AliRtcVideoTrack;
-    streamType?: AliRtcVideoStreamType;
-    stats: any;
-}
-
-declare enum AliRtcDataMsgType {
-    AliEngineDataMsgNone = 0,
-    AliEngineDataMsgMusicProgress = 1,
-    AliEngineDataMsgCustom = 2
-}
-declare class AliRtcDataChannelMsg {
-    data: ArrayBuffer;
-    networkTime: number;
-    futureOrProgress: number;
-    type: AliRtcDataMsgType;
-    constructor(data: ArrayBuffer, type?: AliRtcDataMsgType, networkTime?: number, progress?: number);
-    toBuffer(): ArrayBuffer;
-    static parse(buffer: ArrayBuffer): AliRtcDataChannelMsg | undefined;
+interface LocalStreamManagerListener {
+    trackended: (type: TrackEvent) => {};
+    publishupdate: () => {};
 }
-
-interface AliRtcEngineEventListener {
+declare class LocalStreamManager extends EventEmitter$1<LocalStreamManagerListener> {
     /**
-     * @brief 网络连接状态改变
-     * @param status 连接状态
-     * @param reason 连接状态变化原因
+     * @ignore
      */
-    connectionStatusChange: (status: AliRtcConnectionStatus, reason: AliRtcConnectionStatusChangeReason) => void;
+    static logName: string;
+    private pluginManager;
+    private slsReporter;
+    private publishingCameraVideoStream;
+    private publishingScreenVideoStream;
+    cameraStreamInfo: AliRtcLocalStreamInfo;
+    screenStreamInfo: AliRtcLocalStreamInfo;
+    private streamInfos;
+    private _audioCaptureDisabled;
+    private _cameraCaptureDisabled;
+    private _publishLocalAudioStreamEnabled;
+    private _publishLocalVideoStreamEnabled;
+    private _publishLocalScreenStreamEnabled;
+    constructor(pluginManager: PluginManager, slsReporter: SLSReporter);
+    get hasCamera(): boolean;
+    get audioCaptureDisabled(): boolean;
+    set audioCaptureDisabled(closed: boolean);
+    get cameraCaptureDisabled(): boolean;
+    set cameraCaptureDisabled(closed: boolean);
+    setAudioMuted(muted: boolean): void;
+    get isAudioMuted(): boolean;
+    setCameraMuted(muted: boolean): void;
+    get isCameraMuted(): boolean;
+    setScreenMuted(muted: boolean): void;
+    get isScreenMuted(): boolean;
+    get publishLocalAudioStreamEnabled(): boolean;
+    set publishLocalAudioStreamEnabled(enable: boolean);
+    get publishLocalVideoStreamEnabled(): boolean;
+    set publishLocalVideoStreamEnabled(enable: boolean);
+    get publishLocalScreenStreamEnabled(): boolean;
+    set publishLocalScreenStreamEnabled(enable: boolean);
+    updateStreams(): Promise<void>;
+    private setAvailableCameraDeviceId;
+    private setAvailableMicrophoneDeviceId;
     /**
-     * @brief 本地设备异常回调
-     * @param deviceType 设备类型, 参考{@link AliRtcEngine.AliRtcEngineLocalDeviceType}
-     * @param exceptionType 设备异常类型, 参考{@link AliRtcEngine.AliRtcEngineLocalDeviceExceptionType}
-     * @param msg 异常时携带的信息
-     * @note 此回调标识了内部无法恢复了设备异常，收到此回调时用户需要检查设备是否可用
+     * 创建 LocalStream
+     * @param {LocalStreamConfig} params 创建 LocalStream 的配置
+     * @returns {LocalStream} 当前创建的 LocalStream
      */
-    localDeviceException: (localDeviceType: AliRtcEngineLocalDeviceType, localDeviceExceptionType: AliRtcEngineLocalDeviceExceptionType, description: string) => void;
+    createLocalStream(params: LocalStreamConfig): Promise<LocalStream | undefined>;
     /**
-     * @brief 用户鉴权信息即将过期通知，收到后30秒鉴权过期
-     * @note 该回调在鉴权信息30秒前触发，收到该回调后应该及时更新鉴权信息，参考 {@link AliRtcEngine.refreshAuthInfo}
+     * 停止推流，底层调用 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;
+    }>;
     /**
-     * 被服务器踢出/会议结束频道的消息
-     * @param code 原因参考{@link AliRtcEngine.AliRtcOnByeType}
+     * 停止所有流
      */
-    bye: (code: AliRtcOnByeType) => void;
+    stop(): void;
     /**
-     * @brief 远端用户（通信模式）/（互动模式，主播角色）加入频道回调
-     * @details 该回调在以下场景会被触发
-     * - 通信模式：远端用户加入频道会触发该回调，如果当前用户在加入频道前已有其他用户在频道中，当前用户加入频道后也会收到已加入频道用户的回调
-     * - 互动模式：
-     *   - 远端主播角色用户加入频道会触发该回调，如果当前用户在加入频道前已有其他主播在频道中，当前用户加入频道后也会收到已加入频道主播的回调
-     *   - 远端观众角色调用 {@link AliRtcEngine.setClientRole} 切换为主播角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkInteractive}，同时设置了推流时，会触发该回调
-     *
-     * @param uid 用户ID，从App server分配的唯一标示符
-     * @param elapsed 用户加入频道时的耗时
-     * @note 互动模式下回调行为
-     * - 主播间可以互相收到加入频道回调
-     * - 观众可以收到主播加入频道回调
-     * - 主播无法收到观众加入频道回调
+     * 设置摄像头流 profile
+     * @param {LocalStream | null} stream
+     * @param {string} profileKey
+     * @param {IProfile} profile
      */
-    remoteUserOnLineNotify: (uid: string, elapsed: number) => void;
+    setVideoProfile(profileKey?: string, profile?: Partial<IProfile>, skipConstraints?: boolean): Promise<void>;
     /**
-     * @brief 远端用户（通信模式）/（互动模式，主播角色）离开频道回调
-     * @details 该回调在以下场景会被触发
-     * - 通信模式：远端用户离开频道会触发该回调
-     * - 互动模式：
-     *   - 远端主播角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkInteractive} 离开频道
-     *   - 远端主播切换调用 {@link AliRtcEngine.setClientRole} 切换为观众角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkLive}，会触发该回调
-     * - 通信模式和互动模式主播角色情况下，当长时间收不到远端用户数据，超时掉线时，会触发该回调
-     *
-     * @param uid 用户ID，从App server分配的唯一标示符
-     * @param reason 用户离线的原因，详见 {@link AliRtcEngine.AliRtcUserOfflineReason}
+     * 设置摄像头流 content hint
+     * @param {string} hint
+     * @note 不传则尝试复用之前的 hint
      */
-    remoteUserOffLineNotify: (uid: string, aliRtcUserOfflineReason: AliRtcUserOfflineReason) => void;
+    setVideoContentHint(hint?: string): 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 该回调仅在通信模式用户和互动模式下的主播角色才会触发
+     * 设置音频流 profile
+     * @param {string} profileKey
      */
-    remoteTrackAvailableNotify: (uid: string, aliRtcAudioTrack: AliRtcAudioTrack, aliRtcVideoTrack: AliRtcVideoTrack) => void;
+    setAudioProfile(profileKey: AudioProfileKey): Promise<void>;
     /**
-     * @brief 远端用户静音/取消静音回调
-     * @param uid 远端用户ID
-     * @param isMute 该用户是否静音
-     * - true: 静音
-     * - false: 取消静音
+     * 设置屏幕共享流 profile
+     * @param {LocalStream} stream
+     * @param {string} profileKey
+     * @param {IProfile} profile
      */
-    userAudioMuted: (uid: string, isMute: boolean) => void;
+    setScreenProfile(profileKey?: string, profile?: Partial<IProfile>): Promise<void>;
+    setScreenContentHint(hint?: string): void;
     /**
-     * @brief 对端用户发送视频黑帧数据发送通知
-     * @param uid 执行muteVideo的用户ID
-     * @param isMute
-     * - true: 推流黑帧
-     * - false: 正常推流
-     * @note 该接口用于对端用户发送视频黑帧数据时的回调
+     * 设置 cameraVideoConstraints
+     * @param {IVideoConstraints} cameraVideoConstraints
      */
-    userVideoMuted: (uid: string, isMute: boolean) => void;
+    setCameraVideoConstraints(cameraVideoConstraints: MediaTrackConstraints): 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 当前频道
+     * 设置 micAudioConstraints
+     * @param {IAudioConstraints} micAudioConstraints
      */
-    audioPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
+    setMicAudioConstraints(micAudioConstraints: MediaTrackConstraints): void;
+}
+
+interface DeviceStatus {
+    micOpen: boolean;
+    micInterrupted: boolean;
+    audioDisable: boolean;
+    cameraOpen: boolean;
+    videoDisable: boolean;
+    screenShare: boolean;
+    screenDisable: boolean;
+    backgroundMode: boolean;
+    accompanyPlaying: boolean;
+}
+
+interface UpdateTracksResult {
+    restoreSub?: boolean;
+}
+declare class RemoteStreamInfo extends EventEmitter$1<StreamListener> {
     /**
-     * 音频订阅情况变更回调
-     * @param uid 用户ID
-     * @param oldState 之前的订阅状态
-     * @param newState 当前的订阅状态
-     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
-     * @param channel 当前频道
+     * @ignore
      */
-    audioSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    static logName: string;
+    protected audioInfo: RemoteMediaTrackInfo;
+    protected videoLargeInfo: RemoteMediaTrackInfo;
+    protected videoSmallInfo: RemoteMediaTrackInfo;
+    protected screenInfo: RemoteMediaTrackInfo;
+    protected dataInfo: RemoteMediaTrackInfo;
+    protected audioVolume: number;
+    protected audioMuted: boolean;
+    protected userStatus?: DeviceStatus;
+    constructor();
     /**
-     * 视频推流变更回调
-     * @param oldState 之前的推流状态
-     * @param newState 当前的推流状态
-     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
-     * @param channel 当前频道
+     * 远端流音频轨道信息
+     * @returns
      */
-    videoPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
+    getAudioInfo(): RemoteMediaTrackInfo;
     /**
-     * 次要流推流变更回调
-     * @param oldState 之前的推流状态
-     * @param newState 当前的推流状态
-     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
-     * @param channel 当前频道
+     * 远端流视频轨道信息
+     * @returns
      */
-    dualStreamPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
+    getVideoSmallInfo(): RemoteMediaTrackInfo;
     /**
-     * 屏幕分享推流变更回调
-     * @param oldState 之前的推流状态
-     * @param newState 当前的推流状态
-     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
-     * @param channel 当前频道
+     * 远端流视频轨道信息
+     * @returns
      */
-    screenSharePublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
+    getVideoLargeInfo(): RemoteMediaTrackInfo;
     /**
-     * DataChannel 推流变更回调
-     * @param oldState 之前的推流状态
-     * @param newState 当前的推流状态
-     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
-     * @param channel 当前频道
+     * 远端流屏幕共享轨道信息
+     * @returns
      */
-    dataPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
+    getScreenInfo(): RemoteMediaTrackInfo;
+    getDataInfo(): RemoteMediaTrackInfo;
+    get subscribingInfos(): RemoteMediaTrackInfo[];
+    get hasTrack(): boolean;
     /**
-     * 相机流订阅情况变更回调
-     * @param uid 用户ID
-     * @param oldState 之前的订阅状态
-     * @param newState 当前的订阅状态
-     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
-     * @param channel 当前频道
+     * 远端流是否包含音频轨道
+     * @returns
      */
-    videoSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    get hasAudio(): boolean;
     /**
-     * 大小流订阅情况变更回调
-     * @param uid 用户ID
-     * @param oldStreamType 之前的订阅状态
-     * @param newStreamType 当前的订阅状态
-     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
-     * @param channel 当前频道
+     * 远端流是否包含视频轨道
+     * @returns
      */
-    subscribeStreamTypeChanged: (uid: string, oldStreamType: AliRtcVideoStreamType, newStreamType: AliRtcVideoStreamType, elapseSinceLastState: number, channel: string) => void;
+    get hasVideo(): boolean;
     /**
-     * 屏幕分享流订阅情况变更回调
-     * @param uid 用户ID
-     * @param oldState 之前的订阅状态
-     * @param newState 当前的订阅状态
-     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
-     * @param channel 当前频道
+     * 远端流是否包含视频大流轨道
+     * @returns
      */
-    screenShareSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    get hasVideoLarge(): boolean;
     /**
-     * DataChannel 订阅情况变更回调
-     * @param uid 用户ID
-     * @param oldState 之前的订阅状态
-     * @param newState 当前的订阅状态
-     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
-     * @param channel 当前频道
+     * 远端流是否包含视频小流轨道
+     * @returns
      */
-    dataSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    get hasVideoSmall(): boolean;
     /**
-     * 收到媒体扩展信息回调
-     * @param uid 用户ID，媒体信息发送用户的ID
-     * @param message 媒体扩展信息
-     * @param payloadType payload类型，sendMediaExtensionMsg返回5，sendMediaExtensionMsgEx发送的会返回具体类型
-     * @note 当一端通过 {@link AliRtcEngine.sendMediaExtensionMsg} 发送信息后，其他端通过该回调接收数据
+     * 远端流是否包含屏幕共享轨道
+     * @returns
      */
-    mediaExtensionMsgReceived: (uid: string, message: ArrayBuffer, payloadType: number) => void;
+    get hasScreen(): boolean;
+    get hasData(): boolean;
     /**
-     * @brief 用户鉴权信息即将过期通知，收到后30秒鉴权过期
-     * @note 该回调在鉴权信息30秒前触发，收到该回调后应该及时更新鉴权信息，参考 {@link AliRtcEngine.refreshAuthInfo:}
+     * 是否订阅远端流音频轨道
+     * @returns
      */
-    authInfoWillExpire: () => void;
+    get isAudioSubscribed(): boolean;
+    get isAudioSubscribing(): boolean;
     /**
-     * @brief 用户调用需要鉴权的接口，服务端返回信息过期
-     * @note 该回调触发代表鉴权信息已过期，想要继续在会中，需要重新入会，参考 {@link AliRtcEngine.joinChannel:name:onResultWithUserId:}
+     * 是否订阅远端流视频轨道
+     * @returns
      */
-    authInfoExpired: () => {};
+    get isVideoSubscribed(): boolean;
+    get isVideoSubscribing(): boolean;
     /**
-     * 远程用户的音频自动播放失败
-     * @param uid
-     * @note 应该在收到该回调时弹出弹窗引导用户点击页面进行播放，用户点击页面后 SDK 会自动尝试播放
+     * 是否订阅远端流视频大流轨道
+     * @returns
      */
-    remoteAudioAutoPlayFail: (uid: string) => void;
+    get isVideoLargeSubscribed(): boolean;
+    get isVideoLargeSubscribing(): boolean;
     /**
-     * 远程用户的视频自动播放失败
-     * @param uid
-     * @note 应该在收到该回调时弹出弹窗引导用户点击页面进行播放，用户点击页面后 SDK 会自动尝试播放
+     * 是否订阅远端流视频小流轨道
+     * @returns
      */
-    remoteVideoAutoPlayFail: (uid: string, videoTrack: AliRtcVideoTrack) => void;
+    get isVideoSmallSubscribed(): boolean;
+    get isVideoSmallSubscribing(): boolean;
     /**
-     * 远程用户的音频播放出错
-     * @param uid 用户ID
-     * @param reason 出错原因，可选
+     * 是否订阅远端流屏幕共享轨道
+     * @returns
      */
-    remoteAudioPlayError: (uid: string, reason: string | undefined) => void;
+    get isScreenSubscribed(): boolean;
+    get isScreenSubscribing(): boolean;
+    get isDataSubscribed(): boolean;
+    get isDataSubscribing(): 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, dataSsrc: string): void;
+    markRemoteTrackSubscribing(option: SubscribeOptions): any;
+    updateRemoteTrackSubState(option: SubscribeOptions): any;
     /**
-     * 远程用户的视频播放出错
-     * @param uid 用户ID
-     * @param reason 出错原因，可选
+     * 更新远端用户设备状态
+     * @param status
+     * @returns {boolean} 状态改变返回true，否则返回false
      */
-    remoteVideoPlayError: (uid: string, reason: string | undefined) => void;
+    updateRemoteUserDeviceStatus(status: string): boolean;
+}
+
+type AliRtcLocalView = string | HTMLVideoElement | string[] | HTMLVideoElement[] | null;
+
+interface AliRtcRemoteAudioStats {
+    uid: string;
+    track: AliRtcAudioTrack;
+    stats: any;
+}
+
+interface AliRtcRemoteVideoStats {
+    uid: string;
+    track: AliRtcVideoTrack;
+    streamType?: AliRtcVideoStreamType;
+    stats: any;
+}
+
+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;
+    get audioElement(): HTMLAudioElement | undefined;
+}
+
+interface RemoteUserViewMap {
+    cameraViews: HTMLVideoElement[];
+    screenViews: HTMLVideoElement[];
+}
+declare class RemoteUser extends User {
     /**
-     * 远程用户订阅数据通道
-     * @param uid 用户ID
+     * @ignore
      */
-    remoteUserSubscribedDataChannel: (uid: string) => void;
-    /**
-     * rtc 传输数据统计
-     * @param stats 统计信息
-     */
-    rtcStats: (stats: any) => void;
+    static logName: string;
+    remoteCallid: string;
+    remoteUserInfo: AliRtcRemoteUserInfo;
+    protected localUser?: LocalUser;
+    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 slsReporter: SLSReporter;
+    private wantSubAudio;
+    private wantSubVideo;
+    private wantSubScreen;
+    private defaultVideoStreamType;
+    private audioMuted;
+    private playoutVolume;
+    private playoutGainNode?;
+    private audioSubState;
+    private videoSubState;
+    private videoLargeSubState;
+    private videoSmallSubState;
+    private screenSubState;
+    private dataSubState;
+    private dc;
+    private dcMsgWaitingPieces;
+    streamInfo: RemoteStreamInfo;
+    private _streamUrl;
+    private parameter;
+    private monitorTimerId?;
+    private monitorDataCache;
+    private trackTraceIdMap;
+    constructor(config: RemoteUserConfig);
+    get streamUrl(): string;
+    set streamUrl(value: string);
+    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;
+    getAudioElement(): HTMLAudioElement | undefined;
+    private handleAudioContextSuspended;
+    setPlayoutVolume(value: number): 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 isDataSubscribing(): 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;
     /**
-     * 发布视频流的数据统计
-     * @param aliRtcStats 统计信息
+     * 销毁
+     * @returns {Promise<void>}
      */
-    rtcLocalVideoStats: (stats: AliRtcLocalVideoStats[]) => void;
+    clear(needStopSub?: boolean): Promise<void>;
     /**
-     * 发布音频流的数据统计
-     * @param aliRtcStats 统计信息
+     * 更新远端用户的设备状态
+     * @param {string} status
+     * @returns {void}
      */
-    rtcLocalAudioStats: (stats: AliRtcLocalAudioStats[]) => void;
+    updateRemoteUserDeviceStatus(status: string): void;
     /**
-     * 订阅视频流的数据统计
-     * @param aliRtcStats 统计信息
+     * 更新远端用户的推流状态，已经停止推流的 tracks 要 delete，或者整体 stop
+     * @param {string} callid
+     * @param {string} pullStreamUrl
+     * @param {TrackInfo[]} tracks
+     * @returns {Promise<TrackChangeState>}
      */
-    rtcRemoteVideoStats: (stats: AliRtcRemoteVideoStats[]) => void;
+    updateRemoteTracks(callid: string, pullStreamUrl: string, _pubid: string, tracks?: TrackInfo[]): Promise<UpdateTracksResult>;
     /**
-     * 订阅远端音频流的数据统计
-     * @param aliRtcStats 统计信息
+     * 订阅远端流
+     * @param {SubscribeOptions} options
+     * @returns {Promise<void>} 返回可播放的 MediaStream，可能为空。如果同时订阅了主流和辅流，只会返回主流对应的 MediaStream
      */
-    rtcRemoteAudioStats: (stats: AliRtcRemoteAudioStats[]) => void;
+    subscribe(options?: SubscribeOptions, reason?: SubscribeReason, startTs?: number): Promise<void>;
     /**
-     * @brief 错误通知
-     * @deprecated 请使用 occurError
-     * @details 如果engine出现error，通过这个回调通知app
-     * @param error  错误类型，参考 {@link AliRtcError}
-     * @param uid 用户 Id，不一定存在
+     * 订阅远端流
+     * @param {SubscribeOptions} options 订阅配置
+     * @param {boolean} secondary 是否订阅辅流
+     * @returns {Promise<SubscribeResult>}
      */
-    onOccurError: (error: AliRtcError, uid?: string) => void;
+    private subscribeProxy;
     /**
-     * @brief 错误通知
-     * @details 如果engine出现error，通过这个回调通知app
-     * @param error  错误类型，参考 {@link AliRtcError}
-     * @param uid 用户 Id，不一定存在
+     * 移除对某些轨道的订阅
+     * @param {UnSubscribeOptions} options 取消订阅轨道配置
+     * @returns {Promise<SubscribeResult>}
      */
-    occurError: (error: AliRtcError, uid?: string) => void;
+    private subscribeDeleteTracks;
     /**
-     * @brief 收到数据通道消息
-     * @param uid 用户ID
-     * @param message 消息
+     * 移除对某些轨道的订阅
+     * @param {Partial<ISubConfigItem>} deleteTrack 删除订阅配置
+     * @returns {Promise<SubscribeResult>}
      */
-    dataChannelMsg: (uid: string, message: AliRtcDataChannelMsg) => void;
+    private subscribeDeleteProxy;
     /**
-     * @brief AI agent处理结果
-     * @param code 返回code码
-     * @param action 结果对应的action
-     * @param result 结果
+     * 用保存的订阅参数恢复订阅
      */
-    AIAgentResult: (code: number, action: string, result: string) => void;
-}
-
-type AliRtcLocalView = string | HTMLVideoElement | string[] | HTMLVideoElement[] | null;
-
-interface AliEngineCameraCapturerConfiguration {
-    width?: number;
-    height?: number;
-    frameRate?: number;
-    maxSendFrameRate?: number;
-    bitrate?: number;
-    cameraDirection?: AliRtcCameraDirection;
-    deviceId?: string;
-}
-type VideoProfileWithSendFramerate = Partial<IProfile & {
-    maxSendFrameRate: number;
-}>;
-
-declare enum AliRtcRawDataStreamType {
-    /** 相机流 */
-    AliRtcSdkStreamTypeCapture = 0,
-    /** 屏幕共享流 */
-    AliRtcSdkStreamTypeScreen = 1
-}
-
-interface AliRtcVideoTrackConfig {
-    userId?: string;
-    streamType: AliRtcRawDataStreamType;
-}
-
-interface AudioLevelMonitorListener {
-    audioLevel: (level: number) => void;
-}
-declare class AudioLevelMonitor extends EventEmitter$1<AudioLevelMonitorListener> {
-    private audioContext;
-    private stream;
-    private sourceNode?;
-    private analyser?;
-    constructor();
-    getLevel(): number;
+    restore(): void;
+    resumeAudio(): Promise<void>;
+    resumeVideo(videoTrack?: AliRtcVideoTrack): Promise<void>;
+    resumePlay(): void;
     /**
-     * 开启监听 audio level 的变化
-     *
-     * @param {MediaStreamTrack} track 音频轨
-     * @param {number} [interval=1000] 检测间隔，单位毫秒，默认 1000ms
+     * 停止订阅远端流
+     * @param {string} userId
+     * @param {UnSubscribeOptions} options
+     * @returns {Promise<void>}
      */
-    start(track: MediaStreamTrack, interval?: number): void;
-    stop(): void;
-    dispose(): void;
-}
-
-declare class LocalProfileManager {
-    private defaultProfile;
-    profile?: string;
-    profileMap: Map<string, IProfile>;
-    audioProfile?: AudioProfileKey;
-    contentHint?: string;
-    constructor(defaultProfile?: IProfile);
-    updateProfile(profileKey: string, profileValue?: Partial<IProfile>): void;
-    get videoProfile(): string | undefined;
-    updateAudioProfile(profileKey: AudioProfileKey): void;
-    setContentHint(videoTrack: MediaStreamTrack | undefined, contentHint?: string): void;
+    stopSubscribe(options?: UnSubscribeOptions): Promise<void>;
     /**
-     * 更新源流 Constraints
-     * 更新 PeerConnectiong Sender 相关配置
-     * @param stream
+     * 停止对某个拉流 URL 的订阅
+     * @param {url} pullStreamUrl
+     * @returns {Promise<SubscribeResult>}
      */
-    setVideoProfile(originVideoTrack: MediaStreamTrack | undefined, target: LocalStream | undefined, skipConstraints?: boolean): Promise<void>;
-}
-
-interface PublishStreamInfo {
-    audio?: LocalStream;
-    video?: LocalStream;
-    videoSmall?: LocalStream;
-    screen?: LocalStream;
-    videoProfile?: LocalProfileManager;
-    screenProfile?: LocalProfileManager;
-}
-
-interface PluginManagerListener {
-    added: (plugin: AliRtcPlugin) => void;
-    removed: (plugin: AliRtcPlugin) => void;
-    updated: (plugin: AliRtcPlugin) => void;
-}
-declare class PluginManager extends EventEmitter$1<PluginManagerListener> {
-    private plugins;
-    add(plugin: AliRtcPlugin, options?: any): void;
-    remove(name: string): void;
-    removeAll(): void;
-    get(name: string): AliRtcPlugin | undefined;
-    has(name: string): boolean;
-    getAll(): AliRtcPlugin[];
-}
-
-interface LocalStreamManagerListener {
-    trackended: (type: TrackEvent) => {};
-    publishupdate: () => {};
-}
-declare class LocalStreamManager extends EventEmitter$1<LocalStreamManagerListener> {
+    private doStopSubscribe;
+    private updateStream;
+    private updateScreenStream;
+    private clearStream;
+    private clearScreenStream;
+    private onDataChannelMessage;
+    private onDataChannelError;
+    private dataChannelConnected;
+    private subscribeDataChannel;
+    private subscribeStopDataChannel;
+    getRetryOptions(): RemoteSubscribeOptions | undefined;
     /**
-     * @ignore
+     * 尝试更新订阅
+     * 1. 需要新增订阅的情况：想要订阅 & 没有正在订阅 & 远端有流
      */
-    static logName: string;
-    private pluginManager;
-    private slsReporter;
-    private publishingCameraVideoStream;
-    private publishingScreenVideoStream;
-    cameraStreamInfo: AliRtcLocalStreamInfo;
-    screenStreamInfo: AliRtcLocalStreamInfo;
-    private streamInfos;
-    private _audioCaptureDisabled;
-    private _cameraCaptureDisabled;
-    private _publishLocalAudioStreamEnabled;
-    private _publishLocalVideoStreamEnabled;
-    private _publishLocalScreenStreamEnabled;
-    constructor(pluginManager: PluginManager, slsReporter: SLSReporter);
-    get hasCamera(): boolean;
-    get audioCaptureDisabled(): boolean;
-    set audioCaptureDisabled(closed: boolean);
-    get cameraCaptureDisabled(): boolean;
-    set cameraCaptureDisabled(closed: boolean);
-    setAudioMuted(muted: boolean): void;
-    get isAudioMuted(): boolean;
-    setCameraMuted(muted: boolean): void;
-    get isCameraMuted(): boolean;
-    setScreenMuted(muted: boolean): void;
-    get isScreenMuted(): boolean;
-    get publishLocalAudioStreamEnabled(): boolean;
-    set publishLocalAudioStreamEnabled(enable: boolean);
-    get publishLocalVideoStreamEnabled(): boolean;
-    set publishLocalVideoStreamEnabled(enable: boolean);
-    get publishLocalScreenStreamEnabled(): boolean;
-    set publishLocalScreenStreamEnabled(enable: boolean);
-    updateStreams(): Promise<void>;
-    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;
+    updateSubscribe(reason: SubscribeReason): {
+        addOption: SubscribeOptions;
+        deleteOption: SubscribeOptions;
+    };
+    private handleAutoPlayFailed;
+    private handleAudioPaused;
+    private handleVideoPlayFailded;
+    private playAudio;
+    stopPlayAudio(): void;
+    playAll(isScreen?: boolean, isReplace?: boolean): void;
     /**
-     * 设置摄像头流 profile
-     * @param {LocalStream | null} stream
-     * @param {string} profileKey
-     * @param {IProfile} profile
+     * 播放
      */
-    setVideoProfile(profileKey?: string, profile?: Partial<IProfile>, skipConstraints?: boolean): Promise<void>;
+    private play;
+    stopPlayAll(isScreen?: boolean): void;
     /**
-     * 设置摄像头流 content hint
-     * @param {string} hint
-     * @note 不传则尝试复用之前的 hint
+     * 是否开启声音
+     * @param {boolean} enable
+     * @returns {void}
      */
-    setVideoContentHint(hint?: string): void;
+    toggleAudio(enable?: boolean): void;
     /**
-     * 设置音频流 profile
-     * @param {string} profileKey
+     * 是否开启画面
+     * @param {boolean} enable
+     * @returns {void}
      */
-    setAudioProfile(profileKey: AudioProfileKey): Promise<void>;
+    toggleVideo(enable?: boolean): void;
     /**
-     * 设置屏幕共享流 profile
-     * @param {LocalStream} stream
-     * @param {string} profileKey
-     * @param {IProfile} profile
+     * 是否开启画面
+     * @param {boolean} enable
+     * @returns {void}
      */
-    setScreenProfile(profileKey?: string, profile?: Partial<IProfile>): Promise<void>;
-    setScreenContentHint(hint?: string): void;
+    toggleScreen(enable?: boolean): void;
+    getStats(): Promise<{
+        audio: AliRtcRemoteAudioStats[];
+        video: AliRtcRemoteVideoStats[];
+    }>;
     /**
-     * 设置 cameraVideoConstraints
-     * @param {IVideoConstraints} cameraVideoConstraints
+     * 开启音量检测
+     * @param {number} interval 时间间隔
      */
-    setCameraVideoConstraints(cameraVideoConstraints: MediaTrackConstraints): void;
+    enableAudioVolumeIndication(interval: number): void;
+    private reportSubscribeMonitor;
+    private startStreamMonitor;
     /**
-     * 设置 micAudioConstraints
-     * @param {IAudioConstraints} micAudioConstraints
+     * 停止本地流数据采集
      */
-    setMicAudioConstraints(micAudioConstraints: MediaTrackConstraints): void;
+    private stopStreamMonitor;
 }
 
-interface DeviceStatus {
-    micOpen: boolean;
-    micInterrupted: boolean;
-    audioDisable: boolean;
-    cameraOpen: boolean;
-    videoDisable: boolean;
-    screenShare: boolean;
-    screenDisable: boolean;
-    backgroundMode: boolean;
-    accompanyPlaying: boolean;
+interface RemoteSubscribeOptions {
+    remoteUser: RemoteUser;
+    options: SubscribeOptions;
 }
-
-interface UpdateTracksResult {
-    restoreSub?: boolean;
+declare enum RtsPeerConnectionType {
+    PUBLISH = "publish",
+    SUBSCRIBE = "subscribe"
 }
-declare class RemoteStreamInfo extends EventEmitter$1<StreamListener> {
+interface RtsManagerEventListener {
+    reconnecting: (type: RtsPeerConnectionType) => {};
+    disconnected: () => {};
+    connected: (isReconnected: boolean, type: RtsPeerConnectionType) => {};
+    subscribeexceeds: () => {};
+    seimessage: (url: string, payloadType: number, data: ArrayBuffer) => {};
+}
+declare class RtsManager extends EventEmitter$1<RtsManagerEventListener> {
     /**
      * @ignore
      */
     static logName: string;
-    protected audioInfo: RemoteMediaTrackInfo;
-    protected videoLargeInfo: RemoteMediaTrackInfo;
-    protected videoSmallInfo: RemoteMediaTrackInfo;
-    protected screenInfo: RemoteMediaTrackInfo;
-    protected dataInfo: RemoteMediaTrackInfo;
-    protected audioVolume: number;
-    protected audioMuted: boolean;
-    protected userStatus?: DeviceStatus;
-    constructor();
+    private rts;
+    private encodedInsertableStreams;
+    private audioRedEnabled;
+    private localStreamManager;
+    private slsReporter;
+    private _rtsPeerConnectionType;
+    private connecting;
+    private connected;
+    private _pcTraceId;
+    private _localJoinTime;
+    private connectionResolve?;
+    private connectingPromise?;
+    private dcResolve?;
+    private dcReject?;
+    private dcConnectingPromise?;
+    private _publishingTracks;
+    private parameter;
+    preferredPubL1Ip?: string;
+    preferredSubL1Ip?: string;
+    constructor(localStreamManager: LocalStreamManager, slsReporter: SLSReporter, parameter: Parameter);
+    private addRTSListener;
     /**
-     * 远端流音频轨道信息
-     * @returns
+     * 更新鉴权信息，传入一个新的带鉴权的 URL，RTS 会去除鉴权信息做更新
+     * @param newUrlWithAuth
      */
-    getAudioInfo(): RemoteMediaTrackInfo;
+    updateAuth(newUrlWithAuth: string): void;
+    get pcTraceId(): string;
+    set localJoinTime(time: number);
+    setEncodedInsertableStreams(enable: boolean): void;
+    setAudioRedEnabled(enable: boolean): void;
+    clear(): void;
+    private startConnect;
+    private setConnected;
+    get isConnecting(): boolean;
+    get isConnected(): boolean;
+    get publishingTracks(): TrackInfo[];
+    private getPubMsid;
+    private updatePublishingTracks;
+    private httpPublish;
+    waitPublishSender(streamUrl: string, isAudio?: boolean, msid?: string): Promise<any>;
+    getPublishVideoStats(streamUrl: string, msid?: string): Promise<unknown>;
+    getPublishAudioStats(streamUrl: string, msid?: string): Promise<unknown>;
+    publishAdd(streamUrl: string, stream: LocalStream, callId: string, extra?: PublishExtraParams, isResume?: boolean, waitSender?: boolean, reason?: PublishReason): Promise<string>;
+    publishDelete(streamUrl: string, options: PublishOptions): Promise<string>;
+    publishReplace(streamUrl: string, stream: LocalStream, extra?: PublishExtraParams): Promise<string>;
+    publishStop(streamUrl: string): Promise<string>;
+    publishAddDataChannel(streamUrl: string): Promise<any>;
+    publishStopDataChannel(streamUrl: string, datachannel: any): Promise<void>;
+    unpublish(): Promise<void>;
     /**
-     * 远端流视频轨道信息
-     * @returns
+     * 获取 sub/subAdd config
+     * @param {ISubscribeConfig | ISubConfigItem} options
+     * @returns {Omit<ISignalConfig | ISubConfigItem, 'url'>}
      */
-    getVideoSmallInfo(): RemoteMediaTrackInfo;
+    private getSubConfig;
+    private httpSubscribe;
+    private subscribeAdd;
+    subscribeDelete(subscribeOptions: RemoteSubscribeOptions): Promise<ISubDeleteResult | undefined>;
+    subscribeStop(streamUrl: string): Promise<void>;
+    subscribeAddDataChannel(streamUrl: string): Promise<any>;
+    subscribeStopDatachannel(streamUrl: string, datachannel: any): Promise<any>;
+    publish(streamUrl: string, callId: string, isResume?: boolean, reason?: PublishReason): Promise<{
+        traceId: string;
+        l1ip?: string;
+    }>;
+    private reportSubscribeLatency;
+    subscribe(remoteSubscribeOptions: RemoteSubscribeOptions, reason: SubscribeReason, callId: string, remoteCallId: string, startTs: number, retryCount?: number): Promise<any>;
+    getSubscribeVideoStats(streamUrl: string, msid?: string): Promise<unknown>;
+    getSubscribeAudioStats(streamUrl: string, msid?: string): Promise<unknown>;
+    getStreamByMsid(config: any): LocalStream | RemoteStream;
+    getDatachannelByMsid(config: {
+        url: string;
+        msid?: string;
+    }): any;
+    getPCStats(): Promise<any>;
+    sendSEI(streamUrl: string, data: ArrayBuffer, repeatCount: number, payloadType: number): Promise<void>;
+}
+
+declare class User extends EventEmitter$1<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;
+    protected createCallId(): void;
+    setUserInfo(uid: string, displayName: string): void;
+    refreshUserInfo(uid: string): void;
     /**
-     * 远端流视频轨道信息
-     * @returns
+     * 获取音频 level
      */
-    getVideoLargeInfo(): RemoteMediaTrackInfo;
+    getAudioLevel(): number;
+    enableAudioVolumeIndication(interval: number): void;
     /**
-     * 远端流屏幕共享轨道信息
-     * @returns
+     * 销毁用户，清空数据
      */
-    getScreenInfo(): RemoteMediaTrackInfo;
-    getDataInfo(): RemoteMediaTrackInfo;
-    get subscribingInfos(): RemoteMediaTrackInfo[];
-    get hasTrack(): boolean;
+    clear(): void;
+}
+
+interface AliRtcLocalAudioStats {
+    track: AliRtcAudioTrack;
+    stats: any;
+}
+
+interface AliRtcLocalVideoStats {
+    track: AliRtcVideoTrack;
+    streamType?: AliRtcVideoStreamType;
+    stats: any;
+}
+
+declare enum AliRtcDataMsgType {
+    AliEngineDataMsgNone = 0,
+    AliEngineDataMsgMusicProgress = 1,
+    AliEngineDataMsgCustom = 2
+}
+declare class AliRtcDataChannelMsg {
+    data: ArrayBuffer;
+    networkTime: number;
+    futureOrProgress: number;
+    type: AliRtcDataMsgType;
+    constructor(data: ArrayBuffer, type?: AliRtcDataMsgType, networkTime?: number, progress?: number);
+    toBuffer(): ArrayBuffer;
+    static parse(buffer: ArrayBuffer): AliRtcDataChannelMsg | undefined;
+}
+
+interface AliEngineCameraCapturerConfiguration {
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    maxSendFrameRate?: number;
+    bitrate?: number;
+    cameraDirection?: AliRtcCameraDirection;
+    deviceId?: string;
+}
+type VideoProfileWithSendFramerate = Partial<IProfile & {
+    maxSendFrameRate: number;
+}>;
+
+declare class LocalUser extends User {
     /**
-     * 远端流是否包含音频轨道
-     * @returns
+     * @ignore
      */
-    get hasAudio(): boolean;
+    static logName: string;
+    private _url;
+    private joinTime;
+    private publishPromise;
+    private previewElements;
+    private screenPreviewElements;
+    private streamManager;
+    private dc;
+    protected streamTracks?: TrackInfo[];
+    protected publishId: string;
+    protected signalingManager: SignalingManager;
+    private shouldPublish;
+    traceId: string;
+    private monitorTimerId?;
+    private monitorDataCache;
+    private trackTraceIdMap;
+    private candidateDataCache;
+    private pcMediaStatsMap;
+    protected slsReporter: SLSReporter;
+    private audioPubState;
+    private videoPubState;
+    private videoSmallPubState;
+    private screenPubState;
+    private dataPubState;
+    private parameter;
+    constructor(config: LocalUserConfig);
+    get url(): string;
+    set url(value: string);
+    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(profile?: VideoProfileWithSendFramerate): Promise<void>;
+    setVideoContentHint(hint: string): void;
+    setScreenContentHint(hint: string): void;
+    setAudioProfile(profileKey: AudioProfileKey): Promise<void>;
+    setScreenProfile(profile?: Partial<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;
+    setMicrophoneConstraints(constraints: MediaTrackConstraints): void;
+    updatePubId(): void;
+    clearPublishState(): void;
+    leave(): Promise<void>;
     /**
-     * 远端流是否包含视频轨道
-     * @returns
+     * 销毁，停止推流
+     * @returns {Promise<void>}
      */
-    get hasVideo(): boolean;
+    clear(): Promise<void>;
+    resetElement(element: HTMLVideoElement): void;
+    setPreviewElement(previewParams: PreviewConfig): void;
+    startDefaultCameraAndMic(audioOnly?: boolean): Promise<void>;
     /**
-     * 远端流是否包含视频大流轨道
-     * @returns
+     * 为本地预览设置渲染元素和视频流
+     * @param {AliRtcLocalView} view 渲染元素，null 则为停止显示
+     * @param {AliRtcVideoTrack} track 视频流类型
      */
-    get hasVideoLarge(): boolean;
+    setViewConfig(elements: null | HTMLVideoElement[], track: AliRtcVideoTrack): void;
     /**
-     * 远端流是否包含视频小流轨道
+     * 开启摄像头采集
+     * @param params
      * @returns
      */
-    get hasVideoSmall(): boolean;
+    startCameraCapture(): Promise<LocalStream | undefined>;
     /**
-     * 远端流是否包含屏幕共享轨道
-     * @returns
+     * 关闭摄像头采集
+     * @note 调用此接口后，入会后、离会再入会，采集设备保持关闭状态
      */
-    get hasScreen(): boolean;
-    get hasData(): boolean;
+    stopCameraCapture(): Promise<void>;
     /**
-     * 是否订阅远端流音频轨道
+     * 开启麦克风采集
+     * @param params
      * @returns
      */
-    get isAudioSubscribed(): boolean;
-    get isAudioSubscribing(): boolean;
+    startAudioCapture(): Promise<LocalStream | undefined>;
     /**
-     * 是否订阅远端流视频轨道
-     * @returns
+     * 关闭音频采集
+     * @note 调用此接口后，入会后、离会再入会，采集设备保持关闭状态
      */
-    get isVideoSubscribed(): boolean;
-    get isVideoSubscribing(): boolean;
+    stopAudioCapture(): Promise<void>;
+    startCameraAndMic(): Promise<LocalStream | undefined>;
     /**
-     * 是否订阅远端流视频大流轨道
-     * @returns
+     * 预览本地流
+     * @param {PreviewConfig} previewParams
+     * @returns {Promise<MediaStream>}
      */
-    get isVideoLargeSubscribed(): boolean;
-    get isVideoLargeSubscribing(): boolean;
+    preview(previewParams: PreviewConfig): Promise<MediaStream | undefined>;
     /**
-     * 是否订阅远端流视频小流轨道
-     * @returns
+     * 在所有预览容器中预览当前流
+     * @param {boolean} screen 是否指定预览辅流
      */
-    get isVideoSmallSubscribed(): boolean;
-    get isVideoSmallSubscribing(): boolean;
+    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;
+    private reportAudioProfile;
+    private reportVideoProfile;
+    private reportScreenProfile;
+    private updateDataChannel;
+    private publishDataChannel;
+    /**
+     * 开始推流
+     * @param isResume 是否是恢复推流
      * @returns
      */
-    get isScreenSubscribed(): boolean;
-    get isScreenSubscribing(): boolean;
-    get isDataSubscribed(): boolean;
-    get isDataSubscribing(): 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, dataSsrc: string): void;
-    markRemoteTrackSubscribing(option: SubscribeOptions): any;
-    updateRemoteTrackSubState(option: SubscribeOptions): any;
+    startPublish(isResume?: boolean, reason?: PublishReason): Promise<void>;
     /**
-     * 更新远端用户设备状态
-     * @param status
-     * @returns {boolean} 状态改变返回true，否则返回false
+     * 重新执行 progress 并触发 publishupdate
      */
-    updateRemoteUserDeviceStatus(status: string): boolean;
-}
-
-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;
-    get audioElement(): HTMLAudioElement | undefined;
-}
-
-interface RemoteUserViewMap {
-    cameraViews: HTMLVideoElement[];
-    screenViews: HTMLVideoElement[];
-}
-declare class RemoteUser extends User {
+    updateStreams(): Promise<void>;
     /**
-     * @ignore
+     * 对比本地流和正在推流，进行推流更新
+     * @param isResume 是否是恢复推流
      */
-    static logName: string;
-    remoteCallid: string;
-    remoteUserInfo: AliRtcRemoteUserInfo;
-    protected localUser?: LocalUser;
-    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 slsReporter: SLSReporter;
-    private wantSubAudio;
-    private wantSubVideo;
-    private wantSubScreen;
-    private defaultVideoStreamType;
-    private audioMuted;
-    private playoutVolume;
-    private playoutGainNode?;
-    private audioSubState;
-    private videoSubState;
-    private videoLargeSubState;
-    private videoSmallSubState;
-    private screenSubState;
-    private dataSubState;
-    private dc;
-    private dcMsgWaitingPieces;
-    streamInfo: RemoteStreamInfo;
-    private _streamUrl;
-    private parameter;
-    private monitorTimerId?;
-    private monitorDataCache;
-    private trackTraceIdMap;
-    constructor(config: RemoteUserConfig);
-    get streamUrl(): string;
-    set streamUrl(value: string);
-    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;
-    getAudioElement(): HTMLAudioElement | undefined;
-    private handleAudioContextSuspended;
-    setPlayoutVolume(value: number): 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 isDataSubscribing(): 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, reason?: SubscribeReason, startTs?: number): Promise<void>;
+    publishUpdate(reason?: PublishReason): Promise<PublishInfo | undefined>;
+    private syncPublishToRoomServer;
+    private refreshPushStreamUrl;
     /**
-     * 订阅远端流
-     * @param {SubscribeOptions} options 订阅配置
-     * @param {boolean} secondary 是否订阅辅流
-     * @returns {Promise<SubscribeResult>}
+     * 推流，用于 rts subscribe/publish 被调用后，此时 DataChannel 已存在
+     * @param {LocalStream} stream
+     * @returns {Promise<PublishInfo>}
      */
-    private subscribeProxy;
+    publishAdd(stream: LocalStream, extra: PublishExtraParams, isResume?: boolean, retryTimes?: number): Promise<PublishInfo>;
     /**
-     * 移除对某些轨道的订阅
-     * @param {UnSubscribeOptions} options 取消订阅轨道配置
-     * @returns {Promise<SubscribeResult>}
+     * 替换推流 Track（仅限于替换已存在的 Track 类型）
+     * @param {LocalStream} stream
+     * @returns {Promise<PublishInfo>}
      */
-    private subscribeDeleteTracks;
+    publishReplace(stream: LocalStream, extra?: PublishExtraParams): Promise<PublishInfo>;
     /**
-     * 移除对某些轨道的订阅
-     * @param {Partial<ISubConfigItem>} deleteTrack 删除订阅配置
-     * @returns {Promise<SubscribeResult>}
+     * 停止推某些轨，不销毁 DataChannel 和 LocalStream，用于非销毁场景
+     * @param {PublishOptions} options
+     * @returns {Promise<PublishInfo>}
      */
-    private subscribeDeleteProxy;
+    publishDeleteTracks(options: PublishOptions): Promise<PublishInfo>;
     /**
-     * 用保存的订阅参数恢复订阅
+     * 停止推流，不销毁  LocalStream，用于非销毁场景
+     * @returns {Promise<PublishInfo>}
      */
-    restore(): void;
-    resumeAudio(): Promise<void>;
-    resumeVideo(videoTrack?: AliRtcVideoTrack): Promise<void>;
-    resumePlay(): void;
+    publishStop(): Promise<PublishInfo>;
     /**
-     * 停止订阅远端流
-     * @param {string} userId
-     * @param {UnSubscribeOptions} options
-     * @returns {Promise<void>}
+     * 停止推流，销毁 DataChannel，用于销毁的场景
+     * @returns {Promise<PublishInfo>}
      */
-    stopSubscribe(options?: UnSubscribeOptions): Promise<void>;
+    unPublish(): Promise<PublishInfo>;
     /**
-     * 停止对某个拉流 URL 的订阅
-     * @param {url} pullStreamUrl
-     * @returns {Promise<SubscribeResult>}
+     * 事件通知本地的设备使用状态
      */
-    private doStopSubscribe;
-    private updateStream;
-    private updateScreenStream;
-    private clearStream;
-    private clearScreenStream;
-    private onDataChannelMessage;
-    private onDataChannelError;
-    private dataChannelConnected;
-    private subscribeDataChannel;
-    private subscribeStopDataChannel;
-    getRetryOptions(): RemoteSubscribeOptions | undefined;
+    reportSelfDeviceStatus(): void;
     /**
-     * 尝试更新订阅
-     * 1. 需要新增订阅的情况：想要订阅 & 没有正在订阅 & 远端有流
+     * 从localStream 中获取当前的设备状态
+     * @returns {string}
      */
-    updateSubscribe(reason: SubscribeReason): {
-        addOption: SubscribeOptions;
-        deleteOption: SubscribeOptions;
-    };
-    private handleAutoPlayFailed;
-    private handleAudioPaused;
-    private handleVideoPlayFailded;
-    private playAudio;
-    stopPlayAudio(): void;
-    playAll(isScreen?: boolean, isReplace?: boolean): void;
+    private getDeviceStatus;
+    private onTrackEnd;
+    private resetPreviewElements;
+    private resetSecondayPreviewElements;
+    getMediaStats(id: string): any;
+    private reportPublishMonitor;
+    private reportNetwork;
+    private startStreamMonitor;
     /**
-     * 播放
+     * 停止本地流数据采集
      */
-    private play;
-    stopPlayAll(isScreen?: boolean): void;
+    private stopStreamMonitor;
     /**
-     * 是否开启声音
-     * @param {boolean} enable
+     * 清除本地流
      * @returns {void}
      */
-    toggleAudio(enable?: boolean): void;
+    clearStream(): void;
     /**
-     * 是否开启画面
-     * @param {boolean} enable
-     * @returns {void}
+     * 获取当前使用的摄像头 deviceId
+     * @returns {string | undefined}
      */
-    toggleVideo(enable?: boolean): void;
+    getCurrentCameraDeviceId(): string | undefined;
     /**
-     * 是否开启画面
-     * @param {boolean} enable
-     * @returns {void}
+     * 获取当前使用的摄像头 deviceId
+     * @returns {string | undefined}
      */
-    toggleScreen(enable?: boolean): void;
+    getCurrentMicDeviceId(): string | undefined;
+    enableAudioVolumeIndication(interval: number): void;
+    sendSEI(message: ArrayBuffer, repeatCount: number, payloadType: number): Promise<void>;
+    sendDataChannelMessage(message: AliRtcDataChannelMsg): void;
     getStats(): Promise<{
-        audio: AliRtcRemoteAudioStats[];
-        video: AliRtcRemoteVideoStats[];
+        audio: AliRtcLocalAudioStats[];
+        video: AliRtcLocalVideoStats[];
+        candidate: any;
     }>;
-    /**
-     * 开启音量检测
-     * @param {number} interval 时间间隔
-     */
-    enableAudioVolumeIndication(interval: number): void;
-    private reportSubscribeMonitor;
-    private startStreamMonitor;
-    /**
-     * 停止本地流数据采集
-     */
-    private stopStreamMonitor;
 }
 
-interface RemoteSubscribeOptions {
-    remoteUser: RemoteUser;
-    options: SubscribeOptions;
+interface AudioMixerPluginOptions {
+    audio?: number;
+    screen?: number;
 }
-declare enum RtsPeerConnectionType {
-    PUBLISH = "publish",
-    SUBSCRIBE = "subscribe"
+
+type AliRtcDualVideoPluginOptions = VideoScalerOptions;
+
+declare enum AliRtcCapabilityProfile {
+    Default = 0,
+    Human = 1,
+    Robot = 2
 }
-interface RtsManagerEventListener {
-    reconnecting: (type: RtsPeerConnectionType) => {};
-    disconnected: () => {};
-    connected: (isReconnected: boolean, type: RtsPeerConnectionType) => {};
-    subscribeexceeds: () => {};
-    seimessage: (url: string, payloadType: number, data: ArrayBuffer) => {};
+type AliRtcChannelParam = {
+    userName?: string;
+    capabilityProfile?: AliRtcCapabilityProfile;
+};
+
+interface RemoteUserMap {
+    [userId: string]: RemoteUser;
 }
-declare class RtsManager extends EventEmitter$1<RtsManagerEventListener> {
+declare class BizControl extends EventEmitter$1<BizControlListener> {
     /**
      * @ignore
      */
     static logName: string;
-    private rts;
-    private encodedInsertableStreams;
-    private audioRedEnabled;
-    private localStreamManager;
-    private slsReporter;
-    private _rtsPeerConnectionType;
-    private connecting;
-    private connected;
-    private _pcTraceId;
-    private _localJoinTime;
-    private connectionResolve?;
-    private connectingPromise?;
-    private dcResolve?;
-    private dcReject?;
-    private dcConnectingPromise?;
-    private _publishingTracks;
-    private parameter;
-    preferredPubL1Ip?: string;
-    constructor(localStreamManager: LocalStreamManager, slsReporter: SLSReporter, parameter: Parameter);
-    private addRTSListener;
-    /**
-     * 更新鉴权信息，传入一个新的带鉴权的 URL，RTS 会去除鉴权信息做更新
-     * @param newUrlWithAuth
-     */
-    updateAuth(newUrlWithAuth: string): void;
-    get pcTraceId(): string;
-    set localJoinTime(time: number);
-    setEncodedInsertableStreams(enable: boolean): void;
-    setAudioRedEnabled(enable: boolean): void;
-    clear(): void;
-    private startConnect;
-    private setConnected;
-    get isConnecting(): boolean;
-    get isConnected(): boolean;
-    get publishingTracks(): TrackInfo[];
-    private getPubMsid;
-    private updatePublishingTracks;
-    private httpPublish;
-    waitPublishSender(streamUrl: string, isAudio?: boolean, msid?: string): Promise<any>;
-    getPublishVideoStats(streamUrl: string, msid?: string): Promise<unknown>;
-    getPublishAudioStats(streamUrl: string, msid?: string): Promise<unknown>;
-    publishAdd(streamUrl: string, stream: LocalStream, callId: string, extra?: PublishExtraParams, isResume?: boolean, waitSender?: boolean, reason?: PublishReason): Promise<string>;
-    publishDelete(streamUrl: string, options: PublishOptions): Promise<string>;
-    publishReplace(streamUrl: string, stream: LocalStream, extra?: PublishExtraParams): Promise<string>;
-    publishStop(streamUrl: string): Promise<string>;
-    publishAddDataChannel(streamUrl: string): Promise<any>;
-    publishStopDataChannel(streamUrl: string, datachannel: any): Promise<void>;
-    unpublish(): Promise<void>;
+    protected self: LocalUser;
+    protected userMap: RemoteUserMap;
+    private usersViewMap;
+    rtsManager: RtsManager;
+    protected localStreamManager: LocalStreamManager;
+    protected authInfo?: AliRtcAuthInfo;
+    protected signalingManager: SignalingManager;
+    pluginManager: PluginManager;
+    private audioMixerPlugin?;
+    private dualVideoPlugin?;
+    private blankAudioPlugin?;
+    private audioProcessorPlugin?;
+    protected slsReporter: SLSReporter;
+    private statsMonitorId?;
+    private autoSubAudio;
+    private autoSubVideo;
+    private autoSubScreen;
+    private wantSubAudio;
+    private wantSubVideo;
+    private wantSubScreen;
+    private defaultStreamType;
+    private audioMuted;
+    private playoutVolume;
+    private refreshUrlTimer?;
+    private audioVolumeIndicationInterval;
+    private indicationTimer;
+    private parameter;
+    private audio3AConfig;
+    private dcReadyHelper?;
+    constructor(config: BizControlConfig);
+    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[];
     /**
-     * 获取 sub/subAdd config
-     * @param {ISubscribeConfig | ISubConfigItem} options
-     * @returns {Omit<ISignalConfig | ISubConfigItem, 'url'>}
+     * 获取推流对象，只能是自己
      */
-    private getSubConfig;
-    private httpSubscribe;
-    private subscribeAdd;
-    subscribeDelete(subscribeOptions: RemoteSubscribeOptions): Promise<ISubDeleteResult | undefined>;
-    subscibeStop(streamUrl: string): Promise<void>;
-    subscribeAddDataChannel(streamUrl: string): Promise<any>;
-    subscribeStopDatachannel(streamUrl: string, datachannel: any): Promise<any>;
-    publish(streamUrl: string, callId: string, isResume?: boolean, reason?: PublishReason): Promise<{
-        traceId: string;
-        l1ip?: string;
-    }>;
-    private reportSubscribeLatency;
-    subscribe(remoteSubscribeOptions: RemoteSubscribeOptions, reason: SubscribeReason, callId: string, remoteCallId: string, startTs: number): Promise<any>;
-    getSubscribeVideoStats(streamUrl: string, msid?: string): Promise<unknown>;
-    getSubscribeAudioStats(streamUrl: string, msid?: string): Promise<unknown>;
-    getStreamByMsid(config: any): LocalStream | RemoteStream;
-    getDatachannelByMsid(config: {
-        url: string;
-        msid?: string;
-    }): any;
-    getPCStats(): Promise<any>;
-    sendSEI(streamUrl: string, data: ArrayBuffer, repeatCount: number, payloadType: number): Promise<void>;
-}
-
-declare class User extends EventEmitter$1<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;
-    protected createCallId(): void;
-    setUserInfo(uid: string, displayName: string): void;
-    refreshUserInfo(uid: string): void;
+    get publisher(): LocalUser | undefined;
+    get isSubscribing(): boolean;
     /**
-     * 获取音频 level
+     * 处理远端用户推流状态变化
+     * @param {string} userId
+     * @param {string} displayname
+     * @param {string} callid
+     * @param {string} pullStreamUrl
+     * @param {TrackInfo[]} tracks
+     * @returns {void}
      */
-    getAudioLevel(): number;
-    enableAudioVolumeIndication(interval: number): void;
-    /**
-     * 销毁用户，清空数据
+    onRemotePublishStateChange(publishInfo: PublishUser, updateSubscribe?: boolean): void;
+    /** 定期更新所有人的推拉流地址，便于重连
+     * @param pushStreamUrl 已有的推流地址，根据地址中的过期时间来设置定时器
+     * @private
      */
-    clear(): void;
-}
-
-declare class LocalUser extends User {
+    private setTimeoutToUpdateAllStreamUrls;
     /**
-     * @ignore
+     * 登陆成功后初始化用户管理，创建自己
+     * @param {AliRtcAuthInfo} authInfo
+     * @param {JoinResult} data
+     * @returns {Promise<void>}
      */
-    static logName: string;
-    private _url;
-    private joinTime;
-    private publishPromise;
-    private previewElements;
-    private screenPreviewElements;
-    private streamManager;
-    private dc;
-    protected streamTracks?: TrackInfo[];
-    protected publishId: string;
-    protected signalingManager: SignalingManager;
-    private shouldPublish;
-    traceId: string;
-    private monitorTimerId?;
-    private monitorDataCache;
-    private trackTraceIdMap;
-    private candidateDataCache;
-    private pcMediaStatsMap;
-    protected slsReporter: SLSReporter;
-    private audioPubState;
-    private videoPubState;
-    private videoSmallPubState;
-    private screenPubState;
-    private dataPubState;
-    private parameter;
-    constructor(config: LocalUserConfig);
-    get url(): string;
-    set url(value: string);
-    set preferredPubL1Ip(value: string);
-    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(profile?: VideoProfileWithSendFramerate): Promise<void>;
-    setVideoContentHint(hint: string): void;
-    setScreenContentHint(hint: string): void;
-    setAudioProfile(profileKey: AudioProfileKey): Promise<void>;
-    setScreenProfile(profile?: Partial<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;
-    setMicrophoneConstraints(constraints: MediaTrackConstraints): void;
-    updatePubId(): void;
-    clearPublishState(): void;
+    init(authInfo: AliRtcAuthInfo, data: JoinResult, channelParam: AliRtcChannelParam): void;
     leave(): Promise<void>;
     /**
-     * 销毁，停止推流
+     * 离会后清除所有数据
      * @returns {Promise<void>}
      */
     clear(): Promise<void>;
-    resetElement(element: HTMLVideoElement): void;
-    setPreviewElement(previewParams: PreviewConfig): void;
-    startDefaultCamera(audioOnly: boolean): Promise<void>;
-    startDefaultAudio(): Promise<void>;
+    private startStatsMonitor;
+    private stopStatsMonitor;
     /**
-     * 为本地预览设置渲染元素和视频流
-     * @param {AliRtcLocalView} view 渲染元素，null 则为停止显示
-     * @param {AliRtcVideoTrack} track 视频流类型
+     * 添加远端用户
+     * @param {JoinInfo} userJoinInfo
+     * @param {SubscribeReason} reason
+     * @returns {void}
      */
-    setViewConfig(elements: null | HTMLVideoElement[], track: AliRtcVideoTrack): void;
+    addUser(userJoinInfo: JoinInfo, reason: SubscribeReason): RemoteUser;
     /**
-     * 开启摄像头采集
-     * @param params
-     * @returns
+     * 执行添加远端用户
+     * @param {string} userId
+     * @param {string} displayName
+     * @returns {RemoteUser}
      */
-    startCameraCapture(): Promise<LocalStream | undefined>;
+    private executeAddUser;
     /**
-     * 关闭摄像头采集
-     * @note 调用此接口后，入会后、离会再入会，采集设备保持关闭状态
+     * 远端用户设备状态变化
+     * @param {DeviceStatusChangeType} event
+     * @param {string} userId
      */
-    stopCameraCapture(): Promise<void>;
+    private onRemoteDeviceStatusChange;
     /**
-     * 开启麦克风采集
-     * @param params
-     * @returns
+     * 远端流数据采集上报
+     * @param {any} stat
      */
-    startAudioCapture(): Promise<LocalStream | undefined>;
+    private onRemoteStatReport;
     /**
-     * 关闭音频采集
-     * @note 调用此接口后，入会后、离会再入会，采集设备保持关闭状态
+     * rts 单 PC 订阅超限
      */
-    stopAudioCapture(): Promise<void>;
+    private onSubscribeExceeds;
     /**
-     * 预览本地流
-     * @param {PreviewConfig} previewParams
-     * @returns {Promise<MediaStream>}
+     * 移除远端用户
+     * @param {LeaveInfo} user
+     * @returns {Promise<void>}
+     */
+    removeLeftUser(user: LeaveInfo): Promise<void>;
+    /**
+     * 更新远端用户数据
+     * @param {JoinInfo[]} users
+     * @returns {{joinList: JoinInfo[], leaveList: LeaveInfo[], presentList: JoinInfo[]}}
+     */
+    diffUsers(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;
+    setEnableDualVideoStream(enabled: boolean, options?: AliRtcDualVideoPluginOptions): void;
+    setAudioVolume(options: AudioMixerPluginOptions): void;
+    enableAudioVolumeIndication(interval: number): void;
+    setPlayoutVolume(volume: number): void;
+    refreshAuthInfo(authInfo: AliRtcRefreshAuthInfo): void;
+    setEnableMediaExtensionMsg(enable: boolean): void;
+    setAudioRedEnabled(enable: boolean): void;
+    setParameter(parameter: string): void;
+    private setupAudioProcessingPluginIfNeeded;
+    getParameter(): string;
+    sendDataChannelMessage(message: AliRtcDataChannelMsg): void;
+}
+
+declare enum AliRtcLiveTranscodingMixMode {
+    /*! 单路模式 */
+    LiveTranscodingSingle = 0,
+    /*! 混流模式 */
+    LiveTranscodingMix = 1
+}
+declare enum AliRtcLiveTranscodingStreamType {
+    /*! 原始流 */
+    LiveTranscodingOrigin = 0,
+    /*! 音频 */
+    LiveTranscodingAudio = 1,
+    /*! 视频 */
+    LiveTranscodingVideo = 2
+}
+declare enum AliRtcLiveTranscodingSourceType {
+    /*! 相机流 */
+    LiveTranscodingCamera = 0,
+    /*! 屏幕流 */
+    LiveTranscodingShareScreen = 1
+}
+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 enum AliRtcLiveTranscodingAudioSampleRate {
+    LiveTranscoding_HZ_48000 = 48000,
+    LiveTranscoding_HZ_44100 = 44100,
+    LiveTranscoding_HZ_32000 = 32000,
+    LiveTranscoding_HZ_16000 = 16000,
+    LiveTranscoding_HZ_8000 = 8000
+}
+declare enum AliRtcLiveTranscodingSegmentType {
+    /*! 无人像分割 */
+    LiveTranscodingNoBody = 0,
+    /*! 人像分割 */
+    LiveTranscodingBody = 1
+}
+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
+}
+declare enum AliRtcLiveTranscodingCropMode {
+    /*! 缩放模式 */
+    LiveTranscodingOrigin = 0,
+    /*! 剪裁 */
+    LiveTranscodingCrop = 1,
+    /*! 填充 */
+    LiveTranscodingFill = 2
+}
+declare enum AliRtcLiveTranscodingMediaProcessMode {
+    /*! 通用模式 */
+    LiveTranscodingNormal = 0,
+    /*! 虚拟背景模式 */
+    LiveTranscodingVirtualBackground = 1
+}
+declare enum AliRtcLiveTranscodingState {
+    LiveTranscodingState_IDLE = 0,
+    LiveTranscodingState_CONNNECT = 1,
+    LiveTranscodingState_RUNNING = 2,
+    LiveTranscodingState_RECOVERING = 3,
+    LiveTranscodingState_FAILURE = 4,
+    LiveTranscodingState_END = 5
+}
+declare enum AliRtcLiveTranscodingErrorCode {
+    LiveTranscodingErrorPublishOk = 0,
+    LiveTranscodingErrorStreamNotFound = 17825793,
+    LiveTranscodingErrorStreamAlreadyExist = 17825794,
+    LiveTranscodingErrorInvalidParam = 17825795,
+    LiveTranscodingErrorInternalError = 17825796,
+    LiveTranscodingErrorRtmpServerError = 17825797,
+    LiveTranscodingErrorRtmpStreamUrlError = 17825798,
+    LiveTranscodingErrorPublishTimeout = 17825799,
+    LiveTranscodingErrorNotAuthorized = 17825800
+}
+declare enum AliRtcTrascodingPublishTaskStatus {
+    /*! 任务开始 */
+    TrascodingPublishTaskStatusStart = 0,
+    /*! 任务更新 */
+    TrascodingPublishTaskStatusUpdate = 1,
+    /*! 任务已停止 */
+    TrascodingPublishTaskStatusStop = 2
+}
+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 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);
+}
+
+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;
+    };
+}
+
+declare enum DisplayType {
+    NOT_DISPLAY = 0,
+    ALWAYS = 1,
+    WHEN_NO_VIDEO = 2
+}
+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;
+    };
+}
+
+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;
+    };
+}
+
+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;
+    };
+}
+
+declare class LiveTranscodingMixParam {
+    taskProfile: AliRtcLiveTranscodingTaskProfile;
+    encodeParam?: AliRtcLiveTranscodingEncodeParam;
+    users: AliRtcTranscodingUser[];
+    backgroundColor: number;
+    backgrounds: AliRtcTranscodingImage[];
+    watermarks: AliRtcTranscodingImage[];
+    clockWidgets: AliRtcTranscodingClockWidget[];
+    cropMode?: AliRtcLiveTranscodingCropMode;
+    mediaProcessMode?: AliRtcLiveTranscodingMediaProcessMode;
+    constructor(taskProfile: AliRtcLiveTranscodingTaskProfile);
+}
+
+declare class AliRtcLiveTranscodingSingleParam {
+    userId?: string;
+    streamType?: AliRtcLiveTranscodingStreamType;
+    sourceType?: AliRtcLiveTranscodingSourceType;
+    constructor(uid?: string, streamType?: AliRtcLiveTranscodingStreamType, sourceType?: AliRtcLiveTranscodingSourceType);
+}
+
+declare class AliRtcLiveTranscodingParam {
+    /*! 旁路模式 */
+    mixMode: AliRtcLiveTranscodingMixMode;
+    /*! 路模式单路参数 */
+    singleParam?: AliRtcLiveTranscodingSingleParam;
+    /*! 旁路模式混流参数 */
+    mixParam?: LiveTranscodingMixParam;
+    constructor(mixMode?: AliRtcLiveTranscodingMixMode, singleParam?: AliRtcLiveTranscodingSingleParam, mixParam?: LiveTranscodingMixParam);
+    toJson(type: MPU_TASK_TRANSACTION_TYPE, authInfo: AliRtcAuthInfo, taskId: string, streamUrl?: string, messageId?: string): {
+        [key: string]: any;
+    };
+}
+
+declare class AliRtcLiveTranscoding {
+    authInfo?: AliRtcAuthInfo;
+    private slsReporter;
+    constructor(slsReporter: SLSReporter);
+    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;
+}
+
+declare enum AliRtcLogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    API = 2,
+    WARNING = 3,
+    ERROR = 4,
+    NONE = 5
+}
+
+interface AliRtcBeautyConfig {
+    whiteningLevel: number;
+    /*! 磨皮等级[0-1.0] */
+    smoothnessLevel: number;
+}
+
+interface AliRtcWebTrackConfig {
+    biz: string;
+    extraParams?: string;
+}
+interface AliRtcEngineConfig {
+    env?: AliRtcEnv;
+    webTrack?: boolean | AliRtcWebTrackConfig;
+    maxSignalingConnectRetryCount?: number;
+}
+interface AliRtcAIAgentParam {
+    /*! ai agent id */
+    agentId: string;
+    /*! ai agent的区域 */
+    region: string;
+    /*! 启动ai agent的action */
+    action: string;
+    /*! 启动ai agent的参数 */
+    params: string;
+}
+
+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}
      */
-    preview(previewParams: PreviewConfig): Promise<MediaStream | undefined>;
     /**
-     * 在所有预览容器中预览当前流
-     * @param {boolean} screen 是否指定预览辅流
+     * 被服务器踢出/会议结束频道的消息
+     * @param code 原因参考{@link AliRtcEngine.AliRtcOnByeType}
      */
-    previewAll(previewAllParams?: PreviewAllConfig): Promise<void>;
+    bye: (code: AliRtcOnByeType) => void;
     /**
-     * 停止预览本地流
+     * @brief 远端用户（通信模式）/（互动模式，主播角色）加入频道回调
+     * @details 该回调在以下场景会被触发
+     * - 通信模式：远端用户加入频道会触发该回调，如果当前用户在加入频道前已有其他用户在频道中，当前用户加入频道后也会收到已加入频道用户的回调
+     * - 互动模式：
+     *   - 远端主播角色用户加入频道会触发该回调，如果当前用户在加入频道前已有其他主播在频道中，当前用户加入频道后也会收到已加入频道主播的回调
+     *   - 远端观众角色调用 {@link AliRtcEngine.setClientRole} 切换为主播角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkInteractive}，同时设置了推流时，会触发该回调
+     *
+     * @param uid 用户ID，从App server分配的唯一标示符
+     * @param elapsed 用户加入频道时的耗时
+     * @note 互动模式下回调行为
+     * - 主播间可以互相收到加入频道回调
+     * - 观众可以收到主播加入频道回调
+     * - 主播无法收到观众加入频道回调
      */
-    stopPreview(previewParams?: StopPreviewConfig): void;
+    remoteUserOnLineNotify: (uid: string, elapsed: number) => void;
     /**
-     * 恢复推流
-     * @returns {Promise<void>}
+     * @brief 远端用户（通信模式）/（互动模式，主播角色）离开频道回调
+     * @details 该回调在以下场景会被触发
+     * - 通信模式：远端用户离开频道会触发该回调
+     * - 互动模式：
+     *   - 远端主播角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkInteractive} 离开频道
+     *   - 远端主播切换调用 {@link AliRtcEngine.setClientRole} 切换为观众角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkLive}，会触发该回调
+     * - 通信模式和互动模式主播角色情况下，当长时间收不到远端用户数据，超时掉线时，会触发该回调
+     *
+     * @param uid 用户ID，从App server分配的唯一标示符
+     * @param reason 用户离线的原因，详见 {@link AliRtcEngine.AliRtcUserOfflineReason}
      */
-    resumePublish(): Promise<void>;
-    createLocalStream(params: LocalStreamConfig): Promise<LocalStream | undefined>;
-    stopLocalStream(options: PublishOptions): Promise<void>;
-    private compareAndPublish;
-    private reportAudioProfile;
-    private reportVideoProfile;
-    private reportScreenProfile;
-    private updateDataChannel;
-    private publishDataChannel;
+    remoteUserOffLineNotify: (uid: string, aliRtcUserOfflineReason: AliRtcUserOfflineReason) => void;
     /**
-     * 开始推流
-     * @param isResume 是否是恢复推流
-     * @returns
+     * @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 该回调仅在通信模式用户和互动模式下的主播角色才会触发
      */
-    startPublish(isResume?: boolean, reason?: PublishReason): Promise<void>;
+    remoteTrackAvailableNotify: (uid: string, aliRtcAudioTrack: AliRtcAudioTrack, aliRtcVideoTrack: AliRtcVideoTrack) => void;
     /**
-     * 重新执行 progress 并触发 publishupdate
+     * @brief 远端用户静音/取消静音回调
+     * @param uid 远端用户ID
+     * @param isMute 该用户是否静音
+     * - true: 静音
+     * - false: 取消静音
      */
-    updateStreams(): Promise<void>;
+    userAudioMuted: (uid: string, isMute: boolean) => void;
     /**
-     * 对比本地流和正在推流，进行推流更新
-     * @param isResume 是否是恢复推流
+     * @brief 对端用户发送视频黑帧数据发送通知
+     * @param uid 执行muteVideo的用户ID
+     * @param isMute
+     * - true: 推流黑帧
+     * - false: 正常推流
+     * @note 该接口用于对端用户发送视频黑帧数据时的回调
      */
-    publishUpdate(reason?: PublishReason): Promise<PublishInfo | undefined>;
-    private syncPublishToRoomServer;
-    private refreshPushStreamUrl;
+    userVideoMuted: (uid: string, isMute: boolean) => void;
     /**
-     * 推流，用于 rts subscribe/publish 被调用后，此时 DataChannel 已存在
-     * @param {LocalStream} stream
-     * @returns {Promise<PublishInfo>}
+     * @brief 对端用户发送屏幕黑帧数据发送通知
+     * @param uid 执行muteVideo的用户ID
+     * @param isMute
+     * - true: 推流黑帧
+     * - false: 正常推流
+     * @note 该接口用于对端用户发送屏幕黑帧数据时的回调
      */
-    publishAdd(stream: LocalStream, extra: PublishExtraParams, isResume?: boolean, retryTimes?: number): Promise<PublishInfo>;
+    userScreenMuted: (uid: string, isMute: boolean) => void;
     /**
-     * 替换推流 Track（仅限于替换已存在的 Track 类型）
-     * @param {LocalStream} stream
-     * @returns {Promise<PublishInfo>}
+     * 音量反馈
+     * @param {Array} speakers 用户音量对象数组
+     * @param {string} speaker.userId 用户ID
+     * @param {number} speaker.volume 音量
+     * @note userId 为空字符串时代表是本地麦克风采集的音量
      */
-    publishReplace(stream: LocalStream, extra?: PublishExtraParams): Promise<PublishInfo>;
+    audioVolume: (speakers: {
+        userId: string;
+        volume: number;
+    }[]) => void;
     /**
-     * 停止推某些轨，不销毁 DataChannel 和 LocalStream，用于非销毁场景
-     * @param {PublishOptions} options
-     * @returns {Promise<PublishInfo>}
+     * 发布视频流的数据统计
+     * @param aliRtcStats 统计信息
      */
-    publishDeleteTracks(options: PublishOptions): Promise<PublishInfo>;
+    aliRtcStats: (aliRtcStats: any) => void;
     /**
-     * 停止推流，不销毁  LocalStream，用于非销毁场景
-     * @returns {Promise<PublishInfo>}
+     * 音频推流变更回调
+     * @param track 流标识
+     * @param oldState 之前的推流状态
+     * @param newState 当前的推流状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
      */
-    publishStop(): Promise<PublishInfo>;
+    audioPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
     /**
-     * 停止推流，销毁 DataChannel，用于销毁的场景
-     * @returns {Promise<PublishInfo>}
+     * 音频订阅情况变更回调
+     * @param uid 用户ID
+     * @param oldState 之前的订阅状态
+     * @param newState 当前的订阅状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
      */
-    unPublish(): Promise<PublishInfo>;
+    audioSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
     /**
-     * 事件通知本地的设备使用状态
+     * 视频推流变更回调
+     * @param oldState 之前的推流状态
+     * @param newState 当前的推流状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
      */
-    reportSelfDeviceStatus(): void;
+    videoPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
     /**
-     * 从localStream 中获取当前的设备状态
-     * @returns {string}
+     * 次要流推流变更回调
+     * @param oldState 之前的推流状态
+     * @param newState 当前的推流状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
      */
-    private getDeviceStatus;
-    private onTrackEnd;
-    private resetPreviewElements;
-    private resetSecondayPreviewElements;
-    getMediaStats(id: string): any;
-    private reportPublishMonitor;
-    private reportNetwork;
-    private startStreamMonitor;
+    dualStreamPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
     /**
-     * 停止本地流数据采集
+     * 屏幕分享推流变更回调
+     * @param oldState 之前的推流状态
+     * @param newState 当前的推流状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
      */
-    private stopStreamMonitor;
+    screenSharePublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
     /**
-     * 清除本地流
-     * @returns {void}
+     * DataChannel 推流变更回调
+     * @param oldState 之前的推流状态
+     * @param newState 当前的推流状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
      */
-    clearStream(): void;
+    dataPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
     /**
-     * 获取当前使用的摄像头 deviceId
-     * @returns {string | undefined}
+     * 相机流订阅情况变更回调
+     * @param uid 用户ID
+     * @param oldState 之前的订阅状态
+     * @param newState 当前的订阅状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
      */
-    getCurrentCameraDeviceId(): string | undefined;
+    videoSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
     /**
-     * 获取当前使用的摄像头 deviceId
-     * @returns {string | undefined}
+     * 大小流订阅情况变更回调
+     * @param uid 用户ID
+     * @param oldStreamType 之前的订阅状态
+     * @param newStreamType 当前的订阅状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
      */
-    getCurrentMicDeviceId(): string | undefined;
-    enableAudioVolumeIndication(interval: number): void;
-    sendSEI(message: ArrayBuffer, repeatCount: number, payloadType: number): Promise<void>;
-    sendDataChannelMessage(message: AliRtcDataChannelMsg): void;
-    getStats(): Promise<{
-        audio: AliRtcLocalAudioStats[];
-        video: AliRtcLocalVideoStats[];
-        candidate: any;
-    }>;
-}
-
-interface AudioMixerPluginOptions {
-    audio?: number;
-    screen?: number;
-}
-
-interface VideoScalerOptions {
-    width: number;
-    height: number;
-    frameRate: number;
-}
-interface VideoScaler {
-    getVideoTrack: () => MediaStreamTrack;
-    updateOptions: (options: VideoScalerOptions) => void;
-    dispose: () => void;
-}
-
-declare class VideoScalerFactory {
-    static isSupport(): boolean;
+    subscribeStreamTypeChanged: (uid: string, oldStreamType: AliRtcVideoStreamType, newStreamType: AliRtcVideoStreamType, elapseSinceLastState: number, channel: string) => void;
     /**
-     * 获取实例
-     * @param {MediaStreamTrack} videoTrack
-     * @param {IProfile} profile
-     * @return {VideoScaler}
+     * 屏幕分享流订阅情况变更回调
+     * @param uid 用户ID
+     * @param oldState 之前的订阅状态
+     * @param newState 当前的订阅状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
      */
-    static getInstance(videoTrack: MediaStreamTrack, options: VideoScalerOptions): VideoScaler;
-}
-
-type AliRtcDualVideoPluginOptions = VideoScalerOptions;
-
-declare enum AliRtcCapabilityProfile {
-    Default = 0,
-    Human = 1,
-    Robot = 2
-}
-type AliRtcChannelParam = {
-    userName?: string;
-    capabilityProfile?: AliRtcCapabilityProfile;
-};
-
-interface RemoteUserMap {
-    [userId: string]: RemoteUser;
-}
-declare class BizControl extends EventEmitter$1<BizControlListener> {
+    screenShareSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
+    /**
+     * DataChannel 订阅情况变更回调
+     * @param uid 用户ID
+     * @param oldState 之前的订阅状态
+     * @param newState 当前的订阅状态
+     * @param elapseSinceLastState 状态变更时间间隔(毫秒)
+     * @param channel 当前频道
+     */
+    dataSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
     /**
-     * @ignore
+     * 收到媒体扩展信息回调
+     * @param uid 用户ID，媒体信息发送用户的ID
+     * @param message 媒体扩展信息
+     * @param payloadType payload类型，sendMediaExtensionMsg返回5，sendMediaExtensionMsgEx发送的会返回具体类型
+     * @note 当一端通过 {@link AliRtcEngine.sendMediaExtensionMsg} 发送信息后，其他端通过该回调接收数据
      */
-    static logName: string;
-    protected self: LocalUser;
-    protected userMap: RemoteUserMap;
-    private usersViewMap;
-    rtsManager: RtsManager;
-    protected localStreamManager: LocalStreamManager;
-    protected authInfo?: AliRtcAuthInfo;
-    protected signalingManager: SignalingManager;
-    pluginManager: PluginManager;
-    private audioMixerPlugin?;
-    private dualVideoPlugin?;
-    private blankAudioPlugin?;
-    private audioProcessorPlugin?;
-    protected slsReporter: SLSReporter;
-    private statsMonitorId?;
-    private autoSubAudio;
-    private autoSubVideo;
-    private autoSubScreen;
-    private wantSubAudio;
-    private wantSubVideo;
-    private wantSubScreen;
-    private defaultStreamType;
-    private audioMuted;
-    private playoutVolume;
-    private refreshUrlTimer?;
-    private audioVolumeIndicationInterval;
-    private indicationTimer;
-    private parameter;
-    private audio3AConfig;
-    private dcReadyHelper?;
-    constructor(config: BizControlConfig);
-    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[];
+    mediaExtensionMsgReceived: (uid: string, message: ArrayBuffer, payloadType: number) => void;
     /**
-     * 获取推流对象，只能是自己
+     * @brief 用户鉴权信息即将过期通知，收到后30秒鉴权过期
+     * @note 该回调在鉴权信息30秒前触发，收到该回调后应该及时更新鉴权信息，参考 {@link AliRtcEngine.refreshAuthInfo:}
      */
-    get publisher(): LocalUser | undefined;
-    get isSubscribing(): boolean;
+    authInfoWillExpire: () => void;
     /**
-     * 处理远端用户推流状态变化
-     * @param {string} userId
-     * @param {string} displayname
-     * @param {string} callid
-     * @param {string} pullStreamUrl
-     * @param {TrackInfo[]} tracks
-     * @returns {void}
+     * @brief 用户调用需要鉴权的接口，服务端返回信息过期
+     * @note 该回调触发代表鉴权信息已过期，想要继续在会中，需要重新入会，参考 {@link AliRtcEngine.joinChannel:name:onResultWithUserId:}
      */
-    onRemotePublishStateChange(publishInfo: PublishUser): void;
-    /** 定期更新所有人的推拉流地址，便于重连
-     * @param pushStreamUrl 已有的推流地址，根据地址中的过期时间来设置定时器
-     * @private
+    authInfoExpired: () => {};
+    /**
+     * 远程用户的音频自动播放失败
+     * @param uid
+     * @note 应该在收到该回调时弹出弹窗引导用户点击页面进行播放，用户点击页面后 SDK 会自动尝试播放
      */
-    private setTimeoutToUpdateAllStreamUrls;
+    remoteAudioAutoPlayFail: (uid: string) => void;
     /**
-     * 登陆成功后初始化用户管理，创建自己
-     * @param {AliRtcAuthInfo} authInfo
-     * @param {JoinResult} data
-     * @returns {Promise<void>}
+     * 远程用户的视频自动播放失败
+     * @param uid
+     * @note 应该在收到该回调时弹出弹窗引导用户点击页面进行播放，用户点击页面后 SDK 会自动尝试播放
      */
-    init(authInfo: AliRtcAuthInfo, data: JoinResult, channelParam: AliRtcChannelParam): void;
-    leave(): Promise<void>;
+    remoteVideoAutoPlayFail: (uid: string, videoTrack: AliRtcVideoTrack) => void;
     /**
-     * 离会后清除所有数据
-     * @returns {Promise<void>}
+     * 远程用户的音频播放出错
+     * @param uid 用户ID
+     * @param reason 出错原因，可选
      */
-    clear(): Promise<void>;
-    private startStatsMonitor;
-    private stopStatsMonitor;
+    remoteAudioPlayError: (uid: string, reason: string | undefined) => void;
     /**
-     * 添加远端用户
-     * @param {string} userId
-     * @param {string} displayName
-     * @returns {void}
+     * 远程用户的视频播放出错
+     * @param uid 用户ID
+     * @param reason 出错原因，可选
      */
-    addUser(userId: string, displayName: string, reason: SubscribeReason): RemoteUser;
+    remoteVideoPlayError: (uid: string, reason: string | undefined) => void;
     /**
-     * 执行添加远端用户
-     * @param {string} userId
-     * @param {string} displayName
-     * @returns {RemoteUser}
+     * 远程用户订阅数据通道
+     * @param uid 用户ID
      */
-    private executeAddUser;
+    remoteUserSubscribedDataChannel: (uid: string) => void;
     /**
-     * 远端用户设备状态变化
-     * @param {DeviceStatusChangeType} event
-     * @param {string} userId
+     * rtc 传输数据统计
+     * @param stats 统计信息
      */
-    private onRemoteDeviceStatusChange;
+    rtcStats: (stats: any) => void;
     /**
-     * 远端流数据采集上报
-     * @param {any} stat
+     * 发布视频流的数据统计
+     * @param aliRtcStats 统计信息
      */
-    private onRemoteStatReport;
+    rtcLocalVideoStats: (stats: AliRtcLocalVideoStats[]) => void;
     /**
-     * rts 单 PC 订阅超限
+     * 发布音频流的数据统计
+     * @param aliRtcStats 统计信息
      */
-    private onSubscribeExceeds;
+    rtcLocalAudioStats: (stats: AliRtcLocalAudioStats[]) => void;
     /**
-     * 移除远端用户
-     * @param {LeaveInfo} user
-     * @returns {Promise<void>}
+     * 订阅视频流的数据统计
+     * @param aliRtcStats 统计信息
      */
-    removeLeftUser(user: LeaveInfo): Promise<void>;
+    rtcRemoteVideoStats: (stats: AliRtcRemoteVideoStats[]) => void;
     /**
-     * 更新远端用户数据
-     * @param {JoinInfo[]} users
-     * @returns {{joinList: JoinInfo[], leaveList: LeaveInfo[], presentList: JoinInfo[]}}
+     * 订阅远端音频流的数据统计
+     * @param aliRtcStats 统计信息
      */
-    updateUsers(users: JoinInfo[]): {
-        joinList: JoinInfo[];
-        leaveList: LeaveInfo[];
-        presentList: JoinInfo[];
-    };
+    rtcRemoteAudioStats: (stats: AliRtcRemoteAudioStats[]) => void;
     /**
-     * 根据 userId 获取 RemoteUser
-     * @param {string} userId
-     * @returns {RemoteUser | undefined}
+     * @brief 错误通知
+     * @deprecated 请使用 occurError
+     * @details 如果engine出现error，通过这个回调通知app
+     * @param error  错误类型，参考 {@link AliRtcError}
+     * @param uid 用户 Id，不一定存在
      */
-    getRemoteUser(userId: string): RemoteUser | undefined;
+    onOccurError: (error: AliRtcError, uid?: string) => void;
     /**
-     * 更新远端用户设备信息
-     * @param {RemoteUserStatus} user
-     * @returns {boolean} true: 用户状态改变  false: 用户状态没有改变
+     * @brief 错误通知
+     * @details 如果engine出现error，通过这个回调通知app
+     * @param error  错误类型，参考 {@link AliRtcError}
+     * @param uid 用户 Id，不一定存在
      */
-    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;
-    setEnableDualVideoStream(enabled: boolean, options?: AliRtcDualVideoPluginOptions): void;
-    setAudioVolume(options: AudioMixerPluginOptions): void;
-    enableAudioVolumeIndication(interval: number): void;
-    setPlayoutVolume(volume: number): void;
-    refreshAuthInfo(authInfo: AliRtcRefreshAuthInfo): void;
-    setEnableMediaExtensionMsg(enable: boolean): void;
-    setAudioRedEnabled(enable: boolean): void;
-    setParameter(parameter: string): void;
-    private setupAudioProcessingPluginIfNeeded;
-    getParameter(): string;
-    sendDataChannelMessage(message: AliRtcDataChannelMsg): void;
+    occurError: (error: AliRtcError, uid?: string) => void;
+    /**
+     * @brief 收到数据通道消息
+     * @param uid 用户ID
+     * @param message 消息
+     */
+    dataChannelMsg: (uid: string, message: AliRtcDataChannelMsg) => void;
+    /**
+     * @brief AI agent处理结果
+     * @param code 返回code码
+     * @param action 结果对应的action
+     * @param result 结果
+     */
+    AIAgentResult: (code: number, action: string, result: string) => void;
 }
 
-declare class AliRtcLiveTranscoding {
-    authInfo?: AliRtcAuthInfo;
-    private slsReporter;
-    constructor(slsReporter: SLSReporter);
-    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;
+declare enum AliRtcRawDataStreamType {
+    /** 相机流 */
+    AliRtcSdkStreamTypeCapture = 0,
+    /** 屏幕共享流 */
+    AliRtcSdkStreamTypeScreen = 1
 }
 
 interface AliRtcScreenShareConfiguration {
@@ -3511,30 +3527,15 @@ interface AliRtcScreenShareConfiguration {
     bitrate?: number;
 }
 
-interface AliRtcWebTrackConfig {
-    biz: string;
-    extraParams?: string;
-}
-interface AliRtcEngineConfig {
-    env?: AliRtcEnv;
-    webTrack?: boolean | AliRtcWebTrackConfig;
-    maxSignalingConnectRetryCount?: number;
-}
-interface AliRtcAIAgentParam {
-    /*! ai agent id */
-    agentId: string;
-    /*! ai agent的区域 */
-    region: string;
-    /*! 启动ai agent的action */
-    action: string;
-    /*! 启动ai agent的参数 */
-    params: string;
+interface AliRtcScreenShareStartConfig {
+    audio?: boolean;
+    videoTrack?: MediaStreamVideoTrack;
+    audioTrack?: MediaStreamAudioTrack;
 }
 
-interface AliRtcBeautyConfig {
-    whiteningLevel: number;
-    /*! 磨皮等级[0-1.0] */
-    smoothnessLevel: number;
+interface AliRtcVideoTrackConfig {
+    userId?: string;
+    streamType: AliRtcRawDataStreamType;
 }
 
 interface ImageHolderPluginOptions {
@@ -3692,7 +3693,7 @@ declare class AliRtcEngine extends EventEmitter$1<AliRtcEngineEventListener> {
     private backToUnpublishStatus;
     /**
      * 处理入会远程的用户
-     * @param {JoinInfo[]} users
+     * @param {JoinInfo[]} userJoinInfo
      * @returns {void}
      */
     private handleUsersJoin;