@byteplus/rtc 4.42.1 → 4.44.0

package/index.d.ts

@@ -14,6 +14,11 @@ declare enum ErrorCode {
 	 */
 	INVALID_PARAMS = "INVALID_PARAMS",
 	
+	/** 
+	 * @brief You are not in the room when trying to publish/unpublish or subscribe/unsubscribe stream
+	 */
+	INVOKED_BEFORE_JOIN_ROOM = "INVOKED_BEFORE_JOIN_ROOM",
+	
 	/** 
 	 * @brief Invalid Token
 	 */
@@ -123,7 +128,6 @@ declare enum ErrorCode {
 	 * @brief Users have been removed from the room because the administrator dismissed the room by calling OpenAPI.
 	 */
 	ROOM_DISMISS = "ROOM_DISMISS",
-	/** Token过期被踢出房间 */
 	
 	/** 
 	 * @brief Token expired. Call `joinRoom` to rejoin with a valid Token.
@@ -367,7 +371,13 @@ declare enum ErrorCode {
 	/** 
 	 * @brief The user publishes a public stream before joining room.
 	 */
-	START_PUBLIC_STREAM_BEFORE_JOIN = "START_PUBLIC_STREAM_BEFORE_JOIN"
+	START_PUBLIC_STREAM_BEFORE_JOIN = "START_PUBLIC_STREAM_BEFORE_JOIN",
+	
+	/** 
+	 * @brief Reconnection with the server fails and SDK will no longer automatically retry.
+	 *        Please leave room first and join room again, or contact technical support.
+	 */
+	RECONNECT_FAILED = "RECONNECT_FAILED"
 }
 declare enum AudioMixingError {
 	
@@ -432,16 +442,16 @@ declare enum AudioMixingError {
 export interface IAudioMixingManager {
 	
 	/** 
-	 * @brief Start playing audio files and mixes. <br>
-	 *         This method can be called many times by passing in different IDs and filepath to realize simultaneous playback of multiple mixing files and mixing overlay.<br>
-	 * @param id Mix ID. For identifying the mix, please ensure that the mix ID is unique. <br>
+	 * @brief Start playing audio files and mixes.
+	 *         This method can be called many times by passing in different IDs and filepath to realize simultaneous playback of multiple mixing files and mixing overlay.
+	 * @param id Mix ID. For identifying the mix, please ensure that the mix ID is unique.
 	 *         If this method is repeatedly called with the same ID, the previous mix stops and the next mix starts.
 	 * @param filePath  Specify the file path either the absolute path of a local file or the url of online audio.  Files with the extension of mp3 and aac are supported.
-	 * @param config  Mix Sound configuration <br>
+	 * @param config  Mix Sound configuration.
 	 *         You can set the number of times the mix is played, whether the mix is played locally, and whether the mix is sent to the remote end. For details.
 	 * @return
-	 * @notes + If you have already loaded the sound effect into memory through [preloadAudioMixing](#preloadaudiomixing), make sure that the ID here is the same as the ID set by [preloadAudioMixing](#preloadaudiomixing).  <br>
-	 *        + After you start playing the audio file and mixing, you can call the [stopAudioMixing](#stopaudiomixing) method to stop playing the audio file. <br>
+	 * @notes + If you have already loaded the sound effect into memory through [preloadAudioMixing](#preloadaudiomixing), make sure that the ID here is the same as the ID set by [preloadAudioMixing](#preloadaudiomixing).
+	 *        + After you start playing the audio file and mixing, you can call the [stopAudioMixing](#stopaudiomixing) method to stop playing the audio file.
 	 *        + The mixing data of this method comes from an external file, while the mixing data of [enableAudioMixingFrame](#enableAudioMixingFrame) comes from an external cache and the audio format is PCM. These two mixing methods can coexist.
 	 * @region Advanced Feature
 	 */
@@ -450,7 +460,7 @@ export interface IAudioMixingManager {
 	/** 
 	 * @brief Stop playing audio files and mixes
 	 * @param id ID of the mixing
-	 * @notes + After calling [startAudioMixing](#startaudiomixing) method to start playing audio files and mixes, you can call this method to stop playing audio files and mixes. <br>
+	 * @notes + After calling [startAudioMixing](#startaudiomixing) method to start playing audio files and mixes, you can call this method to stop playing audio files and mixes.
 	 *        + After calling this method to stop playing the audio file, the audio file will be automatically uninstalled.
 	 * @region Advanced Feature
 	 */
@@ -459,8 +469,8 @@ export interface IAudioMixingManager {
 	/** 
 	 * @brief Pause playing audio files and mixes
 	 * @param id  ID of the mixing
-	 * @notes + After calling [startAudioMixing](#startaudiomixing) method to start playing audio files and mixes, you can call this method to pause playing audio files and mixes. <br>
-	 *        + After calling this method to pause playing audio files and mixing, you can call the [resumeAudioMixing](#resumeaudiomixing) method to resume playing and mixing. <br>
+	 * @notes + After calling [startAudioMixing](#startaudiomixing) method to start playing audio files and mixes, you can call this method to pause playing audio files and mixes.
+	 *        + After calling this method to pause playing audio files and mixing, you can call the [resumeAudioMixing](#resumeaudiomixing) method to resume playing and mixing.
 	 * @region Advanced Feature
 	 */
 	pauseAudioMixing(id: number): void;
@@ -468,21 +478,21 @@ export interface IAudioMixingManager {
 	/** 
 	 * @brief Resume playing audio files and mixing
 	 * @param id  Mixing ID
-	 * @notes After calling the [pauseAudioMixing](#pauseaudiomixing) method to pause playing audio files and mixing, you can resume playing and mixing by calling this method. <br>
+	 * @notes After calling the [pauseAudioMixing](#pauseaudiomixing) method to pause playing audio files and mixing, you can resume playing and mixing by calling this method.
 	 * @region Advanced Feature
 	 */
 	resumeAudioMixing(id: number): void;
 	
 	/** 
 	 * @brief Preload the specified audio file into memory
-	 * @param id Mix ID. For identifying the mix, please ensure that the mix ID is unique. <br>
-	 *         If this method is called repeatedly with the same ID, the latter overrides the previous. <br>
-	 *         If you call [startAudioMixing](#startaudiomixing) and then call this method with the same ID, the previous mix stopped, and then the next mix was loaded. <br>
+	 * @param id Mix ID. For identifying the mix, please ensure that the mix ID is unique.
+	 *         If this method is called repeatedly with the same ID, the latter overrides the previous.
+	 *         If you call [startAudioMixing](#startaudiomixing) and then call this method with the same ID, the previous mix stopped, and then the next mix was loaded.
 	 *         After calling this method with an ID to preload A.mp3, if you need to call [startAudioMixing](#startaudiomixing) to play B.mp3 with the same ID, please call [unloadAudioMixing](#unloadaudiomixing) to uninstall A.mp3 first, otherwise you will report an error AUDIO_MIXING_ERROR_LOAD_CONFLICT.
-	 * @param filePath  Used for mixing file paths. It can be the absolute path of the local file or the url of the online audio. <br>
+	 * @param filePath  Used for mixing file paths. It can be the absolute path of the local file or the url of the online audio.
 	 * @return
-	 * @notes + When you need to play an audio file frequently, call this method to preload the file. When playing, you can only load the file once to reduce CPU usage. <br>
-	 *        + This method pre-loads the specified audio file, and only calling [startAudioMixing](#startaudiomixing) API can you start playing the specified audio file. <br>
+	 * @notes + When you need to play an audio file frequently, call this method to preload the file. When playing, you can only load the file once to reduce CPU usage.
+	 *        + This method pre-loads the specified audio file, and only calling [startAudioMixing](#startaudiomixing) API can you start playing the specified audio file.
 	 *        + The specified audio file preloaded by calling this method can be unloaded through [unloadAudioMixing](#unloadaudiomixing).
 	 * @region Advanced Feature
 	 */
@@ -498,9 +508,9 @@ export interface IAudioMixingManager {
 	/** 
 	 * @brief Adjust the volume of audio mixing, including audio files and PCM data.
 	 * @param id Mixing ID
-	 * @param volume The ratio of the mixing volume to the original volume. The range is `[0, 400]`. The recommended range is `[0, 100]`. <br>
-	 *         + 0: Mute <br>
-	 *         + 100: Original volume <br>
+	 * @param volume The ratio of the mixing volume to the original volume. The range is `[0, 400]`. The recommended range is `[0, 100]`.
+	 *         + 0: Mute
+	 *         + 100: Original volume
 	 *         + 400: Maximum volume (with overflow protection)
 	 * @region Advanced Feature
 	 */
@@ -509,9 +519,8 @@ export interface IAudioMixingManager {
 	/** 
 	 * @brief Get volume of the audio files.
 	 * @param id Audio mix id
-	 * @return <br>
-	 *         + `0`: Failure<br>
-	 *         + `>0`: Successful. Volume<br>
+	 * @return + `0`: Failure
+	 *         + `>0`: Successful. Volume
 	 * @region Advanced Feature
 	 */
 	getAudioMixingVolume(id: number): number;
@@ -519,8 +528,7 @@ export interface IAudioMixingManager {
 	/** 
 	 * @brief Get audio file duration
 	 * @param id   Mix ID
-	 * @return   <br>
-	 *         + > 0: Success, audio file duration, in milliseconds. <br>
+	 * @return + > 0: Success, audio file duration, in milliseconds.
 	 *         + < 0: Failure
 	 * @notes  Before calling this method to obtain the length of the audio file, you need to call [preloadAudioMixing](#preloadaudiomixing) or [startAudioMixing](#startaudiomixing).
 	 * @region Advanced Feature
@@ -530,8 +538,7 @@ export interface IAudioMixingManager {
 	/** 
 	 * @brief Get audio file playback progress
 	 * @param id   Mix ID
-	 * @return   <br>
-	 *         + > 0: Success, audio file playback progress, in milliseconds. <br>
+	 * @return + > 0: Success, audio file playback progress, in milliseconds.
 	 *         + < 0: Failed
 	 * @notes Before calling this method to get the audio file playback progress, you need to call [startAudioMixing](#startaudiomixing) to start playing the audio file.
 	 * @region Advanced Feature
@@ -541,20 +548,20 @@ export interface IAudioMixingManager {
 	/** 
 	 * @brief Set the starting playback position of the audio file
 	 * @param id Mixing ID
-	 * @param position The starting playback position of the audio file in milliseconds.<br>
+	 * @param position The starting playback position of the audio file in milliseconds.
 	 *                 Call [getAudioMixingDuration](#getAudioMixingDuration) to get the duration of the audio file. The value of  `position` must not be greater than the duration of the audio file.
-	 * @notes + This method allows you to play an audio file from a specified position as appropriate, without having to play an audio file in its entirety from the beginning to finish.  <br>
+	 * @notes + This method allows you to play an audio file from a specified position as appropriate, without having to play an audio file in its entirety from the beginning to finish.
 	 *       + Before calling this method to set the playback position of the audio file, you need to call [startAudioMixing](#startaudiomixing) to start playing the audio file.
 	 * @region Advanced Feature
 	 */
 	setAudioMixingPosition(id: number, position: number): void;
 	
 	/** 
-	 * @brief Start PCM mixing. <br>
+	 * @brief Start PCM mixing.
 	 *        To mix multiple PCM audio data, call this API multiple times with different ids.
-	 * @param type Mixing type <br>
+	 * @param type Mixing type.
 	 *        Whether the PCM data is mixed locally and sent to the remotes.
-	 * @notes + After this API, you must call [pushAudioMixingFrame](#pushaudiomixingframe) to start mixing. <br>
+	 * @notes + After this API, you must call [pushAudioMixingFrame](#pushaudiomixingframe) to start mixing.
 	 *        + To end PCM mixing, use [disableAudioMixingFrame](#disableaudiomixingframe).
 	 * @region Advanced Feature
 	 */
@@ -569,7 +576,7 @@ export interface IAudioMixingManager {
 	/** 
 	 * @brief Push PCM audio frame data for mixing
 	 * @param buffer Refer to [Browser documentation](https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer)
-	 * @notes Before calling this method, you must start the external audio stream mixing through [enableAudioMixingFrame](#enableaudiomixingframe). <br>
+	 * @notes Before calling this method, you must start the external audio stream mixing through [enableAudioMixingFrame](#enableaudiomixingframe).
 	 * @region Advanced Feature
 	 */
 	pushAudioMixingBuffer(buffer: AudioBuffer): void;
@@ -647,8 +654,8 @@ export interface MixOption {
 	
 	/** 
 	 * @brief Mix playback times
-	 * @notes + Play_count < = 0: Infinite loop <br>
-	 *        + Play_count == 1: Play once (default) <br>
+	 * @notes + Play_count < = 0: Infinite loop
+	 *        + Play_count == 1: Play once (default)
 	 *        + Play_count > 1: Play play_count times
 	 */
 	playCount: number;
@@ -665,38 +672,136 @@ declare class EnhancedEventEmitter<EventTypes extends ValidEventTypes = string |
 }
 
 /** 
- * @brief Information of media device
+ * @brief Information and state of a media device.
  */
-export interface RTCDevice {
+export interface DeviceInfo {
+	
+	/** 
+	 * @brief Information of a media device. See [MediaDeviceInfo](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo).
+	 */
+	mediaDeviceInfo: MediaDeviceInfo;
+	
+	/** 
+	 * @brief Device state.
+	 */
+	deviceState: "active" | "inactive";
+}
+export interface AudioCodecProfile {
+	chn: number;
+	sr: number;
+}
+export interface IEngineBAC {
+	codec?: any;
+	play?: AudioCodecProfile;
+	record?: AudioCodecProfile;
+	agc?: any;
+	aec?: any;
+	ans?: any;
+}
+export interface IEngineANM {
+	enc_param: {
+		bitrate: number;
+		chn: number;
+	};
+}
+export interface IAudioConfig {
+	bitrate: number;
+	channel: number;
+	sampleRate: number;
+	agc: boolean;
+	aec: boolean;
+	ans: boolean;
+}
+declare class AudioProfileManager {
+	engineBAC: any;
+	engineANM: any;
+	bitrate?: number;
+	sampleRate?: number;
+	channel: number;
+	aec: boolean;
+	agc: boolean;
+	ans: boolean;
+	constructor();
+	private _init;
+	updateEngineBAC(newProfile?: IEngineBAC): void;
+	updateEngineANM(newProfile?: IEngineANM): void;
+	setAudioProfile(profile: AudioProfileType): void;
+	setBitrate(bitrate: number): void;
+	setAEC(enable: boolean): void;
+	setAGC(enable: boolean): void;
+	setANS(enable: boolean): void;
+	getOpusConfigStr(): string;
+	get config(): IAudioConfig;
+}
+declare enum StreamMixingEventType {
 	
 	/** 
-	 * @brief Device ID
-	 * Refer to the [browser documentation](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo)
+	 * @brief Request a start to push the mixed stream to CDN.
 	 */
-	deviceId: MediaDeviceInfo["deviceId"];
+	START = 1,
 	
 	/** 
-	 * @brief Device type
-	 * Refer to the [browser documentation](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo)
+	 * @brief Success.
 	 */
-	deviceType: MediaDeviceInfo["kind"];
+	START_SUCCESS = 2,
 	
 	/** 
-	 * @brief Device information
-	 * Refer to the [browser documentation](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo)
+	 * @brief Failure.
 	 */
-	deviceInfo: MediaDeviceInfo;
+	START_FAILED = 3,
 	
 	/** 
-	 * @brief Device label
-	 * Refer to the [browser documentation](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo)
+	 * @brief Request a configuration update.
 	 */
-	deviceName: MediaDeviceInfo["label"];
+	UPDATE = 4,
 	
 	/** 
-	 * @brief Device state
+	 * @brief Push the mixed stream after the configuration update.
 	 */
-	deviceState: "active" | "inactive";
+	UPDATE_SUCCESS = 5,
+	
+	/** 
+	 * @brief Fail to update the configuration.
+	 */
+	UPDATE_FAILED = 6,
+	
+	/** 
+	 * @brief Request a stop to push the mixed stream to CDN.
+	 */
+	STOP = 7,
+	
+	/**  Pushing the mixed stream to CDN is stopped.
+	 * @brief
+	 */
+	STOP_SUCCESS = 8,
+	
+	/** 
+	 * @brief Fail to stop pushing the mixed stream to CDN.
+	 */
+	STOP_FAILED = 9
+}
+/** 
+ * @brief Cloud proxy informatio
+ */
+export interface CloudProxyInfo {
+	
+	/** 
+	 * @brief The cloud proxy IP of log report
+	 */
+	logProxy: string;
+	
+	/** 
+	 * @brief The cloud proxy IP of the access
+	 */
+	accessProxy: string;
+	
+	/** 
+	 * @brief The cloud proxy IP of RTC admin control
+	 */
+	configProxy: string;
+}
+export interface RTCContext {
+	audioProfileManager: AudioProfileManager;
 }
 
 /** 
@@ -809,7 +914,12 @@ export interface onVideoFirstFrameDecodedEvent {
 /** 
  * Event related to decoding the first video frame of the public stream.
  */
-export declare type PublicStreamVideoFirstFrameDecodedEvent = Omit<onVideoFirstFrameDecodedEvent, "userId"> & {
+export declare type PublicStreamVideoFirstFrameDecodedEvent = Omit<
+
+/** 
+ * @brief Event related to the decoding of the first video frame.
+ */
+onVideoFirstFrameDecodedEvent, "userId"> & {
 	
 	/** 
 	 * @brief  The public stream's ID.
@@ -929,6 +1039,7 @@ export interface LocalAudioStats {
 	numChannels: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Sample rate of sending
 	 */
 	sentSampleRate?: number;
@@ -945,6 +1056,7 @@ export interface LocalVideoStats {
 	sentKBitrate: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Frame rate of the source video
 	 */
 	inputFrameRate?: number;
@@ -965,11 +1077,13 @@ export interface LocalVideoStats {
 	rendererOutputFrameRate?: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Target bitrate
 	 */
 	targetKBitrate?: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Target frame rate
 	 */
 	targetFrameRate?: number;
@@ -990,6 +1104,7 @@ export interface LocalVideoStats {
 	rtt: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Bitrate of encoding
 	 */
 	encodedBitrate?: number;
@@ -1079,11 +1194,13 @@ export interface RemoteAudioStats {
 	stallDuration?: number;
 	
 	/** 
+	 * @hidden
 	 * @brief End-to-end delay, unit: ms
 	 */
 	e2eDelay: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Sample rate of the playback
 	 */
 	playoutSampleRate?: number;
@@ -1120,6 +1237,7 @@ export interface RemoteAudioStats {
 	receivedSampleRate: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Video frozen rate
 	 */
 	frozenRate?: number;
@@ -1135,11 +1253,13 @@ export interface RemoteAudioStats {
 	concealmentEvent: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Sample rate of decoding
 	 */
 	decSampleRate?: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Decoding duration, unit: s
 	 */
 	decDuration?: number;
@@ -1176,6 +1296,7 @@ export interface RemoteVideoStats {
 	decoderOutputFrameRate: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Frame rate of rendering
 	 */
 	rendererOutputFrameRate?: number;
@@ -1191,6 +1312,7 @@ export interface RemoteVideoStats {
 	stallDuration?: number;
 	
 	/** 
+	 * @hidden
 	 * @brief End-to-end delay, unit: ms
 	 */
 	e2eDelay: number;
@@ -1211,11 +1333,13 @@ export interface RemoteVideoStats {
 	rtt: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Video frozen rate
 	 */
 	frozenRate?: number;
 	
 	/** 
+	 * @hidden
 	 * @brief Video index
 	 */
 	videoIndex?: number;
@@ -1303,16 +1427,10 @@ declare enum EngineEventsTypes {
 	 * @brief Connection state changes.
 	 */
 	onConnectionStateChanged = "onConnectionStateChanged",
-	
-	/** 
-	 * @brief A new media stream in the room
-	 */
-	onStreamAdd = "onStreamAdd",
-	
-	/** 
-	 * @brief A media stream in the room has been stopped.
-	 */
-	onStreamRemove = "onStreamRemove",
+	onUserPublishStream = "onUserPublishStream",
+	onUserUnpublishStream = "onUserUnpublishStream",
+	onUserPublishScreen = "onUserPublishScreen",
+	onUserUnpublishScreen = "onUserUnpublishScreen",
 	
 	/** 
 	 * @brief Receiving a broadcasting message in the room
@@ -1334,16 +1452,6 @@ declare enum EngineEventsTypes {
 	 */
 	onUserBinaryMessageReceived = "onUserBinaryMessageReceived",
 	
-	/** 
-	 * @brief A visible user in the room mutes his/her audio.
-	 */
-	onUserMuteAudio = "onUserMuteAudio",
-	
-	/** 
-	 * @brief A visible user in the room mutes his/her video.
-	 */
-	onUserMuteVideo = "onUserMuteVideo",
-	
 	/** 
 	 * @brief The first video frame has been rendered successfully.
 	 */
@@ -1375,9 +1483,14 @@ declare enum EngineEventsTypes {
 	onFirstPublicStreamAudioFrameDecoded = "onFirstPublicStreamAudioFrameDecoded",
 	
 	/** 
-	 * @brief The state of the media device changes.
+	 * @brief The state of the video media device changes.
+	 */
+	onVideoDeviceStateChanged = "onVideoDeviceStateChanged",
+	
+	/** 
+	 * @brief The state of the audio media device changes.
 	 */
-	onMediaDeviceStateChanged = "onMediaDeviceStateChanged",
+	onAudioDeviceStateChanged = "onAudioDeviceStateChanged",
 	
 	/** 
 	 * @brief Callback including the state of the remote media stream
@@ -1432,6 +1545,7 @@ declare enum EngineEventsTypes {
 	 * @brief The state of pushing streams to CDN
 	 */
 	onLiveTranscodingResult = "onLiveTranscodingResult",
+	onStreamMixingEvent = "onStreamMixingEvent",
 	onAudioPlaybackDeviceTestVolume = "onAudioPlaybackDeviceTestVolume",
 	onSEIMessageReceived = "onSEIMessageReceived",
 	onError = "onError",
@@ -1441,7 +1555,31 @@ declare enum EngineEventsTypes {
 	onTokenWillExpire = "onTokenWillExpire",
 	onCloudProxyConnected = "onCloudProxyConnected",
 	onPushPublicStreamResult = "onPushPublicStreamResult",
-	onPublicStreamSEIMessageReceived = "onPublicStreamSEIMessageReceived"
+	onPublicStreamSEIMessageReceived = "onPublicStreamSEIMessageReceived",
+	onNetworkQuality = "onNetworkQuality",
+	onSimulcastSubscribeFallback = "onSimulcastSubscribeFallback",
+	onRemoteVideoSizeChanged = "onRemoteVideoSizeChanged"
+}
+
+/** 
+ * @brief Pushing a mixed stream to CDN events
+ */
+export interface StreamMixingEvent {
+	
+	/** 
+	 * @brief The types. See [StreamMixingEventType](104481#streammixingeventtype).
+	 */
+	event: StreamMixingEventType;
+	
+	/** 
+	 * @brief The error codes. See [StreamMixingEventErrorCode](104480#streammixingeventerrorcode).
+	 */
+	error: StreamMixingEventErrorCode;
+	
+	/** 
+	 * @brief The detailed error messages.
+	 */
+	message: string;
 }
 
 /** 
@@ -1482,22 +1620,6 @@ export interface onSEIMessageReceivedEvent {
 	remoteStreamKey: RemoteStreamKey;
 }
 
-/** 
- * @brief User mutes audio or video.
- */
-export interface UserMuteEvent {
-	
-	/** 
-	 * @brief User information, refer to [UserInfo](#userinfo) for more details.
-	 */
-	userInfo: UserInfo;
-	
-	/** 
-	 * @brief Details of disabling audio or video.
-	 */
-	muteState: MuteState;
-}
-
 /** 
  * @brief The connection state changes.
  */
@@ -1573,58 +1695,58 @@ export interface AudioMixingStateChangedEvent {
 }
 
 /** 
- * @brief Information about local audio   <br>
+ * @brief Information about local audio
  */
 export interface LocalAudioPropertiesInfo {
 	
 	/** 
-	 * @brief Indicates whether the audio is captured by microphone or from screen sharing.  <br>
+	 * @brief Indicates whether the audio is captured by microphone or from screen sharing.
 	 */
 	streamIndex: StreamIndex;
 	
 	/** 
 	 * @type keytype
-	 * @brief Audio information  <br>
+	 * @brief Audio information
 	 */
 	audioPropertiesInfo: AudioPropertiesInfo;
 }
 
 /** 
- * @brief Information about remote audio   <br>
+ * @brief Information about remote audio
  */
 export interface RemoteAudioPropertiesInfo {
 	
 	/** 
-	 * @brief Information about remote stream  <br>
+	 * @brief Information about remote stream
 	 */
 	streamKey: StreamKey;
 	
 	/** 
-	 * @brief Information about remote audio properties  <br>
+	 * @brief Information about remote audio properties
 	 */
 	audioPropertiesInfo: AudioPropertiesInfo;
 }
 
 /** 
- * @brief Audio information   <br>
+ * @brief Audio information
  */
 export interface AudioPropertiesInfo {
 	
 	/** 
-	 * @brief linear volume. The value is in linear relation to the original volume. The higher the value, the higher the volume. The range is [0,255]. <br>
-	 *        - [0, 25]: Silence <br>
-	 *        - [26, 75]: Low volume <br>
-	 *        - [76, 204]: Medium volume <br>
-	 *        - [205, 255]: High volume <br>
+	 * @brief linear volume. The value is in linear relation to the original volume. The higher the value, the higher the volume. The range is [0,255].
+	 *        - [0, 25]: Silence
+	 *        - [26, 75]: Low volume
+	 *        - [76, 204]: Medium volume
+	 *        - [205, 255]: High volume
 	 */
 	linearVolume: number;
 	
 	/** 
-	 * @brief non-linear volume in dB. The value is in proportion to the log value of the original volume. You can use the value to recognize the Active Speaker in the room. The range is [-127, 0]. <br>
-	 *        - [-127, -60]: Silence <br>
-	 *        - [-59, -40]: Low volume <br>
-	 *        - [-39, -20]: Medium volume <br>
-	 *        - [-19, 0]: High volume <br>
+	 * @brief non-linear volume in dB. The value is in proportion to the log value of the original volume. You can use the value to recognize the Active Speaker in the room. The range is [-127, 0].
+	 *        - [-127, -60]: Silence
+	 *        - [-59, -40]: Low volume
+	 *        - [-39, -20]: Medium volume
+	 *        - [-19, 0]: High volume
 	 */
 	nonlinearVolume: number;
 }
@@ -1645,10 +1767,42 @@ export interface StreamKey {
 	userId: string;
 	
 	/** 
-	 * @brief Indicates whether the audio is captured by microphone or from screen sharing.  <br>
+	 * @brief Indicates whether the audio is captured by microphone or from screen sharing.
 	 */
 	streamIndex: StreamIndex;
 }
+declare enum StreamMixingEventErrorCode {
+	
+	/** 
+	 * @brief Success.
+	 */
+	ERR_OK = 0,
+	
+	/** 
+	 * @brief Failure. Invalid configuration parameters.
+	 */
+	ERR_PARAM_INVALID = 1,
+	
+	/** 
+	 * @brief RTC connection failure. The RTC server will be auto-reconnected.
+	 */
+	ERR_FRAME_TIMEOUT = 2,
+	
+	/** 
+	 * @brief Errors occur during stream mixing. Please retry your request.
+	 */
+	ERR_POSTPROCESS = 3,
+	
+	/** 
+	 * @brief Failure. Please wait for a re-push.
+	 */
+	ERR_PUSH_CDN = 4,
+	
+	/** 
+	 * @brief Other unknown errors.
+	 */
+	ERR_UNKNOWN = 9999
+}
 
 /** 
  * @list 104477
@@ -1685,35 +1839,80 @@ export interface IEngineEvents {
 	[EngineEventsTypes.onConnectionStateChanged]: (event: ConnectionStateChangeEvent) => void;
 	
 	/** 
-	 * @brief A new stream added into the room.
-	 * @param event `stream` object.
-	 * @region Room Management Event
+	 * @brief Callback on new media streams captured by camera/microphone in the room.
+	 * @notes You will receive this callback after a remote user successfully publishes media streams captured by camera/microphone in the room with [publishStream](#publishstream). Then you can choose whether to call [subscribeStream](#subscribeStream) to subscribe to the streams or not.
 	 */
-	[EngineEventsTypes.onStreamAdd]: (event: {
-		stream: RTCStream;
+	[EngineEventsTypes.onUserPublishStream]: (event: {
+		
+		/** 
+		 * @brief ID of the remote user who published the stream
+		 */
+		userId: string;
+		
+		/** 
+		 * @brief Remote stream type
+		 */
+		mediaType: MediaType;
 	}) => void;
 	
 	/** 
-	 * @brief Users will receive this event when a user in the room pauses/ resumes publishing audio stream.
-	 * @param event
-	 * @region Room Management Event
+	 * @brief Callback on removal of remote media stream captured by camera/microphone.
+	 * @notes You will receive this callback after a remote user successfully unpublishes media streams captured by camera/microphone in the room with [publishStream](#publishstream). Then you can choose whether to call [unsubscribeStream](#unsubscribeStream) to unsubscribe from the streams or not.
 	 */
-	[EngineEventsTypes.onUserMuteAudio]: (event: UserMuteEvent) => void;
+	[EngineEventsTypes.onUserUnpublishStream]: (event: {
+		
+		/** 
+		 * @brief ID of the remote user who removed the stream
+		 */
+		userId: string;
+		
+		/** 
+		 * @brief Remote stream type
+		 */
+		mediaType: MediaType;
+		
+		/** 
+		 * @brief The reason for the removal
+		 */
+		reason: StreamRemoveReason;
+	}) => void;
 	
 	/** 
-	 * @brief Users will receive this event when a user in the room pauses/ resumes publishing video stream.
-	 * @region Room Management Event
-	 * @param event
+	 * @brief Callback on new screen sharing media streams from remote users in the room.
+	 * @notes You will receive this callback after a remote user successfully published screen sharing streams in the room with [publishScreen](#publishscreen). Then you can choose whether to call [subscribeScreen](#subscribeScreen) to subscribe to the streams or not.
 	 */
-	[EngineEventsTypes.onUserMuteVideo]: (event: UserMuteEvent) => void;
+	[EngineEventsTypes.onUserPublishScreen]: (event: {
+		
+		/** 
+		 * @brief ID of the remote user who published the stream
+		 */
+		userId: string;
+		
+		/** 
+		 * @brief Remote stream type
+		 */
+		mediaType: MediaType;
+	}) => void;
 	
 	/** 
-	 * @brief Users will receive this event when a user in the room pauses/ resumes publishing audio stream.
-	 * @param event <li>stream: media stream</li><li>reason</li>.
-	 * @region Room Management Event
+	 * @brief Callback on removal of screen sharing media streams from remote users in the room.
+	 * @notes You will receive this callback after a remote user successfully unpublishes media streams captured by camera/microphone in the room with [publishScreen](#publishscreen). Then you can choose whether to call [unsubscribeScreen](#unsubscribeScreen) to unsubscribe from the streams or not.
 	 */
-	[EngineEventsTypes.onStreamRemove]: (event: {
-		stream: RTCStream;
+	[EngineEventsTypes.onUserUnpublishScreen]: (event: {
+		
+		/** 
+		 * @brief ID of the remote user who removed the stream
+		 */
+		userId: string;
+		
+		/** 
+		 * @brief Remote stream type
+		 */
+		mediaType: MediaType;
+		
+		/** 
+		 * @brief The reason for the removal
+		 */
 		reason: StreamRemoveReason;
 	}) => void;
 	
@@ -1739,11 +1938,16 @@ export interface IEngineEvents {
 	[EngineEventsTypes.onAudioFirstFrameDecoded]: (event: onAudioFirstFrameDecodedEvent) => void;
 	
 	/** 
-	 * @brief Event of media device state changing
-	 * @param event Media device and its state
-	 * @region Engine Management Event
+	 * @brief Event of video device state changing.
+	 * @param event Information and state of a media device.
 	 */
-	[EngineEventsTypes.onMediaDeviceStateChanged]: (event: RTCDevice) => void;
+	[EngineEventsTypes.onVideoDeviceStateChanged]: (event: DeviceInfo) => void;
+	
+	/** 
+	 * @brief Event of audio device state changing.
+	 * @param event Information and state of a media device.
+	 */
+	[EngineEventsTypes.onAudioDeviceStateChanged]: (event: DeviceInfo) => void;
 	
 	/** 
 	 * @brief Failure of automatically playing
@@ -1754,31 +1958,55 @@ export interface IEngineEvents {
 	
 	/** 
 	 * @brief Event of media track ending
-	 * @param event <li>kind: string Type of the track</li><li>isScreen: boolean Whether it is a screen-sharing stream</li>
+	 * @param event
 	 * @region Video Management Event
 	 */
 	[EngineEventsTypes.onTrackEnded]: (event: {
+		
+		/** 
+		 * @brief Type of the trac
+		 */
 		kind: string;
+		
+		/** 
+		 * @brief Whether it is a screen-sharing stream.
+		 */
 		isScreen: boolean;
 	}) => void;
 	
 	/** 
 	 * @brief Event of receiving a broadcast text message in the room
-	 * @param event <li>userId: string userID of the message sender</li><li>message: Contents of the message</li>
+	 * @param event
 	 * @region Message Event
 	 */
 	[EngineEventsTypes.onRoomMessageReceived]: (event: {
+		
+		/** 
+		 * @brief userID of the message sender.
+		 */
 		userId: string;
+		
+		/** 
+		 * @brief Contents of the message.
+		 */
 		message: any;
 	}) => void;
 	
 	/** 
 	 * @brief Event of receiving a broadcast binary message in the room
-	 * @param event <li>userId: string userID of the message sender</li><li>message: any Contents of the message</li>
+	 * @param event
 	 * @region Message Event
 	 */
 	[EngineEventsTypes.onRoomBinaryMessageReceived]: (event: {
+		
+		/** 
+		 * @brief userID of the message sender
+		 */
 		userId: string;
+		
+		/** 
+		 * @brief Contents of the message
+		 */
 		message: ArrayBuffer;
 	}) => void;
 	
@@ -1811,7 +2039,7 @@ export interface IEngineEvents {
 	[EngineEventsTypes.onLocalStreamStats]: (stats: LocalStreamStats) => void;
 	
 	/** 
-	 * @brief Subscribed public stream's statistics and network condition, reference period 2s.
+	 * @brief This 2 s periodical callback notifies information of the public stream after calling [startPlayPublicStream](104478#startplaypublicstream).
 	 * @param stats
 	 */
 	[EngineEventsTypes.onPublicStreamStats]: (stats: PublicStreamStats) => void;
@@ -1821,69 +2049,88 @@ export interface IEngineEvents {
 	 * @deprecated since 4.42, use onLocalAudioPropertiesReport and onRemoteAudioPropertiesReport instead.
 	 * @brief Volume of each of the users in the room
 	 * If the user has not joined a room, the list will only include volume of `local_user`.
-	 * @param event Active user in the room and his/her volume.
+	 * @param event
 	 * @region Room Event
 	 */
 	[EngineEventsTypes.onAudioVolumeIndication]: (event: {
+		
+		/** 
+		 * @brief Active user in the room and his/her volume.
+		 */
 		speakers: AudioVolumeInfo[];
 	}) => void;
 	
 	/** 
-	 * @brief After calling [enableAudioPropertiesReport](104478#enableAudioPropertiesReport), you will periodically receive this callback for the information about local audio. <br>
-	 *        Local audio includes the microphone audio and the screen audio captured using RTC SDK internal mechanisms.  <br>
-	 * @param event Information about local audio.  <br>
-	 * @region Audio Managment  <br>
+	 * @brief After calling [enableAudioPropertiesReport](104478#enableAudioPropertiesReport), you will periodically receive this callback for the information about local audio.
+	 *        Local audio includes the microphone audio and the screen audio captured using RTC SDK internal mechanisms.
+	 * @param event Information about local audio.
+	 * @region Audio Managment
 	 */
 	[EngineEventsTypes.onLocalAudioPropertiesReport]: (event: LocalAudioPropertiesInfo[]) => void;
 	
 	/** 
-	 * @brief After calling [enableAudioPropertiesReport](104478#enableAudioPropertiesReport), you will periodically receive this callback for the information about the subscribed remote audio streams. <br>
-	 *        The remote audio streams includes the microphone audio and screen audio collected using the RTC SDK internal mechanism/custom mechanism.  <br>
-	 * @param event Information about remote audio.  <br>
+	 * @brief After calling [enableAudioPropertiesReport](104478#enableAudioPropertiesReport), you will periodically receive this callback for the information about the subscribed remote audio streams.
+	 *        The remote audio streams includes the microphone audio and screen audio collected using the RTC SDK internal mechanism/custom mechanism.
+	 * @param event Information about remote audio.
 	 * @region Audio Management
 	 */
 	[EngineEventsTypes.onRemoteAudioPropertiesReport]: (event: RemoteAudioPropertiesInfo[]) => void;
 	
 	/** 
 	 * @brief The current playback device has been changed successfully by calling [setAudioPlaybackDevice](104478#setAudioPlaybackDevice).
-	 * @param event Information of the media devices. Refer to the [official documentation](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo) for more details.
-	 * @region Audio Management Event
+	 * @param event Information of the media devices. See [MediaDeviceInfo](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo).
 	 */
-	[EngineEventsTypes.onAudioPlaybackDeviceChanged]: (event: RTCDevice) => void;
+	[EngineEventsTypes.onAudioPlaybackDeviceChanged]: (event: MediaDeviceInfo) => void;
 	
 	/** 
 	 * @brief The remote clients in the room will be informed of the state change via this event after the publisher starts audio capture by calling [startAudioCapture](104478#startAudioCapture).
-	 * @param event `userId: string` The publisher who starts the internal audio capture
+	 * @param event
 	 * @region Audio Management Event
 	 */
 	[EngineEventsTypes.onUserStartAudioCapture]: (event: {
+		
+		/** 
+		 * @brief The publisher who starts the internal audio capture
+		 */
 		userId: string;
 	}) => void;
 	
 	/** 
 	 * @brief The remote clients in the room will be informed of the state change via this event after the publisher stops audio capture by calling [stopAudioCapture](104478#stopAudioCapture).
-	 * @param event `userId: string` userId of the publisher who stops the internal audio capture
+	 * @param event
 	 * @region Room Management Event
 	 */
 	[EngineEventsTypes.onUserStopAudioCapture]: (event: {
+		
+		/** 
+		 * @brief The userId of the publisher who stops the internal audio capture.
+		 */
 		userId: string;
 	}) => void;
 	
 	/** 
 	 * @brief The remote clients in the room will be informed of the state change via this event after the publisher starts video capture by calling [startVideoCapture](104478#startVideoCapture).
-	 * @param event `userId: string` userId of the publisher who starts the internal video capture
+	 * @param event
 	 * @region Room Management Event
 	 */
 	[EngineEventsTypes.onUserStartVideoCapture]: (event: {
+		
+		/** 
+		 * @brief The userId of the publisher who starts the internal video capture.
+		 */
 		userId: string;
 	}) => void;
 	
 	/** 
 	 The remote clients in the room will be informed of the state change via  this event after the publisher stops video capture by calling [stopVideoCapture](104478#stopVideoCapture).
-	 * @param event `userId: string` userId of the publisher who stops the internal video capture
+	 * @param event
 	 * @region Room Management Event
 	 */
 	[EngineEventsTypes.onUserStopVideoCapture]: (event: {
+		
+		/** 
+		 * @brief The userId of the publisher who stops the internal video capture.
+		 */
 		userId: string;
 	}) => void;
 	
@@ -1896,22 +2143,42 @@ export interface IEngineEvents {
 	
 	/** 
 	 * @brief Result of the Auto-Subscription
-	 * @param event <li>`userId: string` userId of the publisher to be subscribed</li><li>`isScreen: boolean` Wether it is a screen-sharing stream</li><li>`state: SubscribeState` </li>
+	 * @param event
 	 * @region Room Management Event
 	 */
 	[EngineEventsTypes.onAutoSubscribeResult]: (event: {
+		
+		/** 
+		 * @brief The userId of the publisher to be subscribed
+		 */
 		userId: string;
+		
+		/** 
+		 * @brief Wether it is a screen-sharing stream
+		 */
 		isScreen: boolean;
+		
+		/** 
+		 * @brief Subscription state.
+		 */
 		state: SubscribeState;
 	}) => void;
 	
 	/** 
 	 * @brief Result of Auto-publishing. You will receive this event if you enable Auto-publish when calling `joinRoom`
-	 * @param event <li>`isScreen: boolean` Wether it is a screen-sharing stream </li><li>`state: PublishState` </li>
+	 * @param event
 	 * @region Room Management Event
 	 */
 	[EngineEventsTypes.onAutoPublishResult]: (event: {
+		
+		/** 
+		 * @brief Wether it is a screen-sharing stream
+		 */
 		isScreen: boolean;
+		
+		/** 
+		 * @brief Publish state.
+		 */
 		state: PublishState;
 	}) => void;
 	
@@ -1923,6 +2190,8 @@ export interface IEngineEvents {
 	[EngineEventsTypes.onAutoplayFailed]: (event: PlayerEvent) => void;
 	
 	/** 
+	 * @hidden
+	 * @deprecated since 4.44, use onStreamMixingEvent instead.
 	 * @brief Result of the Pushing stream to CDN
 	 * @param event
 	 * @region Advanced Feature Event
@@ -1931,11 +2200,15 @@ export interface IEngineEvents {
 	
 	/** 
 	 * @brief event of error
-	 * @param event The reason why the current user has been removed from the room.
+	 * @param event
 	 * @region Room Management Event
 	 */
 	[EngineEventsTypes.onError]: (event: {
-		errorCode: ErrorCode.DUPLICATE_LOGIN | ErrorCode.RTM_DUPLICATE_LOGIN | ErrorCode.RTM_TOKEN_ERROR | ErrorCode.EXPIRED_TOKEN;
+		
+		/** 
+		 * @brief The reason why the current user has been removed from the room.
+		 */
+		errorCode: ErrorCode.DUPLICATE_LOGIN | ErrorCode.RTM_DUPLICATE_LOGIN | ErrorCode.RTM_TOKEN_ERROR | ErrorCode.EXPIRED_TOKEN | ErrorCode.RECONNECT_FAILED;
 	}) => void;
 	
 	/** 
@@ -2005,6 +2278,7 @@ export interface IEngineEvents {
 	
 	/** 
 	 * @brief Callback of the successful rendering of the first video frame of the public stream.
+	 *         Refer to [startPlayPublicStream](104478#startplaypublicstream) for details about subscribing to a public stream.
 	 * @param event
 	 */
 	[EngineEventsTypes.onFirstPublicStreamVideoFrameRendered]: (event: PublicStreamAudioFirstFrameDecodedEvent) => void;
@@ -2015,28 +2289,61 @@ export interface IEngineEvents {
 	 * @notes Start an audio-device test by calling [startAudioPlaybackDeviceTest](104478#startaudioplaybackdevicetest) or [startAudioDeviceRecordTest](104478#startaudiodevicerecordtest) will register this callback for regular notification on playing volume. You can set the time interval between each callback by passing a proper value when calling the API above.
 	 */
 	[EngineEventsTypes.onAudioPlaybackDeviceTestVolume]: (volume: number) => void;
-}
-
-/** 
- * @brief Cloud proxy informatio
- */
-export interface CloudProxyInfo {
 	
 	/** 
-	 * @brief The cloud proxy IP of log report
+	 * @brief The callback reports the network quality of the local user every 2s after the user enters the room.
 	 */
-	logProxy: string;
+	[EngineEventsTypes.onNetworkQuality]: (
 	
 	/** 
-	 * @brief The cloud proxy IP of the access
+	 * @brief Upstream network quality
 	 */
-	accessProxy: string;
+	uplinkNetworkQuality: NetworkQuality, 
 	
 	/** 
-	 * @brief The cloud proxy IP of RTC admin control
+	 * @brief Downstream network quality
 	 */
-	configProxy: string;
-}
+	downlinkNetworkQuality: NetworkQuality) => void;
+	
+	/** 
+	 * @brief Receives this callback when fallback happens or the stream recovers from fallback.
+	 * @param event Information about stream switching
+	 */
+	[EngineEventsTypes.onSimulcastSubscribeFallback]: (event: RemoteStreamSwitch) => void;
+	
+	/** 
+	 * @brief When the resolution of remote video changes, users who subscribed to the stream will receive this callback.
+	 */
+	[EngineEventsTypes.onRemoteVideoSizeChanged]: (
+	
+	/** 
+	 * @brief Information of the remote stream
+	 */
+	key: RemoteStreamKey, 
+	
+	/** 
+	 * @brief Information of video frame
+	 */
+	info: {
+		
+		/** 
+		 * @brief Width（pixel）
+		 */
+		width: number;
+		
+		/** 
+		 * @brief Height（pixel）
+		 */
+		height: number;
+	}) => void;
+	
+	/** 
+	 * @brief Pushing a mixed stream to CDN events
+	 * @param event
+	 * @region Push to CDN
+	 */
+	[EngineEventsTypes.onStreamMixingEvent]: (event: StreamMixingEvent) => void;
+}
 
 /** 
  * @list 104477
@@ -2045,142 +2352,176 @@ export interface CloudProxyInfo {
 export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	
 	/** 
-	 * @brief Join the room. <br>
-	 * Call this method to join the room and make audio & video calls with other users in the room. <br>
-	 * @param token Dynamic key. It is used for authentication and verification of users entering the room. <br>
-	 *         You need to bring Token to enter the room. When testing, you can use the console to generate temporary tokens. The official launch requires the use of the key SDK to generate and issue tokens at your server level. <br>
-	 *         Apps with different AppIDs are not interoperable. <br>
-	 *         Make sure that the AppID used to generate the Token is the same as the AppID used to create the engine, otherwise it will cause the join room to fail. <br>
-	 * @param roomId  The ID of the room to be added. <br>
-	 *     The room ID is a non-empty string with a length of less than 128 bytes, and the following character set ranges are supported: <br>
-	 *      1. 26 capital letters A~ Z. <br>
-	 *      2. 26 lowercase letters a~ z. <br>
-	 *      3. 10 numbers 0~ 9. <br>
-	 *      4. Underscore "_", the at sign "@", and the minus sign "-". <br>
+	 * @brief Join the room.
+	 * Call this method to join the room and make audio & video calls with other users in the room.
+	 * @param token Dynamic key. It is used for authentication and verification of users entering the room.
+	 *         You need to bring Token to enter the room. When testing, you can use the console to generate temporary tokens. The official launch requires the use of the key SDK to generate and issue tokens at your server level.
+	 *         Apps with different AppIDs are not interoperable.
+	 *         Make sure that the AppID used to generate the Token is the same as the AppID used to create the engine, otherwise it will cause the join room to fail.
+	 * @param roomId  The ID of the room to be added.
+	 *     The room ID is a non-empty string with a length of less than 128 bytes, and the following character set ranges are supported:
+	 *      1. 26 capital letters A~ Z.
+	 *      2. 26 lowercase letters a~ z.
+	 *      3. 10 numbers 0~ 9.
+	 *      4. Underscore "_", the at sign "@", and the minus sign "-".
 	 * @param userInfo  User information.
 	 * @param roomConfig  Room parameter configuration, set the room mode and whether to automatically publish or subscribe to the flow.
 	 * @return
 	 * @notes + In the same room with the same App ID, the user ID of each user must be unique. The user will be kicked out of the room when a user with the same userID joins the room because of the error of `DUPLICATE_LOGIN`.
-	 *        + Remote users will receive [onUserJoined](104479#onuserjoined) callback when a visible user joins the room. Call [setUserVisibility](#setuservisibility) to switch the visibility of the user. <br>
-	 *        + RTC SDK will try reconnect after losing connection to the server caused by a poor network connection. The remote user will receive [onUserJoined](104479#onuserjoined) if a visible user reconnected successfully. <br>
+	 *        + Remote users will receive [onUserJoined](104479#onuserjoined) callback when a visible user joins the room. Call [setUserVisibility](#setuservisibility) to switch the visibility of the user.
+	 *        + RTC SDK will try reconnect after losing connection to the server caused by a poor network connection. The remote user will receive [onUserJoined](104479#onuserjoined) if a visible user reconnected successfully.
 	 * @region Room Management
 	 */
-	joinRoom(token: string | null, roomId: string, userInfo: UserInfo, roomConfig: RoomConfig): Promise<void>;
+	joinRoom(token: string | null, roomId: string, userInfo: UserInfo, roomConfig?: RoomConfig): Promise<void>;
 	
 	/** 
-	 * @brief Leave the room.   <br>
-	 * The user calls this API to leave the room, end the call process, and release all call-related resources. <br>
-	 * @notes + After visible users leave the room, other users in the room will receive [onUserLeave](104479#onuserleave) callback notification. <br>
-	 *     + You must call this API to end the call, after calling the [joinRoom](#joinroom) method to join the room. Otherwise you cannot start the next call. Repeatedly call this method have no negative impact. <br>
+	 * @brief Leave the room.
+	 * The user calls this API to leave the room, end the call process, and release all call-related resources.
+	 * @notes + After visible users leave the room, other users in the room will receive [onUserLeave](104479#onuserleave) callback notification.
+	 *     + You must call this API to end the call, after calling the [joinRoom](#joinroom) method to join the room. Otherwise you cannot start the next call. Repeatedly call this method have no negative impact.
 	 * @region Room Management
 	 */
 	leaveRoom(waitAck?: boolean): Promise<void>;
 	
 	/** 
 	 * @brief Destroy engine
-	 * Destroy the engine instances created by calling [createEngine](#createengine) and release all related resources <br>
-	 * @notes + Make sure that the business scenarios related to the `RTCEngine` instances that need to be destroyed are all finished before calling this API. <br>
-	 *       + Calling this API will destroy all memory related to this `RTCEngine` instance, and stop any interaction with the media server. <br>
-	 *       + This API is a blocking call which will block the current thread until the SDK completes the exit logic. Therefore, do NOT to call this API directly in the callback thread. Besides do NOT wait for the execution of the main thread including this API in any callback, thus causing a deadlock. <br>
+	 * Destroy the engine instances created by calling [createEngine](#createengine) and release all related resources.
+	 * @notes + Make sure that the business scenarios related to the `RTCEngine` instances that need to be destroyed are all finished before calling this API.
+	 *       + Calling this API will destroy all memory related to this `RTCEngine` instance, and stop any interaction with the media server.
+	 *       + This API is a blocking call which will block the current thread until the SDK completes the exit logic. Therefore, do NOT to call this API directly in the callback thread. Besides do NOT wait for the execution of the main thread including this API in any callback, thus causing a deadlock.
 	 * @region Engine Management
 	 */
 	destroy(): void;
 	
 	/** 
-	 * @brief Start publishing media streams.
-	 * @return
-	 * @notes + Call this API to publish media streams only when you have disabled Auto-Publish when calling [joinRoom](#joinroom).
-	 *     + An invisible user can not publish media streams. Call [setUserVisibility](#setuservisibility) to change the visibility of a user.
-	 *     + Users can only publish media streams in one room at the same time. Call [publishScreen](#publishscreen) to start screen sharing.
-	 *     + After publishing media streams by calling this API, other users in the room will be informed via [onStreamAdd](104479#onstreamadd).
-	 * @region Media Transmission
+	 * @brief Publishes media streams captured by camera/microphone in the current room.
+	 * @param mediaType Media stream type, used for specifying whether to publish audio stream or video stream.
+	 * @notes + Streams are not published automatically in multi-room mode by default, you need to call this API to publish streams manually.  <br>
+	 *        + An invisible user cannot publish media streams. Call [setUserVisibility](#setuservisibility) to change your visibility in the room.  <br>
+	 *        + Call [publishScreen](#publishscreen) to start screen sharing.  <br>
+	 *        + After you call this API, the other users in the room will receive [onUserPublishStream](104479#onuserpublishstream). Those who successfully received your streams will receive [onAudioFirstFrameDecoded](104479#onaudiofirstframedecoded)/[onVideoFirstFrameDecoded](104479#onvideofirstframedecoded) at the same time.  <br>
+	 *        + Call [unpublishStream](#unpublishstream) to stop publishing streams.
+	 * @region Room Management
 	 */
-	publish(): Promise<void>;
+	publishStream(mediaType: MediaType): Promise<void>;
 	
 	/** 
-	 * @brief Stops publishing local media streams in the room.
-	 * @return
-	 * @notes + Call this API to stop publishing either started by calling [publish](#publish) or enabling Auto-Publish.
-	 *      + After stopping publishing media streams by calling this API, other users in the room will be informed via [onStreamRemove](104479#onstreamremove).
-	 * @region Media Transmission
+	 * @brief Stops publishing media streams captured by camera/microphone in the current room.
+	 * @param mediaType Media stream type, used for specifying whether to stop publishing audio stream or video stream.
+	 * @notes + After calling [publishStream](#publishstream), call this API to stop publishing streams. <br>
+	 *        + After calling this API, the other users in the room will receive [onUserUnpublishStream](104479#onuserunpublishstream).
+	 * @region Room Management
 	 */
-	unpublish(): Promise<void>;
+	unpublishStream(mediaType: MediaType): Promise<void>;
 	
 	/** 
-	 * @brief Subscribe to media streams in the room.   <br>
-	 * Call this API to subscribe to media streams in the room regardless of subscription mode, either Auto or Manual. <br>
-	 * Call this API to update the properties and configurations of the stream you have already subscribed to.
-	 * @param userId  User ID of the publisher of the subscribed media stream
-	 * @param mediaType  Mainstream or screen-sharing stream.
-	 * @param streamType  Media stream type to be subscribed to.
-	 * @param configure  Subscription configuration of video streams.
-	 * @return
-	 * @notes + Get the media stream information in the room from [onStreamAdd](104479#onstreamadd) and [onStreamRemove](104479#onstreamremove). <br>
-	 *      + You can update the subscription configuration by calling the API even after calling [pauseAllSubscribedStream](#pauseallsubscribedstream) to pause streaming. Call [resumeAllSubscribedStream](#resumeallsubscribedstream) to resume streaming and apply the changes.
-	 * @region Media Transmission
+	 * @brief Publishes local screen sharing streams in the current room.
+	 * @param mediaType Media stream type, used for specifying whether to publish audio stream or video stream.
+	 * @notes + An invisible user cannot publish media streams. Call [setUserVisibility](#setuservisibility) to change your visibility in the room. <br>
+	 *        + After you called this API, the other users in the room will receive [onUserPublishScreen](104479#onuserpublishscreen). Those who successfully received your streams will receive [onAudioFirstFrameDecoded](104479#onaudiofirstframedecoded)/[onVideoFirstFrameDecoded](104479#onvideofirstframedecoded) at the same time.  <br>
+	 *        + Call [unpublishScreen](#unpublishscreen) to stop publishing screen sharing streams.
+	 * @region Screen Sharing
 	 */
-	subscribeUserStream(userId: string, mediaType: SubscribeMediaType, streamType?: StreamIndex, configure?: SubscribeVideoConfig): Promise<void>;
+	publishScreen(mediaType: MediaType): Promise<void>;
 	
 	/** 
-	 * @brief Stop subscribing to media streams in the room.   <br>
-	 * You can call this API to unsubscribe to media streams regardless of automatic or manual subscription mode. <br>
-	 * @param userId  User ID of the publisher of the subscribed media stream
-	 * @param isScreen  Whether the stream unsubscribed is a screen-sharing stream. <br>
-	 * @return
-	 * @notes Call this API regardless of whether the media stream is subscribed to or not. When the `userId` is invalid or unsubscribed, the SDK will ignore the request without any negative effect.
-	 * @region Media Transmission
+	 * @brief Stops publishing local screen sharing streams in the current room.
+	 * @param mediaType Media stream type, used for specifying whether to stop publishing audio stream or video stream.
+	 * @notes  + After calling [publishScreen](#publishscreen), call this API to stop publishing streams. <br>
+	 *         + After calling this API, the other users in the room will receive [onUserUnpublishScreen](104479#onuserunpublishscreen).
+	 * @region Screen Sharing
 	 */
-	unSubscribe(userId: string, isScreen: boolean): Promise<void>;
+	unpublishScreen(mediaType: MediaType): Promise<void>;
 	
 	/** 
-	 * @brief Update Token. <br>
+	 * @brief Subscribes to specific remote media streams captured by camera/microphone.  <br>
+	 *        You can call this API in both automatic subscription mode and manual subscription mode.
+	 * @param userId The ID of the remote user who published the target audio/video stream.
+	 * @param mediaType Media stream type, used for specifying whether to subscribe to the audio stream or the video stream.
+	 * @notes + You must first get the remote stream information through onUserPublishStream{@link #IRTCRoomEventHandler#onUserPublishStream} before calling this API to subscribe to streams accordingly.  <br>
+	 *        + The [onAudioFirstFrameDecoded](104479#onaudiofirstframedecoded)/[onVideoFirstFrameDecoded](104479#onvideofirstframedecoded) callback will be triggered after calling this API to indicate that the audio/video stream was successfully received.  <br>
+	 * @region Room Management
+	 */
+	subscribeStream(userId: string, mediaType: MediaType): Promise<void>;
+	
+	/** 
+	 * @brief Unsubscribes from specific remote media streams captured by camera/microphone.  <br>
+	 *        You can call this API in both automatic subscription mode and manual subscription mode.
+	 * @param userId The ID of the remote user who published the target audio/video stream.
+	 * @param mediaType Media stream type, used for specifying whether to unsubscribe from the audio stream or the video stream.
+	 * @region Room Management
+	 */
+	unsubscribeStream(userId: string, mediaType: MediaType): Promise<void>;
+	
+	/** 
+	 * @brief Subscribes to specific screen sharing media stream.  <br>
+	 *        You can call this API in both automatic subscription mode and manual subscription mode.
+	 * @param userId The ID of the remote user who published the target screen audio/video stream.
+	 * @param mediaType Media stream type, used for specifying whether to subscribe to the audio stream or the video stream.
+	 * @notes + You must first get the remote stream information through [onUserPublishScreen](104479#onuserpublishscreen) before calling this API to subscribe to streams accordingly.  <br>
+	 *        + The [onAudioFirstFrameDecoded](104479#onaudiofirstframedecoded)/[onVideoFirstFrameDecoded](104479#onvideofirstframedecoded) callback will be triggered after calling this API to indicate that the audio/video stream was successfully received.  <br>
+	 * @region Room Management
+	 */
+	subscribeScreen(userId: string, mediaType: MediaType): Promise<void>;
+	
+	/** 
+	 * @brief Unsubscribes from specific screen sharing media stream.  <br>
+	 *        You can call this API in both automatic subscription mode and manual subscription mode.
+	 * @param uid The ID of the remote user who published the target screen audio/video stream.
+	 * @param type Media stream type, used for specifying whether to unsubscribe from the audio stream or the video stream.
+	 * @region Room Management
+	 */
+	unsubscribeScreen(userId: string, mediaType: MediaType): Promise<void>;
+	
+	/** 
+	 * @brief Update Token.
 	 * You will receive [onTokenWillExpire](104479#ontokenwillexpire) 30 s before the Token expires. Call this API to submit a new Token.
-	 * @param token A valid token <br>
-	 * @notes + If you call [joinRoom](#joinroom) with an expired token, the joining will fail with an error code `INVALID_TOKEN`. And you need to obtain a valid token and call this API to update the token. <br>
-	 *      + If joining a room failed because the token expired, call this API with an updated token. And then RTC SDK will automatically rejoin the room without calling [joinRoom](#joinroom) again.  <br>
+	 * @param token A valid token.
+	 * @notes + If you call [joinRoom](#joinroom) with an expired token, the joining will fail with an error code `INVALID_TOKEN`. And you need to obtain a valid token and call this API to update the token.
+	 *      + If joining a room failed because the token expired, call this API with an updated token. And then RTC SDK will automatically rejoin the room without calling [joinRoom](#joinroom) again.
 	 *      + The user will be removed from the room when the Token expires.
 	 * @region Room Management
 	 */
 	updateToken(token: string): void;
 	
 	/** 
-	 * @brief Switch the microphone used for internal audio capture  <br>
-	 * @param deviceId
-	 * @region Device Management
+	 * @brief Switch the microphone used for internal audio capturing.
+	 * @param deviceId Device ID. Call [enumerateDevices](#enumeratedevices) to get the device list.
+	 * @return
 	 * @notes  If the internal audio capturing is on, the switch is effective once you call this API. If the internal audio capturing is off, the setting will be effective when capture starts.
 	 */
-	switchMicrophone(deviceId: string): Promise<void>;
+	setAudioCaptureDevice(deviceId: string): Promise<void>;
 	
 	/** 
-	 * @brief Switch the camera used for internal video capture  <br>
-	 * The default camera to be used depends on the web browser.
-	 * @param deviceId ID of the device need to enable which you can call [getDevices](#getdevices) to obtain.
+	 * @brief Switch the camera used for internal video capturing.
+	 * @param deviceId Device ID. Call [enumerateDevices](#enumeratedevices) to get the device list.
 	 * @return
-	 * @notes  If the internal video capturing is on, the switch is effective once you call this API. If the internal video capturing is off, the setting will be effective when capture starts.
-	 * @region Device Management
+	 * @notes + If the internal video capturing is on, the switch is effective once you call this API. If the internal video capturing is off, the setting will be effective when capture starts.
+	 *        + For mobile devices, set deviceId as `"user"` to use the front camera. Set deviceId as `"environment"` to use the rear camera.
+	 *        + The default camera is set by the browser.
 	 */
-	switchCamera(deviceId: string): Promise<void>;
+	setVideoCaptureDevice(deviceId: string): Promise<void>;
 	
 	/** 
 	 * @brief Enable internal video capture. The default state is off.
 	 * Internal video capture refers to: capturing video using the built-in module.
 	 * The remote clients in the room will be informed of the state change via [onUserStartVideoCapture](104479#onuserstartvideocapture) after the publisher starts video capture by calling this API.
-	 * @param deviceId ID of the device need to enable which you can call [getDevices](#getdevices) to obtain.
+	 * @param deviceId ID of the device need to enable which you can call [enumerateDevices](#enumeratedevices) to obtain.
 	 * @return The actual effective video capture parameters. See [MediaTrackSettings](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints). Pay attention to the properties: `frameRate`, `height`, and `width`.
-	 * @notes + Call [stopVideoCapture](#stopvideocapture) to stop the internal video capture. Otherwise, the internal video capture will sustain until you destroy the engine instance.<br>
-	 *     + Once you create the engine instance, you can start internal video capture regardless of the video publishing state. The video stream will start publishing only after the video capture starts. <br>
-	 *     + Call [switchCamera](#switchcamera) to switch the camera used by the internal video capture module.<br>
+	 * @notes + Call [stopVideoCapture](#stopvideocapture) to stop the internal video capture. Otherwise, the internal video capture will sustain until you destroy the engine instance.
+	 *     + Once you create the engine instance, you can start internal video capture regardless of the video publishing state. The video stream will start publishing only after the video capture starts.
+	 *     + Call [setVideoCaptureDevice](#setvideocapturedevice) to switch the camera used by the internal video capture module.
 	 * @region Video Management
 	 */
 	startVideoCapture(deviceId?: string): Promise<MediaTrackSettings>;
 	
 	/** 
-	 * @brief Enable internal video capture immediately. The default setting is off.   <br>
+	 * @brief Enable internal video capture immediately. The default setting is off.
 	 * Internal video capture refers to: capturing video using the built-in module.
-	 * The remote clients in the room will be informed of the state change via [onUserStopVideoCapture](104479#onuserstopvideocapture) after the publisher stops video capture by calling this API.<br>
+	 * The remote clients in the room will be informed of the state change via [onUserStopVideoCapture](104479#onuserstopvideocapture) after the publisher stops video capture by calling this API.
 	 * @return
-	 * @notes + Call [startVideoCapture](#startvideocapture) to enable the internal video capture. <br>
-	 *     + Without calling this API the internal video capture will sustain until you destroy the engine instance.<br>
+	 * @notes + Call [startVideoCapture](#startvideocapture) to enable the internal video capture.
+	 *     + Without calling this API the internal video capture will sustain until you destroy the engine instance.
 	 * @region Video Management
 	 */
 	stopVideoCapture(): Promise<void>;
@@ -2189,21 +2530,21 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @brief Start internal audio capture. The default is off.
 	 * Internal audio capture refers to: capturing audio using the built-in module.
 	 * The remote clients in the room will be informed of the state change via [onUserStartAudioCapture](104479#onuserstartaudiocapture) after the publisher starts audio capture by calling this API.
-	 * @param deviceId ID of the device need to enable which you can call [getDevices](#getdevices) to obtain.
+	 * @param deviceId ID of the device need to enable which you can call [enumerateDevices](#enumeratedevices) to obtain.
 	 * @return
-	 * @notes + Call [stopAudioCapture](#stopaudiocapture) to stop the internal audio capture. Otherwise, the internal audio capture will sustain until you destroy the engine instance. <br>
-	 *     + Once you create the engine instance, you can start internal audio capture regardless of the audio publishing state. The audio stream will start publishing only after the audio capture starts. <br>
+	 * @notes + Call [stopAudioCapture](#stopaudiocapture) to stop the internal audio capture. Otherwise, the internal audio capture will sustain until you destroy the engine instance.
+	 *     + Once you create the engine instance, you can start internal audio capture regardless of the audio publishing state. The audio stream will start publishing only after the audio capture starts.
 	 * @region Audio Management
 	 */
 	startAudioCapture(deviceId?: string): Promise<void>;
 	
 	/** 
-	 * @brief Stop internal audio capture. The default is off.   <br>
+	 * @brief Stop internal audio capture. The default is off.
 	 * Internal audio capture refers to: capturing audio using the built-in module.
-	 * The remote clients in the room will be informed of the state change via [onUserStopAudioCapture](104479#onuserstopaudiocapture) after stopping audio capture by calling this API.<br>
+	 * The remote clients in the room will be informed of the state change via [onUserStopAudioCapture](104479#onuserstopaudiocapture) after stopping audio capture by calling this API.
 	 * @return
-	 * @notes + Call [startAudioCapture](#startaudiocapture) to enable the internal audio capture. <br>
-	 *     + Without calling this API the internal audio capture will sustain until you destroy the engine instance.<br>
+	 * @notes + Call [startAudioCapture](#startaudiocapture) to enable the internal audio capture.
+	 *     + Without calling this API the internal audio capture will sustain until you destroy the engine instance.
 	 * @region Audio Management
 	 */
 	stopAudioCapture(): Promise<void>;
@@ -2212,9 +2553,9 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @brief Use the capture module provided by the RTC SDK to capture the current screen stream for sharing.
 	 * @param screenConfig Specify properties for the sharing screen.
 	 * @return
-	 * @notes + Call this API will start screen stream video capture but will not publish the captured video. Publishing a screen-sharing stream by calling [publishScreen](#publishScreen). <br>
-	 *     + To turn off screen video source capture, call [stopScreenVideoCapture](#stopScreenVideoCapture). <br>
-	 *     + Before calling this API, you can call [setVideoEncoderConfig](#setvideoencoderconfig) to set the capture frame rate and encoding resolution of the screen video stream. <br>
+	 * @notes + Call this API will start screen stream video capture but will not publish the captured video. Publishing a screen-sharing stream by calling [publishScreen](#publishScreen).
+	 *     + To turn off screen video source capture, call [stopScreenVideoCapture](#stopScreenVideoCapture).
+	 *     + Before calling this API, you can call [setVideoEncoderConfig](#setvideoencoderconfig) to set the capture frame rate and encoding resolution of the screen video stream.
 	 * @region Advanced Feature
 	 */
 	startScreenCapture(screenConfig?: ScreenConfig): Promise<void>;
@@ -2227,26 +2568,6 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 */
 	stopScreenCapture(): Promise<void>;
 	
-	/** 
-	 * @brief Publish screen-sharing streams.
-	 * @return
-	 * @notes + You must join the room before you can call this API. <br>
-	 *      + This API is only available to visible users.
-	 *      + After the call, the remote receives the [onStreamAdd](104479#onstreamadd) callback. <br>
-	 *      + Call [unpublishScreen](#unpublishscreen) to unpublish.
-	 * @region Advanced Feature
-	 */
-	publishScreen(): Promise<void>;
-	
-	/** 
-	 * @brief Stop publishing screen-sharing streams.
-	 * @return
-	 * @notes + To start publishing, call [publishScreen](#publishscreen). <br>
-	 *      + After the call, the remote receives the [onStreamRemove](104479#onstreamremove) callback.
-	 * @region Advanced Feature
-	 */
-	unpublishScreen(): Promise<void>;
-	
 	/** 
 	 * @brief Bind a view to the local media stream and set the rendering mode for the rendering of the local stream
 	 * Listen to `onPlayerEvent` for the state after binding a view to the local video stream.
@@ -2270,15 +2591,15 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	setRemoteVideoPlayer(streamIndex: StreamIndex, videoPlayerOption: VideoPlayerOption): HTMLVideoElement | undefined;
 	
 	/** 
-	 * @brief Enable or disable the mirror mode for the local video stream.   <br>
+	 * @brief Enable or disable the mirror mode for the local video stream.
 	 * @param mirrorType Whether to turn on mirror mode.
 	 * @region Media Processing
 	 */
 	setLocalVideoMirrorType(mirrorType: MirrorType): void;
 	
 	/** 
-	 * @brief Sets the speaker or the earpiece as the audio playback device. The audio playback device defaults to the speaker.   <br>
-	 * @param deviceId ID of the audio playback device. Call [getDevices](#getdevices) to get device ID.
+	 * @brief Sets the speaker or the earpiece as the audio playback device. The audio playback device defaults to the speaker.
+	 * @param deviceId ID of the audio playback device. Call [enumerateDevices](#enumeratedevices) to get device ID.
 	 * @return
 	 * @notes  You can call this API before or after the user joins a room.
 	 * @region Audio Management
@@ -2294,39 +2615,16 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 */
 	play(userId: string): Promise<void>;
 	
-	/** 
-	 * @brief Enable/ Disable the transmission of the local audio stream.
-	 * Remote users in the room will be informed via [onUserMuteAudio](104479#onusermuteaudio) after the visible user changes the transmission state of the audio streams by calling this API.
-	 * @param muteState An identifier denoting whether the local audio stream is sending.
-	 * @return
-	 * @notes + Calling this API toggles the transmission state of the local audio streams instead of the capture state.
-	 *        + You can enable audio transmission regardless of the audio capture state. Enable the transmission before capture, thus the audio stream can be sent once the capture starts.
-	 * @region Media Transmission
-	 */
-	muteLocalAudio(muteState: MuteState): Promise<boolean>;
-	
-	/** 
-	 * @brief Enable/ Disable the transmission of the local video stream.  The video stream is not sending by default.
-	 * Call this API to start sending local video streams when using either internal capture module or custom video source. <br>
-	 * Remote users in the room will be informed via [onUserMuteAudio](104479#onusermuteaudio) after the visible user changes the transmission state of the video streams by calling this API.
-	 * @param muteState An identifier denoting whether the local video stream is sending
-	 * @return Sending state of the local video stream
-	 * @notes + This API only controls the sending state of the local video stream and does not affect the local video acquisition state.
-	 *        + You can enable video transmission regardless of the video capture state. Enable the transmission before capture, thus the video stream can be sent once the capture starts.
-	 * @region Media Transmission
-	 */
-	muteLocalVideo(muteState: MuteState): Promise<boolean>;
-	
 	/** 
 	 * @brief Pause receiving remote media streams.
 	 * @param mediaType Media stream type subscribed to.
 	 * @return
-	 * @notes + Calling this API does not change the capture state and the transmission state of the remote clients. <br>
-	 *         + Calling this API does not cancel the subscription or change any subscription configuration. <br>
+	 * @notes + Calling this API does not change the capture state and the transmission state of the remote clients.
+	 *         + Calling this API does not cancel the subscription or change any subscription configuration.
 	 *         + To resume, call [resumeAllSubscribedStream](#resumeAllSubscribedStream).
 	 * @region Media Stream Transmission
 	 */
-	pauseAllSubscribedStream(mediaType: PauseResumeControlMediaType): Promise<void>;
+	pauseAllSubscribedStream(mediaType: MediaType): Promise<void>;
 	
 	/** 
 	 * @brief Resume receiving remote media streams
@@ -2336,43 +2634,43 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 *         + Calling this API does not change any subscription configuration.
 	 * @region Media Transmission
 	 */
-	resumeAllSubscribedStream(mediaType: PauseResumeControlMediaType): Promise<void>;
+	resumeAllSubscribedStream(mediaType: MediaType): Promise<void>;
 	
 	/** 
-	 * @brief Send point-to-point text messages to a specified user in the room.<br>
+	 * @brief Send point-to-point text messages to a specified user in the room.
 	 * The recipient receives the message via [onUserMessageReceived](104479#onusermessagereceived)  once the message is sent successfully.
 	 * @param userId User ID of the recipient
-	 * @param message Text to be sent within 62KB<br>
+	 * @param message Text to be sent within 62KB
 	 * @return
-	 * @notes Call [joinRoom](#joinroom) to join the room before calling this API. <br>
+	 * @notes Call [joinRoom](#joinroom) to join the room before calling this API.
 	 * @region Message
 	 */
 	sendUserMessage(userId: string, message: string): Promise<unknown> | undefined;
 	
 	/** 
-	 * @brief Send point-to-point binary messages to a specified user in the room.<br>
+	 * @brief Send point-to-point binary messages to a specified user in the room.
 	 * The recipient receives the message via [onUserBinaryMessageReceived](104479#onuserbinarymessagereceived) once the message is sent successfully.
 	 * @param userId User ID of the recipient
-	 * @param message Binary to be sent within 62KB<br>
+	 * @param message Binary to be sent within 62KB
 	 * @return
-	 * @notes Call [joinRoom](#joinroom) to join the room before calling this API. <br>
+	 * @notes Call [joinRoom](#joinroom) to join the room before calling this API.
 	 * @region Message
 	 */
 	sendUserBinaryMessage(userId: string, message: ArrayBuffer): Promise<unknown>;
 	
 	/** 
-	 * @brief Send text messaging to all other users in the room.<br>
+	 * @brief Send text messaging to all other users in the room.
 	 * Users in the room will receive message via [onRoomMessageReceived](104479#onroommessagereceived) once the message is sent successfully.
-	 * @param message Text to be sent within 62KB<br>
+	 * @param message Text to be sent within 62KB
 	 * @return
 	 * @region Message
 	 */
 	sendRoomMessage(message: string): Promise<any> | undefined;
 	
 	/** 
-	 * @brief Send binary messaging to all other users in the room.<br>
+	 * @brief Send binary messaging to all other users in the room.
 	 * Users in the room will receive binary message via [onRoomBinaryMessageReceived](104479#onroombinarymessagereceived) once the message is sent successfully.
-	 * @param message Binary message to be sent within 62KB<br>
+	 * @param message Binary message to be sent within 62KB
 	 * @return
 	 * @region Message
 	 */
@@ -2382,7 +2680,7 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @brief Send SEI message carried by video frames
 	 * @param streamIndex
 	 * @param message SEI message within 4kb. Empty message or message exceeding this size will not be sent with respective error prompt.
-	 * @param repeatCount Number of message sending repetitions. The value range is [0,30]. <br>
+	 * @param repeatCount Number of message sending repetitions. The value range is [0,30].
 	 *                    Calling this API to add SEI data to consecutive `repeatCount` video frames starting from the current one.
 	 * @notes + Call this API to add SEI message to the video frame captured by the internal video capture module.
 	 *         + SDK will abandon the SEI message if no video frame in 2s after you call this API.
@@ -2392,21 +2690,44 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	sendSEIMessage(streamIndex: StreamIndex, message: Uint8Array | string, repeatCount: number): void;
 	
 	/** 
-	 * @region Video Management
 	 * @brief Sets the video encoder configuration of the publishing streams.
-	 * @param streamIndex
-	 * @param descriptions The max parameters of the video stream.
-	 *         When you call [enableSimulcastMode](#enableSimulcastMode) and enable simulcasting, you can call this API to set the parameters of the multiple video streams. The length of `descriptions` is no more than 3. The code rate of the parameters must be in descending order.
+	 * @param descriptions List of configurations for multiple streams. You should note that the resolution you set is the maximum resolution of each stream.
+	 *        You can set parameters for up to 3 streams, SDK will always take the value of the first 3 streams when parameters for more streams are set.
+	 *        The code rate of the parameters must be in descending order.
 	 *        When the resolution of the max stream is in [540P, 1080P], you can simulcast 3 streams; when in [270P, 450P], you can simulcast 2 streams; when in [0, 180P], you can not enable simulcast.
-	 * @notes For the video stream captured by the camera, the default value is 360P, 15FPS; for the screen-sharing stream, the default value is 1080P, 15FPS.
+	 * @notes  <br>
+	 *        + For the video stream captured by the camera, the default value is 360P, 15FPS; for the screen-sharing stream, the default value is 1080P, 15FPS.
+	 *        + Before calling this API to set parameters for multiple video streams, the largest resolution of published streams is 640px × 360px with a frame rate of 15fps by default.  <br>
+	 *        + This API is applicable to the video stream captured by the camera, see [setScreenEncoderConfig](#setscreenencoderconfig) for setting parameters for screen sharing video stream.
+	 * @region Video Management
+	 */
+	setVideoEncoderConfig(descriptions: VideoEncoderConfig | VideoEncoderConfig[]): Promise<void>;
+	
+	/** 
+	 * @brief Video publisher call this API to set the expected configurations for the screen sharing video stream, including resolution, frame rate, bitrate, scale mode, and fallback strategy in poor network conditions.
+	 * @param description You expected configurations for screen sharing video stream.
+	 * @notes Before calling this API, a screen video stream with a default resolution of 1920px × 1080px and a frame rate of 15fps will be published.
+	 * @region Screen Shareing Management
+	 */
+	setScreenEncoderConfig(description: VideoEncoderConfig): Promise<void>;
+	
+	/** 
+	 * @brief Sets your expected configuration of the remote video stream that you want to subscribe to or have subscribed to.
+	 * @param userId The ID of the target stream publisher
+	 * @param remoteVideoConfig Your expected configuration, see RemoteVideoConfig{@link #RemoteVideoConfig}.
+	 * @notes <br>
+	 *        + This API only works after the publisher calls [enableSimulcastMode](#enablesimulcastmode) to enable publishing multiple video streams, in which case the subscriber will receive a stream that is closest to the set configuration.  <br>
+	 *        + If you don't call this API after the publisher enables the function of publishing multiple streams, you will receive by default the video stream with the largest resolution set by the publisher.  <br>
+	 *        + You should call this API in the room. If you want to call it before entering the room, you should set the `remoteVideoConfig` in the roomConfig` when calling [joinRoom](#joinroom).  <br>
+	 * @region Video Management
 	 */
-	setVideoEncoderConfig(streamIndex: StreamIndex, descriptions: VideoEncoderConfig | VideoEncoderConfig[]): Promise<void>;
+	setRemoteVideoConfig(userId: string, remoteVideoConfig: RemoteVideoConfig): Promise<void>;
 	
 	/** 
 	 * @region Video Management
 	 * @brief Enables the simulcast mode of the video stream captured by the camera at the publishing end.imulcasting, including resolution, frame rate, bitrate, scale mode, fallback strategy under poor network conditions.
 	 * @param enabled
-	 * @param + You must call this API before publishing the video streams. <br>
+	 * @param + You must call this API before publishing the video streams.
 	 *    + After enabling the simulcast mode, SDK automatically sets the encoding parameters for the video streams. For manual setting, call [setVideoEncoderConfig](#setVideoEncoderConfig).
 	 */
 	enableSimulcastMode(enabled: boolean): boolean;
@@ -2414,22 +2735,22 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	/** 
 	 * @hidden
 	 * @deprecated since 4.42, use enableAudioPropertiesReport instead
-	 * @brief Turn on/off volume prompts. Off by default. <br>
+	 * @brief Turn on/off volume prompts. Off by default.
 	 * Call this API to set the report period of the volume information of local user and each subscribed user.
 	 * Local client will get informed of the the volume of local user and each subscribed users via [onAudioVolumeIndication](104479#onaudiovolumeindication).
-	 * @param interval The time interval for receiving a volume prompt callback <br>
-	 *        It is recommended to set to greater than or equal to 200 milliseconds; when less than 10 milliseconds, the behavior is undefined. <br>
-	 *         + ≤ 0: Disable the volume prompt function. <br>
+	 * @param interval The time interval for receiving a volume prompt callback.
+	 *        It is recommended to set to greater than or equal to 200 milliseconds; when less than 10 milliseconds, the behavior is undefined.
+	 *         + ≤ 0: Disable the volume prompt function.
 	 *         + > 0: Enable the volume prompt function and set the time interval for receiving the volume prompt callback. In milliseconds.
 	 * @region Room Management
 	 */
 	setAudioVolumeIndicationInterval(interval?: number): void;
 	
 	/** 
-	 * @brief Enable audio information prompts.   <br>
-	 * @param config Audio information prompts-related configurations.  <br>
-	 * @notes With the prompt on, you can:  <br>
-	 *       + Get the information of the audio stream captured by the local microphone and screen audio stream through [onLocalAudioPropertiesReport](104479#onLocalAudioPropertiesReport).  <br>
+	 * @brief Enable audio information prompts.
+	 * @param config Audio information prompts-related configurations.
+	 * @notes With the prompt on, you can:
+	 *       + Get the information of the audio stream captured by the local microphone and screen audio stream through [onLocalAudioPropertiesReport](104479#onLocalAudioPropertiesReport).
 	 *       + Get the information of the subscribed remote audio streams through [onRemoteAudioPropertiesReport](104479#onRemoteAudioPropertiesReport).
 	 * @region Audio Management
 	 */
@@ -2446,7 +2767,7 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	startLiveTranscoding(transcode: LiveTranscodeConfig): Promise<void>;
 	
 	/** 
-	 * @brief Update configuration needed when pushing media streams to CDN.  <br>
+	 * @brief Update configuration needed when pushing media streams to CDN.
 	 * After calling [startLiveTranscoding](#startlivetranscoding) to enable the function of pushing streams to CDN, you can call this API to update the relevant configurations.
 	 * @param transcode Configurations that you want to update.
 	 * @region Advanced Feature
@@ -2462,25 +2783,25 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	stopLiveTranscoding(): Promise<void>;
 	
 	/** 
-	 * @brief Set the business ID.   <br>
+	 * @brief Set the business ID.
 	 * You can use businessId to distinguish different business scenarios. You can customize your businessId to serve as a sub AppId, which can share and refine the function of the AppId, but it does not need authentication.
 	 * @param businessId Your customized businessId
 	 *                   BusinessId is a tag, and you can customize its granularity.
-	 * @notes  You must call this API before the [joinRoom](#joinroom) API, otherwise it will be invalid. <br>
+	 * @notes  You must call this API before the [joinRoom](#joinroom) API, otherwise it will be invalid.
 	 * @region Engine Management
 	 */
 	setBusinessId(businessId: string): boolean;
 	
 	/** 
-	 * @brief Set user visibility. Visible by default.   <br>
+	 * @brief Set user visibility. Visible by default.
 	 * @param enable  Visibility of the user in the room:
-	 *         + `true`: The user can publish media streams. And the other users in the room get informed of the behaviors of the user, such as Joining room, starting video capture, and Leaving room.<br>
+	 *         + `true`: The user can publish media streams. And the other users in the room get informed of the behaviors of the user, such as Joining room, starting video capture, and Leaving room.
 	 *         + `false`: The user cannot publish media streams. And the other users in the room do not get informed of the behaviors of the user, such as joining, starting video capture, or leaving.
 	 * @return
-	 * @notes + You can call this API whether the user is in a room or not. <br>
+	 * @notes + You can call this API whether the user is in a room or not.
 	 *        + When you call this API, the other users in the room will be informed via the related callback:
-	 *            - Switch from `false` to `true`: [onUserJoined](104479#onuserjoined)<br>
-	 *            - Switch from `true` to `false`: [onUserLeave](104479#onuserleave) <br>
+	 *            - Switch from `false` to `true`: [onUserJoined](104479#onuserjoined)
+	 *            - Switch from `true` to `false`: [onUserLeave](104479#onuserleave)
 	 * @region Room Management
 	 */
 	setUserVisibility(enable: boolean): Promise<void>;
@@ -2549,11 +2870,11 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	setVideoCaptureConfig(config: TrackCaptureConfig): Promise<void>;
 	
 	/** 
-	 * @brief Log in to the RTM server. <br>
+	 * @brief Log in to the RTM server.
 	 * Call this method before users within the same `appID` can communicate with each other via messages.
-	 * @param token Dynamic key. It is used for authentication and verification of users entering the room. <br>
-	 *         You need to bring Token to enter the room. When testing, you can use the console to generate temporary tokens. The official launch requires the use of the key SDK to generate and issue tokens at your server level. <br>
-	 *         Apps with different AppIDs are not interoperable. <br>
+	 * @param token Dynamic key. It is used for authentication and verification of users entering the room.
+	 *         You need to bring Token to enter the room. When testing, you can use the console to generate temporary tokens. The official launch requires the use of the key SDK to generate and issue tokens at your server level.
+	 *         Apps with different AppIDs are not interoperable.
 	 * @param userInfo  User information.
 	 * @return
 	 * @notes
@@ -2634,9 +2955,9 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	/** 
 	 * @brief  Start cloud proxy
 	 * @param  cloudProxyInfo cloud proxy informarion list.
-	 * @notes  + Call this API before joining the room.<br>
-	 *         + Start pre-call network detection after starting cloud proxy. <br>
-	 *         + After starting cloud proxy and connects the cloud proxy server successfully, receives [onCloudProxyConnected](104479#onCloudProxyConnected). <br>
+	 * @notes  + Call this API before joining the room.
+	 *         + Start pre-call network detection after starting cloud proxy.
+	 *         + After starting cloud proxy and connects the cloud proxy server successfully, receives [onCloudProxyConnected](104479#onCloudProxyConnected).
 	 *         + To stop cloud proxy, call [stopCloudProxy](#stopCloudProxy).
 	 */
 	startCloudProxy(cloudProxyInfo: CloudProxyInfo): void;
@@ -2716,7 +3037,7 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @param filePath Image path in Http protocal; or Blob object.
 	 *    The format of the image can be: JPG, PNG, or BMP.
 	 *    When the ratio of the image is not the same as the video encoder configuration, the image will be resized with fixed ratio until the width and the height are no more than that of the encoder configuration.
-	 * @return + It's recommended to call this API before stopping video capture to avoid blank frame in video recording. <br>
+	 * @return + It's recommended to call this API before stopping video capture to avoid blank frame in video recording.
 	 *    + You cannot see the image during local preview.
 	 */
 	setDummyCaptureImagePath(index: StreamIndex, filePath: string): Promise<void>;
@@ -2727,6 +3048,29 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 */
 	defaultTranscoding(): Required<LiveTranscodeConfig>;
 	
+	/** 
+	 * @brief Set the fallback option for remote media stream
+	 *        Fallback：to enable media stream fallback or to subscribe to only audio stream under poor network conditions to ensure smooth communication.
+	 * @param option Fallback options for subscribed media stream
+	 * @return + `true` Success
+	 *         + `false` Failure
+	 * @notes + You must call this API before joining the room.
+	 *        + After you enable the fallback, you will receive [onSimulcastSubscribeFallback](104479#onsimulcastsubscribefallback) and [onRemoteVideoSizeChanged](104479#onremotevideosizechanged} when the resolution of your subscribed stream is lowered or restored.
+	 *        + You can set media stream fallback using API or cloud configuration. The latter takes a higher priority.
+	 */
+	setSubscribeFallbackOption(option: SubscribeFallbackOption): boolean;
+	
+	/** 
+	 * @brief Set the priority of the remote user's media stream.
+	 *        Use this API with [setSubscribeFallbackOption](#setsubscribefallbackoption).
+	 *        With video stream fallback enabled and user priority specified, the stream quality of higher priority user is the last to be compromised.
+	 * @param userId The ID of the remote user
+	 * @param priority The priority of the remote user's media stream
+	 * @return + `true` Success
+	 *         + `false` Failure
+	 */
+	setRemoteUserPriority(userId: string, priority: RemoteUserPriority): boolean;
+	
 	/** 
 	 * @brief Start the playback test for the local audio device. RTC will start playing the audio file specified. And RTC will notify the audio volume via the [onAudioPlaybackDeviceTestVolume](104479#onaudioplaybackdevicetestvolume) periodically.
 	 * @param filePath Specify the path of the audio file for the playback test, including *.wav and *.mp3.
@@ -2751,15 +3095,15 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @notes + You can call this API whether the user is in a room.
 	 * + The audio capturing will stop and begins to play the recording in 30 s after calling this API. Before that, call [stopAudioDeviceRecordAndPlayTest](#stopaudiodevicerecordandplayTest) to stop capturing and start playing the recording.
 	 * + You must stop the test before starting another test for audio devices.
-	 * + Call [stopAudioDeviceRecordTest](#stopaudiodevicerecordtest) to stop the test, including capturing and playing the recording.
+	 * + Call [stopAudioDevicePlayTest](#stopaudiodeviceplaytest) to stop the test, including capturing and playing the recording.
 	 * + This test performs locally and does not involve network connection testing.
 	 */
 	startAudioDeviceRecordTest(indicationInterval: number): Promise<void>;
 	
 	/** 
 	 * @brief Call this API to stop recording in the test and start to play the recording.
-	 * @notes After calling this API, the recording starts playing during which you can call [stopAudioDeviceRecordTest](#stopaudiodevicerecordtest) to stop playing.
-	*/
+	 * @notes After calling this API, the recording starts playing during which you can call [stopAudioDevicePlayTest](#stopaudiodeviceplaytest) to stop playing.
+	 */
 	stopAudioDeviceRecordAndPlayTest(): void;
 	
 	/** 
@@ -2767,6 +3111,13 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * Before the test ends by itself, you can call this API to stop the recording or playing.
 	 */
 	stopAudioDevicePlayTest(): void;
+	
+	/** 
+	 * @brief Set the sound quality.
+	 * @param profile  A sound quality option consists of a set of audio profiles and applying each brings a different listening experience. Choose the appropriate audio quality to meet the requirement of the scenario.
+	 * @notes We recommend to call this API before the audio capture starts.
+	 */
+	setAudioProfile(profile: AudioProfileType): void;
 }
 
 /** 
@@ -2813,7 +3164,7 @@ export interface UserInfo {
 	
 	/** 
 	 * @brief ExtraInfo Additional information passed by the user, with a maximum length of 200 bytes. Callback to remote user in [onUserJoined](104479#onuserjoined).
-	 * @notes  Supports the following character set ranges   <br>
+	 * @notes  Supports the following character set ranges
 	 *      + 26 uppercase letters A~ Z
 	 *      + 26 lowercase letters a~ z
 	 *      + 10 numbers 0~ 9
@@ -2838,7 +3189,7 @@ export declare enum UserOfflineReason {
 	DROPPED = 1,
 	
 	/** 
-	 * @brief The remote client calls `setUserVisibility` to turn invisible.<br>
+	 * @brief The remote client calls `setUserVisibility` to turn invisible.
 	 */
 	SWITCH_TO_INVISIBLE = 2,
 	
@@ -2865,19 +3216,31 @@ export interface RoomConfig {
 	 * @brief Enable/disable auto-subscribe audio. Enable by default.
 	 *        Call publish[104481#publish] to publish media streams if you disable `isAutoPublish`.
 	 */
-	isAutoPublish: boolean;
+	isAutoPublish?: boolean;
 	
 	/** 
 	 * @brief Enable/disable auto-subscribe audio. Enable by default.
 	 * Call subscribeUserStream, unsubscribe to revise the subscription.
 	 */
-	isAutoSubscribeAudio: boolean;
+	isAutoSubscribeAudio?: boolean;
 	
 	/** 
 	 * @brief Enable/disable auto-subscribe video. Enable by default.
 	 * Call subscribeUserStream, unsubscribe to revise the subscription.
 	 */
-	isAutoSubscribeVideo: boolean;
+	isAutoSubscribeVideo?: boolean;
+	
+	/** 
+	 * @brief  Room profile
+	 *        Choose an appropriate room-profile option to meet the requirement of the scenario for media encoding algorithm, video profiles, and network configurations.
+	 *        Call [setAudioProfile](104478#setaudioprofile) to choose an audio quality option.
+	 */
+	roomProfileType?: RoomProfileType;
+	
+	/** 
+	 * @brief Expected configuration of remote video stream.
+	 */
+	remoteVideoConfig?: RemoteVideoConfig;
 }
 
 /** 
@@ -2917,22 +3280,6 @@ export interface SubscribeConfig {
 	subAudio: boolean;
 }
 
-/** 
- * @brief Transmission/Playback state of the media stream
- */
-export declare enum MuteState {
-	
-	/** 
-	 * @brief Enable
-	 */
-	MUTE_STATE_OFF = 0,
-	
-	/** 
-	 * @brief Disable
-	 */
-	MUTE_STATE_ON = 1
-}
-
 /** 
  * @brief Result of updating subscription
  */
@@ -2981,27 +3328,6 @@ export declare enum MirrorMode {
 	MIRROR_MODE_ON = 1
 }
 
-/** 
- * @brief Media stream type
- */
-export declare enum PauseResumeControlMediaType {
-	
-	/** 
-	 * @brief Audio
-	 */
-	RTC_PAUSE_RESUME_CONTROL_AUDIO = 0,
-	
-	/** 
-	 * @brief Video
-	 */
-	RTC_PAUSE_RESUME_CONTROL_VIDEO = 1,
-	
-	/** 
-	 * @brief Both video and audio
-	 */
-	RTC_PAUSE_RESUME_CONTROL_AUDIO_AND_VIDEO = 2
-}
-
 /** 
  * @brief Player information and rendering mode
  */
@@ -3018,7 +3344,7 @@ export interface VideoPlayerOption {
 	renderMode?: VideoRenderMode;
 	
 	/** 
-	 * @brief User ID, a non-empty string within 128 bytes. Use the following character set ranges   <br>
+	 * @brief User ID, a non-empty string within 128 bytes. Use the following character set ranges
 	 *      + 26 uppercase letters A~ Z
 	 *      + 26 lowercase letters a~ z
 	 *      + 10 numbers 0~ 9
@@ -3033,14 +3359,14 @@ export interface VideoPlayerOption {
 export declare enum VideoRenderMode {
 	
 	/** 
-	 * @brief Windows fill priority.   <br>
-	 * Scale the video frame at the original equal ratio until the window is filled with video. If the video frame aspect ratio is different from that of the window, the over-brims of the video frame will not be displayed. <br>
+	 * @brief Windows fill priority.
+	 * Scale the video frame at the original equal ratio until the window is filled with video. If the video frame aspect ratio is different from that of the window, the over-brims of the video frame will not be displayed.
 	 */
 	RENDER_MODE_HIDDEN = 0,
 	
 	/** 
-	 * @brief All video frame contents are fit to display in the window.   <br>
-	 * Scale the video frame at the original equal ratio until the whole video frame has been displayed in the window. If the video frame aspect ratio is different from that of the window, the area on the window that is not filled by the video frame will be blacked out. <br>
+	 * @brief All video frame contents are fit to display in the window.
+	 * Scale the video frame at the original equal ratio until the whole video frame has been displayed in the window. If the video frame aspect ratio is different from that of the window, the area on the window that is not filled by the video frame will be blacked out.
 	 */
 	RENDER_MODE_FIT = 1
 }
@@ -3078,45 +3404,32 @@ export declare enum StreamIndex {
 }
 
 /** 
- * @brief Type of the media stream subscribed to
+ * @brief Media stream type
  */
-export declare enum SubscribeMediaType {
-	
-	/** 
-	 * @brief Audio only
-	 */
-	AUDIO_ONLY = 0,
+export declare enum MediaType {
 	
 	/** 
-	 * @brief Video only
+	 * @brief Controls audio only
 	 */
-	VIDEO_ONLY = 1,
+	AUDIO = 1,
 	
 	/** 
-	 * @brief Both video and audio
+	 * @brief Controls video only
 	 */
-	AUDIO_AND_VIDEO = 2,
+	VIDEO = 2,
 	
 	/** 
-	 * @brief Neither audio nor video
+	 * @brief Controls both audio and video
 	 */
-	NONE = 3
+	AUDIO_AND_VIDEO = 3
 }
 
 /** 
  * @brief Subscription configuration of video streams
  */
-export interface SubscribeVideoConfig {
-	
-	/** 
-	 * @brief videoIndex Quality level of the video stream subscribed to. <br>
-	 * In Simulcast mode, use a number to specify the expected quality of the video stream to be subscribed to. In Simulcast mode, a video has a diversity of encoded qualities that ranking from 0 to 3. Call [setVideoEncoderConfig](#setvideoencoderconfig) to enable Simulcast mode on the publisher's clients.  <br>
-	 */
-	videoIndex: number;
-}
 
 /** 
- * @brief Stream property.   <br>
+ * @brief Stream property.
  */
 export interface RTCStream {
 	
@@ -3141,45 +3454,45 @@ export interface RTCStream {
 	hasAudio: boolean;
 	
 	/** 
-	 * @brief Properties of the video stream.   <br>
+	 * @brief Properties of the video stream.
 	 * When a remote user calls the [setVideoEncoderConfig](#setvideoencoderconfig) API to publish multiple configured video streams, this will contain attribute information for all video streams published by the user.
 	 */
 	videoStreamDescriptions?: VideoStreamDescription[];
 }
 
 /** 
- * @brief The reason for the removal of the remote stream in the room.   <br>
+ * @brief The reason for the removal of the remote stream in the room.
  *
  */
 export declare enum StreamRemoveReason {
 	
 	/** 
-	 * @brief The remote user stops publishing the stream.   <br>
+	 * @brief The remote user stops publishing the stream.
 	 */
 	STREAM_REMOVE_REASON_UNPUBLISH = 0,
 	
 	/** 
-	 * @brief The remote user failed to publish the stream.   <br>
+	 * @brief The remote user failed to publish the stream.
 	 */
 	STREAM_REMOVE_REASON_PUBLISH_FAILED = 1,
 	
 	/** 
-	 * @brief Keep alive failed.   <br>
+	 * @brief Keep alive failed.
 	 */
 	STREAM_REMOVE_REASON_KEEP_LIVE_FAILED = 2,
 	
 	/** 
-	 * @brief The remote user is disconnected.   <br>
+	 * @brief The remote user is disconnected.
 	 */
 	STREAM_REMOVE_REASON_CLIENT_DISCONNECTED = 3,
 	
 	/** 
-	 * @brief The remote user republishes the stream.   <br>
+	 * @brief The remote user republishes the stream.
 	 */
 	STREAM_REMOVE_REASON_REPUBLISH = 4,
 	
 	/** 
-	 * @brief Other reasons.   <br>
+	 * @brief Other reasons.
 	 */
 	STREAM_REMOVE_REASON_OTHER = 5
 }
@@ -3268,7 +3581,9 @@ export interface AudioVolumeInfo {
 export interface ScreenConfig {
 	
 	/** 
-	 * @brief Set `true` for capturing the system audio when the user is using Chrome on Windows.
+	 * @brief Whether to display the enable audio option when sharing screen.
+	 *        • On Windows, you can share the system audio through sharing the entire screen, and share audio from a tab through sharing a Chrome tab.
+	 *        • On macOS, you can only share audio from a tab through sharing a Chrome tab.
 	 */
 	enableAudio?: boolean;
 }
@@ -3321,22 +3636,22 @@ export declare enum MirrorType {
 }
 
 /** 
- * @brief Configuration related to audio information prompt.   <br>
+ * @brief Configuration related to audio information prompt.
  */
 export interface AudioPropertiesConfig {
 	
 	/** 
-	 * @brief Prompt interval in ms, the default value is 100. <br>
-	 *        + `<= 0`: Turn off prompt <br>
-	 *        + `(0,100]`: Invalid interval value, and will be automatically reset to 100ms. <br>
-	 *        + `> 100`: The actual value of interval  <br>
+	 * @brief Prompt interval in ms, the default value is 100.
+	 *        + `<= 0`: Turn off prompt
+	 *        + `(0,100]`: Invalid interval value, and will be automatically reset to 100ms.
+	 *        + `> 100`: The actual value of interval
 	 */
 	interval?: number;
 	
 	/** 
-	 * @brief Whether to keep audio information prompt on when you are not on the video/audio call webpage. The default setting is `true`.  <br>
-	 *        + true: Keep the prompt on  <br>
-	 *        + false: Disable the prompt  <br>
+	 * @brief Whether to keep audio information prompt on when you are not on the video/audio call webpage. The default setting is `true`.
+	 *        + true: Keep the prompt on
+	 *        + false: Disable the prompt
 	 */
 	enableInBackground?: boolean;
 }
@@ -3446,7 +3761,7 @@ export interface LiveTranscodeAudioConfig {
 	channels: number;
 	
 	/** 
-	 * @brief The AAC profile to be set. The value must be `LC`, `HEv1`, ` or 'HEv2`. The default value is `LC`.
+	 * @brief The AAC profile to be set. The value must be `LC`, `HEv1`, or `HEv2`. The default value is `LC`.
 	 */
 	AACProfile: "LC" | "HEv1" | "HEv2";
 }
@@ -3513,17 +3828,17 @@ export interface LiveTranscodeLayoutRegion {
 	h: number;
 	
 	/** 
-	 * @brief The view mode to be set. See the following options: <br>
-	 * + 1: Fill and Crop. The video is enlarged or shrunk with fixed aspect ratio, and completely fills the windows. The region of the video which exceeds the window will be cropped. <br>
-	 * + 2: Fit. The video is enlarged or shrunk with fixed aspect ratio, and is shown completely in the windows. The region of the window, which is not filled with video, is filled with black background.  <br>
+	 * @brief The view mode to be set. See the following options:
+	 * + 1: Fill and Crop. The video is enlarged or shrunk with fixed aspect ratio, and completely fills the windows. The region of the video which exceeds the window will be cropped.
+	 * + 2: Fit. The video is enlarged or shrunk with fixed aspect ratio, and is shown completely in the windows. The region of the window, which is not filled with video, is filled with black background.
 	 * + 3: Stretch. The video's aspect ratio is changed as it's automatically stretched to completely fill the bounding box it's contained in, but the whole image is visible.
 	 */
 	renderMode?: number;
 	
 	/** 
-	 * @brief The content to be set. The default value is 0. See the following options: <br>
-	 * + 0: Push both audio and video stream. <br>
-	 * + 1: Push audio stream only. <br>
+	 * @brief The content to be set. The default value is 0. See the following options:
+	 * + 0: Push both audio and video stream.
+	 * + 1: Push audio stream only.
 	 * + 2: Push video stream only.
 	 */
 	contentControl?: number;
@@ -3545,17 +3860,17 @@ export interface LiveTranscodeLayoutRegion {
 export interface RemoteStreamKey {
 	
 	/** 
-	 * @brief Room identification
+	 * @brief Room ID
 	 */
 	roomId: string;
 	
 	/** 
-	 * @brief User identification
+	 * @brief User ID
 	 */
 	userId: string;
 	
 	/** 
-	 * @brief Mainstream or screen-sharing stream. Refer to [StreamIndex](#streamIndex) for details.
+	 * @brief Mainstream or screen-sharing stream.
 	 */
 	streamIndex: StreamIndex;
 }
@@ -3688,7 +4003,7 @@ export interface PublicStreamConfig {
 		fps?: number;
 		
 		/** 
-		 * @brief Bitrate, unit: kbps<br>
+		 * @brief Bitrate, unit: kbps
 		 */
 		kBitRate: number;
 	};
@@ -3720,6 +4035,255 @@ export interface PublicStreamConfig {
 	};
 }
 
+/** 
+ * @brief Configuration of remote video stream
+ */
+export interface RemoteVideoConfig {
+	
+	/** 
+	 * @brief Width of the video frame in px
+	 */
+	width: number;
+	
+	/** 
+	 * @brief Width of the video frame in px
+	 */
+	height: number;
+}
+
+/** 
+ * @brief Fallback options for subscribed media stream
+ */
+export declare enum SubscribeFallbackOption {
+	
+	/** 
+	 * @brief Default setting. Media stream fallback is disabled.
+	 */
+	DISABLE = 0,
+	
+	/** 
+	 * @brief When the downstream network quality is bad, the video stream fallbacks to stream of lower resolution and then to voice only. See [Media Stream Fallback](https://www.volcengine.com/docs/6348/70137) for fallback rules.
+	 *        This setting takes effect only when the publisher enables simulcast mode through [EnableSimulcastMode](104478#enablesimulcastmode).
+	 */
+	VIDEO_STREAM_LOW = 1,
+	
+	/** 
+	 * @brief When the downstream network quality is bad, the video stream fallbacks to voice only.
+	 *        If you enables simulcast mode on the publisher, this option is not recommended as it might impair user experience.
+	 */
+	AUDIO_ONLY = 2
+}
+
+/** 
+ * @brief priority of the remote user
+ */
+export declare enum RemoteUserPriority {
+	
+	/** 
+	 * @brief Low. Default value.
+	 */
+	LOW = 0,
+	
+	/** 
+	 * @brief The remote user's priority is medium.
+	 */
+	MEDIUM = 100,
+	
+	/** 
+	 * @brief The remote user's priority is high.
+	 */
+	HIGH = 200
+}
+
+/** 
+ * @brief Network quality.
+ */
+export declare enum NetworkQuality {
+	
+	/** 
+	 * @brief Unknown.
+	 */
+	UNKNOWN = 0,
+	
+	/** 
+	 * @brief The network quality is excellent.
+	 */
+	EXCELLENT = 1,
+	
+	/** 
+	 * @brief The quality is good, but the bitrate is lower than Excellent.
+	 */
+	GOOD = 2,
+	
+	/** 
+	 * @brief Users experience slightly impaired communication.
+	 */
+	POOR = 3,
+	
+	/** 
+	 * @brief Users can communicate with each other, but not smoothly. It is recommended to lower sampling rate, frame rate, or remind the user through UI to switch to a voice call.
+	 */
+	BAD = 4,
+	
+	/** 
+	 * @brief Network quality is very bad, users can barely communicate. It is recommended to notify users of poor network connection through UI.
+	 */
+	VBAD = 5
+}
+
+/** 
+ * @brief Information of stream switching due to a subscribed media stream fallback.
+ */
+export interface RemoteStreamSwitch {
+	
+	/** 
+	 * @brief User Id of the remote publisher
+	 */
+	userId: string;
+	
+	/** 
+	 * @brief Whether it is a screen-sharing stream
+	 */
+	isScreen: boolean;
+	
+	/** 
+	 * @brief The index of original video stream
+	 */
+	beforeVideoIndex: number;
+	
+	/** 
+	 * @brief The index of current video stream
+	 */
+	afterVideoIndex: number;
+	
+	/** 
+	 * @brief Whether it is a video stream before stream switching.
+	 */
+	beforeEnable: boolean;
+	
+	/** 
+	 * @brief Whether it is a video stream after stream switching.
+	 */
+	afterEnable: boolean;
+	
+	/** 
+	 * @brief Reason for media stream fallback or recovery
+	 */
+	reason: FallbackOrRecoverReason;
+}
+
+/** 
+ * @brief The reason for media stream fallback or recovery
+ */
+export declare enum FallbackOrRecoverReason {
+	
+	/** 
+	 * @brief Default value. Other reasons.
+	 */
+	Unknown = -1,
+	
+	/** 
+	 * @brief Subscribed media stream falls back due to low bandwidth.
+	 */
+	SubscribeFallbackByBandwidth = 0,
+	
+	/** 
+	 * @brief Subscribed media stream recovers from the fallback due to bandwidth increase.
+	 */
+	SubscribeRecoverByBandwidth = 2
+}
+
+/** 
+ * @brief  Room profile
+ *        While calling [joinRoom](104478#joinroom) choose an appropriate room-profile option to meet the requirement of the scenario for media encoding algorithm, video profiles, and network configurations.
+ *        Call [setAudioProfile](104478#setaudioprofile) to choose an audio quality option if it is necessary.
+ */
+export declare enum RoomProfileType {
+	
+	/** 
+	 * @brief Default mode for video/audio calls, such as voice chat room
+	 */
+	communication = 0,
+	
+	/** 
+	 * @brief For 1 v.s. 1 audio and video calls
+	 */
+	chat = 5,
+	
+	/** 
+	 * @brief Audio and video chat for 3 or more people
+	 */
+	chatRoom = 6,
+	
+	/** 
+	 * @brief For the event of co-hosting during live streaming broadcast
+	 */
+	coHost = 9,
+	
+	/** 
+	 * @brief For meeting Apps installed on terminals of meeting rooms
+	 */
+	meeting = 16,
+	
+	/** 
+	 * @brief For the online classrooms and lectures that over 9 participants can join the audio and video chat.
+	 */
+	classRoom = 18
+}
+
+/** 
+ * @brief  Audio quality
+ *         Call [setAudioProfile](104478#setaudioprofile) to choose an audio quality option.
+ */
+export declare enum AudioProfileType {
+	
+	/** 
+	 * @brief Default sound quality
+	 *        The sound quality configuration of RoomProfileType{@link #RoomProfileType} set by the server or client side
+	 */
+	default = 0,
+	
+	/** 
+	 * @brief Smooth
+	 *        Sample rate: 16 KHz
+	 *        Mono-channel
+	 *        Encoding birrate: 24 Kpbs
+	 *        Fluent priority, low power consumption, and low traffic consumption, suitable for most game scenarios, such as team-wide voice chat, group-wide voice chat, nation-wide voice chat.
+	 */
+	fluent = 1,
+	
+	/** 
+	 * @brief Mono-channel standard
+	 *        Sample rate: 48 KHz
+	 *        Encoding bitrate: 48 Kpbs
+	 *        For scenarios requiring distinct voice, you can choose this mode, which achieves balanced latency, consumption, and network packets. It is suitable for educational Apps and the online Mafia Games.
+	 */
+	standard = 2,
+	
+	/** 
+	 * @brief Dual-channel music
+	 *        Sample rate: 48 KHz
+	 *        Encoding birrate: 128 Kpbs
+	 *        This mode provides high-resolution audio at a cost of high latency, consumption, and large network packets. It is suitable for entertainment Apps such as co-hosting and online talent contests.
+	 *        Not recommended for game Apps.
+	 */
+	hd = 3,
+	
+	/** 
+	 * @brief Dual-channel standard
+	 *        Sample rate: 48 KHz
+	 *        Encoding birrate: 80 Kpbs
+	 */
+	standardStereo = 4,
+	
+	/** 
+	 * @brief Mono-channel music
+	 *        Sample rate: 48 KHz
+	 *        Encoding birrate: 128 Kpbs
+	 */
+	hdMono = 5
+}
+
 /** 
  * @brief Point-to-point text message
  */
@@ -3753,6 +4317,7 @@ export interface UserBinaryMessageEvent {
 }
 
 /** 
+ * @hidden
  * @brief Event during pushing stream to CDN
  */
 export interface LiveTranscodingResultEvent {
@@ -3793,9 +4358,10 @@ declare const Config: {
 	EXPECTED_ADDR: string;
 	LOG_SERVER_URL: string;
 	CONFIG_REQUEST_DOMAINS: string[];
+	DEVICE_ID: string;
 };
 declare function setParameter(key: keyof typeof Config, value: any): void;
-declare function getParameter(key: keyof typeof Config): string | string[] | never[];
+declare function getParameter(key: keyof typeof Config): string | string[];
 /**
  * @list 104477
  * @detail 104478
@@ -3807,10 +4373,10 @@ declare function getParameter(key: keyof typeof Config): string | string[] | nev
 export interface IVERTC {
 	
 	/** 
-	 * @brief Call this API to create an IRTCEngine instance that provides RTC service.   <br>
-	 *        Call this API before calling any other APIs within the RTC SDK.<br>
+	 * @brief Call this API to create an IRTCEngine instance that provides RTC service.
+	 *        Call this API before calling any other APIs within the RTC SDK.
 	 *        Calling this API repeatedly will create multiple IRTCEngine instances.
-	 * @param appId A unique identifier for each application. You can apply appIDs on the RTC console.   <br>
+	 * @param appId A unique identifier for each application. You can apply appIDs on the RTC console.
 	 *              Instances generated by different AppIDs are independent in RTC service. Users served by one AppID cannot communicate with users served by another AppID.
 	 * @return Return an `IRTCEngine` instance if you call this API successfully.
 	 * @notes + Call [destroyEngine](#destroyengine) respectively to destroy each IRTCEngine instance.
@@ -3822,7 +4388,7 @@ export interface IVERTC {
 	/** 
 	 * @brief Call this API to destroy the IRTCEngine instance created by [createEngine](#createengine).
 	 * @param engine By calling this API, this `IRTCEngine` instance and resource related will be wiped from memory. And any interaction with the media server will end.
-	 * @notes + Before calling this API， ensure all business scenarios related to this `IRTCEngine` instance have ended. <br>
+	 * @notes + Before calling this API， ensure all business scenarios related to this `IRTCEngine` instance have ended.
 	 *       + Calling this API will block the main thread until it completes the exiting process. Therefore, do not include this API in a callback. Nor wait in a callback for the execution of this API in the main thread, thus causing a deadlock.
 	 * @region Engine Management
 	 */
@@ -3836,22 +4402,30 @@ export interface IVERTC {
 	getSdkVersion(): string;
 	
 	/** 
-	 * @brief Call this API to enumerate media devices and their IDs, such as microphone, camera, and headset.
-	 * Call this API to get deviceIds used to specify the device when calling [setAudioPlaybackDevice](#setaudioplaybackdevice), [startVideoCapture](#startvideocapture), and [startAudioCapture](#startaudiocapture).
+	 * @brief Call this API to enumerate media devices and their IDs, such as microphones, cameras, and headsets.
+	 *        Call this API to get deviceId used to specify the device when calling [setAudioPlaybackDevice](#setaudioplaybackdevice), [startVideoCapture](#startvideocapture), and [startAudioCapture](#startaudiocapture).
 	 * @return A list of all media devices.
-	 * @region Device Management
+	 * @notes Only when the browser has permission to the media devices can it enumerate the full device list. Make sure the media device access is turned on before calling this API.
 	 */
-	getDevices(): Promise<RTCDevice[]>;
+	enumerateDevices(): Promise<MediaDeviceInfo[]>;
 	
 	/** 
 	 * @brief Call this API to request for access to video and audio devices.
 	 * @param options The device type you need
-	 *                 <li>`video: boolean` Video devices<li>`audio:boolean` Audio devices</li>
-	 * @return <li>`video: boolean` Video devices<li>`audio:boolean` Audio devices</li>
+	 * @return + `video: boolean` Video devices
+	 *         + `audio:boolean` Audio devices
 	 * @region Device Management
 	 */
 	enableDevices: (options?: {
+		
+		/** 
+		 * @brief Video devices
+		 */
 		video: boolean;
+		
+		/** 
+		 * @brief Audio devices
+		 */
 		audio: boolean;
 	}) => Promise<{
 		video: boolean;
@@ -3860,33 +4434,32 @@ export interface IVERTC {
 	
 	/** 
 	 * @brief Call this API to enumerate microphone devices.
-	 * Call this API to get Device IDs used to specify the device when calling [startAudioCapture](#startaudiocapture).
+	 *        Call this API to get Device IDs used to specify the device when calling [startAudioCapture](#startaudiocapture).
 	 * @return A list including all microphone devices.
-	 * @region Device Management
+	 * @notes Only when the browser has permission to the media devices can it enumerate the full device list. Make sure the media device access is turned on before calling this API.
 	 */
-	getMicrophones: () => Promise<RTCDevice[]>;
+	enumerateAudioCaptureDevices: () => Promise<MediaDeviceInfo[]>;
 	
 	/** 
-	 * @brief Call this API to enumerate audio and video devices and their IDs, such as microphone, camera, and headset.
-	 * Call this API to get Device IDs used to specify the device when calling [startVideoCapture](#startvideocapture).
+	 * @brief Call this API to enumerate audio and video devices and their IDs, such as microphones, cameras, and headsets.
+	 *        Call this API to get Device IDs used to specify the device when calling [startVideoCapture](#startvideocapture).
 	 * @return A list including all camera devices.
-	 * @region Device Management
+	 * @notes Only when the browser has permission to the media devices can it enumerate the full device list. Make sure the media device access is turned on before calling this API.
 	 */
-	getCameras: () => Promise<RTCDevice[]>;
+	enumerateVideoCaptureDevices: () => Promise<MediaDeviceInfo[]>;
 	
 	/** 
 	 * @brief Call this API to enumerate audio playback devices and their IDs, such as speakers and headsets.
-	 * Call this API to get Device IDs used to specify the device when calling [setAudioPlaybackDevice](#setaudioplaybackdevice).
+	 *        Call this API to get Device IDs used to specify the device when calling [setAudioPlaybackDevice](#setaudioplaybackdevice).
 	 * @return A list including all audio playback devices.
-	 * @region Device Management
+	 * @notes Only when the browser has permission to the media devices can it enumerate the full device list. Make sure the media device access is turned on before calling this API.
 	 */
-	getAudioPlayback: () => Promise<RTCDevice[]>;
+	enumerateAudioPlaybackDevices: () => Promise<MediaDeviceInfo[]>;
 	
 	/** 
 	 * @brief Call this API to check whether the browser is supported.
-	 * @return
-	 *         + `True`: Supported
-	 *         - `False`: Not Supported
+	 * @return + `True`: Supported
+	 *         + `False`: Not Supported
 	 * @region Engine Management
 	 */
 	isSupported: () => Promise<boolean>;
@@ -3894,7 +4467,7 @@ export interface IVERTC {
 	/** 
 	 * @brief Gets the codec type supported by current browser.
 	 * If you have enabled vp8 codec, you can call the API to check whether the current browser supports vp8 encoding type before entering the room.
-	 * @return 当前浏览器支持的编解码类型
+	 * @return Codec types supported by the current browser
 	 * @region Engine Management
 	 */
 	getSupportedCodecs: () => Promise<string[]>;
@@ -3903,7 +4476,7 @@ declare class VERTC implements IVERTC {
 	getSdkVersion: () => string;
 	createEngine: (appId: string) => IRTCEngine;
 	destroyEngine: (engine: IRTCEngine) => void;
-	getDevices: () => Promise<RTCDevice[]>;
+	enumerateDevices: () => Promise<MediaDeviceInfo[]>;
 	enableDevices: (options?: {
 		video: boolean;
 		audio: boolean;
@@ -3911,9 +4484,9 @@ declare class VERTC implements IVERTC {
 		video: boolean;
 		audio: boolean;
 	}>;
-	getMicrophones: () => Promise<RTCDevice[]>;
-	getCameras: () => Promise<RTCDevice[]>;
-	getAudioPlayback: () => Promise<RTCDevice[]>;
+	enumerateAudioCaptureDevices: () => Promise<MediaDeviceInfo[]>;
+	enumerateVideoCaptureDevices: () => Promise<MediaDeviceInfo[]>;
+	enumerateAudioPlaybackDevices: () => Promise<MediaDeviceInfo[]>;
 	getParameter: typeof getParameter;
 	setParameter: typeof setParameter;
 	isSupported: () => Promise<boolean>;