@byteplus/rtc 4.41.3 → 4.43.0

package/index.d.ts

@@ -15,16 +15,28 @@ declare enum ErrorCode {
 	INVALID_PARAMS = "INVALID_PARAMS",
 	
 	/** 
-	 * @brief Token is invalid or has expired.
+	 * @brief Invalid Token
 	 */
 	INVALID_TOKEN = "INVALID_TOKEN",
+	
+	/** 
+	 * @brief Token expired.
+	 */
 	EXPIRED_TOKEN = "EXPIRED_TOKEN",
 	
 	/** 
 	 * @brief Failure of joining room
 	 */
 	JOIN_ROOM_FAILED = "JOIN_ROOM_FAILED",
+	
+	/** 
+	 * @brief Fail to update Token failed because the Token is invalid.
+	 */
 	UPDATE_TOKEN_WITH_INVALID_TOKEN = "UPDATE_TOKEN_WITH_INVALID_TOKEN",
+	
+	/** 
+	 * @brief Fail to update Token failed because the user has not joined any room.
+	 */
 	UPDATE_TOKEN_BEFORE_JOIN = "UPDATE_TOKEN_BEFORE_JOIN",
 	
 	/** 
@@ -111,7 +123,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.
@@ -247,6 +258,16 @@ declare enum ErrorCode {
 	 */
 	UNEXPECTED_ERROR = "UNEXPECTED_ERROR",
 	
+	/** 
+	 * @brief You have started another device test while the current one is still ongoing.
+	 */
+	REPEAT_DEVICE_TEST = "REPEAT_DEVICE_TEST",
+	
+	/** 
+	 * @brief The audio device test failed.
+	 */
+	AUDIO_DEVICE_TEST_FAILED = "AUDIO_DEVICE_RECORD_FAILED",
+	
 	/** 
 	 * @brief The user has already logged in.
 	 */
@@ -345,7 +366,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.  <br>
+	 *        Please leave room first and join room again, or contact technical support.
+	 */
+	RECONNECT_FAILED = "RECONNECT_FAILED"
 }
 declare enum AudioMixingError {
 	
@@ -676,6 +703,76 @@ export interface RTCDevice {
 	 */
 	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;
+}
+/** 
+ * @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;
+}
 
 /** 
  * A user joins the room
@@ -787,7 +884,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.
@@ -1376,6 +1478,8 @@ declare enum EngineEventsTypes {
 	 * @brief Indication of audio volume
 	 */
 	onAudioVolumeIndication = "onAudioVolumeIndication",
+	onLocalAudioPropertiesReport = "onLocalAudioPropertiesReport",
+	onRemoteAudioPropertiesReport = "onRemoteAudioPropertiesReport",
 	
 	/** 
 	 * @brief Callback of the state changing of audio playback devices
@@ -1408,6 +1512,7 @@ declare enum EngineEventsTypes {
 	 * @brief The state of pushing streams to CDN
 	 */
 	onLiveTranscodingResult = "onLiveTranscodingResult",
+	onAudioPlaybackDeviceTestVolume = "onAudioPlaybackDeviceTestVolume",
 	onSEIMessageReceived = "onSEIMessageReceived",
 	onError = "onError",
 	onAudioMixingStateChanged = "onAudioMixingStateChanged",
@@ -1547,6 +1652,84 @@ export interface AudioMixingStateChangedEvent {
 	error: AudioMixingError;
 }
 
+/** 
+ * @brief Information about local audio   <br>
+ */
+export interface LocalAudioPropertiesInfo {
+	
+	/** 
+	 * @brief Indicates whether the audio is captured by microphone or from screen sharing.  <br>
+	 */
+	streamIndex: StreamIndex;
+	
+	/** 
+	 * @type keytype
+	 * @brief Audio information  <br>
+	 */
+	audioPropertiesInfo: AudioPropertiesInfo;
+}
+
+/** 
+ * @brief Information about remote audio   <br>
+ */
+export interface RemoteAudioPropertiesInfo {
+	
+	/** 
+	 * @brief Information about remote stream  <br>
+	 */
+	streamKey: StreamKey;
+	
+	/** 
+	 * @brief Information about remote audio properties  <br>
+	 */
+	audioPropertiesInfo: AudioPropertiesInfo;
+}
+
+/** 
+ * @brief Audio information   <br>
+ */
+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>
+	 */
+	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>
+	 */
+	nonlinearVolume: number;
+}
+
+/** 
+ * @brief Information about the remote stream
+ */
+export interface StreamKey {
+	
+	/** 
+	 * @brief ID of the room from which the stream is published.
+	 */
+	roomId: string;
+	
+	/** 
+	 * @brief ID of the user who publishes the stream.
+	 */
+	userId: string;
+	
+	/** 
+	 * @brief Indicates whether the audio is captured by microphone or from screen sharing.  <br>
+	 */
+	streamIndex: StreamIndex;
+}
+
 /** 
  * @list 104477
  * @detail 104479
@@ -1583,10 +1766,14 @@ export interface IEngineEvents {
 	
 	/** 
 	 * @brief A new stream added into the room.
-	 * @param event `stream` object.
+	 * @param event
 	 * @region Room Management Event
 	 */
 	[EngineEventsTypes.onStreamAdd]: (event: {
+		
+		/** 
+		 * @brief `stream` object.
+		 */
 		stream: RTCStream;
 	}) => void;
 	
