/// <reference types="node" />
import { EventEmitter } from 'events';
import { ObservedClient, ObservedClientSettings } from './ObservedClient';
import { Observer } from './Observer';
import { ScoreCalculator } from './scores/ScoreCalculator';
import { CalculatedScore } from './scores/CalculatedScore';
import { Detectors } from './detectors/Detectors';
import { RemoteTrackResolver } from './utils/RemoteTrackResolver';
import { Updater } from './updaters/Updater';
import { ObservedCallEventMonitor } from './ObservedCallEventMonitor';
export type ObservedCallSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
    callId: string;
    appData?: AppData;
    remoteTrackResolvePolicy?: 'p2p' | 'mediasoup-sfu' | 'none';
    updatePolicy?: 'update-on-any-client-updated' | 'update-when-all-client-updated' | 'update-on-interval';
    updateIntervalInMs?: number;
    closeCallIfEmptyForMs?: number;
};
export type ObservedCallEvents = {
    update: [];
    newclient: [ObservedClient];
    empty: [];
    'not-empty': [];
    close: [];
};
export declare interface ObservedCall {
    on<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
    off<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
    once<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
    emit<U extends keyof ObservedCallEvents>(event: U, ...args: ObservedCallEvents[U]): boolean;
}
export declare class ObservedCall<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
    readonly observer: Observer;
    readonly detectors: Detectors;
    updater?: Updater;
    scoreCalculator: ScoreCalculator;
    readonly callId: string;
    readonly observedClients: Map<string, ObservedClient<Record<string, unknown>>>;
    readonly clientsUsedTurn: Set<string>;
    readonly calculatedScore: CalculatedScore;
    remoteTrackResolver?: RemoteTrackResolver;
    totalAddedClients: number;
    totalRemovedClients: number;
    numberOfIssues: number;
    numberOfPeerConnections: number;
    numberOfInboundRtpStreams: number;
    numberOfOutboundRtpStreams: number;
    numberOfDataChannels: number;
    maxNumberOfClients: number;
    deltaNumberOfIssues: number;
    appData: AppData;
    closed: boolean;
    startedAt?: number;
    endedAt?: number;
    closedAt?: number;
    readonly settings: Pick<ObservedCallSettings, 'closeCallIfEmptyForMs'>;
    private closeTimer?;
    constructor(settings: ObservedCallSettings<AppData>, observer: Observer);
    get numberOfClients(): number;
    get score(): number | undefined;
    close(): void;
    getObservedClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(clientId: string): ObservedClient<ClientAppData> | undefined;
    createObservedClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedClientSettings<ClientAppData>): ObservedClient<ClientAppData>;
    createEventMonitor<CTX>(context: CTX): ObservedCallEventMonitor<CTX>;
    update(): void;
    private _onClientUpdate;
    private _clientJoined;
    private _clientLeft;
}
//# sourceMappingURL=ObservedCall.d.ts.map