@mtkruto/node 0.1.140 → 0.1.142

package/esm/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.140";
+export declare const APP_VERSION = "MTKruto 0.1.142";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/esm/4_constants.js

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

package/esm/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/esm/5_client.js

@@ -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/esm/client/0_types.d.ts

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

package/esm/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/esm/client/1_reaction_manager.js

@@ -0,0 +1,84 @@
+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;
+import { UNREACHABLE } from "../1_utilities.js";
+import { peerToChatId, types } from "../2_tl.js";
+import { constructMessageReaction, constructMessageReactionCount, constructMessageReactions } from "../3_types.js";
+export class ReactionManager {
+    constructor(c) {
+        _ReactionManager_c.set(this, void 0);
+        __classPrivateFieldSet(this, _ReactionManager_c, c, "f");
+    }
+    static canHandleUpdate(update) {
+        return update instanceof types.UpdateBotMessageReactions || update instanceof types.UpdateBotMessageReaction || update instanceof types.UpdateMessageReactions || update instanceof types.UpdateChannelMessageViews || update instanceof types.UpdateChannelMessageForwards;
+    }
+    async handleUpdate(update) {
+        if (update instanceof types.UpdateBotMessageReactions) {
+            const messageReactionCount = await constructMessageReactionCount(update, __classPrivateFieldGet(this, _ReactionManager_c, "f").getEntity);
+            if (messageReactionCount) {
+                return { messageReactionCount };
+            }
+            else {
+                return null;
+            }
+        }
+        else if (update instanceof types.UpdateBotMessageReaction) {
+            const messageReactions = await constructMessageReactions(update, __classPrivateFieldGet(this, _ReactionManager_c, "f").getEntity);
+            if (messageReactions) {
+                return { messageReactions };
+            }
+            else {
+                return null;
+            }
+        }
+        else if (update instanceof types.UpdateMessageReactions) {
+            const chatId = peerToChatId(update.peer);
+            const message = await __classPrivateFieldGet(this, _ReactionManager_c, "f").storage.getMessage(chatId, update.msg_id);
+            if (message instanceof 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) => constructMessageReaction(v, recentReactions));
+                return ({ messageInteractions: { chatId, messageId: update.msg_id, reactions, views, forwards } });
+            }
+            else {
+                return null;
+            }
+        }
+        else if (update instanceof types.UpdateChannelMessageViews || update instanceof types.UpdateChannelMessageForwards) {
+            const chatId = peerToChatId(new types.PeerChannel(update));
+            const message = await __classPrivateFieldGet(this, _ReactionManager_c, "f").storage.getMessage(chatId, update.id);
+            if (message instanceof 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) => constructMessageReaction(v, recentReactions)) ?? [];
+                return { messageInteractions: { chatId, messageId: update.id, reactions, views, forwards } };
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
+}
+_ReactionManager_c = new WeakMap();

package/esm/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 { FileSource, ID, Message, MessageEntity, ParseMode, Reaction, Update, UsernameResolver } 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 { 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,11 @@ 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>;
 }
 export {};

package/esm/client/2_message_manager.js

@@ -9,11 +9,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _MessageManager_instances, _MessageManager_c, _MessageManager_parseText, _MessageManager_updatesToMessages, _MessageManager_usernameResolver, _MessageManager_constructReplyMarkup, _MessageManager_resolveSendAs, _MessageManager_constructReplyTo, _MessageManager_sendDocumentInner, _MessageManager_sendMedia, _MessageManager_resolveFileId;
+var _MessageManager_instances, _MessageManager_c, _MessageManager_updatesToMessages, _MessageManager_constructReplyMarkup, _MessageManager_resolveSendAs, _MessageManager_constructReplyTo, _MessageManager_sendDocumentInner, _MessageManager_sendMedia, _MessageManager_resolveFileId, _MessageManager_sendReaction;
 import { contentType, debug } from "../0_deps.js";
 import { getRandomId, toUnixTimestamp, UNREACHABLE } from "../1_utilities.js";
