@mtkruto/node 0.1.141 → 0.1.143

package/esm/client/5_session_string.d.ts

@@ -0,0 +1,3 @@
+import { Client } from "./4_client.js";
+export declare function exportSessionString(client: Client): Promise<string>;
+export declare function importSessionString(client: Client, string: string): Promise<void>;

package/esm/client/5_session_string.js

@@ -0,0 +1,22 @@
+import { base64DecodeUrlSafe, base64EncodeUrlSafe, rleDecode, rleEncode } from "../1_utilities.js";
+import { TLReader, TLWriter } from "../2_tl.js";
+export async function exportSessionString(client) {
+    const [dc, authKey] = await Promise.all([client.storage.getDc(), client.storage.getAuthKey()]);
+    if (dc == null || authKey == null) {
+        throw new Error("Client not authorized");
+    }
+    const writer = new TLWriter();
+    writer.writeString(dc);
+    writer.writeBytes(authKey);
+    const data = rleEncode(writer.buffer);
+    return base64EncodeUrlSafe(data);
+}
+export async function importSessionString(client, string) {
+    const data = rleDecode(base64DecodeUrlSafe(string));
+    const reader = new TLReader(data);
+    const dc = reader.readString();
+    const authKey = reader.readBytes();
+    await client.storage.initialize();
+    await client.storage.setDc(dc);
+    await client.storage.setAuthKey(authKey);
+}

package/esm/connection/1_connection_web_socket.js

