import { default as EventEmitter_2 } from 'wolfy87-eventemitter';

/**
 * @public
 * 音频采集编码预设值数组
 */
export declare const AUDIO_ENCODER_CONFIG_SETTINGS: {
    LOW: QNAudioEncoderConfig;
    STANDARD: QNAudioEncoderConfig;
    STANDARD_STEREO: QNAudioEncoderConfig;
    HIGH: QNAudioEncoderConfig;
    HIGH_STEREO: QNAudioEncoderConfig;
};

/**
 * @public
 * 音频采集编码配置
 */
export declare interface QNAudioEncoderConfig {
    /**
     * 采样率(Hz)
     */
    sampleRate?: number;
    /**
     * 采样大小
     */
    sampleSize?: number;
    /**
     * 是否采用双声道
     */
    stereo?: boolean;
    /**
     * 音频码率(Kbps)
     */
    bitrate?: number;
}

/**
 * @public
 * 音频采集编码预设值
 */
export declare type QNAudioEncoderConfigPreset = keyof typeof AUDIO_ENCODER_CONFIG_SETTINGS;

/**
 * @public
 * @deprecated use QNAudioEncoderConfig instead
 * 音频采集编码配置
 */
export declare interface QNAudioEncoderConfiguration extends QNAudioEncoderConfig {
}

/**
 * @public
 * @deprecated use QNAudioEncoderConfigPreset instead
 * 音频采集编码预设值
 */
export declare type QNAudioEncoderConfigurationPreset = QNAudioEncoderConfigPreset;

/**
 * @public
 */
export declare class QNAudioMixer extends EventEmitter_2 {
    /**
     * 开始混音并播放
     */
    start(loop?: boolean): Promise<void>;
    /**
     * 停止混音和播放
     */
    stop(): void;
    /**
     * 恢复混音和播放
     */
    resume(): void;
    /**
     * 暂停混音和播放
     */
    pause(): void;
    /**
     * 获取混音音频时长
     */
    getDuration(): number;
    /**
     * 获取当前混音位置
     */
    getCurrentPosition(): number;
    /**
     * 跳转到指定位置混音
     */
    seekTo(time: number): void;
    /**
     * 设置外部音频本地播放音量
     * 如果不想听到外部音频在本地播放的声音，可以将音频设置为 0
     * @param volume 音量值，默认为 1 表示原始音量
     */
    setPlayingVolume(volume: number): void;
}

/**
 * @public
 * 音频数据处理状态
 */
export declare enum QNAudioSourceState {
    /**
     * 播放中
     */
    PlAYING = "PlAYING",
    /**
     * 暂停
     */
    PAUSED = "PAUSED",
    /**
     * 停止
     */
    STOPPED = "STOPPED"
}

/**
 * @public
 * 音频数据源类型
 */
export declare type QNAudioSourceType = string | File | AudioBuffer;

/**
 * @public
 */
export declare class QNBufferSourceAudioTrack extends QNLocalAudioTrack {
    /**
     * 数据源
     */
    source: QNAudioSourceType;
    /**
     * 开始
     */
    start(loop?: boolean): Promise<void>;
    /**
     * 停止
     */
    stop(): void;
    /**
     * 恢复
     */
    resume(): void;
    /**
     * 暂停
     */
    pause(): void;
    /**
     * 获取音频时长
     */
    getDuration(): number;
    /**
     * 获取当前位置
     */
    getCurrentPosition(): number;
    /**
     * 跳转到指定位置
     */
    seekTo(time: number): void;
}

/**
 * @public
 * 外部音频导入配置
 */
export declare interface QNBufferSourceAudioTrackConfig {
    /**
     * 外部音频数据源
     */
    source: QNAudioSourceType;
    /**
     * 外部音频编码配置
     */
    encoderConfig?: QNAudioEncoderConfig | QNAudioEncoderConfigPreset;
    /**
     * 自定义 tag 文本
     */
    tag?: string;
}

/**
 * @public
 */
export declare class QNCameraVideoTrack extends QNLocalVideoTrack {
    play(container: HTMLElement, config?: QNPlayerConfig): Promise<void>;
}

/**
 * @public
 * 摄像头采集配置
 */
