@byteplus/react-native-live-push 1.1.3-rc.4 → 1.3.0-rc.0

package/lib/commonjs/typescript/codegen/ios/keytype.d.ts

@@ -1,448 +1,1142 @@
 import { int, BOOL, NSDictionary, float, CMTime, GLuint, CVPixelBufferRef, CMSampleBufferRef, NSData, NSArray, NSString } from './types';
 export declare enum VeLiveVideoEffectLicenseType {
     
+    /** {en}
+     * @brief Authenticate offline.
+     *
+     */
     VeLiveVideoEffectLicenseTypeOffLine = 0,
     
+    /** {en}
+     * @brief Authenticate online.
+     *
+     */
     VeLiveVideoEffectLicenseTypeOnLine = 1
 }
 export declare enum VeLiveNetworkQuality {
     
+    /** {en}
+     * @brief Network status not found.
+     *
+     */
     VeLiveNetworkQualityUnknown = -1,
     
+    /** {en}
+     * @brief Bad network condition.
+     *
+     */
     VeLiveNetworkQualityBad = 0,
     
+    /** {en}
+     * @brief Poor network condition.
+     *
+     */
     VeLiveNetworkQualityPoor = 1,
     
+    /** {en}
+     * @brief Good network condition.
+     *
+     */
     VeLiveNetworkQualityGood = 2
 }
 export declare enum VeLiveAudioChannel {
     
+    /** {en}
+     * @brief Mono, which is suitable for voice communication and saves bandwidth.
+     *
+     */
     VeLiveAudioChannelMono = 1,
     
+    /** {en}
+     * @brief Stereo, which provides a richer audio experience and is suitable for music playback.
+     *
+     */
     VeLiveAudioChannelStereo = 2
 }
 export declare enum VeLiveVideoEncodeFrameType {
     
+    /** {en}
+     * @brief IDR frame.
+     *
+     */
     VeLiveVideoEncodeFrameTypeIDR = 1,
     
+    /** {en}
+     * @brief SPS/PPS frame.
+     *
+     */
     VeLiveVideoEncodeFrameTypeSPSPPS = 2,
     
+    /** {en}
+     * @brief B frame.
+     *
+     */
     VeLiveVideoEncodeFrameTypeB = 3,
     
+    /** {en}
+     * @brief P frame.
+     *
+     */
     VeLiveVideoEncodeFrameTypeP = 4
 }
 export declare class VeLiveVideoEncoderConfiguration {
     
+    /** {en}
+     * @brief The video resolution. See [VeLiveVideoResolution](#VeLiveVideoResolution) for details. The default value is `VeLiveVideoResolution720P`.
+     */
     resolution: VeLiveVideoResolution;
     
+    /** {en}
+     * @brief The video codec. The default value is `VeLiveVideoCodecH264`. See [VeLiveVideoCodec](#VeLiveVideoCodec) for details.
+     */
     codec: VeLiveVideoCodec;
     
+    /** {en}
+     * @brief The target video encoding bitrate, in Kbps. The default value depends on the value of the `resolution` parameter.
+     */
     bitrate: int;
     
+    /** {en}
+     * @brief The minimum video encoding bitrate, in Kbps, when the adaptive bitrate (ABR) feature is enabled. The default value depends on the value of the `resolution` parameter.
+     */
     minBitrate: int;
     
+    /** {en}
+     * @brief The maximum video encoding bitrate, in Kbps, when the adaptive bitrate (ABR) feature is enabled. The default value depends on the value of the `resolution` parameter.
+     */
     maxBitrate: int;
     
+    /** {en}
+     * @brief The video GOP size, in seconds. The default value is `2`.
+     */
     gopSize: int;
     
+    /** {en}
+     * @brief The encoded frame rate, in fps. The default value is `15`.
+     */
     fps: int;
     
+    /** {en}
+     * @brief Whether to enable B frames. <br>
+     *     - YES: Enable.
+     *     - NO: (Default) Disable.
+     */
     enableBFrame: BOOL;
     
+    /** {en}
+     * @brief Whether to enable hardware encoding.<br>
+     *        - YES: (Default) Enable;
+     *        - NO: Disable.
+     */
     enableAccelerate: BOOL;
     
+    /** {en}
+     * @brief Creates a VeLiveVideoEncoderConfiguration {@link #VeLiveVideoEncoderConfiguration} object and specifies the video resolution.
+     * @param resolution The video resolution. See VeLiveVideoResolution {@link #VeLiveVideoResolution} for details.
+     * @return  <br>
+     *        The VeLiveVideoEncoderConfiguration {@link #VeLiveVideoEncoderConfiguration} object.
+     */
     initWithResolution(resolution: VeLiveVideoResolution): this;
 }
 export declare enum VeLiveVideoFrameSource {
     
+    /** {en}
+     * @brief The original video frame captured by the camera or other video sources.
+     *
+     */
     VeLiveVideoFrameSourceCapture = 1,
     
+    /** {en}
+     * @brief The video frame prior to encoding after undergoing various processes, such as filtering and rotation.
+     *
+     */
     VeLiveVideoFrameSourcePreEncode = 2
 }
 export declare enum VeLiveAudioBufferType {
     
+    /** {en}
+     * @brief Unknown data type.
+     *
+     */
     VeLiveAudioBufferTypeUnknown = -1,
     
+    /** {en}
+     * @brief CMSampleBufferRef.
+     *
+     */
     VeLiveAudioBufferTypeSampleBuffer = 0,
     
+    /** {en}
+     * @brief NSData.
+     *
+     */
     VeLiveAudioBufferTypeNSData = 1
 }
 export declare class VeLivePusherConfiguration {
     
+    /** {en}
+     * @brief The video capture configurations. See [VeLiveVideoCaptureConfiguration](#VeLiveVideoCaptureConfiguration) for details.
+     */
     videoCaptureConfig: VeLiveVideoCaptureConfiguration;
     
+    /** {en}
+     * @brief The audio capture configurations. See [VeLiveAudioCaptureConfiguration](#VeLiveAudioCaptureConfiguration) for details.
+     */
     audioCaptureConfig: VeLiveAudioCaptureConfiguration;
     
+    /** {en}
+     * @brief The time interval between each attempt to reconnect, in seconds. The default value is `5`.
+     */
     reconnectIntervalSeconds: int;
     
+    /** {en}
+     * @brief The number of attempts to reconnect after the initial attempt fails. The default value is `3`.
+     */
     reconnectCount: int;
     
+    /** {en}
+     * @brief Advanced parameters. You can leave this parameter empty.
+     */
     extraParameters: NSDictionary;
     init(): this;
 }
 export declare enum VeLiveVideoCaptureType {
     
+    /** {en}
+     * @brief Capture the video with the front-facing camera.
+     *
+     */
     VeLiveVideoCaptureFrontCamera = 0,
     
+    /** {en}
+     * @brief Capture the video with the rear camera.
+     *
+     */
     VeLiveVideoCaptureBackCamera = 1,
     
+    /** {en}
+     * @brief Capture the video with dual cameras.
+     *
+     */
     VeLiveVideoCaptureDualCamera = 2,
     
+    /** {en}
+     * @brief Capture the video with an external device or source.
+     *
+     */
     VeLiveVideoCaptureExternal = 4,
     
+    /** {en}
+     * @brief Use a static image as the video source.
+     *
+     */
     VeLiveVideoCaptureCustomImage = 5,
     
+    /** {en}
+     * @brief Use the last frame as the video source.
+     *
+     */
     VeLiveVideoCaptureLastFrame = 6,
     
+    /** {en}
+     * @brief Use a black frame as the video source. This is usually used for debugging purposes or in special circumstances.
+     *
+     */
     VeLiveVideoCaptureDummyFrame = 7
 }
 export declare class VeLiveFileRecorderConfiguration {
     
+    /** {en}
+     * @brief The width of the recorded video, in pixels. The default value is `360`.
+     */
     width: int;
     
+    /** {en}
+     * @brief The height of the recorded video, in pixels. The default value is `640`.
+     */
     height: int;
     
+    /** {en}
+     * @deprecated
+     * @brief The frame rate of the recorded video. The default value is `15`. The value range is [1,15].
+     */
     fps: int;
     
+    /** {en}
+     * @brief The encoding bitrate of the recorded video, in Kbps. The default value is `2000`.
+     */
     bitrate: int;
     init(): this;
 }
 export declare enum VeLiveVideoBufferType {
     
+    /** {en}
+     * @brief Unknown data type, which is the default type if you do not specify any type.
+     *
+     */
     VeLiveVideoBufferTypeUnKnown = -1,
     
+    /** {en}
+     * @brief CVPixelBuffer.
+     *
+     */
     VeLiveVideoBufferTypePixelBuffer = 0,
     
+    /** {en}
+     * @brief CMSampleBufferRef.
+     *
+     */
     VeLiveVideoBufferTypeSampleBuffer = 1,
     
+    /** {en}
+     * @brief NSData.
+     *
+     */
     VeLiveVideoBufferTypeNSData = 2,
     
+    /** {en}
+     * @brief OpenGL texture.
+     *
+     */
     VeLiveVideoBufferTypeTexture = 3
 }
 export declare class VeLiveMixVideoLayout {
     
+    /** {en}
+     * @brief The unique identifier for a video stream.
+     */
     streamId: int;
     
+    /** {en}
+     * @brief The horizontal offset, which represents the ratio of the distance between the left edge of the video and the left edge of the screen to the width of the screen. The value range is [0.0,1.0], where `0.0` indicates the left edge and `1.0` indicates the right edge.
+     */
     x: float;
     
+    /** {en}
+     * @brief The vertical offset, which represents the ratio of the distance between the top edge of the video and the top edge of the screen to the height of the screen. The value range is [0.0,1.0], where `0.0` indicates the top edge and `1.0` indicates the bottom edge.
+     */
     y: float;
     
+    /** {en}
+     * @brief The ratio of the video width to the screen width. The value range is [0.0,1.0], where `1.0` indicates that the video occupies the entire screen width.
+     */
     width: float;
     
+    /** {en}
+     * @brief The ratio of the video height to the screen height. The value range is [0.0,1.0], where `1.0` indicates that the video occupies the entire screen height.
+     */
     height: float;
     
+    /** {en}
+     * @brief The video transparency. The value range is [0.0, 1.0], where `0.0` indicates full transparency and `1.0` indicates full opacity.
+     */
     alpha: float;
     
+    /** {en}
+     * @brief The level of video within the final mixed video. The value range is [0,100], where `0` represents the bottom layer. The higher the value, the higher the level of the video in the final output.
+     */
     zOrder: int;
     
+    /** {en}
+     * @brief The render mode of the video. See [VeLivePusherRenderMode](#VeLivePusherRenderMode) for details.
+     */
     renderMode: VeLivePusherRenderMode;
+    
+    /** {en}
+     * @brief Whether to retain the original Alpha channel value of the video stream. The default is retain. When the value of [alpha](#VeLiveMixVideoLayout-alpha) is within the range of [0.0, 1.0], this configuration is ignored.<br/>
+     *
+     *        - YES: Retain;
+     *        - NO: Do not retain.
+     */
+    enableAlpha: BOOL;
     init(): this;
 }
 export declare class VeLiveMixAudioLayout {
     
+    /** {en}
+     * @brief The unique identifier for an audio stream.
+     */
     streamId: int;
     
+    /** {en}
+     * @detail api
+     * @brief The volume of the mixed audio stream. The value range is [0.0,4.0]. If you set [VeLiveAudioMixType](#VeLiveAudioMixType) to `VeLiveAudioMixPlayAndPush`, this property takes effect on both the host and the audience sides.
+     */
     volume: float;
     init(): this;
 }
 export declare enum VeLiveAudioProfile {
     
+    /** {en}
+     * @brief LC-AAC.
+     *
+     */
     VeLiveAudioAACProfileLC = 0,
     
+    /** {en}
+     * @brief HEv1-AAC.
+     *
+     */
     VeLiveAudioAACProfileHEv1 = 1,
     
+    /** {en}
+     * @brief HEv2-AAC.
+     *
+     */
     VeLiveAudioAACProfileHEv2 = 2
 }
 export declare class VeLiveVideoFrame {
     
+    /** {en}
+     * @brief The video buffer type. The default value is `VeLiveVideoBufferTypeUnknown`. See [VeLiveVideoBufferType](#VeLiveVideoBufferType) for details.
+     */
     bufferType: VeLiveVideoBufferType;
     
+    /** {en}
+     * @brief The pixel format. When `bufferType` is `VeLiveVideoBufferTypeNSData`, you must specify `pixelFormat`. See [VeLivePixelFormat](#VeLivePixelFormat) for details.
+     */
     pixelFormat: VeLivePixelFormat;
     
+    /** {en}
+     * @brief The rotation angle in a clockwise direction. See [VeLiveVideoRotation](#VeLiveVideoRotation) for details.
+     */
     rotation: VeLiveVideoRotation;
     
+    /** {en}
+     * @brief The width of the video, in pixels.
+     */
     width: int;
     
+    /** {en}
+     * @brief The height of the video, in pixels.
+     */
     height: int;
     
+    /** {en}
+     * @brief The timestamp of the video frame, in μs.
+     */
     pts: CMTime;
     
+    /** {en}
+     * @brief The video data, when `bufferType` is `VeLiveVideoBufferTypeTexture`.
+     */
     textureId: GLuint;
     
+    /** {en}
+     * @brief The video data, when `bufferType` is `VeLiveVideoBufferTypePixelBuffer`.
+     */
     pixelBuffer: CVPixelBufferRef;
     
+    /** {en}
+     * @brief The video data, when `bufferType` is `VeLiveVideoBufferTypeSampleBuffer`.
+     */
     sampleBuffer: CMSampleBufferRef;
     
+    /** {en}
+     * @brief The video data, when `bufferType` is `VeLiveVideoBufferTypeNSData`.
+     */
     data: NSData;
     
+    /** {en}
+     * @brief Triggered when the SDK has completed processing the video frame and no longer needs the memory. You can release the memory for the video frame after receiving this callback.
+     */
     releaseCallback(): void;
     init(): this;
 }
 export declare enum VeLiveVideoFluencyLevel {
     
+    /** {en}
+     * @brief Smooth. The frame rate reaches the expected rate.
+     *
+     */
     VeLiveVideoFluencyLevelSmooth = 0,
     
+    /** {en}
+     * @brief Minor freeze. The frame rate is 1 to 3 fps lower than the expected rate.
+     *
+     */
     VeLiveVideoFluencyLevelSluggish = 1,
     
+    /** {en}
+     * @brief Severe freeze. The frame rate is 4 fps lower than the expected rate.
+     *
+     */
     VeLiveVideoFluencyLevelBlocked = 2,
     
+    /** {en}
+     * @brief Completely frozen. The frame rate is below 2 fps.
+     *
+     */
     VeLiveVideoFluencyLevelStuck = 3
 }
 export declare enum VeLiveVideoMirrorType {
     
+    /** {en}
+     * @brief Mirror the captured video. When turned on, both the preview and the pushed video are mirrored.
+     *
+     */
     VeLiveVideoMirrorCapture = 0,
     
+    /** {en}
+     * @brief Mirror the preview. When turned on, only the preview is mirrored.
+     *
+     */
     VeLiveVideoMirrorPreview = 1,
     
+    /** {en}
+     * @brief Mirror the video before encoding. When turned on, only the pushed video is mirrored.
+     *
+     */
     VeLiveVideoMirrorPushStream = 2
 }
 export declare class VeLiveAudioCaptureConfiguration {
     
+    /** {en}
+     * @brief The sample rate. See [VeLiveAudioSampleRate](#VeLiveAudioSampleRate) for details. The default value is `VeLiveAudioSampleRate44100`.
+     */
     sampleRate: VeLiveAudioSampleRate;
     
+    /** {en}
+     * @brief The number of audio channels. See [VeLiveAudioChannel](#VeLiveAudioChannel) for details. The default value is `VeLiveAudioChannelStereo`.
+     */
     channel: VeLiveAudioChannel;
     init(): this;
 }
 export declare enum VeLiveVideoResolution {
     
+    /** {en}
+     * @brief 360P. The predefined configurations are as follows:
+     *         - Resolution in landscape mode: 640x360
+     *         - Resolution in portrait mode: 360x640
+     *         - Frame rate: 15 fps
+     *         - Target bitrate: 500 kbps
+     *         - Minimum bitrate: 250 kbps
+     *         - Maximum bitrate: 800 kbps
+     *
+     */
     VeLiveVideoResolution360P = 0,
     
+    /** {en}
+     * @brief 480P. The predefined configurations are as follows:
+     *         - Resolution in landscape mode: 864x480
+     *         - Resolution in portrait mode: 480x864
+     *         - Frame rate: 15 fps
+     *         - Target bitrate: 800 kbps
+     *         - Minimum bitrate: 320 kbps
+     *         - Maximum bitrate: 1266 kbps
+     *
+     */
     VeLiveVideoResolution480P = 1,
     
+    /** {en}
+     * @brief 540P. The predefined configurations are as follows:
+     *         - Resolution in landscape mode: 960x540
+     *         - Resolution in portrait mode: 540x960
+     *         - Frame rate: 15 fps
+     *         - Target bitrate: 1000 kbps
+     *         - Minimum bitrate: 500 kbps
+     *         - Maximum bitrate: 1520 kbps
+     *
+     */
     VeLiveVideoResolution540P = 2,
     
+    /** {en}
+     * @brief 720P. The predefined configurations are as follows:
+     *         - Resolution in landscape mode: 1280x720
+     *         - Resolution in portrait mode: 720x1280
+     *         - Frame rate: 15 fps
+     *         - Target bitrate: 1200 kbps
+     *         - Minimum bitrate: 800 kbps
+     *         - Maximum bitrate: 1900 kbps
+     *
+     */
     VeLiveVideoResolution720P = 3,
     
+    /** {en}
+     * @brief 1080P. The predefined configurations are as follows:
+     *         - Resolution in landscape mode: 1920x1080
+     *         - Resolution in portrait mode: 1080x1920
+     *         - Frame rate: 20 fps
+     *         - Target bitrate: 2500 kbps
+     *         - Minimum bitrate: 1000 kbps
+     *         - Maximum bitrate: 3800 kbps
+     *
+     */
     VeLiveVideoResolution1080P = 4,
     
+    /** {en}
+     * @brief The resolution of the streamed screen. The predefined configurations are as follows:
+     *         - Frame rate: 15 fps
+     *         - Target bitrate: 2500 kbps
+     *         - Minimum bitrate: 1000 kbps
+     *         - Maximum bitrate: 3800 kbps
+     *
+     */
     VeLiveVideoResolutionScreen = 10
 }
 export declare enum VeLiveVideoRotation {
     
+    /** {en}
+     * @brief Do not rotate.
+     *
+     */
     VeLiveVideoRotation0 = 0,
     
+    /** {en}
+     * @brief Rotate by 90 degrees clockwise.
+     *
+     */
     VeLiveVideoRotation90 = 1,
     
+    /** {en}
+     * @brief Rotate by 180 degrees clockwise.
+     *
+     */
     VeLiveVideoRotation180 = 2,
     
+    /** {en}
+     * @brief Rotate by 270 degrees clockwise.
+     *
+     */
     VeLiveVideoRotation270 = 3
 }
 export declare class VeLiveStreamMixDescription {
     
+    /** {en}
+     * @brief An array of video mixing configurations, where each array element represents the mixing configurations of a video stream. See [VeLiveMixVideoLayout](#VeLiveMixVideoLayout) for details.
+     */
     mixVideoStreams: NSArray<VeLiveMixVideoLayout>;
     
+    /** {en}
+     * @brief An array of audio mixing configurations, where each array element represents the mixing configurations of an audio stream. See [VeLiveMixAudioLayout](#VeLiveMixAudioLayout) for details.
+     */
     mixAudioStreams: NSArray<VeLiveMixAudioLayout>;
     
+    /** {en}
+     * @brief The background color of the mixed video, in  #RRGGBB format.
+     */
     backgroundColor: NSString;
     init(): this;
 }
 export declare enum VeLiveAudioCaptureType {
     
+    /** {en}
+     * @brief Capture the audio with the default microphone.
+     *
+     */
     VeLiveAudioCaptureMicrophone = 0,
     
+    /** {en}
+     * @brief Capture the audio in voice call mode, which will activate the 3A features of the hardware, including automatic gain control, automatic frequency control, and automatic noise suppression.
+     *
+     */
     VeLiveAudioCaptureVoiceCommunication = 1,
     
+    /** {en}
+     * @brief Capture the audio with an external device or source.
+     *
+     */
     VeLiveAudioCaptureExternal = 2,
     
+    /** {en}
+     * @brief Use muted frames as the audio source.
+     *
+     */
     VeLiveAudioCaptureMuteFrame = 3
 }
 export declare enum VeLiveVideoCodec {
     
+    /** {en}
+     * @brief H.264.
+     *
+     */
     VeLiveVideoCodecH264 = 0,
     
+    /** {en}
+     * @brief ByteVC1, an encoding format developed by BytePlus.
+     *
+     */
     VeLiveVideoCodecByteVC1 = 1
 }
 export declare class VeLiveVideoEncodeFrame {
     
+    /** {en}
+     * @brief The display timestamp, in μs. The display timestamp indicates when the frame should be rendered.
+     */
     pts: CMTime;
     
+    /** {en}
+     * @brief The dts time, or the decoding timestamp, in μs. The decoding timestamp indicates when the frame should be decoded.
+     */
     dts: CMTime;
     
+    /** {en}
+     * @brief The type of the encoded frame. See [VeLiveVideoEncodeFrameType:](#VeLiveVideoEncodeFrameType) for details.
+     */
     videoEcodeFrameType: VeLiveVideoEncodeFrameType;
     
+    /** {en}
+     * @brief The encoded data of the video frame. The encoded data is represented by an object of type NSData.
+     */
     data: NSData;
     init(): this;
 }
 export declare class VeLiveAudioEncoderConfiguration {
     
+    /** {en}
+     * @brief The audio encoding bitrate, in Kbps. The default value is `64`.
+     */
     bitrate: int;
     
+    /** {en}
+     * @brief The encoding sample rate. The default value is `VeLiveAudioSampleRate44100`. See [VeLiveAudioSampleRate](#VeLiveAudioSampleRate) for details.
+     */
     sampleRate: VeLiveAudioSampleRate;
     
+    /** {en}
+     * @brief The number of audio channels. The default value is `VeLiveAudioChannelStereo`. See [VeLiveAudioChannel](#VeLiveAudioChannel) for details.
+     */
     channel: VeLiveAudioChannel;
     
+    /** {en}
+     * @brief The AAC encoding format. The default value is `VeLiveAudioAACProfileLC`. See [VeLiveAudioProfile](#VeLiveAudioProfile) for details.
+     */
     profile: VeLiveAudioProfile;
     init(): this;
 }
 export declare enum VeLivePusherLogLevel {
     
+    /** {en}
+     * @brief Output VERBOSE, DEBUG, INFO, WARNING and ERROR.
+     *
+     */
     VeLivePusherLogLevelVerbose = 0,
     
+    /** {en}
+     * @brief Output DEBUG, INFO, WARNING and ERROR.
+     *
+     */
     VeLivePusherLogLevelDebug = 1,
     
+    /** {en}
+     * @brief Output INFO, WARNING and ERROR.
+     *
+     */
     VeLivePusherLogLevelInfo = 2,
     
+    /** {en}
+     * @brief Output WARNING and ERROR.
+     *
+     */
     VeLivePusherLogLevelWarn = 3,
     
+    /** {en}
+     * @brief Output ERROR.
+     *
+     */
     VeLivePusherLogLevelError = 4,
     
+    /** {en}
+     * @brief Disable logging.
+     *
+     */
     VeLivePusherLogLevelNone = 5
 }
 export declare enum VeLiveAudioMixType {
     
+    /** {en}
+     * @brief The audience can hear the mixed audio, but the host cannot.
+     *
+     */
     VeLiveAudioMixPush = 0,
     
+    /** {en}
+     * @brief Both the host and audience can hear the mixed audio.
+     *
+     */
     VeLiveAudioMixPlayAndPush = 1
 }
 export declare enum VeLivePusherRenderMode {
     
+    /** {en}
+     * @brief Uniformly scale the video until the screen is completely filled. Part of the video may be cropped.
+     *
+     */
     VeLivePusherRenderModeHidden = 0,
     
+    /** {en}
+     * @brief Display the full video. The video is uniformly scaled until one dimension of the video hits the boundary of the screen. Any remaining space on the screen will be filled with background color.
+     *
+     */
     VeLivePusherRenderModeFit = 1,
     
+    /** {en}
+     * @brief Stretch the video to fill the screen. The aspect ratio of the video might change.
+     *
+     */
     VeLivePusherRenderModeFill = 2
 }
 export declare class VeLiveVideoEffectLicenseConfiguration {
     
+    /** {en}
+     * @brief The special effects license type. See [VeLiveVideoEffectLicenseType](#VeLiveVideoEffectLicenseType) for details.
+     */
     type: VeLiveVideoEffectLicenseType;
     
+    /** {en}
+     * @brief The local path to the video effects license, when [VeLiveVideoEffectLicenseType](#VeLiveVideoEffectLicenseType) is `VeLiveVideoEffectLicenseTypeOffLine`.
+     */
     path: NSString;
     
+    /** {en}
+     * @brief The online authentication key for the video effects license, when [VeLiveVideoEffectLicenseType](#VeLiveVideoEffectLicenseType) is `VeLiveVideoEffectLicenseTypeOnLine`.
+     */
     key: NSString;
     
+    /** {en}
+     * @brief The online authentication secret for the video effects license, when [VeLiveVideoEffectLicenseType](#VeLiveVideoEffectLicenseType) is `VeLiveVideoEffectLicenseTypeOnLine`.
+     */
     secret: NSString;
     
+    /** {en}
+     * @brief The online authentication address for the video effects license, when [VeLiveVideoEffectLicenseType](#VeLiveVideoEffectLicenseType) is `VeLiveVideoEffectLicenseTypeOnLine`.
+     */
     url: NSString;
     
+    /** {en}
+     * @detail api
+     * @brief Initializes the license configurations in local authentication mode.
+     * @param path The local cache path for the video effects license. You can get the path through the [path](#VeLiveVideoEffectLicenseConfiguration-path) property.
+     * @return A [VeLiveVideoEffectLicenseConfiguration](#VeLiveVideoEffectLicenseConfiguration) object that uses the specified local path for license authentication.
+     */
     initWithPath(path: NSString): this;
     
+    /** {en}
+     * @detail api
+     * @brief Initializes the license configurations in online authentication mode.
+     * @param key The online authentication key for the video effects license. You can get it through the [key](#VeLiveVideoEffectLicenseConfiguration-key) property.
+     * @param secret The online authentication secret for the video effects license. You can get it through the [secret](#VeLiveVideoEffectLicenseConfiguration-secret) property.
+     * @param url The online authentication address for the video effects license. You can get it through the [url](#VeLiveVideoEffectLicenseConfiguration-url) property. If you set it to nil, the SDK will use the default URL.
+     * @return A [VeLiveVideoEffectLicenseConfiguration](#VeLiveVideoEffectLicenseConfiguration) object that uses the specified key, secret and address for online license authentication.
+     */
     initWithKey(key: NSString, secret: NSString, url: NSString): this;
 }
 export declare enum VeLiveAudioFrameSource {
     
+    /** {en}
+     * @brief The original audio frame captured by the microphone or other audio sources.
+     *
+     */
     VeLiveAudioFrameSourceCapture = 1,
     
+    /** {en}
+     * @brief The audio frame prior to encoding after undergoing various processes, such as noise cancellation and echo cancellation.
+     *
+     */
     VeLiveAudioFrameSourcePreEncode = 2
 }
 export declare enum VeLivePushStatus {
     
+    /** {en}
+     * @brief The initial state.
+     *
+     */
     VeLivePushStatusNone = 0,
     
+    /** {en}
+     * @brief Connecting to the server.
+     *
+     */
     VeLivePushStatusConnecting = 1,
     
+    /** {en}
+     * @brief The connection with the server is established.
+     *
+     */
     VeLivePushStatusConnectSuccess = 2,
     
+    /** {en}
+     * @brief Reconnecting to the server.
+     *
+     */
     VeLivePushStatusReconnecting = 3,
     
+    /** {en}
+     * @brief Stops connecting to the server.
+     *
+     */
     VeLivePushStatusConnectStop = 4,
     
+    /** {en}
+     * @brief Fails to connect to the server.
+     *
+     */
     VeLivePushStatusConnectError = 5,
     
+    /** {en}
+     * @brief The connection with the server is lost.
+     *
+     */
     VeLivePushStatusDisconnected = 6
 }
 export declare enum VeLiveFirstFrameType {
     
+    /** {en}
+     * @brief The first audio or video frame captured by the microphone or the camera.
+     *
+     */
     VeLiveFirstCaptureFrame = 0,
     
+    /** {en}
+     * @brief The first video frame rendered, which is the first frame displayed on the screen.
+     *
+     */
     VeLiveFirstRenderFrame = 1,
     
+    /** {en}
+     * @brief The first audio or video frame encoded.
+     *
+     */
     VeLiveFirstEncodedFrame = 2,
     
+    /** {en}
+     * @brief The first audio or video frame transmitted through the network.
+     *
+     */
     VeLiveFirstSendFrame = 3,
     
+    /** {en}
+     * @brief The first audio frame captured from the app after screen streaming starts.
+     *
+     */
     VeLiveFirstAppAudioCaptureFrame = 4
 }
 export declare enum VeLiveAudioSampleRate {
     
+    /** {en}
+     * @brief 44.1K. This sample rate is suitable for most audio processing scenarios, and is the standard sampling rate for music CDs.
+     *
+     */
     VeLiveAudioSampleRate44100 = 44100
 }
 export declare class VeLivePusherStatistics {
     
+    /** {en}
+     * @brief The width of the captured video, in pixels.
+     */
     captureWidth: int;
     
+    /** {en}
+     * @brief The height of the captured video, in pixels.
+     */
     captureHeight: int;
     
+    /** {en}
+     * @brief The captured frame rate, in fps.
+     */
     captureFps: int;
     
+    /** {en}
+     * @brief The width of the encoded video, in pixels.
+     */
     encodeWidth: int;
     
+    /** {en}
+     * @brief The height of the encoded video, in pixels.
+     */
     encodeHeight: int;
     
+    /** {en}
+     * @brief The encoded frame rate, in fps.
+     */
     encodeFps: int;
     
+    /** {en}
+     * @brief The encoded video bitrate, in Kbps.
+     */
     encodeVideoBitrate: int;
     
+    /** {en}
+     * @brief The encoded audio bitrate, in Kbps.
+     */
     encodeAudioBitrate: int;
     
+    /** {en}
+     * @brief The transmission frame rate, in fps. You can use this parameter to showcase the real-time frame rate on the user interface.
+     */
     transportFps: int;
     
+    /** {en}
+     * @brief The transmission bitrate, in Kbps. You can use this parameter to showcase the real-time bitrate on the user interface.
+     */
     transportVideoBitrate: int;
     
+    /** {en}
+     * @brief The encoded frame rate you specify in the setVideoEncoderConfiguration:{@link #VeLivePusher#setVideoEncoderConfiguration} method, in fps.
+     */
     fps: int;
     
+    /** {en}
+     * @brief The encoded bitrate you specify in the [setVideoEncoderConfiguration](docs-broadcast-sdk-for-ios-api#VeLivePusher-setvideoencoderconfiguration) method, in Kbps.
+     */
     videoBitrate: int;
     
+    /** {en}
+     * @brief The minimum encoded bitrate you specify in the [etVideoEncoderConfiguration:](docs-broadcast-sdk-for-ios-api#VeLivePusher-setvideoencoderconfiguration) method, in Kbps.
+     */
     minVideoBitrate: int;
     
+    /** {en}
+     * @brief The maximum encoded bitrate you specify in the setVideoEncoderConfiguration:{@link #VeLivePusher#setVideoEncoderConfiguration} method, in Kbps.
+     */
     maxVideoBitrate: int;
     
+    /** {en}
+     * @brief The push stream address.
+     */
     url: NSString;
     
+    /** {en}
+     * @brief The video codec.
+     */
     codec: NSString;
     init(): this;
 }
 export declare enum VeLivePixelFormat {
     
+    /** {en}
+     * @brief Unknown format.
+     *
+     */
     VeLivePixelFormatUnknown = -1,
     
+    /** {en}
+     * @brief I420.
+     *
+     */
     VeLivePixelFormatI420 = 0,
     
+    /** {en}
+     * @brief NV12.
+     *
+     */
     VeLivePixelFormatNV12 = 1,
     
+    /** {en}
+     * @brief NV21 format.
+     *
+     */
     VeLivePixelFormatNV21 = 2,
     
+    /** {en}
+     * @brief RAGBA.
+     *
+     */
     VeLivePixelFormatBGRA32 = 3,
     
+    /** {en}
+     * @brief OpenGL 2D texture.
+     *
+     */
     VeLivePixelFormat2DTexture = 4
 }
 export declare class VeLiveVideoCaptureConfiguration {
     
+    /** {en}
+     * @brief The width of the captured video, in pixels. The default value is `720`.
+     */
     width: int;
     
+    /** {en}
+     * @brief The height of the captured video, in pixels. The default value is `1280`.
+     */
     height: int;
     
+    /** {en}
+     * @brief The captured frame rate, in fps. The default value is `15`.
+     */
     fps: int;
     
+    /** {en}
+     * @brief The pixel format. The default format is kCVPixelFormatType_420YpCbCr8BiPlanarFullRange.
+     * @note The following formats are supported:
+     *       - kCVPixelFormatType_32BGRA
+     *       - kCVPixelFormatType_420YpCbCr8BiPlanarFullRange
+     *       - kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
+     *       - kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange
+     */
     pixelFormat: OSType;
     init(): this;
 }
 export declare class VeLiveAudioFrame {
     
+    /** {en}
+     * @brief The audio data type. The default value is `VeLiveAudioBufferTypeUnknown`. See [VeLiveAudioBufferType](#VeLiveAudioBufferType) for details.
+     */
     bufferType: VeLiveAudioBufferType;
     
+    /** {en}
+     * @brief The audio sample rate. See [VeLiveAudioSampleRate](#VeLiveAudioSampleRate) for details.
+     */
     sampleRate: VeLiveAudioSampleRate;
     
+    /** {en}
+     * @brief The number of audio channels. See [VeLiveAudioChannel](#VeLiveAudioChannel) for details.
+     */
     channels: VeLiveAudioChannel;
     
+    /** {en}
+     * @brief The audio frame timestamp, in μs, when `bufferType` is `VeLiveAudioBufferNSData`.
+     */
     pts: CMTime;
     
+    /** {en}
+     * @brief The audio data, when `bufferType` is `VeLiveAudioBufferTypeSampleBuffer`.
+     */
     sampleBuffer: CMSampleBufferRef;
     
+    /** {en}
+     * @brief The audio data, when `bufferType` is `VeLiveAudioBufferTypeNSData`. The audio data is of type float32 and is stored in little-endian byte order.
+     */
     data: NSData;
     init(): this;
 }
 export declare enum VeLiveAudioPowerLevel {
     
+    /** {en}
+     * @brief Muted. The volume is 1 dB or less.
+     *
+     */
     VeLiveAudioPowerLevelSilent = 0,
     
+    /** {en}
+     * @brief Quiet. The volume is below 15 dB.
+     *
+     */
     VeLiveAudioPowerLevelQuiet = 1,
     
+    /** {en}
+     * @brief Soft, close to whisper. The volume is between 16 dB and 30 dB.
+     *
+     */
     VeLiveAudioPowerLevelLight = 2,
     
+    /** {en}
+     * @brief Normal, similar to the volume in a daily conversation. The volume is between 30 dB and 60 dB.
+     *
+     */
     VeLiveAudioPowerLevelNormal = 3,
     
+    /** {en}
+     * @brief Loud, similar to the volume of the noise at cafes. The volume is between 61 dB and 85 dB.
+     *
+     */
     VeLiveAudioPowerLevelLoud = 4,
     
+    /** {en}
+     * @brief Noisy, similar to the volume of the noise on a busy street or at a concert. The volume is higher than 85 dB.
+     *
+     */
     VeLiveAudioPowerLevelNoisy = 5
 }
 export declare enum UIInterfaceOrientation {