import EventEmitter from 'eventemitter3';
import { ClientMonitor } from "../ClientMonitor";
import { Detectors } from "../detectors/Detectors";
import * as W3C from "../schema/W3cStatsIdentifiers";
import { Logger } from "../utils/logger";
import { InboundRtpMonitor } from "./InboundRtpMonitor";
import { RemoteOutboundRtpMonitor } from "./RemoteOutboundRtpMonitor";
import { OutboundRtpMonitor } from "./OutboundRtpMonitor";
import { RemoteInboundRtpMonitor } from "./RemoteInboundRtpMonitor";
import { MediaSourceMonitor } from "./MediaSourceMonitor";
import { CodecMonitor } from "./CodecMonitor";
import { MediaPlayoutMonitor } from "./MediaPlayoutMonitor";
import { PeerConnectionTransportMonitor } from "./PeerConnectionTransportMonitor";
import { IceTransportMonitor } from "./IceTransportMonitor";
import { IceCandidateMonitor } from "./IceCandidateMonitor";
import { IceCandidatePairMonitor } from "./IceCandidatePairMonitor";
import { CertificateMonitor } from "./CertificateMonitor";
import { DataChannelMonitor } from "./DataChannelMonitor";
import { InboundTrackMonitor } from "./InboundTrackMonitor";
import { OutboundTrackMonitor } from "./OutboundTrackMonitor";
import { CalculatedScore } from "../scores/CalculatedScore";
import { StatsCollector } from "../collectors/StatsCollector";
import { StatsAdapters } from "../adapters/StatsAdapters";
import { SelectedIcePath } from "./SelectedIcePath";
import { PeerConnectionSample, PeerConnectionTransportStats } from "../schema/ClientSample";
export type PeerConnectionMonitorEvents = {
    'close': [];
    'update': [];
    'stats': [W3C.RtcStats[]];
};
export declare class PeerConnectionMonitor extends EventEmitter<PeerConnectionMonitorEvents> {
    readonly peerConnectionId: string;
    readonly statsCollector: StatsCollector;
    readonly parent: ClientMonitor;
    private readonly logger;
    attachments?: Record<string, unknown> | undefined;
    readonly statsAdapters: StatsAdapters;
    readonly detectors: Detectors;
    readonly mappedCodecMonitors: Map<string, CodecMonitor>;
    readonly mappedInboundRtpMonitors: Map<number, InboundRtpMonitor>;
    readonly mappedRemoteOutboundRtpMonitors: Map<number, RemoteOutboundRtpMonitor>;
    readonly mappedOutboundRtpMonitors: Map<number, OutboundRtpMonitor>;
    readonly mappedDataChannelMonitors: Map<string, DataChannelMonitor>;
    readonly mappedRemoteInboundRtpMonitors: Map<number, RemoteInboundRtpMonitor>;
    readonly mappedMediaSourceMonitors: Map<string, MediaSourceMonitor>;
    readonly mappedMediaPlayoutMonitors: Map<string, MediaPlayoutMonitor>;
    readonly mappedPeerConnectionTransportMonitors: Map<string, PeerConnectionTransportMonitor>;
    readonly mappedIceTransportMonitors: Map<string, IceTransportMonitor>;
    readonly mappedIceCandidateMonitors: Map<string, IceCandidateMonitor>;
    readonly mappedIceCandidatePairMonitors: Map<string, IceCandidatePairMonitor>;
    readonly mappedCertificateMonitors: Map<string, CertificateMonitor>;
    readonly mappedSelectedIcePaths: Map<string, SelectedIcePath>;
    private readonly _pendingMediaStreamTracks;
    readonly mappedInboundTracks: Map<string, InboundTrackMonitor>;
    readonly mappedOutboundTracks: Map<string, OutboundTrackMonitor>;
    closed: boolean;
    sendingAudioBitrate: number;
    sendingVideoBitrate: number;
    receivingAudioBitrate: number;
    receivingVideoBitrate: number;
    outboundFractionLost: number;
    inboundFractionalLost: number;
    totalInboundPacketsLost: number;
    totalInboundPacketsReceived: number;
    totalOutboundPacketsSent: number;
    totalOutboundPacketsReceived: number;
    totalOutboundPacketsLost: number;
    totalDataChannelBytesSent: number;
    totalDataChannelBytesReceived: number;
    totalSentAudioBytes: number;
    totalSentVideoBytes: number;
    totalReceivedAudioBytes: number;
    totalReceivedVideoBytes: number;
    totalAvailableIncomingBitrate: number;
    totalAvailableOutgoingBitrate: number;
    deltaInboundPacketsLost: number;
    deltaInboundPacketsReceived: number;
    deltaOutboundPacketsSent: number;
    deltaOutboundPacketsReceived: number;
    deltaOutboundPacketsLost: number;
    deltaAudioBytesSent: number;
    deltaVideoBytesSent: number;
    deltaAudioBytesReceived: number;
    deltaVideoBytesReceived: number;
    deltaDataChannelBytesReceived: number;
    deltaDataChannelBytesSent: number;
    highestSeenSendingBitrate?: number;
    highestSeenReceivingBitrate?: number;
    highestSeenAvailableOutgoingBitrate?: number;
    highestSeenAvailableIncomingBitrate?: number;
    congested: boolean;
    iceRttInSec?: number;
    ewmaIceRttInSec?: number;
    rtcpRttInSec?: number;
    ewmaRtcpRttInSec?: number;
    connectingStartedAt?: number;
    connectedAt?: number;
    private _connectionState?;
    iceState?: W3C.RtcIceTransportState;
    usingTURN?: boolean;
    usingTCP?: boolean;
    calculatedStabilityScore: CalculatedScore;
    appData?: Record<string, unknown> | undefined;
    constructor(peerConnectionId: string, statsCollector: StatsCollector, parent: ClientMonitor, logger: Logger, attachments?: Record<string, unknown> | undefined);
    get avgRttInSec(): number | undefined;
    get ewmaRttInSec(): number | undefined;
    get score(): number | undefined;
    get scoreReasons(): Record<string, number> | undefined;
    get receivingBitrate(): number;
    get sendingBitrate(): number;
    get tracks(): (InboundTrackMonitor | OutboundTrackMonitor)[];
    on<K extends keyof PeerConnectionMonitorEvents>(event: K, listener: (...args: PeerConnectionMonitorEvents[K]) => void): this;
    once<K extends keyof PeerConnectionMonitorEvents>(event: K, listener: (...args: PeerConnectionMonitorEvents[K]) => void): this;
    off<K extends keyof PeerConnectionMonitorEvents>(event: K, listener: (...args: PeerConnectionMonitorEvents[K]) => void): this;
    emit(event: keyof PeerConnectionMonitorEvents, ...args: PeerConnectionMonitorEvents[typeof event]): boolean;
    collect(): Promise<W3C.RtcStats[]>;
    accept(stats: W3C.RtcStats[]): void;
    private _acceptAdaptedStats;
    createSample(): PeerConnectionSample;
    addMediaStreamTrack(track: MediaStreamTrack, attachments?: Record<string, unknown>): void;
    get codecs(): CodecMonitor[];
    get inboundRtps(): InboundRtpMonitor[];
    get remoteOutboundRtps(): RemoteOutboundRtpMonitor[];
    get outboundRtps(): OutboundRtpMonitor[];
    get remoteInboundRtps(): RemoteInboundRtpMonitor[];
    get mediaSources(): MediaSourceMonitor[];
    get mediaPlayouts(): MediaPlayoutMonitor[];
    get dataChannels(): DataChannelMonitor[];
    get peerConnectionTransports(): PeerConnectionTransportMonitor[];
    get iceTransports(): IceTransportMonitor[];
    get iceCandidates(): IceCandidateMonitor[];
    get iceCandidatePairs(): IceCandidatePairMonitor[];
    get certificates(): CertificateMonitor[];
    get selectedIcePaths(): SelectedIcePath[];
    get selectedIcePath(): SelectedIcePath | undefined;
    get selectedIceCandidatePairs(): IceCandidatePairMonitor[];
    set connectionState(state: W3C.RtcPeerConnectionState | undefined);
    get connectionState(): W3C.RtcPeerConnectionState | undefined;
    private _updateSelectedIcePaths;
    private _checkVisited;
    close(): void;
    private _updateCodec;
    private _updateInboundRtp;
    private _updateDataChannel;
    private _updateRemoteOutboundRtp;
    private _updateOutboundRtp;
    private _updateRemoteInboundRtp;
    private _updateMediaSource;
    private _updateMediaPlayout;
    _updatePeerConnectionTransport(input: Partial<PeerConnectionTransportStats>): PeerConnectionTransportMonitor | undefined | void;
    private _updateIceTransport;
    private _updateIceCandidate;
    private _updateIceCandidatePair;
    private _updateCertificate;
    private _createOutboundTrackMonitor;
    private _createInboundTrackMonitor;
}