import { BlockedStunRequestsDetector, BlockedTransportIssuePayload } from "../detectors/BlockedStunRequestsDetector";
import { IssueRegistry } from "../utils/IssueRegistry";
import { SliceConfig, SlicedWindow } from "../utils/SlicedWindow";
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 { UplinkCongestionDetector, UplinkCongestionIssuePayload } from "../detectors/UplinkCongestionDetector";
import { DownlinkCongestionDetector, DownlinkCongestionIssuePayload } from "../detectors/DownlinkCongestionDetector";
import { InboundTrackMonitor } from "./InboundTrackMonitor";
import { OutboundTrackMonitor } from "./OutboundTrackMonitor";
import { CalculatedScore } from "../scores/CalculatedScore";
import { IceDisconnectedDetector, IceDisconnectedIssuePayload } from "../detectors/IceDisconnectedDetector";
import { IceConnectionFailedDetector, IceConnectionFailedIssuePayload } from "../detectors/IceConnectionFailedDetector";
import { IceTransportStalledDetector, IceTransportStalledIssuePayload } from "../detectors/IceTransportStalledDetector";
import { UnstableIcePathDetector, UnstableIcePathIssuePayload } from "../detectors/UnstableIcePathDetector";
import { IceEstablishmentFailedDetector, IceEstablishmentFailedIssuePayload } from "../detectors/IceEstablishmentFailedDetector";
import { DtlsHandshakeFailedDetector, DtlsHandshakeFailedIssuePayload } from "../detectors/DtlsHandshakeFailedDetector";
import { DtlsHandshakeStalledDetector, DtlsHandshakeStalledIssuePayload } from "../detectors/DtlsHandshakeStalledDetector";
import { IceReachabilityDetector, NoAvailableIceCandidateIssuePayload } from "../detectors/IceReachabilityDetector";
import { RtpSenderStalledDetector, RtpSenderStalledIssuePayload } from "../detectors/RtpSenderStalledDetector";
import { TransportDemuxStalledDetector, TransportDemuxStalledIssuePayload } from "../detectors/TransportDemuxStalledDetector";
import { TransportDelayDetector, TransportDelayIssuePayload } from "../detectors/TransportDelayDetector";
import { TransportLossDetector, TransportLossIssuePayload } from "../detectors/TransportLossDetector";
import { BlockedOutboundMediaDetector, BlockedOutboundMediaIssuePayload } from "../detectors/BlockedOutboundMediaDetector";
import { BlockedInboundMediaDetector, BlockedInboundMediaIssuePayload } from "../detectors/BlockedInboundMediaDetector";
import { StatsCollector } from "../collectors/StatsCollector";
import { StatsAdapters } from "../adapters/StatsAdapters";
import { SelectedIcePath } from "./SelectedIcePath";
import { PeerConnectionSample, PeerConnectionTransportStats, QualityLimitationDurations } from "../schema/ClientSample";
import { TrackMonitor } from './TrackMonitor';
export type PeerConnectionMonitorEvents = {
    'close': [];
    'update': [];
    'stats': [W3C.RtcStats[]];
};
export type PeerConnectionQualityLimitationReason = keyof QualityLimitationDurations;
export type PeerConnectionWindowValues = {
    totalRtcpRoundTripTimeInMs: number | null;
    totalRtcpRoundTripMeasurements: number | null;
    totalIceRoundTripTimeInMs: number | null;
    totalIceResponsesReceived: number | null;
};
export type PeerConnectionWindowConfig = {
    maxAllowedGapInMs: number;
    numberOfSamples: Record<'detection' | 'recovery', number>;
};
export type PeerConnectionIssues = {
    [BlockedInboundMediaDetector.ISSUE_TYPE]: BlockedInboundMediaIssuePayload;
    [BlockedStunRequestsDetector.ISSUE_TYPE]: BlockedTransportIssuePayload;
    [BlockedOutboundMediaDetector.ISSUE_TYPE]: BlockedOutboundMediaIssuePayload;
    [DownlinkCongestionDetector.ISSUE_TYPE]: DownlinkCongestionIssuePayload;
    [DtlsHandshakeFailedDetector.ISSUE_TYPE]: DtlsHandshakeFailedIssuePayload;
    [DtlsHandshakeStalledDetector.ISSUE_TYPE]: DtlsHandshakeStalledIssuePayload;
    [IceConnectionFailedDetector.ISSUE_TYPE]: IceConnectionFailedIssuePayload;
    [IceDisconnectedDetector.ISSUE_TYPE]: IceDisconnectedIssuePayload;
    [IceEstablishmentFailedDetector.ISSUE_TYPE]: IceEstablishmentFailedIssuePayload;
    [IceReachabilityDetector.ISSUE_TYPE]: NoAvailableIceCandidateIssuePayload;
    [IceTransportStalledDetector.ISSUE_TYPE]: IceTransportStalledIssuePayload;
    [RtpSenderStalledDetector.ISSUE_TYPE]: RtpSenderStalledIssuePayload;
    [TransportDelayDetector.ISSUE_TYPE]: TransportDelayIssuePayload;
    [TransportDemuxStalledDetector.ISSUE_TYPE]: TransportDemuxStalledIssuePayload;
    [TransportLossDetector.ISSUE_TYPE]: TransportLossIssuePayload;
    [UnstableIcePathDetector.ISSUE_TYPE]: UnstableIcePathIssuePayload;
    [UplinkCongestionDetector.ISSUE_TYPE]: UplinkCongestionIssuePayload;
};
export declare class PeerConnectionMonitor extends EventEmitter<PeerConnectionMonitorEvents> {
    readonly peerConnectionId: string;
    readonly statsCollector: StatsCollector;
    readonly parent: ClientMonitor;
    private readonly logger;
    attachments?: Record<string, unknown> | undefined;
    private static readonly LIMITATION_PRIORITY;
    readonly statsAdapters: StatsAdapters;
    readonly detectors: Detectors;
    readonly issues: IssueRegistry<PeerConnectionIssues>;
    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;
    dataChannelSendingBitrate: number;
    dataChannelReceivingBitrate: number;
    outboundFractionLost: number;
    inboundFractionalLost: number;
    avgInboundFractionLost?: number;
    avgOutboundFractionLost?: number;
    avgInboundJitterInMs?: number;
    transportStability?: number;
    deltaTime?: number | undefined;
    statsClockTime: number;
    readonly slicedWindow: SlicedWindow<PeerConnectionWindowValues, Record<keyof PeerConnectionWindowConfig['numberOfSamples'], SliceConfig>>;
    private _previousNewestTimestamp?;
    totalInboundPacketsLost?: number;
    totalInboundPacketsReceived?: number;
    totalOutboundPacketsSent?: number;
    totalOutboundPacketsReceived?: number;
    totalOutboundPacketsLost?: number;
    totalDataChannelBytesSent?: number;
    totalDataChannelBytesReceived?: number;
    totalSentAudioBytes?: number;
    totalSentVideoBytes?: number;
    totalReceivedAudioBytes?: number;
    totalReceivedVideoBytes?: number;
    totalVideoEncodeTimeInMs?: number;
    totalVideoDecodeTimeInMs?: number;
    totalAvailableIncomingBitrate?: number;
    totalAvailableOutgoingBitrate?: number;
    totalPacketSendDelayInSec?: number;
    deltaInboundPacketsLost?: number;
    deltaInboundPacketsReceived?: number;
    deltaOutboundPacketsSent?: number;
    deltaOutboundPacketsReceived?: number;
    deltaOutboundPacketsLost?: number;
    deltaAudioBytesSent?: number;
    deltaVideoBytesSent?: number;
    deltaAudioBytesReceived?: number;
    deltaVideoBytesReceived?: number;
    deltaDataChannelBytesReceived?: number;
    deltaDataChannelBytesSent?: number;
    deltaPacketSendDelayInSec?: number;
    deltaVideoPacketsSent?: number;
    deltaVideoEncodeTimeInMs?: number;
    deltaVideoDecodeTimeInMs?: number;
    avgPacketSendDelayInMs?: number;
    deltaInboundVideoJitterBufferDelayInSec?: number;
    deltaInboundVideoJitterBufferEmittedCount?: number;
    avgInboundVideoJitterBufferDelayInMs?: number;
    uplinkCongested: boolean;
    uplinkVideoCongestionSeverity?: number;
    downlinkCongested: boolean;
    downlinkVideoCongestionSeverity?: number;
    cpulimited: boolean;
    stalledRtpSender?: boolean;
    stalledTransportDemux?: boolean;
    hasInboundMedia: boolean;
    hasOutboundMedia: boolean;
    hasInboundVideo: boolean;
    qualityLimitationReason?: PeerConnectionQualityLimitationReason;
    iceRttInSec?: number;
    ewmaIceRttInSec?: number;
    rtcpRttInSec?: number;
    ewmaRtcpRttInSec?: number;
    connectingStartedAt?: number;
    connectedAt?: number;
    private _connectionState?;
    iceState?: W3C.RtcIceTransportState;
    iceGatheringState?: string;
    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;
    congested: boolean;
    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[];
    private _feedSlicedWindow;
    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 localIceCandidates(): IceCandidateMonitor[];
    get iceCandidatePairs(): IceCandidatePairMonitor[];
    get certificates(): CertificateMonitor[];
    get selectedIcePaths(): SelectedIcePath[];
    get selectedIcePath(): SelectedIcePath | undefined;
    get blockedTransport(): boolean;
    get selectedIceCandidatePairs(): IceCandidatePairMonitor[];
    private static readonly ICE_STATE_SEVERITY;
    private _mostSevereIceState;
    set connectionState(state: W3C.RtcPeerConnectionState | undefined);
    get connectionState(): W3C.RtcPeerConnectionState | undefined;
    private _updateSelectedIcePaths;
    private _updatePeerConnectionLimitationReason;
    private _refreshTransportStability;
    private _updateTransportQualityAverages;
    private _hasLiveTrack;
    private _checkVisited;
    getTrackMonitor(trackId: string): TrackMonitor | undefined;
    getInboundTrackMonitor(trackId: string): InboundTrackMonitor | undefined;
    getOutboundTrackMonitor(trackId: string): OutboundTrackMonitor | undefined;
    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;
}