teleproto 203.0.0

package/client/os.d.ts

@@ -0,0 +1,2 @@
+import * as os from "os";
+export default os;

package/client/os.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = __importStar(require("os"));
+exports.default = os;

package/client/path.d.ts

@@ -0,0 +1,2 @@
+import path from "path";
+export default path;

package/client/path.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+exports.default = path_1.default;

package/client/telegramBaseClient.d.ts

@@ -0,0 +1,238 @@
+/// <reference types="node" />
+import { Connection } from "..";
+import { Session } from "../sessions";
+import { Logger, PromisedNetSockets, PromisedWebSockets } from "../extensions";
+import { Api } from "../tl";
+import type { AuthKey } from "../crypto/AuthKey";
+import { EntityCache } from "../entityCache";
+import type { ParseInterface } from "./messageParse";
+import type { EventBuilder } from "../events/common";
+import { MTProtoSender } from "../network";
+import { ProxyInterface } from "../network/connection/TCPMTProxy";
+import { Semaphore } from "async-mutex";
+import { LogLevel } from "../extensions/Logger";
+import Deferred from "../extensions/Deferred";
+/**
+ * Interface for creating a new client.
+ * All of these have a default value and you should only change those if you know what you are doing.
+ */
+export interface TelegramClientParams {
+    /** The connection instance to be used when creating a new connection to the servers. It must be a type.<br/>
+     * Defaults to {@link ConnectionTCPFull} on Node and {@link ConnectionTCPObfuscated} on browsers.
+     */
+    connection?: typeof Connection;
+    /**
+     * Whether to connect to the servers through IPv6 or not. By default this is false.
+     */
+    useIPV6?: boolean;
+    /**
+     * The timeout in seconds to be used when connecting. This does nothing for now.
+     */
+    timeout?: number;
+    /**
+     * How many times a request should be retried.<br/>
+     * Request are retried when Telegram is having internal issues (due to INTERNAL error or RPC_CALL_FAIL error),<br/>
+     * when there is a errors.FloodWaitError less than floodSleepThreshold, or when there's a migrate error.<br/>
+     * defaults to 5.
+     */
+    requestRetries?: number;
+    /**
+     * How many times the connection should retry, either on the initial connection or when Telegram disconnects us.<br/>
+     * May be set to a negative or undefined value for infinite retries, but this is not recommended, since the program can get stuck in an infinite loop.<br/>
+     * defaults to 5
+     */
+    connectionRetries?: number;
+    /**
+     * How many times to reconnect before giving up. This happens after the initial connection is finished<br/>
+     * defaults to infinity
+     */
+    reconnectRetries?: number;
+    /**
+     * Experimental proxy to be used for the connection. (only supports MTProxies)
+     */
+    proxy?: ProxyInterface;
+    /**
+     * How many times we should retry borrowing a sender from another DC when it fails. defaults to 5
+     */
+    downloadRetries?: number;
+    /** The delay in milliseconds to sleep between automatic reconnections. defaults to 1000*/
+    retryDelay?: number;
+    /**Whether reconnection should be retried connection_retries times automatically if Telegram disconnects us or not. defaults to true */
+    autoReconnect?: boolean;
+    /** does nothing for now */
+    sequentialUpdates?: boolean;
+    /** The threshold below which the library should automatically sleep on flood wait and slow mode wait errors (inclusive).<br/>
+     *  For instance, if a FloodWaitError for 17s occurs and floodSleepThreshold is 20s, the library will sleep automatically.<br/>
+     *  If the error was for 21s, it would raise FloodWaitError instead. defaults to 60 sec.*/
+    floodSleepThreshold?: number;
+    /**
+     * Device model to be sent when creating the initial connection. Defaults to os.type().toString().
+     */
+    deviceModel?: string;
+    /**
+     * System version to be sent when creating the initial connection. defaults to os.release().toString() -.
+     */
+    systemVersion?: string;
+    /**
+     * App version to be sent when creating the initial connection. Defaults to 1.0.
+     */
+    appVersion?: string;
+    /**
+     * Language code to be sent when creating the initial connection. Defaults to 'en'.
+     */
+    langCode?: string;
+    /**
+     * System lang code to be sent when creating the initial connection. Defaults to 'en'.
+     */
+    systemLangCode?: string;
+    /**
+     * Instance of Logger to use. <br />
+     * If a `Logger` is given, it'll be used directly. If nothing is given, the default logger will be used. <br />
+     * To create your own Logger make sure you extends GramJS logger {@link Logger} and override `log` method.
+     */
+    baseLogger?: Logger;
+    /**
+     * Whether to try to connect over Wss (or 443 port) or not.
+     */
+    useWSS?: boolean;
+    /**
+     * Limits how many downloads happen at the same time.
+     */
+    maxConcurrentDownloads?: number;
+    /**
+     * Whether to check for tampering in messages or not.
+     */
+    securityChecks?: boolean;
+    /**
+     * Only for web DCs. Whether to use test servers or not.
+     */
+    testServers?: boolean;
+    /**
+     * What type of network connection to use (Normal Socket (for node) or Websockets (for browsers usually) )
+     */
+    networkSocket?: typeof PromisedNetSockets | typeof PromisedWebSockets;
+}
+export declare abstract class TelegramBaseClient {
+    /** The current gramJS version. */
+    __version__: string;
+    /** @hidden */
+    _config?: Api.Config;
+    /** @hidden */
+    _log: Logger;
+    /** @hidden */
+    _floodSleepThreshold: number;
+    session: Session;
+    apiHash: string;
+    apiId: number;
+    /** @hidden */
+    _requestRetries: number;
+    /** @hidden */
+    _downloadRetries: number;
+    /** @hidden */
+    _connectionRetries: number;
+    /** @hidden */
+    _reconnectRetries: number;
+    /** @hidden */
+    _retryDelay: number;
+    /** @hidden */
+    _timeout: number;
+    /** @hidden */
+    _autoReconnect: boolean;
+    /** @hidden */
+    _connection: typeof Connection;
+    /** @hidden */
+    _initRequest: Api.InitConnection;
+    /** @hidden */
+    _sender?: MTProtoSender;
+    /** @hidden */
+    _floodWaitedRequests: any;
+    /** @hidden */
+    _borrowedSenderPromises: any;
+    /** @hidden */
+    _bot?: boolean;
+    /** @hidden */
+    _useIPV6: boolean;
+    /** @hidden */
+    _selfInputPeer?: Api.InputPeerUser;
+    /** @hidden */
+    useWSS: boolean;
+    /** @hidden */
+    _errorHandler?: (error: Error) => Promise<void>;
+    /** @hidden */
+    _eventBuilders: [EventBuilder, CallableFunction][];
+    /** @hidden */
+    _entityCache: EntityCache;
+    /** @hidden */
+    _lastRequest?: number;
+    /** @hidden */
+    _parseMode?: ParseInterface;
+    /** @hidden */
+    _ALBUMS: Map<string, [NodeJS.Timeout, Api.TypeUpdate[]]>;
+    /** @hidden */
+    _exportedSenderPromises: Map<number, Promise<MTProtoSender>>;
+    /** @hidden */
+    private _exportedSenderReleaseTimeouts;
+    /** @hidden */
+    protected _loopStarted: boolean;
+    /** @hidden */
+    _reconnecting: boolean;
+    /** @hidden */
+    _destroyed: boolean;
+    /** @hidden */
+    _isSwitchingDc: boolean;
+    /** @hidden */
+    protected _proxy?: ProxyInterface;
+    /** @hidden */
+    _semaphore: Semaphore;
+    /** @hidden */
+    _securityChecks: boolean;
+    /** @hidden */
+    testServers: boolean;
+    /** @hidden */
+    networkSocket: typeof PromisedNetSockets | typeof PromisedWebSockets;
+    _connectedDeferred: Deferred<void>;
+    constructor(session: string | Session, apiId: number, apiHash: string, clientParams: TelegramClientParams);
+    get floodSleepThreshold(): number;
+    set floodSleepThreshold(value: number);
+    set maxConcurrentDownloads(value: number);
+    _initSession(): Promise<void>;
+    get connected(): boolean | undefined;
+    disconnect(): Promise<void>;
+    get disconnected(): boolean;
+    _disconnect(): Promise<void>;
+    /**
+     * Disconnects all senders and removes all handlers
+     * Disconnect is safer as it will not remove your event handlers
+     */
+    destroy(): Promise<void>;
+    /** @hidden */
+    _authKeyCallback(authKey: AuthKey, dcId: number): Promise<void>;
+    /** @hidden */
+    _cleanupExportedSender(dcId: number): Promise<void>;
+    /** @hidden */
+    _connectSender(sender: MTProtoSender, dcId: number): Promise<MTProtoSender>;
+    /** @hidden */
+    _borrowExportedSender(dcId: number, shouldReconnect?: boolean, existingSender?: MTProtoSender): Promise<MTProtoSender>;
+    /** @hidden */
+    _createExportedSender(dcId: number): MTProtoSender;
+    /** @hidden */
+    getSender(dcId: number): Promise<MTProtoSender>;
+    getDC(dcId: number, download: boolean): Promise<{
+        id: number;
+        ipAddress: string;
+        port: number;
+    }>;
+    invoke<R extends Api.AnyRequest>(request: R): Promise<R["__response"]>;
+    setLogLevel(level: LogLevel): void;
+    get logger(): Logger;
+    /**
+     * Custom error handler for the client
+     * @example
+     * ```ts
+     * client.onError = async (error)=>{
+     *         console.log("error is",error)
+     *     }
+     * ```
+     */
+    set onError(handler: (error: Error) => Promise<void>);
+}