-import { as, peerToChatId, types } from "../2_tl.js";
-import { assertMessageType, constructMessage as constructMessage_, FileID, FileType, messageEntityToTlObject, replyMarkupToTlObject } from "../3_types.js";
+import { as, getChannelChatId, peerToChatId, types } from "../2_tl.js";
+import { assertMessageType, constructMessage as constructMessage_, FileID, FileType, messageEntityToTlObject, reactionEqual, reactionToTlObject, replyMarkupToTlObject } from "../3_types.js";
 import { STICKER_SET_NAME_TTL } from "../4_constants.js";
 import { parseHtml } from "./0_html.js";
 import { getFileContents, isHttpUrl } from "./0_utilities.js";
@@ -22,9 +22,14 @@ export class MessageManager {
     constructor(c) {
         _MessageManager_instances.add(this);
         _MessageManager_c.set(this, void 0);
-        _MessageManager_usernameResolver.set(this, async (v) => {
-            const inputPeer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(v).then((v) => v[as](types.InputPeerUser));
-            return new types.InputUser(inputPeer);
+        Object.defineProperty(this, "usernameResolver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (v) => {
+                const inputPeer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(v).then((v) => v[as](types.InputPeerUser));
+                return new types.InputUser(inputPeer);
+            }
         });
         __classPrivateFieldSet(this, _MessageManager_c, c, "f");
     }
@@ -78,6 +83,26 @@ export class MessageManager {
         const messages = await this.getMessages(chatId, [messageId]);
         return messages[0] ?? null;
     }
+    parseText(text, params) {
+        const entities_ = params?.entities ?? [];
+        const parseMode = params?.parseMode ?? __classPrivateFieldGet(this, _MessageManager_c, "f").parseMode;
+        switch (parseMode) {
+            case null:
+                break;
+            case "HTML": {
+                const [newText, entitiesToPush] = parseHtml(text);
+                text = newText;
+                for (const entity of entitiesToPush) {
+                    entities_.push(entity);
+                }
+                break;
+            }
+            default:
+                UNREACHABLE();
+        }
+        const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v)) : undefined;
+        return [text, entities];
+    }
     async getStickerSetName(inputStickerSet, hash = 0) {
         const maybeStickerSetName = await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.getStickerSetName(inputStickerSet.id, inputStickerSet.access_hash);
         if (maybeStickerSetName != null && Date.now() - maybeStickerSetName[1].getTime() < STICKER_SET_NAME_TTL) {
@@ -152,7 +177,7 @@ export class MessageManager {
         return messages;
     }
     async sendMessage(chatId, text, params) {
-        const [message, entities] = __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_parseText).call(this, text, params);
+        const [message, entities] = this.parseText(text, params);
         const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
         const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
         const randomId = getRandomId();
@@ -383,7 +408,7 @@ export class MessageManager {
         const sendAs = params?.sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.sendAs) : undefined; // TODO: check default sendAs
         const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
         const explanation = params?.explanation;
-        const parseResult = explanation !== undefined ? __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_parseText).call(this, explanation, { parseMode: params?.explanationParseMode, entities: params?.explanationEntities }) : undefined;
+        const parseResult = explanation !== undefined ? this.parseText(explanation, { parseMode: params?.explanationParseMode, entities: params?.explanationEntities }) : undefined;
         const solution = parseResult === undefined ? undefined : parseResult[0];
         const solutionEntities = parseResult === undefined ? undefined : parseResult[1];
         const answers = options.map((v, i) => new types.PollAnswer({ option: new Uint8Array([i]), text: v }));
@@ -428,7 +453,7 @@ export class MessageManager {
         return message_;
     }
     async editMessageText(chatId, messageId, text, params) {
-        const [message, entities] = __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_parseText).call(this, text, params);
+        const [message, entities] = this.parseText(text, params);
         const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.editMessage({
             id: messageId,
             peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
@@ -475,27 +500,95 @@ export class MessageManager {
     async unpinMessages(chatId) {
         await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.unpinAllMessages({ peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId) });
     }
-}
-_MessageManager_c = new WeakMap(), _MessageManager_usernameResolver = new WeakMap(), _MessageManager_instances = new WeakSet(), _MessageManager_parseText = function _MessageManager_parseText(text, params) {
-    const entities_ = params?.entities ?? [];
-    const parseMode = params?.parseMode ?? __classPrivateFieldGet(this, _MessageManager_c, "f").parseMode;
-    switch (parseMode) {
-        case null:
-            break;
-        case "HTML": {
-            const [newText, entitiesToPush] = parseHtml(text);
-            text = newText;
-            for (const entity of entitiesToPush) {
-                entities_.push(entity);
+    async setAvailableReactions(chatId, availableReactions) {
+        // TODO: sync with storage
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.setChatAvailableReactions({
+            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+            available_reactions: availableReactions == "none" ? new types.ChatReactionsNone() : availableReactions == "all" ? new types.ChatReactionsAll() : Array.isArray(availableReactions) ? new types.ChatReactionsSome({ reactions: availableReactions.map((v) => v.type == "emoji" ? new types.ReactionEmoji({ emoticon: v.emoji }) : new types.ReactionCustomEmoji({ document_id: BigInt(v.id) })) }) : UNREACHABLE(),
+        });
+    }
+    async setReactions(chatId, messageId, reactions, params) {
+        await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendReaction).call(this, chatId, messageId, reactions, params);
+    }
+    async addReaction(chatId, messageId, reaction, params) {
+        const chosenReactions = await this.getMessage(chatId, messageId).then((v) => v?.reactions ?? []).then((v) => v.filter((v) => v.chosen));
+        for (const r of chosenReactions) {
+            if (reactionEqual(r.reaction, reaction)) {
+                return;
             }
-            break;
         }
-        default:
-            UNREACHABLE();
+        const reactions = [reaction, ...chosenReactions.map((v) => v.reaction)];
+        await this.setReactions(chatId, messageId, reactions, params);
+    }
+    async removeReaction(chatId, messageId, reaction) {
+        const chosenReactions = await this.getMessage(chatId, messageId).then((v) => v?.reactions ?? []).then((v) => v.filter((v) => v.chosen));
+        for (const r of chosenReactions) {
+            if (reactionEqual(r.reaction, reaction)) {
+                const reactions = chosenReactions.filter((v) => v != r).map((v) => v.reaction);
+                await this.setReactions(chatId, messageId, reactions);
+                break;
+            }
+        }
+    }
+    static canHandleUpdate(update) {
+        return update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditMessage || update instanceof types.UpdateEditChannelMessage || update instanceof types.UpdateDeleteMessages || update instanceof types.UpdateDeleteChannelMessages;
+    }
+    async handleUpdate(update) {
+        if (update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditMessage || update instanceof types.UpdateEditChannelMessage) {
+            if (update.message instanceof types.Message || update.message instanceof types.MessageService) {
+                const chatId = peerToChatId(update.message.peer_id);
+                await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.setMessage(chatId, update.message.id, update.message);
+                // promises.push(this.#chatListManager.reassignChatLastMessage(chatId));
+            }
+        }
+        if (update instanceof types.UpdateNewMessage ||
+            update instanceof types.UpdateNewChannelMessage ||
+            update instanceof types.UpdateEditMessage ||
+            update instanceof types.UpdateEditChannelMessage) {
+            if (!(update.message instanceof types.MessageEmpty)) {
+                const isOutgoing = update.message.out;
+                let shouldIgnore = isOutgoing ? (await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.getAccountType()) == "user" ? false : true : false;
+                if (__classPrivateFieldGet(this, _MessageManager_c, "f").ignoreOutgoing != null && isOutgoing) {
+                    shouldIgnore = __classPrivateFieldGet(this, _MessageManager_c, "f").ignoreOutgoing;
+                }
+                if (!shouldIgnore) {
+                    const message = await this.constructMessage(update.message);
+                    if (update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewChannelMessage) {
+                        return ({ message });
+                    }
+                    else {
+                        return ({ editedMessage: message });
+                    }
+                }
+            }
+        }
+        if (update instanceof types.UpdateDeleteMessages) {
+            const deletedMessages = new Array();
+            for (const messageId of update.messages) {
+                const chatId = await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.getMessageChat(messageId);
+                if (chatId) {
+                    deletedMessages.push({ chatId, messageId });
+                }
+            }
+            if (deletedMessages.length > 0) {
+                return { deletedMessages };
+            }
+        }
+        else if (update instanceof types.UpdateDeleteChannelMessages) {
+            const chatId = getChannelChatId(update.channel_id);
+            const deletedMessages = new Array();
+            for (const messageId of update.messages) {
+                const message = await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.getMessage(chatId, messageId);
+                if (message != null) {
+                    deletedMessages.push({ chatId, messageId });
+                }
+            }
+            return { deletedMessages };
+        }
+        return null;
     }
-    const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v)) : undefined;
-    return [text, entities];
-}, _MessageManager_updatesToMessages = async function _MessageManager_updatesToMessages(chatId, updates) {
+}
+_MessageManager_c = new WeakMap(), _MessageManager_instances = new WeakSet(), _MessageManager_updatesToMessages = async function _MessageManager_updatesToMessages(chatId, updates) {
     const messages = new Array();
     if (updates instanceof types.Updates) {
         for (const update of updates.updates) {
@@ -520,7 +613,7 @@ _MessageManager_c = new WeakMap(), _MessageManager_usernameResolver = new WeakMa
 }, _MessageManager_constructReplyMarkup = async function _MessageManager_constructReplyMarkup(params) {
     if (params?.replyMarkup) {
         await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertBot("replyMarkup");
-        return replyMarkupToTlObject(params.replyMarkup, __classPrivateFieldGet(this, _MessageManager_usernameResolver, "f").bind(this));
+        return replyMarkupToTlObject(params.replyMarkup, this.usernameResolver.bind(this));
     }
 }, _MessageManager_resolveSendAs = async function _MessageManager_resolveSendAs(params) {
     const sendAs = params?.sendAs;
@@ -580,7 +673,7 @@ _MessageManager_c = new WeakMap(), _MessageManager_usernameResolver = new WeakMa
     const sendAs = params?.sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.sendAs) : undefined; // TODO: check default sendAs
     const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
     const caption_ = params?.caption;
-    const parseResult = caption_ !== undefined ? __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_parseText).call(this, caption_, { parseMode: params?.parseMode, entities: params?.captionEntities }) : undefined;
+    const parseResult = caption_ !== undefined ? this.parseText(caption_, { parseMode: params?.parseMode, entities: params?.captionEntities }) : undefined;
     const caption = parseResult === undefined ? undefined : parseResult[0];
     const captionEntities = parseResult === undefined ? undefined : parseResult[1];
     const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.sendMedia({
@@ -618,4 +711,12 @@ _MessageManager_c = new WeakMap(), _MessageManager_usernameResolver = new WeakMa
         };
     }
     return null;
+}, _MessageManager_sendReaction = async function _MessageManager_sendReaction(chatId, messageId, reactions, params) {
+    await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.sendReaction({
+        peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+        msg_id: messageId,
+        reaction: reactions.map((v) => reactionToTlObject(v)),
+        big: params?.big ? true : undefined,
+        add_to_recent: params?.addToRecents ? true : undefined,
+    });
 };

package/esm/client/3_callback_query_manager.d.ts

@@ -0,0 +1,16 @@
+import { enums, types } from "../2_tl.js";
+import { Update } from "../3_types.js";
+import { AnswerCallbackQueryParams } from "./0_params.js";
+import { C as C_ } from "./0_types.js";
+import { MessageManager } from "./2_message_manager.js";
+type C = C_ & {
+    messageManager: MessageManager;
+};
+export declare class CallbackQueryManager {
+    #private;
+    constructor(c: C);
+    answerCallbackQuery(id: string, params?: AnswerCallbackQueryParams): Promise<void>;
+    static canHandleUpdate(update: enums.Update): update is types.UpdateBotCallbackQuery | types.UpdateInlineBotCallbackQuery;
+    handleUpdate(update: types.UpdateBotCallbackQuery | types.UpdateInlineBotCallbackQuery): Promise<Update>;
+}
+export {};

package/esm/client/3_callback_query_manager.js

@@ -0,0 +1,36 @@
+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 _CallbackQueryManager_c;
+import { types } from "../2_tl.js";
+import { constructCallbackQuery } from "../3_types.js";
+export class CallbackQueryManager {
+    constructor(c) {
+        _CallbackQueryManager_c.set(this, void 0);
+        __classPrivateFieldSet(this, _CallbackQueryManager_c, c, "f");
+    }
+    async answerCallbackQuery(id, params) {
+        await __classPrivateFieldGet(this, _CallbackQueryManager_c, "f").storage.assertBot("answerCallbackQuery");
+        await __classPrivateFieldGet(this, _CallbackQueryManager_c, "f").api.messages.setBotCallbackAnswer({
+            query_id: BigInt(id),
+            cache_time: params?.cacheTime ?? 0,
+            message: params?.text,
+            alert: params?.alert ? true : undefined,
+        });
+    }
+    static canHandleUpdate(update) {
+        return update instanceof types.UpdateBotCallbackQuery || update instanceof types.UpdateInlineBotCallbackQuery;
+    }
+    async handleUpdate(update) {
+        return { callbackQuery: await constructCallbackQuery(update, __classPrivateFieldGet(this, _CallbackQueryManager_c, "f").getEntity, __classPrivateFieldGet(this, _CallbackQueryManager_c, "f").messageManager.getMessageWithReply.bind(this)) };
+    }
+}
+_CallbackQueryManager_c = new WeakMap();

package/esm/client/3_chat_list_manager.d.ts

@@ -1,5 +1,5 @@
-import { types } from "../2_tl.js";
-import { Chat } from "../3_types.js";
+import { enums, types } from "../2_tl.js";
+import { Chat, ID } from "../3_types.js";
 import { C as C_ } from "./0_types.js";
 import { MessageManager } from "./2_message_manager.js";
 type C = C_ & {
@@ -9,13 +9,9 @@ export declare class ChatListManager {
     #private;
     constructor(c: C);
     reassignChatLastMessage(chatId: number, add?: boolean, sendUpdate?: boolean): Promise<() => Promise<void>>;
-    tryGetChatId(username: string): number | null;
-    getChatAnywhere(chatId: number): [Chat | undefined, number];
-    handelUpdateFolderPeers(update: types.UpdateFolderPeers): Promise<void>;
-    handleUpdatePinnedDialogs(update: types.UpdatePinnedDialogs): Promise<void>;
-    handleUpdateChannel(update: types.UpdateChannel): Promise<void>;
-    handleUpdateChat(update: types.UpdateChat): Promise<void>;
-    handleUpdateUser(update: types.UpdateUser | types.UpdateUserName): Promise<void>;
     getChats(from?: "archived" | "main", after?: Chat, limit?: number): Promise<Chat[]>;
+    static canHandleUpdate(update: enums.Update): update is types.UpdateNewMessage | types.UpdateNewChannelMessage | types.UpdatePinnedDialogs | types.UpdateFolderPeers | types.UpdateChannel | types.UpdateChat | types.UpdateUser | types.UpdateUserName;
+    handleUpdate(update: types.UpdateNewMessage | types.UpdateNewChannelMessage | types.UpdatePinnedDialogs | types.UpdateFolderPeers | types.UpdateChannel | types.UpdateChat | types.UpdateUser | types.UpdateUserName): Promise<void>;
+    getChat(chatId: ID): Promise<Chat>;
 }
 export {};