@@ -1606,11 +1793,19 @@ export interface IEngineEvents {
 	
 	/** 
 	 * @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>.
+	 * @param event
 	 * @region Room Management Event
 	 */
 	[EngineEventsTypes.onStreamRemove]: (event: {
+		
+		/** 
+		* @brief Media stream
+		*/
 		stream: RTCStream;
+		
+		/** 
+		* @brief Reason
+		*/
 		reason: StreamRemoveReason;
 	}) => void;
 	
@@ -1651,31 +1846,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;
 	
@@ -1708,21 +1927,43 @@ 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;
 	
 	/** 
+	 * @hidden
+	 * @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>
+	 */
+	[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>
+	 * @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.
@@ -1732,37 +1973,53 @@ export interface IEngineEvents {
 	
 	/** 
 	 * @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;
 	
@@ -1775,22 +2032,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;
 	
@@ -1810,11 +2087,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;
 	
 	/** 
@@ -1837,6 +2118,11 @@ export interface IEngineEvents {
 	 * @region Message Event
 	 */
 	[EngineEventsTypes.onUserBinaryMessageReceivedOutsideRoom]: (event: UserBinaryMessageEvent) => void;
+	
+	/** 
+	 * @brief You will receive this callback 30 s before the Token expires.
+	 * Call [updateToken](104478#updatetoken) to submit a new Token。The user will be removed from the room when the Token expires.
+	 */
 	[EngineEventsTypes.onTokenWillExpire]: () => void;
 	
 	/** 
@@ -1847,7 +2133,7 @@ export interface IEngineEvents {
 	
 	/** 
 	 * @brief Callback of the result of publishing the public stream.
-	 *        After calling [startPushPublicStream](#startpushpublicstream), you will be informed of the result through this callback.
+	 *        After calling [startPushPublicStream](104478#startpushpublicstream), you will be informed of the result through this callback.
 	 * @param event
 	 */
 	[EngineEventsTypes.onPushPublicStreamResult]: (event: PublicStreamResultEvent) => void;
@@ -1855,7 +2141,7 @@ export interface IEngineEvents {
 	/** 
 	 * @hidden
 	 * @brief Callback of the SEI carried by the public video stream.
-	 *        You will receive SEI by this callback if the public stream you subscribed to by calling [startPlayPublicStream](#startplaypublicstream) is carrying SEI.
+	 *        You will receive SEI by this callback if the public stream you subscribed to by calling [startPlayPublicStream](104478#startplaypublicstream) is carrying SEI.
 	 * @param event
 	 * @notes When multiple streams in the public stream contain SEI:
 	 *        + You will receive SEI from all the video frames if the SEI do not have conflicts.
@@ -1865,44 +2151,31 @@ export interface IEngineEvents {
 	
 	/** 
 	 * @brief Callback of the successful decoding of the first video frame of the public stream.
-	 *        Refer to [startPlayPublicStream](#startplaypublicstream) for details about subsribing to a public stream.
+	 *        Refer to [startPlayPublicStream](104478#startplaypublicstream) for details about subscribing to a public stream.
 	 * @param event
 	 */
 	[EngineEventsTypes.onFirstPublicStreamVideoFrameDecoded]: (event: PublicStreamVideoFirstFrameDecodedEvent) => void;
 	
 	/** 
 	 * @brief Callback of the successful decoding of the first audio frame of the public stream.
-	 *        Refer to [startPlayPublicStream](#startplaypublicstream) for details about subsribing to a public stream.
+	 *        Refer to [startPlayPublicStream](104478#startplaypublicstream) for details about subscribing to a public stream.
 	 * @param event
 	 */
 	[EngineEventsTypes.onFirstPublicStreamAudioFrameDecoded]: (event: PublicStreamAudioFirstFrameDecodedEvent) => void;
 	
 	/** 
 	 * @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;
-}
-
-/** 
- * @brief Cloud proxy informatio
- */
-export interface CloudProxyInfo {
 	
 	/** 
-	 * @brief The cloud proxy IP of log report
+	 * @brief Notification on the playing volume during the test for the local audio devices
+	 * @param volume playing volume during the test for the local audio devices in milliseconds. We recommend to set it to 200 ms.The range is [0,255].
+	 * @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.
 	 */
-	logProxy: string;
-	
-	/** 
-	 * @brief The cloud proxy IP of the access
-	 */
-	accessProxy: string;
-	
-	/** 
-	 * @brief The cloud proxy IP of RTC admin control
-	 */
-	configProxy: string;
+	[EngineEventsTypes.onAudioPlaybackDeviceTestVolume]: (volume: number) => void;
 }
 
 /** 
@@ -2001,11 +2274,11 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	
 	/** 
 	 * @brief Update Token. <br>
-	 * Call this API to update the Token information of the room when the Token expires <br>
+	 * 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>
-	 *      + You have no need to worry about the token expiration after the user joining successfully. Because RTC SDK only verifies the token when the user joins.
+	 *      + The user will be removed from the room when the Token expires.
 	 * @region Room Management
 	 */
 	updateToken(token: string): void;
@@ -2029,17 +2302,17 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	switchCamera(deviceId: string): Promise<void>;
 	
 	/** 
-	 * @brief Enable internal video capture. The default state is off.   <br>
+	 * @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.<br>
+	 * 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.
-	 * @return
+	 * @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>
 	 * @region Video Management
 	 */
-	startVideoCapture(deviceId?: string): Promise<void>;
+	startVideoCapture(deviceId?: string): Promise<MediaTrackSettings>;
 	
 	/** 
 	 * @brief Enable internal video capture immediately. The default setting is off.   <br>
@@ -2058,7 +2331,7 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * 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.
 	 * @return
-	 * @notes + Call [stopVideoCapture](#stopvideocapture) to stop the internal audio capture. Otherwise, the internal audio capture will sustain until you destroy the engine instance. <br>
+	 * @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>
 	 * @region Audio Management
 	 */
@@ -2259,17 +2532,28 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	sendSEIMessage(streamIndex: StreamIndex, message: Uint8Array | string, repeatCount: number): void;
 	
 	/** 
-	 * @brief Sets the video encoder configuration of each individual stream for simulcasting, including resolution, frame rate, bitrate, scale mode, fallback strategy under poor network conditions.
+	 * @region Video Management
+	 * @brief Sets the video encoder configuration of the publishing streams.
 	 * @param streamIndex
-	 * @param descriptions Video parameters of each individual stream for simulcasting.
-	 *                     The length of `VideoEncoderConfig` is no more than 3. The resolutions must be in descending sort.
-	 * @notes + The video streams are encoded by default with a bitrate of 500bps. <br>
-	 *        + The screen stream takes the first set of parameters. <br>
-	 * @region Media Transmission
+	 * @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.
+	 *        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.
 	 */
-	setVideoEncoderConfig(streamIndex: StreamIndex, descriptions: VideoEncoderConfig[]): Promise<void>;
+	setVideoEncoderConfig(streamIndex: StreamIndex, descriptions: VideoEncoderConfig | VideoEncoderConfig[]): 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>
+	 *    + 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;
+	
+	/** 
+	 * @hidden
+	 * @deprecated since 4.42, use enableAudioPropertiesReport instead
 	 * @brief Turn on/off volume prompts. Off by default. <br>
 	 * 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).
@@ -2281,6 +2565,16 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 */
 	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>
+	 *       + Get the information of the subscribed remote audio streams through [onRemoteAudioPropertiesReport](104479#onRemoteAudioPropertiesReport).
+	 * @region Audio Management
+	 */
+	enableAudioPropertiesReport(config?: AudioPropertiesConfig): void;
+	
 	/** 
 	 * @brief Starts pushing media streams to CDN and sets the relevant configurations.
 	 * @param transcode configuration for push media streams to CDN.
@@ -2403,7 +2697,7 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @param userInfo  User information.
 	 * @return
 	 * @notes
-	 *        + Call logout{@link #logout} to log out the IM server.
+	 *        + Call [logout](104478@#logout) to log out the IM server.
 	 *        + In the same App ID, the user ID of each user must be unique. The user will be logged out when a user with the same userID joins the room because of the error of `RTM_DUPLICATE_LOGIN`.
 	 * @region Room Management
 	 */
@@ -2419,7 +2713,7 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @brief Update the Token used to login. Since all tokens have a limited time-to-live, call this API to refresh the token.
 	 * @param token updated token
 	 * @return
-	 * @notes + Call this API to refresh the token after the token has expired with no need for calling login{@link #login}.
+	 * @notes + Call this API to refresh the token after the token has expired with no need for calling [login](#login).
 	 *  + You will be informed of the expiration of the token if you tried to login with an expired token or during a reconnection. If the token expired after the user has logged in, no actions need to be taken.
 	 */
 	updateLoginToken(token: string | null): Promise<void>;
@@ -2428,7 +2722,7 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @brief Get the status of a user before sending him/her a P2P message. You can also call this API to check the status of the current user.
 	 * @param userId ID of the user whose status intended to know
 	 * @return
-	 * @notes Call login{@link #login} before calling this API.
+	 * @notes Call [login](104478@#login) before calling this API.
 	 */
 	getPeerOnlineStatus(userId: string): Promise<USER_ONLINE_STATUS>;
 	
@@ -2437,8 +2731,8 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @param userId ID of the recipient
 	 * @param message Text message within 62 KB.
 	 * @return
-	 * @notes + Call login{@link #login} before calling this API.
-	 * + The recipient must be logged into the server and will receive the text message via [EngineEventsTypes.onUserMessageReceivedOutsideRoom]{@link #[EngineEventsTypes.onUserMessageReceivedOutsideRoom]} if the message has been sent successfully.
+	 * @notes + Call [login](104478@#login) before calling this API.
+	 * + The recipient must be logged into the server and will receive the text message via [EngineEventsTypes.onUserMessageReceivedOutsideRoom](104479#onUserMessageReceivedOutsideRoom) if the message has been sent successfully.
 	 */
 	sendUserMessageOutsideRoom(userId: string, message: string): Promise<any>;
 	
@@ -2446,8 +2740,8 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @brief Send point-to-point (P2P) binary message to a user.
 	 * @param userId ID of the recipient
 	 * @param message Binary message within 46 KB
-	 * @return + Call login{@link #login} before calling this API.
-	 *  + The recipient must be logged into the server and will receive the text message via [EngineEventsTypes.onUserBinaryMessageReceivedOutsideRoom]{@link #[EngineEventsTypes.onUserBinaryMessageReceivedOutsideRoom]} if the message has been sent successfully.
+	 * @return + Call [login](#login) before calling this API.
+	 *  + The recipient must be logged into the server and will receive the text message via [EngineEventsTypes.onUserBinaryMessageReceivedOutsideRoom](104479#onuserbinarymessagereceivedoutsideroom) if the message has been sent successfully.
 	 * @notes
 	 */
 	sendUserBinaryMessageOutsideRoom(userId: string, message: ArrayBuffer): Promise<any>;
@@ -2457,7 +2751,7 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 * @param signature Dynamic signature.
 	 * @param url Address of the IM server
 	 * @return
-	 * @notes Call login{@link #login} before calling this API.
+	 * @notes Call [login](#login) before calling this API.
 	 */
 	setServerParams(signature: string, url: string): Promise<any>;
 	
@@ -2480,8 +2774,7 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	/** 
 	 * @brief  Start cloud proxy
 	 * @param  cloudProxyInfo cloud proxy informarion list.
-	 * @notes   <br>
-	 *         + Call this API before joining the room.<br>
+	 * @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>
 	 *         + To stop cloud proxy, call [stopCloudProxy](#stopCloudProxy).
@@ -2536,7 +2829,7 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 *                       If the designated stream is not published when you call this API, you will receive the public stream once it is published.
 	 * @return
 	 * @notes + Before calling this API, we recommend that you call [setPublicStreamVideoPlayer](#setpublicstreamvideoplayer) first to set the player information and rendering mode for the public stream.
-	 *        + After calling this API, you will receive [onFirstPublicStreamVideoFrameDecoded](#onfirstpublicstreamvideoframedecoded) and [onFirstPublicStreamAudioFrameDecoded](#onfirstpublicstreamaudioframedecoded) once the first frame has been decoded.
+	 *        + After calling this API, you will receive [onFirstPublicStreamVideoFrameDecoded](104479#onfirstpublicstreamvideoframedecoded) and [onFirstPublicStreamAudioFrameDecoded](104479#onfirstpublicstreamaudioframedecoded) once the first frame has been decoded.
 	 *        + Call [stopPlayPublicStream](#stopplaypublicstream) to unsubscribing from the public stream.
 	 */
 	startPlayPublicStream(publicStreamId: string): Promise<void>;
@@ -2556,11 +2849,71 @@ export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
 	 */
 	setPublicStreamVideoPlayer(publicStreamId: string, videoPlayerOption: Omit<VideoPlayerOption, "userId">): void;
 	
+	/** 
+	 * @region Video Management
+	 * @brief Set the placeholder image during local video capture pause
+	 * @param index
+	 * @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>
+	 *    + You cannot see the image during local preview.
+	 */
+	setDummyCaptureImagePath(index: StreamIndex, filePath: string): Promise<void>;
+	
 	/** 
 	 * @brief Get the default parameters of `LiveTranscodeConfig`.
 	 * @return The default parameters of `LiveTranscodeConfig`
 	 */
 	defaultTranscoding(): Required<LiveTranscodeConfig>;
+	
+	/** 
+	 * @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.
+	 * @param indicationInterval The time interval between each callback in milliseconds. We recommend setting it to 200 ms. The minimal value is 100 ms.
+	 * @return Resolve when the test ends.
+	 * @notes + You can call this API whether the user is in the room.
+	 * + Call [stopAudioPlaybackDeviceTest](#stopaudioplaybackdevicetest) to stop the playback test before moving on to the other device tests.
+	 */
+	startAudioPlaybackDeviceTest(filePath: string, indicationInterval: number): Promise<void>;
+	
+	/** 
+	 * @brief Stop the playback test for the local audio device.
+	 * @notes Call this API to stop the playback test started by calling [startAudioPlaybackDeviceTest](#startaudioplaybackdevicetest) before moving on to the other device tests.
+	 */
+	stopAudioPlaybackDeviceTest(): void;
+	
+	/** 
+	 * @brief Start the capture and playback test for local audio devices.
+	 * We recommend to register [onLocalAudioPropertiesReport](104479#onlocalaudiopropertiesreport) callback via [enableAudioPropertiesReport](enableaudiopropertiesreport). Once the test starts, you can get the volume of the capturing audio by this callback.
+	 * @param indicationInterval The time interval between each callback of [onAudioPlaybackDeviceTestVolume](104479#onaudioplaybackdevicetestvolume) via which you get informed of the playback volume during the test.  We recommend setting it to 200 ms. The minimal value is 100 ms.
+	 * @return Resolve when the test ends.
+	 * @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.
+	 * + 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.
+	*/
+	stopAudioDeviceRecordAndPlayTest(): void;
+	
+	/** 
+	 * @brief Stop the capture and playback test for local audio devices which is started by calling [startAudioDeviceRecordTest](#startaudiodevicerecordtest).
+	 * 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;
 }
 
 /** 
@@ -2657,6 +3010,7 @@ 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;
 	
@@ -2671,6 +3025,13 @@ export interface RoomConfig {
 	 * Call subscribeUserStream, unsubscribe to revise the subscription.
 	 */
 	isAutoSubscribeVideo: boolean;
+	
+	/** 
+	 * @brief  Room profile<br>
+	 *        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;
 }
 
 /** 
@@ -2716,12 +3077,12 @@ export interface SubscribeConfig {
 export declare enum MuteState {
 	
 	/** 
-	 * @brief Enable
+	 * @brief Disable
 	 */
 	MUTE_STATE_OFF = 0,
 	
 	/** 
-	 * @brief Disable
+	 * @brief Enable
 	 */
 	MUTE_STATE_ON = 1
 }
@@ -2806,7 +3167,7 @@ export interface VideoPlayerOption {
 	renderDom?: string | HTMLElement;
 	
 	/** 
-	 * @brief Rendering modes: optional  `RENDER_MODE_HIDDEN`, `RENDER_MODE_FIT` and `RENDER_MODE_ADAPTIVE`.
+	 * @brief Rendering modes: optional  `RENDER_MODE_HIDDEN` and `RENDER_MODE_FIT` .
 	 */
 	renderMode?: VideoRenderMode;
 	
@@ -3071,6 +3432,21 @@ export interface ScreenConfig {
  */
 export interface VideoEncoderConfig {
 	
+	/** 
+	 * @brief width in px
+	 */
+	width: number;
+	
+	/** 
+	 * @brief height in px
+	 */
+	height: number;
+	
+	/** 
+	 * @brief frame rate
+	 */
+	frameRate: number;
+	
 	/** 
 	 * @brief The max bitrate, unit: kbps
 	 */
@@ -3098,6 +3474,27 @@ export declare enum MirrorType {
 	MIRROR_TYPE_RENDER = 1
 }
 
+/** 
+ * @brief Configuration related to audio information prompt.   <br>
+ */
+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>
+	 */
+	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>
+	 */
+	enableInBackground?: boolean;
+}
+
 /** 
  * @brief Configurations to be set when pushing media streams to CDN
  */
@@ -3203,7 +3600,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";
 }
@@ -3477,6 +3874,97 @@ export interface PublicStreamConfig {
 	};
 }
 
+/** 
+ * @brief  Room profile<br>
+ *        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  <br>
+	 *        Sample rate: 16 KHz<br>
+	 *        Mono-channel<br>
+	 *        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  <br>
+	 *        Sample rate: 48 KHz<br>
+	 *        Encoding bitrate: 48 Kpbs<br>
+	 *        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  <br>
+	 *        Sample rate: 48 KHz<br>
+	 *        Encoding birrate: 128 Kpbs<br>
+	 *        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. <br>
+	 *        Not recommended for game Apps.
+	 */
+	hd = 3,
+	
+	/** 
+	 * @brief Dual-channel standard  <br>
+	 *        Sample rate: 48 KHz<br>
+	 *        Encoding birrate: 80 Kpbs
+	 */
+	standardStereo = 4,
+	
+	/** 
+	 * @brief Mono-channel music  <br>
+	 *        Sample rate: 48 KHz<br>
+	 *        Encoding birrate: 128 Kpbs<br>
+	 */
+	hdMono = 5
+}
+
 /** 
  * @brief Point-to-point text message
  */
@@ -3550,9 +4038,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
@@ -3564,10 +4053,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.
@@ -3579,7 +4068,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
 	 */
@@ -3603,12 +4092,20 @@ export interface IVERTC {
 	/** 
 	 * @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;
@@ -3641,9 +4138,8 @@ export interface IVERTC {
 	
 	/** 
 	 * @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>;
@@ -3651,7 +4147,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[]>;