import { Detectors } from "../detectors/Detectors";
import { SilentAudioSourceDetector, SilentAudioSourceIssuePayload } from "../detectors/SilentAudioSourceDetector";
import { VideoCaptureBottleneckDetector, VideoCaptureBottleneckIssuePayload } from "../detectors/VideoCaptureBottleneckDetector";
import { EncoderBottleneckDetector, EncoderBottleneckIssuePayload } from "../detectors/EncoderBottleneckDetector";
import { OutboundTrackSample } from "../schema/ClientSample";
import { CalculatedScore } from "../scores/CalculatedScore";
import { MediaSourceMonitor } from "./MediaSourceMonitor";
import { OutboundRtpMonitor } from "./OutboundRtpMonitor";
import type { TrackContentType } from "./TrackMonitor";
import { IssueRegistry } from "../utils/IssueRegistry";
import { DryOutboundTrackDetector, DryOutboundTrackIssuePayload } from "../detectors/DryOutboundTrackDetector";
import { CaptureSourceLostDetector, CaptureSourceLostIssuePayload } from "../detectors/CaptureSourceLostDetector";
import { SliceConfig, SlicedWindow } from "../utils/SlicedWindow";
export type OutboundTrackContext = {
    contentType?: TrackContentType;
    paused?: boolean;
};
export type OutboundTrackWindowValues = {
    mediaSourceTotalProducedFrames: number | null;
    highestLayerTotalEncodedFrames: number | null;
};
export type OutboundTrackWindowConfig = {
    maxAllowedGapInMs: number;
    numberOfSamples: Record<'detection' | 'recovery', number>;
};
export type OutboundTrackIssues = {
    [DryOutboundTrackDetector.ISSUE_TYPE]: DryOutboundTrackIssuePayload;
    [CaptureSourceLostDetector.ISSUE_TYPE]: CaptureSourceLostIssuePayload;
    [EncoderBottleneckDetector.ISSUE_TYPE]: EncoderBottleneckIssuePayload;
    [VideoCaptureBottleneckDetector.ISSUE_TYPE]: VideoCaptureBottleneckIssuePayload;
    [SilentAudioSourceDetector.ISSUE_TYPE]: SilentAudioSourceIssuePayload;
};
export declare class OutboundTrackMonitor {
    readonly track: MediaStreamTrack;
    private _mediaSource;
    readonly direction = "outbound";
    readonly detectors: Detectors;
    readonly issues: IssueRegistry<OutboundTrackIssues>;
    readonly slicedWindow: SlicedWindow<OutboundTrackWindowValues, Record<keyof OutboundTrackWindowConfig['numberOfSamples'], SliceConfig>>;
    private _highestLayerTotalEncodedFrames;
    bitrate?: number;
    jitter?: number;
    fractionLost?: number;
    sendingPacketRate?: number;
    remoteReceivedPacketRate?: number;
    sourceEnded: boolean;
    readonly mappedOutboundRtps: Map<number, OutboundRtpMonitor>;
    private _context;
    private _detectedContentType?;
    get paused(): boolean;
    set paused(value: boolean);
    settings?: MediaTrackSettings;
    videoCaptureSettingsChanged?: boolean;
    degradedVideoCapture?: boolean;
    videoCaptureDegradation?: number;
    degradedEncodingPerformance?: boolean;
    videoEncodingDegradation?: number;
    dry?: boolean;
    silentAudioSource?: boolean;
    lostCaptureSource?: boolean;
    get contentType(): TrackContentType | undefined;
    calculatedScore: CalculatedScore;
    get score(): number | undefined;
    get scoreReasons(): Record<string, number> | undefined;
    attachments?: Record<string, unknown> | undefined;
    appData?: Record<string, unknown> | undefined;
    constructor(track: MediaStreamTrack, _mediaSource: MediaSourceMonitor, attachments?: Record<string, unknown>);
    getPeerConnection(): import("./PeerConnectionMonitor").PeerConnectionMonitor;
    getMediaSource(): MediaSourceMonitor;
    get kind(): string;
    get isScreenShare(): boolean;
    get readyState(): MediaStreamTrack['readyState'];
    setContext(context: OutboundTrackContext): void;
    highestLayer?: OutboundRtpMonitor;
    update(): void;
    private _refreshCaptureSettings;
    getOutboundRtps(): OutboundRtpMonitor[];
    createSample(): OutboundTrackSample;
}