import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
import { mtp, tl } from '../tl/index.js';
import { ICorePlatform } from '../types/platform.js';
import { Logger } from '../utils/index.js';
import { PersistentConnectionParams, PersistentConnection } from './persistent-connection.js';
import { ServerSaltManager } from './server-salt.js';
import { Emitter } from '@fuman/utils';
import { MtprotoSession } from './mtproto-session.js';
export interface SessionConnectionParams extends PersistentConnectionParams {
    initConnection: tl.RawInitConnectionRequest;
    inactivityTimeout?: number;
    pingInterval: number;
    layer: number;
    disableUpdates?: boolean;
    withUpdates?: boolean;
    isMainConnection: boolean;
    isMainDcConnection: boolean;
    usePfs?: boolean;
    salts: ServerSaltManager;
    readerMap: TlReaderMap;
    writerMap: TlWriterMap;
    platform: ICorePlatform;
}
/**
 * A connection to a single DC.
 */
export declare class SessionConnection extends PersistentConnection {
    readonly params: SessionConnectionParams;
    private _flushTimer;
    private _queuedDestroySession;
    private _pendingWaitForUnencrypted;
    private _usePfs;
    private _isPfsBindingPending;
    private _isPfsBindingPendingInBackground;
    private _pfsUpdateTimeout?;
    private _inactivityPendingFlush;
    private _readerMap;
    private _writerMap;
    private _crypto;
    private _salts;
    readonly _session: MtprotoSession;
    private _pingInterval;
    readonly onDisconnect: Emitter<void>;
    readonly onKeyChange: Emitter<Uint8Array | null>;
    readonly onTmpKeyChange: Emitter<[Uint8Array, number] | null>;
    readonly onFloodDone: Emitter<void>;
    readonly onRequestAuth: Emitter<void>;
    readonly onAuthBegin: Emitter<void>;
    readonly onUpdate: Emitter<tl.TypeUpdates>;
    readonly onFutureSalts: Emitter<mtp.RawMt_future_salt[]>;
    private _triedReconnectingOn404;
    constructor(params: SessionConnectionParams, log: Logger);
    private _online;
    getAuthKey(temp?: boolean): Uint8Array | null;
    setUsePfs(usePfs: boolean): void;
    onClosed(): void;
    destroy(): Promise<void>;
    reset(forever?: boolean): void;
    onConnected(): void;
    protected handleError(error: Error): void;
    protected onConnectionUsable(): void;
    _authorize(): void;
    private _authorizePfs;
    waitForUnencryptedMessage(timeout?: number): Promise<Uint8Array>;
    private _warnedAboutUpdates;
    protected onMessage(data: Uint8Array): void;
    private _handleRawMessage;
    private _handleMessage;
    private _onRpcResult;
    private _processPendingChainedFails;
    private _onMessageAcked;
    private _onAllFailed;
    private _onMessageFailed;
    private _registerOutgoingMsgId;
    private _onPong;
    private _onBadServerSalt;
    private _onBadMsgNotification;
    private _onNewSessionCreated;
    private _onMessageInfo;
    private _onMessagesInfo;
    private _onMsgsStateInfo;
    private _onFutureSalts;
    private _enqueueRpc;
    _resetSession(reason?: string): void;
    private _sendAck;
    sendRpc<T extends tl.RpcMethod>(request: T, timeout?: number, abortSignal?: AbortSignal, chainId?: string | number): Promise<tl.RpcCallReturn[T['_']]>;
    notifyNetworkChanged(online: boolean): void;
    private _cancelRpc;
    protected _onInactivityTimeout(): void;
    flushWhenIdle(): void;
    private _handleGetStateTimeout;
    private _flush;
    private _doFlush;
}