@mtkruto/node 0.1.142 → 0.1.144

package/esm/3_types.d.ts

@@ -47,6 +47,7 @@ export * from "./types/1_sticker.js";
 export * from "./types/1_user.js";
 export * from "./types/1_video_note.js";
 export * from "./types/1_video.js";
+export * from "./types/2_chat_member.js";
 export * from "./types/2_chosen_inline_result.js";
 export * from "./types/2_game.js";
 export * from "./types/2_inline_keyboard_button.js";

package/esm/3_types.js

@@ -47,6 +47,7 @@ export * from "./types/1_sticker.js";
 export * from "./types/1_user.js";
 export * from "./types/1_video_note.js";
 export * from "./types/1_video.js";
+export * from "./types/2_chat_member.js";
 export * from "./types/2_chosen_inline_result.js";
 export * from "./types/2_game.js";
 export * from "./types/2_inline_keyboard_button.js";

package/esm/4_constants.d.ts

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

package/esm/4_constants.js

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

package/esm/client/0_message.js

@@ -39,11 +39,11 @@ export async function encryptMessage(message, authKey, authKeyId, salt, sessionI
     payloadWriter.write(encoded);
     payloadWriter.write(new Uint8Array(mod(-(payloadWriter.buffer.length + 12), 16) + 12));
     const payload = payloadWriter.buffer;
-    const messageKey = (await sha256(concat(authKey.slice(88, 120), payload))).slice(8, 24);
-    const a = await sha256(concat(messageKey, authKey.slice(0, 36)));
-    const b = await sha256(concat(authKey.slice(40, 76), messageKey));
-    const aesKey = concat(a.slice(0, 8), b.slice(8, 24), a.slice(24, 32));
-    const aesIV = concat(b.slice(0, 8), a.slice(8, 24), b.slice(24, 32));
+    const messageKey = (await sha256(concat(authKey.subarray(88, 120), payload))).subarray(8, 24);
+    const a = await sha256(concat(messageKey, authKey.subarray(0, 36)));
+    const b = await sha256(concat(authKey.subarray(40, 76), messageKey));
+    const aesKey = concat(a.subarray(0, 8), b.subarray(8, 24), a.subarray(24, 32));
+    const aesIV = concat(b.subarray(0, 8), a.subarray(8, 24), b.subarray(24, 32));
     const messageWriter = new TLWriter();
     messageWriter.writeInt64(authKeyId);
     messageWriter.write(messageKey);
@@ -55,10 +55,10 @@ export async function decryptMessage(buffer, authKey, authKeyId, _sessionId) {
     assertEquals(reader.readInt64(false), authKeyId);
     const messageKey_ = reader.readInt128();
     const messageKey = bufferFromBigInt(messageKey_, 16, true, true);
-    const a = await sha256(concat(messageKey, authKey.slice(8, 44)));
-    const b = await sha256(concat(authKey.slice(48, 84), messageKey));
-    const aesKey = concat(a.slice(0, 8), b.slice(8, 24), a.slice(24, 32));
-    const aesIv = concat(b.slice(0, 8), a.slice(8, 24), b.slice(24, 32));
+    const a = await sha256(concat(messageKey, authKey.subarray(8, 44)));
+    const b = await sha256(concat(authKey.subarray(48, 84), messageKey));
+    const aesKey = concat(a.subarray(0, 8), b.subarray(8, 24), a.subarray(24, 32));
+    const aesIv = concat(b.subarray(0, 8), a.subarray(8, 24), b.subarray(24, 32));
     const plaintext = ige256Decrypt(reader.buffer, aesKey, aesIv);
     assertEquals(plaintext.buffer.byteLength % 4, 0);
     let plainReader = new TLReader(plaintext);

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

@@ -34,6 +34,7 @@ export interface C {
     parseMode: ParseMode;
     apiFactory: ApiFactory;
     ignoreOutgoing: boolean | null;
+    cdn: boolean;
 }
 export declare class ConnectionError extends Error {
 }

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

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

package/esm/client/1_bot_info_manager.js

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

package/esm/client/1_file_manager.js

@@ -44,7 +44,7 @@ export class FileManager {
                     try {
                         const start = part * chunkSize;
                         const end = start + chunkSize;
-                        const bytes = contents.slice(start, end);
+                        const bytes = contents.subarray(start, end);
                         if (bytes.length == 0) {
                             continue main;
                         }

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

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

package/esm/client/1_network_statistics_manager.js

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

package/esm/client/2_client_plain.js

@@ -106,8 +106,8 @@ export class ClientPlain extends ClientAbstract {
         d("got server_DH_params_ok");
         const newNonce_ = bufferFromBigInt(newNonce, 32, true, true);
         const serverNonce_ = bufferFromBigInt(serverNonce, 16, true, true);
-        const tmpAesKey = concat(await sha1(concat(newNonce_, serverNonce_)), (await sha1(concat(serverNonce_, newNonce_))).slice(0, 0 + 12));
-        const tmpAesIv = concat((await sha1(concat(serverNonce_, newNonce_))).slice(12, 12 + 8), await sha1(concat(newNonce_, newNonce_)), newNonce_.slice(0, 0 + 4));
+        const tmpAesKey = concat(await sha1(concat(newNonce_, serverNonce_)), (await sha1(concat(serverNonce_, newNonce_))).subarray(0, 0 + 12));
+        const tmpAesIv = concat((await sha1(concat(serverNonce_, newNonce_))).subarray(12, 12 + 8), await sha1(concat(newNonce_, newNonce_)), newNonce_.subarray(0, 0 + 4));
         const answerWithHash = ige256Decrypt(dhParams.encrypted_answer, tmpAesKey, tmpAesIv);
         const dhInnerData = new TLReader(answerWithHash.slice(20)).readObject();
         assertInstanceOf(dhInnerData, types.Server_DH_inner_data);
@@ -130,8 +130,8 @@ export class ClientPlain extends ClientAbstract {
         const dhGenOk = await this.invoke(new functions.set_client_DH_params({ nonce, server_nonce: serverNonce, encrypted_data: encryptedData }));
         assertInstanceOf(dhGenOk, types.Dh_gen_ok);
         d("got dh_gen_ok");
-        const serverNonceSlice = serverNonce_.slice(0, 8);
-        const salt = newNonce_.slice(0, 0 + 8).map((v, i) => v ^ serverNonceSlice[i]);
+        const serverNonceSlice = serverNonce_.subarray(0, 8);
+        const salt = newNonce_.subarray(0, 0 + 8).map((v, i) => v ^ serverNonceSlice[i]);
         const authKey_ = modExp(gA, b, dhPrime);
         const authKey = bufferFromBigInt(authKey_, 256, false, false);
         d("auth key created");

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

@@ -1,6 +1,6 @@
 import { enums, types } from "../2_tl.js";
-import { FileSource, ID, Message, MessageEntity, ParseMode, Reaction, Update, UsernameResolver } from "../3_types.js";
-import { DeleteMessagesParams, EditMessageParams, EditMessageReplyMarkupParams, ForwardMessagesParams, GetHistoryParams, PinMessageParams, SendAnimationParams, SendAudioParams, SendContactParams, SendDiceParams, SendDocumentParams, SendLocationParams, SendMessageParams, SendPhotoParams, SendPollParams, SendVenueParams, SendVideoNoteParams, SendVideoParams, SendVoiceParams } from "./0_params.js";
+import { ChatAction, ChatMember, FileSource, ID, Message, MessageEntity, ParseMode, Reaction, Update, UsernameResolver } from "../3_types.js";
+import { BanChatMemberParams, DeleteMessagesParams, EditMessageParams, EditMessageReplyMarkupParams, ForwardMessagesParams, GetHistoryParams, PinMessageParams, SendAnimationParams, SendAudioParams, SendContactParams, SendDiceParams, SendDocumentParams, SendLocationParams, SendMessageParams, SendPhotoParams, SendPollParams, SendVenueParams, SendVideoNoteParams, SendVideoParams, SendVoiceParams, SetChatMemberRightsParams, SetChatPhotoParams } from "./0_params.js";
 import { AddReactionParams, SetReactionsParams } from "./0_params.js";
 import { C as C_ } from "./0_types.js";
 import { FileManager } from "./1_file_manager.js";
@@ -48,5 +48,14 @@ export declare class MessageManager {
     removeReaction(chatId: number, messageId: number, reaction: Reaction): Promise<void>;
     static canHandleUpdate(update: enums.Update): update is types.UpdateNewMessage | types.UpdateNewChannelMessage | types.UpdateEditMessage | types.UpdateEditChannelMessage | types.UpdateDeleteMessages | types.UpdateDeleteChannelMessages;
     handleUpdate(update: types.UpdateNewMessage | types.UpdateNewChannelMessage | types.UpdateEditMessage | types.UpdateEditChannelMessage | types.UpdateDeleteMessages | types.UpdateDeleteChannelMessages): Promise<Update | null>;
+    sendChatAction(chatId: ID, action: ChatAction, params?: {
+        messageThreadId?: number;
+    }): Promise<void>;
+    deleteChatPhoto(chatId: number): Promise<void>;
+    setChatPhoto(chatId: number, photo: FileSource, params?: SetChatPhotoParams): Promise<void>;
+    banChatMember(chatId: ID, memberId: ID, params?: BanChatMemberParams): Promise<void>;
+    unbanChatMember(chatId: ID, memberId: ID): Promise<void>;
+    setChatMemberRights(chatId: ID, memberId: ID, params?: SetChatMemberRightsParams): Promise<void>;
+    getChatAdministrators(chatId: ID): Promise<ChatMember[]>;
 }
 export {};

package/esm/client/2_message_manager.js

@@ -13,7 +13,7 @@ var _MessageManager_instances, _MessageManager_c, _MessageManager_updatesToMessa
 import { contentType, debug } from "../0_deps.js";
 import { getRandomId, toUnixTimestamp, UNREACHABLE } from "../1_utilities.js";
 import { as, getChannelChatId, peerToChatId, types } from "../2_tl.js";
-import { assertMessageType, constructMessage as constructMessage_, FileID, FileType, messageEntityToTlObject, reactionEqual, reactionToTlObject, replyMarkupToTlObject } from "../3_types.js";
+import { assertMessageType, chatMemberRightsToTlObject, constructChatMember, constructMessage as constructMessage_, FileID, FileType, messageEntityToTlObject, reactionEqual, reactionToTlObject, replyMarkupToTlObject } from "../3_types.js";
 import { STICKER_SET_NAME_TTL } from "../4_constants.js";
 import { parseHtml } from "./0_html.js";
 import { getFileContents, isHttpUrl } from "./0_utilities.js";
@@ -587,6 +587,175 @@ export class MessageManager {
         }
         return null;
     }
+    async sendChatAction(chatId, action, params) {
+        let action_;
+        switch (action) {
+            case "type":
+                action_ = new types.SendMessageTypingAction();
+                break;
+            case "uploadPhoto":
+                action_ = new types.SendMessageUploadPhotoAction({ progress: 0 });
+                break;
+            case "recordVideo":
+                action_ = new types.SendMessageRecordVideoAction();
+                break;
+            case "uploadVideo":
+                action_ = new types.SendMessageRecordVideoAction();
+                break;
+            case "recordVoice":
+                action_ = new types.SendMessageRecordAudioAction();
+                break;
+            case "uploadAudio":
+                action_ = new types.SendMessageUploadAudioAction({ progress: 0 });
+                break;
+            case "uploadDocument":
+                action_ = new types.SendMessageUploadDocumentAction({ progress: 0 });
+                break;
+            case "chooseSticker":
+                action_ = new types.SendMessageChooseStickerAction();
+                break;
+            case "findLocation":
+                action_ = new types.SendMessageGeoLocationAction();
+                break;
+            case "recordVideoNote":
+                action_ = new types.SendMessageRecordRoundAction();
+                break;
+            case "uploadVideoNote":
+                action_ = new types.SendMessageUploadRoundAction({ progress: 0 });
+                break;
+            default:
+                throw new Error("Invalid chat action: " + action);
+        }
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.setTyping({ peer: await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId), action: action_, top_msg_id: params?.messageThreadId });
+    }
+    async deleteChatPhoto(chatId) {
+        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(peer instanceof types.InputPeerChannel) && !(peer instanceof types.InputPeerChat)) {
+            UNREACHABLE();
+        }
+        if (peer instanceof types.InputPeerChannel) {
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.editPhoto({ channel: new types.InputChannel(peer), photo: new types.InputChatPhotoEmpty() });
+        }
+        else if (peer instanceof types.InputPeerChat) {
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.editChatPhoto({ chat_id: peer.chat_id, photo: new types.InputChatPhotoEmpty() });
+        }
+    }
+    async setChatPhoto(chatId, photo, params) {
+        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(peer instanceof types.InputPeerChannel) && !(peer instanceof types.InputPeerChat)) {
+            UNREACHABLE();
+        }
+        const [contents, fileName] = await getFileContents(photo);
+        const file = await __classPrivateFieldGet(this, _MessageManager_c, "f").fileManager.upload(contents, { fileName: params?.fileName ?? fileName, chunkSize: params?.chunkSize, signal: params?.signal });
+        const photo_ = new types.InputChatUploadedPhoto({ file });
+        if (peer instanceof types.InputPeerChannel) {
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.editPhoto({ channel: new types.InputChannel(peer), photo: photo_ });
+        }
+        else if (peer instanceof types.InputPeerChat) {
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.editChatPhoto({ chat_id: peer.chat_id, photo: photo_ });
+        }
+    }
+    async banChatMember(chatId, memberId, params) {
+        const chat = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(chat instanceof types.InputPeerChannel) && !(chat instanceof types.InputPeerChat)) {
+            throw new Error("Invalid chat ID");
+        }
+        const member = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
+        if (chat instanceof types.InputPeerChannel) {
+            if (params?.deleteMessages) {
+                try {
+                    await this.deleteChatMemberMessages(chatId, memberId);
+                }
+                catch {
+                    //
+                }
+            }
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.editBanned({
+                channel: new types.InputChannel(chat),
+                participant: member,
+                banned_rights: new types.ChatBannedRights({
+                    until_date: params?.untilDate ? toUnixTimestamp(params.untilDate) : 0,
+                    view_messages: true,
+                    send_messages: true,
+                    send_media: true,
+                    send_stickers: true,
+                    send_gifs: true,
+                    send_games: true,
+                    send_inline: true,
+                    embed_links: true,
+                }),
+            });
+        }
+        else if (chat instanceof types.InputPeerChat) {
+            if (!(member instanceof types.InputPeerUser)) {
+                throw new Error("Invalid user ID");
+            }
+            await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.deleteChatUser({
+                chat_id: chat.chat_id,
+                user_id: new types.InputUser(member),
+                revoke_history: params?.deleteMessages ? true : undefined,
+            });
+        }
+    }
+    async unbanChatMember(chatId, memberId) {
+        const chat = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(chat instanceof types.InputPeerChannel)) {
+            throw new Error("Invalid chat ID");
+        }
+        const member = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.editBanned({
+            channel: new types.InputChannel(chat),
+            participant: member,
+            banned_rights: new types.ChatBannedRights({ until_date: 0 }),
+        });
+    }
+    async setChatMemberRights(chatId, memberId, params) {
+        const chat = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (!(chat instanceof types.InputPeerChannel)) {
+            throw new Error("Invalid chat ID");
+        }
+        const member = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(memberId);
+        await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.editBanned({
+            channel: new types.InputChannel(chat),
+            participant: member,
+            banned_rights: chatMemberRightsToTlObject(params?.rights, params?.untilDate),
+        });
+    }
+    async getChatAdministrators(chatId) {
+        const peer = await __classPrivateFieldGet(this, _MessageManager_c, "f").getInputPeer(chatId);
+        if (peer instanceof types.InputPeerChannel) {
+            const channel = new types.InputChannel(peer);
+            const participants = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.channels.getParticipants({
+                channel,
+                filter: new types.ChannelParticipantsAdmins(),
+                offset: 0,
+                limit: 100,
+                hash: 0n,
+            });
+            if (participants instanceof types.channels.ChannelParticipantsNotModified) {
+                UNREACHABLE();
+            }
+            const chatMembers = new Array();
+            for (const p of participants.participants) {
+                chatMembers.push(await constructChatMember(p, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity));
+            }
+            return chatMembers;
+        }
+        else if (peer instanceof types.InputPeerChat) {
+            const fullChat = await __classPrivateFieldGet(this, _MessageManager_c, "f").api.messages.getFullChat(peer); // TODO: full chat cache
+            if (!(fullChat.full_chat instanceof types.ChatFull) || !(fullChat.full_chat.participants instanceof types.ChatParticipants)) {
+                UNREACHABLE();
+            }
+            const chatMembers = new Array();
+            for (const p of fullChat.full_chat.participants.participants) {
+                chatMembers.push(await constructChatMember(p, __classPrivateFieldGet(this, _MessageManager_c, "f").getEntity));
+            }
+            return chatMembers;
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
 }
 _MessageManager_c = new WeakMap(), _MessageManager_instances = new WeakSet(), _MessageManager_updatesToMessages = async function _MessageManager_updatesToMessages(chatId, updates) {
     const messages = new Array();

package/esm/client/3_callback_query_manager.js

@@ -30,7 +30,7 @@ export class CallbackQueryManager {
         return update instanceof types.UpdateBotCallbackQuery || update instanceof types.UpdateInlineBotCallbackQuery;
     }
     async handleUpdate(update) {
-        return { callbackQuery: await constructCallbackQuery(update, __classPrivateFieldGet(this, _CallbackQueryManager_c, "f").getEntity, __classPrivateFieldGet(this, _CallbackQueryManager_c, "f").messageManager.getMessageWithReply.bind(this)) };
+        return { callbackQuery: await constructCallbackQuery(update, __classPrivateFieldGet(this, _CallbackQueryManager_c, "f").getEntity, __classPrivateFieldGet(this, _CallbackQueryManager_c, "f").messageManager.getMessageWithReply.bind(__classPrivateFieldGet(this, _CallbackQueryManager_c, "f").messageManager)) };
     }
 }
 _CallbackQueryManager_c = new WeakMap();

package/esm/client/3_inline_query_manager.js

@@ -19,9 +19,10 @@ export class InlineQueryManager {
         __classPrivateFieldSet(this, _InlineQueryManager_c, c, "f");
     }
     async answerInlineQuery(id, results, params) {
+        await __classPrivateFieldGet(this, _InlineQueryManager_c, "f").storage.assertBot("answerInlineQuery");
         await __classPrivateFieldGet(this, _InlineQueryManager_c, "f").api.messages.setInlineBotResults({
             query_id: BigInt(id),
-            results: await Promise.all(results.map((v) => inlineQueryResultToTlObject(v, __classPrivateFieldGet(this, _InlineQueryManager_c, "f").messageManager.parseText.bind(this), __classPrivateFieldGet(this, _InlineQueryManager_c, "f").messageManager.usernameResolver.bind(this)))),
+            results: await Promise.all(results.map((v) => inlineQueryResultToTlObject(v, __classPrivateFieldGet(this, _InlineQueryManager_c, "f").messageManager.parseText.bind(__classPrivateFieldGet(this, _InlineQueryManager_c, "f").messageManager), __classPrivateFieldGet(this, _InlineQueryManager_c, "f").messageManager.usernameResolver.bind(__classPrivateFieldGet(this, _InlineQueryManager_c, "f").messageManager)))),
             cache_time: params?.cacheTime ?? 300,
             private: params?.isPersonal ? true : undefined,
             switch_webview: params?.button && params.button.webApp ? new types.InlineBotWebView({ text: params.button.text, url: params.button.webApp.url }) : undefined,

package/esm/client/4_client.d.ts

@@ -2,7 +2,7 @@ import { MaybePromise } from "../1_utilities.js";
 import { functions, types } from "../2_tl.js";
 import { Storage } from "../3_storage.js";
 import { DC } from "../3_transport.js";
-import { BotCommand, Chat, ChatAction, ChatP, Document, FileSource, ID, InlineQueryResult, Message, MessageAnimation, MessageAudio, MessageContact, MessageDice, MessageDocument, MessageLocation, MessagePhoto, MessagePoll, MessageText, MessageVenue, MessageVideo, MessageVideoNote, MessageVoice, NetworkStatistics, ParseMode, Reaction, Update, UpdateIntersection, User } from "../3_types.js";
+import { BotCommand, Chat, ChatAction, ChatMember, ChatP, Document, FileSource, ID, InlineQueryResult, Message, MessageAnimation, MessageAudio, MessageContact, MessageDice, MessageDocument, MessageLocation, MessagePhoto, MessagePoll, MessageText, MessageVenue, MessageVideo, MessageVideoNote, MessageVoice, NetworkStatistics, ParseMode, Reaction, Update, UpdateIntersection, User } from "../3_types.js";
 import { Migrate } from "../4_errors.js";
 import { ClientAbstract } from "./0_client_abstract.js";
 import { FilterQuery, WithFilter } from "./0_filters.js";
@@ -74,6 +74,8 @@ export interface Context {
     kickSender: () => Promise<void>;
     /** Set the rights of the received message. */
     setSenderRights: (params?: SetChatMemberRightsParams) => Promise<void>;
+    /** Get the administrators of the chat which the message was received from. */
+    getChatAdministrators: () => Promise<ChatMember[]>;
     /** Change the reactions made to the received message. */
     react: (reactions: Reaction[], params?: SetReactionsParams) => Promise<void>;
     /** Send a chat action to the chat which the message was received from. */
@@ -84,9 +86,9 @@ export interface Context {
     editMessageText: (messageId: number, text: string, params?: EditMessageParams) => Promise<MessageText>;
     /** Edit the reply markup of a message in the chat which the message was received from. */
     editMessageReplyMarkup: (messageId: number, params?: EditMessageReplyMarkupParams) => Promise<Message>;
-    /** Answer the received callback query. */
+    /** Answer the received callback query. Bot-only. */
     answerCallbackQuery: (params?: AnswerCallbackQueryParams) => Promise<void>;
-    /** Answer the received inline query. */
+    /** Answer the received inline query. Bot-only */
     answerInlineQuery: (results: InlineQueryResult[], params?: AnswerInlineQueryParams) => Promise<void>;
     /** Retrieve a single message of the chat which the message was received from. */
     getMessage: (messageId: number) => Promise<Message | null>;
@@ -236,6 +238,15 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
     private [getEntity];
     private [getEntity];
     private [getEntity];
+    use(...middleware: Middleware<UpdateIntersection<C>>[]): Composer<UpdateIntersection<C>>;
+    branch(predicate: (ctx: UpdateIntersection<C>) => MaybePromise<boolean>, trueHandler_: Middleware<UpdateIntersection<C>>, falseHandler_: Middleware<UpdateIntersection<C>>): Composer<UpdateIntersection<C>>;
+    filter<D extends C>(predicate: (ctx: UpdateIntersection<C>) => ctx is D, ...middleware: Middleware<D>[]): Composer<D>;
+    filter(predicate: (ctx: UpdateIntersection<C>) => MaybePromise<boolean>, ...middleware: Middleware<UpdateIntersection<C>>[]): Composer<C>;
+    on<Q extends FilterQuery>(filter: Q, ...middleawre: Middleware<WithFilter<C, Q>>[]): Composer<UpdateIntersection<WithFilter<C, Q>>>;
+    command(commands: string | RegExp | (string | RegExp)[] | {
+        names: string | RegExp | (string | RegExp)[];
+        prefixes: string | string[];
+    }, ...middleawre: Middleware<WithFilter<C, "message:text">>[]): Composer<UpdateIntersection<WithFilter<C, "message:text">>>;
     /**
      * Send a text message.
      *
@@ -327,15 +338,6 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      * @method
      */
     getMe(): Promise<User>;
-    use(...middleware: Middleware<UpdateIntersection<C>>[]): Composer<UpdateIntersection<C>>;
-    branch(predicate: (ctx: UpdateIntersection<C>) => MaybePromise<boolean>, trueHandler_: Middleware<UpdateIntersection<C>>, falseHandler_: Middleware<UpdateIntersection<C>>): Composer<UpdateIntersection<C>>;
-    filter<D extends C>(predicate: (ctx: UpdateIntersection<C>) => ctx is D, ...middleware: Middleware<D>[]): Composer<D>;
-    filter(predicate: (ctx: UpdateIntersection<C>) => MaybePromise<boolean>, ...middleware: Middleware<UpdateIntersection<C>>[]): Composer<C>;
-    on<Q extends FilterQuery>(filter: Q, ...middleawre: Middleware<WithFilter<C, Q>>[]): Composer<UpdateIntersection<WithFilter<C, Q>>>;
-    command(commands: string | RegExp | (string | RegExp)[] | {
-        names: string | RegExp | (string | RegExp)[];
-        prefixes: string | string[];
-    }, ...middleawre: Middleware<WithFilter<C, "message:text">>[]): Composer<UpdateIntersection<WithFilter<C, "message:text">>>;
     /**
      * Answer a callback query. Bot-only.
      *
@@ -694,5 +696,12 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      * @param memberId The identifier of a member.
      */
     setChatMemberRights(chatId: ID, memberId: ID, params?: SetChatMemberRightsParams): Promise<void>;
+    /**
+     * Get the administrators of a chat.
+     *
+     * @method
+     * @param chatId The identifier of the chat.
+     */
+    getChatAdministrators(chatId: ID): Promise<ChatMember[]>;
 }
 export {};