@mtkruto/browser 0.6.1 → 0.119.1

package/esm/client/6_client.js

@@ -0,0 +1,3409 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
+ *
+ * This file is part of MTKruto.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { delay, MINUTE, SECOND, unreachable } from "../0_deps.js";
+import { AccessError, ConnectionError, InputError } from "../0_errors.js";
+import { drop, getLogger, Mutex, ZERO_CHANNEL_ID } from "../1_utilities.js";
+import { StorageMemory } from "../2_storage.js";
+import { Api, Mtproto } from "../2_tl.js";
+import { getDcId } from "../3_transport.js";
+import { constructChatP, constructUser2 } from "../3_types.js";
+import { APP_VERSION, DEVICE_MODEL, INITIAL_DC, LANG_CODE, LANG_PACK, MAX_CHANNEL_ID, MAX_CHAT_ID, SYSTEM_LANG_CODE, SYSTEM_VERSION, USERNAME_TTL } from "../4_constants.js";
+import { AuthKeyUnregistered, FloodWait, Migrate, SessionRevoked } from "../4_errors.js";
+import { peerToChatId } from "../tl/2_telegram.js";
+import { AbortableLoop } from "./0_abortable_loop.js";
+import { StorageOperations } from "./0_storage_operations.js";
+import { canBeInputChannel, canBeInputUser, DOWNLOAD_POOL_SIZE, getUsername, toInputChannel, toInputUser } from "./0_utilities.js";
+import { skipInvoke } from "./1_invoke_middleware.js";
+import { AccountManager } from "./2_account_manager.js";
+import { BotInfoManager } from "./2_bot_info_manager.js";
+import { BusinessConnectionManager } from "./2_business_connection_manager.js";
+import { ClientEncrypted } from "./2_client_encrypted.js";
+import { FileManager } from "./2_file_manager.js";
+import { NetworkStatisticsManager } from "./2_network_statistics_manager.js";
+import { PaymentManager } from "./2_payment_manager.js";
+import { ReactionManager } from "./2_reaction_manager.js";
+import { signIn } from "./2_sign_in.js";
+import { TranslationsManager } from "./2_translations_manager.js";
+import { UpdateManager } from "./2_update_manager.js";
+import { ClientEncryptedPool } from "./3_client_encrypted_pool.js";
+import { MessageManager } from "./3_message_manager.js";
+import { VideoChatManager } from "./3_video_chat_manager.js";
+import { CallbackQueryManager } from "./4_callback_query_manager.js";
+import { ChatListManager } from "./4_chat_list_manager.js";
+import { ChatManager } from "./4_chat_manager.js";
+import { ChecklistManager } from "./4_checklist_manager.js";
+import { ForumManager } from "./4_forum_manager.js";
+import { GiftManager } from "./4_gift_manager.js";
+import { InlineQueryManager } from "./4_inline_query_manager.js";
+import { LinkPreviewManager } from "./4_link_preview_manager.js";
+import { PollManager } from "./4_poll_manager.js";
+import { StoryManager } from "./4_story_manager.js";
+import { Composer } from "./5_composer.js";
+export { restartAuth } from "./2_sign_in.js";
+export const handleMigrationError = Symbol("handleMigrationError");
+// global Client ID counter for logs
+let id = 0;
+const getPeer = Symbol();
+const mustGetPeer = Symbol();
+/**
+ * An MTKruto client.
+ */
+export class Client extends Composer {
+    #clients = new Array();
+    #downloadPools = {};
+    #uploadPools = {};
+    #guaranteeUpdateDelivery;
+    // 2_
+    #accountManager;
+    #botInfoManager;
+    #businessConnectionManager;
+    #fileManager;
+    #networkStatisticsManager;
+    #paymentManager;
+    #reactionManager;
+    #translationsManager;
+    #updateManager;
+    // 3_
+    #messageManager;
+    #videoChatManager;
+    // 4_
+    #callbackQueryManager;
+    #chatListManager;
+    #chatManager;
+    #checklistManager;
+    #forumManager;
+    #giftManager;
+    #inlineQueryManager;
+    #linkPreviewManager;
+    #pollManager;
+    #storyManager;
+    // deno-lint-ignore no-explicit-any
+    #managers;
+    // deno-lint-ignore no-explicit-any
+    get managers() {
+        return this.#managers ?? (this.#managers ??= {
+            // 2_
+            accountManager: this.#accountManager,
+            botInfoManager: this.#botInfoManager,
+            businessConnectionManager: this.#businessConnectionManager,
+            fileManager: this.#fileManager,
+            networkStatisticsManager: this.#networkStatisticsManager,
+            paymentManager: this.#paymentManager,
+            reactionManager: this.#reactionManager,
+            translationsManager: this.#translationsManager,
+            updateManager: this.#updateManager,
+            // 3_
+            messageManager: this.#messageManager,
+            videoChatManager: this.#videoChatManager,
+            // 4_
+            callbackQueryManager: this.#callbackQueryManager,
+            chatListManager: this.#chatListManager,
+            chatManager: this.#chatManager,
+            checklistManager: this.#checklistManager,
+            forumManager: this.#forumManager,
+            giftManager: this.#giftManager,
+            inlineQueryManager: this.#inlineQueryManager,
+            linkPreviewManager: this.#linkPreviewManager,
+            pollManager: this.#pollManager,
+            storyManager: this.#storyManager,
+        });
+    }
+    #storage_;
+    #messageStorage_;
+    storage;
+    messageStorage;
+    #parseMode;
+    #apiId;
+    #apiHash;
+    #transportProvider;
+    appVersion;
+    deviceModel;
+    language;
+    platform;
+    systemLangCode;
+    systemVersion;
+    #publicKeys;
+    #outgoingMessages;
+    #persistCache;
+    #disableUpdates;
+    #authString;
+    #initialDc;
+    #L;
+    #LsignIn;
+    #LupdateGapRecoveryLoop;
+    #LstorageWriteLoop;
+    #LhandleMigrationError;
+    #Lmin;
+    /**
+     * Constructs the client.
+     */
+    constructor(params) {
+        super();
+        this.#apiId = params?.apiId ?? 0;
+        this.#apiHash = params?.apiHash ?? "";
+        this.#transportProvider = params?.transportProvider;
+        this.#initialDc = params?.initialDc ?? INITIAL_DC;
+        this.#storage_ = params?.storage || new StorageMemory();
+        this.#persistCache = params?.persistCache ?? false;
+        if (!this.#persistCache) {
+            this.#messageStorage_ = new StorageMemory();
+        }
+        else {
+            this.#messageStorage_ = this.#storage_;
+        }
+        this.storage = new StorageOperations(this.#storage_);
+        this.messageStorage = new StorageOperations(this.#messageStorage_);
+        this.#parseMode = params?.parseMode ?? null;
+        this.#disableUpdates = params?.disableUpdates ?? false;
+        this.#authString = params?.authString;
+        this.appVersion = params?.appVersion ?? APP_VERSION;
+        this.deviceModel = params?.deviceModel ?? DEVICE_MODEL;
+        this.language = params?.language ?? LANG_CODE;
+        this.platform = params?.platform ?? LANG_PACK;
+        this.systemLangCode = params?.systemLangCode ?? SYSTEM_LANG_CODE;
+        this.systemVersion = params?.systemVersion ?? SYSTEM_VERSION;
+        this.#publicKeys = params?.publicKeys;
+        this.#outgoingMessages = params?.outgoingMessages ?? false;
+        this.#guaranteeUpdateDelivery = params?.guaranteeUpdateDelivery ?? false;
+        const L = this.#L = getLogger("Client").client(id++);
+        this.#LsignIn = L.branch("signIn");
+        this.#LupdateGapRecoveryLoop = L.branch("updateGapRecoveryLoop");
+        this.#LstorageWriteLoop = L.branch("storageWriteLoop");
+        this.#LhandleMigrationError = L.branch("[handleMigrationError]");
+        this.#Lmin = L.branch("min");
+        const c = {
+            id,
+            getUploadPoolSize: this.#getUploadPoolSize.bind(this),
+            invoke: async (function_, params) => {
+                if (params?.businessConnectionId) {
+                    if (Mtproto.is("ping", function_)) {
+                        unreachable();
+                    }
+                    return await this.invoke({ _: "invokeWithBusinessConnection", connection_id: params.businessConnectionId, query: function_ }, params);
+                }
+                else {
+                    return await this.invoke(function_, params);
+                }
+            },
+            storage: this.storage,
+            messageStorage: this.messageStorage,
+            guaranteeUpdateDelivery: this.#guaranteeUpdateDelivery,
+            setConnectionState: this.#propagateConnectionState.bind(this),
+            resetConnectionState: () => this.#stateChangeHandler(this.isConnected),
+            getSelfId: this.#getSelfId.bind(this),
+            getIsPremium: this.#getIsPremium.bind(this),
+            getInputPeer: this.getInputPeer.bind(this),
+            getInputChannel: this.getInputChannel.bind(this),
+            getInputUser: this.getInputUser.bind(this),
+            getInputPeerChatId: this.#getInputPeerChatId.bind(this),
+            getPeer: this[mustGetPeer].bind(this),
+            handleUpdate: this.#queueHandleCtxUpdate.bind(this),
+            parseMode: this.#parseMode,
+            outgoingMessages: this.#outgoingMessages,
+            dropPendingUpdates: params?.dropPendingUpdates,
+            isDisconnected: () => this.isDisconnected,
+            langPack: this.platform,
+            langCode: this.language,
+        };
+        // 2_
+        this.#accountManager = new AccountManager(c);
+        this.#botInfoManager = new BotInfoManager(c);
+        this.#businessConnectionManager = new BusinessConnectionManager(c);
+        const fileManager = this.#fileManager = new FileManager(c);
+        this.#networkStatisticsManager = new NetworkStatisticsManager(c);
+        this.#paymentManager = new PaymentManager(c);
+        this.#reactionManager = new ReactionManager(c);
+        this.#translationsManager = new TranslationsManager(c);
+        this.#updateManager = new UpdateManager(c);
+        // 3_
+        const messageManager = this.#messageManager = new MessageManager({ ...c, fileManager });
+        this.#videoChatManager = new VideoChatManager({ ...c, fileManager });
+        // 4_
+        this.#callbackQueryManager = new CallbackQueryManager({ ...c, messageManager });
+        this.#chatListManager = new ChatListManager({ ...c, fileManager, messageManager });
+        this.#chatManager = new ChatManager({ ...c, fileManager, messageManager });
+        this.#checklistManager = new ChecklistManager({ ...c, messageManager });
+        this.#forumManager = new ForumManager({ ...c, messageManager });
+        this.#giftManager = new GiftManager({ ...c, messageManager });
+        this.#inlineQueryManager = new InlineQueryManager({ ...c, messageManager });
+        this.#linkPreviewManager = new LinkPreviewManager({ ...c, messageManager });
+        this.#pollManager = new PollManager({ ...c, messageManager });
+        this.#storyManager = new StoryManager({ ...c, fileManager, messageManager });
+        this.#updateManager.setUpdateHandler(this.#handleUpdate.bind(this));
+        if (params?.defaultHandlers ?? true) {
+            this.invoke.use(async ({ error }, next) => {
+                if (error instanceof FloodWait && error.seconds <= 10) {
+                    L.warning("sleeping for", error.seconds, "because of:", error);
+                    await delay(error.seconds * SECOND);
+                    return true;
+                }
+                else {
+                    return next();
+                }
+            });
+        }
+    }
+    #setMainClient(client) {
+        this.#disconnectAllClients();
+        this.#clients = [client];
+        client.handlers.onUpdate = (updates) => {
+            this.#updateManager.processUpdates(updates, true, null);
+            this.#lastUpdates = new Date();
+        };
+        client.handlers.onDeserializationError = async () => {
+            await this.#updateManager.recoverUpdateGap("deserialization error");
+        };
+        client.handlers.onNewServerSalt = async (serverSalt) => {
+            await this.storage.setServerSalt(serverSalt);
+        };
+        client.onConnectionStateChange = this.#onConnectionStateChange.bind(this);
+    }
+    #newClient(dc, main, isCdn) {
+        const client = new ClientEncrypted(dc, this.#apiId, {
+            appVersion: this.appVersion,
+            deviceModel: this.deviceModel,
+            langCode: this.language,
+            langPack: this.platform,
+            systemLangCode: this.systemLangCode,
+            systemVersion: this.systemVersion,
+            transportProvider: this.#transportProvider,
+            isCdn: isCdn,
+            disableUpdates: !main || isCdn,
+            publicKeys: this.#publicKeys,
+        });
+        client.connectionCallback = this.#networkStatisticsManager.getTransportReadWriteCallback(isCdn);
+        return client;
+    }
+    #disconnectAllClients() {
+        for (const client of this.#clients) {
+            client.disconnect();
+        }
+        for (const pool of Object.values(this.#downloadPools)) {
+            pool.disconnect();
+        }
+        for (const pool of Object.values(this.#uploadPools)) {
+            pool.disconnect();
+        }
+    }
+    get #client() {
+        return this.#clients[0];
+    }
+    // direct ClientEncrypted property proxies
+    get isConnected() {
+        return this.#client?.isConnected ?? false;
+    }
+    get isDisconnected() {
+        return this.#client?.isDisconnected ?? true;
+    }
+    #propagateConnectionState(connectionState) {
+        this.#queueHandleCtxUpdate({ connectionState });
+        this.#lastPropagatedConnectionState = connectionState;
+    }
+    #lastPropagatedConnectionState = null;
+    #stateChangeHandler = ((isConnected) => {
+        const connectionState = isConnected ? "ready" : "notConnected";
+        if (this.#lastPropagatedConnectionState !== connectionState) {
+            this.#propagateConnectionState(connectionState);
+        }
+    }).bind(this);
+    #storageInited = false;
+    async #initStorage() {
+        if (!this.#storageInited) {
+            await this.storage.initialize();
+            if (!this.#guaranteeUpdateDelivery) {
+                await this.storage.deleteUpdates();
+                await this.storage.commit(true);
+            }
+            this.#storageInited = true;
+        }
+    }
+    #connectMutex = new Mutex();
+    /**
+     * 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.
+     * Before establishing the connection, the session is saved.
+     */
+    async connect() {
+        const unlock = await this.#connectMutex.lock();
+        try {
+            if (this.isConnected) {
+                return;
+            }
+            await this.#initStorage();
+            if (this.#authString && !this.#authStringImported) {
+                await this.importAuthString(this.#authString);
+            }
+            const auth = this.storage.auth.mustGet();
+            if (auth.authKey !== null && auth.dc !== null) {
+                if (!this.#client || this.#client.dc !== auth.dc) {
+                    this.#client?.disconnect();
+                    this.#setMainClient(this.#newClient(auth.dc, true, false));
+                }
+                await this.#client.setAuthKey(auth.authKey);
+                if (this.#client.serverSalt === 0n) {
+                    this.#client.serverSalt = await this.storage.getServerSalt() ?? 0n;
+                }
+            }
+            else {
+                const dc = auth.dc ?? this.#initialDc;
+                if (!this.#client || this.#client.dc !== dc) {
+                    this.#client?.disconnect();
+                    this.#setMainClient(this.#newClient(dc, true, false));
+                }
+            }
+            await this.#client.connect();
+            await this.storage.auth.update((v) => {
+                v.authKey = this.#client.authKey;
+                v.dc = this.#client.dc;
+            });
+            await this.storage.setServerSalt(this.#client.serverSalt);
+            this.#updateGapRecoveryLoop.start();
+            this.#clientDisconnectionLoop.start();
+            if (!this.#messageStorage_.isMemory) {
+                this.#storageWriteLoop.start();
+            }
+            else {
+                this.#L.debug("not starting storageWriteLoop");
+            }
+            await this.storage.commit(true);
+        }
+        finally {
+            unlock();
+        }
+    }
+    async [handleMigrationError](err) {
+        let newDc = String(err.dc);
+        if (Math.abs(getDcId(this.#client.dc, this.#client.isCdn)) >= 10_000) {
+            newDc += "-test";
+        }
+        this.disconnect();
+        await this.storage.auth.update((v) => {
+            v.authKey = null;
+            v.dc = newDc;
+        });
+        await this.connect();
+        this.#LhandleMigrationError.debug(`migrated to DC${newDc}`);
+    }
+    async disconnect() {
+        this.#disconnectAllClients();
+        this.#clientDisconnectionLoop.abort();
+        this.#updateGapRecoveryLoop.abort();
+        this.#storageWriteLoop.abort();
+        this.#updateManager.closeAllChats();
+        await this.storage.commit(true);
+        await this.messageStorage.commit(true);
+    }
+    #lastPropagatedAuthorizationState = null;
+    async #propagateAuthorizationState(authorized) {
+        if (this.#lastPropagatedAuthorizationState !== authorized) {
+            await this.#handleCtxUpdate({ authorizationState: { isAuthorized: authorized } });
+            this.#lastPropagatedAuthorizationState = authorized;
+        }
+    }
+    async #getSelfId() {
+        const id = await this.storage.getAccountId();
+        if (id === null) {
+            throw new Error("Unauthorized");
+        }
+        return id;
+    }
+    async #getIsPremium() {
+        const maybeIsPremium = await this.storage.getIsPremium();
+        if (maybeIsPremium !== null) {
+            return maybeIsPremium;
+        }
+        return this.#lastGetMe?.isPremium ?? false;
+    }
+    #lastUpdates = new Date();
+    #updateGapRecoveryLoop = new AbortableLoop(async (loop, signal) => {
+        await delay(60 * SECOND, { signal });
+        if (!this.isConnected) {
+            loop.abort();
+            return;
+        }
+        if (Date.now() - this.#lastUpdates.getTime() >= 15 * MINUTE) {
+            drop(this.#updateManager.recoverUpdateGap("lastUpdates").then(() => {
+                this.#lastUpdates = new Date();
+            }));
+        }
+    }, (loop, err) => {
+        if (!this.isConnected) {
+            loop.abort();
+        }
+        else {
+            this.#LupdateGapRecoveryLoop.error(err);
+        }
+    });
+    #clientDisconnectionLoop = new AbortableLoop(async (loop, signal) => {
+        await delay(60 * SECOND, { signal });
+        if (!this.isConnected) {
+            loop.abort();
+            return;
+        }
+        const now = Date.now();
+        const disconnectAfter = 5 * MINUTE;
+        for (const [i, client] of this.#clients.entries()) {
+            if (i > 0 && !client.isDisconnected && client.lastRequest && now - client.lastRequest.getTime() >= disconnectAfter) {
+                client?.disconnect();
+            }
+        }
+    }, (loop) => {
+        if (!this.isConnected) {
+            loop.abort();
+        }
+    });
+    #storageWriteLoop = new AbortableLoop(async (_loop, signal) => {
+        await delay(5 * SECOND, { signal });
+        await this.messageStorage.commit();
+        await this.storage.commit();
+    }, (err) => {
+        this.#LstorageWriteLoop.error(err);
+    });
+    async #checkAuthorization() {
+        if (this.#lastGetMe) {
+            return this.#lastGetMe;
+        }
+        try {
+            await this.#updateManager.fetchState("#checkAuthorization");
+            const me = await this.#getMe();
+            await this.#propagateAuthorizationState(true);
+            drop(this.#updateManager.recoverUpdateGap("#checkAuthorization"));
+            return me;
+        }
+        catch (err) {
+            if (!(err instanceof AuthKeyUnregistered) && !(err instanceof SessionRevoked)) {
+                throw err;
+            }
+        }
+    }
+    /**
+     * Send a user verification code.
+     *
+     * @param phoneNumber The phone number to send the code to.
+     * @method ac
+     */
+    async sendCode(phoneNumber) {
+        const me = await this.#checkAuthorization();
+        if (me) {
+            return;
+        }
+        try {
+            await this.#accountManager.sendCode(phoneNumber, this.#apiId, this.#apiHash);
+        }
+        catch (err) {
+            if (err instanceof Migrate) {
+                await this[handleMigrationError](err);
+                await this.#accountManager.sendCode(phoneNumber, this.#apiId, this.#apiHash);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    /**
+     * Check if a code entered by the user was the same as the verification code.
+     *
+     * @param code A code entered by the user.
+     * @method ac
+     */
+    async checkCode(code) {
+        const result = await this.#accountManager.checkCode(code);
+        if (result.type === "signedIn") {
+            await this.storage.auth.update((v) => {
+                v.userId = result.userId;
+                v.isBot = false;
+            });
+            this.#LsignIn.debug("signed in as user");
+            await this.#propagateAuthorizationState(true);
+            await this.#updateManager.fetchState("checkCode");
+        }
+        return result;
+    }
+    /**
+     * Get the user account password's hint.
+     *
+     * @method ac
+     */
+    async getPasswordHint() {
+        return await this.#accountManager.getPasswordHint();
+    }
+    /**
+     * Check whether a password entered by the user is the same as the account's one.
+     *
+     * @param password The password to check
+     * @returns The result of the check.
+     * @method ac
+     */
+    async checkPassword(password) {
+        const result = await this.#accountManager.checkPassword(password);
+        if (result.type === "signedIn") {
+            await this.storage.auth.update((v) => {
+                v.userId = result.userId;
+                v.isBot = false;
+            });
+            await this.storage.commit(true);
+            this.#LsignIn.debug("signed in as user");
+            await this.#propagateAuthorizationState(true);
+            await this.#updateManager.fetchState("checkPassword");
+        }
+        return result;
+    }
+    /**
+     * Check whether a bot token is valid.
+     *
+     * @param password The password to check
+     * @returns The result of the check.
+     * @method ac
+     */
+    async checkBotToken(botToken) {
+        const me = await this.#checkAuthorization();
+        if (me) {
+            return {
+                type: "signedIn",
+                userId: me.id,
+            };
+        }
+        while (true) {
+            try {
+                const result = await this.#accountManager.checkBotToken(botToken, this.#apiId, this.#apiHash);
+                if (result.type === "signedIn") {
+                    await this.storage.auth.update((v) => {
+                        v.userId = result.userId;
+                        v.isBot = true;
+                    });
+                    await this.storage.commit(true);
+                    this.#LsignIn.debug("signed in as bot");
+                    await this.#propagateAuthorizationState(true);
+                    await this.#updateManager.fetchState("checkBotToken");
+                }
+                return result;
+            }
+            catch (err) {
+                if (err instanceof Migrate) {
+                    await this[handleMigrationError](err);
+                    continue;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    /**
+     * Signs in using the provided parameters if not already signed in.
+     * If no parameters are provided, the credentials will be prompted in runtime.
+     *
+     * Notes:
+     * 1. Requires the `apiId` and `apiHash` paramters to be passed when constructing the client.
+     * 3. Reconnects the client to the appropriate DC in case of MIGRATE_X errors.
+     */
+    async signIn(params) {
+        await signIn(this, this.#LsignIn, params);
+    }
+    async signOut() {
+        try {
+            await Promise.all([
+                this.storage.reset(),
+                this.invoke({ _: "auth.logOut" }).then(() => {
+                    this.#propagateAuthorizationState(false);
+                }),
+            ]);
+        }
+        finally {
+            this.#lastGetMe = null;
+            this.disconnect();
+            await this.connect();
+        }
+    }
+    /**
+     * Same as calling `.connect()` followed by `.signIn(params)`.
+     */
+    async start(params) {
+        await this.connect();
+        await this.signIn(params);
+    }
+    async #getClient(params) {
+        let client;
+        switch (params.type) {
+            case undefined:
+                client = await this.#getMainClient(params.dc);
+                break;
+            case "download":
+                client = await this.#getDownloadClient(params.dc);
+                break;
+            case "upload":
+                client = await this.#getUploadClient();
+                break;
+        }
+        if (client !== this.#client && !this.isDisconnected && client.isDisconnected) {
+            await client.connect();
+        }
+        return client;
+    }
+    #getMainClientMutex = new Mutex();
+    async #getMainClient(dc) {
+        if (dc === undefined || dc === this.#client?.dc) {
+            return this.#client;
+        }
+        let client = this.#clients.find((v) => v.dc === dc);
+        if (client) {
+            return client;
+        }
+        const unlock = await this.#getMainClientMutex.lock();
+        client = this.#clients.find((v) => v.dc === dc);
+        if (client) {
+            return client;
+        }
+        try {
+            client = this.#newClient(dc, false, false);
+            await this.#setupClient(client);
+            this.#clients.push(client);
+            return client;
+        }
+        finally {
+            unlock();
+        }
+    }
+    async #getDownloadClient(dc) {
+        dc ??= this.#client.dc;
+        const pool = this.#downloadPools[dc] ??= new ClientEncryptedPool();
+        if (!pool.size) {
+            if (!pool.size) {
+                for (let i = 0; i < DOWNLOAD_POOL_SIZE; ++i) {
+                    pool.add(this.#newClient(dc, false, true));
+                }
+            }
+        }
+        const client = pool.nextClient();
+        if (client.authKey.length) {
+            return client;
+        }
+        await this.#setupClient(client);
+        return client;
+    }
+    async #getUploadPoolSize() {
+        const dc = this.#client.dc;
+        return (dc !== "2" && dc !== "4") || await this.#getIsPremium() ? 8 : 4;
+    }
+    async #getUploadClient() {
+        const dc = this.#client.dc;
+        const poolSize = await this.#getUploadPoolSize();
+        const pool = this.#uploadPools[dc] ??= new ClientEncryptedPool();
+        if (!pool.size) {
+            for (let i = 0; i < poolSize; ++i) {
+                pool.add(await this.#newClient(dc, false, true));
+            }
+        }
+        const client = pool.nextClient();
+        if (client.authKey.length) {
+            return client;
+        }
+        await this.#setupClient(client);
+        return client;
+    }
+    async #setupClient(client) {
+        const storage = client.dc === this.#client.dc ? this.storage : new StorageOperations(this.storage.provider.branch(client.dc + (client.isCdn ? "_cdn" : "")));
+        await storage.initialize();
+        const auth = storage.auth.mustGet();
+        const serverSalt = await storage.getServerSalt();
+        if (auth.authKey !== null) {
+            await client.setAuthKey(auth.authKey);
+            if (serverSalt) {
+                client.serverSalt = serverSalt;
+            }
+        }
+        await client.connect();
+        if (auth.authKey === null) {
+            await this.#importAuthorization(client);
+        }
+        await storage.auth.update((v) => v.authKey = client.authKey);
+        if (client.dc !== this.#client.dc) {
+            await storage.setServerSalt(client.serverSalt);
+            client.handlers.onNewServerSalt = async (serverSalt) => {
+                await storage.setServerSalt(serverSalt);
+            };
+        }
+    }
+    async #importAuthorization(client) {
+        if (this.#client.dc === client.dc && this.#client.isCdn === client.isCdn) {
+            const auth = this.storage.auth.mustGet();
+            const serverSalt = await this.storage.getServerSalt();
+            if (auth.authKey !== null) {
+                await client.setAuthKey(auth.authKey);
+                if (serverSalt) {
+                    client.serverSalt = serverSalt;
+                }
+            }
+            return;
+        }
+        const exportedAuthorization = await this.#client.invoke({ _: "auth.exportAuthorization", dc_id: getDcId(client.dc, client.isCdn) });
+        await client.invoke({ ...exportedAuthorization, _: "auth.importAuthorization" });
+    }
+    async #invoke(function_, params) {
+        if (!this.#client) {
+            throw new ConnectionError("The connection is not open.");
+        }
+        let n = 1;
+        let client;
+        while (true) {
+            client = params ? await this.#getClient(params) : this.#client;
+            const main = client === this.#client;
+            try {
+                const result = await client.invoke(function_);
+                if (main) {
+                    try {
+                        await this.#updateManager.processResult(result);
+                    }
+                    catch (err) {
+                        this.#L.error("failed to process result:", err);
+                    }
+                    if (Api.isOfEnum("Update", result) || Api.isOfEnum("Updates", result)) {
+                        return new Promise((resolve) => {
+                            this.#updateManager.processUpdates(result, true, Mtproto.is("ping", function_) ? null : function_, () => resolve(result));
+                        });
+                    }
+                }
+                return result;
+            }
+            catch (err) {
+                if (err instanceof AuthKeyUnregistered && !main) {
+                    await this.#importAuthorization(client);
+                    continue;
+                }
+                else if (err instanceof ConnectionError && !main && !this.isDisconnected) {
+                    continue;
+                }
+                else if (await this.#handleInvokeError(Object.freeze({ client: this, error: err, function: function_, n: n++ }), () => Promise.resolve(false))) {
+                    continue;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+    }
+    #handleInvokeError = skipInvoke();
+    /**
+     * Invokes a function waiting and returning its reply.
+     * Requires the client to be connected.
+     *
+     * @param function_ The function to invoke.
+     */
+    invoke = Object.assign(this.#invoke, {
+        use: (handler) => {
+            const handle = this.#handleInvokeError;
+            this.#handleInvokeError = async (ctx, next) => {
+                let result = null;
+                return await handle(ctx, async () => {
+                    if (result !== null)
+                        return result;
+                    result = await handler(ctx, next);
+                    return result;
+                });
+            };
+        },
+    });
+    exportAuthString() {
+        return this.storage.exportAuthString(this.#apiId);
+    }
+    #authStringImported = false;
+    async importAuthString(authString) {
+        if (this.isConnected) {
+            throw new Error("Cannot import auth string while the client is connected");
+        }
+        await this.#initStorage();
+        await this.storage.importAuthString(authString);
+        this.#authStringImported = true;
+        if (!this.#apiId) {
+            this.#apiId = this.storage.auth.mustGet().apiId;
+        }
+    }
+    async #getUserAccessHash(userId) {
+        const users = await this.invoke({ _: "users.getUsers", id: [{ _: "inputUser", user_id: userId, access_hash: 0n }] });
+        const user = Api.is("user", users[0]) ? users[0] : undefined;
+        return user?.access_hash ?? 0n;
+    }
+    async #getChannelAccessHash(channelId) {
+        const channels = await this.invoke({ _: "channels.getChannels", id: [{ _: "inputChannel", channel_id: channelId, access_hash: 0n }] });
+        const channel = Api.is("channel", channels.chats[0]) ? channels.chats[0] : undefined;
+        return channel?.access_hash ?? 0n;
+    }
+    /**
+     * Get a chat's inputPeer. Useful when calling API functions directly.
+     *
+     * @param id The identifier of a chat.
+     */
+    async getInputPeer(id) {
+        if (id === "me" || id === await this.#getSelfId()) {
+            return { _: "inputPeerSelf" };
+        }
+        const inputPeer = await this.#getInputPeerInner(id);
+        if (((Api.is("inputPeerUser", inputPeer) || Api.is("inputPeerChannel", inputPeer)) && inputPeer.access_hash === 0n) && this.storage.isBot) {
+            if ("channel_id" in inputPeer) {
+                inputPeer.access_hash = await this.#getChannelAccessHash(inputPeer.channel_id);
+            }
+            else {
+                inputPeer.access_hash = await this.#getUserAccessHash(inputPeer.user_id);
+            }
+        }
+        if ((Api.is("inputPeerUser", inputPeer) || Api.is("inputPeerChannel", inputPeer)) && inputPeer.access_hash === 0n) {
+            throw new AccessError(`The chat ${id} cannot be accessed.`);
+        }
+        return inputPeer;
+    }
+    async #getInputPeerChatId(inputPeer) {
+        if (Api.isOneOf(["inputPeerSelf", "inputUserSelf"], inputPeer)) {
+            return await this.#getSelfId();
+        }
+        else if (Api.isOneOf(["inputPeerEmpty", "inputUserEmpty", "inputChannelEmpty"], inputPeer)) {
+            unreachable();
+        }
+        else {
+            return Api.peerToChatId(inputPeer);
+        }
+    }
+    /**
+     * Get a channel or a supergroup's inputChannel. Useful when calling API functions directly.
+     *
+     * @param id The identifier of the channel or the supergroup.
+     */
+    async getInputChannel(id) {
+        const inputPeer = await this.getInputPeer(id);
+        if (!canBeInputChannel(inputPeer)) {
+            throw new TypeError(`The chat ${id} is not a channel neither a supergroup.`);
+        }
+        return toInputChannel(inputPeer);
+    }
+    /**
+     * Get a user's inputUser. Useful when calling API functions directly.
+     *
+     * @param id The identifier of the user.
+     */
+    async getInputUser(id) {
+        const inputPeer = await this.getInputPeer(id);
+        if (!canBeInputUser(inputPeer)) {
+            throw new TypeError(`The chat ${id} is not a private chat.`);
+        }
+        return toInputUser(inputPeer);
+    }
+    async #getInputPeerInner(id) {
+        const idn = Number(id);
+        if (!isNaN(idn)) {
+            id = idn;
+        }
+        let peer;
+        if (typeof id === "string") {
+            id = getUsername(id);
+            let resolvedId = 0;
+            const maybeUsername = await this.messageStorage.usernames.get([id]);
+            if (maybeUsername !== null && Date.now() - maybeUsername[1].getTime() < USERNAME_TTL) {
+                const [id] = maybeUsername;
+                resolvedId = id;
+            }
+            else {
+                const resolved = await this.invoke({ _: "contacts.resolveUsername", username: id });
+                this.#updateManager.processChats(resolved.chats, resolved);
+                this.#updateManager.processUsers(resolved.users, resolved);
+                if (Api.is("peerUser", resolved.peer)) {
+                    resolvedId = Api.peerToChatId(resolved.peer);
+                }
+                else if (Api.is("peerChannel", resolved.peer)) {
+                    resolvedId = Api.peerToChatId(resolved.peer);
+                }
+                else {
+                    unreachable();
+                }
+            }
+            const resolvedIdType = Api.getChatIdPeerType(resolvedId);
+            if (resolvedIdType === "user") {
+                const accessHash = await this.messageStorage.getUserAccessHash(resolvedId);
+                peer = { _: "inputPeerUser", user_id: Api.chatIdToPeerId(resolvedId), access_hash: accessHash ?? 0n };
+            }
+            else if (resolvedIdType === "channel") {
+                const accessHash = await this.messageStorage.getChannelAccessHash(resolvedId);
+                peer = { _: "inputPeerChannel", channel_id: Api.chatIdToPeerId(resolvedId), access_hash: accessHash ?? 0n };
+            }
+            else {
+                unreachable();
+            }
+        }
+        else if (id > 0) {
+            const accessHash = await this.messageStorage.getUserAccessHash(id);
+            peer = { _: "inputPeerUser", user_id: Api.chatIdToPeerId(id), access_hash: accessHash ?? 0n };
+        }
+        else if (-MAX_CHAT_ID <= id) {
+            peer = { _: "inputPeerChat", chat_id: BigInt(Math.abs(id)) };
+        }
+        else if (ZERO_CHANNEL_ID - MAX_CHANNEL_ID <= id && id !== ZERO_CHANNEL_ID) {
+            const accessHash = await this.messageStorage.getChannelAccessHash(id);
+            peer = { _: "inputPeerChannel", channel_id: Api.chatIdToPeerId(id), access_hash: accessHash ?? 0n };
+        }
+        else {
+            throw new InputError("The ID is of an format unknown.");
+        }
+        if (!Api.is("inputPeerChat", peer) && !peer.access_hash) {
+            // TODO
+            // const chatId = Api.peerToChatId(peer);
+            // const minPeerReference = await this.messageStorage.getLastMinPeerReference(chatId);
+            // if (minPeerReference) {
+            //   const minInputPeer = await this.#getMinInputPeer(canBeInputChannel(peer) ? "channel" : "user", { ...minPeerReference, senderId: chatId });
+            //   if (minInputPeer) {
+            //     this.#Lmin.debug("resolved input min peer", minInputPeer);
+            //     peer = minInputPeer;
+            //   }
+            // }
+        }
+        return peer;
+    }
+    async #getMinInputPeer(type, reference) {
+        const peer_ = await this.messageStorage.peers.get([reference.chatId]);
+        if (peer_ !== null && (peer_[0].type === "channel" || peer_[0].type === "supergroup")) {
+            const peer = { _: "inputPeerChannel", channel_id: BigInt(peer_[0].id), access_hash: peer_[1] };
+            if (type === "user") {
+                return { _: "inputPeerUserFromMessage", peer, msg_id: reference.messageId, user_id: Api.chatIdToPeerId(reference.senderId) };
+            }
+            else {
+                return { _: "inputPeerChannelFromMessage", peer, msg_id: reference.messageId, channel_id: Api.chatIdToPeerId(reference.senderId) };
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    async [getPeer](peer) {
+        const id = Api.peerToChatId(peer);
+        const entity = await this.messageStorage.peers.get([id]);
+        if (entity === null) {
+            if (entity === null && this.storage.isBot && Api.is("peerUser", peer) || Api.is("peerChannel", peer)) {
+                await this.getInputPeer(id);
+            }
+            else {
+                return entity;
+            }
+        }
+        return await this.messageStorage.peers.get([id]);
+    }
+    [mustGetPeer](peer) {
+        return this.messageStorage.peers.mustGet([peerToChatId(peer)]);
+    }
+    async #handleCtxUpdate(update) {
+        if (this.#disableUpdates && !("authorizationState" in update) && !("connectionState" in update)) {
+            return;
+        }
+        try {
+            await this.handleUpdate(this, update);
+        }
+        catch (err) {
+            this.#L.error("Failed to handle update:", err);
+            throw err;
+        }
+    }
+    #queueHandleCtxUpdate(update) {
+        this.#updateManager.getHandleUpdateQueue(UpdateManager.MAIN_BOX_ID).add(async () => {
+            await this.#handleCtxUpdate(update);
+        });
+    }
+    async #handleUpdate(update) {
+        const maybePromises = new Array();
+        if (Api.is("updateUserName", update)) {
+            const value = [Number(update.user_id), new Date()];
+            for (const username_ of update.usernames) {
+                const username = username_.username.toLowerCase();
+                this.messageStorage.usernames.set([username], value);
+            }
+            const peer = { ...update, _: "peerUser" };
+            const peer_ = await this[getPeer](peer);
+            if (peer_ !== null) {
+                const username = update.usernames[0];
+                if (username !== undefined) {
+                    peer_[0].username = username.username;
+                    const also = update.usernames.filter((v) => v !== username);
+                    if (also.length) {
+                        peer_[0].also = also.map((v) => v.username);
+                    }
+                    else {
+                        delete peer_[0].also;
+                    }
+                }
+                else {
+                    delete peer_[0].username;
+                }
+                this.messageStorage.setPeer2(peer_[0], peer_[1]);
+            }
+        }
+        if (this.#messageManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#messageManager.handleUpdate(update));
+        }
+        if (this.#chatManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#chatManager.handleUpdate(update));
+        }
+        if (this.#pollManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#pollManager.handleUpdate(update));
+        }
+        if (this.#videoChatManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#videoChatManager.handleUpdate(update));
+        }
+        if (this.#callbackQueryManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#callbackQueryManager.handleUpdate(update));
+        }
+        if (this.#inlineQueryManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#inlineQueryManager.handleUpdate(update));
+        }
+        if (this.#linkPreviewManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#linkPreviewManager.handleUpdate(update));
+        }
+        if (this.#reactionManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#reactionManager.handleUpdate(update));
+        }
+        if (this.#chatListManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#chatListManager.handleUpdate(update));
+        }
+        if (this.#storyManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#storyManager.handleUpdate(update));
+        }
+        if (this.#businessConnectionManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#businessConnectionManager.handleUpdate(update));
+        }
+        if (this.#storyManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#storyManager.handleUpdate(update));
+        }
+        if (this.#paymentManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#paymentManager.handleUpdate(update));
+        }
+        if (this.#translationsManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#translationsManager.handleUpdate(update));
+        }
+        if (this.#botInfoManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#botInfoManager.handleUpdate(update));
+        }
+        if (this.#accountManager.canHandleUpdate(update)) {
+            maybePromises.push(() => this.#accountManager.handleUpdate(update));
+        }
+        return () => Promise.resolve().then(async () => {
+            const updates = [{ update }];
+            for (const maybePromise of maybePromises) {
+                try {
+                    const value = maybePromise();
+                    const update = value instanceof Promise ? await value : value;
+                    if (update) {
+                        updates.push(update);
+                    }
+                }
+                catch (err) {
+                    this.#L.error("failed to construct update:", err);
+                }
+            }
+            for (const update of updates) {
+                try {
+                    await this.#handleCtxUpdate(update);
+                }
+                finally {
+                    if ("deletedMessages" in update) {
+                        for (const { chatId, messageId } of update.deletedMessages) {
+                            await this.messageStorage.setMessage(chatId, messageId, null);
+                        }
+                    }
+                }
+            }
+        });
+    }
+    #lastGetMe = null;
+    async #getMe() {
+        if (this.#lastGetMe !== null) {
+            return this.#lastGetMe;
+        }
+        else {
+            const user = await this.#getMeInner();
+            this.#lastGetMe = user;
+            return user;
+        }
+    }
+    async #getMeInner() {
+        let chatP = (await this[getPeer]({ _: "peerUser", user_id: BigInt(await this.#getSelfId()) }))?.[0] ?? null;
+        if (chatP === null) {
+            const users = await this.invoke({ _: "users.getUsers", id: [{ _: "inputUserSelf" }] });
+            chatP = constructChatP(Api.as("user", users[0]));
+            await this.storage.setIsPremium(chatP.isPremium);
+        }
+        const user = constructUser2(chatP);
+        this.#lastGetMe = user;
+        return user;
+    }
+    #previouslyConnected = false;
+    #lastConnectionState = false;
+    #onConnectionStateChange(isConnected) {
+        if (this.#lastConnectionState !== isConnected) {
+            if (isConnected) {
+                if (this.#previouslyConnected) {
+                    drop(this.#updateManager.recoverUpdateGap("reconnect"));
+                }
+                this.#previouslyConnected = true;
+            }
+            const connectionState = isConnected ? "ready" : "notConnected";
+            this.#queueHandleCtxUpdate({ connectionState });
+        }
+    }
+    //
+    // ========================= ACCOUNT ========================= //
+    //
+    /**
+     * Get information on the currently authorized user.
+     *
+     * @method ac
+     * @returns Information on the currently authorized user.
+     */
+    async getMe() {
+        if (this.#lastGetMe === null) {
+            const me = await this.#checkAuthorization();
+            if (!me) {
+                throw new InputError("Not signed in.");
+            }
+            else {
+                return me;
+            }
+        }
+        return await this.#getMeInner();
+    }
+    /**
+     * Show a username in the current account, a bot account, a supergroup, or a channel's profile. User-only.
+     *
+     * @method ac
+     * @param id `"me"`, a bot ID, a supergroup ID, or a channel ID.
+     * @param username The username to show.
+     */
+    async showUsername(id, username) {
+        await this.#accountManager.showUsername(id, username);
+    }
+    /**
+     * Hide a username from the current account, a bot account, a supergroup, or a channel's profile. User-only.
+     *
+     * @method ac
+     * @param id `"me"`, a bot ID, a supergroup ID, or a channel ID.
+     * @param username The username to hide.
+     */
+    async hideUsername(id, username) {
+        await this.#accountManager.hideUsername(id, username);
+    }
+    /**
+     * Check the availability of a username. User-only.
+     *
+     * @method ac
+     * @param username The username to check.
+     * @returns Whether the username is available.
+     */
+    async checkUsername(username, params) {
+        return await this.#accountManager.checkUsername(username, params);
+    }
+    /**
+     * Set the username of the current account. User-only.
+     *
+     * @method ac
+     * @param username The username to set.
+     */
+    async setUsername(username) {
+        await this.#accountManager.setUsername(username);
+    }
+    /**
+     * Remove the current account's username. User-only.
+     *
+     * @method ac
+     */
+    async removeUsername() {
+        await this.#accountManager.removeUsername();
+    }
+    /**
+     * Reorder the usernames of the current account, a bot account, a supergroup, or a channel's profile. User-only.
+     *
+     * @method ac
+     * @param id `"me"`, a bot ID, a supergroup ID, or a channel ID.
+     * @param order The new order to use.
+     * @returns Whether the order was changed.
+     */
+    async reorderUsernames(id, order) {
+        return await this.#accountManager.reorderUsernames(id, order);
+    }
+    /**
+     * Hide all usernames from a supergroup or a channel's profile. User-only.
+     *
+     * @method ac
+     * @param id A supergroup ID or a channel ID.
+     * @returns Whether any username was hidden.
+     */
+    async hideUsernames(id) {
+        return await this.#accountManager.hideUsernames(id);
+    }
+    /**
+     * Get a business connection. Bot-only.
+     *
+     * @method ac
+     * @param id The identifier of the business connection.
+     * @cache
+     */
+    async getBusinessConnection(id) {
+        return await this.#businessConnectionManager.getBusinessConnection(id);
+    }
+    /**
+     * Set the current account's online status. User-only.
+     *
+     * @method ac
+     * @param isOnline The new online status.
+     */
+    async setIsOnline(isOnline) {
+        await this.#accountManager.setIsOnline(isOnline);
+    }
+    /**
+     * Set the current account's emoji status. User-only.
+     *
+     * @method ac
+     * @param emojiStatus The emoji or gift to set as the new emoji status.
+     */
+    async setEmojiStatus(emojiStatus, params) {
+        await this.#accountManager.setEmojiStatus(emojiStatus, params);
+    }
+    /**
+     * Remove the current account's emoji status. User-only.
+     *
+     * @method ac
+     */
+    async removeEmojiStatus() {
+        await this.#accountManager.removeEmojiStatus();
+    }
+    /**
+     * Set the emoji status of a channel. User-only.
+     *
+     * @method ac
+     * @param chatId The identifier of a channel.
+     * @param emojiStatus The emoji or gift to set as the new emoji status.
+     */
+    async setChannelEmojiStatus(chatId, emojiStatus, params) {
+        await this.#accountManager.setChannelEmojiStatus(chatId, emojiStatus, params);
+    }
+    /**
+     * Remove the emoji status of a channel. User-only.
+     *
+     * @method ac
+     * @param chatId The identifier of a channel.
+     */
+    async removeChannelEmojiStatus(chatId) {
+        await this.#accountManager.removeChannelEmojiStatus(chatId);
+    }
+    /**
+     * Set the emoji status of a bot's user. Bot-only.
+     *
+     * @method ac
+     * @param userId The identifier of a user of the bot.
+     * @param emojiStatus The emoji or gift to set as the new emoji status.
+     */
+    async setUserEmojiStatus(userId, emojiStatus, params) {
+        await this.#accountManager.setUserEmojiStatus(userId, emojiStatus, params);
+    }
+    /**
+     * Remove the emoji status of a bot's user. Bot-only.
+     *
+     * @method ac
+     * @param userId The identifier of a user of the bot.
+     */
+    async removeUserEmojiStatus(userId) {
+        await this.#accountManager.removeUserEmojiStatus(userId);
+    }
+    /**
+     * Update the profile of the current user. At least one parameter must be specified. User-only.
+     *
+     * @method ac
+     */
+    async updateProfile(params) {
+        await this.#accountManager.updateProfile(params);
+    }
+    /**
+     * Set the birthday of the current user. User-only.
+     *
+     * @method ac
+     */
+    async setBirthday(params) {
+        await this.#accountManager.setBirthday(params);
+    }
+    /**
+     * Set the personal channel of the current user. User-only.
+     *
+     * @method ac
+     */
+    async setPersonalChannel(params) {
+        await this.#accountManager.setPersonalChannel(params);
+    }
+    /**
+     * Set the name color of the current user. User-only.
+     *
+     * @method ac
+     * @param color The identifier of the color to set.
+     */
+    async setNameColor(color, params) {
+        await this.#accountManager.setNameColor(color, params);
+    }
+    /**
+     * Set the profile color of the current user. User-only.
+     *
+     * @method ac
+     * @param color The identifier of the color to set.
+     */
+    async setProfileColor(color, params) {
+        await this.#accountManager.setProfileColor(color, params);
+    }
+    /**
+     * Set the location of the current user. User-only.
+     *
+     * @method ac
+     */
+    async setLocation(params) {
+        await this.#accountManager.setLocation(params);
+    }
+    /**
+     * Set the working hours of the current user. User-only.
+     *
+     * @method ac
+     */
+    async setWorkingHours(params) {
+        await this.#accountManager.setWorkingHours(params);
+    }
+    /**
+     * Enable sponsored messages on the current user. User-only.
+     *
+     * @method ac
+     */
+    async enableSponsoredMessages() {
+        await this.#accountManager.enableSponsoredMessages();
+    }
+    /**
+     * Disable sponsored messages on the current user. User-only.
+     *
+     * @method ac
+     */
+    async disableSponsoredMessages() {
+        await this.#accountManager.disableSponsoredMessages();
+    }
+    /**
+     * Pause the business bot in a chat. User-only.
+     *
+     * @method ac
+     */
+    async pauseBusinessBotConnection(chatId) {
+        await this.#accountManager.pauseBusinessBotConnection(chatId);
+    }
+    /**
+     * Resume the business bot in a chat. User-only.
+     *
+     * @method ac
+     */
+    async resumeBusinessBotConnection(chatId) {
+        await this.#accountManager.resumeBusinessBotConnection(chatId);
+    }
+    //
+    // ========================= MESSAGES ========================= //
+    //
+    /**
+     * Send a text message.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the message to.
+     * @param text The message's text.
+     * @returns The sent text message.
+     */
+    async sendMessage(chatId, text, params) {
+        return await this.#messageManager.sendMessage(chatId, text, params);
+    }
+    /**
+     * Stream a drafted text message. Bot-only.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the message to.
+     * @param draftId The identifier of the draft.
+     * @param text The message's text.
+     */
+    async sendMessageDraft(chatId, draftId, text, params) {
+        await this.#messageManager.sendMessageDraft(chatId, draftId, text, params);
+    }
+    /**
+     * Send a photo.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the photo to.
+     * @param photo The photo to send.
+     * @returns The sent photo.
+     */
+    async sendPhoto(chatId, photo, params) {
+        return await this.#messageManager.sendPhoto(chatId, photo, params);
+    }
+    /**
+     * Send a document.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the document to.
+     * @param document The document to send.
+     * @returns The sent document.
+     */
+    async sendDocument(chatId, document, params) {
+        return await this.#messageManager.sendDocument(chatId, document, params);
+    }
+    /**
+     * Send a sticker.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the sticker to.
+     * @param document The sticker to send.
+     * @returns The sent sticker.
+     */
+    async sendSticker(chatId, sticker, params) {
+        return await this.#messageManager.sendSticker(chatId, sticker, params);
+    }
+    /**
+     * Send a video.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the video to.
+     * @param video The video to send.
+     * @returns The sent video.
+     */
+    async sendVideo(chatId, video, params) {
+        return await this.#messageManager.sendVideo(chatId, video, params);
+    }
+    /**
+     * Send an animation.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the animation to.
+     * @param animation The animation to send.
+     * @returns The sent animation.
+     */
+    async sendAnimation(chatId, animation, params) {
+        return await this.#messageManager.sendAnimation(chatId, animation, params);
+    }
+    /**
+     * Send a voice message.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the voice message to.
+     * @param voice The voice to send.
+     * @returns The sent voice message.
+     */
+    async sendVoice(chatId, voice, params) {
+        return await this.#messageManager.sendVoice(chatId, voice, params);
+    }
+    /**
+     * Send an audio file.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the audio file to.
+     * @param audio The audio to send.
+     * @returns The sent audio filr.
+     */
+    async sendAudio(chatId, audio, params) {
+        return await this.#messageManager.sendAudio(chatId, audio, params);
+    }
+    /**
+     * Send a media group.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the media group to.
+     * @param media The media to include in the media group. Animations are not allowed. All of them must be of the same media type, but an exception is that photos and videos can be mixed.
+     * @returns The sent messages.
+     */
+    async sendMediaGroup(chatId, media, params) {
+        return await this.#messageManager.sendMediaGroup(chatId, media, params);
+    }
+    /**
+     * Send a video note.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the video note to.
+     * @param videoNote The video note to send.
+     * @returns The sent video note.
+     */
+    async sendVideoNote(chatId, videoNote, params) {
+        return await this.#messageManager.sendVideoNote(chatId, videoNote, params);
+    }
+    /**
+     * Send a location.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the location to.
+     * @param latitude The location's latitude.
+     * @param longitude The location's longitude.
+     * @returns The sent location.
+     */
+    async sendLocation(chatId, latitude, longitude, params) {
+        return await this.#messageManager.sendLocation(chatId, latitude, longitude, params);
+    }
+    /**
+     * Send a contact.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the contact to.
+     * @param firstName The contact's first name.
+     * @param number The contact's phone number.
+     * @returns The sent contact.
+     */
+    async sendContact(chatId, firstName, number, params) {
+        return await this.#messageManager.sendContact(chatId, firstName, number, params);
+    }
+    /**
+     * Send a dice.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the dice to.
+     * @returns The sent dice.
+     */
+    async sendDice(chatId, params) {
+        return await this.#messageManager.sendDice(chatId, params);
+    }
+    /**
+     * Send a venue.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the venue to.
+     * @param latitude The latitude of the venue.
+     * @param longitude The longitude of the venue.
+     * @param title The title of the venue.
+     * @param address The written address of the venue.
+     * @returns The sent venue.
+     */
+    async sendVenue(chatId, latitude, longitude, title, address, params) {
+        return await this.#messageManager.sendVenue(chatId, latitude, longitude, title, address, params);
+    }
+    /**
+     * Send a poll.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the poll to.
+     * @param question The poll's question.
+     * @param options The poll's options.
+     * @returns The sent poll.
+     */
+    async sendPoll(chatId, question, options, params) {
+        return await this.#messageManager.sendPoll(chatId, question, options, params);
+    }
+    /**
+     * Send a checklist. User-only.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the checklist to.
+     * @param title The checklist's title.
+     * @param items The checklist's items.
+     * @returns The sent checklist.
+     */
+    async sendChecklist(chatId, title, items, params) {
+        return await this.#messageManager.sendChecklist(chatId, title, items, params);
+    }
+    /**
+     * Send an invoice. Bot-only.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the invoice to.
+     * @param title The invoice's title.
+     * @param description The invoice's description.
+     * @param payload The invoice's payload.
+     * @param currency The invoice's currency.
+     * @param prices The invoice's price tags.
+     * @returns The sent invoice.
+     */
+    async sendInvoice(chatId, title, description, payload, currency, prices, params) {
+        return await this.#messageManager.sendInvoice(chatId, title, description, payload, currency, prices, params);
+    }
+    /**
+     * Edit a message's text.
+     *
+     * @method ms
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message.
+     * @param text The new text of the message.
+     * @returns The edited text message.
+     */
+    async editMessageText(chatId, messageId, text, params) {
+        return await this.#messageManager.editMessageText(chatId, messageId, text, params);
+    }
+    /**
+     * Edit a message's caption.
+     *
+     * @method ms
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message.
+     * @param text The new caption of the message.
+     * @returns The edited message.
+     */
+    async editMessageCaption(chatId, messageId, params) {
+        return await this.#messageManager.editMessageCaption(chatId, messageId, params);
+    }
+    /**
+     * Edit a message's media.
+     *
+     * @method ms
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message.
+     * @param media The new media of the message.
+     * @returns The edited message.
+     */
+    async editMessageMedia(chatId, messageId, media, params) {
+        return await this.#messageManager.editMessageMedia(chatId, messageId, media, params);
+    }
+    /**
+     * Edit an inline message's media.
+     *
+     * @method ms
+     * @param inlineMessageId The identifier of the inline message.
+     * @param media The new media of the message.
+     */
+    async editInlineMessageMedia(inlineMessageId, media, params) {
+        await this.#messageManager.editInlineMessageMedia(inlineMessageId, media, params);
+    }
+    /**
+     * Edit an inline message's text. Bot-only.
+     *
+     * @method ms
+     * @param inlineMessageId The identifier of the inline message.
+     * @param text The new text of the message.
+     */
+    async editInlineMessageText(inlineMessageId, text, params) {
+        await this.#messageManager.editInlineMessageText(inlineMessageId, text, params);
+    }
+    /**
+     * Edit an inline message's caption. Bot-only.
+     *
+     * @method ms
+     * @param inlineMessageId The identifier of the inline message.
+     */
+    async editInlineMessageCaption(inlineMessageId, params) {
+        await this.#messageManager.editInlineMessageCaption(inlineMessageId, params);
+    }
+    /**
+     * Edit a message's reply markup.
+     *
+     * @method ms
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message.
+     * @returns The edited message.
+     */
+    async editMessageReplyMarkup(chatId, messageId, params) {
+        return await this.#messageManager.editMessageReplyMarkup(chatId, messageId, params);
+    }
+    /**
+     * Edit an inline message's reply markup. Bot-only.
+     *
+     * @method ms
+     * @param inlineMessageId The identifier of the inline message.
+     */
+    async editInlineMessageReplyMarkup(inlineMessageId, params) {
+        await this.#messageManager.editInlineMessageReplyMarkup(inlineMessageId, params);
+    }
+    /**
+     * Edit a message's live location.
+     *
+     * @method ms
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message.
+     * @param latitude The new latitude.
+     * @param longitude The new longitude.
+     * @returns The edited location message.
+     */
+    async editMessageLiveLocation(chatId, messageId, latitude, longitude, params) {
+        return await this.#messageManager.editMessageLiveLocation(chatId, messageId, latitude, longitude, params);
+    }
+    /**
+     * Edit an inline message's live location. Bot-only.
+     *
+     * @method ms
+     * @param inlineMessageId The identifier of the inline message.
+     * @param latitude The new latitude.
+     * @param longitude The new longitude.
+     * @returns The edited location message.
+     */
+    async editInlineMessageLiveLocation(inlineMessageId, latitude, longitude, params) {
+        await this.#messageManager.editInlineMessageLiveLocation(inlineMessageId, latitude, longitude, params);
+    }
+    /**
+     * Retrieve multiple messages.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to retrieve the messages from.
+     * @param messageIds The identifiers of the messages to retrieve.
+     * @example ```ts
+     * const message = await client.getMessages("@MTKruto", [210, 212]);
+     * ```
+     * @returns The retrieved messages.
+     * @cache
+     */
+    async getMessages(chatId, messageIds) {
+        return await this.#messageManager.getMessages(chatId, messageIds);
+    }
+    /**
+     * Retrieve a single message.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the message to retrieve.
+     * @example ```ts
+     * const message = await client.getMessage("@MTKruto", 212);
+     * ```
+     * @returns The retrieved message.
+     * @cache
+     */
+    async getMessage(chatId, messageId) {
+        return await this.#messageManager.getMessage(chatId, messageId);
+    }
+    /**
+     * Retrieve a message using its link.
+     *
+     * @method ms
+     * @param link A message link.
+     * @example ```ts
+     * const message = await client.resolveMessageLink("https://t.me/MTKruto/212");
+     * ```
+     * @returns The message that was linked to.
+     */
+    async resolveMessageLink(link) {
+        return await this.#messageManager.resolveMessageLink(link);
+    }
+    /**
+     * Delete multiple messages.
+     *
+     * @method ms
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageIds The identifiers of the messages to delete.
+     */
+    async deleteMessages(chatId, messageIds, params) {
+        await this.#messageManager.deleteMessages(chatId, messageIds, params);
+    }
+    /**
+     * Delete a single message.
+     *
+     * @method ms
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message to delete.
+     */
+    async deleteMessage(chatId, messageId, params) {
+        await this.#messageManager.deleteMessages(chatId, [messageId], params);
+    }
+    /**
+     * Delete all messages sent by a specific member of a chat. User-only.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat. Must be a supergroup.
+     * @param memberId The identifier of the member.
+     */
+    async deleteChatMemberMessages(chatId, memberId) {
+        await this.#messageManager.deleteChatMemberMessages(chatId, memberId);
+    }
+    /**
+     * Delete multiple scheduled messages.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat.
+     * @param messageIds The identifiers of the scheduled messages to delete.
+     */
+    async deleteScheduledMessages(chatId, messageIds) {
+        await this.#messageManager.deleteScheduledMessages(chatId, messageIds);
+    }
+    /**
+     * Delete a scheduled message.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the scheduled message to delete.
+     */
+    async deleteScheduledMessage(chatId, messageId) {
+        await this.#messageManager.deleteScheduledMessage(chatId, messageId);
+    }
+    /**
+     * Send multiple scheduled messages before their schedule.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat.
+     * @param messageIds The identifiers of the scheduled messages to send.
+     */
+    async sendScheduledMessages(chatId, messageIds) {
+        return await this.#messageManager.sendScheduledMessages(chatId, messageIds);
+    }
+    /**
+     * Send a scheduled message before its schedule.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the scheduled message to send.
+     */
+    async sendScheduledMessage(chatId, messageId) {
+        return await this.#messageManager.sendScheduledMessage(chatId, messageId);
+    }
+    /**
+     * Pin a message in a chat.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the message.
+     */
+    async pinMessage(chatId, messageId, params) {
+        await this.#messageManager.pinMessage(chatId, messageId, params);
+    }
+    /**
+     * Unpin a pinned message.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the message.
+     */
+    async unpinMessage(chatId, messageId, params) {
+        await this.#messageManager.unpinMessage(chatId, messageId, params);
+    }
+    /**
+     * Unpin all pinned messages.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat.
+     */
+    async unpinMessages(chatId, params) {
+        await this.#messageManager.unpinMessages(chatId, params);
+    }
+    /**
+     * Forward multiple messages.
+     *
+     * @method ms
+     * @param from The identifier of a chat to forward the messages from.
+     * @param to The identifier of a chat to forward the messages to.
+     * @param messageIds The identifiers of the messages to forward.
+     * @returns The forwarded messages.
+     */
+    async forwardMessages(from, to, messageIds, params) {
+        return await this.#messageManager.forwardMessages(from, to, messageIds, params);
+    }
+    /**
+     * Forward a single message.
+     *
+     * @method ms
+     * @param from The identifier of a chat to forward the message from.
+     * @param to The identifier of a chat to forward the message to.
+     * @param messageId The identifier of the message to forward.
+     * @returns The forwarded message.
+     */
+    async forwardMessage(from, to, messageId, params) {
+        return (await this.forwardMessages(from, to, [messageId], params))[0];
+    }
+    /**
+     * Stop a poll.
+     *
+     * @method ms
+     * @param chatId The chat that includes the poll.
+     * @param messageId The idenfifier of the poll's message.
+     * @returns The new state of the poll.
+     */
+    async stopPoll(chatId, messageId, params) {
+        return await this.#messageManager.stopPoll(chatId, messageId, params);
+    }
+    /**
+     * Send a chat action.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat to send the chat action to.
+     * @param action The chat action.
+     * @param messageThreadId The thread to send the chat action to.
+     */
+    async sendChatAction(chatId, action, params) {
+        await this.#messageManager.sendChatAction(chatId, action, params);
+    }
+    /**
+     * Search for messages. User-only.
+     *
+     * @method ms
+     */
+    async searchMessages(params) {
+        return await this.#messageManager.searchMessages(params);
+    }
+    /**
+     * Mark messages as read. User-only.
+     *
+     * @method ms
+     * @param chatId The identifier of the chat which the messages belong to.
+     * @param untilMessageId The identifier of the message that will be marked as read, along with any other unread messages before it.
+     */
+    async readMessages(chatId, untilMessageId) {
+        await this.#messageManager.readMessages(chatId, untilMessageId);
+    }
+    /**
+     * Start a bot. User-only.
+     *
+     * @method ms
+     * @param botId The identifier of the bot to start.
+     * @returns The start message.
+     */
+    async startBot(botId, params) {
+        return await this.#messageManager.startBot(botId, params);
+    }
+    /**
+     * Transcribe a voice message. User-only.
+     *
+     * @method ms
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message.
+     * @cache
+     */
+    async transcribeVoice(chatId, messageId) {
+        return await this.#messageManager.transcribeVoice(chatId, messageId);
+    }
+    /**
+     * Get a sticker set.
+     *
+     * @method ms
+     * @param name The name of the sticker set or its link.
+     */
+    async getStickerSet(name) {
+        return await this.#messageManager.getStickerSet(name);
+    }
+    /*
+     * Get the link preview for a message that is about to be sent. User-only.
+     *
+     * @method ms
+     * @param text The message's text.
+     */
+    async getLinkPreview(text, params) {
+        return await this.#linkPreviewManager.getLinkPreview(text, params);
+    }
+    /**
+     * Open a mini app. User-only.
+     *
+     * @method ms
+     * @param botId The identifier of a bot with the mini app.
+     * @param chatId The identifier of the chat from which the mini app is opened.
+     * @cache
+     */
+    async openMiniApp(botId, chatId, params) {
+        return await this.#messageManager.openMiniApp(botId, chatId, params);
+    }
+    /**
+     * Get a progress ID that can be passed to relevant send* methods to receive upload progress updates for them.
+     *
+     * @method ms
+     * @cache
+     */
+    async getProgressId() {
+        return await this.#fileManager.getProgressId();
+    }
+    /**
+     * Get messages saved from a specific chat.
+     *
+     * @method ms
+     * @param chatId The identifier of a chat.
+     */
+    async getSavedMessages(chatId, params) {
+        return await this.#messageManager.getSavedMessages(chatId, params);
+    }
+    /**
+     * Get a list of saved chats.
+     *
+     * @method ms
+     */
+    async getSavedChats(params) {
+        return await this.#messageManager.getSavedChats(params);
+    }
+    /**
+     * Get a list of reactions made to a message. User-only.
+     *
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the message.
+     * @method ms
+     */
+    async getMessageReactions(chatId, messageId, params) {
+        return await this.#messageManager.getMessageReactions(chatId, messageId, params);
+    }
+    //
+    // ========================= POLLS ========================= //
+    //
+    /**
+     * Cast a vote. User-only.
+     *
+     * @method pl
+     * @param chatId The identifier of the chat that includes the poll.
+     * @param messageId The identifier of the message that includes the poll.
+     * @param optionIndexes The indexes of the options to cast for.
+     */
+    async vote(chatId, messageId, optionIndexes) {
+        await this.#pollManager.vote(chatId, messageId, optionIndexes);
+    }
+    /**
+     * Retract a vote. User-only.
+     *
+     * @method pl
+     * @param chatId The identifier of the chat that includes the poll.
+     * @param messageId The identifier of the message that includes the poll.
+     */
+    async retractVote(chatId, messageId) {
+        await this.#pollManager.retractVote(chatId, messageId);
+    }
+    //
+    // ========================= CHECKLISTS ========================= //
+    //
+    /**
+     * Add items to a checklist. User-only.
+     *
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the checklist message.
+     * @param items The items to add.
+     * @method cl
+     */
+    async addToChecklist(chatId, messageId, items) {
+        await this.#checklistManager.addToChecklist(chatId, messageId, items);
+    }
+    /**
+     * Update a checklist. User-only.
+     *
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the checklist message.
+     * @method cl
+     */
+    async updateChecklist(chatId, messageId, params) {
+        await this.#checklistManager.updateChecklist(chatId, messageId, params);
+    }
+    /**
+     * Check multiple items of a checklist. User-only.
+     *
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the checklist message.
+     * @param items The identifiers of the items to check.
+     * @method cl
+     */
+    async checkChecklistItems(chatId, messageId, items) {
+        await this.#checklistManager.checkChecklistItems(chatId, messageId, items);
+    }
+    /**
+     * Uncheck multiple items of a checklist. User-only.
+     *
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the checklist message.
+     * @param items The identifiers of the items to uncheck.
+     * @method cl
+     */
+    async uncheckChecklistItems(chatId, messageId, items) {
+        await this.#checklistManager.uncheckChecklistItems(chatId, messageId, items);
+    }
+    /**
+     * Check a single item of a checklist. User-only.
+     *
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the checklist message.
+     * @param item The identifier of the item to check.
+     * @method cl
+     */
+    async checkChecklistItem(chatId, messageId, item) {
+        await this.#checklistManager.checkChecklistItem(chatId, messageId, item);
+    }
+    /**
+     * Uncheck a single item of a checklist. User-only.
+     *
+     * @param chatId The identifier of a chat.
+     * @param messageId The identifier of the checklist message.
+     * @param item The identifier of the item to uncheck.
+     * @method cl
+     */
+    async uncheckChecklistItem(chatId, messageId, item) {
+        await this.#checklistManager.uncheckChecklistItem(chatId, messageId, item);
+    }
+    //
+    // ========================= FILES ========================= //
+    //
+    /**
+     * Download a chunk of a file.
+     *
+     * @method fs
+     * @param fileId The identifier of a file.
+     * @example ```ts
+     * const chunk = await client.downloadChunk(fileId, { chunkSize: 256 * 1024 });
+     * ```
+     * @returns The downloaded chunk.
+     * @cache file
+     */
+    async downloadChunk(fileId, params) {
+        const controller = new AbortController();
+        for await (const chunk of this.#fileManager.download(fileId, { ...params, signal: controller.signal })) {
+            controller.abort();
+            return chunk;
+        }
+        unreachable();
+    }
+    /**
+     * Download a file.
+     *
+     * @method fs
+     * @param fileId The identifier of the file to download.
+     * @example ```ts
+     * for await (const chunk of client.download(fileId, { chunkSize: 256 * 1024 })) {
+     *   await outFile.write(chunk);
+     * }
+     * ```
+     * @returns A generator yielding the contents of the file.
+     * @cache file
+     */
+    async *download(fileId, params) {
+        for await (const chunk of this.#fileManager.download(fileId, params)) {
+            yield chunk;
+        }
+    }
+    /**
+     * Get custom emoji documents for download.
+     *
+     * @method fs
+     * @param id Identifier of one or more of custom emojis.
+     * @returns The custom emoji documents.
+     * @cache
+     */
+    async getCustomEmojiStickers(id) {
+        return await this.#fileManager.getCustomEmojiStickers(id);
+    }
+    //
+    // ========================= CHATS ========================= //
+    //
+    /**
+     * Get chats from a chat list. User-only.
+     *
+     * @method ch
+     */
+    async getChats(params) {
+        return await this.#chatListManager.getChats(params?.from, params?.after, params?.limit);
+    }
+    /**
+     * Get pinned chats from a chat list. User-only.
+     *
+     * @method ch
+     * @param from The chat list to get the pinned chats from. Defaults to main.
+     */
+    async getPinnedChats(from) {
+        return await this.#chatListManager.getPinnedChats(from);
+    }
+    /**
+     * Get a chat.
+     *
+     * @method ch
+     * @cache
+     */
+    async getChat(chatId) {
+        return await this.#chatListManager.getChat(chatId);
+    }
+    /**
+     * Get chat history. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async getHistory(chatId, params) {
+        return await this.#messageManager.getHistory(chatId, params);
+    }
+    /**
+     * Set a chat's available reactions. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param availableReactions The new available reactions.
+     */
+    async setAvailableReactions(chatId, availableReactions) {
+        await this.#chatManager.setAvailableReactions(chatId, availableReactions);
+    }
+    /**
+     * Set a chat's photo.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param photo A photo to set as the chat's photo.
+     */
+    async setChatPhoto(chatId, photo, params) {
+        await this.#chatManager.setChatPhoto(chatId, photo, params);
+    }
+    /**
+     * Delete a chat's photo.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async deleteChatPhoto(chatId) {
+        await this.#chatManager.deleteChatPhoto(chatId);
+    }
+    /**
+     * Ban a member from a chat.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param memberId The identifier of the member.
+     */
+    async banChatMember(chatId, memberId, params) {
+        await this.#chatManager.banChatMember(chatId, memberId, params);
+    }
+    /**
+     * Unban a member from a chat.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat. Must be a supergroup.
+     * @param memberId The identifier of the member.
+     */
+    async unbanChatMember(chatId, memberId) {
+        await this.#chatManager.unbanChatMember(chatId, memberId);
+    }
+    /**
+     * Kick a member from a chat. Same as a banChatMember call followed by unbanChatMember.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat. Must be a supergroup.
+     * @param memberId The identifier of the member.
+     */
+    async kickChatMember(chatId, memberId) {
+        await this.#chatManager.banChatMember(chatId, memberId);
+        await this.#chatManager.unbanChatMember(chatId, memberId);
+    }
+    /**
+     * Set the rights of a chat member.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat. Must be a supergroup.
+     * @param memberId The identifier of the member.
+     */
+    async setChatMemberRights(chatId, memberId, params) {
+        await this.#chatManager.setChatMemberRights(chatId, memberId, params);
+    }
+    /**
+     * Get the administrators of a chat.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @returns The chat's administrators.
+     */
+    async getChatAdministrators(chatId) {
+        return await this.#chatListManager.getChatAdministrators(chatId);
+    }
+    /**
+     * Enable join requests in a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat. Must be a channel or a supergroup.
+     */
+    async enableJoinRequests(chatId) {
+        await this.#chatManager.enableJoinRequests(chatId);
+    }
+    /**
+     * Disable join requests in a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat. Must be a channel or a supergroup.
+     */
+    async disableJoinRequests(chatId) {
+        await this.#chatManager.disableJoinRequests(chatId);
+    }
+    /**
+     * Get inactive chats. User-only.
+     *
+     * @method ch
+     * @retuns A list of inactive chats the current user is member of.
+     */
+    async getInactiveChats() {
+        return await this.#accountManager.getInactiveChats();
+    }
+    /**
+     * Get the invite links created for a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @returns The invite links created for the chat. This might be a subset of the results if they were less than `limit`. The parameters `afterDate` and `afterInviteLink` can be used for pagination.
+     */
+    async getCreatedInviteLinks(chatId, params) {
+        return await this.#chatManager.getCreatedInviteLinks(chatId, params);
+    }
+    /**
+     * Join a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async joinChat(chatId) {
+        await this.#chatManager.joinChat(chatId);
+    }
+    /**
+     * Leave a chat.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async leaveChat(chatId) {
+        await this.#chatManager.leaveChat(chatId);
+    }
+    /**
+     * Get information on a user's chat membership.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param userId The identifier of the user.
+     */
+    async getChatMember(chatId, userId) {
+        return await this.#chatListManager.getChatMember(chatId, userId);
+    }
+    /**
+     * Get the members of a chat.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async getChatMembers(chatId, params) {
+        return await this.#chatListManager.getChatMembers(chatId, params);
+    }
+    /**
+     * Set a chat's sticker set.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat. Must be a supergroup.
+     * @param setName The name of the set.
+     */
+    async setChatStickerSet(chatId, setName) {
+        await this.#messageManager.setChatStickerSet(chatId, setName);
+    }
+    /**
+     * Delete a chat's sticker set.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat. Must be a supergroup.
+     */
+    async deleteChatStickerSet(chatId) {
+        await this.#messageManager.deleteChatStickerSet(chatId);
+    }
+    /**
+     * Set the number of boosts required to circument a chat's default restrictions. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param boosts The number of boosts required to circumvent its restrictions.
+     */
+    async setBoostsRequiredToCircumventRestrictions(chatId, boosts) {
+        await this.#chatManager.setBoostsRequiredToCircumventRestrictions(chatId, boosts);
+    }
+    /**
+     * Create an invite link.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat to create the invite link for.
+     * @returns The newly created invite link.
+     */
+    async createInviteLink(chatId, params) {
+        return await this.#chatManager.createInviteLink(chatId, params);
+    }
+    /**
+     * Approve a join request.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat with the join request.
+     * @param userId The user who made the join request.
+     */
+    async approveJoinRequest(chatId, userId) {
+        await this.#chatManager.approveJoinRequest(chatId, userId);
+    }
+    /**
+     * Decline a join request.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat with the join request.
+     * @param userId The user who made the join request.
+     */
+    async declineJoinRequest(chatId, userId) {
+        await this.#chatManager.declineJoinRequest(chatId, userId);
+    }
+    /**
+     * Approve all join requests. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat with the join requests.
+     */
+    async approveJoinRequests(chatId, params) {
+        await this.#chatManager.approveJoinRequests(chatId, params);
+    }
+    /**
+     * Decline all join requests. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat with the join requests.
+     */
+    async declineJoinRequests(chatId, params) {
+        await this.#chatManager.declineJoinRequests(chatId, params);
+    }
+    /**
+     * Get pending join requests in a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat with the join requests.
+     */
+    async getJoinRequests(chatId, params) {
+        return await this.#chatManager.getJoinRequests(chatId, params);
+    }
+    /**
+     * Add a single user to a chat.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat to add the user to.
+     * @param userId The identifier of the user to add to the chat.
+     * @returns An array of FailedInvitation that has at most a length of 1. If empty, it means that the user was added.
+     */
+    async addChatMember(chatId, userId, params) {
+        return await this.#chatManager.addChatMember(chatId, userId, params);
+    }
+    /**
+     * Add multiple users at once to a channel or a supergroup.
+     *
+     * @method ch
+     * @param chatId The identifier of the channel or supergroup to add the users to.
+     * @param userId The identifiers of the users to add to the channel or supergroup.
+     * @returns An array of FailedInvitation that has at most a length that is the same as that of the parameter userIds. If empty, it means that all the provided users were added.
+     */
+    async addChatMembers(chatId, userIds) {
+        return await this.#chatManager.addChatMembers(chatId, userIds);
+    }
+    /**
+     * Open a chat.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat to open.
+     */
+    async openChat(chatId, params) {
+        await this.#updateManager.openChat(chatId, params);
+    }
+    /**
+     * Close a chat previously opened by openChat.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat to close.
+     */
+    async closeChat(chatId) {
+        await this.#updateManager.closeChat(chatId);
+    }
+    /**
+     * Create a group. User-only.
+     *
+     * @method ch
+     * @param title The title of the group.
+     * @returns The created group.
+     */
+    async createGroup(title, params) {
+        return await this.#chatListManager.createGroup(title, params);
+    }
+    /**
+     * Create a supergroup. User-only.
+     *
+     * @method ch
+     * @param title The title of the supergroup.
+     * @returns The created supergroup.
+     */
+    async createSupergroup(title, params) {
+        return await this.#chatListManager.createSupergroup(title, params);
+    }
+    /**
+     * Create a channel. User-only.
+     *
+     * @method ch
+     * @param title The title of the channel.
+     * @returns The created channel.
+     */
+    async createChannel(title, params) {
+        return await this.#chatListManager.createChannel(title, params);
+    }
+    /**
+     * Set the time to live of the messages of a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param messageTtl The time to live of the messages in seconds.
+     */
+    async setMessageTtl(chatId, messageTtl) {
+        await this.#chatListManager.setMessageTtl(chatId, messageTtl);
+    }
+    /**
+     * Archive multiple chats. User-only.
+     *
+     * @method ch
+     * @param chatIds The identifiers of the chats to archive.
+     */
+    async archiveChats(chatIds) {
+        await this.#chatListManager.archiveChats(chatIds);
+    }
+    /**
+     * Archive a single chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async archiveChat(chatId) {
+        await this.#chatListManager.archiveChat(chatId);
+    }
+    /**
+     * Unarchive multiple chats. User-only.
+     *
+     * @method ch
+     * @param chatIds The identifiers of the chats to unarchive.
+     */
+    async unarchiveChats(chatIds) {
+        await this.#chatListManager.unarchiveChats(chatIds);
+    }
+    /**
+     * Unarchive a single chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async unarchiveChat(chatId) {
+        await this.#chatListManager.unarchiveChat(chatId);
+    }
+    /**
+     * Get common chats between a user and the current one. User-only.
+     *
+     * @method ch
+     * @param userId The identifier of the user to get the common chats with them.
+     */
+    async getCommonChats(userId, params) {
+        return await this.#chatListManager.getCommonChats(userId, params);
+    }
+    /**
+     * Get the settings of a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async getChatSettings(chatId) {
+        return await this.#chatListManager.getChatSettings(chatId);
+    }
+    /**
+     * Disable business bots in a private chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the private chat to disable business bots in.
+     */
+    async disableBusinessBots(chatId) {
+        await this.#chatListManager.disableBusinessBots(chatId);
+    }
+    /**
+     * Enable business bots in a private chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the private chat to enable business bots in.
+     */
+    async enableBusinessBots(chatId) {
+        await this.#chatListManager.enableBusinessBots(chatId);
+    }
+    /**
+     * Disable slow mode in a group. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the group to disable slow mode in.
+     */
+    async disableSlowMode(chatId) {
+        await this.#chatManager.disableSlowMode(chatId);
+    }
+    /**
+     * Change slow mode in a group. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the group to change slow mode in.
+     * @param duration New slow mode duration.
+     */
+    async setSlowMode(chatId, duration) {
+        await this.#chatManager.setSlowMode(chatId, duration);
+    }
+    /**
+     * Change the title of a chat.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param title The new title.
+     */
+    async setChatTitle(chatId, title) {
+        await this.#chatManager.setChatTitle(chatId, title);
+    }
+    /**
+     * Change the description of a chat.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param description The new description.
+     */
+    async setChatDescription(chatId, description) {
+        await this.#chatManager.setChatDescription(chatId, description);
+    }
+    /**
+     * Hide the member list of a group to non-admins. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the group.
+     */
+    async hideMemberList(chatId) {
+        await this.#chatManager.hideMemberList(chatId);
+    }
+    /**
+     * Show the member list of a group to non-admins. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the group.
+     */
+    async showMemberList(chatId) {
+        await this.#chatManager.showMemberList(chatId);
+    }
+    /**
+     * Enable topics in a group. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the group.
+     * @param isShownAsTabs Whether topics should be displayed as tabs.
+     */
+    async enableTopics(chatId, isShownAsTabs) {
+        await this.#chatManager.enableTopics(chatId, isShownAsTabs);
+    }
+    /**
+     * Disable topics in a group. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the group.
+     */
+    async disableTopics(chatId) {
+        await this.#chatManager.disableTopics(chatId);
+    }
+    /**
+     * Enable automatic anti-spam in a group. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the group.
+     */
+    async enableAntispam(chatId) {
+        await this.#chatManager.enableAntispam(chatId);
+    }
+    /**
+     * Disable automatic anti-spam in a group. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the group.
+     */
+    async disableAntispam(chatId) {
+        await this.#chatManager.disableAntispam(chatId);
+    }
+    /**
+     * Enable post signatures in a channel. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the channel.
+     */
+    async enableSignatures(chatId, params) {
+        await this.#chatManager.enableSignatures(chatId, params);
+    }
+    /**
+     * Disable post signatures in a channel. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of the channel.
+     */
+    async disableSignatures(chatId) {
+        await this.#chatManager.disableSignatures(chatId);
+    }
+    /**
+     * Delete a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async deleteChat(chatId) {
+        await this.#chatManager.deleteChat(chatId);
+    }
+    /**
+     * Get discussion chat suggestions. User-only.
+     *
+     * @method ch
+     */
+    async getDiscussionChatSuggestions() {
+        return await this.#chatManager.getDiscussionChatSuggestions();
+    }
+    /**
+     * Set a channel's discussion chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a channel.
+     * @param discussionChatId The identifier of a chat to use as discussion for the channel.
+     */
+    async setDiscussionChat(chatId, discussionChatId) {
+        await this.#chatManager.setDiscussionChat(chatId, discussionChatId);
+    }
+    /**
+     * Transfer the ownership of a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param userId The identifier of the new owner.
+     * @param password The password of the current account.
+     */
+    async transferChatOwnership(chatId, userId, password) {
+        await this.#chatManager.transferChatOwnership(chatId, userId, password);
+    }
+    /**
+     * Create a forum topic.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param title The title of the topic.
+     * @returns The created topic.
+     */
+    async createTopic(chatId, title, params) {
+        return await this.#forumManager.createTopic(chatId, title, params);
+    }
+    /**
+     * Edit a forum topic.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param topicId The identifier of the topic.
+     * @param title The new title of the topic.
+     * @returns The new topic.
+     */
+    async editTopic(chatId, topicId, title, params) {
+        return await this.#forumManager.editTopic(chatId, topicId, title, params);
+    }
+    /**
+     * Hide the general forum topic.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async hideGeneralTopic(chatId) {
+        await this.#forumManager.hideGeneralTopic(chatId);
+    }
+    /**
+     * Show the general forum topic.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async showGeneralTopic(chatId) {
+        await this.#forumManager.showGeneralTopic(chatId);
+    }
+    /**
+     * Close a forum topic.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param topicId The identifier of the topic.
+     */
+    async closeTopic(chatId, topicId) {
+        await this.#forumManager.closeTopic(chatId, topicId);
+    }
+    /**
+     * Reopen a forum topic.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param topicId The identifier of the topic.
+     */
+    async reopenTopic(chatId, topicId) {
+        await this.#forumManager.reopenTopic(chatId, topicId);
+    }
+    /**
+     * Pin a forum topic.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param topicId The identifier of the topic.
+     */
+    async pinTopic(chatId, topicId) {
+        await this.#forumManager.pinTopic(chatId, topicId);
+    }
+    /**
+     * Unpin a forum topic.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param topicId The identifier of the topic.
+     */
+    async unpinTopic(chatId, topicId) {
+        await this.#forumManager.unpinTopic(chatId, topicId);
+    }
+    /**
+     * Promote a chat member.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param userId The identifier of the user to promote.
+     */
+    async promoteChatMember(chatId, userId, params) {
+        await this.#chatManager.promoteChatMember(chatId, userId, params);
+    }
+    /**
+     * Change the tag of a chat member.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     * @param userId The identifier of the user that is a member of the chat.
+     */
+    async setChatMemberTag(chatId, userId, params) {
+        await this.#chatManager.setChatMemberTag(chatId, userId, params);
+    }
+    /**
+     * Enable sharing in a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async enableSharing(chatId) {
+        await this.#chatManager.enableSharing(chatId);
+    }
+    /**
+     * Disable sharing in a chat. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a chat.
+     */
+    async disableSharing(chatId) {
+        await this.#chatManager.disableSharing(chatId);
+    }
+    /**
+     * Get recommended channels. User-only.
+     *
+     * @method ch
+     * @returns A list of recommended channels.
+     */
+    async getRecommendedChannels() {
+        return await this.#chatManager.getRecommendedChannels();
+    }
+    /**
+     * Get similar channels. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a channel to get similar channels for.
+     * @returns A list of similar channels.
+     */
+    async getSimilarChannels(chatId) {
+        return await this.#chatManager.getSimilarChannels(chatId);
+    }
+    /**
+     * Get similar bots. User-only.
+     *
+     * @method ch
+     * @param chatId The identifier of a bot to get similar bots for.
+     * @returns A list of similar bots.
+     */
+    async getSimilarBots(chatId) {
+        return await this.#chatManager.getSimilarBots(chatId);
+    }
+    //
+    // ========================= CALLBACK QUERIES ========================= //
+    //
+    /**
+     * Send a callback query. User-only.
+     *
+     * @method cq
+     * @param botId The identifier of the bot to send the callback query to.
+     * @param messageId The identifier of the message that includes at a button responsible for the callback query question.
+     * @param question The callback query's question.
+     * @returns The bot's answer to the callback query.
+     * @cache
+     */
+    async sendCallbackQuery(botId, messageId, question) {
+        return await this.#callbackQueryManager.sendCallbackQuery(botId, messageId, question);
+    }
+    /**
+     * Answer a callback query. Bot-only.
+     *
+     * @method cq
+     * @param id ID of the callback query to answer.
+     */
+    async answerCallbackQuery(id, params) {
+        await this.#callbackQueryManager.answerCallbackQuery(id, params);
+    }
+    //
+    // ========================= INLINE QUERIES ========================= //
+    //
+    /**
+     * Send an inline query. User-only.
+     *
+     * @method iq
+     * @param botId The identifier of a bot to send the inline query to.
+     * @param chatId The identifier of the chat from which the inline query is sent.
+     * @returns The bot's answer to the inline query.
+     * @cache
+     */
+    async sendInlineQuery(botId, chatId, params) {
+        return await this.#inlineQueryManager.sendInlineQuery(botId, chatId, params);
+    }
+    /**
+     * Answer an inline query. Bot-only.
+     *
+     * @method iq
+     * @param id The identifier of the inline query to answer.
+     * @param results The results to answer with.
+     */
+    async answerInlineQuery(id, results, params) {
+        await this.#inlineQueryManager.answerInlineQuery(id, results, params);
+    }
+    //
+    // ========================= BOTS ========================= //
+    //
+    /**
+     * Set the bot's description in the given language. Bot-only.
+     *
+     * @method bs
+     */
+    async setMyDescription(params) {
+        await this.#botInfoManager.setMyDescription(params);
+    }
+    /**
+     * Set the bot's name in the given language. Bot-only.
+     *
+     * @method bs
+     */
+    async setMyName(params) {
+        await this.#botInfoManager.setMyName(params);
+    }
+    /**
+     * Set the bot's short description in the given language. Bot-only.
+     *
+     * @method bs
+     */
+    async setMyShortDescription(params) {
+        await this.#botInfoManager.setMyShortDescription(params);
+    }
+    /**
+     * Get the bot's description in the given language. Bot-only.
+     *
+     * @method bs
+     * @returns The current bot's description in the specified language.
+     */
+    async getMyDescription(params) {
+        return await this.#botInfoManager.getMyDescription(params);
+    }
+    /**
+     * Get the bot's name in the given language. Bot-only.
+     *
+     * @method bs
+     * @returns The current bot's name in the specified language.
+     */
+    async getMyName(params) {
+        return await this.#botInfoManager.getMyName(params);
+    }
+    /**
+     * Get the bot's short description in the given language. Bot-only.
+     *
+     * @method bs
+     * @returns The current bot's short description in the specified language.
+     */
+    async getMyShortDescription(params) {
+        return await this.#botInfoManager.getMyShortDescription(params);
+    }
+    /**
+     * Set the bot's commands in the given scope and/or language. Bot-only.
+     *
+     * @method bs
+     * @param commands The commands to set.
+     */
+    async setMyCommands(commands, params) {
+        await this.#botInfoManager.setMyCommands(commands, params);
+    }
+    /**
+     * Get the bot's commands in the given scope and/or language. Bot-only.
+     *
+     * @method bs
+     * @returns The current bot's commands in the specified language.
+     */
+    async getMyCommands(params) {
+        return await this.#botInfoManager.getMyCommands(params);
+    }
+    //
+    // ========================= REACTIONS ========================= //
+    //
+    /**
+     * Change reactions made to a message.
+     *
+     * @method re
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message to add the reaction to.
+     * @param reactions The new reactions.
+     */
+    async setReactions(chatId, messageId, reactions, params) {
+        await this.#messageManager.setReactions(chatId, messageId, reactions, params);
+    }
+    /**
+     * Make a reaction to a message.
+     *
+     * @method re
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message to add the reaction to.
+     * @param reaction The reaction to add.
+     */
+    async addReaction(chatId, messageId, reaction, params) {
+        await this.#messageManager.addReaction(chatId, messageId, reaction, params);
+    }
+    /**
+     * Undo a reaction made to a message.
+     *
+     * @method re
+     * @param chatId The identifier of the chat which the message belongs to.
+     * @param messageId The identifier of the message which the reaction was made to.
+     * @param reaction The reaction to remove.
+     */
+    async removeReaction(chatId, messageId, reaction) {
+        await this.#messageManager.removeReaction(chatId, messageId, reaction);
+    }
+    //
+    // ========================= STORIES ========================= //
+    //
+    /**
+     * Create a story. User-only.
+     *
+     * @method st
+     * @param content The content of the story.
+     * @returns The created story.
+     */
+    async createStory(chatId, content, params) {
+        return await this.#storyManager.createStory(chatId, content, params);
+    }
+    /**
+     * Retrieve multiple stories. User-only.
+     *
+     * @method st
+     * @param chatId The identifier of a chat.
+     * @param storyIds The identifiers of the stories to retrieve.
+     * @returns The retrieved stories.
+     */
+    async getStories(chatId, storyIds) {
+        if (!storyIds.length) {
+            return [];
+        }
+        return await this.#storyManager.getStories(chatId, storyIds);
+    }
+    /**
+     * Retrieve a single story. User-only.
+     *
+     * @method st
+     * @param chatId The identifier of a chat.
+     * @param storyId The identifier of the story to retrieve.
+     * @returns The retrieved story.
+     */
+    async getStory(chatId, storyId) {
+        return await this.#storyManager.getStory(chatId, storyId);
+    }
+    /**
+     * Delete multiple stories. User-only.
+     *
+     * @method st
+     * @param chatId The identifier of a chat.
+     * @param storyIds The identifiers of the stories to delete.
+     */
+    async deleteStories(chatId, storyIds) {
+        await this.#storyManager.deleteStories(chatId, storyIds);
+    }
+    /**
+     * Delete a single story. User-only.
+     *
+     * @method st
+     * @param chatId The identifier of a chat.
+     * @param storyId The identifier of the story to delete.
+     */
+    async deleteStory(chatId, storyId) {
+        await this.#storyManager.deleteStory(chatId, storyId);
+    }
+    /**
+     * Add multiple stories to highlights. User-only.
+     *
+     * @method st
+     * @param chatId The identifier of a chat.
+     * @param storyIds The identifiers of the stories to add to highlights.
+     */
+    async addStoriesToHighlights(chatId, storyIds) {
+        await this.#storyManager.addStoriesToHighlights(chatId, storyIds);
+    }
+    /**
+     * Add a single story to highlights. User-only.
+     *
+     * @method st
+     * @param chatId The identifier of a chat.
+     * @param storyId The identifier of the story to add to highlights.
+     */
+    async addStoryToHighlights(chatId, storyId) {
+        await this.#storyManager.addStoryToHighlights(chatId, storyId);
+    }
+    /**
+     * Remove multiple stories from highlights. User-only.
+     *
+     * @method st
+     * @param chatId The identifier of a chat.
+     * @param storyIds The identifiers of the stories to remove from highlights.
+     */
+    async removeStoriesFromHighlights(chatId, storyIds) {
+        await this.#storyManager.removeStoriesFromHighlights(chatId, storyIds);
+    }
+    /**
+     * Remove a single story from highlights. User-only.
+     *
+     * @method st
+     * @param chatId The identifier of a chat.
+     * @param storyId The identifier of the story to remove from highlights.
+     */
+    async removeStoryFromHighlights(chatId, storyId) {
+        await this.#storyManager.removeStoryFromHighlights(chatId, storyId);
+    }
+    //
+    // ========================= MISC ========================= //
+    //
+    /**
+     * Get network statistics. This might not always be available.
+     *
+     * @method mc
+     */
+    async getNetworkStatistics() {
+        return await this.#networkStatisticsManager.getNetworkStatistics();
+    }
+    /**
+     * Block a user. User-only.
+     *
+     * @method mc
+     * @param userId The identifier of the user to block.
+     */
+    async blockUser(userId) {
+        await this.#messageManager.blockUser(userId);
+    }
+    /**
+     * Unblock a user. User-only.
+     *
+     * @method mc
+     * @param userId The identifier of the user to unblock.
+     */
+    async unblockUser(userId) {
+        await this.#messageManager.unblockUser(userId);
+    }
+    //
+    // ========================= VIDEO CHATS ========================= //
+    //
+    /**
+     * Start a video chat. User-only.
+     *
+     * @method vc
+     * @param chatId The identifier of a chat to start the video chat in.
+     * @returns The started video chat.
+     */
+    async startVideoChat(chatId, params) {
+        return await this.#videoChatManager.startVideoChat(chatId, params);
+    }
+    /**
+     * Schedule a video chat. User-only.
+     *
+     * @method vc
+     * @param chatId The identifier of a chat to schedule the video chat in.
+     * @param startAt A point in time within the future in which the video chat will be started.
+     * @returns The scheduled video chat.
+     */
+    async scheduleVideoChat(chatId, startAt, params) {
+        return await this.#videoChatManager.scheduleVideoChat(chatId, startAt, params);
+    }
+    /**
+     * Join a video chat. User-only.
+     *
+     * @method vc
+     * @param id The identifier of a video chat retrieved from getChat, startVideoChat, or scheduleVideoChat.
+     * @param params_ WebRTC connection parameters.
+     * @returns Parameters to be passed to the used WebRTC library.
+     */
+    async joinVideoChat(id, params_, params) {
+        return await this.#videoChatManager.joinVideoChat(id, params_, params);
+    }
+    /**
+     * Leave a video chat. User-only.
+     *
+     * @method vc
+     * @param id The identifier of a video chat retrieved from getChat, startVideoChat, or scheduleVideoChat.
+     */
+    async leaveVideoChat(id) {
+        await this.#videoChatManager.leaveVideoChat(id);
+    }
+    /**
+     * Join a live stream. User-only.
+     *
+     * @method vc
+     * @param id The identifier of a video chat retrieved from getChat, startVideoChat, or scheduleVideoChat.
+     */
+    async joinLiveStream(id) {
+        await this.#videoChatManager.joinLiveStream(id);
+    }
+    /**
+     * Get a video chat. User-only.
+     *
+     * @method vc
+     * @param id The identifier of a video chat retrieved from getChat, startVideoChat, or scheduleVideoChat.
+     * @cache
+     */
+    async getVideoChat(id) {
+        return await this.#videoChatManager.getVideoChat(id);
+    }
+    /**
+     * Get live stream channels. User-only.
+     *
+     * @method vc
+     * @param id The identifier of a video chat retrieved from getChat, startVideoChat, or scheduleVideoChat.
+     */
+    async getLiveStreamChannels(id) {
+        return await this.#videoChatManager.getLiveStreamChannels(id);
+    }
+    /**
+     * Download a live stream segment. User-only.
+     *
+     * @method vc
+     * @param id The identifier of a video chat retrieved from getChat, startVideoChat, or scheduleVideoChat.
+     * @param channelId Stream channel ID.
+     * @param scale Stream channel scale.
+     * @param timestamp Millisecond timestamp of the chunk to download.
+     */
+    async downloadLiveStreamSegment(id, channelId, scale, timestamp, params) {
+        return await this.#videoChatManager.downloadLiveStreamSegment(id, channelId, scale, timestamp, params);
+    }
+    //
+    // ========================= PAYMENTS ========================= //
+    //
+    /**
+     * Answer a pre-checkout query. Bot-only.
+     *
+     * @method pa
+     * @param preCheckoutQueryId The identifier of the pre-checkout query.
+     * @param ok Whether the checkout is going to be processed.
+     */
+    async answerPreCheckoutQuery(preCheckoutQueryId, ok, params) {
+        await this.#paymentManager.answerPreCheckoutQuery(preCheckoutQueryId, ok, params);
+    }
+    /**
+     * Refund a star payment. Bot-only.
+     *
+     * @method pa
+     * @param userId The identifier of the user that was charged.
+     * @param telegramPaymentChargeId The identifier of the charge.
+     */
+    async refundStarPayment(userId, telegramPaymentChargeId) {
+        await this.#paymentManager.refundStarPayment(userId, telegramPaymentChargeId);
+    }
+    //
+    // ========================= CONTACTS ========================= //
+    //
+    /**
+     * Get contacts. User-only.
+     *
+     * @method co
+     */
+    async getContacts() {
+        return await this.#accountManager.getContacts();
+    }
+    /**
+     * Delete multiple contacts. User-only.
+     *
+     * @method co
+     * @param userIds The identifiers of contacts to delete.
+     */
+    async deleteContacts(userIds) {
+        await this.#accountManager.deleteContacts(userIds);
+    }
+    /**
+     * Delete a single contact. User-only.
+     *
+     * @method co
+     * @param userId The identifier of the contact to delete.
+     */
+    async deleteContact(userId) {
+        await this.#accountManager.deleteContact(userId);
+    }
+    /**
+     * Add a contact. User-only.
+     *
+     * @method co
+     * @param userId The identifier of the user to add as contact.
+     */
+    async addContact(userId, params) {
+        await this.#accountManager.addContact(userId, params);
+    }
+    //
+    // ========================= TRANSLATIONS ========================= //
+    //
+    /**
+     * Get translations. User-only.
+     *
+     * @method ta
+     * @cache
+     */
+    async getTranslations(params) {
+        return await this.#translationsManager.getTranslations(params);
+    }
+    //
+    // ========================= GIFTS ========================= //
+    //
+    /**
+     * Get available gifts.
+     *
+     * @method gf
+     */
+    async getGifts() {
+        return await this.#giftManager.getGifts();
+    }
+    /**
+     * Get gifts claimed by a user or a channel. User-only.
+     *
+     * @method gf
+     * @param chatId The identifier of a user or a channel to get gifts for.
+     */
+    async getClaimedGifts(chatId, params) {
+        return await this.#giftManager.getClaimedGifts(chatId, params);
+    }
+    /**
+     * Send a gift.
+     *
+     * @method gf
+     * @param chatId The identifier of a user or a channel to send the gift to.
+     * @param giftId The identifier of the gift to send.
+     */
+    async sendGift(chatId, giftId, params) {
+        await this.#giftManager.sendGift(chatId, giftId, params);
+    }
+    /**
+     * Sell a gift.
+     *
+     * @method gf
+     * @param gift The gift to sell.
+     */
+    async sellGift(gift) {
+        await this.#giftManager.sellGift(gift);
+    }
+    /**
+     * Craft gifts.
+     *
+     * @method gf
+     * @param gift The gifts to craft.
+     */
+    async craftGifts(gifts) {
+        await this.#giftManager.craftGifts(gifts);
+    }
+    /**
+     * Get a gift using its slug.
+     *
+     * @method gf
+     * @param slug The slug of a gift.
+     */
+    async getGift(slug) {
+        return await this.#giftManager.getGift(slug);
+    }
+    /**
+     * Transfer a gift. User-only.
+     *
+     * @method gf
+     * @param chatId The identifier of a chat to transfer the gift to.
+     * @param gift The gift to transfer.
+     */
+    async transferGift(chatId, gift) {
+        return await this.#giftManager.transferGift(chatId, gift);
+    }
+}