import type EventEmitter from 'eventemitter3';
import type { RTMPError } from '../Error';
export declare enum RTMPInnerEventsTypes {
    OnVideoCaptured = "onvideocaptured",
    OnAudioCaptured = "onaudiocaptured",
    OnVideoCaptureNoOutput = "onvideocapturenooutput",
    OnVideoEncoded = "onvideoencoded",
    OnAudioEncoded = "onaudioencoded",
    OnEncodedFrame = "onencodedframe",
    OnPacketed = "onpacketed",
    OnUpstreamFeedback = "onupstreamfeedback",
    OnBitrateChanged = "onbitratechanged"
}
export declare enum RTMPEventsTypes {
    OnError = "onerror",
    OnConnectClosed = "onconnectclosed",
    OnFirstFramePushed = "onfirstframepushed"
}
export declare enum StreamTrackType {
    Video = "video",
    Audio = "audio"
}
export declare enum WorkerUpEvents {
    Init = "init",
    AvExist = "avexist",
    VideoFrame = "videoframe",
    MockVideoEncode = "mockvideoencode",
    AudioFrame = "audioframe",
    AdjustBitrate = "adjustbitrate",
    Publish = "publish",
    UnPublish = "unpublish",
    Download = "download",
    GetStats = "getstats",
    EncodeConfig = "encodeconfig"
}
export declare enum WorkerDownEvents {
    Ready = "ready",
    Error = "error",
    FirstFramePushed = "firstframepushed",
    Flvfile = "flvfile",
    STATS = "stats",
    Close = "close"
}
export type VideoEncodedFrame = {
    buffer: Uint8Array;
    props: {
        originTs: number;
        timestamp: number;
        duration: number;
        byteLength: number;
        type: 'key' | 'delta';
    };
    cfg: VideoDecoderConfig;
};
export type AudioChunkInfo = {
    offset: number;
    data: {
        audioData: AudioData;
        buffer: Float32Array;
    };
};
export type AudioFrame = {
    buffer: Float32Array;
    props: {
        timestamp: number;
        sampleRate: number;
        numberOfChannels: number;
    };
};
export type AudioEncodedFrame = {
    buffer: Uint8Array;
    props: {
        originTs: number;
        timestamp: number;
    };
};
export type EncodeSetting = {
    codec: string;
    hardwareAcceleration: HardwarePreference;
    videoBitrate: number;
    audioBitrate: number;
    width: number;
    height: number;
    frameRate: number;
    gopSize: number;
    sampleRate: number;
    channel: number;
    hasVideo: boolean;
    hasAudio: boolean;
    vDeviceId: string;
    aDeviceId: string;
};
export type EncodeCapacityConfig = {
    sampleRate?: number;
    channel?: 1 | 2;
    gopSize?: number;
};
export type RTMPStats = {
    video: {
        sendBitrate: number;
        framesPerSecond: number;
        framesEncoded: number;
        keyFramesEncoded: number;
        sendSpeed: number;
        codec: string;
        frameWidth: number;
        frameHeight: number;
        gopSize: number;
    };
    audio: {
        sendBitrate: number;
        framesEncoded: number;
        codec: string;
        channels: number;
        sampleRate: number;
    };
};
type Partial<T> = {
    [P in keyof T]?: T[P];
};
export type PartialEncodeSetting = Partial<EncodeSetting>;
export type PartailFeedbackSetting = Partial<{
    videoBitrate: number;
    width: number;
    height: number;
    frameRate: number;
}>;
export type RTMPEvents = {
    [RTMPInnerEventsTypes.OnVideoCaptured]: (frame: VideoFrame, setting: MediaTrackConstraintSet) => void;
    [RTMPInnerEventsTypes.OnAudioCaptured]: (frame: AudioData, setting: MediaTrackConstraintSet) => void;
    [RTMPInnerEventsTypes.OnVideoCaptureNoOutput]: () => void;
    [RTMPInnerEventsTypes.OnVideoEncoded]: (frame: VideoEncodedFrame) => void;
    [RTMPInnerEventsTypes.OnAudioEncoded]: (frame: AudioEncodedFrame) => void;
    [RTMPInnerEventsTypes.OnEncodedFrame]: (type: StreamTrackType, frame: VideoEncodedFrame | AudioEncodedFrame) => void;
    [RTMPInnerEventsTypes.OnPacketed]: (tag: Uint8Array, key?: boolean) => void;
    [RTMPInnerEventsTypes.OnUpstreamFeedback]: (setting: PartailFeedbackSetting) => void;
    [RTMPInnerEventsTypes.OnBitrateChanged]: (kind: StreamTrackType, bitrate: number) => void;
    [RTMPEventsTypes.OnError]: (e: RTMPError) => void;
    [RTMPEventsTypes.OnFirstFramePushed]: () => void;
    [RTMPEventsTypes.OnConnectClosed]: (e?: string) => void;
};
declare abstract class AbsLiveRTMP {
    abstract ready: () => Promise<void>;
    abstract videoFrameCaptured: (frame: VideoFrame, setting: MediaTrackConstraintSet) => void;
    abstract audioFrameCaptured: (frame: AudioData, setting: MediaTrackConstraintSet) => void;
    abstract startMockVideoEncode: () => void;
    abstract publish: (url: string) => Promise<void>;
    abstract adjustBitrate: (kind: StreamTrackType, bitrate: number) => void;
    abstract updateSetting: (setting: PartialEncodeSetting) => void;
    abstract getSetting: () => EncodeSetting;
}
export interface ILiveRTMP extends AbsLiveRTMP, EventEmitter<RTMPEvents> {
}
declare abstract class AbsBridge {
    static isSupported: () => boolean;
    static version: string;
    abstract ready: () => Promise<void>;
    abstract setEncodeCapacity: (cfg: EncodeCapacityConfig) => void;
    abstract addTrack: (track: MediaStreamTrack) => void;
    abstract replaceTrack: (kind: StreamTrackType, track: MediaStreamTrack | null) => void;
    abstract publish: (url: string) => void;
    abstract adjustBitrate: (kind: StreamTrackType, bitrate: number) => void;
    abstract getStats: () => Promise<RTMPStats>;
    abstract destroy: () => void;
}
export interface IBridge extends AbsBridge, EventEmitter<RTMPEvents> {
    get audioMsTrack(): MediaStreamTrack | null;
    get videoMsTrack(): MediaStreamTrack | null;
}
export {};