export declare interface QNCameraVideoTrackConfig {
    /**
     * 视频编码配置
     */
    encoderConfig?: QNVideoEncoderConfig | QNVideoEncoderConfigPreset;
    /**
     * 选择前置摄像头还是后置摄像头
     */
    facingMode?: "user" | "environment";
    /**
     * 传输优化模式
     */
    optimizationMode?: QNVideoOptimizationMode;
    /**
     * 选择摄像头 ID
     */
    cameraId?: string;
    /**
     * 自定义 tag 信息
     */
    tag?: string;
}

/**
 * @public
 */
export declare class QNCanvasVideoTrack extends QNLocalVideoTrack {
    /**
     * 修改画布内容
     */
    updateSources(sources: QNCanvasVideoTrackSource[]): Promise<void>;
    play(container: HTMLElement, config?: QNPlayerConfig): Promise<void>;
    /**
     * 销毁当前流
     */
    destroy(): void;
}

/**
 * @public
 * canvas video track 配置
 */
export declare interface QNCanvasVideoTrackConfig {
    /**
     * 画布宽
     */
    width: number;
    /**
     * 画布高
     */
    height: number;
    /**
     * 画布中元素布局
     */
    sources: QNCanvasVideoTrackSource[];
    /**
     * 自定义 tag 信息
     */
    tag?: string;
}

/**
 * @public
 * canvas video track Source 配置
 */
export declare interface QNCanvasVideoTrackSource {
    /**
     * 图片数据源
     */
    source: string | ArrayBuffer | File;
    /**
     * 在画布左上角 x 坐标
     */
    x: number;
    /**
     * 在画布左上角 y 坐标
     */
    y: number;
    /**
     * 图片占据画布的宽度（默认为图片本身的宽度）
     */
    width?: number;
    /**
     * 图片占据画布的高度（默认为图片本身的高度）
     */
    height?: number;
}

/**
 * @public
 * Chrome 插件采集源
 */
export declare enum QNChromeExtensionSourceType {
    /**
     * 窗口采集
     */
    WINDOW = "window",
    /**
     * 屏幕采集
     */
    SCREEN = "screen"
}

/**
 * @public
 * 连接断开状态
 */
export declare interface QNConnectionDisconnectedInfo {
    /**
     * 连接断开原因
     */
    reason: QNConnectionDisconnectedReason;
    /**
     * 错误码
     */
    errorCode?: number;
    /**
     * 错误信息描述
     */
    errorMessage?: string;
}

/**
 * @public
 * 连接断开原因
 */
export declare enum QNConnectionDisconnectedReason {
    /**
     * 主动退出
     */
    LEAVE = "LEAVE",
    /**
     * 被踢出房间
     */
    KICKED_OUT = "KICKED_OUT",
    /**
     * 发生错误，异常断开
     */
    ERROR = "ERROR"
}

/**
 * @public
 * 房间连接状态
 */
export declare enum QNConnectionState {
    /**
     * 初始状态
     */
    DISCONNECTED = "DISCONNECTED",
    /**
     * 正在连接
     */
    CONNECTING = "CONNECTING",
    /**
     * 连接成功
     */
    CONNECTED = "CONNECTED",
    /**
     * 正在重连
     */
    RECONNECTING = "RECONNECTING",
    /**
     * 重连成功
     */
    RECONNECTED = "RECONNECTED"
}

/**
 * @public
 * 约束值
 */
export declare interface QNConstrainLong {
    /**
     * 最小值
     */
    min?: number;
    /**
     * 最大值
     */
    max?: number;
    /**
     * 期望值
     * 当达不到期望值时，会自动选择最近的值
     */
    ideal?: number;
    /**
     * 严格值
     * 当达不到严格值时，抛出错误
     */
    exact?: number;
}

/**
 * @public
 */
export declare class QNCustomAudioTrack extends QNLocalAudioTrack {
}

/**
 * @public
 * 自定义音频采集配置
 */
export declare interface QNCustomAudioTrackConfig {
    /**
     * 音频采集源
     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack} for more information
     */
    mediaStreamTrack: MediaStreamTrack;
    /**
     * 音频码率(Kbps)
     */
    bitrate?: number;
    /**
     * 自定义 tag 文本
     */
    tag?: string;
}

/**
 * @public
 * 自定义文本消息
 */
export declare interface QNCustomMessage {
    /**
     * 消息 ID
     */
    ID: string;
    /**
     * 用户 ID
     */
    userID: string;
    /**
     * 消息内容
     */
    content: string;
    /**
     * 时间戳
     */
    timestamp: number;
}

