@mtkruto/browser 0.6.1 → 0.119.1

package/esm/client/3_message_manager.js

@@ -1,6 +1,6 @@
 /**
  * MTKruto - Cross-runtime JavaScript library for building Telegram clients
- * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ * Copyright (C) 2023-2026 Roj <https://roj.im/>
  *
  * This file is part of MTKruto.
  *
@@ -17,30 +17,24 @@
  * 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/>.
  */
-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 _MessageManager_instances, _MessageManager_c, _MessageManager_LresolveFileId, _MessageManager_checkParams, _MessageManager_updatesToMessages, _MessageManager_constructReplyMarkup, _MessageManager_resolveSendAs, _MessageManager_constructReplyTo, _MessageManager_sendDocumentInner, _MessageManager_sendMedia, _MessageManager_resolveInputMediaInner, _MessageManager_resolveInputMedia, _MessageManager_sendReaction, _MessageManager_toggleJoinRequests;
-import { contentType, unreachable } from "../0_deps.js";
+import { contentType, equals, startsWith, unreachable } from "../0_deps.js";
 import { InputError } from "../0_errors.js";
-import { getLogger, getRandomId, toUnixTimestamp } from "../1_utilities.js";
-import { as, getChannelChatId, is, isOneOf, peerToChatId } from "../2_tl.js";
-import { constructChatMemberUpdated, constructFailedInvitation, constructInviteLink, constructJoinRequest, deserializeFileId, selfDestructOptionToInt } from "../3_types.js";
-import { assertMessageType, chatMemberRightsToTlObject, constructMessage as constructMessage_, deserializeInlineMessageId, FileType, messageEntityToTlObject, reactionEqual, reactionToTlObject, replyMarkupToTlObject } from "../3_types.js";
-import { messageSearchFilterToTlObject } from "../types/0_message_search_filter.js";
+import { encodeText, fromUnixTimestamp, getLogger, getRandomId } from "../1_utilities.js";
+import { Api } from "../2_tl.js";
+import { PackShortNameInvalid } from "../3_errors.js";
+import { getDc } from "../3_transport.js";
+import { constructMessageReactionList, constructMiniAppInfo, constructSavedChats, constructStickerSet, constructVoiceTranscription, deserializeFileId, isMessageType, messageSearchFilterToTlObject, selfDestructOptionToInt } from "../3_types.js";
+import { assertMessageType, constructMessage as constructMessage_, deserializeInlineMessageId, FileType, messageEntityToTlObject, reactionEqual, reactionToTlObject, replyMarkupToTlObject } from "../3_types.js";
 import { parseHtml } from "./0_html.js";
 import { parseMarkdown } from "./0_markdown.js";
-import { canBeInputChannel, canBeInputUser, checkArray, checkMessageId, isHttpUrl, toInputChannel, toInputUser } from "./0_utilities.js";
+import { canBeInputChannel, checkArray, checkMessageId, getLimit, getUsername, isHttpUrl, toInputChannel } from "./0_utilities.js";
 const FALLBACK_MIME_TYPE = "application/octet-stream";
 const STICKER_MIME_TYPES = ["image/webp", "video/webm", "application/x-tgsticker"];
+const ANIMATION_MIME_TYPES = ["image/gif", "video/mp4"];
+const AUDIO_MIME_TYPES = ["audio/mpeg", "audio/mp4"];
+const VOICE_MIME_TYPES = ["audio/ogg", "audio/mpeg", "audio/mp4"];
+const VIDEO_MIME_TYPES = ["video/mp4"];
+const VIDEO_NOTE_MIME_TYPES = ["video/mp4"];
 const messageManagerUpdates = [
     "updateNewMessage",
     "updateNewChannelMessage",
@@ -53,37 +47,25 @@ const messageManagerUpdates = [
     "updateDeleteMessages",
     "updateDeleteChannelMessages",
     "updateDeleteScheduledMessages",
-    "updateChannelParticipant",
-    "updateChatParticipant",
-    "updateBotChatInviteRequester",
+    "updateTranscribedAudio",
 ];
 export class MessageManager {
+    #c;
+    #LresolveFileId;
     constructor(c) {
-        _MessageManager_instances.add(this);
-        _MessageManager_c.set(this, void 0);
-        _MessageManager_LresolveFileId.set(this, void 0);
-        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) => as("inputPeerUser", v));
-                return { ...inputPeer, _: "inputUser" };
-            }
-        });
-        __classPrivateFieldSet(this, _MessageManager_c, c, "f");
+        this.#c = c;
         const L = getLogger("MessageManager").client(c.id);
-        __classPrivateFieldSet(this, _MessageManager_LresolveFileId, L.branch("resolveFileId"), "f");
+        this.#LresolveFileId = L.branch("resolveFileId");
     }
     async getMessages(chatId, messageIds) {
         checkArray(messageIds, checkMessageId);
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        const peer = await this.#c.getInputPeer(chatId);
         let messages_ = new Array();
-        const chatId_ = peerToChatId(peer);
+        const chatId_ = await this.#c.getInputPeerChatId(peer);
         let shouldFetch = false;
         for (const messageId of messageIds) {
-            const message = await __classPrivateFieldGet(this, _MessageManager_c, "f").messageStorage.getMessage(chatId_, messageId);
-            if (message == null) {
+            const message = await this.#c.messageStorage.getMessage(chatId_, messageId);
+            if (message === null) {
                 messages_ = [];
                 shouldFetch = true;
                 break;
@@ -94,28 +76,30 @@ export class MessageManager {
         }
         if (shouldFetch) {
             if (canBeInputChannel(peer)) {
-                messages_ = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.getMessages", channel: toInputChannel(peer), id: messageIds.map((v) => ({ _: "inputMessageID", id: v })) }).then((v) => as("messages.channelMessages", v).messages);
+                messages_ = await this.#c.invoke({ _: "channels.getMessages", channel: toInputChannel(peer), id: messageIds.map((v) => ({ _: "inputMessageID", id: v })) }).then((v) => Api.as("messages.channelMessages", v).messages);
             }
             else {
-                messages_ = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+                messages_ = await this.#c.invoke({
                     _: "messages.getMessages",
                     id: messageIds.map((v) => ({ _: "inputMessageID", id: v })),
-                }).then((v) => as("messages.messages", v).messages);
+                }).then((v) => Api.as("messages.messages", v).messages);
             }
         }
         const messages = new Array();
         for (const message_ of messages_) {
-            if (is("messageEmpty", message_)) {
+            if (Api.is("messageEmpty", message_)) {
                 continue;
             }
             const message = await this.constructMessage(message_);
-            messages.push(message);
+            if (message.chat.id === chatId_) {
+                messages.push(message);
+            }
         }
         return messages;
     }
     async getMessageWithReply(chatId, messageId) {
         const message = await this.getMessage(chatId, messageId);
-        if (message != null && message.replyToMessageId) {
+        if (message !== null && message.replyToMessageId) {
             message.replyToMessage = await this.getMessage(chatId, message.replyToMessageId) ?? undefined;
         }
         return message;
@@ -158,38 +142,107 @@ export class MessageManager {
         }
         return [text, entities];
     }
-    async parseText(text_, params) {
-        const [text, entities_] = MessageManager.parseText(text_, params?.entities ?? [], params?.parseMode ?? __classPrivateFieldGet(this, _MessageManager_c, "f").parseMode);
-        const entities = entities_?.length > 0 ? await Promise.all(entities_.map((v) => messageEntityToTlObject(v, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity))) : undefined;
+    #checkParams(params) {
+        if (params && "replyMarkup" in params && params.replyMarkup !== undefined) {
+            this.#c.storage.assertBot("replyMarkup");
+        }
+        if (params && "businessConnectionId" in params && params.businessConnectionId !== undefined) {
+            this.#c.storage.assertBot("businessConnectionId");
+        }
+        if (params && "sendAs" in params && params.sendAs !== undefined) {
+            this.#c.storage.assertUser("sendAs");
+        }
+        if (params && "sendAt" in params && params.sendAt !== undefined) {
+            this.#c.storage.assertUser("businessConsendAtnectionId");
+        }
+    }
+    parseText(text_, params) {
+        const [text, entities_] = MessageManager.parseText(text_, params?.entities ?? [], params?.parseMode ?? this.#c.parseMode);
+        const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v, this.#c.getPeer)) : undefined;
         return [text, entities];
     }
+    async updatesToMessages(chatId, updates, businessConnectionId) {
+        const messages = new Array();
+        if (Api.is("updates", updates)) {
+            for (const update of updates.updates) {
+                if ("message" in update && Api.is("messageEmpty", update.message)) {
+                    continue;
+                }
+                if (Api.is("updateNewMessage", update) || Api.is("updateEditMessage", update) || Api.is("updateNewScheduledMessage", update)) {
+                    const message = await this.constructMessage(update.message);
+                    if (Api.is("updateNewScheduledMessage", update)) {
+                        message.isScheduled = true;
+                    }
+                    messages.push(message);
+                }
+                else if (Api.is("updateNewChannelMessage", update) || Api.is("updateEditChannelMessage", update)) {
+                    messages.push(await this.constructMessage(update.message));
+                }
+                else if (Api.is("updateBotNewBusinessMessage", update)) {
+                    messages.push(await this.constructMessage(update.message, false, { connectionId: businessConnectionId ?? update.connection_id, replyToMessage: update.reply_to_message }));
+                }
+                else if (Api.is("updateBotEditBusinessMessage", update)) {
+                    messages.push(await this.constructMessage(update.message, false, { connectionId: businessConnectionId ?? update.connection_id, replyToMessage: update.reply_to_message }));
+                }
+            }
+        }
+        else if (Api.is("updateShortSentMessage", updates)) {
+            const message = await this.getMessage(chatId, updates.id);
+            if (message !== null) {
+                messages.push(message);
+            }
+        }
+        return messages;
+    }
     async constructMessage(message_, r, business) {
-        return await constructMessage_(message_, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity, this.getMessage.bind(this), __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.getStickerSetName.bind(__classPrivateFieldGet(this, _MessageManager_c, "f").fileManager), r, business);
+        const mediaPoll = "media" in message_ && Api.is("messageMediaPoll", message_.media) ? message_.media : null;
+        const pollId = mediaPoll?.poll.id;
+        let poll = null;
+        let pollResults = null;
+        if (pollId) {
+            [poll, pollResults] = await Promise.all([this.#c.messageStorage.getPoll(pollId), this.#c.messageStorage.getPollResults(pollId)]);
+        }
+        const message = await constructMessage_(message_, this.#c.getPeer, this.getMessage.bind(this), this.#c.fileManager.getStickerSetName.bind(this.#c.fileManager), r, business, poll ?? undefined, pollResults ?? undefined);
+        if (!poll && mediaPoll) {
+            await this.#c.messageStorage.setPoll(mediaPoll.poll.id, mediaPoll.poll);
+        }
+        if (!pollResults && mediaPoll) {
+            await this.#c.messageStorage.setPollResults(mediaPoll.poll.id, mediaPoll.results);
+        }
+        return message;
     }
     async forwardMessages(from, to, messageIds, params) {
         checkArray(messageIds, checkMessageId);
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.forwardMessages", from_peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(from), to_peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(to), id: messageIds, random_id: messageIds.map(() => getRandomId()), silent: params?.disableNotification || undefined, top_msg_id: params?.messageThreadId, noforwards: params?.disableNotification || undefined, send_as: params?.sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.sendAs) : undefined, drop_author: params?.dropSenderName || undefined, drop_media_captions: params?.dropCaption || undefined });
-        return await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, to, result);
+        const result = await this.#c.invoke({ _: "messages.forwardMessages", from_peer: await this.#c.getInputPeer(from), to_peer: await this.#c.getInputPeer(to), id: messageIds, random_id: messageIds.map(() => getRandomId()), silent: params?.isSilent || undefined, top_msg_id: params?.messageThreadId, noforwards: params?.isSilent || undefined, send_as: params?.sendAs ? await this.#c.getInputPeer(params.sendAs) : undefined, drop_author: params?.dropSenderName || undefined, drop_media_captions: params?.dropCaption || undefined });
+        return await this.updatesToMessages(to, result);
     }
     async getHistory(chatId, params) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("getHistory");
-        let limit = params?.limit ?? 100;
-        if (limit <= 0) {
-            limit = 1;
-        }
-        else if (limit > 100) {
-            limit = 100;
-        }
-        let offsetId = params?.fromMessageId ?? 0;
+        this.#c.storage.assertUser("getHistory");
+        const limit = getLimit(params?.limit);
+        let offsetId = params?.offsetId ?? 0;
         if (offsetId < 0) {
             offsetId = 0;
         }
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        let offsetDate = params?.offsetDate ?? 0;
+        if (offsetDate < 0) {
+            offsetDate = 0;
+        }
+        const peer = await this.#c.getInputPeer(chatId);
         const messages = new Array();
         if (messages.length > 0) {
             offsetId = messages[messages.length - 1].id; // TODO: track id of oldest message and don't send requests for it
         }
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.getHistory", peer: peer, offset_id: offsetId, offset_date: 0, add_offset: 0, limit, max_id: 0, min_id: 0, hash: 0n });
+        const result = await this.#c.invoke({
+            _: "messages.getHistory",
+            peer: peer,
+            offset_id: offsetId,
+            offset_date: offsetDate,
+            add_offset: params?.addOffset ?? 0,
+            limit,
+            max_id: 0,
+            min_id: 0,
+            hash: 0n,
+        });
         if (!("messages" in result)) {
             unreachable();
         }
@@ -199,48 +252,76 @@ export class MessageManager {
         }
         return messages;
     }
+    usernameResolver = async (v) => {
+        const inputPeer = await this.#c.getInputPeer(v).then((v) => Api.as("inputPeerUser", v));
+        return { ...inputPeer, _: "inputUser" };
+    };
+    async #constructReplyMarkup(params) {
+        if (params?.replyMarkup) {
+            this.#c.storage.assertBot("replyMarkup");
+            return await replyMarkupToTlObject(params.replyMarkup, this.usernameResolver.bind(this));
+        }
+    }
+    async #resolveSendAs(params) {
+        const sendAs = params?.sendAs;
+        if (sendAs !== undefined) {
+            this.#c.storage.assertUser("sendAs");
+            return sendAs ? await this.#c.getInputPeer(sendAs) : undefined;
+        }
+    }
+    async sendMessageDraft(chatId, draftId, text, params) {
+        this.#c.storage.assertBot("sendMessageDraft");
+        const [message, entities] = this.parseText(text, params);
+        const peer = await this.#c.getInputPeer(chatId);
+        await this.#c.invoke({
+            _: "messages.setTyping",
+            peer,
+            action: { _: "sendMessageTextDraftAction", random_id: BigInt(draftId), text: { _: "textWithEntities", text: message, entities: entities ?? [] } },
+            top_msg_id: params?.messageThreadId,
+        });
+    }
     async sendMessage(chatId, text, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const [message, entities] = await 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);
