import type { types } from 'mediasoup-client';
import type { ParsedInboundAudioStreamStats, ParsedInboundVideoStreamStats } from 'webrtc-issue-detector';
import { PEER_EVENTS, TRACK_EVENTS } from '../../../constants/events';
import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
import { type PeerTrackInfo, type PreferredLayersParams, type SpatialLayerParams, TrackLabel } from '../../../types/common';
import type { PeerConsumerFactory } from '../../../types/container';
import type { CallState } from '../../CallState';
import type Logger from '../../Logger';
import type Network from '../../network';
import type PeerConsumer from '../../PeerConsumer';
import type StatsHandler from '../../WebRTCStats/StatsHandler';
import type Media from '../index';
import type { MOSScores } from '../../../qoe/types';
import type { WIDStatsAdapter } from '../../../qoe/WIDStatsAdapter';
import type { ScoresCalculator } from '../../../qoe/ScoresCalculator';
export interface PeerTrackDependencies {
    callState: CallState;
    loggerFactory: (namespace: string) => Logger;
    media: Media;
    network: Network;
    peerConsumerFactory: PeerConsumerFactory;
    widStatsAdapter: WIDStatsAdapter;
    scoresCalculator: ScoresCalculator;
}
interface PeerTrackConstructor extends PeerTrackDependencies {
    mediaStreamTrack: MediaStreamTrack;
    label: TrackLabel;
    consumer?: PeerConsumer;
    muted: boolean;
    paused: boolean;
    onClose: () => void;
    peerEventEmitter: EnhancedEventEmitter;
    statsHandler: StatsHandler;
}
interface PeerTrackObserverEvents {
    [PEER_EVENTS.trackStart]: [PeerTrack];
    [PEER_EVENTS.trackEnd]: [PeerTrack];
    [TRACK_EVENTS.volumeChanged]: [{
        value: number;
    }];
    [PEER_EVENTS.trackFailed]: [PeerTrack];
    [PEER_EVENTS.trackPaused]: [PeerTrack];
    [PEER_EVENTS.trackResumed]: [PeerTrack];
}
interface CloseTrackParams {
    closeRemote?: boolean;
}
declare class PeerTrack {
    #private;
    readonly label: TrackLabel;
    consumer?: PeerConsumer;
    readonly observer: EnhancedEventEmitter<PeerTrackObserverEvents>;
    constructor(payload: PeerTrackConstructor);
    get videoWebRTCStats(): ParsedInboundVideoStreamStats | undefined;
    get audioWebRTCStats(): ParsedInboundAudioStreamStats | undefined;
    get connectionScores(): MOSScores;
    get logCtx(): Record<string, unknown>;
    get volume(): number;
    get isRemote(): boolean;
    get mediaStreamTrack(): MediaStreamTrack;
    get kind(): types.MediaKind;
    get isPaused(): boolean;
    get isMuted(): boolean;
    get consumerId(): string | undefined;
    get currentSpatialLayer(): number;
    close({ closeRemote }?: CloseTrackParams): Promise<void>;
    mute(): Promise<void>;
    unmute(): Promise<void>;
    pause(pauseRemote?: boolean): Promise<void>;
    resume(resumeRemote?: boolean): Promise<void>;
    private resumeConsumer;
    private pauseConsumer;
    requestVideoPreferredLayers({ spatialLayer, temporalLayer }: PreferredLayersParams): Promise<void>;
    requestKeyFrame(): Promise<void>;
    getVideoAvailableLayers(): SpatialLayerParams[] | undefined;
    getInfo(): Promise<PeerTrackInfo>;
    private getOutboundStats;
    private requestMaxSpatialLayer;
    private checkConsumerState;
    setVolume(value: number): void;
    private closeConsumer;
    private restartConsumer;
    private isInboundRTPStreamActive;
    private clearCheckStateTimeout;
}
export default PeerTrack;