import EnhancedEventEmitter from "../../EnhancedEventEmitter";
import Consumer from "./Consumer";
import { RemoteSdp } from "../../utils";
import { SignalingPcRes, RtpCapabilities, SignalingPublishRes, TrackStatsReport, IceParameters, IceCandidates, MediaStatisticStatsWithCalculationReport } from "../../types";
import { SignalingWS } from "../ws";
import { Track } from "../stream/track";
import { PCTrack } from "../stream/pctrack";
export interface ConsumerInfo {
    kind: "video" | "audio";
    consumerId: string;
    streamId: string;
    trackId: string;
    ssrc: number;
    rtxSsrc?: number;
    cname: string;
    mid?: string;
    closed?: boolean;
}
export declare class Handler extends EnhancedEventEmitter {
    _pc: RTCPeerConnection;
    protected _extendedRtpCapabilities: RtpCapabilities;
    protected _remoteSdp: RemoteSdp;
    _isRestartingICE: boolean;
    isPcReady: boolean;
    pcid: string;
    private _direction;
    protected _simulcast: boolean;
    private lastMediaStatistics;
    private intervalId;
    constructor(direction: "send" | "recv", extendedRtpCapabilities: RtpCapabilities, settings?: Object);
    getStats(track: MediaStreamTrack, lastReportList?: TrackStatsReport[]): Promise<TrackStatsReport[]>;
    registerMediaStatisticStatsReport(): void;
    unregisterMediaStatisticStatsReport(): void;
    addMediaStatistics(reports: MediaStatisticStatsWithCalculationReport[], lastReports: MediaStatisticStatsWithCalculationReport[]): void;
    getCurrentIceConnectionState(): RTCIceConnectionState;
    close(): void;
}
export declare class SendHandler extends Handler {
    private _transportReady;
    private _stream;
    private _pcReady;
    private _signaling;
    constructor(extendedRtpCapabilities: any, signaling: SignalingWS, settings: any);
    getReady(transportRemoteParameters: SignalingPcRes): Promise<void>;
    addProducerTracks(producerTracks: Track[]): Promise<SignalingPublishRes>;
    removeProducerTracks(producerTracks: PCTrack[]): Promise<any>;
    replaceProducerTrack(producerTrack: PCTrack, target: "image" | "video"): Promise<void>;
    restartICE(iceParameters: IceParameters, iceCandidates: IceCandidates[]): Promise<void>;
    private _setupTransport;
}
export declare class RecvHandler extends Handler {
    private _transportCreated;
    /**
     * 对于 plan-b consumer 是以 trackId 为 id，因为取消订阅的时候改 consumer 会被移除
     * 但是对于 unified-plan 取消订阅的时候 consumer 不能移除（只能标记成 closed 来组 inactive m-line）
     * 所以不能使用 trackId 作为 id，这里对于 unified-plan 会将列表 index 作为 id，也就是将 this._consumerInfos 当作列表使用
     */
    private _consumerInfos;
    private _pcReady;
    private _signaling;
    constructor(extendedRtpCapabilities: any, signaling: SignalingWS, settings: any);
    private getReady;
    /**
     * 如果发生了重复订阅的情况，策略是直接返回已经保存的 track 信息
     * 也就是无论传入的 consumer 是否重复，都返回和传入数量一致的 MediaStreamTrack
     */
    addConsumerTracks(consumers: Consumer[]): Promise<MediaStreamTrack[]>;
    private genNewConsumerInfo;
    private addConsumerTrack;
    removeConsumerTracks(consumers: Consumer[]): Promise<any>;
    restartICE(iceParameters: IceParameters, iceCandidates: IceCandidates[]): Promise<void>;
    setupTransport(trackIds: string[]): Promise<any>;
}
export declare function updateSenderParameters(senders: RTCRtpSender[]): void;
export declare function createPcOffer(pc: RTCPeerConnection, simulcast: boolean, offerOptions?: RTCOfferOptions): Promise<RTCSessionDescriptionInit>;
export declare function getHandler<T extends "send" | "recv">(direction: T, extendedRtpCapabilities: RtpCapabilities, signaling: SignalingWS, settings?: any): T extends "send" ? SendHandler : RecvHandler;