/**
 * @public
 */
export declare class QNCustomVideoTrack extends QNLocalVideoTrack {
}

/**
 * @public
 * 自定义视频采集配置
 */
export declare interface QNCustomVideoTrackConfig {
    /**
     * 视频采集源
     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack} for more information
     */
    mediaStreamTrack: MediaStreamTrack;
    /**
     * 视频码率(Kbps)
     */
    bitrate?: number;
    /**
     * 自定义 tag 文本
     */
    tag?: string;
}

/**
 * @public
 * 设备信息
 */
export declare interface QNDeviceInfo {
    /**
     * 设备基本信息
     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo} for further information
     */
    device: MediaDeviceInfo;
    /**
     * 设备状态信息
     */
    state: QNDeviceState;
}

/**
 * @public
 * 设备状态信息
 */
export declare enum QNDeviceState {
    /**
     * 设备插入
     */
    ACTIVE = "ACTIVE",
    /**
     * 设备拔出
     */
    INACTIVE = "INACTIVE"
}

/**
 * @public
 * 单路转推配置项
 */
export declare interface QNDirectLiveStreamingConfig extends QNLiveStreamingConfig {
    /**
     * 设置单路转推的视频 Track，仅支持设置一路视频 Track
     */
    videoTrack?: QNTrack;
    /**
     * 设置单路转推的音频 Track，仅支持设置一路音频 Track
     */
    audioTrack?: QNTrack;
}

/**
 * @public
 * CDN 转推基础配置
 */
export declare interface QNLiveStreamingConfig {
    /**
     * 流任务 ID
     */
    streamID: string;
    /**
     * 推流地址
     */
    url: string;
}

/**
 * @public
 * CDN 转推状态
 */
export declare enum QNLiveStreamingState {
    /**
     * 已开始
     */
    STARTED = "STARTED",
    /**
     * 已停止
     */
    STOPPED = "STOPPED"
}

/**
 * @public
 */
export declare class QNLocalAudioTrack extends QNLocalTrack {
    /**
     * 设置音量
     */
    setVolume(volume: number): void;
    /**
     * 获取当前音量
     */
    getVolumeLevel(): number | undefined;
    /**
     * 获取当前时域数据
     */
    getCurrentTimeDomainData(): Uint8Array | undefined;
    /**
     * 获取当前频域数据
     */
    getCurrentFrequencyDomainData(): Uint8Array | undefined;
    /**
     * 获取流状态
     */
    getStats(): QNLocalAudioTrackStats;
}

/**
 * @public
 * QNLocalAudioTrack 流状态
 */
export declare interface QNLocalAudioTrackStats {
    /**
     * 上行音频码率
     */
    uplinkBitrate: number;
    /**
     * 上行网络 rtt
     */
    uplinkRTT: number;
    /**
     * 上行网络丢包率
     */
    uplinkLostRate: number;
}

/**
 * @public
 */
export declare class QNLocalTrack extends QNTrack {
    /**
     * 设置 mute 状态
     */
    setMuted(isMuted: boolean): void;
    /**
     * 销毁当前流
     */
    destroy(): void;
}

/**
 * @public
 */
export declare class QNLocalVideoTrack extends QNLocalTrack {
    /**
     * 是否开启大小流
     */
    isMultiProfileEnabled: boolean;
    /**
     * 截取当前视频流画面
     */
    getCurrentFrameData(): string;
    /**
     * 获取流状态数据
     */
    getStats(): QNLocalVideoTrackStats[];
    /**
     * 设置传输优化模式
     */
    setOptimizationMode(mode: QNVideoOptimizationMode): boolean;
}

/**
 * @public
 * QNLocalVideoTrackStats 流状态
 */
export declare interface QNLocalVideoTrackStats {
    /**
     * 该路 track 的 profile
     */
    profile?: QNTrackProfile;
    /**
     * 上行视频帧率
     */
    uplinkFrameRate: number;
    /**
     * 上行视频码率
     */
    uplinkBitrate: number;
    /**
     * 上行网络 rtt
     */
    uplinkRTT: number;
    /**
     * 上行网络丢包率
     */
    uplinkLostRate: number;
}

/**
 * @public
 * 日志等级
 */
