@mtcute/core 0.16.6 → 0.16.9

package/network/client.d.ts

@@ -0,0 +1,213 @@
+import { default as EventEmitter } from 'node:events';
+import { mtp, tl } from '@mtcute/tl';
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { IMtStorageProvider } from '../storage/provider.js';
+import { StorageManagerExtraOptions, StorageManager } from '../storage/storage.js';
+import { MustEqual } from '../types/index.js';
+import { DcOptions, ICryptoProvider, Logger } from '../utils/index.js';
+import { ConfigManager } from './config-manager.js';
+import { NetworkManagerExtraParams, RpcCallOptions, NetworkManager } from './network-manager.js';
+import { PersistentConnectionParams } from './persistent-connection.js';
+import { ReconnectionStrategy } from './reconnection.js';
+import { TransportFactory } from './transports/index.js';
+/** Options for {@link MtClient} */
+export interface MtClientOptions {
+    /**
+     * API ID from my.telegram.org
+     */
+    apiId: number;
+    /**
+     * API hash from my.telegram.org
+     */
+    apiHash: string;
+    /**
+     * Storage to use for this client.
+     */
+    storage: IMtStorageProvider;
+    /** Additional options for the storage manager */
+    storageOptions?: StorageManagerExtraOptions;
+    /**
+     * Cryptography provider to allow delegating
+     * crypto to native addon, worker, etc.
+     */
+    crypto: ICryptoProvider;
+    /**
+     * Whether to use IPv6 datacenters
+     * (IPv6 will be preferred when choosing a DC by id)
+     * (default: false)
+     */
+    useIpv6?: boolean;
+    /**
+     * Primary DC to use for initial connection.
+     * This does not mean this will be the only DC used,
+     * nor that this DC will actually be primary, this only
+     * determines the first DC the library will try to connect to.
+     * Can be used to connect to other networks (like test DCs).
+     *
+     * When session already contains primary DC, this parameter is ignored.
+     *
+     * @default  Production DC 2.
+     */
+    defaultDcs?: DcOptions;
+    /**
+     * Whether to connect to test servers.
+     *
+     * If passed, {@link defaultDc} defaults to Test DC 2.
+     *
+     * **Must** be passed if using test servers, even if
+     * you passed custom {@link defaultDc}
+     */
+    testMode?: boolean;
+    /**
+     * Additional options for initConnection call.
+     * `apiId` and `query` are not available and will be ignored.
+     * Omitted values will be filled with defaults
+     */
+    initConnectionOptions?: Partial<Omit<tl.RawInitConnectionRequest, 'apiId' | 'query'>>;
+    /**
+     * Transport factory to use in the client.
+     *
+     * @default  platform-specific transport: WebSocket on the web, TCP in node
+     */
+    transport: TransportFactory;
+    /**
+     * Reconnection strategy.
+     *
+     * @default  simple reconnection strategy: first 0ms, then up to 5s (increasing by 1s)
+     */
+    reconnectionStrategy?: ReconnectionStrategy<PersistentConnectionParams>;
+    /**
+     * If true, all API calls will be wrapped with `tl.invokeWithoutUpdates`,
+     * effectively disabling the server-sent events for the clients.
+     * May be useful in some cases.
+     *
+     * @default false
+     */
+    disableUpdates?: boolean;
+    /**
+     * mtcute can send all unknown RPC errors to [danog](https://github.com/danog)'s
+     * [error reporting service](https://rpc.pwrtelegram.xyz/).
+     *
+     * This is fully anonymous (except maybe IP) and is only used to improve the library
+     * and developer experience for everyone working with MTProto. This is fully opt-in,
+     * and if you're too paranoid, you can disable it by manually passing `enableErrorReporting: false` to the client.
+     *
+     * @default false
+     */
+    enableErrorReporting?: boolean;
+    /**
+     * Extra parameters for {@link NetworkManager}
+     */
+    network?: NetworkManagerExtraParams;
+    /**
+     * Logger instance for the client.
+     * If not passed, a new one will be created.
+     */
+    logger?: Logger;
+    /**
+     * Set logging level for the client.
+     * Shorthand for `client.log.level = level`.
+     *
+     * See static members of {@link LogManager} for possible values.
+     */
+    logLevel?: number;
+    /**
+     * **EXPERT USE ONLY!**
+     *
+     * Override TL layer used for the connection.
+     *
+     * **Does not** change the schema used.
+     */
+    overrideLayer?: number;
+    /**
+     * **EXPERT USE ONLY**
+     *
+     * Override reader map used for the connection.
+     */
+    readerMap?: TlReaderMap;
+    /**
+     * **EXPERT USE ONLY**
+     *
+     * Override writer map used for the connection.
+     */
+    writerMap?: TlWriterMap;
+}
+/**
+ * Basic MTProto client implementation, only doing the bare minimum
+ * to make RPC calls and receive low-level updates, as well as providing
+ * some APIs to manage that.
+ */
+export declare class MtClient extends EventEmitter {
+    readonly params: MtClientOptions;
+    /**
+     * Crypto provider taken from {@link MtClientOptions.crypto}
+     */
+    readonly crypto: ICryptoProvider;
+    /** Storage manager */
+    readonly storage: StorageManager;
+    /**
+     * "Test mode" taken from {@link MtClientOptions.testMode}
+     */
+    protected readonly _testMode: boolean;
+    /**
+     * Primary DCs taken from {@link MtClientOptions.defaultDcs},
+     * loaded from session or changed by other means (like redirecting).
+     */
+    _defaultDcs: DcOptions;
+    /** TL layer used by the client */
+    readonly _layer: number;
+    /** TL readers map used by the client */
+    readonly _readerMap: TlReaderMap;
+    /** TL writers map used by the client */
+    readonly _writerMap: TlWriterMap;
+    readonly _config: ConfigManager;
+    private _emitError?;
+    readonly log: Logger;
+    readonly network: NetworkManager;
+    private _abortController;
+    readonly stopSignal: AbortSignal;
+    constructor(params: MtClientOptions);
+    emitError(err: unknown): void;
+    private _prepare;
+    /**
+     * **ADVANCED**
+     *
+     * Do all the preparations, but don't connect just yet.
+     * Useful when you want to do some preparations before
+     * connecting, like setting up session.
+     *
+     * Call {@link connect} to actually connect.
+     */
+    prepare(): Promise<void>;
+    private _connect;
+    /**
+     * Initialize the connection to the primary DC.
+     *
+     * You shouldn't usually call this method directly as it is called
+     * implicitly the first time you call {@link call}.
+     */
+    connect(): Promise<void>;
+    /**
+     * Close all connections and finalize the client.
+     */
+    close(): Promise<void>;
+    /**
+     * Make an RPC call.
+     *
+     * The connection must have been {@link connect}-ed
+     * before calling this method.
+     *
+     * This method is still quite low-level and you shouldn't use this
+     * when using high-level API provided by `@mtcute/client`.
+     *
+     * @param message  RPC method to call
+     * @param params  Additional call parameters
+     */
+    call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']] | mtp.RawMt_rpc_error>;
+    /**
+     * Register an error handler for the client
+     *
+     * @param handler Error handler.
+     */
+    onError(handler: (err: unknown) => void): void;
+}

