trtc-sdk-v5 5.4.2-beta.2 → 5.4.3-beta.1

package/index.d.ts

@@ -858,4 +858,875 @@
 	        track: MediaStreamTrack;
 	    }];
 	}
+ class TRTC extends EventEmitter<TRTCEventTypes> {
+	    /**
+	     * Create a TRTC object for implementing functions such as entering a room, previewing, publishing, and subscribing streams.<br>
+	     *
+	     * **Note:**
+	     * - You must create a TRTC object first and call its methods and listen to its events to implement various functions required by the business.
+	     * @example
+	     * // Create a TRTC object
+	     * const trtc = TRTC.create();
+	     *
+	     * @returns {TRTC} TRTC object
+	     */
+	    static create(options?: TRTCOptions): TRTC;
+	    /**
+	     * @typedef TurnServer
+	     * @property {string} url TURN server url
+	     * @property {string=} username TURN server auth user name
+	     * @property {string=} credential TURN server password
+	     * @property {string=} [credentialType=password] TURN server verify password type
+	     */
+	    /**
+	     * @typedef ProxyServer
+	     * @property {string} [websocketProxy] websocket service proxy
+	     * @property {string} [loggerProxy] log service agent
+	     * @property {TurnServer[]} [turnServer] media data transmission agent
+	     * @property {'all'|'relay'} [iceTransportPolicy='all'] 'all' gives priority to directly connecting to TRTC, and tries to go to the turn server if the connection fails.<br>
+	     * 'relay' forces the connection through the TURN server.
+	     */
+	    /**
+	     * Enter a video call room.<br>
+	     * - Entering a room means starting a video call session. Only after entering the room successfully can you make audio and video calls with other users in the room.
+	     * - You can publish local audio and video streams through {@link TRTC#startLocalVideo startLocalVideo()} and {@link TRTC#startLocalAudio startLocalAudio()} respectively. After successful publishing, other users in the room will receive the {@link module:EVENT.REMOTE_AUDIO_AVAILABLE REMOTE_AUDIO_AVAILABLE} and {@link module:EVENT.REMOTE_VIDEO_AVAILABLE REMOTE_VIDEO_AVAILABLE} event notifications.
+	     * - By default, the SDK automatically plays remote audio. You need to call {@link TRTC#startRemoteVideo startRemoteVideo()} to play remote video.
+	     *
+	     * @param {object} options Enter room parameters
+	     * @param {number} options.sdkAppId sdkAppId <br>
+	     * You can obtain the sdkAppId information in the **Application Information** section after creating a new application by clicking **Application Management** > **Create Application** in the [TRTC Console](https://console.intl.cloud.tencent.com/trtc).
+	     * @param {string} options.userId User ID <br>
+	     * It is recommended to limit the length to 32 bytes, and only allow uppercase and lowercase English letters (a-zA-Z), numbers (0-9), underscores, and hyphens.
+	     * @param {string} options.userSig UserSig signature <br>
+	     * Please refer to [UserSig related](https://www.tencentcloud.com/document/product/647/35166) for the calculation method of userSig.
+	     * @param {number=} options.roomId
+	     * the value must be an integer between 1 and 4294967294<br>
+	     * <font color="red">If you need to use a string type room id, please use the strRoomId parameter. One of roomId and strRoomId must be passed in. If both are passed in, the roomId will be selected first.</font>
+	     * @param {string=} options.strRoomId
+	     * String type room id, the length is limited to 64 bytes, and only supports the following characters:
+	     * - Uppercase and lowercase English letters (a-zA-Z)
+	     * - Numbers (0-9)
+	     * - Space ! # $ % & ( ) + - : ; < = . > ? @ [ ] ^ _ { } | ~ ,
+	     * <font color="red">Note: It is recommended to use a numeric type roomId. The string type room id "123" is not the same room as the numeric type room id 123.</font>
+	     * @param {string} [options.scene] Application scene, currently supports the following two scenes:
+	     * - {@link module:TYPE.SCENE_RTC TRTC.TYPE.SCENE_RTC} (default) Real-time call scene, which is suitable for 1-to-1 audio and video calls, or online meetings with up to 300 participants. {@tutorial 04-info-uplink-limits}.
+	     * - {@link module:TYPE.SCENE_LIVE TRTC.TYPE.SCENE_LIVE} Interactive live streaming scene, which is suitable for online live streaming scenes with up to 100,000 people, but you need to specify the role field in the options parameter introduced next.
+	     * @param {string=} [options.role] User role, only meaningful in the {@link module:TYPE.SCENE_LIVE TRTC.TYPE.SCENE_LIVE} scene, and the {@link module:TYPE.SCENE_RTC TRTC.TYPE.SCENE_RTC} scene does not need to specify the role. Currently supports two roles:
+	     * - {@link module:TYPE.ROLE_ANCHOR TRTC.TYPE.ROLE_ANCHOR} (default) Anchor
+	     * - {@link module:TYPE.ROLE_AUDIENCE TRTC.TYPE.ROLE_AUDIENCE} Audience
+	     * Note: The audience role does not have the permission to publish local audio and video, only the permission to watch remote streams. If the audience wants to interact with the anchor by connecting to the microphone, please switch the role to the anchor through {@link TRTC#switchRole switchRole()} before publishing local audio and video.
+	     * @param {boolean} [options.autoReceiveAudio=true] Whether to automatically receive audio. When a remote user publishes audio, the SDK automatically plays the remote user's audio.
+	     * @param {boolean} [options.autoReceiveVideo=true] Whether to automatically receive video. When a remote user publishes video, the SDK automatically subscribes and decodes the remote video. You need to call {@link TRTC#startLocalVideo startLocalVideo} to play the remote video.
+	     * @param {boolean} [options.enableAutoPlayDialog] Whether to enable the SDK's automatic playback failure dialog box, default: true.
+	     * - Enabled by default. When automatic playback fails, the SDK will pop up a dialog box to guide the user to click the page to restore audio and video playback.
+	     * - Can be set to false in order to turn off. Refer to {@tutorial 21-advanced-auto-play-policy}.
+	     * @param {string|ProxyServer} [options.proxy] proxy config. Refer to {@tutorial 34-advanced-proxy}.
+	     * @param {boolean} [options.privateMapKey] Key for entering a room. If permission control is required, please carry this parameter (empty or incorrect value will cause a failure in entering the room).<br>[privateMapKey permission configuration](https://www.tencentcloud.com/document/product/647/35157?lang=en&pg=).
+	     * @throws
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * - {@link module:ERROR_CODE.ENV_NOT_SUPPORTED ENV_NOT_SUPPORTED}
+	     * - {@link module:ERROR_CODE.SERVER_ERROR SERVER_ERROR}
+	     * @example
+	     * const trtc = TRTC.create();
+	     * await trtc.enterRoom({ roomId: 8888, sdkAppId, userId, userSig });
+	     */
+	    enterRoom(params: EnterRoomConfig): Promise<void>;
+	    /**
+	     * Exit the current audio and video call room.
+	     * - After exiting the room, the connection with remote users will be closed, and remote audio and video will no longer be received and played, and the publishing of local audio and video will be stopped.
+	     * - The capture and preview of the local camera and microphone will not stop. You can call {@link TRTC#stopLocalVideo stopLocalVideo()} and {@link TRTC#stopLocalAudio stopLocalAudio()} to stop capturing local microphone and camera.
+	     * @throws {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * @memberof TRTC
+	     * @example
+	     * await trtc.exitRoom();
+	     */
+	    exitRoom(): Promise<void>;
+	    /**
+	     * Switches the user role, only effective in TRTC.TYPE.SCENE_LIVE interactive live streaming mode.
+	     *
+	     * In interactive live streaming mode, a user may need to switch between "audience" and "anchor".
+	     * You can determine the role through the role field in {@link TRTC#enterRoom enterRoom()}, or switch roles after entering the room through switchRole.
+	     * - Audience switches to anchor, call trtc.switchRole(TRTC.TYPE.ROLE_ANCHOR) to convert the user role to TRTC.TYPE.ROLE_ANCHOR anchor role, and then call {@link TRTC#startLocalVideo startLocalVideo()} and {@link TRTC#startLocalAudio startLocalAudio()} to publish local audio and video as needed.
+	     * - Anchor switches to audience, call trtc.switchRole(TRTC.TYPE.ROLE_AUDIENCE) to convert the user role to TRTC.TYPE.ROLE_AUDIENCE audience role. If there is already published local audio and video, the SDK will cancel the publishing of local audio and video.
+	     * > !
+	     * > - This interface can only be called after entering the room successfully.
+	     * > - After closing the camera and microphone, it is recommended to switch to the audience role in time to avoid the anchor role occupying the resources of 50 upstreams.
+	     * @param {string} role User role
+	     * - TRTC.TYPE.ROLE_ANCHOR anchor, can publish local audio and video, up to 50 anchors can publish local audio and video in a single room at the same time.
+	     * - TRTC.TYPE.ROLE_AUDIENCE audience, cannot publish local audio and video, can only watch remote streams, and there is no upper limit on the number of audience members in a single room.
+	     * @param {object} [option]
+	     * @param {string} [option.privateMapKey] `Since v5.3.0+` <br>
+	     * The privateMapKey may expire after a timeout, so you can use this parameter to update the privateMapKey.
+	     * @throws
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.INVALID_OPERATION INVALID_OPERATION}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * - {@link module:ERROR_CODE.SERVER_ERROR SERVER_ERROR}
+	     * @memberof TRTC
+	     * @example
+	     * // After entering the room successfully
+	     * // TRTC.TYPE.SCENE_LIVE interactive live streaming mode, audience switches to anchor
+	     * await trtc.switchRole(TRTC.TYPE.ROLE_ANCHOR);
+	     * // Switch from audience role to anchor role and start streaming
+	     * await trtc.startLocalVideo();
+	     *
+	     * // TRTC.TYPE.SCENE_LIVE interactive live streaming mode, anchor switches to audience
+	     * await trtc.switchRole(TRTC.TYPE.ROLE_AUDIENCE);
+	     * @example
+	     * // Since v5.3.0+
+	     * await trtc.switchRole(TRTC.TYPE.ROLE_ANCHOR, { privateMapKey: 'your new privateMapKey' });
+	     */
+	    switchRole(role: UserRole, option?: {
+	        privateMapKey: string;
+	    }): Promise<void>;
+	    /**
+	     * Destroy the TRTC instance <br/>
+	     *
+	     * After exiting the room, if the business side no longer needs to use trtc, you need to call this interface to destroy the trtc instance in time and release related resources.
+	     *
+	     * Note:
+	     *  - The trtc instance after destruction cannot be used again.
+	     *  - If you have entered the room, you need to call the {@link TRTC#exitRoom TRTC.exitRoom} interface to exit the room successfully before calling this interface to destroy trtc.
+	     *
+	     * @example
+	     * // When the call is over
+	     * await trtc.exitRoom();
+	     * // If the trtc is no longer needed, destroy the trtc and release the reference.
+	     * trtc.destroy();
+	     * trtc = null;
+	     * @throws {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * @memberof TRTC
+	     */
+	    destroy(): void;
+	    /**
+	     * Start collecting audio from the local microphone and publish it to the current room.
+	     * - When to call: can be called before or after entering the room, cannot be called repeatedly.
+	     * - Only one microphone can be opened for a trtc instance. If you need to open another microphone for testing in the case of already opening one microphone, you can create multiple trtc instances to achieve it.
+	     *
+	     * @param {object} [config] - Configuration item
+	     * @param {boolean} [config.publish] - Whether to publish local audio to the room, default is true. If you call this interface before entering the room and publish = true, the SDK will automatically publish after entering the room. You can get the publish state by listening this event {@link module:EVENT.PUBLISH_STATE_CHANGED PUBLISH_STATE_CHANGED}.
+	     * @param {boolean} [config.mute] - Whether to mute microphone. Refer to: {@tutorial 15-basic-dynamic-add-video}.
+	     * @param {object} [config.option] - Local audio options
+	     * @param {string} [config.option.microphoneId]- Specify which microphone to use
+	     * @param {MediaStreamTrack} [config.option.audioTrack] - Custom audioTrack. {@tutorial 20-advanced-customized-capture-rendering}.
+	     * @param {number} [config.option.captureVolume] - Set the capture volume of microphone. The default value is 100. Setting above 100 enlarges the capture volume. Since v5.2.1+.
+	     * @param {number} [config.option.earMonitorVolume] - Set the ear return volume, value range [0, 100], the local microphone is muted by default.
+	     * @param {string} [config.option.profile] - Audio encoding configuration, default {@link module:TYPE.AUDIO_PROFILE_STANDARD TRTC.TYPE.AUDIO_PROFILE_STANDARD}
+	     * @throws
+	     * - {@link module:ERROR_CODE.ENV_NOT_SUPPORTED ENV_NOT_SUPPORTED}
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.DEVICE_ERROR DEVICE_ERROR}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * - {@link module:ERROR_CODE.SERVER_ERROR SERVER_ERROR}
+	     * @example
+	     * // Collect the default microphone and publish
+	     * await trtc.startLocalAudio();
+	     * @example
+	     * // The following is a code example for testing microphone volume, which can be used for microphone volume detection.
+	     * trtc.enableAudioVolumeEvaluation();
+	     * trtc.on(TRTC.EVENT.AUDIO_VOLUME, event => { });
+	     * // No need to publish audio for testing microphone
+	     * await trtc.startLocalAudio({ publish: false });
+	     * // After the test is completed, turn off the microphone
+	     * await trtc.stopLocalAudio();
+	     * @memberof TRTC
+	     */
+	    startLocalAudio(config?: LocalAudioConfig): Promise<void>;
+	    /**
+	     * Update the configuration of the local microphone.
+	     * - When to call: This interface needs to be called after {@link TRTC#startLocalAudio startLocalAudio()} is successful and can be called multiple times.
+	     * - This method uses incremental update: only update the passed parameters, and keep the parameters that are not passed unchanged.
+	     * @param {object} [config]
+	     * @param {boolean} [config.publish] - Whether to publish local audio to the room. You can get the publish state by listening this event {@link module:EVENT.PUBLISH_STATE_CHANGED PUBLISH_STATE_CHANGED}.
+	     * @param {boolean} [config.mute] - Whether to mute microphone. Refer to: {@tutorial 15-basic-dynamic-add-video}.
+	     * @param {object} [config.option] - Local audio configuration
+	     * @param {string} [config.option.microphoneId] - Specify which microphone to use to switch microphones.
+	     * @param {MediaStreamTrack} [config.option.audioTrack] - Custom audioTrack. {@tutorial 20-advanced-customized-capture-rendering}.
+	     * @param {number} [config.option.captureVolume] - Set the capture volume of microphone. The default value is 100. Setting above 100 enlarges the capture volume. Since v5.2.1+.
+	     * @param {number} [config.option.earMonitorVolume] - Set the ear return volume, value range [0, 100], the local microphone is muted by default.
+	     * @throws
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.DEVICE_ERROR DEVICE_ERROR}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * @example
+	     * // Switch microphone
+	     * const microphoneList = await TRTC.getMicrophoneList();
+	     * if (microphoneList[1]) {
+	     *   await trtc.updateLocalAudio({ option: { microphoneId: microphoneList[1].deviceId }});
+	     * }
+	     * @memberof TRTC
+	     */
+	    updateLocalAudio(config: UpdateLocalAudioConfig): Promise<void>;
+	    /**
+	     * Stop collecting and publishing the local microphone.
+	     * - If you just want to mute the microphone, please use updateLocalAudio({ mute: true }). Refer to: {@tutorial 15-basic-dynamic-add-video}.
+	     * @throws {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * @example
+	     * await trtc.stopLocalAudio();
+	     */
+	    stopLocalAudio(): Promise<void>;
+	    /**
+	     * @typedef {object|string} VideoProfile - Configuration for local video stream
+	     *
+	     * Video configuration parameters, can use preset values in string format or custom resolution and other parameters
+	     * | Video Profile | Resolution (Width x Height) | Frame Rate (fps) | Bitrate (kbps) | Remarks |
+	     * | :---       | :---           | :---      | :---      | :--- |
+	     * | 120p       | 160 x 120      | 15        | 200        ||
+	     * | 180p       | 320 x 180      | 15        | 350       ||
+	     * | 240p       | 320 x 240      | 15        | 400       ||
+	     * | 360p       | 640 x 360      | 15        | 800       ||
+	     * | 480p       | 640 x 480      | 15        | 900       ||
+	     * | 720p       | 1280 x 720     | 15        | 1500      ||
+	     * | 1080p      | 1920 x 1080    | 15        | 2000      ||
+	     * | 1440p      | 2560 x 1440    | 30        | 4860      ||
+	     * | 4K         | 3840 x 2160    | 30        | 9000      ||
+	      * @property {number} width - Video width
+	      * @property {number} height - Video height
+	      * @property {number} frameRate - Video frame rate
+	      * @property {number} bitrate - Video bitrate
+	     * @example
+	     * const config = {
+	     *  option: {
+	     *   profile: '480p',
+	     *  },
+	     * }
+	     * await trtc.startLocalVideo(config);
+	     * @example
+	     * const config = {
+	     *  option: {
+	     *    profile: {
+	     *      width: 640,
+	     *      height: 480,
+	     *      frameRate: 15,
+	     *      bitrate: 900,
+	     *    }
+	     *  }
+	     * }
+	     * await trtc.startLocalVideo(config);
+	     */
+	    /**
+	     * Start collecting video from the local camera, play the camera's video on the specified HTMLElement tag, and publish the camera's video to the current room.
+	     * - When to call: can be called before or after entering the room, but cannot be called repeatedly.
+	     * - Only one camera can be started per trtc instance. If you need to start another camera for testing while one camera is already started, you can create multiple trtc instances to achieve this.
+	  
+	     * @param {object} [config]
+	     * @param {string | HTMLElement | HTMLElement[] | null} [config.view] - The HTMLElement instance or ID for local video preview. If not passed or passed as null, the video will not be played.
+	     * @param {boolean} [config.publish] - Whether to publish the local video to the room. If you call this interface before entering the room and publish = true, the SDK will automatically publish after entering the room. You can get the publish state by listening this event {@link module:EVENT.PUBLISH_STATE_CHANGED PUBLISH_STATE_CHANGED}.
+	     * @param {boolean | string} [config.mute] - Whether to mute camera. Supports passing in image url string, the image will be published instead of origin camera stream, Other users in the room will receive the REMOTE_AUDIO_AVAILABLE event. It does not support calling when the camera is turned off. More information: {@tutorial 15-basic-dynamic-add-video}.
+	     * @param {object} [config.option] - Local video configuration
+	     * @param {string} [config.option.cameraId] - Specify which camera to use for switching cameras.
+	     * @param {boolean} [config.option.useFrontCamera] - Whether to use the front camera.
+	     * @param {MediaStreamTrack} [config.option.videoTrack] - Custom videoTrack. {@tutorial 20-advanced-customized-capture-rendering}.
+	     * @param {'view' | 'publish' | 'both' | boolean} [config.option.mirror] - Video mirroring mode, default is 'view'.
+	     * - 'view': Local preview mirroring
+	     * - 'publish': Remote viewing of self mirroring
+	     * - 'both': Both local preview and remote viewing of self mirroring
+	     * - false: Boolean value, represents no mirroring
+	     *
+	     * <font color="orange"> Note: Before version 5.3.2, only boolean can be passed, where true represents local preview mirroring, and false represents no mirroring.</font>
+	     * @param {'contain' | 'cover' | 'fill'} [config.option.fillMode] - Video fill mode. The default is `cover`. Refer to the {@link https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit CSS object-fit} property.
+	     * @param {VideoProfile} [config.option.profile] - Video encoding parameters for the main video.
+	     * @param {VideoProfile} [config.option.small] - Video encoding parameters for the small video. Refer to {@tutorial 27-advanced-small-stream}
+	     * @param {QOS_PREFERENCE_SMOOTH|QOS_PREFERENCE_CLEAR} [config.option.qosPreference] - Set the video encoding strategy for weak networks. Smooth first(default) ({@link module:TYPE.QOS_PREFERENCE_SMOOTH QOS_PREFERENCE_SMOOTH}) or Clear first ({@link module:TYPE.QOS_PREFERENCE_CLEAR QOS_ PREFERENCE_SMOOTH})
+	     * @throws
+	     * - {@link module:ERROR_CODE.ENV_NOT_SUPPORTED ENV_NOT_SUPPORTED}
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.DEVICE_ERROR DEVICE_ERROR}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * - {@link module:ERROR_CODE.SERVER_ERROR SERVER_ERROR}
+	     * @example
+	     * // Preview and publish the camera
+	     * await trtc.startLocalVideo({
+	     *   view: document.getElementById('localVideo'), // Preview the video on the element with the DOM elementId of localVideo.
+	     * });
+	     * @example
+	     * // Preview the camera without publishing. Can be used for camera testing.
+	     * const config = {
+	     *   view: document.getElementById('localVideo'), // Preview the video on the element with the DOM elementId of localVideo.
+	     *   publish: false // Do not publish the camera
+	     * }
+	     * await trtc.startLocalVideo(config);
+	     * // Call updateLocalVideo when you need to publish the video
+	     * await trtc.updateLocalVideo({ publish:true });
+	     * @example
+	     * // Use a specified camera.
+	     * const cameraList = await TRTC.getCameraList();
+	     * if (cameraList[0]) {
+	     *   await trtc.startLocalVideo({
+	     *     view: document.getElementById('localVideo'), // Preview the video on the element with the DOM elementId of localVideo.
+	     *     option: {
+	     *       cameraId: cameraList[0].deviceId,
+	     *     }
+	     *   });
+	     * }
+	     *
+	     * // use front camera on mobile device.
+	     * await trtc.startLocalVideo({ view, option: { useFrontCamera: true }});
+	     * // use rear camera on mobile device.
+	     * await trtc.startLocalVideo({ view, option: { useFrontCamera: false }});
+	     * @memberof TRTC
+	     */
+	    startLocalVideo(config?: LocalVideoConfig): Promise<void>;
+	    /**
+	     * Update the local camera configuration.
+	     * - This interface needs to be called after {@link TRTC#startLocalVideo startLocalVideo()} is successful.
+	     * - This interface can be called multiple times.
+	     * - This method uses incremental update: only updates the passed-in parameters, and keeps the parameters that are not passed in unchanged.
+	     * @param {object} [config]
+	     * @param {string | HTMLElement | HTMLElement[] | null} [config.view] - The HTMLElement instance or Id of the preview camera. If not passed in or passed in null, the video will not be rendered, but the container that consumes bandwidth will still be pushed.
+	     * @param {boolean} [config.publish] - Whether to publish the local video to the room. You can get the publish state by listening this event {@link module:EVENT.PUBLISH_STATE_CHANGED PUBLISH_STATE_CHANGED}.
+	     * @param {boolean | string} [config.mute] - Whether to mute camera. Supports passing in image url string, the image will be published instead of origin camera stream, Other users in the room will receive the REMOTE_AUDIO_AVAILABLE event. It does not support calling when the camera is turned off. More information: {@tutorial 15-basic-dynamic-add-video}.
+	     * @param {object} [config.option] - Local video configuration
+	     * @param {string} [config.option.cameraId] - Specify which camera to use
+	     * @param {boolean} [config.option.useFrontCamera] - Whether to use the front camera
+	     * @param {MediaStreamTrack} [config.option.videoTrack] - Custom videoTrack. {@tutorial 20-advanced-customized-capture-rendering}.
+	     * @param {boolean} [config.option.mirror] - Whether to enable mirror
+	     * @param {'contain' | 'cover' | 'fill'} [config.option.fillMode] - Video fill mode. Refer to the {@link https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit| CSS object-fit} property
+	     * @param {VideoProfile} [config.option.profile] - Video encoding parameters for the main stream
+	     * @param {VideoProfile|boolean} [config.option.small] - Video encoding parameters for the small video. Refer to {@tutorial 27-advanced-small-stream}
+	     * @param {QOS_PREFERENCE_SMOOTH|QOS_PREFERENCE_CLEAR} [config.option.qosPreference] - Set the video encoding strategy for weak networks. Smooth first ({@link module:TYPE.QOS_PREFERENCE_SMOOTH QOS_PREFERENCE_SMOOTH}) or Clear first ({@link module:TYPE.QOS_PREFERENCE_CLEAR QOS_ PREFERENCE_SMOOTH})
+	     * @throws
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.DEVICE_ERROR DEVICE_ERROR}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * @example
+	     * // Switch camera
+	     * const cameraList = await TRTC.getCameraList();
+	     * if (cameraList[1]) {
+	     *   await trtc.updateLocalVideo({ option: { cameraId: cameraList[1].deviceId }});
+	     * }
+	     * @example
+	     * // Stop publishing video, but keep local preview
+	     * await trtc.updateLocalVideo({ publish:false });
+	     * @memberof TRTC
+	     */
+	    updateLocalVideo(config: LocalVideoConfig): Promise<void>;
+	    /**
+	     * Stop capturing, previewing, and publishing the local camera.
+	     * - If you only want to stop publishing video but keep the local camera preview, you can use the {@link TRTC#updateLocalVideo updateLocalVideo({ publish:false })} method.<br>
+	     * @throws {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * @example
+	     * await trtc.stopLocalVideo();
+	     */
+	    stopLocalVideo(): Promise<void>;
+	    /**
+	     * @typedef {object|string} ScreenShareProfile - Screen sharing resolution, bit rate, and frame rate configuration
+	     * Screen sharing configuration parameters, can use preset values or custom resolution and other parameters
+	     * | Screen Profile | Resolution (width x height) | Frame Rate (fps) | Bitrate (kbps) |
+	     * | :---       | :---           | :---      | :---        |
+	     * | 480p       | 640 x 480      | 5         | 900         |
+	     * | 480p_2     | 640 x 480      | 30        | 1000        |
+	     * | 720p       | 1280 x 720     | 5         | 1200        |
+	     * | 720p_2     | 1280 x 720     | 30        | 3000        |
+	     * | 1080p      | 1920 x 1080    | 5         | 1600        |
+	     * | 1080p_2    | 1920 x 1080    | 30        | 4000        |
+	     * - The default resolution for screen sharing is `1080p`.
+	     * - If the above profiles do not meet your business needs, you can also specify custom resolution, frame rate, and bitrate.
+	  
+	     * @property {number} width - Screen sharing width
+	     * @property {number} height - Screen sharing height
+	     * @property {number} frameRate - Screen sharing frame rate
+	     * @property {number} bitrate - Screen sharing bitrate
+	     * @example
+	     * const config = {
+	     *  option: {
+	     *   profile: '720p',
+	     *  },
+	     * }
+	     * await trtc.startScreenShare(config);
+	     */
+	    /**
+	     * Start screen sharing.
+	     *
+	     * - After starting screen sharing, other users in the room will receive the {@link module:EVENT.REMOTE_VIDEO_AVAILABLE REMOTE_VIDEO_AVAILABLE} event, with streamType as {@link module:TYPE.STREAM_TYPE_SUB STREAM_TYPE_SUB}, and other users can play screen sharing through {@link TRTC#startRemoteVideo startRemoteVideo}.
+	     * @param {object} [config]
+	     * @param {string | HTMLElement | HTMLElement[] | null} [config.view] - The HTMLElement instance or Id for previewing local screen sharing. If not passed or passed as null, local screen sharing will not be rendered.
+	     * @param {boolean} [config.publish] - Whether to publish screen sharing to the room. The default is true. If you call this interface before entering the room and publish = true, the SDK will automatically publish after entering the room. You can get the publish state by listening this event {@link module:EVENT.PUBLISH_STATE_CHANGED PUBLISH_STATE_CHANGED}.
+	     * @param {object} [config.option] - Screen sharing configuration
+	     * @param {boolean} [config.option.systemAudio] - Whether to capture system audio. The default is false.
+	     * @param {'contain' | 'cover' | 'fill'} [config.option.fillMode] - Video fill mode. The default is `contain`, refer to {@link https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit CSS object-fit} property.
+	     * @param {ScreenShareProfile} [config.option.profile] - Screen sharing encoding configuration.
+	     * @param {QOS_PREFERENCE_SMOOTH|QOS_PREFERENCE_CLEAR} [config.option.qosPreference] - Set the video encoding strategy for weak networks. Smooth first ({@link module:TYPE.QOS_PREFERENCE_SMOOTH QOS_PREFERENCE_SMOOTH}) or Clear first(default) ({@link module:TYPE.QOS_PREFERENCE_CLEAR QOS_ PREFERENCE_SMOOTH})
+	     * @param {HTMLElement} [config.option.captureElement] - Capture screen from the specified element of current tab. Available on Chrome 104+.
+	     * @param {'current-tab' | 'tab' | 'window' | 'monitor'} [config.option.preferDisplaySurface='monitor'] - The prefer display surface for screen sharing. Available on Chrome 94+.
+	     * - The default is monitor, which means that monitor capture will be displayed first in the Screen Sharing Capture pre-checkbox。
+	     * - If you fill in 'current-tab', the pre-checkbox will only show the current page.
+	     * @throws
+	     * - {@link module:ERROR_CODE.ENV_NOT_SUPPORTED ENV_NOT_SUPPORTED}
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.DEVICE_ERROR DEVICE_ERROR}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * - {@link module:ERROR_CODE.SERVER_ERROR SERVER_ERROR}
+	     * @example
+	     * // Start screen sharing
+	     * await trtc.startScreenShare();
+	     * @memberof TRTC
+	     */
+	    startScreenShare(config?: ScreenShareConfig): Promise<void>;
+	    /**
+	     * Update screen sharing configuration
+	     * - This interface needs to be called after {@link TRTC#startScreenShare startScreenShare()} is successful.
+	     * - This interface can be called multiple times.
+	     * - This method uses incremental update: only update the passed-in parameters, and keep the parameters that are not passed-in unchanged.
+	     * @param {object} [config]
+	     * @param {string | HTMLElement | HTMLElement[] | null} [config.view] - The HTMLElement instance or Id for screen sharing preview. If not passed in or passed in null, the screen sharing will not be rendered.
+	     * @param {boolean} [config.publish=true] - Whether to publish screen sharing to the room
+	     * @param {object} [config.option] - Screen sharing configuration
+	     * @param {'contain' | 'cover' | 'fill'} [config.option.fillMode] - Video fill mode. The default is `contain`, refer to {@link https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit CSS object-fit} property.
+	     * @param {QOS_PREFERENCE_SMOOTH|QOS_PREFERENCE_CLEAR} [config.option.qosPreference] - Set the video encoding strategy for weak networks. Smooth first ({@link module:TYPE.QOS_PREFERENCE_SMOOTH QOS_PREFERENCE_SMOOTH}) or Clear first ({@link module:TYPE.QOS_PREFERENCE_CLEAR QOS_ PREFERENCE_SMOOTH})
+	     * @throws
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.DEVICE_ERROR DEVICE_ERROR}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * - {@link module:ERROR_CODE.SERVER_ERROR SERVER_ERROR}
+	     * @example
+	     * // Stop screen sharing, but keep the local preview of screen sharing
+	     * await trtc.updateScreenShare({ publish:false });
+	     * @memberof TRTC
+	     */
+	    updateScreenShare(config: UpdateScreenShareConfig): Promise<void>;
+	    /**
+	     * Stop screen sharing.
+	  
+	     * @throws {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * @example
+	     * await trtc.stopScreenShare();
+	     */
+	    stopScreenShare(): Promise<void>;
+	    /**
+	     * Play remote video
+	     *
+	     * - When to call: Call after receiving the {@link module:EVENT.REMOTE_VIDEO_AVAILABLE TRTC.on(TRTC.EVENT.REMOTE_VIDEO_AVAILABLE)} event.
+	     * @param {object} [config]
+	     * @param {string | HTMLElement | HTMLElement[] | null} [config.view] - The HTMLElement instance or Id used to play remote video. If not passed or passed null, the video will not be rendered, but the bandwidth will still be consumed.
+	     * @param {string} config.userId - Remote user ID
+	     * @param {TRTC.TYPE.STREAM_TYPE_MAIN|TRTC.TYPE.STREAM_TYPE_SUB} config.streamType - Remote stream type
+	     * - {@link module:TYPE.STREAM_TYPE_MAIN TRTC.TYPE.STREAM_TYPE_MAIN}: Main stream (remote user's camera)
+	     * - {@link module:TYPE.STREAM_TYPE_SUB TRTC.TYPE.STREAM_TYPE_SUB}: Sub stream (remote user's screen sharing)
+	     * @param {object} [config.option] - Remote video configuration
+	     * @param {boolean} [config.option.small] - Whether to subscribe small streams
+	     * @param {boolean} [config.option.mirror] - Whether to enable mirror
+	     * @param {'contain' | 'cover' | 'fill'} [config.option.fillMode] - Video fill mode. Refer to the {@link https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit CSS object-fit} property.
+	     * @param {boolean} [config.option.receiveWhenViewVisible] - Since v5.4.0 <br>Subscribe video only when view is visible. Refer to: {@tutorial 27-advanced-small-stream}.
+	     * @param {HTMLElement} [config.option.viewRoot=document.body] - Since v5.4.0 <br>The root element is the parent element of the view and is used to calculate whether the view is visible relative to the root. The default value is document.body, and it is recommended that you use the first-level parent of the video view list. Refer to: {@tutorial 27-advanced-small-stream}.
+	     * @throws
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.INVALID_OPERATION INVALID_OPERATION}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * - {@link module:ERROR_CODE.SERVER_ERROR SERVER_ERROR}
+	     * @example
+	     * trtc.on(TRTC.EVENT.REMOTE_VIDEO_AVAILABLE, ({ userId, streamType }) => {
+	     *   // You need to place the video container in the DOM in advance, and it is recommended to use `${userId}_${streamType}` as the element id.
+	     *   trtc.startRemoteVideo({ userId, streamType, view: `${userId}_${streamType}` });
+	     * })
+	     * @memberof TRTC
+	     */
+	    startRemoteVideo(config: RemoteVideoConfig): Promise<void>;
+	    /**
+	     * Update remote video playback configuration<br>
+	     * - This method should be called after {@link TRTC#startRemoteVideo startRemoteVideo} is successful.
+	     * - This method can be called multiple times.
+	     * - This method uses incremental updates, so only the configuration items that need to be updated need to be passed in.
+	     * @param {object} [config]
+	     * @param {string | HTMLElement | HTMLElement[] | null} [config.view] - The HTMLElement instance or Id used to play remote video. If not passed or passed null, the video will not be rendered, but the bandwidth will still be consumed.
+	     * @param {string} config.userId - Remote user ID
+	     * @param {TRTC.TYPE.STREAM_TYPE_MAIN|TRTC.TYPE.STREAM_TYPE_SUB} config.streamType - Remote stream type
+	     * - {@link module:TYPE.STREAM_TYPE_MAIN TRTC.TYPE.STREAM_TYPE_MAIN}: Main stream (remote user's camera)
+	     * - {@link module:TYPE.STREAM_TYPE_SUB TRTC.TYPE.STREAM_TYPE_SUB}: Sub stream (remote user's screen sharing)
+	     * @param {object} [config.option] - Remote video configuration
+	     * @param {boolean} [config.option.small] - Whether to subscribe small streams. Refer to: {@tutorial 27-advanced-small-stream}.
+	     * @param {boolean} [config.option.mirror] - Whether to enable mirror
+	     * @param {'contain' | 'cover' | 'fill'} [config.option.fillMode] - Video fill mode. Refer to the {@link https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit CSS object-fit} property.
+	     * @param {boolean} [config.option.receiveWhenViewVisible] - Since v5.4.0 <br>Subscribe video only when view is visible. Refer to: {@tutorial 27-advanced-small-stream}.
+	     * @param {HTMLElement} [config.option.viewRoot=document.body] - Since v5.4.0 <br>The root element is the parent element of the view and is used to calculate whether the view is visible relative to the root. The default value is document.body, and it is recommended that you use the first-level parent of the video view list. Refer to: {@tutorial 27-advanced-small-stream}.
+	     * @throws
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.INVALID_OPERATION INVALID_OPERATION}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * @example
+	     * const config = {
+	     *  view: document.getElementById(userId),
+	     *  userId,
+	     * }
+	     * await trtc.updateRemoteVideo(config);
+	     * @memberof TRTC
+	     */
+	    updateRemoteVideo(config: RemoteVideoConfig): Promise<void>;
+	    /**
+	     * Used to stop remote video playback.<br>
+	     * @param {object} config - Remote video configuration
+	     * @param {string} config.userId - Remote user ID, '*' represents all users.
+	     * @param {TRTC.TYPE.STREAM_TYPE_MAIN|TRTC.TYPE.STREAM_TYPE_SUB} [config.streamType] - Remote stream type. This field is required when userId is not '*'.
+	     * - {@link module:TYPE.STREAM_TYPE_MAIN TRTC.TYPE.STREAM_TYPE_MAIN}: Main stream (remote user's camera)
+	     * - {@link module:TYPE.STREAM_TYPE_SUB TRTC.TYPE.STREAM_TYPE_SUB}: Sub stream (remote user's screen sharing)
+	     * @throws {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * @example
+	     * // Stop playing all remote users
+	     * await trtc.stopRemoteVideo({ userId: '*' });
+	     */
+	    stopRemoteVideo(config: StopRemoteVideoConfig): Promise<void>;
+	    /**
+	     * Mute a remote user and stop subscribing audio data from that user. Only effective for the current user, other users in the room can still hear the muted user's voice.<br>
+	     *
+	     * Note:
+	     * - By default, after entering the room, the SDK will automatically play remote audio. You can call this interface to mute or unmute remote users.
+	     * - If the parameter autoReceiveAudio = false is passed in when entering the room, remote audio will not be played automatically. When audio playback is required, you need to call this method (mute is passed in false) to play remote audio.
+	     * - This interface is effective before or after entering the room (enterRoom), and the mute state will be reset to false after exiting the room (exitRoom).
+	     * - If you want to continue subscribing audio data from the user but not play it, you can call setRemoteAudioVolume(userId, 0)
+	     * @param {string} userId - Remote user ID, '*' represents all users.
+	     * @param {boolean} mute - Whether to mute
+	     * @throws
+	     * - {@link module:ERROR_CODE.INVALID_PARAMETER INVALID_PARAMETER}
+	     * - {@link module:ERROR_CODE.INVALID_OPERATION INVALID_OPERATION}
+	     * - {@link module:ERROR_CODE.OPERATION_FAILED OPERATION_FAILED}
+	     * - {@link module:ERROR_CODE.OPERATION_ABORT OPERATION_ABORT}
+	     * @example
+	     * // Mute all remote users
+	     * await trtc.muteRemoteAudio('*', true);
+	     */
+	    muteRemoteAudio(userId: string, mute: boolean): Promise<void>;
+	    /**
+	     * Used to control the playback volume of remote audio.<br>
+	     *
+	     * - Not supported by iOS Safari
+	     * @param {string} userId - Remote user ID。'*' represents all remote users.
+	     * @param {number} volume - Volume, ranging from 0 to 100. The default value is 100.<br>
+	     * Since `v5.1.3+`, the volume can be set higher than 100.
+	     * @example
+	     * await trtc.setRemoteAudioVolume('123', 90);
+	     */
+	    setRemoteAudioVolume(userId: string, volume: number): void;
+	    startPlugin<T extends keyof PluginStartOptionsMap, O extends PluginStartOptionsMap[T]>(plugin: O extends undefined ? never : T, options: O): Promise<any>;
+	    startPlugin<T extends keyof PluginStartOptionsMap, O extends PluginStartOptionsMap[T]>(plugin: O extends undefined ? T : never): Promise<any>;
+	    updatePlugin<T extends keyof PluginUpdateOptionsMap, O extends PluginUpdateOptionsMap[T]>(plugin: O extends undefined ? never : T, options: O): Promise<any>;
+	    updatePlugin<T extends keyof PluginUpdateOptionsMap, O extends PluginUpdateOptionsMap[T]>(plugin: O extends undefined ? T : never): Promise<any>;
+	    stopPlugin<T extends keyof PluginStopOptionsMap, O extends PluginStopOptionsMap[T]>(plugin: O extends undefined ? never : T, options: O): Promise<any>;
+	    stopPlugin<T extends keyof PluginStopOptionsMap, O extends PluginStopOptionsMap[T]>(plugin: O extends undefined ? T : never): Promise<any>;
+	    /**
+	     * Enables or disables the volume callback.<br>
+	     *
+	     * - After enabling this function, whether someone is speaking in the room or not, the SDK will regularly throw the {@link module:EVENT.AUDIO_VOLUME TRTC.on(TRTC.EVENT.AUDIO_VOLUME)} event, which feedbacks the volume evaluation value of each user.<br>
+	     *
+	     * @param {number} [interval=2000] Used to set the time interval for triggering the volume callback event. The default is 2000(ms), and the minimum value is 100(ms). If set to less than or equal to 0, the volume callback will be turned off.
+	     * @param {boolean} [enableInBackground=false] For performance reasons, when the page switches to the background, the SDK will not throw volume callback events. If you need to receive volume callback events when the page is switched to the background, you can set this parameter to true.
+	     * @memberof TRTC
+	     * @example
+	     * trtc.on(TRTC.EVENT.AUDIO_VOLUME, event => {
+	     *    event.result.forEach(({ userId, volume }) => {
+	     *        const isMe = userId === ''; // When userId is an empty string, it represents the local microphone volume.
+	     *        if (isMe) {
+	     *            console.log(`my volume: ${volume}`);
+	     *        } else {
+	     *            console.log(`user: ${userId} volume: ${volume}`);
+	     *        }
+	     *    })
+	     * });
+	     *
+	     * // Enable volume callback and trigger the event every 1000ms
+	     * trtc.enableAudioVolumeEvaluation(1000);
+	     *
+	     * // To turn off the volume callback, pass in an interval value less than or equal to 0
+	     * trtc.enableAudioVolumeEvaluation(-1);
+	     */
+	    enableAudioVolumeEvaluation(interval?: number, enableInBackground?: boolean): void;
+	    /**
+	     * Listen to TRTC events<br><br>
+	     * For a detailed list of events, please refer to: {@link module:EVENT TRTC.EVENT}
+	     *
+	     * @param {string} eventName Event name
+	     * @param {function} handler Event callback function
+	     * @param {context} context Context
+	     * @memberof TRTC
+	     * @example
+	     * trtc.on(TRTC.EVENT.REMOTE_VIDEO_AVAILABLE, event => {
+	     *   // REMOTE_VIDEO_AVAILABLE event handler
+	     * });
+	     */
+	    on<T extends keyof TRTCEventTypes>(event: T, handler: (...args: TRTCEventTypes[T]) => void, context?: any): this;
+	    /**
+	     * Remove event listener<br>
+	     *
+	     * @param {string} eventName Event name. Passing in the wildcard '*' will remove all event listeners.
+	     * @param {function} handler Event callback function
+	     * @param {context} context Context
+	     * @memberof TRTC
+	     * @example
+	     * trtc.on(TRTC.EVENT.REMOTE_USER_ENTER, function peerJoinHandler(event) {
+	     *   // REMOTE_USER_ENTER event handler
+	     *   console.log('remote user enter');
+	     *
+	     *   trtc.off(TRTC.EVENT.REMOTE_USER_ENTER, peerJoinHandler);
+	     * });
+	     *
+	     * // Remove all event listeners
+	     * trtc.off('*');
+	     */
+	    off<T extends keyof TRTCEventTypes>(event: T | '*', handler: T extends '*' ? never : (...args: TRTCEventTypes[T]) => void, context?: any): this;
+	    /**
+	     * Get video track
+	     *
+	     * @param {string} [config] If not passed, get the local camera videoTrack
+	     * @param {string} [config.userId] If not passed or passed an empty string, get the local videoTrack. Pass the userId of the remote user to get the remote user's videoTrack.
+	     * @param {STREAM_TYPE_MAIN|STREAM_TYPE_SUB} [config.streamType] - Remote stream type:
+	     * - {@link module:TYPE.STREAM_TYPE_MAIN TRTC.TYPE.STREAM_TYPE_MAIN}: Main stream (remote user's camera)(default)
+	     * - {@link module:TYPE.STREAM_TYPE_SUB TRTC.TYPE.STREAM_TYPE_SUB}: Sub stream (remote user's screen sharing)
+	     * @returns {MediaStreamTrack|null} Video track
+	     * @memberof TRTC
+	     * @example
+	     * // Get local camera videoTrack
+	     * const videoTrack = trtc.getVideoTrack();
+	     * // Get local screen sharing videoTrack
+	     * const screenVideoTrack = trtc.getVideoTrack({ streamType: TRTC.TYPE.STREAM_TYPE_SUB });
+	     * // Get remote user's main stream videoTrack
+	     * const remoteMainVideoTrack = trtc.getVideoTrack({ userId: 'test', streamType: TRTC.TYPE.STREAM_TYPE_MAIN });
+	     * // Get remote user's sub stream videoTrack
+	     * const remoteSubVideoTrack = trtc.getVideoTrack({ userId: 'test', streamType: TRTC.TYPE.STREAM_TYPE_SUB });
+	    */
+	    getVideoTrack(config?: {
+	        userId?: string;
+	        streamType?: TRTCStreamType;
+	    }): MediaStreamTrack | null;
+	    /**
+	     * Get audio track
+	     *
+	     * @returns {MediaStreamTrack?} Audio track
+	     * @param {string} [userId] If not passed, get the local audioTrack
+	     * @memberof TRTC
+	     */
+	    getAudioTrack(userId?: string): MediaStreamTrack | null;
+	    setCurrentSpeaker(speakerId: string): void;
+	    /**
+	     * Send SEI Message <br>
+	     *
+	     * > The header of a video frame has a header block called SEI.
+	     * > The principle of this interface is to use the SEI to embed the custom data you want to send along with the video frame.
+	     * > SEI messages can accompany video frames all the way to the live CDN.
+	     *
+	     * Applicable scenarios: synchronization of lyrics, live answering questions, etc.
+	     *
+	     * When to call: call after {@link TRTC#startLocalVideo trtc.startLocalVideo} successfully.
+	     *
+	     * Note:
+	     * 1. Maximum 1KB(Byte) sent in a single call, maximum 30 calls per second, maximum 8KB sent per second.
+	     * 2. Currently only support Chrome 86+, Edge 86+, Opera 72+ browsers.
+	     * 3. Since SEI is sent along with video frames, there is a possibility that video frames may be lost, and therefore SEI may be lost as well. The number of times it can be sent can be increased within the frequency limit, and the business side needs to do message de-duplication on the receiving side.
+	     * 4. SEI cannot be sent without trtc.startLocalVideo; SEI cannot be received without startRemoteVideo.
+	     * 5. Only H264 encoder is supported to send SEI.
+	     * 6. SEI sending and receiving is not supported for small streams for the time being.
+	     * @see {@link module:EVENT.SEI_MESSAGE TRTC.EVENT.SEI_MESSAGE}
+	     * @since v5.3.0
+	     * @param {ArrayBuffer} buffer SEI data to be sent
+	     * @param {Object=} options
+	     * @param {Number} options.seiPayloadType Set the SEI payload type. SDK uses the custom payloadType 243 by default, the business side can use this parameter to set the payloadType to the standard 5. When the business side uses the 5 payloadType, you need to follow the specification to make sure that the first 16 bytes of the `buffer` are the business side's customized uuid.
+	     * @example
+	     * // 1. enable SEI
+	     * const trtc = TRTC.create({
+	     *    enableSEI: true
+	     * })
+	     *
+	     * // 2. send SEI
+	     * try {
+	     *  await trtc.enterRoom({
+	     *   userId: 'user_1',
+	     *   roomId: 12345,
+	     * })
+	     *  await trtc.startLocalVideo();
+	     *  const unit8Array = new Uint8Array([1, 2, 3]);
+	     *  trtc.sendSEIMessage(unit8Array.buffer);
+	     * } catch(error) {
+	     *  console.warn(error);
+	     * }
+	     *
+	     * // 3. receive SEI
+	     * trtc.on(TRTC.EVENT.SEI_MESSAGE, event => {
+	     *  console.warn(`sei ${event.data} from ${event.userId}`);
+	     * })
+	     */
+	    sendSEIMessage(buffer: ArrayBuffer, options?: {
+	        seiPayloadType: number;
+	    }): void;
+	    /**
+	     * Get video snapshot <br>
+	     * Notice: must play the video before it can obtain the snapshot. If there is no playback, an empty string will be returned.
+	     * @param {string} config.userId - Remote user ID
+	     * @param {TRTC.TYPE.STREAM_TYPE_MAIN|TRTC.TYPE.STREAM_TYPE_SUB} config.streamType
+	     * - {@link module:TYPE.STREAM_TYPE_MAIN TRTC.TYPE.STREAM_TYPE_MAIN}: Main stream
+	     * - {@link module:TYPE.STREAM_TYPE_SUB TRTC.TYPE.STREAM_TYPE_SUB}: Sub stream
+	     * @since 5.4.0
+	     * @example
+	     * // get self main stream video frame
+	     * trtc.getVideoSnapshot()
+	     * // get self sub stream video frame
+	     * trtc.getVideoSnapshot({streamType:TRTC.TYPE.STREAM_TYPE_SUB})
+	     * // get remote user main stream video frame
+	     * trtc.getVideoSnapshot({userId: 'remote userId', streamType:TRTC.TYPE.STREAM_TYPE_MAIN})
+	     * @memberof TRTC
+	     */
+	    getVideoSnapshot(config?: VideoFrameConfig): string;
+	    static EVENT: {
+	        readonly ERROR: "error";
+	        readonly AUTOPLAY_FAILED: "autoplay-failed";
+	        readonly KICKED_OUT: "kicked-out";
+	        readonly REMOTE_USER_ENTER: "remote-user-enter";
+	        readonly REMOTE_USER_EXIT: "remote-user-exit";
+	        readonly REMOTE_AUDIO_AVAILABLE: "remote-audio-available";
+	        readonly REMOTE_AUDIO_UNAVAILABLE: "remote-audio-unavailable";
+	        readonly REMOTE_VIDEO_AVAILABLE: "remote-video-available";
+	        readonly REMOTE_VIDEO_UNAVAILABLE: "remote-video-unavailable";
+	        readonly AUDIO_VOLUME: "audio-volume";
+	        readonly NETWORK_QUALITY: "network-quality";
+	        readonly CONNECTION_STATE_CHANGED: "connection-state-changed";
+	        readonly AUDIO_PLAY_STATE_CHANGED: "audio-play-state-changed";
+	        readonly VIDEO_PLAY_STATE_CHANGED: "video-play-state-changed";
+	        readonly SCREEN_SHARE_STOPPED: "screen-share-stopped";
+	        readonly DEVICE_CHANGED: "device-changed";
+	        readonly PUBLISH_STATE_CHANGED: "publish-state-changed";
+	        readonly STATISTICS: "statistics";
+	        readonly SEI_MESSAGE: "sei-message";
+	        readonly TRACK: "track";
+	    };
+	    static ERROR_CODE: {
+	        INVALID_PARAMETER: number;
+	        INVALID_OPERATION: number;
+	        ENV_NOT_SUPPORTED: number;
+	        DEVICE_ERROR: number;
+	        SERVER_ERROR: number;
+	        OPERATION_FAILED: number;
+	        OPERATION_ABORT: number;
+	        UNKNOWN_ERROR: number;
+	    };
+	    static TYPE: {
+	        readonly SCENE_LIVE: Scene.LIVE;
+	        readonly SCENE_RTC: Scene.RTC;
+	        readonly ROLE_ANCHOR: UserRole.ANCHOR;
+	        readonly ROLE_AUDIENCE: UserRole.AUDIENCE;
+	        readonly STREAM_TYPE_MAIN: TRTCStreamType.Main;
+	        readonly STREAM_TYPE_SUB: TRTCStreamType.Sub;
+	        readonly AUDIO_PROFILE_STANDARD: "standard";
+	        readonly AUDIO_PROFILE_STANDARD_STEREO: "standard-stereo";
+	        readonly AUDIO_PROFILE_HIGH: "high";
+	        readonly AUDIO_PROFILE_HIGH_STEREO: "high-stereo";
+	        readonly QOS_PREFERENCE_SMOOTH: "smooth";
+	        readonly QOS_PREFERENCE_CLEAR: "clear";
+	    };
+	    static frameWorkType: number;
+	    /**
+	     * Set the log output level
+	     * <br>
+	     * It is recommended to set the DEBUG level during development and testing, which includes detailed prompt information.
+	     * The default output level is INFO, which includes the log information of the main functions of the SDK.
+	     *
+	     * @param {0-5} [level] Log output level 0: TRACE 1: DEBUG 2: INFO 3: WARN 4: ERROR 5: NONE
+	     * @param {boolean} [enableUploadLog=true] Whether to enable log upload, which is enabled by default. It is not recommended to turn it off, which will affect problem troubleshooting.
+	     * @example
+	     * // Output log levels above DEBUG
+	     * TRTC.setLogLevel(1);
+	     */
+	    static setLogLevel(level: LOG_LEVEL, enableUploadLog?: boolean): void;
+	    /**
+	     * Check if the TRTC Web SDK is supported by the current browser
+	     *
+	     * - Reference: {@tutorial 05-info-browser}.
+	     * @example
+	     * TRTC.isSupported().then((checkResult) => {
+	     *   if(!checkResult.result) {
+	     *      console.log('checkResult', checkResult.result, 'checkDetail', checkResult.detail);
+	     *      // The SDK is not supported by the current browser, guide the user to use the latest version of Chrome browser.
+	     *   }
+	     * });
+	     *
+	     * @returns {Promise.<object>} Promise returns the detection result
+	     * | Property                                   | Type    | Description                         |
+	     * |--------------------------------------------|---------|-------------------------------------|
+	     * | checkResult.result                         | boolean | Detection result                             |
+	     * | checkResult.detail.isBrowserSupported      | boolean | Whether the current browser is supported by the SDK        |
+	     * | checkResult.detail.isWebRTCSupported       | boolean | Whether the current browser supports WebRTC               |
+	     * | checkResult.detail.isWebCodecsSupported    | boolean | Whether the current browser supports WebCodecs            |
+	     * | checkResult.detail.isMediaDevicesSupported | boolean | Whether the current browser supports obtaining media devices and media streams     |
+	     * | checkResult.detail.isScreenShareSupported | boolean | Whether the current browser supports screen sharing    |
+	     * | checkResult.detail.isSmallStreamSupported | boolean | Whether the current browser supports small streams     |
+	     * | checkResult.detail.isH264EncodeSupported   | boolean | Whether the current browser supports H264 encoding for uplink         |
+	     * | checkResult.detail.isH264DecodeSupported   | boolean | Whether the current browser supports H264 decoding for downlink         |
+	     * | checkResult.detail.isVp8EncodeSupported    | boolean | Whether the current browser supports VP8 encoding for uplink          |
+	     * | checkResult.detail.isVp8DecodeSupported    | boolean | Whether the current browser supports VP8 decoding for downlink          |
+	     */
+	    static isSupported(): Promise<{
+	        result: boolean;
+	        detail: {
+	            isBrowserSupported: boolean;
+	            isWebRTCSupported: boolean;
+	            isWebCodecsSupported: boolean;
+	            isMediaDevicesSupported: boolean;
+	            isScreenShareSupported: boolean;
+	            isSmallStreamSupported: boolean;
+	            isH264EncodeSupported: boolean;
+	            isVp8EncodeSupported: boolean;
+	            isH264DecodeSupported: boolean;
+	            isVp8DecodeSupported: boolean;
+	        };
+	    }>;
+	    /**
+	     * Returns the list of camera devices
+	     * <br>
+	     * **Note**
+	     * - This interface does not support use under the http protocol, please use the https protocol to deploy your website. {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia#Privacy_and_security Privacy and security}
+	     * - Calling this method may temporarily open the camera to ensure that the camera list can be normally obtained, and the SDK will automatically stop the camera capture later.
+	     * - You can call the browser's native interface [getCapabilities](https://developer.mozilla.org/en-US/docs/Web/API/InputDeviceInfo/getCapabilities) to get the maximum resolutions supported by the camera, frame rate, mobile devices to distinguish between front and rear cameras, etc. This interface supports Chrome 67+, Edge 79+, Safari 17+, Opera 54+.
+	     * @example
+	     * const cameraList = await TRTC.getCameraList();
+	     * if (cameraList[0] && cameraList[0].getCapabilities) {
+	     *   const { width, height, frameRate, facingMode } = cameraList[0].getCapabilities();
+	     *   console.log(width.max, height.max, frameRate.max);
+	     *   if (facingMode) {
+	     *     if (facingMode[0] === 'user') {
+	     *       // front camera
+	     *     } else if (facingMode[0] === 'environment') {
+	     *       // rear camera
+	     *     }
+	     *   }
+	     * }
+	     * @returns {Promise.<MediaDeviceInfo[]>} Promise returns an array of {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo|MediaDeviceInfo}
+	     */
+	    static getCameraList(): Promise<DeviceInfo[]>;
+	    /**
+	     * Returns the list of microphone devices
+	     * <br>
+	     * **Note**
+	     * - This interface does not support use under the http protocol, please use the https protocol to deploy your website. {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia#Privacy_and_security Privacy and security}
+	     * - Calling this method may temporarily open the microphone to ensure that the microphone list can be normally obtained, and the SDK will automatically stop the microphone capture later.
+	     * - You can call the browser's native interface [getCapabilities](https://developer.mozilla.org/en-US/docs/Web/API/InputDeviceInfo/getCapabilities) to get information about the microphone's capabilities, e.g. the maximum number of channels supported, etc. This interface supports Chrome 67+, Edge 79+, Safari 17+, Opera 54+.
+	     * @example
+	     * const microphoneList = await TRTC.getMicrophoneList();
+	     * if (microphoneList[0] && microphoneList[0].getCapabilities) {
+	     *   const { channelCount } = microphoneList[0].getCapabilities();
+	     *   console.log(channelCount.max);
+	     * }
+	     * @returns {Promise.<MediaDeviceInfo[]>} Promise returns an array of {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo|MediaDeviceInfo}
+	     */
+	    static getMicrophoneList(): Promise<DeviceInfo[]>;
+	    /**
+	     * Returns the list of speaker devices
+	     * <br>
+	     * Calling this method may temporarily open the microphone to ensure that the speaker list can be normally obtained, and the SDK will automatically release the microphone capture later.
+	     * @returns {Promise.<MediaDeviceInfo[]>} Promise returns an array of {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo|MediaDeviceInfo}
+	     */
+	    static getSpeakerList(): Promise<DeviceInfo[]>;
+	    /**
+	     *  Set the current speaker for audio playback
+	     *
+	     * @param {string} speakerId Speaker ID
+	     */
+	    static setCurrentSpeaker(speakerId: string): Promise<void>;
+	}
 export default TRTC