+        this.#checkParams(params);
+        const [message, entities] = this.parseText(text, params);
+        const replyMarkup = await this.#constructReplyMarkup(params);
+        const peer = await this.#c.getInputPeer(chatId);
         const randomId = getRandomId();
-        const noWebpage = params?.linkPreview?.disable ? true : undefined;
-        const invertMedia = params?.linkPreview?.aboveText ? true : undefined;
-        const silent = params?.disableNotification ? true : undefined;
-        const noforwards = params?.protectContent ? true : undefined;
-        const sendAs = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_resolveSendAs).call(this, params);
+        const noWebpage = params?.linkPreview?.isDisabled ? true : undefined;
+        const invertMedia = params?.linkPreview?.isAboveText ? true : undefined;
+        const silent = params?.isSilent ? true : undefined;
+        const noforwards = params?.isContentProtected ? true : undefined;
+        const sendAs = await this.#resolveSendAs(params);
         const effect = params?.effectId ? BigInt(params.effectId) : undefined;
-        const schedule_date = params?.sendAt ? toUnixTimestamp(params.sendAt) : undefined;
-        const allow_paid_floodskip = params?.paidBroadcast ? true : undefined;
+        const schedule_date = params?.sendAt;
+        const allow_paid_floodskip = params?.isPaidBroadcast ? true : undefined;
         let result;
         if (!noWebpage && params?.linkPreview?.url) {
-            result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+            result = await this.#c.invoke({
                 _: "messages.sendMedia",
                 peer,
                 random_id: randomId,
-                media: ({
+                media: {
                     _: "inputMediaWebPage",
                     url: params.linkPreview.url,
-                    force_large_media: params.linkPreview.largeMedia ? true : undefined,
-                    force_small_media: params.linkPreview.smallMedia ? true : undefined,
+                    force_large_media: params.linkPreview.mediaSize === "large" ? true : undefined,
+                    force_small_media: params.linkPreview.mediaSize === "small" ? true : undefined,
                     optional: message.length ? undefined : true,
-                }),
+                },
                 message,
                 invert_media: invertMedia,
                 silent,
                 noforwards,
-                reply_to: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+                reply_to: await this.#constructReplyTo(params),
                 send_as: sendAs,
                 entities,
                 reply_markup: replyMarkup,
                 effect,
                 schedule_date,
                 allow_paid_floodskip,
-            }, params?.businessConnectionId);
+            }, { businessConnectionId: params?.businessConnectionId });
         }
         else {
-            result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+            result = await this.#c.invoke({
                 _: "messages.sendMessage",
                 peer,
                 random_id: randomId,
@@ -249,233 +330,378 @@ export class MessageManager {
                 invert_media: invertMedia,
                 silent,
                 noforwards,
-                reply_to: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+                reply_to: await this.#constructReplyTo(params),
                 send_as: sendAs,
                 entities,
                 reply_markup: replyMarkup,
                 effect,
                 schedule_date,
                 allow_paid_floodskip,
-            }, params?.businessConnectionId);
+            }, { businessConnectionId: params?.businessConnectionId });
         }
-        const message_ = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result, params?.businessConnectionId))[0];
+        const message_ = (await this.updatesToMessages(chatId, result, params?.businessConnectionId))[0];
         return assertMessageType(message_, "text");
     }
+    async #constructReplyTo(params) {
+        const topMsgId = params?.messageThreadId;
+        if (!params?.replyTo) {
+            if (topMsgId) {
+                return { _: "inputReplyToMessage", reply_to_msg_id: topMsgId, top_msg_id: topMsgId };
+            }
+            else {
+                return undefined;
+            }
+        }
+        if ("messageId" in params.replyTo) {
+            return { _: "inputReplyToMessage", reply_to_msg_id: params.replyTo.messageId, top_msg_id: topMsgId, quote_text: params.replyTo.quote?.text, quote_entities: await Promise.all(params.replyTo.quote?.entities.map((v) => messageEntityToTlObject(v, this.#c.getPeer)) ?? []), quote_offset: params.replyTo.quote?.offset };
+        }
+        else {
+            return { _: "inputReplyToStory", peer: await this.#c.getInputPeer(params.replyTo.chatId), story_id: params.replyTo.storyId };
+        }
+    }
     async sendVenue(chatId, latitude, longitude, title, address, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        this.#checkParams(params);
+        const peer = await this.#c.getInputPeer(chatId);
         const randomId = getRandomId();
-        const silent = params?.disableNotification ? true : undefined;
-        const noforwards = params?.protectContent ? true : undefined;
-        const sendAs = params?.sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.sendAs) : undefined;
-        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+        const silent = params?.isSilent ? true : undefined;
+        const noforwards = params?.isContentProtected ? true : undefined;
+        const sendAs = params?.sendAs ? await this.#c.getInputPeer(params.sendAs) : undefined;
+        const replyMarkup = await this.#constructReplyMarkup(params);
+        const result = await this.#c.invoke({
             _: "messages.sendMedia",
             peer,
             random_id: randomId,
             silent,
             noforwards,
-            reply_to: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            reply_to: await this.#constructReplyTo(params),
             send_as: sendAs,
             reply_markup: replyMarkup,
-            media: ({
+            media: {
                 _: "inputMediaVenue",
-                geo_point: ({
+                geo_point: {
                     _: "inputGeoPoint",
                     lat: latitude,
                     long: longitude,
-                }),
+                },
                 title,
                 address,
                 venue_id: params?.foursquareId ?? "",
                 venue_type: params?.foursquareType ?? "",
                 provider: "foursquare",
-            }),
+            },
             message: "",
             effect: params?.effectId ? BigInt(params.effectId) : undefined,
-            schedule_date: params?.sendAt ? toUnixTimestamp(params.sendAt) : undefined,
-            allow_paid_floodskip: params?.paidBroadcast ? true : undefined,
-        }, params?.businessConnectionId);
-        const message = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result, params?.businessConnectionId))[0];
+            schedule_date: params?.sendAt,
+            allow_paid_floodskip: params?.isPaidBroadcast ? true : undefined,
+        }, { businessConnectionId: params?.businessConnectionId });
+        const message = (await this.updatesToMessages(chatId, result, params?.businessConnectionId))[0];
         return assertMessageType(message, "venue");
     }
     async sendContact(chatId, firstName, number, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        this.#checkParams(params);
+        const peer = await this.#c.getInputPeer(chatId);
         const randomId = getRandomId();
-        const silent = params?.disableNotification ? true : undefined;
-        const noforwards = params?.protectContent ? true : undefined;
-        const sendAs = params?.sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.sendAs) : undefined;
-        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+        const silent = params?.isSilent ? true : undefined;
+        const noforwards = params?.isContentProtected ? true : undefined;
+        const sendAs = params?.sendAs ? await this.#c.getInputPeer(params.sendAs) : undefined;
+        const replyMarkup = await this.#constructReplyMarkup(params);
+        const result = await this.#c.invoke({
             _: "messages.sendMedia",
             peer,
             random_id: randomId,
             silent,
             noforwards,
-            reply_to: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            reply_to: await this.#constructReplyTo(params),
             send_as: sendAs,
             reply_markup: replyMarkup,
-            media: ({
+            media: {
                 _: "inputMediaContact",
                 phone_number: number,
                 first_name: firstName,
                 last_name: params?.lastName ?? "",
                 vcard: params?.vcard ?? "",
-            }),
+            },
             message: "",
             effect: params?.effectId ? BigInt(params.effectId) : undefined,
-            schedule_date: params?.sendAt ? toUnixTimestamp(params.sendAt) : undefined,
-            allow_paid_floodskip: params?.paidBroadcast ? true : undefined,
-        }, params?.businessConnectionId);
-        const message = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result, params?.businessConnectionId))[0];
+            schedule_date: params?.sendAt,
+            allow_paid_floodskip: params?.isPaidBroadcast ? true : undefined,
+        }, { businessConnectionId: params?.businessConnectionId });
+        const message = (await this.updatesToMessages(chatId, result, params?.businessConnectionId))[0];
         return assertMessageType(message, "contact");
     }
     async sendDice(chatId, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        this.#checkParams(params);
+        const peer = await this.#c.getInputPeer(chatId);
         const randomId = getRandomId();
-        const silent = params?.disableNotification ? true : undefined;
-        const noforwards = params?.protectContent ? true : undefined;
-        const sendAs = params?.sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.sendAs) : undefined;
-        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+        const silent = params?.isSilent ? true : undefined;
+        const noforwards = params?.isContentProtected ? true : undefined;
+        const sendAs = params?.sendAs ? await this.#c.getInputPeer(params.sendAs) : undefined;
+        const replyMarkup = await this.#constructReplyMarkup(params);
+        const result = await this.#c.invoke({
             _: "messages.sendMedia",
             peer,
             random_id: randomId,
             silent,
             noforwards,
-            reply_to: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            reply_to: await this.#constructReplyTo(params),
             send_as: sendAs,
             reply_markup: replyMarkup,
-            media: ({
+            media: {
                 _: "inputMediaDice",
                 emoticon: params?.emoji ?? "🎲",
-            }),
+            },
             message: "",
             effect: params?.effectId ? BigInt(params.effectId) : undefined,
-            schedule_date: params?.sendAt ? toUnixTimestamp(params.sendAt) : undefined,
-            allow_paid_floodskip: params?.paidBroadcast ? true : undefined,
-        }, params?.businessConnectionId);
-        const message = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result, params?.businessConnectionId))[0];
+            schedule_date: params?.sendAt,
+            allow_paid_floodskip: params?.isPaidBroadcast ? true : undefined,
+        }, { businessConnectionId: params?.businessConnectionId });
+        const message = (await this.updatesToMessages(chatId, result, params?.businessConnectionId))[0];
         return assertMessageType(message, "dice");
     }
     async sendLocation(chatId, latitude, longitude, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        this.#checkParams(params);
+        const peer = await this.#c.getInputPeer(chatId);
         const randomId = getRandomId();
-        const silent = params?.disableNotification ? true : undefined;
-        const noforwards = params?.protectContent ? true : undefined;
-        const sendAs = params?.sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.sendAs) : undefined;
-        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+        const silent = params?.isSilent ? true : undefined;
+        const noforwards = params?.isContentProtected ? true : undefined;
+        const sendAs = params?.sendAs ? await this.#c.getInputPeer(params.sendAs) : undefined;
+        const replyMarkup = await this.#constructReplyMarkup(params);
+        const result = await this.#c.invoke({
             _: "messages.sendMedia",
             peer,
             random_id: randomId,
             silent,
             noforwards,
-            reply_to: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            reply_to: await this.#constructReplyTo(params),
             send_as: sendAs,
             reply_markup: replyMarkup,
             media: params?.livePeriod !== undefined
                 ? ({
                     _: "inputMediaGeoLive",
-                    geo_point: ({
+                    geo_point: {
                         _: "inputGeoPoint",
                         lat: latitude,
                         long: longitude,
                         accuracy_radius: params?.horizontalAccuracy,
-                    }),
+                    },
                     heading: params?.heading,
                     period: params.livePeriod,
                     proximity_notification_radius: params?.proximityAlertRadius,
                 })
                 : ({
                     _: "inputMediaGeoPoint",
-                    geo_point: ({
+                    geo_point: {
                         _: "inputGeoPoint",
                         lat: latitude,
                         long: longitude,
                         accuracy_radius: params?.horizontalAccuracy,
-                    }),
+                    },
                 }),
             message: "",
             effect: params?.effectId ? BigInt(params.effectId) : undefined,
-            schedule_date: params?.sendAt ? toUnixTimestamp(params.sendAt) : undefined,
-            allow_paid_floodskip: params?.paidBroadcast ? true : undefined,
-        }, params?.businessConnectionId);
-        const message = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result, params?.businessConnectionId))[0];
+            schedule_date: params?.sendAt,
+            allow_paid_floodskip: params?.isPaidBroadcast ? true : undefined,
+        }, { businessConnectionId: params?.businessConnectionId });
+        const message = (await this.updatesToMessages(chatId, result, params?.businessConnectionId))[0];
         return assertMessageType(message, "location");
     }
     async sendVideoNote(chatId, audio, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, audio, params, FileType.VideoNote, [
+        this.#checkParams(params);
+        const message = await this.#sendDocumentInner(chatId, audio, params, FileType.VideoNote, [
             { _: "documentAttributeVideo", round_message: true, w: params?.length ?? 0, h: params?.length ?? 0, duration: params?.duration ?? 0 },
-        ], false);
+        ], false, VIDEO_NOTE_MIME_TYPES, () => "video_note.mp4");
         return assertMessageType(message, "videoNote");
     }
     async sendAudio(chatId, audio, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, audio, params, FileType.Audio, [
+        this.#checkParams(params);
+        const message = await this.#sendDocumentInner(chatId, audio, params, FileType.Audio, [
             { _: "documentAttributeAudio", duration: params?.duration ?? 0, performer: params?.performer, title: params?.title },
-        ]);
+        ], undefined, AUDIO_MIME_TYPES, (firstPart) => {
+            if (MessageManager.#isM4a(firstPart)) {
+                return "audio.m4a";
+            }
+            else {
+                return "audio.mp3";
+            }
+        });
         return assertMessageType(message, "audio");
     }