export declare enum QNLogLevel {
    /**
     * VERBOSE 级别日志打印
     */
    VERBOSE = "VERBOSE",
    /**
     * INFO 级别日志打印
     */
    INFO = "INFO",
    /**
     * WARNING 级别日志打印
     */
    WARNING = "WARNING",
    /**
     * ERROR 级别日志打印
     */
    ERROR = "ERROR",
    /**
     * 关闭日志打印
     */
    NONE = "NONE"
}

/**
 * @public
 */
export declare class QNMicrophoneAudioTrack extends QNLocalAudioTrack {
    /**
     * 创建混音管理器
     */
    createAudioMixer(source: QNAudioSourceType): QNAudioMixer;
    /**
     * 销毁 track
     */
    destroy(): void;
}

/**
 * @public
 * 麦克风采集配置
 */
export declare interface QNMicrophoneAudioTrackConfig {
    /**
     * 音频编码配置
     */
    encoderConfig?: QNAudioEncoderConfig | QNAudioEncoderConfigPreset;
    /**
     * 是否启动 automatic echo cancellation
     */
    AEC?: boolean;
    /**
     * 是否启动 audio gain control
     */
    AGC?: boolean;
    /**
     * 是否启动 automatic noise supression
     */
    ANS?: boolean;
    /**
     * 选择麦克风 ID
     */
    microphoneId?: string;
    /**
     * 自定义 tag 文本
     */
    tag?: string;
}

/**
 * @public
 * 网络状态
 */
export declare enum QNNetworkQuality {
    /**
     * 网络质量未知
     */
    UNKNOWN = "UNKNOWN",
    /**
     * 质量极好
     */
    EXCELLENT = "EXCELLENT",
    /**
     * 用户主观感觉和极好差不多，但码率可能略低于极好
     */
    GOOD = "GOOD",
    /**
     * 网络一般
     */
    FAIR = "FAIR",
    /**
     * 网络质量差，影响正常通信
     */
    POOR = "POOR"
}

/**
 * @public
 * 播放配置
 */
export declare interface QNPlayerConfig {
    /**
     * 是否开启镜像
     */
    mirror?: boolean;
}

/**
 * @public
 */
export declare class QNRemoteAudioTrack extends QNRemoteTrack {
    /**
     * 设置音量
     */
    setVolume(volume: number): void;
    /**
     * 获取当前音量
     */
    getVolumeLevel(): number | undefined;
    /**
     * 获取当前时域数据
     */
    getCurrentTimeDomainData(): Uint8Array | undefined;
    /**
     * 获取当前频域数据
     */
    getCurrentFrequencyDomainData(): Uint8Array | undefined;
    /**
     * 获取流状态
     */
    getStats(): QNRemoteAudioTrackStats;
}

/**
 * @public
 * QNRemoteAudioTrack 流状态
 */
export declare interface QNRemoteAudioTrackStats {
    /**
     * 下行音频码率
     */
    downlinkBitrate: number;
    /**
     * 下行网络丢包率
     */
    downlinkLostRate: number;
    /**
     * 上行网络 rtt
     */
    uplinkRTT: number;
    /**
     * 上行网络丢包率
     */
    uplinkLostRate: number;
}

/**
 * @public
 */
export declare class QNRemoteTrack extends QNTrack {
    /**
     * 是否已订阅
     */
    isSubscribed(): boolean;
}

/**
 * @public
 */
export declare class QNRemoteUser {
    /**
     * 用户 ID
     */
    readonly userID: string;
    /**
     * 用户自定义数据
     */
    userData?: string;
    /**
     * 该用户发布的视频 track
     */
    getVideoTracks(): QNRemoteVideoTrack[];
    /**
     * 该用户发布的音频 track
     */
    getAudioTracks(): QNRemoteAudioTrack[];
}

/**
 * @public
 */
export declare class QNRemoteVideoTrack extends QNRemoteTrack {
    /**
     * 是否开启大小流
     */
    isMultiProfileEnabled: boolean;
    /**
     * 选择订阅视频的清晰度
     */
    setProfile(profile: QNTrackProfile): void;
    /**
     * 截取当前视频流数据
     */
    getCurrentFrameData(): string;
    /**
     * 获取流状态数据
     */
    getStats(): QNRemoteVideoTrackStats;
}

/**
 * @public
 * QNRemoteVideoTrack 流状态
 */
