import type { Producer, ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
import type { MediaKind, RtpCodecCapability } from 'mediasoup-client/lib/RtpParameters';
import type { AppData, RtpEncodingParameters } from 'mediasoup-client/lib/types';
import type { ParsedOutboundAudioStreamStats, ParsedOutboundVideoStreamStats } from 'webrtc-issue-detector';
import type LocalMutex from '../engine/LocalMutex';
import type Logger from '../engine/Logger';
import type Media from '../engine/media';
import type { AudioTrackProcessor } from '../engine/media/streamEffects/audio/AudioTrackProcessor';
import type { Effects } from '../engine/media/streamEffects/video/esdk/TrackProcessor';
import type MediaStreamTrackManager from '../engine/media/tracks/MediaStreamTrackManager';
import type { MyPeer } from '../engine/MyPeer';
import type Network from '../engine/network';
import type StatsHandler from '../engine/WebRTCStats/StatsHandler';
import type ProducerCloseManager from '../engine/media/producer/ProducerCloseManager';
import type EnhancedEventEmitter from '../EnhancedEventEmitter';
import type { MOSScores } from '../qoe/types';
import type { WIDStatsAdapter } from '../qoe/WIDStatsAdapter';
import type { ScoresCalculator } from '../qoe/ScoresCalculator';
import type { BaseTrackInfo, EncoderConfig, TrackLabel, TrackOutboundStats, TrackProduceParams, TrackTransformParams } from './common';
import type { InternalObserverEvents } from './engine';
export interface BaseTrackDependenciesParams {
    internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>;
    loggerFactory: (namespace: string) => Logger;
    media: Media;
    mediaStreamTrackManager: MediaStreamTrackManager;
    myPeer: MyPeer;
    network: Network;
    producerCloseManager: ProducerCloseManager;
    mutex: LocalMutex;
    statsHandler: StatsHandler;
    widStatsAdapter: WIDStatsAdapter;
    scoresCalculator: ScoresCalculator;
}
export interface BaseTrackParams {
    loggerNamespace: string;
    mediaStreamTrack: MediaStreamTrack;
    constraints: MediaStreamConstraints;
}
export interface BaseTrack {
    observer: EnhancedEventEmitter;
    mediaStreamTrack: MediaStreamTrack;
    id: string;
    kind: MediaKind;
    isPublished: boolean;
    isPaused: boolean;
    internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>;
    producerId?: string;
    videoWebRTCStats?: ParsedOutboundVideoStreamStats;
    audioWebRTCStats?: ParsedOutboundAudioStreamStats;
    connectionScores: MOSScores;
    getLabel: () => TrackLabel;
    setLabel: (label: TrackLabel) => void;
    setEncoderConfig: (encoderConfig: EncoderConfig) => void;
    getEncoderConfig: () => EncoderConfig;
    setProducer: (producer: Producer) => void;
    setStopTrackOnPause: (value: boolean) => void;
    getProducer: () => Producer | undefined;
    stopMediaStreamTrack: () => void;
    closeProducer: (stopTrack?: boolean) => Promise<void>;
    setPriority: (priority: RTCPriorityType) => Promise<void>;
    produce: ({ encodings, codecOptions, preferredCodec, transformParams, keyFrameRequestDelay, }: TrackProduceParams) => Promise<void>;
    publish: () => Promise<void>;
    unpublish: (stopTrack?: boolean) => Promise<void>;
    resume: () => Promise<void>;
    getInfo: () => Promise<BaseTrackInfo>;
    getStats: () => Promise<TrackOutboundStats | undefined>;
    replaceTrack: (track: MediaStreamTrack) => Promise<void>;
}
export interface TrackWithEncodings extends BaseTrack {
    getCodecOptions: () => ProducerCodecOptions;
    getEncodings: () => RtpEncodingParameters[];
    getPreferredCodec: () => string;
}
export interface TrackWithEffects extends BaseTrack {
    isEffectsProcessing: boolean;
}
export interface AudioTrack extends BaseTrack, TrackWithEncodings, TrackWithEffects {
    setTrackProcessor: (trackProcessor?: AudioTrackProcessor) => void;
    unsetTrackProcessor: () => void;
    enableNoiseSuppression: () => Promise<void>;
    disableNoiseSuppression: () => Promise<void>;
    pause: () => Promise<void>;
}
export interface VideoTrackPublishParams {
    keyFrameRequestDelay?: number;
}
export interface VideoTrack extends BaseTrack, TrackWithEncodings, TrackWithEffects {
    publish: (params?: VideoTrackPublishParams) => Promise<void>;
    setTransformParams: (transformParams: object) => void;
    setMaxSpatialLayer: (spatialLayer: number) => Promise<void>;
    getMaxSpatialLayer: () => number | undefined;
    enableEffects: () => Promise<void>;
    setOnEffectError: (callback: (error: Error) => void) => void;
    disableEffects: () => Promise<void>;
    applyEffects: (effects: Effects) => Promise<void>;
    resetEffects: () => void;
    setOnLoadModels: (callback: () => void) => void;
    modelsLoadProgress: number;
    pause: () => Promise<void>;
}
export type Track = AudioTrack | VideoTrack;
export type AudioTrackParams = BaseTrackParams;
export interface MediaTracksFactory {
    createAudioTrack: (params: Omit<AudioTrackParams, 'logger'>) => BaseTrack;
    createVideoTrack: (params: Omit<BaseTrackParams, 'logger'>) => BaseTrack;
}
export type ProducerAppData = AppData & {
    peerId: string;
    label: TrackLabel;
    maxSpatialLayer: number;
    encodings?: RtpEncodingParameters[];
    codecOptions?: ProducerCodecOptions;
    trackTransformParams?: TrackTransformParams;
    preferredCodec?: string;
    codec?: RtpCodecCapability;
    keyFrameRequestDelay?: number;
};
export interface InitEffectsSDKParams {
    customerId?: string;
    sdk_url?: string;
    api_url?: string;
    localDir?: string;
    version?: string;
}