import { EventEmitterProxy } from 'events-constructor';
import { ApiManager } from '../ApiManager';
import { AutoConnectorManager, IAutoConnectorOptions } from '../AutoConnectorManager';
import { CallManager, TGetUri } from '../CallManager';
import { CallReconnectManager, ICallReconnectOptions } from '../CallReconnectManager';
import { ConnectionManager } from '../ConnectionManager';
import { ConnectionQueueManager } from '../ConnectionQueueManager';
import { ContentedStreamManager } from '../ContentedStreamManager';
import { IncomingCallManager } from '../IncomingCallManager';
import { PresentationManager } from '../PresentationManager';
import { SessionManager } from '../SessionManager';
import { StatsManager, TOutboundVideoVerificationStrictness } from '../StatsManager';
import { VideoSendingBalancerManager } from '../VideoSendingBalancerManager';
import { MainStreamHealthMonitor } from '../MainStreamHealthMonitor';
import { TConnectAndCallSessionParameters, TConnectAndCallSessionResult } from '../ConnectAndCallSession';
import { TJsSIP } from '../types';
import { TContentHint, TOnAddedTransceiver } from '../utils/peerConnection';
import { IBalancerOptions } from '../VideoSendingBalancer';
import { TEventMap } from './events';
declare class SipConnector extends EventEmitterProxy<TEventMap> {
    readonly connectionManager: ConnectionManager;
    readonly connectionQueueManager: ConnectionQueueManager;
    readonly contentedStreamManager: ContentedStreamManager;
    readonly callManager: CallManager;
    readonly autoConnectorManager: AutoConnectorManager;
    readonly callReconnectManager: CallReconnectManager;
    readonly apiManager: ApiManager;
    readonly incomingCallManager: IncomingCallManager;
    readonly presentationManager: PresentationManager;
    readonly statsManager: StatsManager;
    readonly videoSendingBalancerManager: VideoSendingBalancerManager;
    readonly sessionManager: SessionManager;
    readonly mainStreamHealthMonitor: MainStreamHealthMonitor;
    private readonly callSessionState;
    private readonly peerToPeerManager;
    private readonly mainStreamRecovery;
    private readonly preferredMimeTypesVideoCodecs?;
    private readonly excludeMimeTypesVideoCodecs?;
    private activeConnectAndCallSession;
    constructor({ JsSIP }: {
        JsSIP: TJsSIP;
    }, { preferredMimeTypesVideoCodecs, excludeMimeTypesVideoCodecs, videoBalancerOptions, autoConnectorOptions, callReconnectOptions, numberOfConnectionAttempts, minConsecutiveProblemSamplesCount, throttleRecoveryTimeout, }?: {
        preferredMimeTypesVideoCodecs?: string[];
        excludeMimeTypesVideoCodecs?: string[];
        videoBalancerOptions?: Omit<IBalancerOptions, 'getMaxResolution'>;
        autoConnectorOptions?: IAutoConnectorOptions;
        callReconnectOptions?: ICallReconnectOptions;
        numberOfConnectionAttempts?: number;
        minConsecutiveProblemSamplesCount?: number;
        throttleRecoveryTimeout?: number;
    });
    get requestedConnection(): boolean;
    get isPendingConnect(): boolean;
    get isPendingInitUa(): boolean;
    get connectionState(): import('../ConnectionManager').EConnectionStatus;
    get isRegistered(): boolean;
    get isRegisterConfig(): boolean;
    get socket(): import('@krivega/jssip').WebSocketInterface | undefined;
    get requestedCall(): boolean;
    get connection(): RTCPeerConnection | undefined;
    get isCallActive(): boolean;
    get localPorts(): number[];
    get remoteCallerData(): IncomingCallManager['remoteCallerData'];
    get isAvailableIncomingCall(): IncomingCallManager['isAvailableIncomingCall'];
    private get isDirectP2PRoom();
    private get isPresentationCall();
    private get isOptionalPresentationPermission();
    connect: ConnectionManager['connect'];
    disconnect: () => Promise<void>;
    register: () => Promise<import('@krivega/jssip').RegisteredEvent>;
    unregister: () => Promise<import('@krivega/jssip').UnRegisteredEvent>;
    tryRegister: () => Promise<import('@krivega/jssip').RegisteredEvent>;
    sendOptions: (target: Parameters<ConnectionManager["sendOptions"]>[0], body?: Parameters<ConnectionManager["sendOptions"]>[1], extraHeaders?: Parameters<ConnectionManager["sendOptions"]>[2]) => Promise<void>;
    ping: (body?: Parameters<ConnectionManager["ping"]>[0], extraHeaders?: Parameters<ConnectionManager["ping"]>[1]) => Promise<void>;
    checkTelephony: ConnectionManager['checkTelephony'];
    isConfigured: () => boolean;
    getConnectionConfiguration: () => import('../ConnectionManager').TConnectionConfig | undefined;
    getUri: TGetUri;
    startAutoConnect: (...args: Parameters<AutoConnectorManager["start"]>) => Promise<Awaited<ReturnType<AutoConnectorManager["start"]>>>;
    stopAutoConnect: AutoConnectorManager['stop'];
    connectAndCallToServer: (parameters: TConnectAndCallSessionParameters) => Promise<TConnectAndCallSessionResult>;
    call: (params: Omit<Parameters<CallManager["startCall"]>[2], "isPresentationCall">, options?: {
        autoRedial?: boolean;
    }) => Promise<RTCPeerConnection>;
    hangUp: CallManager['endCall'];
    armCallAutoRedial: CallReconnectManager['arm'];
    disarmCallAutoRedial: CallReconnectManager['disarm'];
    forceCallReconnect: CallReconnectManager['forceReconnect'];
    cancelCurrentCallReconnectAttempt: CallReconnectManager['cancelCurrentAttempt'];
    answerToIncomingCall: (params: Parameters<CallManager["answerToIncomingCall"]>[1]) => Promise<RTCPeerConnection>;
    declineToIncomingCall: IncomingCallManager['declineToIncomingCall'];
    getEstablishedRTCSession: CallManager['getEstablishedRTCSession'];
    getRemoteStreams: CallManager['getRemoteStreams'];
    getRecvQuality: CallManager['getRecvQuality'];
    setRecvQuality: CallManager['setRecvQuality'];
    applyQuality: CallManager['applyQuality'];
    /**
     * Заменяет локальный media stream в активной MCU-сессии.
     *
     * Опциональная верификация (`waitForOutboundVideoPackets: true`):
     * 1. Сначала выполняется обычный `callManager.replaceMediaStream` (replaceTrack / reinvite).
     * 2. Затем `statsManager.waitForOutboundVideoPackets` ждёт подтверждения из WebRTC stats,
     *    что outbound-rtp реально шлёт данные с video track из переданного `mediaStream`.
     * 3. Режим строгости задаётся через `waitForOutboundVideoPacketsStrictness`
     *    (`fast` | `normal` | `strict`, по умолчанию в StatsManager — `normal`).
     *
     * Опции wait не передаются в RTC-сессию — они обрабатываются только на уровне SipConnector.
     */
    replaceMediaStream: (mediaStream: Parameters<CallManager["replaceMediaStream"]>[0], options?: Parameters<CallManager["replaceMediaStream"]>[1] & {
        waitForOutboundVideoPackets?: boolean;
        waitForOutboundVideoPacketsTimeout?: number;
        waitForOutboundVideoPacketsStrictness?: TOutboundVideoVerificationStrictness;
    }) => Promise<void>;
    startPresentation(videoTrack: MediaStreamVideoTrack, options?: {
        isNeedReinvite?: boolean;
        contentHint?: TContentHint;
        degradationPreference?: RTCDegradationPreference;
        sendEncodings?: RTCRtpEncodingParameters[];
        onAddedTransceiver?: TOnAddedTransceiver;
        callLimit?: number;
    }): Promise<MediaStreamVideoTrack>;
    stopPresentation(): Promise<MediaStreamVideoTrack | undefined>;
    updatePresentation(videoTrack: MediaStreamVideoTrack, options?: {
        isNeedReinvite?: boolean;
        contentHint?: TContentHint;
        degradationPreference?: RTCDegradationPreference;
        sendEncodings?: RTCRtpEncodingParameters[];
        onAddedTransceiver?: TOnAddedTransceiver;
    }): Promise<MediaStreamVideoTrack | undefined>;
    waitChannels(...args: Parameters<ApiManager['waitChannels']>): Promise<import('../ApiManager').TChannels>;
    waitSyncMediaState(...args: Parameters<ApiManager['waitSyncMediaState']>): Promise<{
        isSyncForced: boolean;
    }>;
    sendDTMF(...args: Parameters<ApiManager['sendDTMF']>): Promise<void>;
    sendChannels(...args: Parameters<ApiManager['sendChannels']>): Promise<void>;
    sendMediaState(...args: Parameters<ApiManager['sendMediaState']>): Promise<void>;
    sendRefusalToTurnOn(...args: Parameters<ApiManager['sendRefusalToTurnOn']>): Promise<void>;
    sendRefusalToTurnOnMic(...args: Parameters<ApiManager['sendRefusalToTurnOnMic']>): Promise<void>;
    sendRefusalToTurnOnCam(...args: Parameters<ApiManager['sendRefusalToTurnOnCam']>): Promise<void>;
    askPermissionToEnableCam(...args: Parameters<ApiManager['askPermissionToEnableCam']>): Promise<void>;
    setMinConsecutiveProblemSamplesCount: (minConsecutiveProblemSamplesCount: number) => void;
    setThrottleRecoveryTimeout: (throttleRecoveryTimeout: number) => void;
    private readonly endCallWithoutSessionRouting;
    private clearActiveConnectAndCallSession;
    private clearActiveConnectAndCallSessionWhenClosed;
    private subscribeDisconnectedFromOutOfCall;
    private subscribeConnectedWithConfigurationFromOutOfCall;
    private mayBeStopPresentationAndNotify;
    private subscribeToApiEvents;
    private readonly sendOffer;
    private setCodecPreferences;
    private subscribe;
    private subscribeToMainStreamHealthMonitorEvents;
    private readonly bridgeEvents;
    private readonly resolveHandleAddTransceiver;
    private getMaxAvailableResolution;
    private readonly resolveMainStreamSendEncodings;
}
export default SipConnector;