export declare interface QNRemoteVideoTrackStats {
    /**
     * 该路 track 的 profile
     */
    profile?: QNTrackProfile;
    /**
     * 下行视频帧率（即自己拉取的视频的帧率）
     */
    downlinkFrameRate: number;
    /**
     * 下行视频码率
     */
    downlinkBitrate: number;
    /**
     * 下行网络丢包率
     */
    downlinkLostRate: number;
    /**
     * 上行网络 rtt （即远端用户发布视频的网络链路的 rtt）
     */
    uplinkRTT: number;
    /**
     * 上行网络丢包率
     */
    uplinkLostRate: number;
}

/**
 * @public
 * 拉伸模式
 */
export declare enum QNRenderMode {
    /**
     * 视频被拉伸以填充视图的大小，而不需要保持长宽比
     */
    FILL = "scaleToFit",
    /**
     * 默认值, 视频通过保持长宽比来填充视图的大小。视频的某些部分可能被剪切
     */
    ASPECT_FILL = "aspectFill",
    /**
     * 通过保持宽高比(可能显示黑色边框)，视频被缩放以适应视图的大小
     */
    ASPECT_FIT = "aspectFit"
}

/**
 * @public
 */
declare class QNRTC {
    /**
     * 获取 SDK 版本号
     */
    static readonly VERSION: string;
    /**
     * 获取浏览器兼容报告
     */
    static isBrowserSupported(): boolean;
    /**
     * 系统兼容检测(约需30s-60s)
     */
    static checkSystemRequirements(): Promise<QNSystemRequirementsTestResult>;
    /**
     * 设置日志打印等级
     */
    static setLogLevel(level: QNLogLevel): void;
    /**
     * 检查 Chrome 浏览器插件是否按安装
     */
    static isChromeExtensionAvailable(): Promise<boolean>;
    /**
     * 创建 QNRTCClient 对象
     */
    static createClient(): QNRTCClient;
    /**
     * 摄像头变化回调
     */
    static onCameraChanged?: (deviceInfo: QNDeviceInfo) => void;
    /**
     * 麦克风变化回调
     */
    static onMicrophoneChanged?: (deviceInfo: QNDeviceInfo) => void;
    /**
     * 播放设备变化回调
     */
    static onPlaybackDeviceChanged?: (deviceInfo: QNDeviceInfo) => void;
    /**
     * 枚举可用的视频输入设备，比如摄像头
     */
    static getCameras(skipPermissionCheck?: boolean): Promise<MediaDeviceInfo[]>;
    /**
     * 枚举可用的音频输入设备，比如麦克风
     */
    static getMicrophones(skipPermissionCheck?: boolean): Promise<MediaDeviceInfo[]>;
    /**
     * 枚举可用的音频播放设备，比如扬声器
     */
    static getPlaybackDevices(skipPermissionCheck?: boolean): Promise<MediaDeviceInfo[]>;
    /**
     * 枚举可用的媒体输入和输出设备，比如麦克风、摄像头、耳机等
     */
    static getDevices(skipPermissionCheck?: boolean): Promise<MediaDeviceInfo[]>;
    /**
     * 通过摄像头采集的视频创建一个视频轨道
     */
    static createCameraVideoTrack(config?: QNCameraVideoTrackConfig): Promise<QNCameraVideoTrack>;
    /**
     * 通过麦克风采集的音频创建一个音频轨道
     */
    static createMicrophoneAudioTrack(config?: QNMicrophoneAudioTrackConfig): Promise<QNMicrophoneAudioTrack>;
    /**
     * 创建用于屏幕共享的视频轨道
     */
    static createScreenVideoTrack(config?: QNScreenVideoTrackConfig, withAudio?: "enable" | "disable" | "auto"): Promise<[QNScreenVideoTrack, QNLocalAudioTrack] | QNScreenVideoTrack>;
    /**
     * 同时采集麦克风音频和摄像头视频轨道
     */
    static createMicrophoneAndCameraTracks(audioConfig?: QNMicrophoneAudioTrackConfig, videoConfig?: QNCameraVideoTrackConfig): Promise<[QNMicrophoneAudioTrack, QNCameraVideoTrack]>;
    /**
     * 通过音频文件或者 AudioBuffer 对象创建一个音频轨道
     */
    static createBufferSourceAudioTrack(config: QNBufferSourceAudioTrackConfig): Promise<QNBufferSourceAudioTrack>;
    /**
     * 创建 canvas video track
     */
    static createCanvasVideoTrack(config: QNCanvasVideoTrackConfig): QNCanvasVideoTrack;
    /**
     * 创建一个自定义的音频轨道
     */
    static createCustomAudioTrack(config: QNCustomAudioTrackConfig): QNCustomAudioTrack;
    /**
     * 创建一个自定义的视频轨道
     */
    static createCustomVideoTrack(config: QNCustomVideoTrackConfig): QNCustomVideoTrack;
    /**
     * 设置传输模式
     */
    static setTransportPolicy(policy: QNTransportPolicy): void;
    /**
     * 检测音频轨道是否活跃。
     * 在一定时间内检测音频轨道声音是否有变化或者是否低于正常值。
     * 可以在开始通话前对音频输入设备进行可用性检测。
     * sdk 最低检测事件为200 ms，若传入值小于60，则 sdk 会自动调整为 200ms。
     */
    static checkAudioTrackIsActive(track: QNLocalAudioTrack | QNRemoteAudioTrack, timeout?: number): Promise<boolean>;
    /**
     * 检测视频轨道是否活跃。
     * 在一定时间内检测视频轨道画面是否有变化。
     * 可以在开始通话前对视频输入设备进行可用性检测。
     * 当视频轨被 muted 的时候返回 false。
     * sdk 最低检测事件为60 ms，若传入值小于60，则 sdk 会自动调整为 60ms。
     */
    static checkVideoTrackIsActive(track: QNLocalVideoTrack | QNRemoteVideoTrack, timeout?: number): Promise<boolean>;
}
export default QNRTC;

