import { EventEmitterProxy } from 'events-constructor';
import { AutoConnectorManager } from '../AutoConnectorManager';
import { CallManager } from '../CallManager';
import { CallReconnectManager } from '../CallReconnectManager';
import { CallSessionState } from '../CallSessionState';
import { ConnectionManager } from '../ConnectionManager';
import { IncomingCallManager } from '../IncomingCallManager';
import { PresentationManager } from '../PresentationManager';
import { TEventMap } from './events';
import { TSessionMachines, TSessionSnapshot } from './types';
type TEqualityFunction<T> = (previous: T, next: T) => boolean;
type TSelector<T> = (snapshot: TSessionSnapshot) => T;
type TCallSessionSource = Pick<CallSessionState, 'getSnapshot' | 'subscribe'>;
type TSessionManagerDeps = {
    connectionManager: Pick<ConnectionManager, 'stateMachine'>;
    callManager: Pick<CallManager, 'stateMachine'>;
    incomingCallManager: Pick<IncomingCallManager, 'stateMachine'>;
    presentationManager: Pick<PresentationManager, 'stateMachine'>;
    autoConnectorManager: Pick<AutoConnectorManager, 'stateMachine'>;
    callReconnectManager: Pick<CallReconnectManager, 'stateMachine'>;
    callSessionState: TCallSessionSource;
};
declare class SessionManager extends EventEmitterProxy<TEventMap> {
    readonly machines: TSessionMachines;
    private readonly callSessionState;
    private currentSnapshot;
    private readonly subscribers;
    private readonly actorSubscriptions;
    constructor(deps: TSessionManagerDeps);
    getSnapshot(): TSessionSnapshot;
    subscribe(listener: (snapshot: TSessionSnapshot) => void): () => void;
    subscribe<T>(selector: TSelector<T>, listener: (value: T) => void, equals?: TEqualityFunction<T>): () => void;
    stop(): void;
    private readonly notifySubscribers;
}
export default SessionManager;