package/client/telegramBaseClient.js

@@ -0,0 +1,368 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramBaseClient = void 0;
+const __1 = require("..");
+const Helpers_1 = require("../Helpers");
+const connection_1 = require("../network/connection");
+const sessions_1 = require("../sessions");
+const extensions_1 = require("../extensions");
+const tl_1 = require("../tl");
+const os_1 = __importDefault(require("./os"));
+const entityCache_1 = require("../entityCache");
+const markdown_1 = require("../extensions/markdown");
+const network_1 = require("../network");
+const AllTLObjects_1 = require("../tl/AllTLObjects");
+const TCPMTProxy_1 = require("../network/connection/TCPMTProxy");
+const async_mutex_1 = require("async-mutex");
+const Logger_1 = require("../extensions/Logger");
+const Deferred_1 = __importDefault(require("../extensions/Deferred"));
+const EXPORTED_SENDER_RECONNECT_TIMEOUT = 1000; // 1 sec
+const EXPORTED_SENDER_RELEASE_TIMEOUT = 30000; // 30 sec
+const DEFAULT_DC_ID = 4;
+const DEFAULT_IPV4_IP = "149.154.167.91";
+const DEFAULT_IPV6_IP = "2001:067c:04e8:f004:0000:0000:0000:000a";
+const clientParamsDefault = {
+    connection: connection_1.ConnectionTCPFull,
+    networkSocket: extensions_1.PromisedNetSockets,
+    useIPV6: false,
+    timeout: 10,
+    requestRetries: 5,
+    connectionRetries: Infinity,
+    retryDelay: 1000,
+    downloadRetries: 5,
+    autoReconnect: true,
+    sequentialUpdates: false,
+    floodSleepThreshold: 60,
+    deviceModel: "",
+    systemVersion: "",
+    appVersion: "",
+    langCode: "en",
+    systemLangCode: "en",
+    _securityChecks: true,
+    useWSS: false,
+    testServers: false,
+};
+class TelegramBaseClient {
+    constructor(session, apiId, apiHash, clientParams) {
+        /** The current gramJS version. */
+        this.__version__ = __1.version;
+        /** @hidden */
+        this._ALBUMS = new Map();
+        /** @hidden */
+        this._exportedSenderPromises = new Map();
+        /** @hidden */
+        this._exportedSenderReleaseTimeouts = new Map();
+        clientParams = Object.assign(Object.assign({}, clientParamsDefault), clientParams);
+        if (!apiId || !apiHash) {
+            throw new Error("Your API ID or Hash cannot be empty or undefined");
+        }
+        if (clientParams.baseLogger) {
+            this._log = clientParams.baseLogger;
+        }
+        else {
+            this._log = new extensions_1.Logger();
+        }
+        this._log.info("Running gramJS version " + __1.version);
+        if (session && typeof session == "string") {
+            session = new sessions_1.StoreSession(session);
+        }
+        if (!(session instanceof sessions_1.Session)) {
+            throw new Error("Only StringSession and StoreSessions are supported currently :( ");
+        }
+        this._floodSleepThreshold = clientParams.floodSleepThreshold;
+        this.session = session;
+        this.apiId = apiId;
+        this.apiHash = apiHash;
+        this._useIPV6 = clientParams.useIPV6;
+        this._requestRetries = clientParams.requestRetries;
+        this._downloadRetries = clientParams.downloadRetries;
+        this._connectionRetries = clientParams.connectionRetries;
+        this._reconnectRetries = clientParams.reconnectRetries;
+        this._retryDelay = clientParams.retryDelay || 0;
+        this._timeout = clientParams.timeout;
+        this._autoReconnect = clientParams.autoReconnect;
+        this._proxy = clientParams.proxy;
+        this._semaphore = new async_mutex_1.Semaphore(clientParams.maxConcurrentDownloads || 1);
+        this.testServers = clientParams.testServers || false;
+        this.networkSocket = clientParams.networkSocket || extensions_1.PromisedNetSockets;
+        if (!(clientParams.connection instanceof Function)) {
+            throw new Error("Connection should be a class not an instance");
+        }
+        this._connection = clientParams.connection;
+        let initProxy;
+        if (this._proxy && "MTProxy" in this._proxy) {
+            this._connection = TCPMTProxy_1.ConnectionTCPMTProxyAbridged;
+            initProxy = new tl_1.Api.InputClientProxy({
+                address: this._proxy.ip,
+                port: this._proxy.port,
+            });
+        }
+        this._initRequest = new tl_1.Api.InitConnection({
+            apiId: this.apiId,
+            deviceModel: clientParams.deviceModel || os_1.default.type().toString() || "Unknown",
+            systemVersion: clientParams.systemVersion || os_1.default.release().toString() || "1.0",
+            appVersion: clientParams.appVersion || "1.0",
+            langCode: clientParams.langCode,
+            langPack: "",
+            systemLangCode: clientParams.systemLangCode,
+            proxy: initProxy,
+        });
+        this._eventBuilders = [];
+        this._floodWaitedRequests = {};
+        this._borrowedSenderPromises = {};
+        this._bot = undefined;
+        this._selfInputPeer = undefined;
+        this.useWSS = clientParams.useWSS;
+        this._securityChecks = !!clientParams.securityChecks;
+        if (this.useWSS && this._proxy) {
+            throw new Error("Cannot use SSL with proxies. You need to disable the useWSS client param in TelegramClient");
+        }
+        this._entityCache = new entityCache_1.EntityCache();
+        // These will be set later
+        this._config = undefined;
+        this._loopStarted = false;
+        this._reconnecting = false;
+        this._destroyed = false;
+        this._isSwitchingDc = false;
+        this._connectedDeferred = new Deferred_1.default();
+        // parse mode
+        this._parseMode = markdown_1.MarkdownParser;
+    }
+    get floodSleepThreshold() {
+        return this._floodSleepThreshold;
+    }
+    set floodSleepThreshold(value) {
+        this._floodSleepThreshold = Math.min(value || 0, 24 * 60 * 60);
+    }
+    set maxConcurrentDownloads(value) {
+        // @ts-ignore
+        this._semaphore._value = value;
+    }
+    // region connecting
+    async _initSession() {
+        await this.session.load();
+        if (!this.session.serverAddress) {
+            this.session.setDC(DEFAULT_DC_ID, this._useIPV6 ? DEFAULT_IPV6_IP : DEFAULT_IPV4_IP, this.useWSS ? 443 : 80);
+        }
+        else {
+            this._useIPV6 = this.session.serverAddress.includes(":");
+        }
+    }
+    get connected() {
+        return this._sender && this._sender.isConnected();
+    }
+    async disconnect() {
+        await this._disconnect();
+        await Promise.all(Object.values(this._exportedSenderPromises)
+            .map((promises) => {
+            return Object.values(promises).map((promise) => {
+                return (promise &&
+                    promise.then((sender) => {
+                        if (sender) {
+                            return sender.disconnect();
+                        }
+                        return undefined;
+                    }));
+            });
+        })
+            .flat());
+        Object.values(this._exportedSenderReleaseTimeouts).forEach((timeouts) => {
+            Object.values(timeouts).forEach((releaseTimeout) => {
+                clearTimeout(releaseTimeout);
+            });
+        });
+        this._exportedSenderPromises.clear();
+    }
+    get disconnected() {
+        return !this._sender || this._sender._disconnected;
+    }
+    async _disconnect() {
+        var _a;
+        await ((_a = this._sender) === null || _a === void 0 ? void 0 : _a.disconnect());
+    }
+    /**
+     * Disconnects all senders and removes all handlers
+     * Disconnect is safer as it will not remove your event handlers
+     */
+    async destroy() {
+        this._destroyed = true;
+        await Promise.all([
+            this.disconnect(),
+            ...Object.values(this._borrowedSenderPromises).map((promise) => {
+                return promise.then((sender) => sender.disconnect());
+            }),
+        ]);
+        this._eventBuilders = [];
+    }
+    /** @hidden */
+    async _authKeyCallback(authKey, dcId) {
+        this.session.setAuthKey(authKey, dcId);
+        await this.session.save();
+    }
+    /** @hidden */
+    async _cleanupExportedSender(dcId) {
+        if (this.session.dcId !== dcId) {
+            this.session.setAuthKey(undefined, dcId);
+        }
+        let sender = await this._exportedSenderPromises.get(dcId);
+        this._exportedSenderPromises.delete(dcId);
+        await (sender === null || sender === void 0 ? void 0 : sender.disconnect());
+    }
+    /** @hidden */
+    async _connectSender(sender, dcId) {
+        // if we don't already have an auth key we want to use normal DCs not -1
+        const dc = await this.getDC(dcId, !!sender.authKey.getKey());
+        while (true) {
+            try {
+                await sender.connect(new this._connection({
+                    ip: dc.ipAddress,
+                    port: dc.port,
+                    dcId: dcId,
+                    loggers: this._log,
+                    proxy: this._proxy,
+                    testServers: this.testServers,
+                    socket: this.networkSocket,
+                }), false);
+                if (this.session.dcId !== dcId && !sender._authenticated) {
+                    this._log.info(`Exporting authorization for data center ${dc.ipAddress} with layer ${AllTLObjects_1.LAYER}`);
+                    const auth = await this.invoke(new tl_1.Api.auth.ExportAuthorization({ dcId: dcId }));
+                    this._initRequest.query = new tl_1.Api.auth.ImportAuthorization({
+                        id: auth.id,
+                        bytes: auth.bytes,
+                    });
+                    const req = new tl_1.Api.InvokeWithLayer({
+                        layer: AllTLObjects_1.LAYER,
+                        query: this._initRequest,
+                    });
+                    await sender.send(req);
+                    sender._authenticated = true;
+                }
+                sender.dcId = dcId;
+                sender.userDisconnected = false;
+                return sender;
+            }
+            catch (err) {
+                if (err.errorMessage === "DC_ID_INVALID") {
+                    sender._authenticated = true;
+                    sender.userDisconnected = false;
+                    return sender;
+                }
+                if (this._errorHandler) {
+                    await this._errorHandler(err);
+                }
+                else if (this._log.canSend(Logger_1.LogLevel.ERROR)) {
+                    console.error(err);
+                }
+                await (0, Helpers_1.sleep)(1000);
+                await sender.disconnect();
+            }
+        }
+    }
+    /** @hidden */
+    async _borrowExportedSender(dcId, shouldReconnect, existingSender) {
+        if (!this._exportedSenderPromises.get(dcId) || shouldReconnect) {
+            this._exportedSenderPromises.set(dcId, this._connectSender(existingSender || this._createExportedSender(dcId), dcId));
+        }
+        let sender;
+        try {
+            sender = await this._exportedSenderPromises.get(dcId);
+            if (!sender.isConnected()) {
+                if (sender.isConnecting) {
+                    await (0, Helpers_1.sleep)(EXPORTED_SENDER_RECONNECT_TIMEOUT);
+                    return this._borrowExportedSender(dcId, false, sender);
+                }
+                else {
+                    return this._borrowExportedSender(dcId, true, sender);
+                }
+            }
+        }
+        catch (err) {
+            if (this._errorHandler) {
+                await this._errorHandler(err);
+            }
+            if (this._log.canSend(Logger_1.LogLevel.ERROR)) {
+                console.error(err);
+            }
+            return this._borrowExportedSender(dcId, true);
+        }
+        if (this._exportedSenderReleaseTimeouts.get(dcId)) {
+            clearTimeout(this._exportedSenderReleaseTimeouts.get(dcId));
+            this._exportedSenderReleaseTimeouts.delete(dcId);
+        }
+        this._exportedSenderReleaseTimeouts.set(dcId, setTimeout(() => {
+            this._exportedSenderReleaseTimeouts.delete(dcId);
+            if (sender._pendingState.values().length) {
+                console.log("sender already has some hanging states. reconnecting");
+                sender._reconnect();
+                this._borrowExportedSender(dcId, false, sender);
+            }
+            else {
+                sender.disconnect();
+            }
+        }, EXPORTED_SENDER_RELEASE_TIMEOUT));
+        return sender;
+    }
+    /** @hidden */
+    _createExportedSender(dcId) {
+        return new network_1.MTProtoSender(this.session.getAuthKey(dcId), {
+            logger: this._log,
+            dcId,
+            retries: this._connectionRetries,
+            delay: this._retryDelay,
+            autoReconnect: this._autoReconnect,
+            connectTimeout: this._timeout,
+            authKeyCallback: this._authKeyCallback.bind(this),
+            isMainSender: dcId === this.session.dcId,
+            onConnectionBreak: this._cleanupExportedSender.bind(this),
+            client: this,
+            securityChecks: this._securityChecks,
+            _exportedSenderPromises: this._exportedSenderPromises,
+            reconnectRetries: this._reconnectRetries,
+        });
+    }
+    /** @hidden */
+    getSender(dcId) {
+        return dcId
+            ? this._borrowExportedSender(dcId)
+            : Promise.resolve(this._sender);
+    }
+    // endregion
+    async getDC(dcId, download) {
+        throw new Error("Cannot be called from here!");
+    }
+    invoke(request) {
+        throw new Error("Cannot be called from here!");
+    }
+    setLogLevel(level) {
+        this._log.setLevel(level);
+    }
+    get logger() {
+        return this._log;
+    }
+    /**
+     * Custom error handler for the client
+     * @example
+     * ```ts
+     * client.onError = async (error)=>{
+     *         console.log("error is",error)
+     *     }
+     * ```
+     */
+    set onError(handler) {
+        this._errorHandler = async (error) => {
+            try {
+                await handler(error);
+            }
+            catch (e) {
+                if (this._log.canSend(Logger_1.LogLevel.ERROR)) {
+                    e.message = `Error ${e.message} thrown while handling top-level error: ${error.message}`;
+                    console.error(e);
+                }
+            }
+        };
+    }
+}
+exports.TelegramBaseClient = TelegramBaseClient;