+    static #isM4a(firstPart) {
+        return firstPart.length >= 10 && startsWith(firstPart.subarray(4), new Uint8Array([0x66, 0x74, 0x79, 0x70, 0x4D, 0x34]));
+    }
     async sendVoice(chatId, voice, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, voice, params, FileType.VoiceNote, [
+        this.#checkParams(params);
+        const message = await this.#sendDocumentInner(chatId, voice, params, FileType.VoiceNote, [
             { _: "documentAttributeAudio", voice: true, duration: params?.duration ?? 0 },
-        ]);
+        ], undefined, VOICE_MIME_TYPES, (firstPart) => {
+            if (startsWith(firstPart, new Uint8Array([0x4F, 0x67, 0x67]))) {
+                return "voice.ogg";
+            }
+            else if (MessageManager.#isM4a(firstPart)) {
+                return "voice.m4a";
+            }
+            else {
+                return "voice.mp3";
+            }
+        });
         return assertMessageType(message, "voice");
     }
     async sendAnimation(chatId, animation, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, animation, params, FileType.Animation, [
+        this.#checkParams(params);
+        const message = await this.#sendDocumentInner(chatId, animation, params, FileType.Animation, [
             { _: "documentAttributeAnimated" },
             { _: "documentAttributeVideo", supports_streaming: true, w: params?.width ?? 0, h: params?.height ?? 0, duration: params?.duration ?? 0 },
-        ]);
+        ], undefined, ANIMATION_MIME_TYPES, (firstPart) => {
+            if (startsWith(firstPart, new Uint8Array([0x47, 0x49, 0x46]))) {
+                return "file.gif";
+            }
+            else {
+                return "file.mp4";
+            }
+        });
         return assertMessageType(message, "animation");
     }
     async sendVideo(chatId, video, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, video, params, FileType.Video, [
+        this.#checkParams(params);
+        const message = await this.#sendDocumentInner(chatId, video, params, FileType.Video, [
             { _: "documentAttributeVideo", supports_streaming: params?.supportsStreaming ? true : undefined, w: params?.width ?? 0, h: params?.height ?? 0, duration: params?.duration ?? 0 },
-        ]);
+        ], undefined, VIDEO_MIME_TYPES, () => "video.mp4");
         return assertMessageType(message, "video");
     }
+    async #sendDocumentInner(chatId, document, params, fileType, otherAttribs, urlSupported = true, expectedMimeTypes, createName) {
+        let media = null;
+        const spoiler = params?.hasSpoiler ? true : undefined;
+        const ttl_seconds = params && "selfDestruct" in params && typeof params.selfDestruct !== undefined ? selfDestructOptionToInt(params.selfDestruct) : undefined;
+        if (typeof document === "string") {
+            const fileId = this.resolveFileId(document, fileType);
+            if (fileId !== null) {
+                media = { _: "inputMediaDocument", id: { ...fileId, _: "inputDocument" }, spoiler, query: otherAttribs.find((v) => Api.is("documentAttributeSticker", v))?.alt || undefined, ttl_seconds };
+            }
+        }
+        if (media === null) {
+            if (typeof document === "string" && isHttpUrl(document)) {
+                if (!urlSupported) {
+                    throw new InputError("URL not supported.");
+                }
+                media = { _: "inputMediaDocumentExternal", url: document, spoiler, ttl_seconds };
+            }
+            else {
+                let mimeType;
+                const file = await this.#c.fileManager.upload(document, params, (name, firstPart) => {
+                    if (!params?.fileName && firstPart && createName) {
+                        name = createName(firstPart);
+                    }
+                    mimeType = params?.mimeType ?? contentType(name.split(".").slice(-1)[0]);
+                    if (name.endsWith(".tgs") && fileType === FileType.Document) {
+                        name += "-";
+                    }
+                    return name;
+                });
+                mimeType ??= FALLBACK_MIME_TYPE;
+                if (mimeType && expectedMimeTypes && !expectedMimeTypes.includes(mimeType)) {
+                    unreachable();
+                }
+                if (Api.is("inputFileStoryDocument", file)) {
+                    unreachable();
+                }
+                let thumb = undefined;
+                if (params?.thumbnail) {
+                    thumb = await this.#c.fileManager.upload(params.thumbnail, { chunkSize: params?.chunkSize, signal: params?.signal });
+                }
+                media = { _: "inputMediaUploadedDocument", file, thumb, spoiler, attributes: [{ _: "documentAttributeFilename", file_name: file.name }, ...otherAttribs], mime_type: mimeType, force_file: fileType === FileType.Document ? true : undefined, ttl_seconds };
+            }
+        }
+        const message = await this.#sendMedia(chatId, media, params);
+        return message;
+    }
     async sendDocument(chatId, document, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, document, params, FileType.Document, []);
+        this.#checkParams(params);
+        const message = await this.#sendDocumentInner(chatId, document, params, FileType.Document, []);
         return assertMessageType(message, "document");
     }
     async sendSticker(chatId, sticker, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, sticker, params, FileType.Sticker, [{ _: "documentAttributeSticker", alt: params?.emoji || "", stickerset: { _: "inputStickerSetEmpty" } }], undefined, STICKER_MIME_TYPES);
+        this.#checkParams(params);
+        const message = await this.#sendDocumentInner(chatId, sticker, params, FileType.Sticker, [{ _: "documentAttributeSticker", alt: params?.emoji || "", stickerset: { _: "inputStickerSetEmpty" } }], undefined, STICKER_MIME_TYPES, (firstPart) => {
+            if (startsWith(firstPart, new Uint8Array([0x1F, 0x8B]))) {
+                return "file.tgs";
+            }
+            else if (firstPart.length >= 12 && equals(firstPart.subarray(8, 12), new Uint8Array([0x57, 0x45, 0x42, 0x50]))) {
+                return "file.webp";
+            }
+            else {
+                return "file.webm";
+            }
+        });
         return assertMessageType(message, "sticker");
     }
     async sendPhoto(chatId, photo, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
+        this.#checkParams(params);
         let media = null;
         const spoiler = params?.hasSpoiler ? true : undefined;
         const ttl_seconds = params && "selfDestruct" in params && params.selfDestruct !== undefined ? selfDestructOptionToInt(params.selfDestruct) : undefined;
         if (typeof photo === "string") {
             const fileId = this.resolveFileId(photo, [FileType.Photo, FileType.ProfilePhoto]);
-            if (fileId != null) {
+            if (fileId !== null) {
                 media = { _: "inputMediaPhoto", id: { ...fileId, _: "inputPhoto" }, spoiler, ttl_seconds };
             }
         }
-        if (media == null) {
+        if (media === null) {
             if (typeof photo === "string" && isHttpUrl(photo)) {
                 media = { _: "inputMediaPhotoExternal", url: photo, spoiler, ttl_seconds: (params && "selfDestruct" in params && params.selfDestruct !== undefined) ? selfDestructOptionToInt(params.selfDestruct) : undefined };
             }
             else {
-                const file = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(photo, params, null, false);
+                const file = await this.#c.fileManager.upload(photo, params, (name, firstPart) => {
+                    if (params?.fileName || !firstPart || name.includes(".")) {
+                        return name;
+                    }
+                    if (startsWith(firstPart, new Uint8Array([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]))) {
+                        return `${name}.png`;
+                    }
+                    else {
+                        return `${name}.jpg`;
+                    }
+                }, false);
                 media = { _: "inputMediaUploadedPhoto", file, spoiler, ttl_seconds: (params && "selfDestruct" in params && params.selfDestruct !== undefined) ? selfDestructOptionToInt(params.selfDestruct) : undefined };
             }
         }
-        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendMedia).call(this, chatId, media, params);
+        const message = await this.#sendMedia(chatId, media, params);
         return assertMessageType(message, "photo");
     }
+    async #sendMedia(chatId, media, params) {
+        if (params?.starCount !== undefined) {
+            if (params.starCount <= 0) {
+                throw new InputError("starCount cannot be zero or negative");
+            }
+            media = { _: "inputMediaPaidMedia", stars_amount: BigInt(params.starCount), extended_media: [media] };
+        }
+        const peer = await this.#c.getInputPeer(chatId);
+        const randomId = getRandomId();
+        const silent = params?.isSilent ? true : undefined;
+        const noforwards = params?.isContentProtected ? true : undefined;
+        const sendAs = params?.sendAs ? await this.#c.getInputPeer(params.sendAs) : undefined;
+        const replyMarkup = await this.#constructReplyMarkup(params);
+        const caption_ = params?.caption;
+        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 this.#c.invoke({
+            _: "messages.sendMedia",
+            peer,
+            random_id: randomId,
+            silent,
+            noforwards,
+            reply_markup: replyMarkup,
+            reply_to: await this.#constructReplyTo(params),
+            send_as: sendAs,
+            media,
+            message: caption ?? "",
+            entities: captionEntities,
+            effect: params?.effectId ? BigInt(params.effectId) : undefined,
+            schedule_date: params?.sendAt,
+            allow_paid_floodskip: params?.isPaidBroadcast ? true : undefined,
+        }, { businessConnectionId: params?.businessConnectionId });
+        return (await this.updatesToMessages(chatId, result, params?.businessConnectionId))[0];
+    }
     resolveFileId(maybeFileId, expectedFileType) {
         expectedFileType = Array.isArray(expectedFileType) ? expectedFileType : [expectedFileType];
         let fileId = null;
@@ -483,9 +709,9 @@ export class MessageManager {
             fileId = deserializeFileId(maybeFileId);
         }
         catch (err) {
-            __classPrivateFieldGet(this, _MessageManager_LresolveFileId, "f").warning(err);
+            this.#LresolveFileId.warning(err);
         }
-        if (fileId != null) {
+        if (fileId !== null) {
             if (!expectedFileType.includes(fileId.type)) {
                 unreachable();
             }
@@ -498,7 +724,7 @@ export class MessageManager {
         return null;
     }
     async sendPoll(chatId, question, options, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
+        this.#checkParams(params);
         question = question?.trim();
         if (!question) {
             throw new Error("Question must not be empty.");
@@ -506,95 +732,324 @@ export class MessageManager {
         if (!Array.isArray(options) || options.length < 2) {
             throw new Error("There must be at least two options.");
         }
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        const peer = await this.#c.getInputPeer(chatId);
         const randomId = getRandomId();
-        const silent = params?.disableNotification ? true : undefined;
-        const noforwards = params?.protectContent ? true : undefined;
-        const sendAs = params?.sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.sendAs) : undefined;
-        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
+        const silent = params?.isSilent ? true : undefined;
+        const noforwards = params?.isContentProtected ? true : undefined;
+        const sendAs = params?.sendAs ? await this.#c.getInputPeer(params.sendAs) : undefined;
+        const replyMarkup = await this.#constructReplyMarkup(params);
         const explanation = params?.explanation;
-        const parseResult = explanation !== undefined ? await this.parseText(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 = await Promise.all(options.map(async (v, i) => {
-            const text = typeof v === "string" ? v : v.text;
-            const entities = typeof v === "string" ? [] : v.entities;
-            const parseResult = await this.parseText(text, { parseMode: params?.optionParseMode, entities: entities });
-            return ({ _: "pollAnswer", option: new Uint8Array([i]), text: { _: "textWithEntities", text: parseResult[0], entities: parseResult[1] ?? [] } });
-        }));
-        const questionParseResult = await this.parseText(question, { parseMode: params?.questionParseMode, entities: params?.questionEntities });
-        const poll = { _: "poll", id: getRandomId(), answers, question: { _: "textWithEntities", text: questionParseResult[0], entities: questionParseResult[1] ?? [] }, closed: params?.isClosed ? true : undefined, close_date: params?.closeDate ? toUnixTimestamp(params.closeDate) : undefined, close_period: params?.openPeriod ? params.openPeriod : undefined, multiple_choice: params?.allowMultipleAnswers ? true : undefined, public_voters: params?.isAnonymous === false ? true : undefined, quiz: params?.type == "quiz" ? true : undefined };
-        const media = { _: "inputMediaPoll", poll, correct_answers: params?.correctOptionIndex ? [new Uint8Array([params.correctOptionIndex])] : undefined, solution, solution_entities: solutionEntities };
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+        const answers = options.map((v, i) => {
+            const text = v.text;
+            const entities = v.entities;
+            const parseResult = this.parseText(text, { parseMode: v.parseMode, entities });
+            return ({ _: "pollAnswer", option: encodeText(String(i)), text: { _: "textWithEntities", text: parseResult[0], entities: parseResult[1] ?? [] } });
+        });
+        const questionParseResult = this.parseText(question, { parseMode: params?.questionParseMode, entities: params?.questionEntities });
+        const poll = { _: "poll", id: getRandomId(), answers, question: { _: "textWithEntities", text: questionParseResult[0], entities: questionParseResult[1] ?? [] }, closed: params?.isClosed ? true : undefined, close_date: params?.closeDate, close_period: params?.openPeriod ? params.openPeriod : undefined, multiple_choice: params?.allowMultipleAnswers ? true : undefined, public_voters: params?.isAnonymous === false ? true : undefined, quiz: params?.type === "quiz" ? true : undefined };
+        const media = { _: "inputMediaPoll", poll, correct_answers: params?.correctOptionIndex !== undefined ? [encodeText(String(params.correctOptionIndex))] : undefined, solution, solution_entities: solutionEntities };
+        const result = await this.#c.invoke({
             _: "messages.sendMedia",
             peer,
             random_id: randomId,
             silent,
             noforwards,
             reply_markup: replyMarkup,
-            reply_to: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            reply_to: await this.#constructReplyTo(params),
             send_as: sendAs,
             media,
             message: "",
             effect: params?.effectId ? BigInt(params.effectId) : undefined,
-            schedule_date: params?.sendAt ? toUnixTimestamp(params.sendAt) : undefined,
-            allow_paid_floodskip: params?.paidBroadcast ? true : undefined,
-        }, params?.businessConnectionId);
-        const message = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result, params?.businessConnectionId))[0];
+            schedule_date: params?.sendAt,
+            allow_paid_floodskip: params?.isPaidBroadcast ? true : undefined,
+        }, { businessConnectionId: params?.businessConnectionId });
+        const message = (await this.updatesToMessages(chatId, result, params?.businessConnectionId))[0];
         return assertMessageType(message, "poll");
     }
