@mtkruto/node 0.0.986 → 0.0.988

package/esm/connection/0_connection.d.ts

@@ -1,6 +1,7 @@
 import { MaybePromise } from "../utilities/0_types.js";
 declare abstract class Foundation {
     abstract get connected(): boolean;
+    stateChangeHandler?: (connected: boolean) => void;
     abstract open(): MaybePromise<void>;
     abstract write(p: Uint8Array): MaybePromise<void>;
     abstract close(): MaybePromise<void>;

package/esm/connection/0_connection.js

@@ -1,4 +1,12 @@
 class Foundation {
+    constructor() {
+        Object.defineProperty(this, "stateChangeHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
 }
 export class ConnectionUnframed extends Foundation {
     constructor() {

package/esm/connection/1_connection_web_socket.d.ts

@@ -1,13 +1,15 @@
 import { ConnectionUnframed } from "./0_connection.js";
 export declare class ConnectionWebSocket extends ConnectionUnframed implements ConnectionUnframed {
+    private readonly url;
     private webSocket;
     private rMutex;
     private wMutex;
     private buffer;
     private nextResolve;
     constructor(url: string | URL);
-    private reinitWs;
+    private initWs;
     get connected(): boolean;
+    private wasConnected;
     private isConnecting;
     private connectionError;
     open(): Promise<void>;

package/esm/connection/1_connection_web_socket.js

@@ -5,6 +5,12 @@ const d = debug("ConnectionWebSocket");
 export class ConnectionWebSocket extends ConnectionUnframed {
     constructor(url) {
         super();
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: url
+        });
         Object.defineProperty(this, "webSocket", {
             enumerable: true,
             configurable: true,
@@ -35,6 +41,12 @@ export class ConnectionWebSocket extends ConnectionUnframed {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "wasConnected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         Object.defineProperty(this, "isConnecting", {
             enumerable: true,
             configurable: true,
@@ -47,16 +59,17 @@ export class ConnectionWebSocket extends ConnectionUnframed {
             writable: true,
             value: null
         });
-        this.webSocket = this.reinitWs(url);
-        this.webSocket.addEventListener("close", (e) => {
-            if (e.code != 1000 && e.reason != "method") {
-                this.webSocket = this.reinitWs(url);
-            }
-        });
+        this.webSocket = this.initWs();
     }
-    reinitWs(url) {
-        const webSocket = new dntShim.WebSocket(url, "binary");
+    initWs() {
+        const webSocket = new dntShim.WebSocket(this.url, "binary");
         const mutex = new Mutex();
+        webSocket.addEventListener("close", () => {
+            this.stateChangeHandler?.(false);
+        });
+        webSocket.addEventListener("open", () => {
+            this.stateChangeHandler?.(true);
+        });
         webSocket.addEventListener("message", async (e) => {
             if (typeof e.data === "string") {
                 return;
@@ -77,7 +90,9 @@ export class ConnectionWebSocket extends ConnectionUnframed {
                 // @ts-ignore: Node.js
                 this.connectionError = err;
             }
-            d("WebSocket error: %o", err);
+            if (this.connected) {
+                d("WebSocket error: %o", err);
+            }
         });
         return webSocket;
     }
@@ -89,6 +104,9 @@ export class ConnectionWebSocket extends ConnectionUnframed {
             throw new Error("Already connecting");
         }
         this.isConnecting = true;
+        if (!this.connected && this.wasConnected) {
+            this.webSocket = this.initWs();
+        }
         try {
             while (this.webSocket.readyState != dntShim.WebSocket.OPEN) {
                 if (this.webSocket.readyState == dntShim.WebSocket.CLOSED) {
@@ -103,6 +121,7 @@ export class ConnectionWebSocket extends ConnectionUnframed {
                     await new Promise((r) => setTimeout(r, 5));
                 }
             }
+            this.wasConnected = true;
         }
         finally {
             this.isConnecting = false;

package/esm/constants.d.ts

@@ -5,7 +5,7 @@ export declare const PUBLIC_KEYS: PublicKeys;
 export declare const VECTOR_CONSTRUCTOR = 481674261;
 export declare const INITIAL_DC: DC;
 export declare const LAYER = 161;
-export declare const APP_VERSION = "MTKruto 0.0.986";
+export declare const APP_VERSION = "MTKruto 0.0.988";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/esm/constants.js

@@ -54,7 +54,7 @@ export const PUBLIC_KEYS = Object.freeze([
 export const VECTOR_CONSTRUCTOR = 0x1CB5C415;
 export const INITIAL_DC = "2-test";
 export const LAYER = 161;
-export const APP_VERSION = "MTKruto 0.0.986";
+export const APP_VERSION = "MTKruto 0.0.988";
 // @ts-ignore: lib
 export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 export const LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

package/esm/deps.js

@@ -4,5 +4,5 @@ export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/
 export { Mutex } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/main/mod.js";
-export const debug = (v) => debug_(`mtkruto/${v}`);
+export const debug = (v) => debug_(v);
 export { decode as base64Decode, encode as base64Encode } from "./deps/deno.land/std@0.200.0/encoding/base64.js";

package/esm/transport/2_transport_provider.d.ts

@@ -2,21 +2,14 @@ import { Connection } from "../connection/0_connection.js";
 import { Transport } from "./0_transport.js";
 export type DC = "1" | "2" | "3" | "4" | "5" | "1-test" | "2-test" | "3-test";
 export interface TransportProviderParams {
-    dc?: DC;
+    dc: DC;
     cdn: boolean;
 }
-export type TransportProvider = {
-    initialDc: DC;
-    createTransport: (params: TransportProviderParams) => {
-        connection: Connection;
-        transport: Transport;
-        dcId: number;
-    };
+export type TransportProvider = (params: TransportProviderParams) => {
+    connection: Connection;
+    transport: Transport;
+    dcId: number;
 };
-export interface TransportProviderCreatorParams {
-    initialDc: DC;
-}
-export type TransportProviderCreator<E = Record<never, never>> = (params: TransportProviderCreatorParams & E) => TransportProvider;
-export declare const webSocketTransportProvider: TransportProviderCreator<{
+export declare const webSocketTransportProvider: (params?: {
     wss?: boolean;
-}>;
+}) => TransportProvider;

package/esm/transport/2_transport_provider.js

@@ -13,17 +13,14 @@ const dcToNameMap = {
 function getDcId(dc, cdn) {
     return Number(dc[0]) + (dc.endsWith("-test") ? 10000 : 0) * (cdn ? -1 : 1);
 }
-export const webSocketTransportProvider = ({ initialDc, wss }) => {
-    return {
-        initialDc,
-        createTransport: ({ dc, cdn }) => {
-            dc ??= initialDc;
-            wss ??= typeof location !== "undefined" && location.protocol == "http:" && location.hostname != "localhost" ? false : true;
-            const url = `${wss ? "wss" : "ws"}://${dcToNameMap[dc]}${cdn ? "-1" : ""}.web.telegram.org/${dc.endsWith("-test") ? "apiws_test" : "apiws"}`;
-            const connection = new ConnectionWebSocket(url);
-            const transport = new TransportIntermediate(connection, true);
-            const dcId = getDcId(dc, cdn);
-            return { connection, transport, dcId };
-        },
+export const webSocketTransportProvider = (params) => {
+    return ({ dc, cdn }) => {
+        params ??= {};
+        params.wss ??= typeof location !== "undefined" && location.protocol == "http:" && location.hostname != "localhost" ? false : true;
+        const url = `${params.wss ? "wss" : "ws"}://${dcToNameMap[dc]}${cdn ? "-1" : ""}.web.telegram.org/${dc.endsWith("-test") ? "apiws_test" : "apiws"}`;
+        const connection = new ConnectionWebSocket(url);
+        const transport = new TransportIntermediate(connection, true);
+        const dcId = getDcId(dc, cdn);
+        return { connection, transport, dcId };
     };
 };

package/esm/utilities/0_queue.d.ts

@@ -0,0 +1,6 @@
+export declare class Queue {
+    private functions;
+    add(fn: () => Promise<void>): void;
+    private busy;
+    private check;
+}

package/esm/utilities/0_queue.js

@@ -0,0 +1,38 @@
+export class Queue {
+    constructor() {
+        Object.defineProperty(this, "functions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Array()
+        });
+        Object.defineProperty(this, "busy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    add(fn) {
+        this.functions.push(fn);
+        this.check();
+    }
+    check() {
+        if (this.busy) {
+            return;
+        }
+        else {
+            this.busy = true;
+        }
+        const fn = this.functions.shift();
+        if (fn !== undefined) {
+            fn().finally(() => {
+                this.busy = false;
+                this.check();
+            });
+        }
+        else {
+            this.busy = false;
+        }
+    }
+}

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/mod.js",
   "main": "./script/mod.js",
   "name": "@mtkruto/node",
-  "version": "0.0.986",
+  "version": "0.0.988",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "license": "LGPL-3.0-or-later",

package/script/client/0_utilities.d.ts

@@ -1,3 +1,5 @@
 import * as types from "../tl/2_types.js";
 export declare function getChannelChatId(channelId: bigint): number;
 export declare function peerToChatId(peer: types.TypePeer | types.TypeInputPeer): number;
+export declare function hasPts(v: types.TypeUpdate | types.TypeUpdates): v is types.UpdateShortMessage | types.UpdateShortChatMessage | types.UpdateShortSentMessage | types.UpdateNewMessage | types.UpdateDeleteMessages | types.UpdateReadHistoryInbox | types.UpdateReadHistoryOutbox | types.UpdatePinnedChannelMessages | types.UpdatePinnedMessages | types.UpdateFolderPeers | types.UpdateChannelWebPage | types.UpdateEditMessage | types.UpdateReadMessagesContents | types.UpdateWebPage;
+export declare function hasChannelPts(v: types.TypeUpdate | types.TypeUpdates): v is types.UpdateNewChannelMessage | types.UpdateEditChannelMessage | types.UpdateDeleteChannelMessages | types.UpdateReadChannelInbox;

package/script/client/0_utilities.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.peerToChatId = exports.getChannelChatId = void 0;
+exports.hasChannelPts = exports.hasPts = exports.peerToChatId = exports.getChannelChatId = void 0;
 const constants_js_1 = require("../constants.js");
 const types = __importStar(require("../tl/2_types.js"));
 const _0_control_js_1 = require("../utilities/0_control.js");
@@ -46,3 +46,27 @@ function peerToChatId(peer) {
     }
 }
 exports.peerToChatId = peerToChatId;
+function hasPts(v) {
+    return v instanceof types.UpdateShortMessage ||
+        v instanceof types.UpdateShortChatMessage ||
+        v instanceof types.UpdateShortSentMessage ||
+        v instanceof types.UpdateNewMessage ||
+        v instanceof types.UpdateDeleteMessages ||
+        v instanceof types.UpdateReadHistoryInbox ||
+        v instanceof types.UpdateReadHistoryOutbox ||
+        v instanceof types.UpdatePinnedChannelMessages ||
+        v instanceof types.UpdatePinnedMessages ||
+        v instanceof types.UpdateFolderPeers ||
+        v instanceof types.UpdateChannelWebPage ||
+        v instanceof types.UpdateEditMessage ||
+        v instanceof types.UpdateReadMessagesContents ||
+        v instanceof types.UpdateWebPage;
+}
+exports.hasPts = hasPts;
+function hasChannelPts(v) {
+    return v instanceof types.UpdateNewChannelMessage ||
+        v instanceof types.UpdateEditChannelMessage ||
+        v instanceof types.UpdateDeleteChannelMessages ||
+        v instanceof types.UpdateReadChannelInbox;
+}
+exports.hasChannelPts = hasChannelPts;

package/script/client/1_client_abstract.d.ts

@@ -1,16 +1,21 @@
 import { MaybePromise } from "../utilities/0_types.js";
-import { Connection } from "../connection/0_connection.js";
-import { Transport } from "../transport/0_transport.js";
-import { DC } from "../transport/2_transport_provider.js";
+import { DC, TransportProvider } from "../transport/2_transport_provider.js";
+export interface ClientAbstractParams {
+    initialDc?: DC;
+    /**
+     * The transport provider to use. Defaults to `webSocketTransportProvider` with its default options.
+     */
+    transportProvider?: TransportProvider;
+    cdn?: boolean;
+}
 export declare abstract class ClientAbstract {
-    protected transportProvider: import("../transport/2_transport_provider.js").TransportProvider;
+    protected readonly initialDc: DC;
+    protected readonly transportProvider: TransportProvider;
     protected readonly cdn: boolean;
-    protected connection: Connection;
-    protected transport: Transport;
-    private _dcId;
-    private _initialDc;
-    get initialDc(): DC;
-    constructor(transportProvider?: import("../transport/2_transport_provider.js").TransportProvider, cdn?: boolean);
+    protected transport?: ReturnType<TransportProvider>;
+    private dc?;
+    constructor(params?: ClientAbstractParams);
+    protected stateChangeHandler?: (connected: boolean) => void;
     get dcId(): number;
     setDc(dc: DC): MaybePromise<void>;
     get connected(): boolean;

package/script/client/1_client_abstract.js

@@ -5,23 +5,20 @@ const deps_js_1 = require("../deps.js");
 const constants_js_1 = require("../constants.js");
 const _2_transport_provider_js_1 = require("../transport/2_transport_provider.js");
 class ClientAbstract {
-    get initialDc() {
-        return this._initialDc;
-    }
-    constructor(transportProvider = (0, _2_transport_provider_js_1.webSocketTransportProvider)({ initialDc: constants_js_1.INITIAL_DC }), cdn = false) {
-        Object.defineProperty(this, "transportProvider", {
+    constructor(params) {
+        Object.defineProperty(this, "initialDc", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: transportProvider
+            value: void 0
         });
-        Object.defineProperty(this, "cdn", {
+        Object.defineProperty(this, "transportProvider", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: cdn
+            value: void 0
         });
-        Object.defineProperty(this, "connection", {
+        Object.defineProperty(this, "cdn", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -33,42 +30,41 @@ class ClientAbstract {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_dcId", {
+        Object.defineProperty(this, "dc", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "_initialDc", {
+        Object.defineProperty(this, "stateChangeHandler", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        const { initialDc, createTransport } = transportProvider;
-        this._initialDc = initialDc;
-        const { connection, transport, dcId } = createTransport({ cdn: this.cdn });
-        this.connection = connection;
-        this.transport = transport;
-        this._dcId = dcId;
+        this.initialDc = params?.initialDc ?? constants_js_1.INITIAL_DC;
+        this.transportProvider = params?.transportProvider ?? (0, _2_transport_provider_js_1.webSocketTransportProvider)();
+        this.cdn = params?.cdn ?? false;
     }
     get dcId() {
-        return this._dcId;
+        if (!this.transport) {
+            throw new Error("Not connected");
+        }
+        return this.transport.dcId;
     }
     // MaybePromise since `Client` has to deal with `Storage.set()`
     setDc(dc) {
-        const { connection, transport, dcId } = this.transportProvider.createTransport({ dc, cdn: this.cdn });
-        this.connection = connection;
-        this.transport = transport;
-        this._dcId = dcId;
+        this.dc = dc;
     }
     get connected() {
-        return this.connection.connected;
+        return this.transport === undefined ? false : this.transport.connection.connected;
     }
     async connect() {
+        this.transport = this.transportProvider({ dc: this.dc ?? this.initialDc, cdn: this.cdn });
+        this.transport.connection.stateChangeHandler = this.stateChangeHandler;
         await (0, deps_js_1.initTgCrypto)();
-        await this.connection.open();
-        await this.transport.initialize();
+        await this.transport.connection.open();
+        await this.transport.transport.initialize();
     }
     async reconnect(dc) {
         await this.disconnect();
@@ -78,8 +74,11 @@ class ClientAbstract {
         await this.connect();
     }
     async disconnect() {
-        await this.transport.deinitialize();
-        await this.connection.close();
+        if (!this.transport) {
+            throw new Error("Not connected");
+        }
+        await this.transport.transport.deinitialize();
+        await this.transport.connection.close();
     }
 }
 exports.ClientAbstract = ClientAbstract;

package/script/client/2_client_plain.d.ts

@@ -1,10 +1,16 @@
+import { PublicKeys } from "../constants.js";
 import { Function } from "../tl/3_functions.js";
-import { TransportProvider } from "../transport/2_transport_provider.js";
-import { ClientAbstract } from "./1_client_abstract.js";
+import { ClientAbstract, ClientAbstractParams } from "./1_client_abstract.js";
+export interface ClientPlainParams extends ClientAbstractParams {
+    /**
+     * MTProto public keys to use in the `[keyId, [key, exponent]][]` format. Don't set this unless you know what you are doing.
+     */
+    publicKeys?: PublicKeys;
+}
 export declare class ClientPlain extends ClientAbstract {
     private readonly publicKeys;
     private lastMsgId;
-    constructor(transportProvider: TransportProvider, publicKeys?: import("../constants.js").PublicKeys);
+    constructor(params?: ClientPlainParams);
     invoke<T extends Function<unknown>>(function_: T): Promise<T["__R"]>;
     createAuthKey(): Promise<{
         authKey: Uint8Array;

package/script/client/2_client_plain.js

@@ -16,13 +16,13 @@ const _1_client_abstract_js_1 = require("./1_client_abstract.js");
 const _0_message_js_1 = require("./0_message.js");
 const d = (0, deps_js_1.debug)("ClientPlain/createAuthKey");
 class ClientPlain extends _1_client_abstract_js_1.ClientAbstract {
-    constructor(transportProvider, publicKeys = constants_js_1.PUBLIC_KEYS) {
-        super(transportProvider);
+    constructor(params) {
+        super(params);
         Object.defineProperty(this, "publicKeys", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: publicKeys
+            value: void 0
         });
         Object.defineProperty(this, "lastMsgId", {
             enumerable: true,
@@ -30,11 +30,15 @@ class ClientPlain extends _1_client_abstract_js_1.ClientAbstract {
             writable: true,
             value: 0n
         });
+        this.publicKeys = params?.publicKeys ?? constants_js_1.PUBLIC_KEYS;
     }
     async invoke(function_) {
+        if (!this.transport) {
+            throw new Error("Not connected");
+        }
         const msgId = this.lastMsgId = (0, _0_message_js_1.getMessageId)(this.lastMsgId);
-        await this.transport.send((0, _0_message_js_1.packUnencryptedMessage)(function_[_1_tl_object_js_1.serialize](), msgId));
-        const buffer = await this.transport.receive();
+        await this.transport.transport.send((0, _0_message_js_1.packUnencryptedMessage)(function_[_1_tl_object_js_1.serialize](), msgId));
+        const buffer = await this.transport.transport.receive();
         if (buffer.length == 4) {
             const int = (0, _0_bigint_js_1.bigIntFromBuffer)(buffer, true, true);
             if (int == -404n) {

package/script/client/3_client.d.ts

@@ -1,10 +1,9 @@
-import { PublicKeys } from "../constants.js";
 import { MaybePromise } from "../utilities/0_types.js";
 import * as types from "../tl/2_types.js";
 import * as functions from "../tl/3_functions.js";
 import { ReadObject } from "../tl/3_tl_reader.js";
 import { Storage } from "../storage/0_storage.js";
-import { DC, TransportProvider } from "../transport/2_transport_provider.js";
+import { DC } from "../transport/2_transport_provider.js";
 import { MessageEntity } from "../types/0_message_entity.js";
 import { ReplyKeyboardRemove } from "../types/0_reply_keyboard_remove.js";
 import { ForceReply } from "../types/0_force_reply.js";
@@ -12,6 +11,7 @@ import { ReplyKeyboardMarkup } from "../types/2_reply_keyboard_markup.js";
 import { InlineKeyboardMarkup } from "../types/2_inline_keyboard_markup.js";
 import { Message } from "../types/3_message.js";
 import { ClientAbstract } from "./1_client_abstract.js";
+import { ClientPlainParams } from "./2_client_plain.js";
 export declare const getEntity: unique symbol;
 export declare const getStickerSetName: unique symbol;
 export declare const handleMigrationError: unique symbol;
@@ -25,16 +25,11 @@ export interface AuthorizeUserParams<S = string> {
     code: S | (() => MaybePromise<S>);
     password: S | ((hint: string | null) => MaybePromise<S>);
 }
-export type UpdateHandler = null | ((client: Client, update: types.TypeUpdate) => MaybePromise<void>);
-export interface ClientParams {
+export interface ClientParams extends ClientPlainParams {
     /**
      * Default parse mode. Defauls to `ParseMode.None`.
      */
     parseMode?: ParseMode;
-    /**
-     * The transport provider to use. Defaults to `webSocketTransportProvider`.
-     */
-    transportProvider?: TransportProvider;
     /**
      * The app_version parameter to be passed to initConnection when calling `authorize`.
      */
@@ -59,10 +54,6 @@ export interface ClientParams {
      * The system_version parameter to be passed to initConnection when calling `authorize`.
      */
     systemVersion?: string;
-    /**
-     * MTProto public keys to use in the `[keyId, [key, exponent]][]` format. Don't set this unless you know what you are doing.
-     */
-    publicKeys?: PublicKeys;
     /**
      * Whether to automatically call `start` with no parameters in the first `invoke` call.
      */
@@ -161,7 +152,6 @@ export declare class Client extends ClientAbstract {
     private promises;
     private toAcknowledge;
     private updateState?;
-    updateHandler: UpdateHandler;
     readonly parseMode: ParseMode;
     readonly appVersion: string;
     readonly deviceModel: string;
@@ -179,7 +169,9 @@ export declare class Client extends ClientAbstract {
      * @param apiHash App's API hash from [my.telegram.org/apps](https://my.telegram.org/apps). Defaults to empty string (unset).
      * @param params Other parameters.
      */
-    constructor(storage?: Storage, apiId?: number | null, apiHash?: string | null, params?: ClientParams, cdn?: boolean);
+    constructor(storage?: Storage, apiId?: number | null, apiHash?: string | null, params?: ClientParams);
+    private propagateConnectionState;
+    protected stateChangeHandler: (connected: boolean) => void;
     private storageInited;
     /**
      * Sets the DC and resets the auth key stored in the session provider
@@ -189,6 +181,7 @@ export declare class Client extends ClientAbstract {
      */
     setDc(dc: DC): Promise<void>;
     private setAuth;
+    private connectMutex;
     /**
      * Loads the session if `setDc` was not called, initializes and connnects
      * a `ClientPlain` to generate auth key if there was none, and connects the client.
@@ -240,14 +233,13 @@ export declare class Client extends ClientAbstract {
     send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
     private processChats;
     private processUsers;
-    private updateApplicationMutex;
-    private applyUpdateNoGap;
-    private applyUpdate;
-    private updateProcessLock;
+    private handleUpdateQueue;
+    private processUpdatesQueue;
+    private checkGap;
+    private checkChannelGap;
     private processUpdates;
     private setUpdateStateDate;
     private getLocalState;
-    private updateGapRecoveryMutex;
     private recoverUpdateGap;
     private recoverChannelUpdateGap;
     getInputPeer(id: ChatID): Promise<types.InputPeerChat | types.InputPeerUser | types.InputPeerChannel>;
@@ -313,4 +305,21 @@ export declare class Client extends ClientAbstract {
      * Get information on the currently authorized user.
      */
     getMe(): Promise<import("../types/1_user.js").User>;
+    private handleUpdate;
+    handler: Handler;
+    use(middleware: Handler): void;
+    on<U extends keyof Update, K extends keyof Update[U]>(filter: Update[U] extends string ? U : U | [U, ...K[]], handler: Handler<Pick<{
+        [P in U]: With<Update[U], K>;
+    }, U>>): void;
+}
+type With<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export type ConnectionState = "not-connected" | "updating" | "ready";
+export interface Update {
+    message: Message;
+    editedMessage: Message;
+    connectionState: ConnectionState;
+}
+export interface Handler<U extends Partial<Update> = Partial<Update>> {
+    (update: U, next: () => Promise<void>): MaybePromise<void>;
 }
+export {};