@mtkruto/node 0.1.141 → 0.1.143

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,248 @@ 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;
+            }
+        }
+        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));
             }
-            break;
         }
-        default:
+        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;
+    }
+    async sendChatAction(chatId, action, params) {
+        let action_;
+        switch (action) {
+            case "type":
+                action_ = new types.SendMessageTypingAction();
+                break;
+            case "uploadPhoto":
+                action_ = new types.SendMessageUploadPhotoAction({ progress: 0 });
+                break;
+            case "recordVideo":
+                action_ = new types.SendMessageRecordVideoAction();
+                break;
+            case "uploadVideo":
+                action_ = new types.SendMessageRecordVideoAction();
+                break;
+            case "recordVoice":
+                action_ = new types.SendMessageRecordAudioAction();
+                break;
+            case "uploadAudio":
+                action_ = new types.SendMessageUploadAudioAction({ progress: 0 });
+                break;
+            case "uploadDocument":
+                action_ = new types.SendMessageUploadDocumentAction({ progress: 0 });
+                break;
+            case "chooseSticker":
+                action_ = new types.SendMessageChooseStickerAction();
+                break;
+            case "findLocation":
+                action_ = new types.SendMessageGeoLocationAction();
+                break;
+            case "recordVideoNote":
+                action_ = new types.SendMessageRecordRoundAction();
+                break;
+            case "uploadVideoNote":
+                action_ = new types.SendMessageUploadRoundAction({ progress: 0 });
+                break;
+            default:
+                throw new Error("Invalid chat action: " + action);
+        }
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.setTyping({ peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId), action: action_, top_msg_id: params?.messageThreadId });
+    }
+    async deleteChatPhoto(chatId) {
+        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(peer instanceof types.InputPeerChannel) && !(peer instanceof types.InputPeerChat)) {
+            UNREACHABLE();
+        }
+        if (peer instanceof types.InputPeerChannel) {
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.editPhoto({ channel: new types.InputChannel(peer), photo: new types.InputChatPhotoEmpty() });
+        }
+        else if (peer instanceof types.InputPeerChat) {
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.editChatPhoto({ chat_id: peer.chat_id, photo: new types.InputChatPhotoEmpty() });
+        }
+    }
+    async setChatPhoto(chatId, photo, params) {
+        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(peer instanceof types.InputPeerChannel) && !(peer instanceof types.InputPeerChat)) {
             UNREACHABLE();
+        }
+        const [contents, fileName] = await getFileContents(photo);
+        const file = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(contents, { fileName: params?.fileName ?? fileName, chunkSize: params?.chunkSize, signal: params?.signal });
+        const photo_ = new types.InputChatUploadedPhoto({ file });
+        if (peer instanceof types.InputPeerChannel) {
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.editPhoto({ channel: new types.InputChannel(peer), photo: photo_ });
+        }
+        else if (peer instanceof types.InputPeerChat) {
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.editChatPhoto({ chat_id: peer.chat_id, photo: photo_ });
+        }
+    }
+    async banChatMember(chatId, memberId, params) {
+        const chat = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(chat instanceof types.InputPeerChannel) && !(chat instanceof types.InputPeerChat)) {
+            throw new Error("Invalid chat ID");
+        }
+        const member = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
+        if (chat instanceof types.InputPeerChannel) {
+            if (params?.deleteMessages) {
+                try {
+                    await this.deleteChatMemberMessages(chatId, memberId);
+                }
+                catch {
+                    //
+                }
+            }
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.editBanned({
+                channel: new types.InputChannel(chat),
+                participant: member,
+                banned_rights: new types.ChatBannedRights({
+                    until_date: params?.untilDate ? toUnixTimestamp(params.untilDate) : 0,
+                    view_messages: true,
+                    send_messages: true,
+                    send_media: true,
+                    send_stickers: true,
+                    send_gifs: true,
+                    send_games: true,
+                    send_inline: true,
+                    embed_links: true,
+                }),
+            });
+        }
+        else if (chat instanceof types.InputPeerChat) {
+            if (!(member instanceof types.InputPeerUser)) {
+                throw new Error("Invalid user ID");
+            }
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.deleteChatUser({
+                chat_id: chat.chat_id,
+                user_id: new types.InputUser(member),
+                revoke_history: params?.deleteMessages ? true : undefined,
+            });
+        }
+    }
+    async unbanChatMember(chatId, memberId) {
+        const chat = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(chat instanceof types.InputPeerChannel)) {
+            throw new Error("Invalid chat ID");
+        }
+        const member = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.editBanned({
+            channel: new types.InputChannel(chat),
+            participant: member,
+            banned_rights: new types.ChatBannedRights({ until_date: 0 }),
+        });
     }
-    const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v)) : undefined;
-    return [text, entities];
-}, _MessageManager_updatesToMessages = async function _MessageManager_updatesToMessages(chatId, updates) {
+    async setChatMemberRights(chatId, memberId, params) {
+        const chat = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(chat instanceof types.InputPeerChannel)) {
+            throw new Error("Invalid chat ID");
+        }
+        const member = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.editBanned({
+            channel: new types.InputChannel(chat),
+            participant: member,
+            banned_rights: new types.ChatBannedRights({
+                until_date: params?.untilDate ? toUnixTimestamp(params.untilDate) : 0,
+                send_messages: params?.rights?.canSendMessages ? true : undefined,
+                send_audios: params?.rights?.canSendAudio ? true : undefined,
+                send_docs: params?.rights?.canSendDocuments ? true : undefined,
+                send_photos: params?.rights?.canSendPhotos ? true : undefined,
+                send_videos: params?.rights?.canSendVideos ? true : undefined,
+                send_roundvideos: params?.rights?.canSendVideoNotes ? true : undefined,
+                send_voices: params?.rights?.canSendVoice ? true : undefined,
+                send_polls: params?.rights?.canSendPolls ? true : undefined,
+                send_stickers: params?.rights?.canSendStickers ? true : undefined,
+                send_gifs: params?.rights?.canSendAnimations ? true : undefined,
+                send_games: params?.rights?.canSendGames ? true : undefined,
+                send_inline: params?.rights?.canSendInlineBotResults ? true : undefined,
+                embed_links: params?.rights?.canAddWebPagePreviews ? true : undefined,
+                change_info: params?.rights?.canChangeInfo ? true : undefined,
+                invite_users: params?.rights?.canInviteUsers ? true : undefined,
+                pin_messages: params?.rights?.canPinMessages ? true : undefined,
+                manage_topics: params?.rights?.canManageTopics ? true : undefined,
+            }),
+        });
+    }
+}
+_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 +766,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 +826,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 +864,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(__classPrivateFieldGet(this, _CallbackQueryManager_c, "f").messageManager)) };
+    }
+}
+_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 {};