+    async sendChecklist(chatId, title, items, params) {
+        this.#c.storage.assertUser("sendChecklist");
+        this.#checkParams(params);
+        title = title?.trim();
+        if (!title) {
+            throw new Error("Title must not be empty.");
+        }
+        if (!Array.isArray(items) || items.length < 1) {
+            throw new Error("There must be at least one item.");
+        }
+        const peer = await this.#c.getInputPeer(chatId);
+        const randomId = getRandomId();
+        const silent = params?.isSilent ? true : undefined;
+        const noforwards = params?.isContentProtected ? true : undefined;
+        const sendAs = params?.sendAs ? await this.#c.getInputPeer(params.sendAs) : undefined;
+        const list = items.map((v, i) => {
+            const text = v.text;
+            const entities = v.entities;
+            const parseResult = this.parseText(text, { parseMode: v.parseMode, entities });
+            return ({ _: "todoItem", id: i + 1, title: { _: "textWithEntities", text: parseResult[0], entities: parseResult[1] ?? [] } });
+        });
+        const titleParseResult = this.parseText(title, { parseMode: params?.titleParseMode, entities: params?.titleEntities });
+        const todo = {
+            _: "todoList",
+            title: { _: "textWithEntities", text: titleParseResult[0], entities: titleParseResult[1] ?? [] },
+            list,
+            others_can_append: params?.isExtendableByOthers ? true : undefined,
+            others_can_complete: params?.isCompletableByOthers ? true : undefined,
+        };
+        const media = { _: "inputMediaTodo", todo };
+        const result = await this.#c.invoke({
+            _: "messages.sendMedia",
+            peer,
+            random_id: randomId,
+            silent,
+            noforwards,
+            reply_to: await this.#constructReplyTo(params),
+            send_as: sendAs,
+            media,
+            message: "",
+            effect: params?.effectId ? BigInt(params.effectId) : undefined,
+            schedule_date: params?.sendAt,
+            allow_paid_floodskip: params?.isPaidBroadcast ? true : undefined,
+        }, { businessConnectionId: params?.businessConnectionId });
+        const message = (await this.updatesToMessages(chatId, result, params?.businessConnectionId))[0];
+        return assertMessageType(message, "checklist");
+    }
     async editMessageReplyMarkup(chatId, messageId, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+        this.#checkParams(params);
+        const result = await this.#c.invoke({
             _: "messages.editMessage",
             id: checkMessageId(messageId),
-            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
-            reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params),
-        }, params?.businessConnectionId);
-        const message_ = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result))[0];
+            peer: await this.#c.getInputPeer(chatId),
+            reply_markup: await this.#constructReplyMarkup(params),
+        }, { businessConnectionId: params?.businessConnectionId });
+        const message_ = (await this.updatesToMessages(chatId, result))[0];
         return message_;
     }
     async editInlineMessageReplyMarkup(inlineMessageId, params) {
-        const id = deserializeInlineMessageId(inlineMessageId);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.editInlineBotMessage", id, reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params) });
+        const id = await deserializeInlineMessageId(inlineMessageId);
+        await this.#c.invoke({
+            _: "messages.editInlineBotMessage",
+            id,
+            reply_markup: await this.#constructReplyMarkup(params),
+        }, { dc: getDc(id.dc_id) });
     }
     async editMessageText(chatId, messageId, text, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const [message, entities] = await this.parseText(text, params);
-        const noWebpage = params?.linkPreview?.disable ? true : undefined;
-        const invertMedia = params?.linkPreview?.aboveText ? true : undefined;
+        this.#checkParams(params);
+        {
+            const message = await this.getMessage(chatId, messageId);
+            if (!message) {
+                throw new InputError("Message not found.");
+            }
+            if (!isMessageType(message, "link") && !isMessageType(message, "text")) {
+                throw new InputError("The referenced message is not a text message.");
+            }
+        }
+        const [message, entities] = this.parseText(text, params);
+        if (!message) {
+            throw new InputError("Message text cannot be empty.");
+        }
+        if (params?.linkPreview && params.linkPreview.type !== "input") {
+            throw new InputError("Expected link preview of type input.");
+        }
+        const noWebpage = params?.linkPreview && params.linkPreview.type === "input" && params.linkPreview.isDisabled ? true : undefined;
+        const invertMedia = params?.linkPreview?.isAboveText ? true : undefined;
         let media = undefined;
         if (!noWebpage && params?.linkPreview?.url) {
-            media = { _: "inputMediaWebPage", url: params.linkPreview.url, force_large_media: params.linkPreview.largeMedia ? true : undefined, force_small_media: params.linkPreview.smallMedia ? true : undefined, optional: message.length ? undefined : true };
+            media = { _: "inputMediaWebPage", url: params.linkPreview.url, force_large_media: params.linkPreview.mediaSize === "large" ? true : undefined, force_small_media: params.linkPreview.mediaSize === "small" ? true : undefined, optional: message.length ? undefined : true };
         }
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+        const result = await this.#c.invoke({
             _: "messages.editMessage",
             id: checkMessageId(messageId),
-            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+            peer: await this.#c.getInputPeer(chatId),
             entities,
             message,
             media,
             no_webpage: noWebpage,
             invert_media: invertMedia,
-            reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params),
-        }, params?.businessConnectionId);
-        const message_ = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result))[0];
+            reply_markup: await this.#constructReplyMarkup(params),
+        }, { businessConnectionId: params?.businessConnectionId });
+        const message_ = (await this.updatesToMessages(chatId, result))[0];
         return assertMessageType(message_, "text");
     }
-    async editInlineMessageText(inlineMessageId, text, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        const [message, entities] = await this.parseText(text, params);
-        const id = deserializeInlineMessageId(inlineMessageId);
-        const noWebpage = params?.linkPreview?.disable ? true : undefined;
-        const invertMedia = params?.linkPreview?.aboveText ? true : undefined;
+    static #CAPTIONABLE_MESSAGE_TYPES = ["photo", "document", "video", "animation", "voice", "audio", "video"];
+    async editMessageCaption(chatId, messageId, params) {
+        let canHaveCaption = false;
+        const message_ = await this.getMessage(chatId, messageId);
+        if (!message_) {
+            throw new InputError("Message not found.");
+        }
+        for (const type of MessageManager.#CAPTIONABLE_MESSAGE_TYPES) {
+            if (isMessageType(message_, type)) {
+                canHaveCaption = true;
+            }
+        }
+        if (!canHaveCaption) {
+            throw new InputError("The referenced message cannot have a caption.");
+        }
+        const [message, entities] = this.parseText(params?.caption ?? "", params);
+        const result = await this.#c.invoke({
+            _: "messages.editMessage",
+            id: checkMessageId(messageId),
+            peer: await this.#c.getInputPeer(chatId),
+            entities: message ? entities : [],
+            message,
+            reply_markup: await this.#constructReplyMarkup(params),
+        }, { businessConnectionId: params?.businessConnectionId });
+        return (await this.updatesToMessages(chatId, result))[0];
+    }
+    async #editInlineMessageTextInner(inlineMessageId, text, params, allowEmpty = true) {
+        this.#checkParams(params);
+        const [message, entities] = this.parseText(text, params);
+        if (!allowEmpty && !message) {
+            throw new InputError("Message text cannot be empty.");
+        }
+        const id = await deserializeInlineMessageId(inlineMessageId);
+        if (params?.linkPreview && params.linkPreview.type !== "input") {
+            throw new InputError("Expected link preview of type input.");
+        }
+        const noWebpage = params?.linkPreview && params.linkPreview.type === "input" && params.linkPreview.isDisabled ? true : undefined;
+        const invertMedia = params?.linkPreview?.isAboveText ? true : undefined;
         let media = undefined;
         if (!noWebpage && params?.linkPreview?.url) {
-            media = { _: "inputMediaWebPage", url: params.linkPreview.url, force_large_media: params.linkPreview.largeMedia ? true : undefined, force_small_media: params.linkPreview.smallMedia ? true : undefined, optional: message.length ? undefined : true };
+            media = { _: "inputMediaWebPage", url: params.linkPreview.url, force_large_media: params.linkPreview.mediaSize === "large" ? true : undefined, force_small_media: params.linkPreview.mediaSize === "small" ? true : undefined, optional: message.length ? undefined : true };
+        }
+        await this.#c.invoke({
+            _: "messages.editInlineBotMessage",
+            id,
+            entities,
+            message,
+            media,
+            no_webpage: noWebpage,
+            invert_media: invertMedia,
+            reply_markup: await this.#constructReplyMarkup(params),
+        }, { dc: getDc(id.dc_id) });
+    }
+    async editInlineMessageText(inlineMessageId, text, params) {
+        await this.#editInlineMessageTextInner(inlineMessageId, text, params, false);
+    }
+    async editInlineMessageCaption(inlineMessageId, params) {
+        await this.#editInlineMessageTextInner(inlineMessageId, params?.caption ?? "", params);
+    }
+    async #resolveInputMediaInner(document, media, fileType, otherAttribs) {
+        let media_ = null;
+        const spoiler = "hasSpoiler" in media && media.hasSpoiler ? true : undefined;
+        if (typeof document === "string") {
+            const fileId = this.resolveFileId(document, fileType);
+            if (fileId !== null) {
+                media_ = { _: "inputMediaDocument", id: { ...fileId, _: "inputDocument" }, spoiler, query: otherAttribs.find((v) => Api.is("documentAttributeSticker", v))?.alt || undefined };
+            }
+        }
+        if (media_ === null) {
+            if (typeof document === "string" && isHttpUrl(document)) {
+                media_ = { _: "inputMediaDocumentExternal", url: document, spoiler };
+            }
+            else {
+                let mimeType;
+                const file = await this.#c.fileManager.upload(document, media, (name) => {
+                    mimeType = media?.mimeType ?? contentType(name.split(".").slice(-1)[0]) ?? FALLBACK_MIME_TYPE;
+                    if (name.endsWith(".tgs") && fileType === FileType.Document) {
+                        name += "-";
+                    }
+                    return name;
+                });
+                if (Api.is("inputFileStoryDocument", file)) {
+                    unreachable();
+                }
+                let thumb = undefined;
+                if ("thumbnail" in media && media.thumbnail) {
+                    thumb = await this.#c.fileManager.upload(media.thumbnail, { chunkSize: media?.chunkSize, signal: media?.signal });
+                }
+                media_ = { _: "inputMediaUploadedDocument", file, thumb, spoiler, attributes: [{ _: "documentAttributeFilename", file_name: file.name }, ...otherAttribs], mime_type: mimeType, force_file: fileType === FileType.Document ? true : undefined };
+            }
         }
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.editInlineBotMessage", id, entities, message, media, no_webpage: noWebpage, invert_media: invertMedia, reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params) });
+        return media_;
+    }
+    async #resolveInputMedia(media) {
+        if ("animation" in media) {
+            return await this.#resolveInputMediaInner(media.animation, media, FileType.Animation, [
+                { _: "documentAttributeAnimated" },
+                { _: "documentAttributeVideo", supports_streaming: true, w: media?.width ?? 0, h: media?.height ?? 0, duration: media?.duration ?? 0 },
+            ]);
+        }
+        else if ("audio" in media) {
+            return await this.#resolveInputMediaInner(media.audio, media, FileType.Audio, [
+                { _: "documentAttributeAudio", duration: media?.duration ?? 0, performer: media?.performer, title: media?.title },
+            ]);
+        }
+        else if ("document" in media) {
+            return await this.#resolveInputMediaInner(media.document, media, FileType.Document, []);
+        }
+        else if ("photo" in media) {
+            let media_ = null;
+            const spoiler = media.hasSpoiler ? true : undefined;
+            const ttl_seconds = "selfDestruct" in media && media.selfDestruct !== undefined ? selfDestructOptionToInt(media.selfDestruct) : undefined;
+            if (typeof media.photo === "string") {
+                const fileId = this.resolveFileId(media.photo, [FileType.Photo, FileType.ProfilePhoto]);
+                if (fileId !== null) {
+                    media_ = { _: "inputMediaPhoto", id: { ...fileId, _: "inputPhoto" }, spoiler, ttl_seconds };
+                }
+            }
+            if (media_ === null) {
+                if (typeof media.photo === "string" && isHttpUrl(media.photo)) {
+                    media_ = { _: "inputMediaPhotoExternal", url: media.photo, spoiler };
+                }
+                else {
+                    const file = await this.#c.fileManager.upload(media.photo, media, null, false);
+                    media_ = { _: "inputMediaUploadedPhoto", file, spoiler, ttl_seconds };
+                }
+            }
+            return media_;
+        }
+        else if ("video" in media) {
+            const ttl_seconds = "selfDestruct" in media && media.selfDestruct !== undefined ? selfDestructOptionToInt(media.selfDestruct) : undefined;
+            const media_ = await this.#resolveInputMediaInner(media.video, media, FileType.Video, [
+                { _: "documentAttributeVideo", supports_streaming: media?.supportsStreaming ? true : undefined, w: media?.width ?? 0, h: media?.height ?? 0, duration: media?.duration ?? 0 },
+            ]);
+            media_.ttl_seconds = ttl_seconds;
+            return media_;
+        }
+        else {
+            unreachable();
+        }
+    }
+    async #resolveInputMediaUpload(media, businessConnectionId) {
+        const inputMedia = await this.#resolveInputMedia(media);
+        if (Api.is("inputMediaUploadedPhoto", inputMedia) || Api.is("inputMediaUploadedDocument", inputMedia)) {
+            const messageMedia = await this.#c.invoke({
+                _: "messages.uploadMedia",
+                peer: { _: "inputPeerSelf" },
+                media: inputMedia,
+                business_connection_id: businessConnectionId,
+            });
+            if (("photo" in messageMedia) && Api.is("photo", messageMedia.photo)) {
+                return {
+                    _: "inputMediaPhoto",
+                    id: {
+                        _: "inputPhoto",
+                        id: messageMedia.photo.id,
+                        access_hash: messageMedia.photo.access_hash,
+                        file_reference: messageMedia.photo.file_reference,
+                    },
+                    spoiler: "hasSpoiler" in media && media.hasSpoiler ? true : undefined,
+                };
+            }
+            else if ("document" in messageMedia && Api.is("document", messageMedia.document)) {
+                return {
+                    _: "inputMediaDocument",
+                    id: { _: "inputDocument", id: messageMedia.document.id, access_hash: messageMedia.document.access_hash, file_reference: messageMedia.document.file_reference },
+                    spoiler: "hasSpoiler" in media && media.hasSpoiler ? true : undefined,
+                };
+            }
+            else {
+                unreachable();
+            }
+        }
+        return inputMedia;
     }
     async editMessageMedia(chatId, messageId, media, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
+        this.#checkParams(params);
         const message = await this.getMessage(chatId, messageId);
         if (!message) {
             throw new InputError("Message not found.");
@@ -602,85 +1057,94 @@ export class MessageManager {
         if (!("animation" in message) && !("audio" in message) && !("document" in message) && !("photo" in message) && !("video" in message)) {
             throw new InputError("Unexpected message type.");
         }
-        const [text, entities] = media.caption !== undefined ? await this.parseText(media.caption, { entities: media.captionEntities, parseMode: media.parseMode }) : ["", []];
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+        const [text, entities] = media.caption !== undefined ? this.parseText(media.caption, { entities: media.captionEntities, parseMode: media.parseMode }) : ["", []];
+        const result = await this.#c.invoke({
             _: "messages.editMessage",
-            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+            peer: await this.#c.getInputPeer(chatId),
             id: messageId,
-            media: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_resolveInputMedia).call(this, media),
-            reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params),
+            media: await this.#resolveInputMedia(media),
+            reply_markup: await this.#constructReplyMarkup(params),
             message: text,
             entities,
-        }, params?.businessConnectionId);
-        const message_ = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result))[0];
+        }, { businessConnectionId: params?.businessConnectionId });
+        const message_ = (await this.updatesToMessages(chatId, result))[0];
         return message_;
     }
     async editInlineMessageMedia(inlineMessageId, media, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertBot("editInlineMessageMedia");
-        const id = deserializeInlineMessageId(inlineMessageId);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.editInlineBotMessage", id, media: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_resolveInputMedia).call(this, media), reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params) });
+        this.#checkParams(params);
+        this.#c.storage.assertBot("editInlineMessageMedia");
+        const id = await deserializeInlineMessageId(inlineMessageId);
+        await this.#c.invoke({
+            _: "messages.editInlineBotMessage",
+            id,
+            media: await this.#resolveInputMediaUpload(media),
+            reply_markup: await this.#constructReplyMarkup(params),
+        }, { dc: getDc(id.dc_id) });
     }
     async deleteMessages(chatId, messageIds, params) {
         checkArray(messageIds, checkMessageId);
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        const peer = await this.#c.getInputPeer(chatId);
         if (canBeInputChannel(peer)) {
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.deleteMessages", channel: toInputChannel(peer), id: messageIds });
+            await this.#c.invoke({ _: "channels.deleteMessages", channel: toInputChannel(peer), id: messageIds });
         }
         else {
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.deleteMessages", id: messageIds, revoke: params?.onlyForMe ? undefined : true });
+            await this.#c.invoke({ _: "messages.deleteMessages", id: messageIds, revoke: params?.onlyForMe ? undefined : true });
         }
     }
     async deleteScheduledMessages(chatId, messageIds) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("sendScheduledMessage");