/**
 * @public
 * QNRTCClient
 */
export declare class QNRTCClient extends EventEmitter_2 {
    /**
     * 本地用户的用户 ID
     */
    readonly userID: string | undefined;
    /**
     * 用户自定义数据
     */
    readonly userData: string | undefined;
    /**
     * 当前房间的名称
     */
    readonly roomName: string | undefined;
    /**
     * 当前房间连接状态
     */
    private connectionState;
    /**
     * 房间当前的远端用户列表
     */
    remoteUsers: QNRemoteUser[];
    /**
     * 获取远端用户
     */
    getRemoteUser(userID: string): QNRemoteUser | undefined;
    /**
     * 加入房间
     */
    join(token: string, userData?: string): Promise<void>;
    /**
     * 离开房间
     */
    leave(): Promise<void>;
    /**
     * 发布
     */
    publish(tracks: QNLocalTrack | QNLocalTrack[]): Promise<void>;
    /**
     * 取消发布
     */
    unpublish(tracks: QNLocalTrack | QNLocalTrack[]): Promise<void>;
    /**
     * 订阅
     */
    subscribe(tracks: QNRemoteTrack | QNRemoteTrack[]): Promise<{
        videoTracks: QNRemoteVideoTrack[];
        audioTracks: QNRemoteAudioTrack[];
    }>;
    /**
     * 取消订阅
     */
    unsubscribe(tracks: QNRemoteTrack | QNRemoteTrack[]): Promise<void>;
    /**
     * 发送自定义消息
     */
    sendMessage(messageID: string, message: string, users?: QNRemoteUser[]): Promise<void>;
    /**
     * 开启单路转推
     */
    startDirectLiveStreaming(config: QNDirectLiveStreamingConfig): Promise<void>;
    /**
     * 停止单路转推
     */
    stopDirectLiveStreaming(streamID: string): Promise<void>;
    /**
     * 开启合流转推
     */
    startTranscodingLiveStreaming(config: QNTranscodingLiveStreamingConfig): Promise<void>;
    /**
     * 停止合流转推
     */
    stopTranscodingLiveStreaming(streamID?: string): Promise<void>;
    /**
     * 新增、更新合流转推的布局
     */
    setTranscodingLiveStreamingTracks(streamID: string | null, transcodingTracks: QNTranscodingLiveStreamingTrack[]): Promise<void>;
    /**
     * 移除合流转推的布局
     */
    removeTranscodingLiveStreamingTracks(streamID: string | null, transcodingTracks: QNTranscodingLiveStreamingTrack[]): Promise<void>;
    /**
     * 获取自己的网络质量等级
     */
    getNetworkQuality(): QNNetworkQuality;
    /**
     * 获取远端用户的网络质量等级
     */
    getUserNetworkQuality(userID: string): QNNetworkQuality;
    /**
     * 启用说话者音量提示。
     * 该方法允许 SDK 定期报告正在说话的远端用户及其音量。
     * 启用音量提示后，无论频道中有没有人说话，SDK 都会每两秒触发 QNRTCClient.on("volume-indicator") 回调。
     */
    enableAudioVolumeIndicator(): void;
}