@@ -50,7 +50,7 @@ export class ConnectionWebSocket extends ConnectionUnframed {
         try {
             while (__classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").readyState != dntShim.WebSocket.OPEN) {
                 if (__classPrivateFieldGet(this, _ConnectionWebSocket_webSocket, "f").readyState == dntShim.WebSocket.CLOSED) {
-                    if (__classPrivateFieldGet(this, _ConnectionWebSocket_connectionError, "f") instanceof ErrorEvent) {
+                    if (__classPrivateFieldGet(this, _ConnectionWebSocket_connectionError, "f") && "message" in __classPrivateFieldGet(this, _ConnectionWebSocket_connectionError, "f")) {
                         throw new Error(__classPrivateFieldGet(this, _ConnectionWebSocket_connectionError, "f").message);
                     }
                     else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mtkruto/node",
-  "version": "0.1.141",
+  "version": "0.1.143",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "repository": {

package/script/4_constants.d.ts

@@ -4,7 +4,7 @@ export type PublicKeys = readonly [bigint, [bigint, bigint]][];
 export declare const PUBLIC_KEYS: PublicKeys;
 export declare const INITIAL_DC: DC;
 export declare const LAYER = 169;
-export declare const APP_VERSION = "MTKruto 0.1.141";
+export declare const APP_VERSION = "MTKruto 0.1.143";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/script/4_constants.js

@@ -79,7 +79,7 @@ exports.PUBLIC_KEYS = Object.freeze([
 ]);
 exports.INITIAL_DC = "2";
 exports.LAYER = 169;
-exports.APP_VERSION = "MTKruto 0.1.141";
+exports.APP_VERSION = "MTKruto 0.1.143";
 // @ts-ignore: lib
 exports.DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 exports.LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

package/script/5_client.d.ts

@@ -2,3 +2,4 @@ export * from "./client/0_params.js";
 export * from "./client/2_client_plain.js";
 export * from "./client/4_client.js";
 export * from "./client/5_composer.js";
+export * from "./client/5_session_string.js";

package/script/5_client.js

@@ -18,3 +18,4 @@ __exportStar(require("./client/0_params.js"), exports);
 __exportStar(require("./client/2_client_plain.js"), exports);
 __exportStar(require("./client/4_client.js"), exports);
 __exportStar(require("./client/5_composer.js"), exports);
+__exportStar(require("./client/5_session_string.js"), exports);

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

@@ -33,6 +33,8 @@ export interface C {
     handleUpdate: (update: Update) => void;
     parseMode: ParseMode;
     apiFactory: ApiFactory;
+    ignoreOutgoing: boolean | null;
+    cdn: boolean;
 }
 export declare class ConnectionError extends Error {
 }

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

@@ -0,0 +1,30 @@
+import { BotCommand } from "../3_types.js";
+import { GetMyCommandsParams, SetMyCommandsParams } from "./0_params.js";
+import { C } from "./0_types.js";
+export declare class BotInfoManager {
+    #private;
+    constructor(c: C);
+    setMyDescription(params?: {
+        description?: string;
+        languageCode?: string;
+    }): Promise<void>;
+    setMyName(params?: {
+        name?: string;
+        languageCode?: string;
+    }): Promise<void>;
+    setMyShortDescription(params?: {
+        shortDescription?: string;
+        languageCode?: string;
+    }): Promise<void>;
+    getMyDescription(params?: {
+        languageCode?: string;
+    }): Promise<string>;
+    getMyName(params?: {
+        languageCode?: string;
+    }): Promise<string>;
+    getMyShortDescription(params?: {
+        languageCode?: string;
+    }): Promise<string>;
+    getMyCommands(params?: GetMyCommandsParams): Promise<BotCommand[]>;
+    setMyCommands(commands: BotCommand[], params?: SetMyCommandsParams): Promise<void>;
+}

package/script/client/1_bot_info_manager.js

@@ -0,0 +1,70 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BotInfoManager_instances, _BotInfoManager_c, _BotInfoManager_setMyInfo, _BotInfoManager_getMyInfo;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotInfoManager = void 0;
+const _2_tl_js_1 = require("../2_tl.js");
+const _3_types_js_1 = require("../3_types.js");
+class BotInfoManager {
+    constructor(c) {
+        _BotInfoManager_instances.add(this);
+        _BotInfoManager_c.set(this, void 0);
+        __classPrivateFieldSet(this, _BotInfoManager_c, c, "f");
+    }
+    async setMyDescription(params) {
+        await __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("setMyDescription");
+        await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_setMyInfo).call(this, { description: params?.description, lang_code: params?.languageCode ?? "" });
+    }
+    async setMyName(params) {
+        await __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("setMyName");
+        await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_setMyInfo).call(this, { name: params?.name, lang_code: params?.languageCode ?? "" });
+    }
+    async setMyShortDescription(params) {
+        await __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("setMyShortDescription");
+        await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_setMyInfo).call(this, { about: params?.shortDescription, lang_code: params?.languageCode ?? "" });
+    }
+    async getMyDescription(params) {
+        await __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("getMyDescription");
+        return await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_getMyInfo).call(this, params?.languageCode).then((v) => v.description);
+    }
+    async getMyName(params) {
+        await __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("getMyName");
+        return await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_getMyInfo).call(this, params?.languageCode).then((v) => v.description);
+    }
+    async getMyShortDescription(params) {
+        await __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("getMyShortDescription");
+        return await __classPrivateFieldGet(this, _BotInfoManager_instances, "m", _BotInfoManager_getMyInfo).call(this, params?.languageCode).then((v) => v.about);
+    }
+    async getMyCommands(params) {
+        await __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("getMyCommands");
+        const commands_ = await __classPrivateFieldGet(this, _BotInfoManager_c, "f").api.bots.getBotCommands({
+            lang_code: params?.languageCode ?? "",
+            scope: await (0, _3_types_js_1.botCommandScopeToTlObject)(params?.scope ?? { type: "default" }, __classPrivateFieldGet(this, _BotInfoManager_c, "f").getInputPeer),
+        });
+        return commands_.map((v) => ({ command: v.command, description: v.description }));
+    }
+    async setMyCommands(commands, params) {
+        await __classPrivateFieldGet(this, _BotInfoManager_c, "f").storage.assertBot("setMyCommands");
+        await __classPrivateFieldGet(this, _BotInfoManager_c, "f").api.bots.setBotCommands({
+            commands: commands.map((v) => new _2_tl_js_1.types.BotCommand(v)),
+            lang_code: params?.languageCode ?? "",
+            scope: await (0, _3_types_js_1.botCommandScopeToTlObject)(params?.scope ?? { type: "default" }, __classPrivateFieldGet(this, _BotInfoManager_c, "f").getInputPeer),
+        });
+    }
+}
+exports.BotInfoManager = BotInfoManager;
+_BotInfoManager_c = new WeakMap(), _BotInfoManager_instances = new WeakSet(), _BotInfoManager_setMyInfo = async function _BotInfoManager_setMyInfo(info) {
+    await __classPrivateFieldGet(this, _BotInfoManager_c, "f").api.bots.setBotInfo({ bot: new _2_tl_js_1.types.InputUserSelf(), ...info });
+}, _BotInfoManager_getMyInfo = function _BotInfoManager_getMyInfo(languageCode) {
+    return __classPrivateFieldGet(this, _BotInfoManager_c, "f").api.bots.getBotInfo({ bot: new _2_tl_js_1.types.InputUserSelf(), lang_code: languageCode ?? "" });
+};

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

@@ -0,0 +1,19 @@
+import { C } from "./0_types.js";
+export declare class NetworkStatisticsManager {
+    #private;
+    constructor(c: C);
+    getNetworkStatistics(): Promise<{
+        messages: {
+            sent: number;
+            received: number;
+        };
+        cdn: {
+            sent: number;
+            received: number;
+        };
+    }>;
+    getTransportReadWriteCallback(): {
+        read: (count: number) => Promise<void>;
+        write: (count: number) => Promise<void>;
+    };
+}

package/script/client/1_network_statistics_manager.js

@@ -0,0 +1,52 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _NetworkStatisticsManager_c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkStatisticsManager = void 0;
+class NetworkStatisticsManager {
+    constructor(c) {
+        _NetworkStatisticsManager_c.set(this, void 0);
+        __classPrivateFieldSet(this, _NetworkStatisticsManager_c, c, "f");
+    }
+    async getNetworkStatistics() {
+        const [messagesRead, messagesWrite, cdnRead, cdnWrite] = await Promise.all([
+            __classPrivateFieldGet(this, _NetworkStatisticsManager_c, "f").storage.get(["netstat_messages_read"]),
+            __classPrivateFieldGet(this, _NetworkStatisticsManager_c, "f").storage.get(["netstat_messages_write"]),
+            __classPrivateFieldGet(this, _NetworkStatisticsManager_c, "f").storage.get(["netstat_cdn_read"]),
+            __classPrivateFieldGet(this, _NetworkStatisticsManager_c, "f").storage.get(["netstat_cdn_write"]),
+        ]);
+        const messages = {
+            sent: Number(messagesWrite || 0),
+            received: Number(messagesRead || 0),
+        };
+        const cdn = {
+            sent: Number(cdnWrite || 0),
+            received: Number(cdnRead || 0),
+        };
+        return { messages, cdn };
+    }
+    getTransportReadWriteCallback() {
+        return {
+            read: async (count) => {
+                const key = __classPrivateFieldGet(this, _NetworkStatisticsManager_c, "f").cdn ? "netstat_cdn_read" : "netstat_messages_read";
+                await __classPrivateFieldGet(this, _NetworkStatisticsManager_c, "f").storage.incr([key], count);
+            },
+            write: async (count) => {
+                const key = __classPrivateFieldGet(this, _NetworkStatisticsManager_c, "f").cdn ? "netstat_cdn_write" : "netstat_messages_write";
+                await __classPrivateFieldGet(this, _NetworkStatisticsManager_c, "f").storage.incr([key], count);
+            },
+        };
+    }
+}
+exports.NetworkStatisticsManager = NetworkStatisticsManager;
+_NetworkStatisticsManager_c = new WeakMap();

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

@@ -0,0 +1,9 @@
+import { enums, types } from "../2_tl.js";
+import { Update } from "../3_types.js";
+import { C } from "./0_types.js";
+export declare class ReactionManager {
+    #private;
+    constructor(c: C);
+    static canHandleUpdate(update: enums.Update): update is types.UpdateBotMessageReactions | types.UpdateBotMessageReaction | types.UpdateMessageReactions | types.UpdateChannelMessageViews | types.UpdateChannelMessageForwards;
+    handleUpdate(update: types.UpdateBotMessageReactions | types.UpdateBotMessageReaction | types.UpdateMessageReactions | types.UpdateChannelMessageViews | types.UpdateChannelMessageForwards): Promise<Update | null>;
+}

package/script/client/1_reaction_manager.js

@@ -0,0 +1,88 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ReactionManager_c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactionManager = void 0;
+const _1_utilities_js_1 = require("../1_utilities.js");
+const _2_tl_js_1 = require("../2_tl.js");
+const _3_types_js_1 = require("../3_types.js");
+class ReactionManager {
+    constructor(c) {
+        _ReactionManager_c.set(this, void 0);
+        __classPrivateFieldSet(this, _ReactionManager_c, c, "f");
+    }
+    static canHandleUpdate(update) {
+        return update instanceof _2_tl_js_1.types.UpdateBotMessageReactions || update instanceof _2_tl_js_1.types.UpdateBotMessageReaction || update instanceof _2_tl_js_1.types.UpdateMessageReactions || update instanceof _2_tl_js_1.types.UpdateChannelMessageViews || update instanceof _2_tl_js_1.types.UpdateChannelMessageForwards;
+    }
+    async handleUpdate(update) {
+        if (update instanceof _2_tl_js_1.types.UpdateBotMessageReactions) {
+            const messageReactionCount = await (0, _3_types_js_1.constructMessageReactionCount)(update, __classPrivateFieldGet(this, _ReactionManager_c, "f").getEntity);
+            if (messageReactionCount) {
+                return { messageReactionCount };
+            }
+            else {
+                return null;
+            }
+        }
+        else if (update instanceof _2_tl_js_1.types.UpdateBotMessageReaction) {
+            const messageReactions = await (0, _3_types_js_1.constructMessageReactions)(update, __classPrivateFieldGet(this, _ReactionManager_c, "f").getEntity);
+            if (messageReactions) {
+                return { messageReactions };
+            }
+            else {
+                return null;
+            }
+        }
+        else if (update instanceof _2_tl_js_1.types.UpdateMessageReactions) {
+            const chatId = (0, _2_tl_js_1.peerToChatId)(update.peer);
+            const message = await __classPrivateFieldGet(this, _ReactionManager_c, "f").storage.getMessage(chatId, update.msg_id);
+            if (message instanceof _2_tl_js_1.types.Message) {
+                message.reactions = update.reactions;
+                await __classPrivateFieldGet(this, _ReactionManager_c, "f").storage.setMessage(chatId, update.msg_id, message);
+                const views = message.views ?? 0;
+                const forwards = message.forwards ?? 0;
+                const recentReactions = update.reactions.recent_reactions ?? [];
+                const reactions = update.reactions.results.map((v) => (0, _3_types_js_1.constructMessageReaction)(v, recentReactions));
+                return ({ messageInteractions: { chatId, messageId: update.msg_id, reactions, views, forwards } });
+            }
+            else {
+                return null;
+            }
+        }
+        else if (update instanceof _2_tl_js_1.types.UpdateChannelMessageViews || update instanceof _2_tl_js_1.types.UpdateChannelMessageForwards) {
+            const chatId = (0, _2_tl_js_1.peerToChatId)(new _2_tl_js_1.types.PeerChannel(update));
+            const message = await __classPrivateFieldGet(this, _ReactionManager_c, "f").storage.getMessage(chatId, update.id);
+            if (message instanceof _2_tl_js_1.types.Message) {
+                if ("views" in update) {
+                    message.views = update.views;
+                }
+                if ("forwards" in update) {
+                    message.forwards = update.forwards;
+                }
+                const views = message.views ?? 0;
+                const forwards = message.forwards ?? 0;
+                const recentReactions = message.reactions?.recent_reactions ?? [];
+                const reactions = message.reactions?.results.map((v) => (0, _3_types_js_1.constructMessageReaction)(v, recentReactions)) ?? [];
+                return { messageInteractions: { chatId, messageId: update.id, reactions, views, forwards } };
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            (0, _1_utilities_js_1.UNREACHABLE)();
+        }
+    }
+}
+exports.ReactionManager = ReactionManager;
+_ReactionManager_c = new WeakMap();

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

@@ -1,6 +1,7 @@
 import { enums, types } from "../2_tl.js";
-import { FileSource, ID, Message } from "../3_types.js";
-import { DeleteMessagesParams, EditMessageParams, EditMessageReplyMarkupParams, ForwardMessagesParams, GetHistoryParams, PinMessageParams, SendAnimationParams, SendAudioParams, SendContactParams, SendDiceParams, SendDocumentParams, SendLocationParams, SendMessageParams, SendPhotoParams, SendPollParams, SendVenueParams, SendVideoNoteParams, SendVideoParams, SendVoiceParams } from "./0_params.js";
+import { ChatAction, FileSource, ID, Message, MessageEntity, ParseMode, Reaction, Update, UsernameResolver } from "../3_types.js";
+import { BanChatMemberParams, DeleteMessagesParams, EditMessageParams, EditMessageReplyMarkupParams, ForwardMessagesParams, GetHistoryParams, PinMessageParams, SendAnimationParams, SendAudioParams, SendContactParams, SendDiceParams, SendDocumentParams, SendLocationParams, SendMessageParams, SendPhotoParams, SendPollParams, SendVenueParams, SendVideoNoteParams, SendVideoParams, SendVoiceParams, SetChatMemberRightsParams, SetChatPhotoParams } from "./0_params.js";
+import { AddReactionParams, SetReactionsParams } from "./0_params.js";
 import { C as C_ } from "./0_types.js";
 import { FileManager } from "./1_file_manager.js";
 interface C extends C_ {
@@ -12,10 +13,15 @@ export declare class MessageManager {
     getMessages(chatId: ID, messageIds: number[]): Promise<Message[]>;
     getMessageWithReply(chatId: ID, messageId: number): Promise<Message>;
     getMessage(chatId: ID, messageId: number): Promise<Message>;
+    parseText(text: string, params?: {
+        parseMode?: ParseMode;
+        entities?: MessageEntity[];
+    }): readonly [string, (import("../tl/2_types.js").MessageEntityMention_ | import("../tl/2_types.js").MessageEntityHashtag_ | import("../tl/2_types.js").MessageEntityBotCommand_ | import("../tl/2_types.js").MessageEntityUrl_ | import("../tl/2_types.js").MessageEntityEmail_ | import("../tl/2_types.js").MessageEntityBold_ | import("../tl/2_types.js").MessageEntityItalic_ | import("../tl/2_types.js").MessageEntityCode_ | import("../tl/2_types.js").MessageEntityPre_ | import("../tl/2_types.js").MessageEntityTextUrl_ | import("../tl/2_types.js").MessageEntityMentionName_ | import("../tl/2_types.js").MessageEntityPhone_ | import("../tl/2_types.js").MessageEntityCashtag_ | import("../tl/2_types.js").MessageEntityUnderline_ | import("../tl/2_types.js").MessageEntityStrike_ | import("../tl/2_types.js").MessageEntityBankCard_ | import("../tl/2_types.js").MessageEntitySpoiler_ | import("../tl/2_types.js").MessageEntityCustomEmoji_ | import("../tl/2_types.js").MessageEntityBlockquote_)[] | undefined];
     getStickerSetName(inputStickerSet: types.InputStickerSetID, hash?: number): Promise<string>;
     constructMessage(message_: enums.Message, r?: boolean): Promise<Message>;
     forwardMessages(from: ID, to: ID, messageIds: number[], params?: ForwardMessagesParams): Promise<Message[]>;
     getHistory(chatId: ID, params?: GetHistoryParams): Promise<Message[]>;
+    usernameResolver: UsernameResolver;
     sendMessage(chatId: ID, text: string, params?: SendMessageParams): Promise<import("../3_types.js").MessageText>;
     sendVenue(chatId: ID, latitude: number, longitude: number, title: string, address: string, params?: SendVenueParams): Promise<import("../3_types.js").MessageVenue>;
     sendContact(chatId: ID, firstName: string, number: string, params?: SendContactParams): Promise<import("../3_types.js").MessageContact>;
@@ -36,5 +42,19 @@ export declare class MessageManager {
     pinMessage(chatId: ID, messageId: number, params?: PinMessageParams): Promise<void>;
     unpinMessage(chatId: ID, messageId: number): Promise<void>;
     unpinMessages(chatId: ID): Promise<void>;
+    setAvailableReactions(chatId: ID, availableReactions: "none" | "all" | Reaction[]): Promise<void>;
+    setReactions(chatId: number, messageId: number, reactions: Reaction[], params?: SetReactionsParams): Promise<void>;
+    addReaction(chatId: number, messageId: number, reaction: Reaction, params?: AddReactionParams): Promise<void>;
+    removeReaction(chatId: number, messageId: number, reaction: Reaction): Promise<void>;
+    static canHandleUpdate(update: enums.Update): update is types.UpdateNewMessage | types.UpdateNewChannelMessage | types.UpdateEditMessage | types.UpdateEditChannelMessage | types.UpdateDeleteMessages | types.UpdateDeleteChannelMessages;
+    handleUpdate(update: types.UpdateNewMessage | types.UpdateNewChannelMessage | types.UpdateEditMessage | types.UpdateEditChannelMessage | types.UpdateDeleteMessages | types.UpdateDeleteChannelMessages): Promise<Update | null>;
+    sendChatAction(chatId: ID, action: ChatAction, params?: {
+        messageThreadId?: number;
+    }): Promise<void>;
+    deleteChatPhoto(chatId: number): Promise<void>;
+    setChatPhoto(chatId: number, photo: FileSource, params?: SetChatPhotoParams): Promise<void>;
+    banChatMember(chatId: ID, memberId: ID, params?: BanChatMemberParams): Promise<void>;
+    unbanChatMember(chatId: ID, memberId: ID): Promise<void>;
+    setChatMemberRights(chatId: ID, memberId: ID, params?: SetChatMemberRightsParams): Promise<void>;
 }
 export {};