+        this.#c.storage.assertUser("sendScheduledMessage");
         checkArray(messageIds, checkMessageId);
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.deleteScheduledMessages", peer, id: messageIds });
+        const peer = await this.#c.getInputPeer(chatId);
+        await this.#c.invoke({ _: "messages.deleteScheduledMessages", peer, id: messageIds });
     }
     async deleteScheduledMessage(chatId, messageId) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("deleteScheduledMessage");
+        this.#c.storage.assertUser("deleteScheduledMessage");
         return await this.deleteScheduledMessages(chatId, [messageId]);
     }
     async sendScheduledMessages(chatId, messageIds) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("sendScheduledMessages");
+        this.#c.storage.assertUser("sendScheduledMessages");
         checkArray(messageIds, checkMessageId);
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.sendScheduledMessages", peer, id: messageIds });
-        return await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result);
+        const peer = await this.#c.getInputPeer(chatId);
+        const result = await this.#c.invoke({ _: "messages.sendScheduledMessages", peer, id: messageIds });
+        return await this.updatesToMessages(chatId, result);
     }
     async sendScheduledMessage(chatId, messageId) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("sendScheduledMessage");
+        this.#c.storage.assertUser("sendScheduledMessage");
         return (await this.sendScheduledMessages(chatId, [messageId]))[0];
     }
     async deleteChatMemberMessages(chatId, memberId) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("deleteChatMemberMessages");
-        const channel = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputChannel(chatId);
-        const participant = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.deleteParticipantHistory", channel, participant });
+        this.#c.storage.assertUser("deleteChatMemberMessages");
+        const channel = await this.#c.getInputChannel(chatId);
+        const participant = await this.#c.getInputPeer(memberId);
+        await this.#c.invoke({ _: "channels.deleteParticipantHistory", channel, participant });
     }
     async pinMessage(chatId, messageId, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.updatePinnedMessage", peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId), id: checkMessageId(messageId), silent: params?.disableNotification ? true : undefined, pm_oneside: params?.bothSides ? undefined : true });
+        this.#checkParams(params);
+        await this.#c.invoke({ _: "messages.updatePinnedMessage", peer: await this.#c.getInputPeer(chatId), id: checkMessageId(messageId), silent: params?.isSilent ? true : undefined, pm_oneside: params?.bothSides ? undefined : true });
     }
     async unpinMessage(chatId, messageId, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.updatePinnedMessage", peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId), id: checkMessageId(messageId), unpin: true }, params?.businessConnectionId);
-    }
-    async unpinMessages(chatId) {
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.unpinAllMessages", peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId) });
+        this.#checkParams(params);
+        await this.#c.invoke({ _: "messages.updatePinnedMessage", peer: await this.#c.getInputPeer(chatId), id: checkMessageId(messageId), unpin: true }, { businessConnectionId: params?.businessConnectionId });
+    }
+    async unpinMessages(chatId, params) {
+        await this.#c.invoke({
+            _: "messages.unpinAllMessages",
+            peer: await this.#c.getInputPeer(chatId),
+            top_msg_id: params?.topicId,
+        });
     }