package/client/updates.d.ts

@@ -0,0 +1,31 @@
+import type { EventBuilder } from "../events/common";
+import { Api } from "../tl";
+import type { TelegramClient } from "..";
+import { UpdateConnectionState } from "../network";
+/**
+ If this exception is raised in any of the handlers for a given event,
+ it will stop the execution of all other registered event handlers.
+ It can be seen as the ``StopIteration`` in a for loop but for events.
+ */
+export declare class StopPropagation extends Error {
+}
+/** @hidden */
+export declare function on(client: TelegramClient, event?: EventBuilder): (f: (event: any) => void) => (event: any) => void;
+/** @hidden */
+export declare function addEventHandler(client: TelegramClient, callback: CallableFunction, event?: EventBuilder): void;
+/** @hidden */
+export declare function removeEventHandler(client: TelegramClient, callback: CallableFunction, event: EventBuilder): void;
+/** @hidden */
+export declare function listEventHandlers(client: TelegramClient): [EventBuilder, CallableFunction][];
+/** @hidden */
+export declare function catchUp(): void;
+/** @hidden */
+export declare function _handleUpdate(client: TelegramClient, update: Api.TypeUpdate | number): void;
+/** @hidden */
+export declare function _processUpdate(client: TelegramClient, update: any, others: any, entities?: any): void;
+/** @hidden */
+export declare function _dispatchUpdate(client: TelegramClient, args: {
+    update: UpdateConnectionState | any;
+}): Promise<void>;
+/** @hidden */
+export declare function _updateLoop(client: TelegramClient): Promise<void>;