@mtkruto/node 0.1.138 → 0.1.140

package/esm/client/2_message_manager.js

@@ -0,0 +1,621 @@
+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_parseText, _MessageManager_updatesToMessages, _MessageManager_usernameResolver, _MessageManager_constructReplyMarkup, _MessageManager_resolveSendAs, _MessageManager_constructReplyTo, _MessageManager_sendDocumentInner, _MessageManager_sendMedia, _MessageManager_resolveFileId;
+import { contentType, debug } from "../0_deps.js";
+import { getRandomId, toUnixTimestamp, UNREACHABLE } from "../1_utilities.js";
+import { as, peerToChatId, types } from "../2_tl.js";
+import { assertMessageType, constructMessage as constructMessage_, FileID, FileType, messageEntityToTlObject, replyMarkupToTlObject } from "../3_types.js";
+import { STICKER_SET_NAME_TTL } from "../4_constants.js";
+import { parseHtml } from "./0_html.js";
+import { getFileContents, isHttpUrl } from "./0_utilities.js";
+const d = debug("MessageManager");
+export class MessageManager {
+    constructor(c) {
+        _MessageManager_instances.add(this);
+        _MessageManager_c.set(this, void 0);
+        _MessageManager_usernameResolver.set(this, async (v) => {
+            const inputPeer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(v).then((v) => v[as](types.InputPeerUser));
+            return new types.InputUser(inputPeer);
+        });
+        __classPrivateFieldSet(this, _MessageManager_c, c, "f");
+    }
+    async getMessages(chatId, messageIds) {
+        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        let messages_ = new Array();
+        const chatId_ = peerToChatId(peer);
+        let shouldFetch = false;
+        for (const messageId of messageIds) {
+            const message = await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.getMessage(chatId_, messageId);
+            if (message == null) {
+                messages_ = [];
+                shouldFetch = true;
+                break;
+            }
+            else {
+                messages_.push(message);
+            }
+        }
+        if (shouldFetch) {
+            if (peer instanceof types.InputPeerChannel) {
+                messages_ = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.getMessages({
+                    channel: new types.InputChannel(peer),
+                    id: messageIds.map((v) => new types.InputMessageID({ id: v })),
+                }).then((v) => v[as](types.messages.ChannelMessages).messages);
+            }
+            else {
+                messages_ = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.getMessages({
+                    id: messageIds.map((v) => new types.InputMessageID({ id: v })),
+                }).then((v) => v[as](types.messages.Messages).messages);
+            }
+        }
+        const messages = new Array();
+        for (const message_ of messages_) {
+            if (message_ instanceof types.MessageEmpty) {
+                continue;
+            }
+            const message = await this.constructMessage(message_);
+            messages.push(message);
+        }
+        return messages;
+    }
+    async getMessageWithReply(chatId, messageId) {
+        const message = await this.getMessage(chatId, messageId);
+        if (message != null && message.replyToMessageId) {
+            message.replyToMessage = await this.getMessage(chatId, message.replyToMessageId) ?? undefined;
+        }
+        return message;
+    }
+    async getMessage(chatId, messageId) {
+        const messages = await this.getMessages(chatId, [messageId]);
+        return messages[0] ?? null;
+    }
+    async getStickerSetName(inputStickerSet, hash = 0) {
+        const maybeStickerSetName = await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.getStickerSetName(inputStickerSet.id, inputStickerSet.access_hash);
+        if (maybeStickerSetName != null && Date.now() - maybeStickerSetName[1].getTime() < STICKER_SET_NAME_TTL) {
+            return maybeStickerSetName[0];
+        }
+        else {
+            const stickerSet = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.getStickerSet({ stickerset: inputStickerSet, hash });
+            const name = stickerSet[as](types.messages.StickerSet).set.short_name;
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.updateStickerSetName(inputStickerSet.id, inputStickerSet.access_hash, name);
+            return name;
+        }
+    }
+    async constructMessage(message_, r) {
+        return await constructMessage_(message_, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity, this.getMessage.bind(this), this.getStickerSetName.bind(this), r);
+    }
+    async forwardMessages(from, to, messageIds, params) {
+        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.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);
+    }
+    async getHistory(chatId, params) {
+        let limit = params?.limit ?? 100;
+        if (limit <= 0) {
+            limit = 1;
+        }
+        else if (limit > 100) {
+            limit = 100;
+        }
+        let offsetId = params?.after?.id ?? 0;
+        if (offsetId < 0) {
+            offsetId = 0;
+        }
+        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        const messages = new Array();
+        for (const message_ of await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.getHistory(peerToChatId(peer), offsetId, limit)) {
+            const message = await this.constructMessage(message_, false);
+            messages.push(message);
+        }
+        if (messages.length < limit) {
+            d("have only %d messages but need %d more", messages.length, limit - messages.length);
+            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").api.messages.getHistory({
+                peer: peer,
+                offset_id: offsetId,
+                offset_date: 0,
+                add_offset: 0,
+                limit,
+                max_id: 0,
+                min_id: 0,
+                hash: 0n,
+            });
+            if (!("messages" in result)) {
+                UNREACHABLE();
+            }
+            for (const message_ of result.messages) {
+                const message = await this.constructMessage(message_, false);
+                messages.push(message);
+            }
+        }
+        return messages;
+    }
+    async sendMessage(chatId, text, params) {
+        const [message, entities] = __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_parseText).call(this, text, params);
+        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
+        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        const randomId = getRandomId();
+        const noWebpage = params?.disableWebPagePreview ? 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 result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.sendMessage({
+            peer,
+            random_id: randomId,
+            message,
+            no_webpage: noWebpage,
+            silent,
+            noforwards,
+            reply_to: __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            send_as: sendAs,
+            entities,
+            reply_markup: replyMarkup,
+        });
+        const message_ = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return assertMessageType(message_, "text");
+    }
+    async sendVenue(chatId, latitude, longitude, title, address, params) {
+        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; // TODO: check default sendAs
+        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
+        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.sendMedia({
+            peer,
+            random_id: randomId,
+            silent,
+            noforwards,
+            reply_to: __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            send_as: sendAs,
+            reply_markup: replyMarkup,
+            media: new types.InputMediaVenue({
+                geo_point: new types.InputGeoPoint({
+                    lat: latitude,
+                    long: longitude,
+                }),
+                title,
+                address,
+                venue_id: params?.foursquareId ?? "",
+                venue_type: params?.foursquareType ?? "",
+                provider: "foursquare",
+            }),
+            message: "",
+        });
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return assertMessageType(message, "venue");
+    }
+    async sendContact(chatId, firstName, number, params) {
+        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; // TODO: check default sendAs
+        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
+        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.sendMedia({
+            peer,
+            random_id: randomId,
+            silent,
+            noforwards,
+            reply_to: __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            send_as: sendAs,
+            reply_markup: replyMarkup,
+            media: new types.InputMediaContact({
+                phone_number: number,
+                first_name: firstName,
+                last_name: params?.lastName ?? "",
+                vcard: params?.vcard ?? "",
+            }),
+            message: "",
+        });
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return assertMessageType(message, "contact");
+    }
+    async sendDice(chatId, params) {
+        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; // TODO: check default sendAs
+        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
+        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.sendMedia({
+            peer,
+            random_id: randomId,
+            silent,
+            noforwards,
+            reply_to: __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            send_as: sendAs,
+            reply_markup: replyMarkup,
+            media: new types.InputMediaDice({
+                emoticon: params?.emoji ?? "🎲",
+            }),
+            message: "",
+        });
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return assertMessageType(message, "dice");
+    }
+    async sendLocation(chatId, latitude, longitude, params) {
+        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; // TODO: check default sendAs
+        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
+        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.sendMedia({
+            peer,
+            random_id: randomId,
+            silent,
+            noforwards,
+            reply_to: __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            send_as: sendAs,
+            reply_markup: replyMarkup,
+            media: params?.livePeriod !== undefined
+                ? new types.InputMediaGeoLive({
+                    geo_point: new types.InputGeoPoint({
+                        lat: latitude,
+                        long: longitude,
+                        accuracy_radius: params?.horizontalAccuracy,
+                    }),
+                    heading: params?.heading,
+                    period: params.livePeriod,
+                    proximity_notification_radius: params?.proximityAlertRadius,
+                })
+                : new types.InputMediaGeoPoint({
+                    geo_point: new types.InputGeoPoint({
+                        lat: latitude,
+                        long: longitude,
+                        accuracy_radius: params?.horizontalAccuracy,
+                    }),
+                }),
+            message: "",
+        });
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return assertMessageType(message, "location");
+    }
+    async sendVideoNote(chatId, audio, params) {
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, audio, params, FileType.VideoNote, [
+            new types.DocumentAttributeVideo({
+                round_message: true,
+                w: params?.length ?? 0,
+                h: params?.length ?? 0,
+                duration: params?.duration ?? 0,
+            }),
+        ], false);
+        return assertMessageType(message, "videoNote");
+    }
+    async sendAudio(chatId, audio, params) {
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, audio, params, FileType.Audio, [
+            new types.DocumentAttributeAudio({
+                duration: params?.duration ?? 0,
+                performer: params?.performer,
+                title: params?.title,
+            }),
+        ]);
+        return assertMessageType(message, "audio");
+    }
+    async sendVoice(chatId, voice, params) {
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, voice, params, FileType.Voice, [
+            new types.DocumentAttributeAudio({
+                voice: true,
+                duration: params?.duration ?? 0,
+            }),
+        ]);
+        return assertMessageType(message, "voice");
+    }
+    async sendAnimation(chatId, animation, params) {
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, animation, params, FileType.Animation, [
+            new types.DocumentAttributeAnimated(),
+            new types.DocumentAttributeVideo({
+                supports_streaming: true,
+                w: params?.width ?? 0,
+                h: params?.height ?? 0,
+                duration: params?.duration ?? 0,
+            }),
+        ]);
+        return assertMessageType(message, "animation");
+    }
+    async sendVideo(chatId, video, params) {
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, video, params, FileType.Video, [
+            new types.DocumentAttributeVideo({
+                supports_streaming: params?.supportsStreaming ? true : undefined,
+                w: params?.width ?? 0,
+                h: params?.height ?? 0,
+                duration: params?.duration ?? 0,
+            }),
+        ]);
+        return assertMessageType(message, "video");
+    }
+    async sendDocument(chatId, document, params) {
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendDocumentInner).call(this, chatId, document, params, FileType.Document, []);
+        return assertMessageType(message, "document");
+    }
+    async sendPhoto(chatId, photo, params) {
+        let media = null;
+        const spoiler = params?.hasSpoiler ? true : undefined;
+        if (typeof photo === "string") {
+            const fileId = __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_resolveFileId).call(this, photo, FileType.Photo);
+            if (fileId != null) {
+                media = new types.InputMediaPhoto({
+                    id: new types.InputPhoto(fileId),
+                    spoiler,
+                });
+            }
+        }
+        if (media == null) {
+            if (typeof photo === "string" && isHttpUrl(photo)) {
+                media = new types.InputMediaPhotoExternal({ url: photo, spoiler });
+            }
+            else {
+                const [contents, fileName] = await getFileContents(photo);
+                const file = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(contents, { fileName, chunkSize: params?.chunkSize, signal: params?.signal });
+                media = new types.InputMediaUploadedPhoto({ file, spoiler });
+            }
+        }
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_sendMedia).call(this, chatId, media, params);
+        return assertMessageType(message, "photo");
+    }
+    async sendPoll(chatId, question, options, params) {
+        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; // TODO: check default sendAs
+        const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
+        const explanation = params?.explanation;
+        const parseResult = explanation !== undefined ? __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_parseText).call(this, explanation, { parseMode: params?.explanationParseMode, entities: params?.explanationEntities }) : undefined;
+        const solution = parseResult === undefined ? undefined : parseResult[0];
+        const solutionEntities = parseResult === undefined ? undefined : parseResult[1];
+        const answers = options.map((v, i) => new types.PollAnswer({ option: new Uint8Array([i]), text: v }));
+        const poll = new types.Poll({
+            id: getRandomId(),
+            answers,
+            question,
+            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 = new types.InputMediaPoll({
+            poll,
+            correct_answers: params?.correctOptionIndex ? [new Uint8Array([params.correctOptionIndex])] : undefined,
+            solution,
+            solution_entities: solutionEntities,
+        });
+        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.sendMedia({
+            peer,
+            random_id: randomId,
+            silent,
+            noforwards,
+            reply_markup: replyMarkup,
+            reply_to: __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+            send_as: sendAs,
+            media,
+            message: "",
+        });
+        const message = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return assertMessageType(message, "poll");
+    }
+    async editMessageReplyMarkup(chatId, messageId, params) {
+        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.editMessage({
+            id: messageId,
+            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+            reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params),
+        });
+        const message_ = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return message_;
+    }
+    async editMessageText(chatId, messageId, text, params) {
+        const [message, entities] = __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_parseText).call(this, text, params);
+        const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.editMessage({
+            id: messageId,
+            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+            entities,
+            message,
+            no_webpage: params?.disableWebPagePreview ? true : undefined,
+            reply_markup: await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params),
+        });
+        const message_ = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+        return assertMessageType(message_, "text");
+    }
+    async deleteMessages(chatId, messageIds, params) {
+        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (peer instanceof types.InputPeerChannel) {
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.deleteMessages({ channel: new types.InputChannel(peer), id: messageIds });
+        }
+        else {
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.deleteMessages({ id: messageIds, revoke: params?.onlyForMe ? undefined : true });
+        }
+    }
+    async deleteChatMemberMessages(chatId, memberId) {
+        const channel = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(channel instanceof types.InputPeerChannel)) {
+            throw new Error("Invalid chat ID");
+        }
+        const participant = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.deleteParticipantHistory({ channel: new types.InputChannel(channel), participant });
+    }
+    async pinMessage(chatId, messageId, params) {
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.updatePinnedMessage({
+            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+            id: messageId,
+            silent: params?.disableNotification ? true : undefined,
+            pm_oneside: params?.bothSides ? undefined : true,
+        });
+    }
+    async unpinMessage(chatId, messageId) {
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.updatePinnedMessage({
+            peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId),
+            id: messageId,
+            unpin: true,
+        });
+    }
+    async unpinMessages(chatId) {
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.unpinAllMessages({ peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId) });
+    }
+}
+_MessageManager_c = new WeakMap(), _MessageManager_usernameResolver = new WeakMap(), _MessageManager_instances = new WeakSet(), _MessageManager_parseText = function _MessageManager_parseText(text, params) {
+    const entities_ = params?.entities ?? [];
+    const parseMode = params?.parseMode ?? __classPrivateFieldGet(this, _MessageManager_c, "f").parseMode;
+    switch (parseMode) {
+        case null:
+            break;
+        case "HTML": {
+            const [newText, entitiesToPush] = parseHtml(text);
+            text = newText;
+            for (const entity of entitiesToPush) {
+                entities_.push(entity);
+            }
+            break;
+        }
+        default:
+            UNREACHABLE();
+    }
+    const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v)) : undefined;
+    return [text, entities];
+}, _MessageManager_updatesToMessages = async function _MessageManager_updatesToMessages(chatId, updates) {
+    const messages = new Array();
+    if (updates instanceof types.Updates) {
+        for (const update of updates.updates) {
+            if ("message" in update && update.message instanceof types.MessageEmpty) {
+                continue;
+            }
+            if (update instanceof types.UpdateNewMessage || update instanceof types.UpdateEditMessage) {
+                messages.push(await this.constructMessage(update.message));
+            }
+            else if (update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateEditChannelMessage) {
+                messages.push(await this.constructMessage(update.message));
+            }
+        }
+    }
+    else if (updates instanceof types.UpdateShortSentMessage) {
+        const message = await this.getMessage(chatId, updates.id);
+        if (message != null) {
+            messages.push(message);
+        }
+    }
+    return messages;
+}, _MessageManager_constructReplyMarkup = async function _MessageManager_constructReplyMarkup(params) {
+    if (params?.replyMarkup) {
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertBot("replyMarkup");
+        return replyMarkupToTlObject(params.replyMarkup, __classPrivateFieldGet(this, _MessageManager_usernameResolver, "f").bind(this));
+    }
+}, _MessageManager_resolveSendAs = async function _MessageManager_resolveSendAs(params) {
+    const sendAs = params?.sendAs;
+    if (sendAs !== undefined) {
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").storage.assertUser("sendAs");
+        return sendAs ? await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(sendAs) : undefined;
+    }
+}, _MessageManager_constructReplyTo = function _MessageManager_constructReplyTo(params) {
+    const topMsgId = params?.messageThreadId;
+    const replyToMsgId = params?.replyToMessageId;
+    return replyToMsgId !== undefined ? new types.InputReplyToMessage({ reply_to_msg_id: replyToMsgId, top_msg_id: topMsgId, quote_text: params?.replyQuote?.text, quote_entities: params?.replyQuote?.entities.map(messageEntityToTlObject), quote_offset: params?.replyQuote?.offset }) : undefined;
+}, _MessageManager_sendDocumentInner = async function _MessageManager_sendDocumentInner(chatId, document, params, fileType, otherAttribs, urlSupported = false) {
+    let media = null;
+    const spoiler = params?.hasSpoiler ? true : undefined;
+    if (typeof document === "string") {
+        const fileId = __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_resolveFileId).call(this, document, fileType);
+        if (fileId != null) {
+            media = new types.InputMediaDocument({
+                id: new types.InputDocument(fileId),
+                spoiler,
+            });
+        }
+    }
+    if (media == null) {
+        if (typeof document === "string" && isHttpUrl(document)) {
+            if (!urlSupported) {
+                throw new Error("URL not supported");
+            }
+            media = new types.InputMediaDocumentExternal({ url: document, spoiler });
+        }
+        else {
+            const [contents, fileName_] = await getFileContents(document);
+            const fileName = params?.fileName ?? fileName_;
+            const mimeType = params?.mimeType ?? contentType(fileName.split(".").slice(-1)[0]) ?? "application/octet-stream";
+            const file = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(contents, { fileName, chunkSize: params?.chunkSize, signal: params?.signal });
+            let thumb = undefined;
+            if (params?.thumbnail) {
+                const [thumbContents, fileName__] = await getFileContents(params.thumbnail);
+                thumb = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(thumbContents, { fileName: fileName__, chunkSize: params?.chunkSize, signal: params?.signal });
+            }
+            media = new types.InputMediaUploadedDocument({
+                file,
+                thumb,
+                spoiler,
+                attributes: [new types.DocumentAttributeFilename({ file_name: fileName }), ...otherAttribs],
+                mime_type: mimeType,
+            });
+        }
+    }
+    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) {
+    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; // TODO: check default sendAs
+    const replyMarkup = await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyMarkup).call(this, params);
+    const caption_ = params?.caption;
+    const parseResult = caption_ !== undefined ? __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_parseText).call(this, caption_, { parseMode: params?.parseMode, entities: params?.captionEntities }) : undefined;
+    const caption = parseResult === undefined ? undefined : parseResult[0];
+    const captionEntities = parseResult === undefined ? undefined : parseResult[1];
+    const result = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.sendMedia({
+        peer,
+        random_id: randomId,
+        silent,
+        noforwards,
+        reply_markup: replyMarkup,
+        reply_to: __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_constructReplyTo).call(this, params),
+        send_as: sendAs,
+        media,
+        message: caption ?? "",
+        entities: captionEntities,
+    });
+    return await __classPrivateFieldGet(this, _MessageManager_instances, "m", _MessageManager_updatesToMessages).call(this, chatId, result).then((v) => v[0]);
+}, _MessageManager_resolveFileId = function _MessageManager_resolveFileId(maybeFileId, expectedFileType) {
+    let fileId = null;
+    try {
+        fileId = FileID.decode(maybeFileId);
+    }
+    catch (err) {
+        d("fileId: %o", err);
+    }
+    if (fileId != null) {
+        if (fileId.fileType != expectedFileType) {
+            UNREACHABLE();
+        }
+        if (fileId.params.mediaId == undefined || fileId.params.accessHash == undefined || fileId.params.fileReference == undefined) {
+            UNREACHABLE();
+        }
+        return {
+            id: fileId.params.mediaId,
+            access_hash: fileId.params.accessHash,
+            file_reference: fileId.params.fileReference,
+        };
+    }
+    return null;
+};

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

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