-    async setAvailableReactions(chatId, availableReactions) {
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.setChatAvailableReactions", peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId), available_reactions: availableReactions == "none" ? { _: "chatReactionsNone" } : availableReactions == "all" ? { _: "chatReactionsAll" } : Array.isArray(availableReactions) ? ({ _: "chatReactionsSome", reactions: availableReactions.map((v) => reactionToTlObject(v)) }) : unreachable() });
+    async #sendReaction(chatId, messageId, reactions, params) {
+        await this.#c.invoke({ _: "messages.sendReaction", peer: await this.#c.getInputPeer(chatId), msg_id: checkMessageId(messageId), reaction: reactions.map((v) => reactionToTlObject(v)), big: params?.isBig ? true : undefined, add_to_recent: params?.addToRecents ? true : undefined });
     }
     async setReactions(chatId, messageId, reactions, params) {
-        await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendReaction).call(this, chatId, messageId, reactions, params);
+        await this.#sendReaction(chatId, messageId, reactions, params);
     }
     async addReaction(chatId, messageId, reaction, params) {
         const message = await this.getMessage(chatId, messageId);
         if (!message) {
             throw new InputError("Message not found.");
         }
-        const chosenReactions = (message.reactions ?? []).filter((v) => v.chosen);
+        const chosenReactions = (message.reactions ?? []).filter((v) => v.isChosen);
         for (const r of chosenReactions) {
             if (reactionEqual(r.reaction, reaction)) {
                 return;
@@ -694,56 +1158,53 @@ export class MessageManager {
         if (!message) {
             throw new InputError("Message not found.");
         }
-        const chosenReactions = (message.reactions ?? []).filter((v) => v.chosen);
+        const chosenReactions = (message.reactions ?? []).filter((v) => v.isChosen);
         for (const r of chosenReactions) {
             if (reactionEqual(r.reaction, reaction)) {
-                const reactions = chosenReactions.filter((v) => v != r).map((v) => v.reaction);
+                const reactions = chosenReactions.filter((v) => v !== r).map((v) => v.reaction);
                 await this.setReactions(chatId, messageId, reactions);
                 break;
             }
         }
     }
-    static canHandleUpdate(update) {
-        return isOneOf(messageManagerUpdates, update);
+    canHandleUpdate(update) {
+        return Api.isOneOf(messageManagerUpdates, update);
     }
     async handleUpdate(update) {
-        if (is("updateNewMessage", update) || is("updateNewChannelMessage", update) || is("updateEditMessage", update) || is("updateEditChannelMessage", update)) {
-            if (is("message", update.message) || is("messageService", update.message)) {
-                const chatId = peerToChatId(update.message.peer_id);
-                await __classPrivateFieldGet(this, _MessageManager_c, "f").messageStorage.setMessage(chatId, update.message.id, update.message);
-            }
-        }
-        if (is("updateNewMessage", update) ||
-            is("updateNewChannelMessage", update) ||
-            is("updateEditMessage", update) ||
-            is("updateEditChannelMessage", update) ||
-            is("updateBotNewBusinessMessage", update) ||
-            is("updateBotEditBusinessMessage", update) ||
-            is("updateNewScheduledMessage", update)) {
-            if (!(is("messageEmpty", update.message))) {
+        if (Api.is("updateNewMessage", update) || Api.is("updateNewChannelMessage", update) || Api.is("updateEditMessage", update) || Api.is("updateEditChannelMessage", update)) {
+            if (Api.is("message", update.message) || Api.is("messageService", update.message)) {
+                const chatId = Api.peerToChatId(update.message.peer_id);
+                await this.#c.messageStorage.setMessage(chatId, update.message.id, update.message);
+            }
+        }
+        if (Api.isOneOf([
+            "updateNewMessage",
+            "updateNewChannelMessage",
+            "updateEditMessage",
+            "updateEditChannelMessage",
+            "updateBotNewBusinessMessage",
+            "updateBotEditBusinessMessage",
+            "updateNewScheduledMessage",
+        ], update)) {
+            if (!(Api.is("messageEmpty", update.message))) {
                 const isOutgoing = update.message.out;
                 let shouldIgnore = false;
                 if (isOutgoing) {
-                    if (__classPrivateFieldGet(this, _MessageManager_c, "f").outgoingMessages == null) {
-                        __classPrivateFieldGet(this, _MessageManager_c, "f").outgoingMessages = __classPrivateFieldGet(this, _MessageManager_c, "f").storage.accountType == "user" ? "all" : "business";
-                    }
-                    if (__classPrivateFieldGet(this, _MessageManager_c, "f").outgoingMessages == "none") {
+                    if ("connection_id" in update && update.connection_id === "") {
                         shouldIgnore = true;
                     }
-                    else if (__classPrivateFieldGet(this, _MessageManager_c, "f").outgoingMessages == "business") {
-                        if (!is("updateBotNewBusinessMessage", update) && !is("updateBotEditBusinessMessage", update)) {
-                            shouldIgnore = true;
-                        }
+                    else {
+                        shouldIgnore = !this.#c.outgoingMessages;
                     }
                 }
                 if (!shouldIgnore) {
                     const business = "connection_id" in update ? { connectionId: update.connection_id, replyToMessage: update.reply_to_message } : undefined;
                     const message = await this.constructMessage(update.message, undefined, business);
-                    if (is("updateNewMessage", update) || is("updateNewChannelMessage", update) || is("updateBotNewBusinessMessage", update)) {
+                    if (Api.is("updateNewMessage", update) || Api.is("updateNewChannelMessage", update) || Api.is("updateBotNewBusinessMessage", update)) {
                         return { message };
                     }
-                    else if (is("updateNewScheduledMessage", update)) {
-                        message.scheduled = true;
+                    else if (Api.is("updateNewScheduledMessage", update)) {
+                        message.isScheduled = true;
                         return { scheduledMessage: message };
                     }
                     else {
@@ -752,10 +1213,10 @@ export class MessageManager {
                 }
             }
         }
-        if (is("updateDeleteMessages", update)) {
+        if (Api.is("updateDeleteMessages", update)) {
             const deletedMessages = new Array();
             for (const messageId of update.messages) {
-                const chatId = await __classPrivateFieldGet(this, _MessageManager_c, "f").messageStorage.getMessageChat(messageId);
+                const chatId = await this.#c.messageStorage.getMessageChat(messageId);
                 if (chatId) {
                     deletedMessages.push({ chatId, messageId });
                 }
@@ -764,45 +1225,36 @@ export class MessageManager {
                 return { deletedMessages };
             }
         }
-        else if (is("updateDeleteChannelMessages", update)) {
-            const chatId = getChannelChatId(update.channel_id);
+        else if (Api.is("updateDeleteChannelMessages", update)) {
+            const chatId = Api.getChannelChatId(update.channel_id);
             const deletedMessages = new Array();
             for (const messageId of update.messages) {
-                const message = await __classPrivateFieldGet(this, _MessageManager_c, "f").messageStorage.getMessage(chatId, messageId);
-                if (message != null) {
+                const message = await this.#c.messageStorage.getMessage(chatId, messageId);
+                if (message !== null) {
                     deletedMessages.push({ chatId, messageId });
                 }
             }
             return { deletedMessages };
         }
-        else if (is("updateDeleteScheduledMessages", update)) {
-            const chatId = peerToChatId(update.peer);
+        else if (Api.is("updateDeleteScheduledMessages", update)) {
+            const chatId = Api.peerToChatId(update.peer);
             const deletedMessages = update.messages.map((v) => ({ chatId, messageId: v }));
-            return { deletedMessages, scheduled: true };
+            return { deletedMessages, isScheduled: true };
         }
-        else if (is("updateBotDeleteBusinessMessage", update)) {
-            const chatId = peerToChatId(update.peer);
+        else if (Api.is("updateBotDeleteBusinessMessage", update)) {
+            const chatId = Api.peerToChatId(update.peer);
             const deletedMessages = update.messages.map((v) => ({ chatId, messageId: v }));
             return { deletedMessages, businessConnectionId: update.connection_id };
         }
-        if (is("updateChannelParticipant", update) || is("updateChatParticipant", update)) {
-            const chatMember = await constructChatMemberUpdated(update, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity);
-            const selfId = await __classPrivateFieldGet(this, _MessageManager_c, "f").getSelfId();
-            if (chatMember.oldChatMember.user.id == selfId) {
-                return { myChatMember: chatMember };
-            }
-            else {
-                return { chatMember };
-            }
-        }
-        if (is("updateBotChatInviteRequester", update)) {
-            const joinRequest = await constructJoinRequest(update, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity);
-            return { joinRequest };
+        if (Api.is("updateTranscribedAudio", update)) {
+            const voiceTranscription = constructVoiceTranscription(update);
+            await this.#c.messageStorage.setVoiceTranscription(voiceTranscription);
+            return { voiceTranscription };
         }
         return null;
     }
     async sendChatAction(chatId, action, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
+        this.#checkParams(params);
         let action_;
         switch (action) {
             case "type":
@@ -841,211 +1293,58 @@ export class MessageManager {
             default:
                 throw new InputError(`Invalid chat action: ${action}`);
         }
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.setTyping", peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId), action: action_, top_msg_id: params?.messageThreadId }, params?.businessConnectionId);
-    }
-    async deleteChatPhoto(chatId) {
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
-        if (!(canBeInputChannel(peer)) && !(is("inputPeerChat", peer))) {
-            unreachable();
-        }
-        if (canBeInputChannel(peer)) {
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.editPhoto", channel: toInputChannel(peer), photo: { _: "inputChatPhotoEmpty" } });
-        }
-        else if (is("inputPeerChat", peer)) {
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.editChatPhoto", chat_id: peer.chat_id, photo: { _: "inputChatPhotoEmpty" } });
-        }
-    }
-    async setChatPhoto(chatId, photo, params) {
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
-        if (!(canBeInputChannel(peer)) && !(is("inputPeerChat", peer))) {
-            unreachable();
-        }
-        const file = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(photo, params);
-        const photo_ = { _: "inputChatUploadedPhoto", file };
-        if (canBeInputChannel(peer)) {
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.editPhoto", channel: toInputChannel(peer), photo: photo_ });
-        }
-        else if (is("inputPeerChat", peer)) {
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "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 (!(is("inputPeerChannel", chat)) && !(is("inputPeerChat", chat))) {
-            throw new InputError("Expected a channel, supergroup, or group ID.");
-        }
-        const member = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
-        if (is("inputPeerChannel", chat)) {
-            if (params?.deleteMessages) {
-                try {
-                    await this.deleteChatMemberMessages(chatId, memberId);
-                }
-                catch {
-                    //
-                }
-            }
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
-                _: "channels.editBanned",
-                channel: { ...chat, _: "inputChannel" },
-                participant: member,
-                banned_rights: ({
-                    _: "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 (is("inputPeerChat", chat)) {
-            if (!canBeInputUser(member)) {
-                throw new InputError(`Invalid user ID: ${memberId}`);
-            }
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.deleteChatUser", chat_id: chat.chat_id, user_id: toInputUser(member), revoke_history: params?.deleteMessages ? true : undefined });
-        }
-    }
-    async unbanChatMember(chatId, memberId) {
-        const channel = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputChannel(chatId);
-        const member = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.editBanned", channel, participant: member, banned_rights: ({ _: "chatBannedRights", until_date: 0 }) });
-    }
-    async setChatMemberRights(chatId, memberId, params) {
-        const channel = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputChannel(chatId);
-        const member = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.editBanned", channel, participant: member, banned_rights: chatMemberRightsToTlObject(params?.rights, params?.untilDate) });
-    }
-    async enableJoinRequests(chatId) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("enableJoinRequests");
-        await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_toggleJoinRequests).call(this, chatId, true);
-    }
-    async disableJoinRequests(chatId) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("disableJoinRequests");
-        await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_toggleJoinRequests).call(this, chatId, false);
-    }
-    async approveJoinRequest(chatId, userId) {
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
-            _: "messages.hideChatJoinRequest",
-            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
-            user_id: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputUser(userId),
-            approved: true,
-        });
+        await this.#c.invoke({ _: "messages.setTyping", peer: await this.#c.getInputPeer(chatId), action: action_, top_msg_id: params?.messageThreadId }, { businessConnectionId: params?.businessConnectionId });
     }
-    async declineJoinRequest(chatId, userId) {
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
-            _: "messages.hideChatJoinRequest",
-            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
-            user_id: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputUser(userId),
-        });
-    }
-    async approveJoinRequests(chatId, params) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("approveJoinRequests");
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
-            _: "messages.hideAllChatJoinRequests",
-            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
-            approved: true,
-            link: params?.inviteLink,
-        });
-    }
-    async declineJoinRequests(chatId, params) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("declineJoinRequests");
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
-            _: "messages.hideAllChatJoinRequests",
-            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
-            link: params?.inviteLink,
+    async searchMessages(params) {
+        this.#c.storage.assertUser("searchMessages");
+        const peer = params?.chatId === undefined ? { _: "inputPeerEmpty" } : await this.#c.getInputPeer(params.chatId);
+        const query = params?.query ?? "";
+        const result = await this.#c.invoke({
+            _: "messages.search",
+            peer,
+            q: query,
+            add_offset: params?.addOffset ?? 0,
+            filter: messageSearchFilterToTlObject(params?.filter ?? "empty"),
+            hash: 0n,
+            limit: getLimit(params?.limit),
+            max_date: 0,
+            max_id: 0,
+            min_date: 0,
+            min_id: 0,
+            offset_id: params?.offset ? params.offset : 0,
+            from_id: params?.from ? await this.#c.getInputPeer(params.from) : undefined,
         });
-    }
-    async searchMessages(chatId, query, params) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("searchMessages");
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.search", peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId), q: query, add_offset: 0, filter: messageSearchFilterToTlObject(params?.filter ?? "empty"), hash: 0n, limit: params?.limit ?? 100, max_date: 0, max_id: 0, min_date: 0, min_id: 0, offset_id: params?.after ? params.after : 0, from_id: params?.from ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.from) : undefined });
         if (!("messages" in result)) {
             unreachable();
         }
+        const count = "count" in result ? result.count : result.messages.length;
         const messages = new Array();
         for (const message_ of result.messages) {
             const message = await this.constructMessage(message_, false);
             messages.push(message);
         }
-        return messages;
-    }
-    async setBoostsRequiredToCircumventRestrictions(chatId, boosts) {
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("setBoostsRequiredToCircumventRestrictions");
-        const channel = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputChannel(chatId);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.setBoostsToUnblockRestrictions", channel, boosts });
-    }
-    async createInviteLink(chatId, params) {
-        if (params?.requireApproval && params?.limit) {
-            throw new InputError("requireApproval cannot be true while limit is specified.");
-        }
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.exportChatInvite", peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId), title: params?.title, expire_date: params?.expireAt ? toUnixTimestamp(params.expireAt) : undefined, request_needed: params?.requireApproval ? true : undefined, usage_limit: params?.limit });
-        return await constructInviteLink(as("chatInviteExported", result), __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity);
-    }
-    async getCreatedInviteLinks(chatId, params) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("getCreatedInviteLinks");
-        const { invites } = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.getExportedChatInvites", peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId), revoked: params?.revoked ? true : undefined, admin_id: params?.by ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputUser(params.by) : { _: "inputUserEmpty" }, limit: params?.limit ?? 100, offset_date: params?.afterDate ? toUnixTimestamp(params.afterDate) : undefined, offset_link: params?.afterInviteLink });
-        return await Promise.all(invites.map((v) => as("chatInviteExported", v)).map((v) => constructInviteLink(v, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity)));
-    }
-    async joinChat(chatId) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("joinChat");
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
-        if (canBeInputUser(peer)) {
-            throw new InputError("Cannot join private chats.");
-        }
-        else if (canBeInputChannel(peer)) {
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.joinChannel", channel: toInputChannel(peer) });
-        }
-        else if (is("inputPeerChat", peer)) {
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.addChatUser", chat_id: peer.chat_id, user_id: { _: "inputUserSelf" }, fwd_limit: 0 }); // TODO: use potential high-level method for adding participants to chats
-        }
-        else {
-            unreachable();
-        }
-    }
-    async leaveChat(chatId) {
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
-        if (canBeInputUser(peer)) {
-            throw new InputError("Cannot leave private chats.");
-        }
-        else if (canBeInputChannel(peer)) {
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.leaveChannel", channel: toInputChannel(peer) });
-        }
-        else if (is("inputPeerChat", peer)) {
-            await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.deleteChatUser", chat_id: peer.chat_id, user_id: { _: "inputUserSelf" } }); // TODO: use potential high-level method for adding participants to chats
-        }
-        else {
-            unreachable();
-        }
+        return { messages, count };
     }
     async blockUser(userId) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("blockUser");
-        const id = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(userId);
-        if (!(is("user", id))) {
-            throw new InputError("Only users can be blocked or unblocked.");
-        }
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "contacts.block", id });
+        this.#c.storage.assertUser("blockUser");
+        const id = await this.#c.getInputPeer(userId);
+        await this.#c.invoke({ _: "contacts.block", id });
     }
     async unblockUser(userId) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("unblockUser");
-        const id = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(userId);
-        if (!(is("user", id))) {
-            throw new InputError("Only users can be blocked or unblocked.");
-        }
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "contacts.unblock", id });
+        this.#c.storage.assertUser("unblockUser");
+        const id = await this.#c.getInputPeer(userId);
+        await this.#c.invoke({ _: "contacts.unblock", id });
     }
     async setChatStickerSet(chatId, setName) {
-        const channel = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputChannel(chatId);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.setStickers", channel, stickerset: { _: "inputStickerSetShortName", short_name: setName } });
+        const channel = await this.#c.getInputChannel(chatId);
+        await this.#c.invoke({ _: "channels.setStickers", channel, stickerset: { _: "inputStickerSetShortName", short_name: setName } });
     }
     async deleteChatStickerSet(chatId) {
-        const channel = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputChannel(chatId);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.setStickers", channel, stickerset: { _: "inputStickerSetEmpty" } });
+        const channel = await this.#c.getInputChannel(chatId);
+        await this.#c.invoke({ _: "channels.setStickers", channel, stickerset: { _: "inputStickerSetEmpty" } });
     }
     async stopPoll(chatId, messageId, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
+        this.#checkParams(params);
         const message = await this.getMessage(chatId, messageId);
         if (!message) {
             throw new InputError("Message not found.");
@@ -1056,41 +1355,46 @@ export class MessageManager {
         if (message.poll.isClosed) {
             throw new InputError("Poll is already stopped.");
         }
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+        const result = await this.#c.invoke({
             _: "messages.editMessage",
-            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+            peer: await this.#c.getInputPeer(chatId),
             id: messageId,
-            media: ({ _: "inputMediaPoll", poll: ({ _: "poll", id: BigInt(message.poll.id), closed: true, question: { _: "textWithEntities", text: "", entities: [] }, answers: [] }) }),
-            reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params),
-        }, params?.businessConnectionId);
-        const message_ = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result))[0];
+            media: { _: "inputMediaPoll", poll: { _: "poll", id: BigInt(message.poll.id), closed: true, question: { _: "textWithEntities", text: "", entities: [] }, answers: [] } },
+            reply_markup: await this.#constructReplyMarkup(params),
+        }, { businessConnectionId: params?.businessConnectionId });
+        const message_ = (await this.updatesToMessages(chatId, result))[0];
         return assertMessageType(message_, "poll").poll;
     }
     async editMessageLiveLocation(chatId, messageId, latitude, longitude, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
+        this.#checkParams(params);
         const message = await this.getMessage(chatId, messageId);
         if (message && "location" in message && message.location.livePeriod) {
-            const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+            const result = await this.#c.invoke({
                 _: "messages.editMessage",
-                peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+                peer: await this.#c.getInputPeer(chatId),
                 id: messageId,
-                media: ({ _: "inputMediaGeoLive", geo_point: ({ _: "inputGeoPoint", lat: latitude, long: longitude, accuracy_radius: params?.horizontalAccuracy }), heading: params?.heading, proximity_notification_radius: params?.proximityAlertRadius }),
-                reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params),
-            }, params?.businessConnectionId);
-            const message = (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result))[0];
+                media: { _: "inputMediaGeoLive", geo_point: { _: "inputGeoPoint", lat: latitude, long: longitude, accuracy_radius: params?.horizontalAccuracy }, heading: params?.heading, proximity_notification_radius: params?.proximityAlertRadius },
+                reply_markup: await this.#constructReplyMarkup(params),
+            }, { businessConnectionId: params?.businessConnectionId });
+            const message = (await this.updatesToMessages(chatId, result))[0];
             return assertMessageType(message, "location");
         }
         unreachable();
     }
     async editInlineMessageLiveLocation(inlineMessageId, latitude, longitude, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertBot("editInlineMessageLiveLocation");
-        const id = deserializeInlineMessageId(inlineMessageId);
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.editInlineBotMessage", id, media: ({ _: "inputMediaGeoLive", geo_point: ({ _: "inputGeoPoint", lat: latitude, long: longitude, accuracy_radius: params?.horizontalAccuracy }), heading: params?.heading, proximity_notification_radius: params?.proximityAlertRadius }), reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params) });
+        this.#checkParams(params);
+        this.#c.storage.assertBot("editInlineMessageLiveLocation");
+        const id = await deserializeInlineMessageId(inlineMessageId);
+        await this.#c.invoke({
+            _: "messages.editInlineBotMessage",
+            id,
+            media: { _: "inputMediaGeoLive", geo_point: { _: "inputGeoPoint", lat: latitude, long: longitude, accuracy_radius: params?.horizontalAccuracy }, heading: params?.heading, proximity_notification_radius: params?.proximityAlertRadius },
+            reply_markup: await this.#constructReplyMarkup(params),
+        }, { dc: getDc(id.dc_id) });
     }
     async sendInvoice(chatId, title, description, payload, currency, prices, params) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertBot("sendInvoice");
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
+        this.#c.storage.assertBot("sendInvoice");
+        this.#checkParams(params);
         if (title.length < 1) {
             throw new InputError("Invoice title cannot be empty.");
         }
