import { ReconnectionStrategy } from '@fuman/net';
import { tl } from '../tl/index.js';
import { BasicDcOption, ICryptoProvider, Logger } from '../utils/index.js';
import { TelegramTransport } from './transports/abstract.js';
import { Emitter } from '@fuman/utils';
export interface PersistentConnectionParams {
    crypto: ICryptoProvider;
    transport: TelegramTransport;
    dc: BasicDcOption;
    testMode: boolean;
    reconnectionStrategy: ReconnectionStrategy;
    inactivityTimeout?: number;
}
/**
 * Base class for persistent connections.
 * Only used for {@link PersistentConnection} and used as a mean of code splitting.
 * This class doesn't know anything about MTProto, it just manages the transport.
 */
export declare abstract class PersistentConnection {
    readonly log: Logger;
    private _uid;
    readonly params: PersistentConnectionParams;
    private _sendOnceConnected;
    private _codec;
    private _fuman;
    protected _disconnectedManually: boolean;
    private _inactivityTimeout;
    _inactive: boolean;
    _destroyed: boolean;
    _usable: boolean;
    readonly onWait: Emitter<number>;
    readonly onUsable: Emitter<void>;
    readonly onError: Emitter<Error>;
    protected abstract onConnected(): void;
    protected abstract onClosed(): void;
    protected abstract handleError(err: Error): void;
    protected abstract onMessage(data: Uint8Array): void;
    protected constructor(params: PersistentConnectionParams, log: Logger);
    private _updateLogPrefix;
    get isConnected(): boolean;
    private _writer?;
    protected _mtproxyInfo?: tl.RawInputClientProxy;
    private _onOpen;
    private _onClose;
    private _onError;
    changeTransport(transport: TelegramTransport): Promise<void>;
    connect(): void;
    reconnect(): void;
    disconnectManual(): Promise<void>;
    destroy(): Promise<void>;
    protected _rescheduleInactivity(): void;
    protected _onInactivityTimeout(): void;
    setInactivityTimeout(timeout?: number): void;
    send(data: Uint8Array): Promise<void>;
}