import { ClientSample } from './schema/ClientSample';
import { Logger } from "./utils/logger";
import EventEmitter from 'eventemitter3';
import { AddedClientIssue, ClientEvent, ClientIssuePayload, ClientMetaData, ClientMonitorEvents, ClientPayload, RaisedClientIssue, ResolvedClientIssue } from './ClientMonitorEvents';
import { PeerConnectionMonitor } from './monitors/PeerConnectionMonitor';
import { AppliedClientMonitorConfig, ClientMonitorConfig, ClientMonitorSourceType } from './ClientMonitorConfig';
import { PartialBy } from './utils/common';
import { Detectors } from './detectors/Detectors';
import { OutboundTrackContext, OutboundTrackMonitor } from './monitors/OutboundTrackMonitor';
import { InboundTrackContext, InboundTrackMonitor } from './monitors/InboundTrackMonitor';
import { TrackMonitor } from './monitors/TrackMonitor';
import { ScoreCalculator } from "./scores/ScoreCalculator";
import { ClientEventPayloadProvider } from './sources/ClientEventPayloadProvider';
import { IssueRegistry } from './utils/IssueRegistry';
import { ExtensionStatsMonitor } from './monitors/ExtensionStatsMonitor';
import { SliceConfig, SlicedWindow } from './utils/SlicedWindow';
export type ExtensionStatProvider = () => {
    type: string;
    payload?: ClientPayload;
    id?: string;
} | Promise<{
    type: string;
    payload?: ClientPayload;
    id?: string;
}>;
export type ClientWindowValues = {
    totalVideoEncodeTimeInMs: number | null;
    totalVideoDecodeTimeInMs: number | null;
};
export type ClientWindowConfig = {
    maxAllowedGapInMs: number;
    numberOfSamples: Record<'detection' | 'recovery', number>;
};
export declare class ClientMonitor<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter<ClientMonitorEvents> {
    static readonly samplingSchemaVersion = "3.7.0";
    readonly createdAt: number;
    readonly mappedPeerConnections: Map<string, PeerConnectionMonitor>;
    readonly mappedExtensionStatsMonitors: Map<string, ExtensionStatsMonitor>;
    readonly detectors: Detectors;
    readonly clientEventPayloadProvider: ClientEventPayloadProvider;
    readonly extensionStatsProviders: Set<ExtensionStatProvider>;
    readonly activeIssues: IssueRegistry;
    readonly slicedWindow: SlicedWindow<ClientWindowValues, Record<keyof ClientWindowConfig['numberOfSamples'], SliceConfig>>;
    scoreCalculator: ScoreCalculator;
    readonly logger: Logger;
    closed: boolean;
    lastSampledAt: number;
    lastCollectingStatsAt: number;
    cpuPerformanceAlertOn: boolean;
    cpuUtilization?: number;
    activeTab: boolean;
    sendingAudioBitrate: number;
    sendingVideoBitrate: number;
    receivingAudioBitrate: number;
    receivingVideoBitrate: number;
    totalAvailableIncomingBitrate: number;
    totalAvailableOutgoingBitrate: number;
    avgRttInSec: number;
    score: number;
    scoreReasons?: Record<string, number>;
    private _browser?;
    private readonly _sources;
    private _timer?;
    private _samplingTick;
    private _collectingCounter;
    private _clientEvents;
    private _clientMetaItems;
    private _clientIssues;
    private _extensionStats;
    private _bufferedClientSamples?;
    durationOfCollectingStatsInMs: number;
    readonly config: AppliedClientMonitorConfig<AppData>;
    private readonly _pendingInboundTrackContexts;
    private readonly _pendingOutboundTrackContexts;
    attachments?: Record<string, unknown>;
    constructor(config?: Partial<ClientMonitorConfig<AppData>>);
    get clientId(): string | undefined;
    set clientId(clientId: string | undefined);
    get callId(): string | undefined;
    set callId(callId: string | undefined);
    get appData(): AppData;
    set appData(appData: AppData);
    set browser(browser: {
        name: 'chrome' | 'firefox' | 'safari' | 'edge' | 'opera' | 'unknown';
        version: string;
    } | undefined);
    get uptimeInMs(): number;
    set onsamplecreated(listener: (...args: ClientMonitorEvents['sample-created']) => void);
    set onstatscollected(listener: (...args: ClientMonitorEvents['stats-collected']) => void);
    set onclientevent(listener: (...args: ClientMonitorEvents['client-event']) => void);
    set onissue(listener: (...args: ClientMonitorEvents['issue']) => void);
    get browser(): {
        name: "chrome" | "firefox" | "safari" | "edge" | "opera" | "unknown";
        version: string;
    } | undefined;
    close(): void;
    on<K extends keyof ClientMonitorEvents>(event: K, listener: (...args: ClientMonitorEvents[K]) => void): this;
    once<K extends keyof ClientMonitorEvents>(event: K, listener: (...args: ClientMonitorEvents[K]) => void): this;
    off<K extends keyof ClientMonitorEvents>(event: K, listener: (...args: ClientMonitorEvents[K]) => void): this;
    emit(event: keyof ClientMonitorEvents, ...args: ClientMonitorEvents[typeof event]): boolean;
    collect(): Promise<[string, RTCStats[]][]>;
    getPeerConnectionMonitor(peerConnectionId: string): PeerConnectionMonitor | undefined;
    getExtensionStatsPayload<T extends Record<string, unknown>>(id: string): T | undefined;
    getExtensionStatsMonitor(id: string): ExtensionStatsMonitor | undefined;
    setScore<T extends Record<string, number>>(score: number, ownReasons?: T, aggregatedReasons?: Record<string, number>): void;
    createSample(): ClientSample | undefined;
    addPeerConnectionMonitor(peerConnectionMonitor: PeerConnectionMonitor): void;
    addClientJoinEvent(event?: {
        payload?: ClientPayload;
        timestamp?: number;
    }): void;
    addClientLeftEvent(event?: {
        payload?: ClientPayload;
        timestamp?: number;
    }): void;
    addEvent<Payload extends ClientPayload = ClientPayload>(event: PartialBy<ClientEvent, 'timestamp'> & {
        payload?: Payload;
    }): void;
    addIssue<T extends ClientIssuePayload = ClientIssuePayload>(input: {
        type: string;
        payload?: T;
        timestamp?: number;
        includeInSample?: boolean;
    }): AddedClientIssue<T> | undefined;
    raiseIssue<T extends ClientIssuePayload = ClientIssuePayload>(key: string, input: {
        type: string;
        payload?: T;
        timestamp?: number;
        includeInSample?: boolean;
    }): RaisedClientIssue<T> | undefined;
    resolveIssue<T extends ClientIssuePayload = ClientIssuePayload>(key: string, input: {
        comment?: string;
        payload?: T;
        resolvedAt?: number;
    }): ResolvedClientIssue | undefined;
    getActiveIssuesByType(type: string): RaisedClientIssue[];
    isIssueActive(key: string): boolean;
    private _bufferIssueForSample;
    addMetaData(metaData: PartialBy<ClientMetaData, 'timestamp'>): void;
    addExtensionStats(stats: {
        type: string;
        payload?: ClientPayload;
        id?: string;
    }): void;
    addSource(source: unknown, type?: ClientMonitorSourceType): void;
    removeSource(source: unknown, type?: ClientMonitorSourceType): void;
    fetchUserAgentData(): any;
    watchNavigatorMediaDevices(): void;
    get peerConnections(): PeerConnectionMonitor[];
    get codecs(): import(".").CodecMonitor[];
    get inboundRtps(): import(".").InboundRtpMonitor[];
    get outboundRtps(): import(".").OutboundRtpMonitor[];
    get remoteInboundRtps(): import(".").RemoteInboundRtpMonitor[];
    get remoteOutboundRtps(): import(".").RemoteOutboundRtpMonitor[];
    get mediaSources(): import(".").MediaSourceMonitor[];
    get mediaPlayouts(): import(".").MediaPlayoutMonitor[];
    get dataChannels(): import(".").DataChannelMonitor[];
    get iceCandidatePairs(): import(".").IceCandidatePairMonitor[];
    get iceCandidates(): import(".").IceCandidateMonitor[];
    get iceTransports(): import(".").IceTransportMonitor[];
    get certificates(): import(".").CertificateMonitor[];
    get tracks(): TrackMonitor[];
    getTrackMonitor(trackId: string): TrackMonitor | undefined;
    getInboundTrackMonitor(trackId: string): InboundTrackMonitor | undefined;
    getOutboundTrackMonitor(trackId: string): OutboundTrackMonitor | undefined;
    setInboundTrackContext(trackId: string, context: InboundTrackContext): void;
    setOutboundTrackContext(trackId: string, context: OutboundTrackContext): void;
    takePendingInboundTrackContext(trackId: string): InboundTrackContext | undefined;
    takePendingOutboundTrackContext(trackId: string): OutboundTrackContext | undefined;
    setCollectingPeriod(collectingPeriodInMs: number): void;
    setSamplingPeriod(samplingPeriodInMs: number): void;
    private _setSamplingTick;
    private _flushBufferedClientSamples;
    private _raiseIssue;
    private _updateIssue;
    private _resolveIssue;
}