@@ -1115,15 +1419,15 @@ export class MessageManager {
             shipping_address_requested: params?.needShippingAddress || undefined,
             email_to_provider: params?.sendEmailToProvider || undefined,
             phone_to_provider: params?.sendPhoneNumberToProvider || undefined,
-            flexible: params?.flexible || undefined,
+            flexible: params?.isFlexible || undefined,
         };
-        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendMedia).call(this, chatId, {
+        const message = await this.#sendMedia(chatId, {
             _: "inputMediaInvoice",
             title,
             description,
             invoice,
             start_param: params?.startParameter,
-            payload: new TextEncoder().encode(payload),
+            payload: encodeText(payload),
             provider_data: { _: "dataJSON", data: params?.providerData ?? "null" },
             provider: params?.providerToken ?? "",
             photo: params?.photoUrl
@@ -1142,44 +1446,8 @@ export class MessageManager {
         }, params);
         return assertMessageType(message, "invoice");
     }
-    async addChatMember(chatId, userId, params) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("addChatMember");
-        const chat = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
-        if (isOneOf(["inputPeerEmpty", "inputPeerSelf", "inputPeerUser", "inputPeerUserFromMessage"], chat)) {
-            throw new InputError("Cannot add members to private chats");
-        }
-        const user = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputUser(userId);
-        if (is("inputPeerChat", chat)) {
-            const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.addChatUser", chat_id: chat.chat_id, user_id: user, fwd_limit: params?.historyLimit ?? 0 });
-            return result.missing_invitees.map(constructFailedInvitation);
-        }
-        else if (is("inputPeerChannel", chat)) {
-            const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.inviteToChannel", channel: { ...chat, _: "inputChannel" }, users: [user] });
-            return result.missing_invitees.map(constructFailedInvitation);
-        }
-        unreachable();
-    }
-    async addChatMembers(chatId, userIds) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("addChatMembers");
-        const chat = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
-        if (isOneOf(["inputPeerEmpty", "inputPeerSelf", "inputPeerUser", "inputPeerUserFromMessage"], chat)) {
-            throw new InputError("Cannot add members to private chats");
-        }
-        const users = new Array();
-        for (const userId of userIds) {
-            users.push(await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputUser(userId));
-        }
-        if (is("inputPeerChat", chat)) {
-            throw new InputError("addChatMembers cannot be used with basic groups");
-        }
-        else if (canBeInputChannel(chat)) {
-            const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.inviteToChannel", channel: toInputChannel(chat), users });
-            return result.missing_invitees.map(constructFailedInvitation);
-        }
-        unreachable();
-    }
     async sendMediaGroup(chatId, media, params) {
-        __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_checkParams).call(this, params);
+        this.#checkParams(params);
         {
             if (!Array.isArray(media) || !media.length) {
                 throw new InputError("Media group must not be empty.");
@@ -1190,13 +1458,13 @@ export class MessageManager {
             for (const media_ of media) {
                 // deno-lint-ignore no-explicit-any
                 const thisMediaType = media_?.animation !== undefined ? "animation" : media_?.audio !== undefined ? "audio" : media_?.photo !== undefined ? "photo" : media_?.video !== undefined ? "video" : "document";
-                if (thisMediaType == "animation") {
+                if (thisMediaType === "animation") {
                     throw new InputError("Media groups cannot consist of animations.");
                 }
-                if ((firstMediaType == "video" || firstMediaType == "photo") && (thisMediaType != "video" && thisMediaType != "photo")) {
+                if ((firstMediaType === "video" || firstMediaType === "photo") && (thisMediaType !== "video" && thisMediaType !== "photo")) {
                     throw new InputError(`Media of the type ${firstMediaType} cannot be mixed with those of the type ${thisMediaType}.`);
                 }
-                if (firstMediaType != "video" && firstMediaType != "photo" && firstMediaType != thisMediaType) {
+                if (firstMediaType !== "video" && firstMediaType !== "photo" && firstMediaType !== thisMediaType) {
                     throw new InputError(`Media of the type ${firstMediaType} cannot be mixed with other types.`);
                 }
             }
@@ -1204,26 +1472,26 @@ export class MessageManager {
         const multiMedia = new Array();
         for (const v of media) {
             const randomId = getRandomId();
-            const [message, entities] = v.caption !== undefined ? await this.parseText(v.caption, { entities: v.captionEntities, parseMode: v.parseMode }) : ["", []];
-            multiMedia.push({ _: "inputSingleMedia", message, entities, random_id: randomId, media: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_resolveInputMedia).call(this, v) });
+            const [message, entities] = v.caption !== undefined ? this.parseText(v.caption, { entities: v.captionEntities, parseMode: v.parseMode }) : ["", []];
+            multiMedia.push({ _: "inputSingleMedia", message, entities, random_id: randomId, media: await this.#resolveInputMedia(v) });
         }
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        const peer = await this.#c.getInputPeer(chatId);
         for (const [i, media_] of multiMedia.entries()) {
-            if (is("inputMediaUploadedPhoto", media_.media)) {
-                const result = as("messageMediaPhoto", await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.uploadMedia", media: media_.media, peer }));
-                const photo = as("photo", result.photo);
+            if (Api.is("inputMediaUploadedPhoto", media_.media)) {
+                const result = Api.as("messageMediaPhoto", await this.#c.invoke({ _: "messages.uploadMedia", media: media_.media, peer }));
+                const photo = Api.as("photo", result.photo);
                 multiMedia[i] = { ...media_, media: { _: "inputMediaPhoto", id: { ...photo, _: "inputPhoto" } } };
             }
-            else if (is("inputMediaUploadedDocument", media_.media)) {
-                const result = as("messageMediaDocument", await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.uploadMedia", media: media_.media, peer }));
-                const document = as("document", result.document);
+            else if (Api.is("inputMediaUploadedDocument", media_.media)) {
+                const result = Api.as("messageMediaDocument", await this.#c.invoke({ _: "messages.uploadMedia", media: media_.media, peer }));
+                const document = Api.as("document", result.document);
                 multiMedia[i] = { ...media_, media: { _: "inputMediaDocument", id: { ...document, _: "inputDocument" } } };
             }
         }
-        const silent = params?.disableNotification ? true : undefined;
-        const noforwards = params?.protectContent ? true : undefined;
-        const sendAs = params?.sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.sendAs) : undefined;
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({
+        const silent = params?.isSilent ? true : undefined;
+        const noforwards = params?.isContentProtected ? true : undefined;
+        const sendAs = params?.sendAs ? await this.#c.getInputPeer(params.sendAs) : undefined;
+        const result = await this.#c.invoke({
             _: "messages.sendMultiMedia",
             peer,
             multi_media: multiMedia,
@@ -1231,19 +1499,19 @@ export class MessageManager {
             noforwards,
             silent,
             send_as: sendAs,
-            reply_to: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
-            allow_paid_floodskip: params?.paidBroadcast ? true : undefined,
+            reply_to: await this.#constructReplyTo(params),
+            allow_paid_floodskip: params?.isPaidBroadcast ? true : undefined,
         });
-        return await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result);
+        return await this.updatesToMessages(chatId, result);
     }
     async readMessages(chatId, untilMessageId) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("readMessages");
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        this.#c.storage.assertUser("readMessages");
+        const peer = await this.#c.getInputPeer(chatId);
         const max_id = untilMessageId;
-        await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.readHistory", peer, max_id });
+        await this.#c.invoke({ _: "messages.readHistory", peer, max_id });
     }
     async startBot(botId, params) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("startBot");
+        this.#c.storage.assertUser("startBot");
         const start_param = params?.deeplink?.trim() || "";
         if (params?.chatId !== undefined && !start_param) {
             throw new InputError("deeplink cannot be unspecified while chatId is specified.");
@@ -1251,242 +1519,267 @@ export class MessageManager {
         if (!params?.deeplink) {
             return await this.sendMessage(botId, "/start");
         }
-        const bot = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputUser(botId);
-        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params?.chatId || botId);
-        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.startBot", bot, peer, random_id: getRandomId(), start_param });
-        return (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, botId, result))[0];
+        const bot = await this.#c.getInputUser(botId);
+        const peer = await this.#c.getInputPeer(params?.chatId || botId);
+        const result = await this.#c.invoke({ _: "messages.startBot", bot, peer, random_id: getRandomId(), start_param });
+        return (await this.updatesToMessages(botId, result))[0];
     }
-}
-_MessageManager_c = new WeakMap(), _MessageManager_LresolveFileId = new WeakMap(), _MessageManager_instances = new WeakSet(), _MessageManager_checkParams = function _MessageManager_checkParams(params) {
-    if (params && "replyMarkup" in params && params.replyMarkup !== undefined) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertBot("replyMarkup");
+    async transcribeVoice(chatId, messageId) {
+        this.#c.storage.assertUser("transcribeVoice");
+        const message = await this.getMessage(chatId, messageId);
+        if (message === null) {
+            throw new InputError("Message not found.");
+        }
+        if (!isMessageType(message, "voice")) {
+            throw new InputError("Message not voice.");
+        }
+        const cachedTranscription = await this.#getCachedVoiceTranscription(message);
+        if (cachedTranscription) {
+            return cachedTranscription;
+        }
+        const peer = await this.#c.getInputPeer(chatId);
+        const result = await this.#c.invoke({ _: "messages.transcribeAudio", peer, msg_id: messageId });
+        return await this.#cacheVoiceTranscription(message, constructVoiceTranscription(result));
     }
-    if (params && "businessConnectionId" in params && params.businessConnectionId !== undefined) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertBot("businessConnectionId");
+    async #getCachedVoiceTranscription(message) {
+        const reference = await this.#c.messageStorage.getVoiceTranscriptionReference(message.chat.id, message.id, fromUnixTimestamp(message.editDate ?? message.date));
+        if (!reference) {
+            return null;
+        }
+        const voiceTranscription = await this.#c.messageStorage.getVoiceTranscription(reference);
+        if (!voiceTranscription || !voiceTranscription.isCompleted) {
+            return null;
+        }
+        return voiceTranscription;
     }
-    if (params && "sendAs" in params && params.sendAs !== undefined) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("sendAs");
+    async #cacheVoiceTranscription(message, voiceTranscription) {
+        await this.#c.messageStorage.setVoiceTranscriptionReference(message.chat.id, message.id, fromUnixTimestamp(message.editDate ?? message.date), BigInt(voiceTranscription.id));
+        await this.#c.messageStorage.setVoiceTranscription(voiceTranscription);
+        return voiceTranscription;
     }
-    if (params && "sendAt" in params && params.sendAt !== undefined) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("businessConsendAtnectionId");
+    async resolveMessageLink(link) {
+        const parseResult = MessageManager.parseMessageLink(link);
+        if (parseResult === null) {
+            throw new InputError("Invalid messsage link.");
+        }
+        const [chatId, messageId] = parseResult;
+        return await this.getMessage(chatId, messageId);
     }
-}, _MessageManager_updatesToMessages = async function _MessageManager_updatesToMessages(chatId, updates, businessConnectionId) {
-    const messages = new Array();
-    if (is("updates", updates)) {
-        for (const update of updates.updates) {
-            if ("message" in update && is("messageEmpty", update.message)) {
-                continue;
-            }
-            if (is("updateNewMessage", update) || is("updateEditMessage", update) || is("updateNewScheduledMessage", update)) {
-                const message = await this.constructMessage(update.message);
-                if (is("updateNewScheduledMessage", update)) {
-                    message.scheduled = true;
+    static parseMessageLink(link) {
+        let url;
+        try {
+            url = new URL(link);
+        }
+        catch (err) {
+            if (err instanceof TypeError) {
+                try {
+                    url = new URL("https://" + link);
+                }
+                catch (err) {
+                    if (err instanceof TypeError) {
+                        return null;
+                    }
+                    else {
+                        throw err;
+                    }
                 }
-                messages.push(message);
-            }
-            else if (is("updateNewChannelMessage", update) || is("updateEditChannelMessage", update)) {
-                messages.push(await this.constructMessage(update.message));
-            }
-            else if (is("updateBotNewBusinessMessage", update)) {
-                messages.push(await this.constructMessage(update.message, false, { connectionId: businessConnectionId ?? update.connection_id, replyToMessage: update.reply_to_message }));
             }
-            else if (is("updateBotEditBusinessMessage", update)) {
-                messages.push(await this.constructMessage(update.message, false, { connectionId: businessConnectionId ?? update.connection_id, replyToMessage: update.reply_to_message }));
+            else {
+                throw err;
             }
         }
-    }
-    else if (is("updateShortSentMessage", updates)) {
-        const message = await this.getMessage(chatId, updates.id);
-        if (message != null) {
-            messages.push(message);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            return null;
         }
-    }
-    return messages;
-}, _MessageManager_constructReplyMarkup = async function _MessageManager_constructReplyMarkup(params) {
-    if (params?.replyMarkup) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertBot("replyMarkup");
-        return await replyMarkupToTlObject(params.replyMarkup, this.usernameResolver.bind(this));
-    }
-}, _MessageManager_resolveSendAs = async function _MessageManager_resolveSendAs(params) {
-    const sendAs = params?.sendAs;
-    if (sendAs !== undefined) {
-        __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("sendAs");
-        return sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(sendAs) : undefined;
-    }
-}, _MessageManager_constructReplyTo = async function _MessageManager_constructReplyTo(params) {
-    const topMsgId = params?.messageThreadId;
-    if (!params?.replyTo) {
-        if (topMsgId) {
-            return { _: "inputReplyToMessage", reply_to_msg_id: topMsgId };
+        if (url.host !== "t.me") {
+            return null;
         }
-        else {
-            return undefined;
+        const parts = url.pathname.split("/").filter((v) => v);
+        if (parts.length < 2) {
+            return null;
         }
-    }
-    if ("messageId" in params.replyTo) {
-        return { _: "inputReplyToMessage", reply_to_msg_id: params.replyTo.messageId, top_msg_id: topMsgId, quote_text: params.replyTo.quote?.text, quote_entities: await Promise.all(params.replyTo.quote?.entities.map((v) => messageEntityToTlObject(v, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity)) ?? []), quote_offset: params.replyTo.quote?.offset };
-    }
-    else {
-        return { _: "inputReplyToStory", peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.replyTo.chatId), story_id: params.replyTo.storyId };
-    }
-}, _MessageManager_sendDocumentInner = async function _MessageManager_sendDocumentInner(chatId, document, params, fileType, otherAttribs, urlSupported = true, expectedMimeTypes) {
-    let media = null;
-    const spoiler = params?.hasSpoiler ? true : undefined;
-    const ttl_seconds = params && "selfDestruct" in params && typeof params.selfDestruct !== undefined ? selfDestructOptionToInt(params.selfDestruct) : undefined;
-    if (typeof document === "string") {
-        const fileId = this.resolveFileId(document, fileType);
-        if (fileId != null) {
-            media = { _: "inputMediaDocument", id: { ...fileId, _: "inputDocument" }, spoiler, query: otherAttribs.find((v) => is("documentAttributeSticker", v))?.alt || undefined, ttl_seconds };
+        if (!isNaN(Number(parts[0]))) {
+            return null;
         }
-    }
-    if (media == null) {
-        if (typeof document === "string" && isHttpUrl(document)) {
-            if (!urlSupported) {
-                throw new InputError("URL not supported.");
+        let peer, id;
+        if (parts[0] === "c") {
+            if (parts.length < 3 || parts.length > 4) {
+                return null;
+            }
+            [peer, id] = [Number(parts[1]), Number(parts[parts.length - 1])];
+            if (isNaN(peer)) {
+                return null;
             }
-            media = { _: "inputMediaDocumentExternal", url: document, spoiler, ttl_seconds };
+            if (isNaN(Number(parts[2]))) {
+                return null;
+            }
+            peer = Api.getChannelChatId(BigInt(peer));
         }
         else {
-            let mimeType;
-            const file = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(document, params, (name) => {
-                mimeType = params?.mimeType ?? contentType(name.split(".").slice(-1)[0]) ?? FALLBACK_MIME_TYPE;
-                if (expectedMimeTypes && !expectedMimeTypes.includes(mimeType)) {
-                    unreachable();
-                }
-                if (name.endsWith(".tgs") && fileType == FileType.Document) {
-                    name += "-";
-                }
-                return name;
-            });
-            if (is("inputFileStoryDocument", file)) {
-                unreachable();
+            if (parts.length > 3) {
+                return null;
+            }
+            [peer, id] = [parts[0], Number(parts[parts.length - 1])];
+            if (isNaN(Number(parts[1]))) {
+                return null;
             }
-            let thumb = undefined;
-            if (params?.thumbnail) {
-                thumb = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(params.thumbnail, { chunkSize: params?.chunkSize, signal: params?.signal });
-            }
-            media = { _: "inputMediaUploadedDocument", file, thumb, spoiler, attributes: [{ _: "documentAttributeFilename", file_name: file.name }, ...otherAttribs], mime_type: mimeType, force_file: fileType == FileType.Document ? true : undefined, ttl_seconds };
-        }
-    }
-    const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendMedia).call(this, chatId, media, params);
-    return message;
-}, _MessageManager_sendMedia = async function _MessageManager_sendMedia(chatId, media, params) {
-    if (params?.starCount !== undefined) {
-        if (params.starCount <= 0) {
-            throw new InputError("starCount cannot be zero or negative");
-        }
-        media = { _: "inputMediaPaidMedia", stars_amount: BigInt(params.starCount), extended_media: [media] };
-    }
-    const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
-    const randomId = getRandomId();
-    const silent = params?.disableNotification ? true : undefined;
-    const noforwards = params?.protectContent ? true : undefined;
-    const sendAs = params?.sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(params.sendAs) : undefined;
-    const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
-    const caption_ = params?.caption;
-    const parseResult = caption_ !== undefined ? await 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").invoke({
-        _: "messages.sendMedia",
-        peer,
-        random_id: randomId,
-        silent,
-        noforwards,
-        reply_markup: replyMarkup,
-        reply_to: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
-        send_as: sendAs,
-        media,
-        message: caption ?? "",
-        entities: captionEntities,
-        effect: params?.effectId ? BigInt(params.effectId) : undefined,
-        schedule_date: params?.sendAt ? toUnixTimestamp(params.sendAt) : undefined,
-        allow_paid_floodskip: params?.paidBroadcast ? true : undefined,
-    }, params?.businessConnectionId);
-    return (await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result, params?.businessConnectionId))[0];
-}, _MessageManager_resolveInputMediaInner = async function _MessageManager_resolveInputMediaInner(document, media, fileType, otherAttribs) {
-    let media_ = null;
-    const spoiler = "hasSpoiler" in media && media.hasSpoiler ? true : undefined;
-    if (typeof document === "string") {
-        const fileId = this.resolveFileId(document, fileType);
-        if (fileId != null) {
-            media_ = { _: "inputMediaDocument", id: { ...fileId, _: "inputDocument" }, spoiler, query: otherAttribs.find((v) => is("documentAttributeSticker", v))?.alt || undefined };
-        }
-    }
-    if (media_ == null) {
-        if (typeof document === "string" && isHttpUrl(document)) {
-            media_ = { _: "inputMediaDocumentExternal", url: document, spoiler };
         }
-        else {
-            let mimeType;
-            const file = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(document, media, (name) => {
-                mimeType = media?.mimeType ?? contentType(name.split(".").slice(-1)[0]) ?? FALLBACK_MIME_TYPE;
-                if (name.endsWith(".tgs") && fileType == FileType.Document) {
-                    name += "-";
+        if (isNaN(id)) {
+            return null;
+        }
+        if (typeof peer === "string") {
+            try {
+                if (getUsername(peer) !== peer) {
+                    return null;
                 }
-                return name;
-            });
-            if (is("inputFileStoryDocument", file)) {
-                unreachable();
             }
-            let thumb = undefined;
-            if ("thumbnail" in media && media.thumbnail) {
-                thumb = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(media.thumbnail, { chunkSize: media?.chunkSize, signal: media?.signal });
+            catch (err) {
+                if (err instanceof InputError) {
+                    return null;
+                }
+                else {
+                    throw err;
+                }
             }
-            media_ = { _: "inputMediaUploadedDocument", file, thumb, spoiler, attributes: [{ _: "documentAttributeFilename", file_name: file.name }, ...otherAttribs], mime_type: mimeType, force_file: fileType == FileType.Document ? true : undefined };
         }
-    }
-    return media_;
-}, _MessageManager_resolveInputMedia = async function _MessageManager_resolveInputMedia(media) {
-    if ("animation" in media) {
-        return await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_resolveInputMediaInner).call(this, media.animation, media, FileType.Animation, [
-            { _: "documentAttributeAnimated" },
-            { _: "documentAttributeVideo", supports_streaming: true, w: media?.width ?? 0, h: media?.height ?? 0, duration: media?.duration ?? 0 },
-        ]);
-    }
-    else if ("audio" in media) {
-        return await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_resolveInputMediaInner).call(this, media.audio, media, FileType.Audio, [
-            { _: "documentAttributeAudio", duration: media?.duration ?? 0, performer: media?.performer, title: media?.title },
-        ]);
-    }
-    else if ("document" in media) {
-        return await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_resolveInputMediaInner).call(this, media.document, media, FileType.Document, []);
-    }
-    else if ("photo" in media) {
-        let media_ = null;
-        const spoiler = media.hasSpoiler ? true : undefined;
-        const ttl_seconds = "selfDestruct" in media && media.selfDestruct !== undefined ? selfDestructOptionToInt(media.selfDestruct) : undefined;
-        if (typeof media.photo === "string") {
-            const fileId = this.resolveFileId(media.photo, [FileType.Photo, FileType.ProfilePhoto]);
-            if (fileId != null) {
-                media_ = { _: "inputMediaPhoto", id: { ...fileId, _: "inputPhoto" }, spoiler, ttl_seconds };
+        return [peer, id];
+    }
+    async getStickerSet(name) {
+        if (name.includes("/")) {
+            let valid = false;
+            try {
+                const url = new URL(name);
+                const pathname = "/addstickers/";
+                valid = (url.protocol === "http:" || url.protocol === "https:") && url.hostname === "t.me" && url.pathname.startsWith(pathname) && url.pathname.length > PackShortNameInvalid.length;
+                if (valid) {
+                    name = url.pathname.slice(pathname.length);
+                    if (name.endsWith("/")) {
+                        name = name.slice(0, -1);
+                        if (name === "") {
+                            valid = false;
+                        }
+                    }
+                }
             }
-        }
-        if (media_ == null) {
-            if (typeof media.photo === "string" && isHttpUrl(media.photo)) {
-                media_ = { _: "inputMediaPhotoExternal", url: media.photo, spoiler };
+            catch (err) {
+                if (err instanceof TypeError) {
+                    valid = false;
+                }
+                else {
+                    throw err;
+                }
             }
-            else {
-                const file = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(media.photo, media, null, false);
-                media_ = { _: "inputMediaUploadedPhoto", file, spoiler, ttl_seconds };
+            if (!valid) {
+                throw new InputError("Invalid sticker set name or link.");
             }
         }
-        return media_;
+        const result = await this.#c.invoke({ _: "messages.getStickerSet", hash: 0, stickerset: { _: "inputStickerSetShortName", short_name: name } });
+        return constructStickerSet(result);
+    }
+    async openMiniApp(botId, chatId, params) {
+        this.#c.storage.assertUser("openMiniApp");
+        const from_bot_menu = params?.isFromMenu ? true : undefined;
+        const silent = params?.isSilent ? true : undefined;
+        const compact = params?.mode === "compact" ? true : undefined;
+        const fullscreen = params?.mode === "fullscreen" ? true : undefined;
+        const peer = await this.#c.getInputPeer(chatId);
+        const bot = await this.#c.getInputUser(botId);
+        const url = params?.url;
+        const start_param = params?.startParameter;
+        const theme_params = params?.themeParameters ? { _: "dataJSON", data: params.themeParameters } : undefined;
+        const platform = this.#c.langPack ?? "";
+        const reply_to = await this.#constructReplyTo(params);
+        const send_as = params?.sendAs ? await this.#c.getInputPeer(params.sendAs) : undefined;
+        const result = await this.#c.invoke({
+            _: "messages.requestWebView",
+            from_bot_menu,
+            silent,
+            compact,
+            fullscreen,
+            peer,
+            bot,
+            url,
+            start_param,
+            theme_params,
+            platform,
+            reply_to,
+            send_as,
+        });
+        return constructMiniAppInfo(result);
     }
-    else if ("video" in media) {
-        const ttl_seconds = "selfDestruct" in media && media.selfDestruct !== undefined ? selfDestructOptionToInt(media.selfDestruct) : undefined;
-        const media_ = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_resolveInputMediaInner).call(this, media.video, media, FileType.Video, [
-            { _: "documentAttributeVideo", supports_streaming: media?.supportsStreaming ? true : undefined, w: media?.width ?? 0, h: media?.height ?? 0, duration: media?.duration ?? 0 },
-        ]);
-        media_.ttl_seconds = ttl_seconds;
-        return media_;
+    async getSavedMessages(chatId, params) {
+        this.#c.storage.assertUser("getSavedMessages");
+        const peer = await this.#c.getInputPeer(chatId);
+        const limit = getLimit(params?.limit);
+        let offsetId = params?.offsetId ?? 0;
+        if (offsetId < 0) {
+            offsetId = 0;
+        }
+        let offsetDate = params?.offsetDate ?? 0;
+        if (offsetDate < 0) {
+            offsetDate = 0;
+        }
+        const result = await this.#c.invoke({
+            _: "messages.getSavedHistory",
+            peer,
+            limit,
+            offset_id: offsetId,
+            offset_date: offsetDate,
+            add_offset: params?.addOffset ?? 0,
+            hash: 0n,
+            max_id: 0,
+            min_id: 0,
+        });
+        if (!("messages" in result)) {
+            unreachable();
+        }
+        const messages = new Array();
+        for (const message_ of result.messages) {
+            const message = await this.constructMessage(message_, false);
+            messages.push(message);
+        }
+        return messages;
     }
-    else {
-        unreachable();
+    async getSavedChats(params) {
+        const limit = getLimit(params?.limit);
+        let offsetId = params?.offsetId ?? 0;
+        if (offsetId < 0) {
+            offsetId = 0;
+        }
+        let offsetDate = params?.offsetDate ?? 0;
+        if (offsetDate < 0) {
+            offsetDate = 0;
+        }
+        let offsetPeer = { _: "inputPeerEmpty" };
+        if (params?.offsetChatId !== undefined) {
+            offsetPeer = await this.#c.getInputPeer(params.offsetChatId);
+        }
+        const result = await this.#c.invoke({
+            _: "messages.getSavedDialogs",
+            hash: 0n,
+            limit,
+            offset_date: offsetDate,
+            offset_id: offsetId,
+            offset_peer: offsetPeer,
+            exclude_pinned: params?.excludePinned || undefined,
+        });
+        return constructSavedChats(result, this.#c.getPeer, this.getMessage.bind(this), this.#c.fileManager.getStickerSetName.bind(this.#c.fileManager));
+    }
+    async getMessageReactions(chatId, messageId, params) {
+        this.#c.storage.assertUser("getMessageReactions");
+        const peer = await this.#c.getInputPeer(chatId);
+        const id = messageId;
+        const reactions = params?.reaction ? reactionToTlObject(params.reaction) : undefined;
+        const offset = params?.offset;
+        const limit = getLimit(params?.limit);
+        const messageReactionsList = await this.#c.invoke({
+            _: "messages.getMessageReactionsList",
+            peer,
+            id,
+            reactions,
+            offset,
+            limit,
+        });
+        return constructMessageReactionList(messageReactionsList);
     }
-}, _MessageManager_sendReaction = async function _MessageManager_sendReaction(chatId, messageId, reactions, params) {
-    await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "messages.sendReaction", peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId), msg_id: checkMessageId(messageId), reaction: reactions.map((v) => reactionToTlObject(v)), big: params?.big ? true : undefined, add_to_recent: params?.addToRecents ? true : undefined });
-}, _MessageManager_toggleJoinRequests = async function _MessageManager_toggleJoinRequests(chatId, enabled) {
-    const channel = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputChannel(chatId);
-    await __classPrivateFieldGet(this, _MessageManager_c, "f").invoke({ _: "channels.toggleJoinRequest", channel, enabled });
-};
+}