package/network/config-manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/network/middlewares/default.d.ts

@@ -0,0 +1,8 @@
+import { RpcCallMiddleware } from '../network-manager.js';
+import { FloodWaiterOptions } from './flood-waiter.js';
+import { InternalErrorsHandlerOptions } from './internal-errors.js';
+export interface BasicMiddlewaresOptions {
+    floodWaiter?: FloodWaiterOptions;
+    internalErrors?: InternalErrorsHandlerOptions;
+}
+export declare function basic(options?: BasicMiddlewaresOptions): RpcCallMiddleware[];

package/network/mtproto-session.d.ts

@@ -0,0 +1,125 @@
+import { default as Long } from 'long';
+import { mtp, tl } from '@mtcute/tl';
+import { TlBinaryWriter, TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { ControllablePromise, ICryptoProvider, Logger, Deque, LongMap, LruSet, SortedArray, timers } from '../utils/index.js';
+import { AuthKey } from './auth-key.js';
+import { ServerSaltManager } from './server-salt.js';
+export interface PendingRpc {
+    method: string;
+    data: Uint8Array;
+    promise: ControllablePromise;
+    stack?: string;
+    gzipOverhead?: number;
+    chainId?: string | number;
+    invokeAfter?: Long;
+    sent?: boolean;
+    done?: boolean;
+    msgId?: Long;
+    seqNo?: number;
+    containerId?: Long;
+    acked?: boolean;
+    initConn?: boolean;
+    getState?: number;
+    cancelled?: boolean;
+    timeout?: timers.Timer;
+}
+export type PendingMessage = {
+    _: 'rpc';
+    rpc: PendingRpc;
+} | {
+    _: 'container';
+    msgIds: Long[];
+} | {
+    _: 'state';
+    msgIds: Long[];
+    containerId: Long;
+} | {
+    _: 'resend';
+    msgIds: Long[];
+    containerId: Long;
+} | {
+    _: 'ping';
+    pingId: Long;
+    containerId: Long;
+} | {
+    _: 'destroy_session';
+    sessionId: Long;
+    containerId: Long;
+} | {
+    _: 'cancel';
+    msgId: Long;
+    containerId: Long;
+} | {
+    _: 'future_salts';
+    containerId: Long;
+} | {
+    _: 'bind';
+    promise: ControllablePromise<boolean | mtp.RawMt_rpc_error>;
+};
+/**
+ * Class encapsulating a single MTProto session and storing
+ * all the relevant state
+ */
+export declare class MtprotoSession {
+    readonly _crypto: ICryptoProvider;
+    readonly log: Logger;
+    readonly _readerMap: TlReaderMap;
+    readonly _writerMap: TlWriterMap;
+    readonly _salts: ServerSaltManager;
+    _sessionId: Long;
+    _authKey: AuthKey;
+    _authKeyTemp: AuthKey;
+    _authKeyTempSecondary: AuthKey;
+    _timeOffset: number;
+    _lastMessageId: Long;
+    _seqNo: number;
+    recentOutgoingMsgIds: LruSet<Long>;
+    recentIncomingMsgIds: LruSet<Long>;
+    queuedRpc: Deque<PendingRpc>;
+    queuedAcks: Long[];
+    queuedStateReq: Long[];
+    queuedResendReq: Long[];
+    queuedCancelReq: Long[];
+    getStateSchedule: SortedArray<PendingRpc>;
+    chains: Map<string | number, Long>;
+    chainsPendingFails: Map<string | number, SortedArray<PendingRpc>>;
+    pendingMessages: LongMap<PendingMessage>;
+    destroySessionIdToMsgId: LongMap<Long>;
+    lastPingRtt: number;
+    lastPingTime: number;
+    lastPingMsgId: Long;
+    lastSessionCreatedUid: Long;
+    initConnectionCalled: boolean;
+    authorizationPending: boolean;
+    next429Timeout: number;
+    current429Timeout?: timers.Timer;
+    next429ResetTimeout?: timers.Timer;
+    constructor(_crypto: ICryptoProvider, log: Logger, _readerMap: TlReaderMap, _writerMap: TlWriterMap, _salts: ServerSaltManager);
+    get hasPendingMessages(): boolean;
+    /**
+     * Reset session by resetting auth key(s) and session state
+     */
+    reset(withAuthKey?: boolean): void;
+    resetAuthKey(): void;
+    updateTimeOffset(offset: number): void;
+    /**
+     * Reset session state and generate a new session ID.
+     *
+     * By default, also cancels any pending RPC requests.
+     * If `keepPending` is set to `true`, pending requests will be kept
+     */
+    resetState(keepPending?: boolean): void;
+    enqueueRpc(rpc: PendingRpc, force?: boolean): boolean;
+    getMessageId(): Long;
+    getSeqNo(isContentRelated?: boolean): number;
+    /** Encrypt a single MTProto message using session's keys */
+    encryptMessage(message: Uint8Array): Uint8Array;
+    /** Decrypt a single MTProto message using session's keys */
+    decryptMessage(data: Uint8Array, callback: Parameters<AuthKey['decryptMessage']>[2]): void;
+    writeMessage(writer: TlBinaryWriter, content: tl.TlObject | mtp.TlObject | Uint8Array, isContentRelated?: boolean): Long;
+    onTransportFlood(callback: () => void): number | undefined;
+    resetLastPing(withTime?: boolean): void;
+    addToChain(chainId: string | number, msgId: Long): Long | undefined;
+    removeFromChain(chainId: string | number, msgId: Long): void;
+    getPendingChainedFails(chainId: string | number): SortedArray<PendingRpc>;
+}

package/network/multi-session-connection.d.ts

@@ -0,0 +1,33 @@
+import { default as EventEmitter } from 'node:events';
+import { mtp, tl } from '@mtcute/tl';
+import { Logger } from '../utils/index.js';
+import { MtprotoSession } from './mtproto-session.js';
+import { SessionConnectionParams, SessionConnection } from './session-connection.js';
+import { TransportFactory } from './transports/index.js';
+export declare class MultiSessionConnection extends EventEmitter {
+    readonly params: SessionConnectionParams;
+    private _count;
+    private _log;
+    readonly _sessions: MtprotoSession[];
+    private _enforcePfs;
+    constructor(params: SessionConnectionParams, _count: number, log: Logger, logPrefix?: string);
+    protected _connections: SessionConnection[];
+    setCount(count: number, connect?: boolean): void;
+    private _updateSessions;
+    private _updateConnections;
+    _destroyed: boolean;
+    destroy(): Promise<void>;
+    private _nextConnection;
+    sendRpc<T extends tl.RpcMethod>(request: T, timeout?: number, abortSignal?: AbortSignal, chainId?: string | number): Promise<tl.RpcCallReturn[T['_']] | mtp.RawMt_rpc_error>;
+    connect(): void;
+    ensureConnected(): void;
+    setAuthKey(authKey: Uint8Array | null, temp?: boolean, idx?: number): void;
+    resetAuthKeys(): void;
+    setInactivityTimeout(timeout?: number): void;
+    notifyKeyChange(): void;
+    notifyNetworkChanged(connected: boolean): void;
+    requestAuth(): void;
+    resetSessions(): void;
+    changeTransport(factory: TransportFactory): void;
+    getPoolSize(): number;
+}

package/network/network-manager.d.ts

@@ -0,0 +1,248 @@
+import { mtp, tl } from '@mtcute/tl';
+import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { default as Long } from 'long';
+import { StorageManager } from '../storage/storage.js';
+import { Middleware } from '../utils/composer.js';
+import { DcOptions, ICryptoProvider, Logger } from '../utils/index.js';
+import { ConfigManager } from './config-manager.js';
+import { MultiSessionConnection } from './multi-session-connection.js';
+import { PersistentConnectionParams } from './persistent-connection.js';
+import { ReconnectionStrategy } from './reconnection.js';
+import { SessionConnection } from './session-connection.js';
+import { TransportFactory } from './transports/index.js';
+export type ConnectionKind = 'main' | 'upload' | 'download' | 'downloadSmall';
+/**
+ * Params passed into {@link NetworkManager} by {@link TelegramClient}.
+ * This type is intended for internal usage only.
+ */
+export interface NetworkManagerParams {
+    storage: StorageManager;
+    crypto: ICryptoProvider;
+    log: Logger;
+    enableErrorReporting: boolean;
+    apiId: number;
+    initConnectionOptions?: Partial<Omit<tl.RawInitConnectionRequest, 'apiId' | 'query'>>;
+    transport: TransportFactory;
+    reconnectionStrategy?: ReconnectionStrategy<PersistentConnectionParams>;
+    disableUpdates?: boolean;
+    testMode: boolean;
+    layer: number;
+    useIpv6: boolean;
+    readerMap: TlReaderMap;
+    writerMap: TlWriterMap;
+    isPremium: boolean;
+    emitError: (err: Error, connection?: SessionConnection) => void;
+    onUpdate: (upd: tl.TypeUpdates) => void;
+    onUsable: () => void;
+    onConnecting: () => void;
+    onNetworkChanged: (connected: boolean) => void;
+    stopSignal: AbortSignal;
+}
+export type ConnectionCountDelegate = (kind: ConnectionKind, dcId: number, isPremium: boolean) => number;
+/**
+ * Additional params passed into {@link NetworkManager} by the user
+ * that customize the behavior of the manager
+ */
+export interface NetworkManagerExtraParams {
+    /**
+     * Whether to use PFS (Perfect Forward Secrecy) for all connections.
+     * This is disabled by default
+     */
+    usePfs?: boolean;
+    /**
+     * Connection count for each connection kind.
+     * The function should be pure to avoid unexpected behavior.
+     *
+     * Defaults to TDLib logic:
+     *   - main: 0 (which stands for "handle internally, based on tmp_sessions value")
+     *   - upload: if premium or dc id is other than 2 or 4, then 8, otherwise 4
+     *   - download: if premium then 8, otherwise 2
+     *   - downloadSmall: 2
+     *
+     * Non-zero value for `main` is **for advanced users only**
+     * as it may lead to unexpected behavior, and is generally not recommended
+     * because of unnecessary extra load on both the server and the client as well as
+     * increased possibility of encountering AUTH_KEY_DUPLICATED errors.
+     */
+    connectionCount?: ConnectionCountDelegate;
+    /**
+     * Idle timeout for non-main connections, in ms
+     *
+     * @default  60000 (60 seconds).
+     */
+    inactivityTimeout?: number;
+    /**
+     * List of middlewares to use for the network manager
+     *
+     * > **Note**: these middlewares apply to **outgoing requests only**.
+     * > If you need to handle incoming updates, use a {@link Dispatcher} instead.
+     */
+    middlewares?: Middleware<RpcCallMiddlewareContext, unknown>[];
+}
+/** Options that can be customized when making an RPC call */
+export interface RpcCallOptions {
+    /**
+     * If the call results in a `FLOOD_WAIT_X` error,
+     * the maximum amount of time to wait before retrying.
+     *
+     * If set to `0`, the call will not be retried.
+     *
+     * Only applies when the flood waiter middleware is enabled.
+     */
+    floodSleepThreshold?: number;
+    /**
+     * If the call results in an internal server error or a flood wait,
+     * the maximum amount of times to retry the call.
+     *
+     * Only applies when the flood waiter middleware and/or
+     * internal errors handler middleware is enabled.
+     */
+    maxRetryCount?: number;
+    /**
+     * Timeout for the call, in milliseconds.
+     *
+     * @default Infinity
+     */
+    timeout?: number;
+    /**
+     * **ADVANCED**
+     *
+     * Kind of connection to use for this call.
+     *
+     * @default 'main'
+     */
+    kind?: ConnectionKind;
+    /**
+     * **ADVANCED**
+     *
+     * ID of the DC to use for this call
+     */
+    dcId?: number;
+    /**
+     * **ADVANCED**
+     *
+     * DC connection manager to use for this call.
+     * Overrides `dcId` if set.
+     */
+    manager?: DcConnectionManager;
+    /**
+     * Abort signal for the call.
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * Whether we should not retry on -503 errors and throw {@link MtTimeoutError} immediately instead.
+     *
+     * Useful for methods like `messages.getBotCallbackAnswer` that reliably return
+     * -503 in case the upstream bot failed to respond.
+     *
+     * Only applies if the internal error handler middleware is enabled,
+     * otherwise -503 is always thrown.
+     */
+    throw503?: boolean;
+    /**
+     * Whether the `X_MIGRATE_%d` errors should be handled locally on request level
+     * instead of changing the default datacenter for the entire client.
+     *
+     * Useful for `invokeWithBusinessConnection`, as it returns a `USER_MIGRATE_%d` error
+     * that is in fact not related to the user, but to the specific request.
+     */
+    localMigrate?: boolean;
+    /**
+     * Some requests should be processed consecutively, and not in parallel.
+     * Using the same `chainId` for multiple requests will ensure that they are processed in the order
+     * of calling `.call()`.
+     *
+     * Particularly useful for `messages.sendMessage` and alike.
+     */
+    chainId?: string | number;
+}
+export interface RpcCallMiddlewareContext {
+    request: tl.RpcMethod;
+    manager: NetworkManager;
+    params?: RpcCallOptions;
+}
+export type RpcCallMiddleware<Result = unknown> = Middleware<RpcCallMiddlewareContext, Result>;
+/**
+ * Wrapper over all connection pools for a single DC.
+ */
+export declare class DcConnectionManager {
+    /** Network manager instance */
+    readonly manager: NetworkManager;
+    /** DC ID */
+    readonly dcId: number;
+    /** DC options to use */
+    readonly _dcs: DcOptions;
+    /** Whether this DC is the primary one */
+    isPrimary: boolean;
+    private _salts;
+    private _log;
+    /** Main connection pool */
+    main: MultiSessionConnection;
+    /** Upload connection pool */
+    upload: MultiSessionConnection;
+    /** Download connection pool */
+    download: MultiSessionConnection;
+    /** Download connection pool (for small files) */
+    downloadSmall: MultiSessionConnection;
+    private get _mainCountOverride();
+    constructor(
+    /** Network manager instance */
+    manager: NetworkManager, 
+    /** DC ID */
+    dcId: number, 
+    /** DC options to use */
+    _dcs: DcOptions, 
+    /** Whether this DC is the primary one */
+    isPrimary?: boolean);
+    private _setupMulti;
+    setIsPrimary(isPrimary: boolean): void;
+    setIsPremium(isPremium: boolean): void;
+    loadKeys(forcePfs?: boolean): Promise<boolean>;
+    setMainConnectionCount(count: number): void;
+    destroy(): Promise<void>;
+}
+/**
+ * Class that manages all connections to Telegram servers.
+ */
+export declare class NetworkManager {
+    readonly params: NetworkManagerParams & NetworkManagerExtraParams;
+    readonly config: ConfigManager;
+    readonly _log: Logger;
+    readonly _storage: StorageManager;
+    readonly _initConnectionParams: tl.RawInitConnectionRequest;
+    readonly _transportFactory: TransportFactory;
+    readonly _reconnectionStrategy: ReconnectionStrategy<PersistentConnectionParams>;
+    readonly _connectionCount: ConnectionCountDelegate;
+    protected readonly _dcConnections: Map<number, DcConnectionManager>;
+    protected _primaryDc?: DcConnectionManager;
+    private _updateHandler;
+    constructor(params: NetworkManagerParams & NetworkManagerExtraParams, config: ConfigManager);
+    private _findDcOptions;
+    private _resetOnNetworkChange?;
+    private _switchPrimaryDc;
+    private _dcCreationPromise;
+    _getOtherDc(dcId: number): Promise<DcConnectionManager>;
+    /**
+     * Perform initial connection to the default DC
+     *
+     * @param defaultDcs  Default DCs to connect to
+     */
+    connect(defaultDcs: DcOptions): Promise<void>;
+    private _pendingExports;
+    private _exportAuthTo;
+    setIsPremium(isPremium: boolean): void;
+    notifyLoggedIn(auth: tl.auth.TypeAuthorization | tl.RawUser): tl.RawUser;
+    notifyLoggedOut(): void;
+    notifyNetworkChanged(connected: boolean): void;
+    resetSessions(): void;
+    private _onConfigChanged;
+    changePrimaryDc(newDc: number): Promise<void>;
+    readonly call: <T extends tl.RpcMethod>(message: T, params?: RpcCallOptions) => Promise<tl.RpcCallReturn[T['_']] | mtp.RawMt_rpc_error>;
+    private _composeCall;
+    private _call;
+    changeTransport(factory: TransportFactory): void;
+    getPoolSize(kind: ConnectionKind, dcId?: number): number;
+    getPrimaryDcId(): number;
+    destroy(): Promise<void>;
+    getMtprotoMessageId(): Long;
+}

package/network/persistent-connection.d.ts

@@ -0,0 +1,52 @@
+import { default as EventEmitter } from 'node:events';
+import { BasicDcOption, ICryptoProvider, Logger } from '../utils/index.js';
+import { ReconnectionStrategy } from './reconnection.js';
+import { ITelegramTransport, TransportFactory } from './transports/index.js';
+export interface PersistentConnectionParams {
+    crypto: ICryptoProvider;
+    transportFactory: TransportFactory;
+    dc: BasicDcOption;
+    testMode: boolean;
+    reconnectionStrategy: ReconnectionStrategy<PersistentConnectionParams>;
+    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 extends EventEmitter {
+    readonly log: Logger;
+    private _uid;
+    readonly params: PersistentConnectionParams;
+    protected _transport: ITelegramTransport;
+    private _sendOnceConnected;
+    private _lastError;
+    private _consequentFails;
+    private _previousWait;
+    private _reconnectionTimeout;
+    private _shouldReconnectImmediately;
+    protected _disconnectedManually: boolean;
+    private _inactivityTimeout;
+    private _inactive;
+    _destroyed: boolean;
+    _usable: boolean;
+    protected abstract onConnected(): void;
+    protected abstract onError(err: Error): void;
+    protected abstract onMessage(data: Uint8Array): void;
+    protected constructor(params: PersistentConnectionParams, log: Logger);
+    get isConnected(): boolean;
+    changeTransport(factory: TransportFactory): void;
+    onTransportReady(): void;
+    protected onConnectionUsable(): void;
+    onTransportError(err: Error): void;
+    onTransportClose(): 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>;
+}

package/network/persistent-connection.test.d.ts

@@ -0,0 +1 @@
+export {};