import WebRTCIssueDetector from 'webrtc-issue-detector';
import { ClientMetaProvider } from '../ClientMetaProvider';
import EnhancedEventEmitter from '../EnhancedEventEmitter';
import { CreateCameraVideoTrackOptions, CreateCustomAudioOptions, CreateCustomVideoOptions, CreateMicrophoneAudioTrackOptions, CreateScreenMediaOptions, JoinChannelParams, Role } from '../types/common';
import type { PeerTrackFactory } from '../types/container';
import { ClientObserverEvents, InternalObserverEvents } from '../types/engine';
import { AudioTrack, BaseTrack, Track } from '../types/media';
import { CallState } from './CallState';
import EventsQueue from './EventsQueue';
import ChannelEventHandler from './handlers/ChannelEventHandler';
import MediaEventHandler from './handlers/MediaEventHandler';
import { IntegrationsService } from './IntegrationsService';
import Logger from './Logger';
import Media from './media';
import { ProcessorsCache } from './media/streamEffects/ProcessorsCache';
import VideoTrack from './media/tracks/DefaultVideoTrack';
import ProducerCloseManager from './media/producer/ProducerCloseManager';
import { MyPeer } from './MyPeer';
import Network from './network';
import NetworkTransportPolicyManager from './network/NetworkTransportPolicyManager';
import Peer from './Peer';
import type { IPeersService } from './Peers';
import LocalMutex from './LocalMutex';
import SignalingApiClient from './signalingApiClient/SignalingApiClient';
import System from './system';
import StatsHandler from './WebRTCStats/StatsHandler';
import TransportsStatsProvider from './WebRTCStats/TransportsStatsProvider';
import { TransportsWebRTCStats } from './WebRTCStats/types';
import PeersStorage from './PeersStorage';
import { ScoresCalculator } from '../qoe/ScoresCalculator';
declare class Engine {
    #private;
    private readonly state;
    private readonly myPeer;
    private readonly integrationsService;
    private readonly processorsCache;
    private readonly mediaEventHandler;
    private readonly channelEventsHandler;
    private readonly peerTrackFactory;
    private readonly peers;
    private readonly peersStorage;
    readonly system: System;
    readonly media: Media;
    readonly network: Network;
    private readonly networkTransportPolicyManager;
    private readonly producerCloseManager;
    private readonly signalingApiClient;
    private readonly eventsQueue;
    private readonly clientEventEmitter;
    private readonly internalEventEmitter;
    private readonly statsHandler;
    private readonly transportsStatsProvider;
    private readonly localMutex;
    private readonly scoresCalculatorInstance;
    private readonly clientMetaProvider;
    private readonly webRtcIssueDetector?;
    private rejoinRequested;
    private isReleasing;
    private readonly mark;
    private readonly handleSignalingError;
    constructor(state: CallState, myPeer: MyPeer, loggerFactory: (namespace: string) => Logger, integrationsService: IntegrationsService, processorsCache: ProcessorsCache, mediaEventHandler: MediaEventHandler, channelEventsHandler: ChannelEventHandler, peerTrackFactory: PeerTrackFactory, peers: IPeersService, peersStorage: PeersStorage, system: System, media: Media, network: Network, networkTransportPolicyManager: NetworkTransportPolicyManager, producerCloseManager: ProducerCloseManager, signalingApiClient: SignalingApiClient, eventsQueue: EventsQueue, clientEventEmitter: EnhancedEventEmitter<ClientObserverEvents>, internalEventEmitter: EnhancedEventEmitter<InternalObserverEvents>, statsHandler: StatsHandler, transportsStatsProvider: TransportsStatsProvider, localMutex: LocalMutex, scoresCalculatorInstance: ScoresCalculator, clientMetaProvider: ClientMetaProvider, webRtcIssueDetector?: WebRTCIssueDetector | undefined);
    get isChannelJoined(): boolean;
    get scoresCalculator(): ScoresCalculator;
    private initialize;
    release(keepTracks?: boolean): Promise<void>;
    getPeers(): Peer[];
    get myPeerId(): string | undefined;
    confirmActivity(): Promise<void>;
    join(params: JoinChannelParams): Promise<void>;
    loadPeers(role?: Role): Promise<void>;
    requestChannelStateSync(): void;
    updateAppData(appData: Record<string, unknown>): Promise<void>;
    createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<VideoTrack>;
    createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<AudioTrack>;
    createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]>;
    createCustomAudioTrack(options: CreateCustomAudioOptions): AudioTrack;
    createCustomVideoTrack(options: CreateCustomVideoOptions): Track;
    deleteTrack(tracks: BaseTrack): Promise<void>;
    transportsStats(): TransportsWebRTCStats | undefined;
    setSignalingServerUrl(url: string): void;
    private cleanup;
    private watchInternalEvents;
    private createSelfPeerTrack;
    private triggerRejoinEventIfAppropriate;
    private watchNetworkState;
    private watchDocumentUnload;
    private createSendRecvTransports;
}
export default Engine;