/**
 * @public
 * 屏幕分享采集编码预设值
 */
export declare type QNScreenEncoderConfigPreset = keyof typeof SUPPORT_SCREEN_ENCODER_CONFIG_LIST;

/**
 * @public
 * @deprecated use QNScreenEncoderConfigPreset instead
 * 屏幕分享采集编码预设值
 */
export declare type QNScreenEncoderConfigurationPreset = QNScreenEncoderConfigPreset;

/**
 * @public
 */
export declare class QNScreenVideoTrack extends QNLocalVideoTrack {
}

/**
 * @public
 * 屏幕分享采集配置
 */
export declare interface QNScreenVideoTrackConfig {
    /**
     * 屏幕分享采集编码配置
     */
    encoderConfig?: QNVideoEncoderConfig | QNScreenEncoderConfigPreset;
    /**
     * 传输优化模式
     */
    optimizationMode?: QNVideoOptimizationMode;
    /**
     * 自定义屏幕录制视频 tag 文本
     */
    screenVideoTag?: string;
    /**
     * 自定义系统声音 tag 文本
     */
    screenAudioTag?: string;
    /**
     * 使用 Chrome 插件采集，设置采集源
     */
    chromeExtensionSourceType?: QNChromeExtensionSourceType;
}

/**
 * @public
 * 系统兼容检测结果
 */
export declare interface QNSystemRequirementsTestResult {
    /**
     * 测试房间名
     */
    roomName: string;
    /**
     * 是否通过测试
     */
    ok: boolean;
    /**
     * 测试失败原因
     */
    reason: string;
    /**
     * 平均 RTT
     */
    avgRTT: number;
    /**
     * 平均丢包率
     */
    avgPacketLossRate: number;
    /**
     * 音频平均码率
     */
    avgAudioBitrate: number;
    /**
     * 视频平均码率
     */
    avgVideoBitrate: number;
    /**
     * 音频平均音量
     */
    avgVolumnLevel: number;
}

/**
 * @public
 */
export declare abstract class QNTrack extends EventEmitter_2 {
    /**
     * Track ID
     */
    trackID?: string;
    /**
     * 用户 ID
     */
    userID?: string;
    /**
     * 自定义 tag 文本
     */
    tag?: string;
    /**
     * 当前播放元素
     */
    readonly mediaElement: HTMLVideoElement | HTMLAudioElement | undefined;
    /**
     * 播放
     */
    play(container: HTMLElement, config?: QNPlayerConfig): Promise<void>;
    /**
     * 是否是音频
     */
    isAudio(): boolean;
    /**
     * 是否是视频
     */
    isVideo(): boolean;
    /**
     * 是否 mute
     */
    isMuted(): boolean;
    /**
     * 获取 webrtc 原生的 track 对象
     */
    getMediaStreamTrack(): MediaStreamTrack | undefined;
}

/**
 * @public
 * 大小流类型
 */
export declare enum QNTrackProfile {
    /**
     * 低分辨率
     */
    LOW = "LOW",
    /**
     * 中分辨率
     */
    MEDIUM = "MEDIUM",
    /**
     * 高分辨率
     */
    HIGH = "HIGH"
}

/**
 * @public
 * 合流转推配置项
 */
export declare interface QNTranscodingLiveStreamingConfig extends QNLiveStreamingConfig {
    /**
     * 设置合流转推画布的宽
     */
    width?: number;
    /**
     * 设置合流转推画布的高
     */
    height?: number;
    /**
     * 设置合流转推的视频帧率
     */
    videoFrameRate?: number;
    /**
     * 设置合流转推的码率
     */
    bitrate?: number;
    /**
     * 设置合流转推的最小码率
     */
    minBitrate?: number;
    /**
     * 设置合流转推的最大码率
     */
    maxBitrate?: number;
    /**
     * 设置合流转推的合流布局
     */
    transcodingTracks?: QNTranscodingLiveStreamingTrack[];
    /**
     * 设置合流画面的填充方式
     */
    renderMode?: QNRenderMode;
    /**
     * 设置合流转推的画布背景
     */
    background?: QNTranscodingLiveStreamingImage;
    /**
     * 设置合流转推的水印
     */
    watermarks?: QNTranscodingLiveStreamingImage[];
    /**
     * 设置是否保持最后一帧
     */
    holdLastFrame?: boolean;
}

