@byteplus/rtc 4.36.0-rc.0 → 4.36.0-rc.1

package/index.d.ts

@@ -0,0 +1,3036 @@
+// Generated by dts-bundle-generator v6.4.0
+
+import { EventArgs, EventEmitter, EventNames, ValidEventTypes } from 'eventemitter3';
+
+/**
+ * @list 104477
+ * @detail 104478
+ */
+/** 
+ * @list 104477
+ * @detail 104478
+ */
+export interface IAudioMixingManager {
+	
+	/** 
+	 * 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.
+	 * @param id Mix ID. For identifying the mix, please ensure that the mix ID is unique. <br>
+	 *         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>
+	 *         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   <br>
+	 *        + If you have already loaded the sound effect into memory through preloadAudioMixing{@link #preloadAudioMixing}, make sure that the ID here is the same as the ID set by preloadAudioMixing{@link #preloadAudioMixing}.  <br>
+	 *        + After you start playing the audio file and mixing, you can call the stopAudioMixing{@link #stopAudioMixing} method to stop playing the audio file. <br>
+	 *        + The mixing data of this method comes from an external file, while the mixing data of enableAudioMixingFrame{@link #enableAudioMixingFrame} comes from an external cache and the audio format is PCM. These two mixing methods can coexist.
+	 * @region Advanced Feature
+	 */
+	startAudioMixing(id: number, filePath: string, options: MixOption): Promise<void>;
+	
+	/** 
+	 * Stop playing audio files and mixes
+	 * @param id ID of the mixing
+	 * @notes   <br>
+	 *        + After calling startAudioMixing{@link #startAudioMixing} method to start playing audio files and mixes, you can call this method to stop playing audio files and mixes. <br>
+	 *        + After calling this method to stop playing the audio file, the audio file will be automatically uninstalled.
+	 * @region Advanced Feature
+	 */
+	stopAudioMixing(id: number): void;
+	
+	/** 
+	 * Pause playing audio files and mixes
+	 * @param id  ID of the mixing
+	 * @notes   <br>
+	 *        + After calling startAudioMixing{@link #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{@link #resumeAudioMixing} method to resume playing and mixing. <br>
+	 * @region Advanced Feature
+	 */
+	pauseAudioMixing(id: number): void;
+	
+	/** 
+	 * Resume playing audio files and mixing
+	 * @param id  Mixing ID
+	 * @notes After calling the pauseAudioMixing{@link #pauseAudioMixing} method to pause playing audio files and mixing, you can resume playing and mixing by calling this method. <br>
+	 * @region Advanced Feature
+	 */
+	resumeAudioMixing(id: number): void;
+	
+	/** 
+	 * 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{@link #startAudioMixing} and then call this method with the same ID, the previous mix stopped, and then the next mix was loaded. <br>
+	 *         After calling this method with an ID to preload A.mp3, if you need to call startAudioMixing{@link #startAudioMixing} to play B.mp3 with the same ID, please call unloadAudioMixing{@link #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>
+	 * @return
+	 * @notes   <br>
+	 *        + 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{@link #startAudioMixing} API can you start playing the specified audio file. <br>
+	 *        + The specified audio file preloaded by calling this method can be unloaded through unloadAudioMixing{@link #unloadAudioMixing}.
+	 * @region Advanced Feature
+	 */
+	preloadAudioMixing(id: number, filePath: string): Promise<void>;
+	
+	/** 
+	 * Uninstall the specified audio file
+	 * @param id Mix ID
+	 * @region Advanced Feature
+	 */
+	unloadAudioMixing(id: number): void;
+	
+	/** 
+	 * 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>
+	 *         + 400: Maximum volume (with overflow protection)
+	 * @region Advanced Feature
+	 */
+	setAudioMixingVolume(id: number, volume: number): void;
+	
+	/** 
+	 * Get volume of the audio files.
+	 * @param id Audio mix id
+	 * @return <br>
+	 *         + `0`: Failure<br>
+	 *         + `>0`: Successful. Volume<br>
+	 * @region Advanced Feature
+	 */
+	getAudioMixingVolume(id: number): number;
+	
+	/** 
+	 *   Get audio file duration
+	 * @param id   Mix ID
+	 * @return   <br>
+	 *         + > 0: Success, audio file duration, in milliseconds. <br>
+	 *         + < 0: Failure
+	 * @notes  Before calling this method to obtain the length of the audio file, you need to call preloadAudioMixing{@link #preloadAudioMixing} or startAudioMixing{@link #startAudioMixing}.
+	 * @region Advanced Feature
+	 */
+	getAudioMixingDuration(id: number): number;
+	
+	/** 
+	 *   Get audio file playback progress
+	 * @param id   Mix ID
+	 * @return   <br>
+	 *         + > 0: Success, audio file playback progress, in milliseconds. <br>
+	 *         + < 0: Failed
+	 * @notes Before calling this method to get the audio file playback progress, you need to call startAudioMixing{@link #startAudioMixing} to start playing the audio file.
+	 * @region Advanced Feature
+	 */
+	getAudioMixingCurrentPosition(id: number): number;
+	
+	/** 
+	 * 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.
+	 * @notes  <br>
+	 *       + 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>
+	 *       + Before calling this method to set the playback position of the audio file, you need to call startAudioMixing{@link #startAudioMixing} to start playing the audio file.
+	 * @region Advanced Feature
+	 */
+	setAudioMixingPosition(id: number, position: number): void;
+	
+	/** 
+	 *  Start PCM mixing. <br>
+	 *        To mix multiple PCM audio data, call this API multiple times with different ids.
+	 * @param type Mixing type <br>
+	 *        Whether the PCM data is mixed locally and sent to the remotes.
+	 * @notes   <br>
+	 *        + After this API, you must call pushAudioMixingFrame{@link #pushAudioMixingFrame} to start mixing. <br>
+	 *        + To end PCM mixing, use disableAudioMixingFrame{@link #disableAudioMixingFrame}.
+	 * @region Advanced Feature
+	 */
+	enableAudioMixingBuffer(type: AudioMixingType): void;
+	
+	/** 
+	 * Disable PCM mixing.
+	 * @region Advanced Feature
+	 */
+	disableAudioMixingBuffer(): void;
+	
+	/** 
+	 * 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{@link #enableAudioMixingFrame}. <br>
+	 * @region Advanced Feature
+	 */
+	pushAudioMixingBuffer(buffer: AudioBuffer): void;
+}
+
+/** 
+ * @type keytype
+ *   Mix playback channel type
+ */
+export declare enum AudioMixingDualMonoMode {
+	
+	/** 
+	 *  Consistent with audio files
+	 */
+	AUTO = 0,
+	
+	/** 
+	 *  Only the left channel audio in the audio file can be heard
+	 */
+	MODE_L = 1,
+	
+	/** 
+	 *  Only the right channel audio in the audio file can be heard
+	 */
+	MODE_R = 2,
+	
+	/** 
+	 *  Can hear the left and right audio channels in the audio file at the same time
+	 */
+	MODE_MIX = 3
+}
+
+/** 
+ * @type keytype
+ *  Mixing type
+ */
+export declare enum AudioMixingType {
+	
+	/** 
+	 *  Played at the local device only
+	 */
+	PLAYOUT = 0,
+	
+	/** 
+	 *  Sent to the remote devices only
+	 */
+	PUBLISH = 1,
+	
+	/** 
+	 *  Played at the local device and sent to the remote devices.
+	 */
+	PLAYOUT_AND_PUBLISH = 2
+}
+declare enum AudioMixingState {
+	
+	AUDIO_MIXING_STATE_PRELOADED = 0,
+	
+	AUDIO_MIXING_STATE_PLAYING = 1,
+	
+	AUDIO_MIXING_STATE_PAUSED = 2,
+	
+	AUDIO_MIXING_STATE_STOPPED = 3,
+	
+	AUDIO_MIXING_STATE_FAILED = 4,
+	
+	AUDIO_MIXING_STATE_FINISHED = 5,
+	
+	AUDIO_MIXING_STATE_PCM_ENABLED = 6,
+	
+	AUDIO_MIXING_STATE_PCM_DISABLED = 7
+}
+
+/** 
+ * @type keytype
+ *   Mixing configuration
+ */
+export interface MixOption {
+	
+	/** 
+	 *  Mix playback times
+	 * @notes   <br>
+	 *        + Play_count < = 0: Infinite loop <br>
+	 *        + Play_count == 1: Play once (default) <br>
+	 *        + Play_count > 1: Play play_count times
+	 */
+	playCount: number;
+	
+	/** 
+	 *  For mixing playback types. Refer to [AudioMixingType](#audiomixingtype).
+	 */
+	type?: AudioMixingType;
+}
+declare class EnhancedEventEmitter<EventTypes extends ValidEventTypes = string | symbol> extends EventEmitter<EventTypes> {
+	constructor();
+	safeEmit<T extends EventNames<EventTypes>>(event: T, ...args: EventArgs<EventTypes, T>): boolean;
+	safeEmitAsPromise(event: string, ...args: any[]): Promise<any>;
+}
+
+/** 
+ * Information of media device
+ */
+export interface RTCDevice {
+	
+	/** 
+	 * Device ID
+	 * Refer to the [browser documentation](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo)
+	 */
+	deviceId: MediaDeviceInfo["deviceId"];
+	
+	/** 
+	 * Device type
+	 * Refer to the [browser documentation](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo)
+	 */
+	deviceType: MediaDeviceInfo["kind"];
+	
+	/** 
+	 * Device information
+	 * Refer to the [browser documentation](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo)
+	 */
+	deviceInfo: MediaDeviceInfo;
+	
+	/** 
+	 * Device label
+	 * Refer to the [browser documentation](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo)
+	 */
+	deviceName: MediaDeviceInfo["label"];
+	
+	/** 
+	 * Device state
+	 */
+	deviceState: "active" | "inactive";
+}
+declare enum ErrorCode {
+	
+	/** 
+	 * Invalid argument of the `engine` object for calling destroyEngine
+	 */
+	INVALID_ENGINE = "INVALID_ENGINE",
+	
+	/** 
+	 * Invalid argument
+	 */
+	INVALID_PARAMS = "INVALID_PARAMS",
+	
+	/** 
+	 * Token is invalid or has expired.
+	 */
+	INVALID_TOKEN = "INVALID_TOKEN",
+	
+	/** 
+	 * Failure of joining room
+	 */
+	JOIN_ROOM_FAILED = "JOIN_ROOM_FAILED",
+	
+	/** 
+	 * Join the same room repeatedly.
+	 */
+	REPEAT_JOIN = "REPEAT_JOIN",
+	
+	/** 
+	 * Publish media stream repeatedly.
+	 */
+	REPEAT_PUBLISH = "REPEAT_PUBLISH",
+	
+	/** 
+	 * Publish before joining a room.
+	 */
+	PUBLISH_BEFORE_JOIN = "PUBLISH_BEFORE_JOIN",
+	
+	/** 
+	 * Un-publish before joining a room.
+	 */
+	UNPUBLISH_BEFORE_JOIN = "UNPUBLISH_BEFORE_JOIN",
+	
+	/** 
+	 * Subscribe before joining a room.
+	 */
+	SUBSCRIBE_BEFORE_JOIN = "SUBSCRIBE_BEFORE_JOIN",
+	
+	/** 
+	 * Unsubscribe before joining a room.
+	 */
+	UNSUBSCRIBE_BEFORE_JOIN = "UNSUBSCRIBE_BEFORE_JOIN",
+	
+	/** 
+	 * Request to publish media stream as an invisible user.
+	 */
+	NO_PUBLISH_PERMISSION = "NO_PUBLISH_PERMISSION",
+	
+	/** 
+	 * Request to subscribe or unsubscribe a stream that doesn't exist.
+	 */
+	STREAM_NOT_EXIST = "STREAM_NOT_EXIST",
+	
+	/** 
+	 * Request to publish an empty stream.
+	 */
+	EMPTY_STREAM = "EMPTY_STREAM",
+	
+	/** 
+	 * Network disconnected. RTC SDk will emit this error code if you call publish, subscribe or the other related methods while the user has not joined a room.
+	 */
+	NOT_CONNECTED_YET = "NOT_CONNECTED_YET",
+	
+	/** 
+	 * Request to send message before the user has joined a room.
+	 */
+	IM_BEFORE_JOIN = "IM_BEFORE_JOIN",
+	
+	/** 
+	 * The user does not exist.
+	 */
+	USER_NOT_EXIST = "USER_NOT_EXIST",
+	
+	/** 
+	 * The user has joined the room.
+	 */
+	ALREADY_IN_ROOM = "ALREADY_IN_ROOM",
+	
+	/** 
+	 * The user is kicked out because a user with the same userId joined the room.
+	 */
+	DUPLICATE_LOGIN = "DUPLICATE_LOGIN",
+	
+	/** 
+	 * Enable capture repeatedly.
+	 */
+	REPEAT_CAPTURE = "REPEAT_CAPTURE",
+	
+	/** 
+	 * Failure of video capture
+	 */
+	GET_VIDEO_TRACK_FAILED = "GET_VIDEO_TRACK_FAILED",
+	
+	/** 
+	 * Failure of getting audio track
+	 */
+	GET_AUDIO_TRACK_FAILED = "GET_AUDIO_TRACK_FAILED",
+	
+	/** 
+	 * Failure of getting screen track
+	 */
+	GET_SCREEN_TRACK_FAILED = "GET_SCREEN_TRACK_FAILED",
+	
+	/** 
+	 * Stream type mismatched. RTC SDK will emit this error code when you enable the local media device after enabling the custom video module.
+	 */
+	STREAM_TYPE_NOT_MATCH = "STREAM_TYPE_NOT_MATCH",
+	
+	/** 
+	 * Cannot find the DOM specified to play the video.
+	 */
+	CANT_FIND_DOM = "CANT_FIND_DOM",
+	
+	/** 
+	 * Invalid device ID
+	 */
+	INVALID_DEVICE_ID = "INVALID_DEVICE_ID",
+	
+	/** 
+	 * No permission for capture
+	 */
+	NO_PERMISSION = "NO_PERMISSION",
+	
+	/** 
+	 * The browser does not support capture.
+	 */
+	NOT_SUPPORTED = "NOT_SUPPORTED",
+	
+	/** 
+	 * Failure of requesting an ICE node
+	 */
+	ICE_SERVER_WRONG = "ICE_SERVER_WRONG",
+	
+	/** 
+	 * Failure of establishing a datachannel
+	 */
+	ESTABLISH_DATACHANNEL_FAILED = "ESTABLISH_DATACHANNEL_FAILED",
+	
+	/** 
+	 * Failure of loading network resource
+	 */
+	LOAD_RESOURCES_FAILED = "LOAD_RESOURCES_FAILED",
+	
+	/** 
+	 * Failure of building the signal channel
+	 */
+	SIGNALING_CHANNEL_NOT_OPEN = "SIGNALING_CHANNEL_NOT_OPEN",
+	
+	/** 
+	 * Request timeout
+	 */
+	TIME_OUT = "TIME_OUT",
+	
+	/** 
+	 * Request is denied for the reason of network disconnected.
+	 */
+	REFUSE_OPERATION_IN_DISCONNECT = "REFUSE_OPERATION_IN_DISCONNECT",
+	
+	/** 
+	 * Failure of building a peer-connection to the signal server for the failure of building transceiver
+	 */
+	ADD_TRANSCEIVER_FAILED = "ADD_TRANSCEIVER_FAILED",
+	
+	/** 
+	 * Failure of updating media track
+	 */
+	UPDATE_TRACK_FAILED = "UPDATE_TRACK_FAILED",
+	
+	/** 
+	 * Failure of publishing a media stream
+	 */
+	PUBLISH_FAILED = "PUBLISH_FAILED",
+	
+	/** 
+	 * Failure of un-publishing a media stream
+	 */
+	UNPUBLISH_FAILED = "UNPUBLISH_FAILED",
+	
+	/** 
+	 * Failure of subscribing a media stream
+	 */
+	SUBSCRIBE_FAILED = "SUBSCRIBE_FAILED",
+	
+	/** 
+	 * Failure of unsubscribing a media stream
+	 */
+	UNSUBSCRIBE_FAILED = "UNSUBSCRIBE_FAILED",
+	
+	/** 
+	 * Call [leaveRoom](#leaveroom)Process of publishing and subscribing will
+	 * RTC SDK will emit this error code when you call the [leaveRoom](#leaveroom) during the process of publishing or subscribing.
+	 */
+	OPERATION_CANCEL = "OPERATION_CANCEL",
+	
+	/** 
+	 * Unknown error
+	 */
+	UNEXPECTED_ERROR = "UNEXPECTED_ERROR"
+}
+declare enum AudioMixingError {
+	
+	/** 
+	 * Normal
+	 */
+	AUDIO_MIXING_ERROR_OK = 0,
+	
+	/** 
+	 * Pre-load fails because of missing audio file or the length of the audio file exceeding 20s.
+	 */
+	AUDIO_MIXING_ERROR_PRELOAD_FAILED = 1,
+	
+	/** 
+	 * Audio mixing starts fails because of missing audio file or failure of reading the audio file.
+	 */
+	AUDIO_MIXING_ERROR_START_FAILED = 2,
+	
+	/** 
+	 * Invalid audio mixing ID
+	 */
+	AUDIO_MIXING_ERROR_ID_NOT_FOUND = 3,
+	
+	/** 
+	 * Invalid start position
+	 */
+	AUDIO_MIXING_ERROR_SET_POSITION_FAILED = 4,
+	
+	/** 
+	 * Invalid volume argument. The volume value ranges [0, 400].
+	 */
+	AUDIO_MIXING_ERROR_INVALID_VOLUME = 5,
+	
+	/** 
+	 * The audio file to be played does not match to the preload one. Call `unloadAudioMixing` to unload file and proceed.
+	 */
+	AUDIO_MIXING_ERROR_LOAD_CONFLICT = 6,
+	
+	/** 
+	 * Type of the audio file to be played is not supported.
+	 */
+	AUDIO_MIXING_ERROR_ID_TYPE_NOT_MATCH = 7,
+	
+	/** 
+	 * Invalid audio pitch
+	 */
+	AUDIO_MIXING_ERROR_ID_TYPE_INVALID_PITCH = 8,
+	
+	/** 
+	 * Invalid audio track
+	 */
+	AUDIO_MIXING_ERROR_INVALID_AUDIO_TRACK = 9
+}
+
+/** 
+ * A user joins the room
+ */
+export interface onUserJoinedEvent {
+	
+	/** 
+	 * userId of the user who is joining the room
+	 */
+	userInfo: UserInfo;
+}
+
+/** 
+ * A user leaves the room
+ */
+export interface onUserLeaveEvent {
+	
+	/** 
+	 * User information, refer to [UserInfo](#userinfo) for more details.
+	 */
+	userInfo: UserInfo;
+	
+	/** 
+	 * The reason the user left the room:
+	 * 0: The remote user calls leaveRoom to actively exit the room
+	 * 1: The remote user is disconnected due to network problems, or switches to an invisible state
+	 */
+	reason: 0 | 1;
+}
+
+/** 
+ * A User in the room publishes a media stream.
+ */
+export interface onStreamAddEvent {
+	
+	/** 
+	 * Stream properties
+	 */
+	stream: RTCStream;
+}
+
+/** 
+ * A User in the room un-publishes the media stream.
+ */
+export interface onStreamRemoveEvent {
+	
+	/** 
+	 * Stream properties
+	 */
+	stream: RTCStream;
+	
+	/** 
+	 * Reason of un-publishing
+	 */
+	reason: StreamRemoveReason;
+}
+
+/** 
+ * Events related to the connection state of the SDK and the signal server
+ */
+export interface onConnectionStateEvent {
+	
+	/** 
+	 * Events related to the connection state of the SDK and the signal server
+	 */
+	state: ConnectionState;
+}
+
+/** 
+ * The first video frame shown on the screen
+ */
+export interface onVideoFirstFrameRenderedEvent {
+	
+	/** 
+	 * userId of the user published the video stream
+	 */
+	userId: string;
+	
+	/** 
+	 * Height
+	 */
+	height: number;
+	
+	/** 
+	 * Width
+	 */
+	width: number;
+}
+
+/** 
+ * Event related to the decoder of the first video frame
+ */
+export interface onVideoFirstFrameDecodedEvent {
+	
+	/** 
+	 * userId of the user published the video stream
+	 */
+	userId: string;
+	
+	/** 
+	 * Height
+	 */
+	height: number;
+	
+	/** 
+	 * Width
+	 */
+	width: number;
+}
+
+/** 
+ * Event related to the decoder of the first audio frame
+ */
+export interface onAudioFirstFrameDecodedEvent {
+	
+	/** 
+	 * userId of the user published the video stream
+	 */
+	userId: string;
+}
+
+/** 
+ * State of the media devices which including audio capture device. audio playback device, and video capture device.
+ */
+export interface onMediaDeviceStateChangeEvent {
+	
+	/** 
+	 * Device identification
+	 */
+	device_id: string;
+	
+	/** 
+	 * Device type, including audio capture device. audio playback device, and video capture device.
+	 */
+	device_type: string;
+	
+	/** 
+	 * Device state
+	 */
+	device_state: "ACTIVE" | "INACTIVE";
+}
+
+/** 
+ * Receiving video frames carrying SEI message
+ */
+export interface onSEIMessageEvent {
+	
+	/** 
+	 * Including userId of the user who sent the message, roomId of the current room, and the media stream carrying this SEI message. Refer to [RemoteStreamKey](#remotestreamkey) for more information.
+	 */
+	remoteStreamKey: RemoteStreamKey;
+	
+	/** 
+	 * SEI message received
+	 */
+	sei: Uint8Array;
+}
+
+/** 
+ * State of the local audio stream
+ */
+export interface LocalAudioStats {
+	
+	/** 
+	 * Audio loss rate
+	 */
+	audioLossRate: number;
+	
+	/** 
+	 * Bitrate of sending, unit: kbps
+	 */
+	sendKBitrate: number;
+	
+	/** 
+	 * Sample rate of audio capturing
+	 */
+	recordSampleRate: number;
+	
+	/** 
+	 * Interval of each states
+	 */
+	statsInterval: number;
+	
+	/** 
+	 * Round trip time, unit: ms
+	 */
+	rtt: number;
+	
+	/** 
+	 * number of the signal channels
+	 */
+	numChannels: number;
+	
+	/** 
+	 * Sample rate of sending
+	 */
+	sentSampleRate?: number;
+}
+
+/** 
+ * Local video states
+ */
+export interface LocalVideoStats {
+	
+	/** 
+	 * Bitrate of sending, unit: kbps
+	 */
+	sentKBitrate: number;
+	
+	/** 
+	 * Frame rate of the source video
+	 */
+	inputFrameRate?: number;
+	
+	/** 
+	 * Frame rate of sending
+	 */
+	sentFrameRate: number;
+	
+	/** 
+	 * Frame rate of encoding
+	 */
+	encoderOutputFrameRate: number;
+	
+	/** 
+	 * Frame rate of rendering
+	 */
+	rendererOutputFrameRate?: number;
+	
+	/** 
+	 * Target bitrate
+	 */
+	targetKBitrate?: number;
+	
+	/** 
+	 * Target frame rate
+	 */
+	targetFrameRate?: number;
+	
+	/** 
+	 * Interval of each states
+	 */
+	statsInterval: number;
+	
+	/** 
+	 * Loss rate of video package
+	 */
+	videoLossRate: number;
+	
+	/** 
+	 * Round trip time, unit: ms
+	 */
+	rtt: number;
+	
+	/** 
+	 * Bitrate of encoding
+	 */
+	encodedBitrate?: number;
+	
+	/** 
+	 * Frame rate of encoding
+	 */
+	encodedFrameWidth: number;
+	
+	/** 
+	 * Height of the encoded video frame
+	 */
+	encodedFrameHeight: number;
+	
+	/** 
+	 * Number of encoded frames
+	 */
+	encodedFrameCount: number;
+	
+	/** 
+	 * Encoding type
+	 */
+	codecType: string;
+	
+	/** 
+	 * Whether it is a screen-sharing stream
+	 */
+	isScreen: boolean;
+}
+
+/** 
+ * State of the local media stream
+ */
+export interface LocalStreamStats {
+	
+	/** 
+	 * State of the local audio stream
+	 */
+	audioStats: LocalAudioStats;
+	
+	/** 
+	 * State of the local video stream
+	 */
+	videoStats: LocalVideoStats;
+	
+	/** 
+	 * Whether it is a screen-sharing stream
+	 */
+	isScreen: boolean;
+	
+	/** 
+	 * @hidden
+	 * Quality of the uplink network
+	 */
+	txQuality?: number;
+	
+	/** 
+	 * @hidden
+	 * Quality of the downlink network
+	 */
+	rxQuality?: number;
+}
+
+/** 
+ * State of the remote audio stream
+ */
+export interface RemoteAudioStats {
+	
+	/** 
+	 * Loss rate of the audio packages
+	 */
+	audioLossRate: number;
+	
+	/** 
+	 * Bitrate of receiving
+	 */
+	receivedKBitrate: number;
+	
+	/** 
+	 * Number of video stalls
+	 */
+	stallCount?: number;
+	
+	/** 
+	 * Duration of a video stall
+	 */
+	stallDuration?: number;
+	
+	/** 
+	 * End-to-end delay, unit: ms
+	 */
+	e2eDelay: number;
+	
+	/** 
+	 * Sample rate of the playback
+	 */
+	playoutSampleRate?: number;
+	
+	/** 
+	 * Interval of each report of states
+	 */
+	statsInterval: number;
+	
+	/** 
+	 * Round trip time, unit: ms
+	 */
+	rtt: number;
+	
+	/** 
+	 * @hidden
+	 * Quality of the media stream
+	 */
+	quality?: number;
+	
+	/** 
+	 * Jitter buffer delay, unit: ms
+	 */
+	jitterBufferDelay: number;
+	
+	/** 
+	 * Number of channels
+	 */
+	numChannels: number;
+	
+	/** 
+	 * Sample rate of the received stream
+	 */
+	receivedSampleRate: number;
+	
+	/** 
+	 * Video frozen rate
+	 */
+	frozenRate?: number;
+	
+	/** 
+	 * Concealed samples
+	 */
+	concealedSamples: number;
+	
+	/** 
+	 * Concealment events
+	 */
+	concealmentEvent: number;
+	
+	/** 
+	 * Sample rate of decoding
+	 */
+	decSampleRate?: number;
+	
+	/** 
+	 * Decoding duration, unit: s
+	 */
+	decDuration?: number;
+}
+
+/** 
+ * Information of the remote video stream
+ */
+export interface RemoteVideoStats {
+	
+	/** 
+	 * Width
+	 */
+	width: number;
+	
+	/** 
+	 * Height
+	 */
+	height: number;
+	
+	/** 
+	 * Loss rate of the video packages
+	 */
+	videoLossRate: number;
+	
+	/** 
+	 * Bitrate of the received video stream
+	 */
+	receivedKBitrate: number;
+	
+	/** 
+	 * Frame rate of decoding
+	 */
+	decoderOutputFrameRate: number;
+	
+	/** 
+	 * Frame rate of rendering
+	 */
+	rendererOutputFrameRate?: number;
+	
+	/** 
+	 * Number of video stalls
+	 */
+	stallCount?: number;
+	
+	/** 
+	 * Duration of a video stall
+	 */
+	stallDuration?: number;
+	
+	/** 
+	 * End-to-end delay, unit: ms
+	 */
+	e2eDelay: number;
+	
+	/** 
+	 * Whether it is a screen-sharing stream
+	 */
+	isScreen: boolean;
+	
+	/** 
+	 * Interval of each states
+	 */
+	statsInterval: number;
+	
+	/** 
+	 * Round trip time, unit: ms
+	 */
+	rtt: number;
+	
+	/** 
+	 * Video frozen rate
+	 */
+	frozenRate?: number;
+	
+	/** 
+	 * Video index
+	 */
+	videoIndex?: number;
+}
+
+/** 
+ * Information of the remote media stream
+ */
+export interface RemoteStreamStats {
+	
+	/** 
+	 * userId of the user who is joining the room
+	 */
+	userId?: string;
+	
+	/** 
+	 * State of the remote audio stream
+	 */
+	audioStats: RemoteAudioStats;
+	
+	/** 
+	 * State of the remote video stream
+	 */
+	videoStats: RemoteVideoStats;
+	
+	/** 
+	 * Whether it is a screen-sharing stream
+	 */
+	isScreen: boolean;
+	
+	/** 
+	 * Quality of the transmitting stream
+	 */
+	txQuality?: number;
+	
+	/** 
+	 * Quality of the receiving stream
+	 */
+	rxQuality?: number;
+}
+declare enum EngineEventsTypes {
+	
+	/** 
+	 * The media track ends.
+	 */
+	onTrackEnded = "onTrackEnded",
+	
+	/** 
+	 * Player event
+	 */
+	onPlayerEvent = "onPlayerEvent",
+	
+	/** 
+	 * Streams fails to play automatically.
+	 */
+	onAutoplayFailed = "onAutoplayFailed",
+	
+	/** 
+	 * A user joins the room.
+	 */
+	onUserJoined = "onUserJoined",
+	
+	/** 
+	 * A user leaves the room.
+	 */
+	onUserLeave = "onUserLeave",
+	
+	/** 
+	 * Connection state changes.
+	 */
+	onConnectionStateChanged = "onConnectionStateChanged",
+	
+	/** 
+	 * A new media stream in the room
+	 */
+	onStreamAdd = "onStreamAdd",
+	
+	/** 
+	 * A media stream in the room has been stopped.
+	 */
+	onStreamRemove = "onStreamRemove",
+	
+	/** 
+	 * Receiving a broadcasting message in the room
+	 */
+	onRoomMessageReceived = "onRoomMessageReceived",
+	
+	/** 
+	 * Receiving a broadcasting binary message in the room
+	 */
+	onRoomBinaryMessageReceived = "onRoomBinaryMessageReceived",
+	
+	/** 
+	 * Receiving a point-to-point text message
+	 */
+	onUserMessageReceived = "onUserMessageReceived",
+	
+	/** 
+	 * Receiving a point-to-point binary message
+	 */
+	onUserBinaryMessageReceived = "onUserBinaryMessageReceived",
+	
+	/** 
+	 * A visible user in the room mutes his/her audio.
+	 */
+	onUserMuteAudio = "onUserMuteAudio",
+	
+	/** 
+	 * A visible user in the room mutes his/her video.
+	 */
+	onUserMuteVideo = "onUserMuteVideo",
+	
+	/** 
+	 * The first video frame has been rendered successfully.
+	 */
+	onVideoFirstFrameRendered = "onVideoFirstFrameRendered",
+	
+	/** 
+	 * The first video frame has been decoded successfully.
+	 */
+	onVideoFirstFrameDecoded = "onVideoFirstFrameDecoded",
+	
+	/** 
+	 * The first audio frame has been decoded successfully.
+	 */
+	onAudioFirstFrameDecoded = "onAudioFirstFrameDecoded",
+	
+	/** 
+	 * The state of the media device changes.
+	 */
+	onMediaDeviceStateChanged = "onMediaDeviceStateChanged",
+	
+	/** 
+	 * Callback including the state of the remote media stream
+	 */
+	onRemoteStreamStats = "onRemoteStreamStats",
+	
+	/** 
+	 * Callback including the state of the local media stream
+	 */
+	onLocalStreamStats = "onLocalStreamStats",
+	
+	/** 
+	 * Indication of audio volume
+	 */
+	onAudioVolumeIndication = "onAudioVolumeIndication",
+	
+	/** 
+	 * Callback of the state changing of audio playback devices
+	 */
+	onAudioPlaybackDeviceChanged = "onAudioPlaybackDeviceChanged",
+	
+	/** 
+	 * A publisher starts video capture.
+	 */
+	onUserStartVideoCapture = "onUserStartVideoCapture",
+	
+	/** 
+	 * A publisher stops video capture.
+	 */
+	onUserStopVideoCapture = "onUserStopVideoCapture",
+	
+	/** 
+	 * A publisher starts audio capture.
+	 */
+	onUserStartAudioCapture = "onUserStartAudioCapture",
+	
+	/** 
+	 * A publisher stops audio capture.
+	 */
+	onUserStopAudioCapture = "onUserStopAudioCapture",
+	onAutoPublishResult = "onAutoPublishResult",
+	onAutoSubscribeResult = "onAutoSubscribeResult",
+	
+	/** 
+	 * The state of pushing streams to CDN
+	 */
+	onLiveTranscodingResult = "onLiveTranscodingResult",
+	onSEIMessageReceived = "onSEIMessageReceived",
+	onError = "onError",
+	onAudioMixingStateChanged = "onAudioMixingStateChanged"
+}
+
+/** 
+ * Event of user connections
+ */
+export interface UserConnectionEvent {
+	
+	/** 
+	 * User information, refer to [UserInfo](#userinfo) for more details.
+	 */
+	userInfo: UserInfo;
+}
+
+/** 
+ * Event of user disconnections
+ */
+export interface UserDisconnectionEvent {
+	
+	/** 
+	 * User information, refer to [UserInfo](#userinfo) for more details.
+	 */
+	userInfo: UserInfo;
+	
+	/** 
+	 * Reason of disconnection
+	 */
+	reason: string;
+}
+
+/** 
+ * Receiving video frames carrying SEI message
+ */
+export interface onSEIMessageReceivedEvent {
+	
+	/** 
+	 * Including userId of the user who sent the message, roomId of the current room, and the media stream carrying this SEI message. Refer to RemoteStreamKey{@link RemoteStreamKey} for more details.
+	 */
+	remoteStreamKey: RemoteStreamKey;
+}
+
+/** 
+ * User mutes audio or video.
+ */
+export interface UserMuteEvent {
+	
+	/** 
+	 * User information, refer to [UserInfo](#userinfo) for more details.
+	 */
+	userInfo: UserInfo;
+	
+	/** 
+	 * Details of disabling audio or video.
+	 */
+	muteState: MuteState;
+}
+
+/** 
+ * The connection state changes.
+ */
+export interface ConnectionStateChangeEvent {
+	
+	/** 
+	 * The internal connection state
+	 */
+	state: ConnectionState;
+}
+
+/** 
+ * Event related to the player
+ */
+export interface PlayerEvent {
+	
+	/** 
+	 * Type of the player
+	 */
+	type: "video" | "audio";
+	
+	/** 
+	 * Event name
+	 */
+	eventName: string;
+	
+	/** 
+	 * Play event. Refer to the [official documentation](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/play_event) for more details.
+	 */
+	rawEvent: Event;
+	
+	/** 
+	 * userId of the user who is joining the room
+	 */
+	userId: string;
+	
+	/** 
+	 * Readies state of the medias. Refer to the [official documentation](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/readyState)
+	 */
+	readyState: number;
+	
+	/** 
+	 * The current time
+	 */
+	currentTime: number;
+	
+	/** 
+	 * Whether it is a screen-sharing stream
+	 */
+	isScreen?: boolean;
+}
+
+/** 
+ * Event of the state change of audio mixing
+ */
+export interface AudioMixingStateChangedEvent {
+	
+	/** 
+	 * Audio mixing ID
+	 */
+	mixId: number;
+	
+	/** 
+	 * State of the audio mixing
+	 */
+	state: AudioMixingState;
+	
+	/** 
+	 * Error of the audio mixing
+	 */
+	error: AudioMixingError;
+}
+
+/** 
+ * @list 104477
+ * @detail 104479
+ */
+export interface IEngineEvents {
+	
+	/** 
+	 * Player event
+	 * @param event
+	 * @region Video Management Event
+	 */
+	[EngineEventsTypes.onPlayerEvent]: (event: PlayerEvent) => void;
+	
+	/** 
+	 * The user joined.
+	 * @param event
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onUserJoined]: (event: onUserJoinedEvent) => void;
+	
+	/** 
+	 * The user leaved.
+	 * @param event
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onUserLeave]: (event: onUserLeaveEvent) => void;
+	
+	/** 
+	 * Connection state changed
+	 * @param event
+	 * @region Network Event
+	 */
+	[EngineEventsTypes.onConnectionStateChanged]: (event: ConnectionStateChangeEvent) => void;
+	
+	/** 
+	 * A new stream added into the room.
+	 * @param event `stream` object. Refer to RTCStream{@link #ref#RTCStream} for more details.
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onStreamAdd]: (event: {
+		stream: RTCStream;
+	}) => void;
+	
+	/** 
+	 * Users will receive this event when a user in the room pauses/ resumes publishing audio stream.
+	 * @param event
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onUserMuteAudio]: (event: UserMuteEvent) => void;
+	
+	/** 
+	 * Users will receive this event when a user in the room pauses/ resumes publishing video stream.
+	 * @region Room Management Event
+	 * @param event
+	 */
+	[EngineEventsTypes.onUserMuteVideo]: (event: UserMuteEvent) => void;
+	
+	/** 
+	 * Users will receive this event when a user in the room pauses/ resumes publishing audio stream.
+	 * @param event <li>stream: RTCStream{@link #ref#RTCStream}</li><li>reason: Refer to StreamRemoveReason{@link #ref#StreamRemoveReason}</li>.
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onStreamRemove]: (event: {
+		stream: RTCStream;
+		reason: StreamRemoveReason;
+	}) => void;
+	
+	/** 
+	 * Rendering of the first video frame
+	 * @param event
+	 * @region Video Management Event
+	 */
+	[EngineEventsTypes.onVideoFirstFrameRendered]: (event: onVideoFirstFrameRenderedEvent) => void;
+	
+	/** 
+	 * Decoding of the first video frame
+	 * @param event
+	 * @region Video Management Event
+	 */
+	[EngineEventsTypes.onVideoFirstFrameDecoded]: (event: onVideoFirstFrameDecodedEvent) => void;
+	
+	/** 
+	 * Decoding of the first audio frame
+	 * @param event
+	 * @region Audio Management Event
+	 */
+	[EngineEventsTypes.onAudioFirstFrameDecoded]: (event: onAudioFirstFrameDecodedEvent) => void;
+	
+	/** 
+	 * Event of device state changing
+	 * @param event Device and its state
+	 * @region Engine Management Event
+	 */
+	[EngineEventsTypes.onMediaDeviceStateChanged]: (event: RTCDevice) => void;
+	/**
+	
+	/** 
+	 * Failure of automatically playing
+	 * @param event
+	 * @region Video Management Event
+	 */
+	[EngineEventsTypes.onAutoplayFailed]: (event: PlayerEvent) => void;
+	
+	/** 
+	 * 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>
+	 * @region Video Management Event
+	 */
+	[EngineEventsTypes.onTrackEnded]: (event: {
+		kind: string;
+		isScreen: boolean;
+	}) => void;
+	
+	/** 
+	 * 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>
+	 * @region Message Event
+	 */
+	[EngineEventsTypes.onRoomMessageReceived]: (event: {
+		userId: string;
+		message: any;
+	}) => void;
+	
+	/** 
+	 * 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>
+	 * @region Message Event
+	 */
+	[EngineEventsTypes.onRoomBinaryMessageReceived]: (event: {
+		userId: string;
+		message: ArrayBuffer;
+	}) => void;
+	
+	/** 
+	 * Receiving a point-to-point text message from one of the users in the room by calling [sendUserMessage](104478#sendUserMessage)
+	 * @param event
+	 * @region Message Event
+	 */
+	[EngineEventsTypes.onUserMessageReceived]: (event: UserMessageEvent) => void;
+	
+	/** 
+	 * Receiving a point-to-point binary message from one of the users in the room
+	 * @param event
+	 * @region Message Event
+	 */
+	[EngineEventsTypes.onUserBinaryMessageReceived]: (event: UserBinaryMessageEvent) => void;
+	
+	/** 
+	 * Statistics of subscribed media streams and network states in a cycle of 2s
+	 * @param stats
+	 * @region Room Event
+	 */
+	[EngineEventsTypes.onRemoteStreamStats]: (stats: RemoteStreamStats) => void;
+	
+	/** 
+	 * Statistics of local media streams and network states in a cycle of 2s
+	 * @param stats
+	 * @region Room Event
+	 */
+	[EngineEventsTypes.onLocalStreamStats]: (stats: LocalStreamStats) => void;
+	
+	/** 
+	 * 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. Refer to AudioVolumeInfo{@link #ref#AudioVolumeInfo}.
+	 * @region Room Event
+	 */
+	[EngineEventsTypes.onAudioVolumeIndication]: (event: {
+		speakers: AudioVolumeInfo[];
+	}) => void;
+	
+	/** 
+	 * 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
+	 */
+	[EngineEventsTypes.onAudioPlaybackDeviceChanged]: (event: RTCDevice) => void;
+	
+	/** 
+	 * 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
+	 * @region Audio Management Event
+	 */
+	[EngineEventsTypes.onUserStartAudioCapture]: (event: {
+		userId: string;
+	}) => void;
+	
+	/** 
+	 * 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
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onUserStopAudioCapture]: (event: {
+		userId: string;
+	}) => void;
+	
+	/** 
+	 * 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
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onUserStartVideoCapture]: (event: {
+		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
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onUserStopVideoCapture]: (event: {
+		userId: string;
+	}) => void;
+	
+	/** 
+	 * Event of receiving SEI data from video frames
+	 * @param event Event of receiving SEI data
+	 * @region Message Event
+	 */
+	[EngineEventsTypes.onSEIMessageReceived]: (event: onSEIMessageEvent) => void;
+	
+	/** 
+	 * 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` Refer to SubscribeState{@link #ref#SubscribeState} for more details.</li>
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onAutoSubscribeResult]: (event: {
+		userId: string;
+		isScreen: boolean;
+		state: SubscribeState;
+	}) => void;
+	
+	/** 
+	 * 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` Refer to PublishState{@link #ref#PublishState} for more details.</li>
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onAutoPublishResult]: (event: {
+		isScreen: boolean;
+		state: PublishState;
+	}) => void;
+	
+	/** 
+	 * Auto-play fails.
+	 * @param event Event related to the player
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onAutoplayFailed]: (event: PlayerEvent) => void;
+	
+	/** 
+	 * Result of the Pushing stream to CDN
+	 * @param event
+	 * @region Advanced Feature Event
+	 */
+	[EngineEventsTypes.onLiveTranscodingResult]: (event: LiveTranscodingResultEvent) => void;
+	
+	/** 
+	 * event of error
+	 * @param event Error code: `DUPLICATE_LOGIN`. A user with the same userId has joined the room. The current user is kicked out.
+	 * @region Room Management Event
+	 */
+	[EngineEventsTypes.onError]: (event: {
+		errorCode: ErrorCode.DUPLICATE_LOGIN;
+	}) => void;
+	
+	/** 
+	 * Event of the state change of audio mixing
+	 * @param event
+	 * @region Advanced Feature
+	 */
+	[EngineEventsTypes.onAudioMixingStateChanged]: (event: AudioMixingStateChangedEvent) => void;
+}
+
+/** 
+ * @list 104477
+ * @detail 104478
+ */
+export interface IRTCEngine extends EnhancedEventEmitter<IEngineEvents> {
+	
+	/** 
+	 * 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>
+	 * @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   <br>
+	 *        + 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 with the error of `REPEAT_JOIN`.
+	 *        + Remote users will receive [[EngineEventsTypes.onUserJoined]](104479#engineeventstypes-onuserjoined) callback when a visible user joins the room. Call setUserVisibility{@link #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 [[EngineEventsTypes.onUserJoined]](104479#engineeventstypes-onuserjoined) if a visible user reconnected successfully. <br>
+	 * @region Room Management
+	 */
+	joinRoom(token: string | null, roomId: string, userInfo: UserInfo, roomConfig: RoomConfig): Promise<void>;
+	
+	/** 
+	 * 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   <br>
+	 *     + After visible users leave the room, other users in the room will receive [[EngineEventsTypes.onUserLeave]](104479#engineeventstypes-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>
+	 * @region Room Management
+	 */
+	leaveRoom(): void;
+	
+	/** 
+	 * 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{@link #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{@link #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>
+	 * @region Engine Management
+	 */
+	destroy(): void;
+	
+	/** 
+	 * Start publishing media streams.
+	 * @return
+	 * @notes  <br>
+	 *     + 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{@link #setUserVisibility} to change the visibility of a user.
+	 *     + Users can only publish media streams in one room at the same time. Call publishScreen{@link #publishScreen} to start screen sharing.
+	 *     + After publishing media streams by calling this API, other users in the room will be informed via [[EngineEventsTypes.onStreamAdd]](104479#engineeventstypes-onstreamadd).
+	 * @region Media Transmission
+	 */
+	publish(): Promise<void>;
+	
+	/** 
+	 * Stops publishing local media streams in the room.
+	 * @return
+	 * @notes   <br>
+	 *      + Call this API to stop publishing either started by calling publish{@link #publish} or enabling Auto-Publish.
+	 *      + After stopping publishing media streams by calling this API, other users in the room will be informed via [[EngineEventsTypes.onStreamRemove]](104479#engineeventstypes-onstreamremove).
+	 * @region Media Transmission
+	 */
+	unpublish(): Promise<void>;
+	
+	/** 
+	 * 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   <br>
+	 *      + Get the media stream information in the room from [[EngineEventsTypes.onStreamAdd]](104479#engineeventstypes-onstreamadd) and [[EngineEventsTypes.onStreamRemove]](104479#engineeventstypes-onstreamremove). <br>
+	 *      + You can update the subscription configuration by calling the API even after calling pauseAllSubscribedStream{@link #pauseAllSubscribedStream} to pause streaming. . Call resumeAllSubscribedStream{@link #resumeAllSubscribedStream} to resume streaming and apply the changes.
+	 * @region Media Transmission
+	 */
+	subscribeUserStream(userId: string, mediaType: SubscribeMediaType, streamType?: StreamIndex, configure?: SubscribeVideoConfig): Promise<void>;
+	
+	/** 
+	 * 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
+	 */
+	unSubscribe(userId: string, isScreen: boolean): Promise<void>;
+	
+	/** 
+	 * Update Token. <br>
+	 * Call this API to update the Token information of the room when the Token expires <br>
+	 * @param token A valid token <br>
+	 * @notes  <br>
+	 *      + 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.
+	 * @region Room Management
+	 */
+	updateToken(token: string): void;
+	
+	/** 
+	 * Switch the microphone used for internal audio capture  <br>
+	 * @param deviceId
+	 * @region Device Management
+	 * @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>;
+	
+	/** 
+	 * 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{@link #getdevices} to obtain.
+	 * @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
+	 */
+	switchCamera(deviceId: string): Promise<void>;
+	
+	/** 
+	 * Enable internal video capture. The default state is off.   <br>
+	 * 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 [[EngineEventsTypes.onUserStartVideoCapture]](104479#engineeventstypes-onuserstartvideocapture) after the publisher starts video capture by calling this API.<br>
+	 * @param deviceId ID of the device need to enable which you can call getDevices{@link #getdevices} to obtain.
+	 * @return
+	 * @notes <br>
+	 *     + Call stopVideoCapture{@link #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{@link #switchCamera} to switch the camera used by the internal video capture module.<br>
+	 * @region Video Management
+	 */
+	startVideoCapture(deviceId?: string): Promise<void>;
+	
+	/** 
+	 * Enable internal video capture immediately. The default setting is off.   <br>
+	 * 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 [[EngineEventsTypes.onUserStopVideoCapture]](104479#engineeventstypes-onuserstopvideocapture) after the publisher stops video capture by calling this API.<br>
+	 * @return
+	 * @notes <br>
+	 *     + 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>
+	 * @region Video Management
+	 */
+	stopVideoCapture(): Promise<void>;
+	
+	/** 
+	 * 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 [[EngineEventsTypes.onUserStartAudioCapture]](104479#engineeventstypes-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{@link #getdevices} to obtain.
+	 * @return
+	 * @notes   <br>
+	 *     + Call stopAudioCapture{@link #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
+	 */
+	startAudioCapture(deviceId?: string): Promise<void>;
+	
+	/** 
+	 * Stop internal audio capture. The default is off.   <br>
+	 * 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 [[EngineEventsTypes.onUserStopAudioCapture]](104479#engineeventstypes-onuserstopaudiocapture) after stopping audio capture by calling this API.<br>
+	 * @return
+	 * @notes   <br>
+	 *     + 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>
+	 * @region Audio Management
+	 */
+	stopAudioCapture(): Promise<void>;
+	
+	/** 
+	 * 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  <br>
+	 *     + Call this API will start screen stream video capture but will not publish the captured video. Publishing a screen-sharing stream by calling publishScreen{@link #publishScreen}. <br>
+	 *     + To turn off screen video source capture, call stopScreenCapture{@link #stopScreenCapture}. <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>
+	 * @region Advanced Feature
+	 */
+	startScreenCapture(screenConfig?: ScreenConfig): Promise<void>;
+	
+	/** 
+	 * Stop screen sharing.
+	 * @return
+	 * @notes If the stream has been published, the other users in the room will receive the [[EngineEventsTypes.onStreamRemove]](104479#engineeventstypes-onstreamremove) event after the user stop screen sharing by calling this API.
+	 * @region Advanced Feature
+	 */
+	stopScreenCapture(): Promise<void>;
+	
+	/** 
+	 * Publish screen-sharing streams.
+	 * @return
+	 * @notes  <br>
+	 *      + 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 [[EngineEventsTypes.onStreamAdd]](104479#engineeventstypes-onstreamadd) callback. <br>
+	 *      + Call unpublishScreen{@link #unpublishScreen} to unpublish.
+	 * @region Advanced Feature
+	 */
+	publishScreen(): Promise<void>;
+	
+	/** 
+	 * Stop publishing screen-sharing streams.
+	 * @return
+	 * @notes  <br>
+	 *      + To start publishing, call publishScreen{@link #publishScreen}. <br>
+	 *      + After the call, the remote receives the [[EngineEventsTypes.onStreamRemove]](104479#engineeventstypes-onstreamremove) callback.
+	 * @region Advanced Feature
+	 */
+	unpublishScreen(): Promise<void>;
+	
+	/** 
+	 * 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.
+	 * Call this API again with a blank view to unbind the view from the local video stream.
+	 * @param streamIndex Video stream properties
+	 * @param videoPlayerOption View information and rendering mode
+	 * @notes You should bind the view after the user joins a room. This setting will sustain when the user leaves the room.
+	 * @region Video Management
+	 */
+	setLocalVideoPlayer(streamIndex: StreamIndex, videoPlayerOption: VideoPlayerOption): void;
+	
+	/** 
+	 * Bind a view to the remote media stream and set the rendering mode for the rendering of the remote stream
+	 *     It's recommended to call this API and bind a view once the event of `onVideoFirstFrameRendered` is triggered.
+	 *     Call this API again with a blank view to unbind the view from the remote video stream.
+	 * @param streamIndex Video stream properties
+	 * @param videoPlayer View information and rendering mode
+	 * @notes You should bind the view after the user joins a room. This setting will sustain when the user leaves the room.
+	 * @region Video Management
+	 */
+	setRemoteVideoPlayer(streamIndex: StreamIndex, videoPlayerOption: VideoPlayerOption): void;
+	
+	/** 
+	 * Enable or disable the mirror mode for the local video stream.   <br>
+	 * @param mirrorType Whether to turn on mirror mode.
+	 * @region Media Processing
+	 */
+	setLocalVideoMirrorType(mirrorType: MirrorType): void;
+	
+	/** 
+	 * 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{@link #getDevices} to get device ID.
+	 * @return
+	 * @notes  You can call this API before or after the user joins a room.
+	 * @region Audio Management
+	 */
+	setAudioPlaybackDevice(deviceId: string): Promise<void>;
+	
+	/** 
+	 * Play audio and video stream manually.
+	 * Call this API when user need to take part in the audio and video reaction after calling [joinRoom](#joinroom) and set to autoPlay to False.
+	 * @param userId
+	 * @return
+	 * @region Room Management
+	 */
+	play(userId: string): Promise<void>;
+	
+	/** 
+	 * Enable/ Disable the transmission of the local audio stream.
+	 * Remote users in the room will be informed via [[EngineEventsTypes.onUserMuteAudio]](104479#engineeventstypes-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 <br>
+	 *        + 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>;
+	
+	/** 
+	 * 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 [[EngineEventsTypes.onUserMuteAudio]](104479#engineeventstypes-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  <br>
+	 *        + 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>;
+	
+	/** 
+	 * Pause receiving remote media streams.
+	 * @param mediaType Media stream type subscribed to.
+	 * @return
+	 * @notes   <br>
+	 *         + 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>
+	 *         + To resume, call resumeAllSubscribedStream{@link #resumeAllSubscribedStream}.
+	 * @region Media Stream Transmission
+	 */
+	pauseAllSubscribedStream(mediaType: PauseResumeControlMediaType): Promise<void>;
+	
+	/** 
+	 * Resume receiving remote media streams
+	 * @param mediaType Media stream type subscribed to
+	 * @return
+	 *  @notes  <br>
+	 *         + Calling this API does not change the capture state and the transmission state of the remote clients.
+	 *         + Calling this API does not change any subscription configuration.
+	 * @region Media Transmission
+	 */
+	resumeAllSubscribedStream(mediaType: PauseResumeControlMediaType): Promise<void>;
+	
+	/** 
+	 * Send point-to-point text messages to a specified user in the room.<br>
+	 * The recipient receives the message via [[EngineEventsTypes.onUserMessageReceived]](104479#engineeventstypes-onusermessagereceived) once the message is sent successfully.
+	 * @param userId User ID of the recipient
+	 * @param message Text to be sent within 62KB<br>
+	 * @return
+	 * @notes Call [joinRoom](#joinroom) to join the room before calling this API. <br>
+	 * @region Message
+	 */
+	sendUserMessage(userId: string, message: string): Promise<unknown> | undefined;
+	
+	/** 
+	 * Send point-to-point binary messages to a specified user in the room.<br>
+	 * The recipient receives the message via [[EngineEventsTypes.onUserBinaryMessageReceived]](104479#engineeventstypes-onuserbinarymessagereceived) once the message is sent successfully.
+	 * @param userId User ID of the recipient
+	 * @param message Binary to be sent within 62KB<br>
+	 * @return
+	 * @notes Call joinRoom {@link # RTCEngine #joinRoom} to join the room before calling this API. <br>
+	 * @region Message
+	 */
+	sendUserBinaryMessage(userId: string, message: ArrayBuffer): Promise<unknown>;
+	
+	/** 
+	 * Send text messaging to all other users in the room.<br>
+	 * Users in the room will receive message via [[EngineEventsTypes.onRoomMessageReceived]](104479#engineeventstypes-onroommessagereceived) once the message is sent successfully.
+	 * @param message Text to be sent within 62KB<br>
+	 * @return
+	 * @region Message
+	 */
+	sendRoomMessage(message: string): Promise<any> | undefined;
+	
+	/** 
+	 * Send binary messaging to all other users in the room.<br>
+	 * Users in the room will receive binary message via [[EngineEventsTypes.onRoomBinaryMessageReceived]](104479#engineeventstypes-onroombinarymessagereceived) once the message is sent successfully.
+	 * @param message Binary message to be sent within 62KB<br>
+	 * @return
+	 * @region Message
+	 */
+	sendRoomBinaryMessage(message: ArrayBuffer): Promise<any> | undefined;
+	
+	/** 
+	 * 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>
+	 *                    Calling this API to add SEI data to consecutive `repeatCount` video frames starting from the current one.
+	 * @notes <br>
+	 *         + 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.
+	 *         + Users receiving the stream will receive the SEI message via onSEIMessageReceived{@link #onSEIMessageReceived} once the SEI message is sent successfully.
+	 * @region Message
+	 */
+	sendSEIMessage(streamIndex: StreamIndex, message: Uint8Array | string, repeatCount: number): void;
+	
+	/** 
+	 * Sets the video encoder configuration of each individual stream for simulcasting, including resolution, frame rate, bitrate, scale mode, fallback strategy under poor network conditions.
+	 * @param streamIndex
+	 * @param descriptions Video parameters of each individual stream for simulcasting.
+	 *                     The length of `videoStreamDescriptions` is no more than 3. The resolutions must be in descending sort.
+	 *                     The maximum resolution is 4096px * 4096px. If the resolution exceeds the limit or the video cannot be encoded, the simulcasting will fail.
+	 * @notes   <br>
+	 *        + When using the internal capture, the resolution and frame rate will be adapted to the maximum resolution and frame rate for encoding. <br>
+	 *        + The video streams are encoded by default with a bitrate of 500bps. <br>
+	 *        + When you call this API, it will take effect immediately, which may cause the camera to restart. <br>
+	 *        + The screen stream takes the first set of parameters. <br>
+	 * @region Media Transmission
+	 */
+	setVideoEncoderConfig(streamIndex: StreamIndex, descriptions: VideoStreamDescription[]): Promise<void>;
+	
+	/** 
+	 * 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 [[EngineEventsTypes.onAudioVolumeIndication]](104479#engineeventstypes-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>
+	 *         + > 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;
+	
+	/** 
+	 * Starts pushing media streams to CDN and sets the relevant configurations.
+	 * @param transcode configuration for push media streams to CDN.
+	 * @return
+	 * @notes   <br>
+	 *        + After calling this API, you will be informed of the result and errors during the pushing process via [[engineeventstypes.onLiveTransCodingResult]](104479#engineeventstypes-onlivetranscodingresult).
+	 *        + Call stopLiveTranscoding{@link #stopLiveTranscoding} to stop pushing stream to CDN.
+	 * @region Advanced Feature
+	 */
+	startLiveTranscoding(transcode: LiveTranscodeConfig): Promise<void>;
+	
+	/** 
+	 * Update configuration needed when pushing media streams to CDN.  <br>
+	 * 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
+	 */
+	updateLiveTranscoding(transcode: Partial<LiveTranscodeConfig>): Promise<void>;
+	
+	/** 
+	 * Stop pushing media streams to CDN
+	 * For starting pushing media streams to CDN. Refer to [startLiveTranscoding](#startlivetranscoding).
+	 * @return
+	 * @region Advanced Feature
+	 */
+	stopLiveTranscoding(): Promise<void>;
+	
+	/** 
+	 * Set the business ID.   <br>
+	 * 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>
+	 * @region Engine Management
+	 */
+	setBusinessId(businessId: string): void;
+	
+	/** 
+	 * Set user visibility. Visible by default.   <br>
+	 * @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>
+	 *         + `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   <br>
+	 *        + You can call this API whether the user is in a room or not. <br>
+	 *        + When you call this API, the other users in the room will be informed via the related callback:
+	 *            - Switch from `false` to `true`: [[EngineEventsTypes.onUserJoined]](104479#engineeventstypes-onuserjoined)<br>
+	 *            - Switch from `true` to `false`: [[engineeventstypes.onUserLeave]](104479#engineeventstypes-onuserleave) <br>
+	 * @region Room Management
+	 */
+	setUserVisibility(enable: boolean): Promise<void>;
+	
+	/** 
+	 * Bind a custom videoTrack object.
+	 * @param index specify a stream index
+	 * @param track specify a video track
+	 * @return
+	 * @region Video Management
+	 */
+	setExternalVideoTrack(index: StreamIndex, track: MediaStreamTrack): Promise<void>;
+	
+	/** 
+	 * Bind a custom audioTrack object.
+	 * @param index specify a stream index
+	 * @param track specify a audio track
+	 * @return
+	 * @region Audio Management
+	 */
+	setExternalAudioTrack(index: StreamIndex, track: MediaStreamTrack): Promise<void>;
+	
+	/** 
+	 * Switch the source from the internal to custom video capture.
+	 * Internal video capture refers to using built-in video capture video.
+	 * @param index audio stream index
+	 * @param videoSourceType Type of the module for video capture
+	 * @return
+	 * @region Video Management
+	 */
+	setVideoSourceType(index: StreamIndex, videoSourceType: VideoSourceType): Promise<void>;
+	
+	/** 
+	 * Switch the source from the internal to custom audio capture.
+	 * Internal audio capture refers to using built-in audio capture.
+	 * @param index audio stream index
+	 * @param audioSourceType Type of the module for video capture
+	 * @return
+	 * @region Audio Management
+	 */
+	setAudioSourceType(index: StreamIndex, audioSourceType: AudioSourceType): Promise<void>;
+	
+	/** 
+	 * Create an audio mixing manager object
+	 * @return audio mixing manager object
+	 * @region Advanced Feature
+	 */
+	getAudioMixingManager(): IAudioMixingManager;
+	
+	/** 
+	 * Configure the internal audio capture. Different browser has its own default settings.
+	 * @param config Configuration of the internal audio capture such as, disabling audio 3A processing
+	 * @return
+	 * @note You can call this API after creating the engine. We recommend to call this API before [startAudioCapture](#startaudiocapture).
+	 * @region Audio Management
+	 */
+	setAudioCaptureConfig(config: TrackCaptureConfig): Promise<void>;
+	
+	/** 
+	 * Configure the internal video capture. Different browser has its own default settings.
+	 * @param config Configuration of the internal video capture
+	 * @return
+	 * @note You can call this API after creating the engine. We recommend to call this API before [startVideoCapture](#startvideocapture).
+	 * @region Video Management
+	 */
+	setVideoCaptureConfig(config: TrackCaptureConfig): Promise<void>;
+}
+
+/** 
+ * Video source type
+ */
+export declare enum VideoSourceType {
+	
+	/** 
+	 * Custom video source
+	 */
+	VIDEO_SOURCE_TYPE_EXTERNAL = 0,
+	
+	/** 
+	 * Internal audio capture, referring to capture video using the built-in module (the default)
+	 */
+	VIDEO_SOURCE_TYPE_INTERNAL = 1
+}
+
+/** 
+ * Audio source type
+ */
+export declare enum AudioSourceType {
+	
+	/** 
+	 * Custom audio source
+	 */
+	AUDIO_SOURCE_TYPE_EXTERNAL = 0,
+	
+	/** 
+	 * Internal audio capture, referring to capture audio using the built-in module (the default)
+	 */
+	AUDIO_SOURCE_TYPE_INTERNAL = 1
+}
+
+/** 
+ * User information
+ */
+export interface UserInfo {
+	
+	/** 
+	 * User ID, a non-empty string within 128 bytes.
+	 */
+	userId: string;
+	
+	/** 
+	 * ExtraInfo Additional information passed by the user, with a maximum length of 200 bytes. Callback to remote user in [[EngineEventsTypes.onUserJoined]](104479#engineeventstypes-onuserjoined).
+	 * @notes  Supports the following character set ranges   <br>
+	 *      + 26 uppercase letters A~ Z
+	 *      + 26 lowercase letters a~ z
+	 *      + 10 numbers 0~ 9
+	 *      + underscore "_", at character "@", minus, number "-"
+	 */
+	extraInfo?: string;
+}
+
+/** 
+ * @private
+ */
+export declare enum ChannelProfile {
+	CHANNEL_PROFILE_COMMUNICATION = 0,
+	CHANNEL_PROFILE_LIVE_BROADCASTING = 1
+}
+
+/** 
+ * Room configure
+ */
+export interface RoomConfig {
+	
+	/** 
+	 * Enable/disable auto-subscribe audio. Enable by default.
+	 */
+	isAutoPublish: boolean;
+	
+	/** 
+	 * Enable/disable auto-subscribe audio. Enable by default.
+	 * Call subscribeUserStream, unsubscribe to revise the subscription.
+	 */
+	isAutoSubscribeAudio: boolean;
+	
+	/** 
+	 * Enable/disable auto-subscribe video. Enable by default.
+	 * Call subscribeUserStream, unsubscribe to revise the subscription.
+	 */
+	isAutoSubscribeVideo: boolean;
+}
+
+/** 
+ * Subscription mode
+ */
+export declare enum SubscribeMode {
+	
+	/** 
+	 * Auto. Subscribe every stream in the room automatically.
+	 */
+	AUTO_SUBSCRIBE_MODE = 0,
+	
+	/** 
+	 * Manual. User can subscribe the stream in the room manually by calling subscribe{@link #subscribe}.
+	 */
+	MANUAL_SUBSCRIBE_MODE = 1
+}
+
+/** 
+ * Subscribe configuration
+ */
+export interface SubscribeConfig {
+	
+	/** 
+	 * Specify whether to subscribe the video stream.
+	 */
+	isScreen: boolean;
+	
+	/** 
+	 * Specify whether to subscribe the audio stream.
+	 */
+	subVideo: boolean;
+	
+	/** 
+	 * Specify whether to subscribe the screen-sharing stream.
+	 */
+	subAudio: boolean;
+}
+
+/** 
+ * Transmission/Playback state of the media stream
+ */
+export declare enum MuteState {
+	
+	/** 
+	 * Enable
+	 */
+	MUTE_STATE_OFF = 0,
+	
+	/** 
+	 * Disable
+	 */
+	MUTE_STATE_ON = 1
+}
+
+/** 
+ * Result of updating subscription
+ */
+export declare enum SubscribeState {
+	
+	/** 
+	 * Update subscription successfully.
+	 */
+	SUBSCRIBE_SUCC = 0,
+	
+	/** 
+	 * Update subscription failed.
+	 */
+	SUBSCRIBE_FAIL = 1
+}
+
+/** 
+ * Result of publishing
+ */
+export declare enum PublishState {
+	
+	/** 
+	 * Publish successfully.
+	 */
+	PUBLISH_SUCC = 0,
+	
+	/** 
+	 * Publish failed.
+	 */
+	PUBLISH_FAIL = 1
+}
+
+/** 
+ * State of Mirror mode
+ */
+export declare enum MirrorMode {
+	
+	/** 
+	 * Disable
+	 */
+	MIRROR_MODE_OFF = 0,
+	
+	/** 
+	 * Enable
+	 */
+	MIRROR_MODE_ON = 1
+}
+
+/** 
+ * Media stream type
+ */
+export declare enum PauseResumeControlMediaType {
+	
+	/** 
+	 * Audio
+	 */
+	RTC_PAUSE_RESUME_CONTROL_AUDIO = 0,
+	
+	/** 
+	 * Video
+	 */
+	RTC_PAUSE_RESUME_CONTROL_VIDEO = 1,
+	
+	/** 
+	 * Both video and audio
+	 */
+	RTC_PAUSE_RESUME_CONTROL_AUDIO_AND_VIDEO = 2
+}
+
+/** 
+ * Player information and rendering mode
+ */
+export interface VideoPlayerOption {
+	
+	/**  Dom
+	 *
+	 */
+	renderDom?: string | HTMLElement;
+	
+	/** 
+	 * Rendering modes: optional  `RENDER_MODE_HIDDEN`, `RENDER_MODE_FIT` and `RENDER_MODE_ADAPTIVE`.
+	 */
+	renderMode?: VideoRenderMode;
+	
+	/** 
+	 * User ID, a non-empty string within 128 bytes. Use the following character set ranges   <br>
+	 *      + 26 uppercase letters A~ Z
+	 *      + 26 lowercase letters a~ z
+	 *      + 10 numbers 0~ 9
+	 *      + underscore "_", at character "@", minus, number "-"
+	 */
+	userId: string;
+}
+
+/** 
+ * Rendering modes
+ */
+export declare enum VideoRenderMode {
+	
+	/** 
+	 * 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>
+	 */
+	RENDER_MODE_HIDDEN = 0,
+	
+	/** 
+	 * 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>
+	 */
+	RENDER_MODE_FIT = 1
+}
+
+/** 
+ * Audio player information
+ */
+export interface AudioPlayerOption {
+	
+	/** 
+	 * User ID
+	 */
+	userId: string;
+	
+	/** 
+	 * DOM
+	 */
+	renderDom?: string;
+}
+
+/** 
+ * Stream specification
+ */
+export declare enum StreamIndex {
+	
+	/** 
+	 * A mainstream is a media stream either captured by the internal module or from the custom source.
+	 */
+	STREAM_INDEX_MAIN = 0,
+	
+	/** 
+	 * Screen-sharing stream, including screen-sharing video streams and/ or audio streams from sound cards
+	 */
+	STREAM_INDEX_SCREEN = 1
+}
+
+/** 
+ * Type of the media stream subscribed to
+ */
+export declare enum SubscribeMediaType {
+	
+	/** 
+	 * Audio only
+	 */
+	AUDIO_ONLY = 0,
+	
+	/** 
+	 * Video only
+	 */
+	VIDEO_ONLY = 1,
+	
+	/** 
+	 * Both video and audio
+	 */
+	AUDIO_AND_VIDEO = 2,
+	
+	/** 
+	 * Neither audio nor video
+	 */
+	NONE = 3
+}
+
+/** 
+ * Subscription configuration of video streams
+ */
+export interface SubscribeVideoConfig {
+	
+	/** 
+	 * 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;
+}
+
+/** 
+ * Stream property.   <br>
+ */
+export interface RTCStream {
+	
+	/** 
+	 * User ID
+	 */
+	userId: string;
+	
+	/** 
+	 * Whether it is a screen-sharing stream
+	 */
+	isScreen: boolean;
+	
+	/** 
+	 * Whether it includes a video stream
+	 */
+	hasVideo: boolean;
+	
+	/** 
+	 * Whether it includes a audio stream
+	 */
+	hasAudio: boolean;
+	
+	/** 
+	 * Properties of the video stream.   <br>
+	 * 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. <br>
+	 * See VideoStreamDescription{@link #VideoStreamDescription}.
+	 */
+	videoStreamDescriptions?: VideoStreamDescription[];
+}
+
+/** 
+ * The reason for the removal of the remote stream in the room.   <br>
+ *
+ */
+export declare enum StreamRemoveReason {
+	
+	/** 
+	 * The remote user stops publishing the stream.   <br>
+	 */
+	STREAM_REMOVE_REASON_UNPUBLISH = 0,
+	
+	/** 
+	 * The remote user failed to publish the stream.   <br>
+	 */
+	STREAM_REMOVE_REASON_PUBLISH_FAILED = 1,
+	
+	/** 
+	 * Keep alive failed.   <br>
+	 */
+	STREAM_REMOVE_REASON_KEEP_LIVE_FAILED = 2,
+	
+	/** 
+	 * The remote user is disconnected.   <br>
+	 */
+	STREAM_REMOVE_REASON_CLIENT_DISCONNECTED = 3,
+	
+	/** 
+	 * The remote user republishes the stream.   <br>
+	 */
+	STREAM_REMOVE_REASON_REPUBLISH = 4,
+	
+	/** 
+	 * Other reasons.   <br>
+	 */
+	STREAM_REMOVE_REASON_OTHER = 5
+}
+
+/** 
+ * @type keytype
+ * SDK Connection state with the signaling server.
+ */
+export declare enum ConnectionState {
+	
+	/** 
+	 * Occupy related resource and get ready to start connecting.
+	 */
+	CONNECTION_START = 0,
+	
+	/** 
+	 * Disconnected.
+	 */
+	CONNECTION_STATE_DISCONNECTED = 1,
+	
+	/** 
+	 * Connecting of the first connection
+	 */
+	CONNECTION_STATE_CONNECTING = 2,
+	
+	/** 
+	 * Completion of the first connection
+	 */
+	CONNECTION_STATE_CONNECTED = 3,
+	
+	/** 
+	 * Reconnecting after a disconnection
+	 */
+	CONNECTION_STATE_RECONNECTING = 4,
+	
+	/** 
+	 * Completion of the reconnecting
+	 */
+	CONNECTION_STATE_RECONNECTED = 5
+}
+
+/** 
+ * Video parameters of each individual stream for simulcasting
+ */
+export interface VideoStreamDescription {
+	
+	/** 
+	 * Width
+	 */
+	width?: number;
+	
+	/** 
+	 * Height
+	 */
+	height?: number;
+	
+	/** 
+	 * Video frame rate
+	 */
+	frameRate?: number;
+	
+	/** 
+	 * Max bitrate
+	 */
+	maxKbps?: number;
+}
+
+/** 
+ * Volume information. Contains user id and volume information for each speaker
+ */
+export interface AudioVolumeInfo {
+	
+	/** 
+	 * Speaker's user id
+	 */
+	userId: string;
+	
+	/** 
+	 * Speaker's volume, ranging from 0 (lowest) - 255 (highest)
+	 */
+	volume: number;
+}
+
+/** 
+ * Configuration for screen-sharing stream
+ */
+export interface ScreenConfig {
+	
+	/** 
+	 * Set `true` for capturing the system audio when the user is using Chrome on Windows.
+	 */
+	enableAudio?: boolean;
+}
+
+/** 
+ * Video encoding configuration
+ */
+export interface VideoEncoderConfig {
+	
+	/** 
+	 * The max bitrate, unit: kbps
+	 */
+	maxKbps: number;
+}
+
+/** 
+ * Internal capture configuration for video & audio. Refer to [browser documentation](https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints) for more details.
+ */
+export declare type TrackCaptureConfig = Omit<MediaTrackConstraints, "deviceId">;
+
+/** 
+ * The mirror type
+ */
+export declare enum MirrorType {
+	
+	/** 
+	 * No mirroring effect
+	 */
+	MIRROR_TYPE_NONE = 0,
+	
+	/** 
+	 * Enable mirror effect for the local video only. RTC SDK will not add mirror effect on the video to encode and transmit to the other
+	 */
+	MIRROR_TYPE_RENDER = 1
+}
+
+/** 
+ * Configurations to be set when pushing media streams to CDN
+ */
+export interface LiveTranscodeConfig {
+	
+	/** 
+	 * CDN url where the mixed stream is supposed to be pushed.
+	 */
+	url: string;
+	
+	/** 
+	 * Audio transcoding related configurations. Refer to [LiveTranscodeVideoConfig](#LiveTranscodeVideoConfig) for more details.
+	 */
+	audio?: LiveTranscodeAudioConfig;
+	
+	/** 
+	 * Video transcoding related configurations. Refer to [LiveTranscodeVideoConfig](#LiveTranscodeVideoConfig) for more details.
+	 */
+	video?: LiveTranscodeVideoConfig;
+	
+	/** 
+	 * User layout information. Refer to [LiveTranscodeLayoutConfig](#LiveTranscodeLayoutConfig) for more details.
+	 */
+	layout?: LiveTranscodeLayoutConfig;
+}
+export declare enum LogChannel {
+	
+	/** 
+	 * domestic
+	 */
+	domestic = 0,
+	
+	/** 
+	 * overseas
+	 */
+	overseas = 1
+}
+
+/** 
+ * Video transcoding related configurations
+ */
+export interface LiveTranscodeVideoConfig {
+	
+	/** 
+	 * Width
+	 */
+	width?: number;
+	
+	/** 
+	 * Height
+	 */
+	height?: number;
+	
+	/** 
+	 * The video encoding format to be set
+	 */
+	codec?: string;
+	
+	/** 
+	 * The frame rate to be set
+	 */
+	fps?: number;
+	
+	/** 
+	 * Number of frames between two I-frames.
+	 */
+	gop?: number;
+	
+	/** 
+	 * Whether to push streams with low latency.
+	 */
+	lowLatency?: boolean;
+	
+	/** 
+	 * Bitrate (kbps) of the mixed video stream
+	 */
+	kBitRate?: number;
+}
+
+/** 
+ * Audio transcoding related configurations
+ */
+export interface LiveTranscodeAudioConfig {
+	codec?: string;
+	
+	/** 
+	 * The bitrate (kbps) to be set. The value must be 16, 32, or 64.
+	 */
+	kBitRate?: number;
+	
+	/** 
+	 *  The sample rate (kHz) to be set. The value must be 16, 32, 44.1, or 48.
+	 */
+	sampleRate?: number;
+	
+	/** 
+	 * The number of sound channels to be set. The value must be 1 or 2.
+	 */
+	channels?: number;
+	
+	/** 
+	 * The AAC profile to be set
+	 */
+	AACProfile?: "LC" | "MAIN" | "HEv1" | "HEv2";
+}
+
+/** 
+ * User layout information
+ */
+export interface LiveTranscodeLayoutConfig {
+	
+	/** 
+	 * User layout information list
+	 */
+	regions?: LiveTranscodeLayoutRegion[];
+	
+	/** 
+	 * Data passed through from the App
+	 */
+	appData?: string;
+	
+	/** 
+	 * Background color of the canvas
+	 */
+	backgroundColor?: string;
+}
+
+/** 
+ * Layout information for one of the video streams to be mixed
+ */
+export interface LiveTranscodeLayoutRegion {
+	
+	/** 
+	 * Transparency to be set. The range is [0.0, 1.0].
+	 */
+	alpha: number;
+	
+	/** 
+	 * ID of the user who published the stream
+	 */
+	userId: string;
+	
+	/** 
+	 * The normalization ratio of the x-coordinate against the whole image which ranging from [0.0,1.0)
+	 */
+	x: number;
+	
+	/** 
+	 * The normalized horizontal coordinate value of the top left end vertex of the user's view, ranging within [0.0, 1.0)
+	 */
+	y: number;
+	
+	/** 
+	 * The normalized vertical coordinate value of the top left end vertex of the user's view, ranging within [0.0, 1.0)
+	 */
+	zorder: number;
+	
+	/** 
+	 * The normalized width of the user's view, ranging within (0.0, 1.0]
+	 */
+	w: number;
+	
+	/** 
+	 * The normalized height of the user's view, ranging within (0.0, 1.0]
+	 */
+	h: number;
+	
+	/** 
+	 * 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>
+	 * + 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;
+	
+	/** 
+	 * 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>
+	 * + 2: Push video stream only.
+	 */
+	contentControl?: number;
+	
+	/** 
+	 * Whether the stream comes from screen sharing
+	 */
+	isScreenStream: boolean;
+	
+	/** 
+	 * Whether the source user of the stream is a local user.
+	 */
+	isLocalUser: boolean;
+}
+
+/** 
+ * Information of the remote stream
+ */
+export interface RemoteStreamKey {
+	
+	/** 
+	 * Room identification
+	 */
+	roomId: string;
+	
+	/** 
+	 * User identification
+	 */
+	userId: string;
+	
+	/** 
+	 * Mainstream or screen-sharing stream. Refer to [StreamIndex](#streamIndex) for details.
+	 */
+	streamIndex: StreamIndex;
+}
+
+/** 
+ * Point-to-point text message
+ */
+export interface UserMessageEvent {
+	
+	/** 
+	 * The user who sent the message
+	 */
+	userId: string;
+	
+	/** 
+	 * Point-to-point text message
+	 */
+	message: Object | string;
+}
+
+/** 
+ * Point-to-point binary message
+ */
+export interface UserBinaryMessageEvent {
+	
+	/** 
+	 * The user who sent the message
+	 */
+	userId: string;
+	
+	/** 
+	 * Point-to-point binary message
+	 */
+	message: ArrayBuffer;
+}
+
+/** 
+ * Event during pushing stream to CDN
+ */
+export interface LiveTranscodingResultEvent {
+	
+	/** 
+	 * Event number during pushing stream to CDN
+	 */
+	code: number;
+	
+	/** 
+	 * Event details during pushing stream to CDN
+	 */
+	message: string;
+}
+declare const Config: {
+	VERSION: string;
+	ICE_CONFIG_REQUEST_URLS_INTERNAL: string[];
+	ICE_CONFIG_REQUEST_URLS: never[];
+	EXPECTED_ADDR: string;
+	LOG_SERVER_URL: string;
+};
+declare function setParameter(key: keyof typeof Config, value: any): void;
+declare function getParameter(key: keyof typeof Config): string | string[] | never[];
+/**
+ * @list 104477
+ * @detail 104478
+ */
+/** 
+ * @list 104477
+ * @detail 104478
+ */
+export interface IVERTC {
+	
+	/** 
+	 * 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>
+	 *        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>
+	 *              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{@link #IRTCEngine} instance if you call this API successfully.
+	 * @notes <br>
+	 *         + Call destroyEngine{@link #destroyEngine} respectively to destroy each IRTCEngine instance.
+	 *         + As each IRTCEngine instance is resource consuming, we recommend creating no more than 2 engine instances on each device at the same time.
+	 * @region Engine Management
+	 */
+	createEngine(appId: string): IRTCEngine;
+	
+	/** 
+	 * Call this API to destroy the IRTCEngine instance created by [createEngine](#createengine).
+	 * @notes <br>
+	 *       + Before calling this API， ensure all business scenarios related to the IRTCEngine{@link #IRTCEngine} instance have ended. <br>
+	 *       + By calling this API, this IRTCEngine{@link #IRTCEngine} instance and resource related will be wiped from memory. And any interaction with the media server will end. <br>
+	 *       + 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
+	 */
+	destroyEngine(engine: IRTCEngine): void;
+	
+	/** 
+	 * Get the current version of the SDK.
+	 * @return The current SDK version.
+	 * @region Engine Management
+	 */
+	getSdkVersion(): string;
+	
+	/** 
+	 * 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).
+	 * @return A list of all media devices Refer to RTCDevice{@link ref#RCTDevice} for more details.
+	 * @region Device Management
+	 */
+	getDevices(): Promise<RTCDevice[]>;
+	
+	/** 
+	 * 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>
+	 * @region Device Management
+	 */
+	enableDevices: (options?: {
+		video: boolean;
+		audio: boolean;
+	}) => Promise<{
+		video: boolean;
+		audio: boolean;
+	}>;
+	
+	/** 
+	 * Call this API to enumerate microphone devices.
+	 * Call this API to get Device IDs used to specify the device when calling [startAudioCapture](#startaudiocapture).
+	 * @return A list including all microphone devices Refer to RTCDevice{@link ref#RCTDevice} for more details.
+	 * @region Device Management
+	 */
+	getMicrophones: () => Promise<RTCDevice[]>;
+	
+	/** 
+	 * 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).
+	 * @return A list including all camera devices. Refer to RTCDevice{@link ref#RCTDevice} for more details.
+	 * @region Device Management
+	 */
+	getCameras: () => Promise<RTCDevice[]>;
+	
+	/** 
+	 * 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).
+	 * @return A list including all audio playback devices. Refer to RTCDevice{@link ref#RCTDevice} for more details.
+	 * @region Device Management
+	 */
+	getAudioPlayback: () => Promise<RTCDevice[]>;
+	
+	/** 
+	 * Call this API to check whether the browser is supported.
+	 * @return
+	 *         + `True`: Supported
+	 *         - `False`: Not Supported
+	 * @region Engine Management
+	 */
+	isSupported: () => boolean;
+}
+declare class VERTC implements IVERTC {
+	getSdkVersion: () => string;
+	createEngine: (appId: string) => IRTCEngine;
+	destroyEngine: (engine: IRTCEngine) => void;
+	getDevices: () => Promise<RTCDevice[]>;
+	enableDevices: (options?: {
+		video: boolean;
+		audio: boolean;
+	}) => Promise<{
+		video: boolean;
+		audio: boolean;
+	}>;
+	getMicrophones: () => Promise<RTCDevice[]>;
+	getCameras: () => Promise<RTCDevice[]>;
+	getAudioPlayback: () => Promise<RTCDevice[]>;
+	getParameter: typeof getParameter;
+	setParameter: typeof setParameter;
+	isSupported: () => boolean;
+	events: typeof EngineEventsTypes;
+	ErrorCode: typeof ErrorCode;
+	platform: string;
+}
+declare const _default: VERTC;
+export default _default;
+
+export as namespace RTC;
+
+export {};