/**
 * @public
 * 合流转推时，画布的背景图片配置
 */
export declare interface QNTranscodingLiveStreamingImage {
    /**
     * 设置图片地址
     */
    url: string;
    /**
     * 设置图片在合流画布中所在位置的 x 坐标
     */
    x: number;
    /**
     * 设置图片在合流画布中所在位置的 y 坐标
     */
    y: number;
    /**
     * 设置图片在合流画布中所在位置的宽
     */
    width: number;
    /**
     * 设置图片在合流画布中所在位置的高
     */
    height: number;
}

/**
 * @public
 * 合流转推时，每一路流在画布中的配置
 */
export declare interface QNTranscodingLiveStreamingTrack {
    /**
     * 参与合流的 trackID
     */
    trackID: string;
    /**
     * track 在合流画布中位置的 x 坐标
     */
    x?: number;
    /**
     * track 在合流画布中位置的 y 坐标
     */
    y?: number;
    /**
     * track 在合流画布中位置的层级
     */
    zOrder?: number;
    /**
     * track 在合流画布中相应位置的宽
     */
    width?: number;
    /**
     * track 在合流画布中相应位置的高
     */
    height?: number;
    /**
     * track 画面合流时的填充方式
     */
    renderMode?: QNRenderMode;
}

/**
 * @public
 * 传输策略
 */
export declare enum QNTransportPolicy {
    /**
     * 强制使用 UDP
     */
    FORCE_UDP = "FORCE_UDP",
    /**
     * 强制使用 TCP
     */
    FORCE_TCP = "FORCE_TCP",
    /**
     * 优先使用 UDP
     */
    PREFER_UDP = "PREFER_UDP"
}

/**
 * @public
 * 视频编码配置
 */
export declare interface QNVideoEncoderConfig {
    /**
     * 视频宽度
     */
    width?: number | QNConstrainLong;
    /**
     * 视频高度
     */
    height?: number | QNConstrainLong;
    /**
     * 视频帧率(fps)
     */
    frameRate?: number;
    /**
     * 视频码率(Kbps)
     */
    bitrate?: number;
    /**
     * 是否开启大小流
     */
    isMultiProfileEnabled?: boolean;
}

/**
 * @public
 * 视频采集编码预设
 */
export declare type QNVideoEncoderConfigPreset = keyof typeof SUPPORT_VIDEO_ENCODER_CONFIG_LIST;

/**
 * @public
 * @deprecated use QNVideoEncoderConfig instead
 * 视频编码配置
 */
export declare interface QNVideoEncoderConfiguration extends QNVideoEncoderConfig {
}

/**
 * @public
 * @deprecated use QNVideoEncoderConfigPreset instead
 * 视频采集编码预设
 */
export declare type QNVideoEncoderConfigurationPreset = QNVideoEncoderConfigPreset;

/**
 * @public
 * 视频优化模式
 */
export declare enum QNVideoOptimizationMode {
    /**
     * 流畅优先
     */
    MOTION = "motion",
    /**
     * 清晰度优先
     */
    DETAIL = "detail",
    /**
     * 由 SDK 自动判断
     */
    DEFAULT = ""
}

/**
 * @public
 * 房间说话者音量回调数据
 */
export declare interface QNVolumeIndicator {
    /**
     * 音量值，范围 0 ~ 1
     */
    level: number;
    /**
     * track ID
     */
    trackID: string;
    /**
     * 用户 ID
     */
    userID: string;
}

/**
 * @public
 * 屏幕分享采集编码预设值数组
 */
export declare const SUPPORT_SCREEN_ENCODER_CONFIG_LIST: {
    "480p": QNVideoEncoderConfig;
    "720p": QNVideoEncoderConfig;
    "1080p": QNVideoEncoderConfig;
};

/**
 * @public
 * 视频采集编码预设值数组
 */
export declare const SUPPORT_VIDEO_ENCODER_CONFIG_LIST: {
    "360p": QNVideoEncoderConfig;
    "480p": QNVideoEncoderConfig;
    "720p": QNVideoEncoderConfig;
    "1080p": QNVideoEncoderConfig;
    "1440p": QNVideoEncoderConfig;
    "4k": QNVideoEncoderConfig;
};

export { }