@mtkruto/node 0.0.834 → 0.0.835

package/esm/types/1_keyboard_button.js

@@ -0,0 +1,133 @@
+import { UNREACHABLE } from "../utilities/0_control.js";
+import { as } from "../tl/1_tl_object.js";
+import * as types from "../tl/2_types.js";
+import { chatAdministratorRightsToTlObject, constructChatAdministratorRights } from "./0_chat_administrator_rights.js";
+export function constructKeyboardButton(button_) {
+    if (button_ instanceof types.KeyboardButton) {
+        return { text: button_.text };
+    }
+    else if (button_ instanceof types.KeyboardButtonRequestPeer) {
+        if (button_.peerType instanceof types.RequestPeerTypeUser) {
+            return {
+                text: button_.text,
+                requestUser: {
+                    requestId: button_.buttonId,
+                    userIsBot: button_.peerType.bot || false,
+                    userIsPremium: button_.peerType.premium || false,
+                },
+            };
+        }
+        else if (button_.peerType instanceof types.RequestPeerTypeChat) {
+            const button = {
+                text: button_.text,
+                requestChat: {
+                    requestId: button_.buttonId,
+                    chatIsChannel: false,
+                    chatIsForum: button_.peerType.forum || false,
+                    chatHasUsername: button_.peerType.hasUsername || false,
+                    chatIsCreated: button_.peerType.creator || false,
+                    botIsMember: button_.peerType.botParticipant || false,
+                },
+            };
+            if (button_.peerType.botAdminRights) {
+                button.requestChat.botAdministratorRights = constructChatAdministratorRights(button_.peerType.botAdminRights[as](types.ChatAdminRights));
+            }
+            if (button_.peerType.userAdminRights) {
+                button.requestChat.userAdministratorRights = constructChatAdministratorRights(button_.peerType.userAdminRights[as](types.ChatAdminRights));
+            }
+            return button;
+        }
+        else if (button_.peerType instanceof types.RequestPeerTypeBroadcast) {
+            const button = {
+                text: button_.text,
+                requestChat: {
+                    requestId: button_.buttonId,
+                    chatIsChannel: true,
+                    chatIsCreated: button_.peerType.creator || false,
+                    chatHasUsername: button_.peerType.hasUsername || false,
+                },
+            };
+            if (button_.peerType.botAdminRights) {
+                button.requestChat.botAdministratorRights = constructChatAdministratorRights(button_.peerType.botAdminRights[as](types.ChatAdminRights));
+            }
+            if (button_.peerType.userAdminRights) {
+                button.requestChat.userAdministratorRights = constructChatAdministratorRights(button_.peerType.userAdminRights[as](types.ChatAdminRights));
+            }
+            return button;
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
+    else if (button_ instanceof types.KeyboardButtonRequestPhone) {
+        return { text: button_.text, requestContact: true };
+    }
+    else if (button_ instanceof types.KeyboardButtonRequestGeoLocation) {
+        return { text: button_.text, requestLocation: true };
+    }
+    else if (button_ instanceof types.KeyboardButtonRequestPoll) {
+        const button = { text: button_.text, requestPoll: {} };
+        if (button_.quiz) {
+            button.requestPoll.type = "quiz";
+        }
+        return button;
+    }
+    else if (button_ instanceof types.KeyboardButtonWebView || button_ instanceof types.KeyboardButtonSimpleWebView) {
+        return { text: button_.text, webApp: { url: button_.url } };
+    }
+    else {
+        UNREACHABLE();
+    }
+}
+export function keyboardButtonToTlObject(button) {
+    if ("requestUser" in button) {
+        return new types.KeyboardButtonRequestPeer({
+            text: button.text,
+            buttonId: button.requestUser.requestId,
+            peerType: new types.RequestPeerTypeUser({ bot: button.requestUser.userIsBot, premium: button.requestUser.userIsPremium }),
+        });
+    }
+    else if ("requestChat" in button) {
+        if (!button.requestChat.chatIsChannel) { // GUESS
+            return new types.KeyboardButtonRequestPeer({
+                text: button.text,
+                buttonId: button.requestChat.requestId,
+                peerType: new types.RequestPeerTypeChat({
+                    forum: button.requestChat.chatIsForum,
+                    hasUsername: button.requestChat.chatHasUsername,
+                    creator: button.requestChat.chatIsCreated || undefined,
+                    botParticipant: button.requestChat.botIsMember || undefined,
+                    botAdminRights: button.requestChat.botAdministratorRights ? chatAdministratorRightsToTlObject(button.requestChat.botAdministratorRights) : undefined,
+                    userAdminRights: button.requestChat.userAdministratorRights ? chatAdministratorRightsToTlObject(button.requestChat.userAdministratorRights) : undefined,
+                }),
+            });
+        }
+        else {
+            return new types.KeyboardButtonRequestPeer({
+                text: button.text,
+                buttonId: button.requestChat.requestId,
+                peerType: new types.RequestPeerTypeBroadcast({
+                    hasUsername: button.requestChat.chatHasUsername,
+                    creator: button.requestChat.chatIsCreated || undefined,
+                    botAdminRights: button.requestChat.botAdministratorRights ? chatAdministratorRightsToTlObject(button.requestChat.botAdministratorRights) : undefined,
+                    userAdminRights: button.requestChat.userAdministratorRights ? chatAdministratorRightsToTlObject(button.requestChat.userAdministratorRights) : undefined,
+                }),
+            });
+        }
+    }
+    else if ("requestContact" in button) {
+        return new types.KeyboardButtonRequestPhone({ text: button.text });
+    }
+    else if ("requestLocation" in button) {
+        return new types.KeyboardButtonRequestGeoLocation({ text: button.text });
+    }
+    else if ("requestPoll" in button) {
+        return new types.KeyboardButtonRequestPoll({ text: button.text, quiz: button.requestPoll.type == "quiz" });
+    }
+    else if ("webApp" in button) {
+        return new types.KeyboardButtonWebView({ text: button.text, url: button.webApp.url });
+    }
+    else {
+        UNREACHABLE();
+    }
+}

package/esm/types/1_user.d.ts

@@ -0,0 +1,19 @@
+import * as types from "../tl/2_types.js";
+import { ChatPhoto } from "./0_chat_photo.js";
+export interface User {
+    id: number;
+    isBot: boolean;
+    firstName: string;
+    lastName?: string;
+    username?: string;
+    also?: string[];
+    photo?: ChatPhoto.User;
+    languageCode?: string;
+    isScam: boolean;
+    isFake: boolean;
+    isPremium: boolean;
+    isVerified: boolean;
+    isSupport: boolean;
+    addedToAttachmentMenu: boolean;
+}
+export declare function constructUser(user_: types.User): User;

package/esm/types/1_user.js

@@ -0,0 +1,25 @@
+import { cleanObject } from "../utilities/0_object.js";
+import { as } from "../tl/1_tl_object.js";
+import * as types from "../tl/2_types.js";
+import { constructChatPhoto } from "./0_chat_photo.js";
+export function constructUser(user_) {
+    const user = {
+        id: Number(user_.id),
+        isBot: user_.bot || false,
+        firstName: user_.firstName || "",
+        lastName: user_.lastName,
+        username: user_.username,
+        also: user_.usernames?.map((v) => v[as](types.Username)).map((v) => v.username),
+        languageCode: user_.langCode,
+        isScam: user_.scam || false,
+        isFake: user_.fake || false,
+        isPremium: user_.premium || false,
+        isVerified: user_.verified || false,
+        isSupport: user_.support || false,
+        addedToAttachmentMenu: user_.attachMenuEnabled || false,
+    };
+    if (user_.photo instanceof types.UserProfilePhoto) {
+        user.photo = constructChatPhoto(user_.photo);
+    }
+    return cleanObject(user);
+}

package/esm/types/2_inline_keyboard_markup.d.ts

@@ -0,0 +1,7 @@
+import * as types from "../tl/2_types.js";
+import { InlineKeyboardButton, inlineKeyboardButtonToTlObject } from "./1_inline_keyboard_button.js";
+export interface InlineKeyboardMarkup {
+    inlineKeyboard: InlineKeyboardButton[][];
+}
+export declare function constructInlineKeyboardMarkup(keyboard_: types.ReplyInlineMarkup): InlineKeyboardMarkup;
+export declare function inlineKeyboardMarkupToTlObject(keyboard: InlineKeyboardMarkup, usernameResolver: Parameters<typeof inlineKeyboardButtonToTlObject>[1]): Promise<types.ReplyInlineMarkup>;

package/esm/types/2_inline_keyboard_markup.js

@@ -0,0 +1,25 @@
+import { as } from "../tl/1_tl_object.js";
+import * as types from "../tl/2_types.js";
+import { constructInlineKeyboardButton, inlineKeyboardButtonToTlObject } from "./1_inline_keyboard_button.js";
+export function constructInlineKeyboardMarkup(keyboard_) {
+    const rows = new Array();
+    for (const row_ of keyboard_.rows.map((v) => v[as](types.KeyboardButtonRow))) {
+        const row = new Array();
+        for (const button_ of row_.buttons) {
+            row.push(constructInlineKeyboardButton(button_));
+        }
+        rows.push(row);
+    }
+    return { inlineKeyboard: rows };
+}
+export async function inlineKeyboardMarkupToTlObject(keyboard, usernameResolver) {
+    const rows_ = new Array();
+    for (const row of keyboard.inlineKeyboard) {
+        const row_ = new Array();
+        for (const button of row) {
+            row_.push(await inlineKeyboardButtonToTlObject(button, usernameResolver));
+        }
+        rows_.push(new types.KeyboardButtonRow({ buttons: row_ }));
+    }
+    return new types.ReplyInlineMarkup({ rows: rows_ });
+}

package/esm/types/2_reply_keyboard_markup.d.ts

@@ -0,0 +1,12 @@
+import * as types from "../tl/2_types.js";
+import { KeyboardButton } from "./1_keyboard_button.js";
+export interface ReplyKeyboardMarkup {
+    keyboard: KeyboardButton[][];
+    isPersistent?: boolean;
+    resizeKeyboard?: boolean;
+    oneTimeKeyboard?: boolean;
+    inputFieldPlaceholder?: string;
+    selective?: boolean;
+}
+export declare function constructReplyKeyboardMarkup(keyboard_: types.ReplyKeyboardMarkup): ReplyKeyboardMarkup;
+export declare function replyKeyboardMarkupToTlObject(replyMarkup: ReplyKeyboardMarkup): types.ReplyKeyboardMarkup;

package/esm/types/2_reply_keyboard_markup.js

@@ -0,0 +1,37 @@
+import { as } from "../tl/1_tl_object.js";
+import * as types from "../tl/2_types.js";
+import { constructKeyboardButton, keyboardButtonToTlObject } from "./1_keyboard_button.js";
+export function constructReplyKeyboardMarkup(keyboard_) {
+    const rows = new Array();
+    for (const row_ of keyboard_.rows.map((v) => v[as](types.KeyboardButtonRow))) {
+        const row = new Array();
+        for (const button_ of row_.buttons) {
+            row.push(constructKeyboardButton(button_));
+        }
+        rows.push(row);
+    }
+    return {
+        resizeKeyboard: keyboard_.resize || false,
+        oneTimeKeyboard: keyboard_.singleUse || false,
+        selective: keyboard_.selective || false,
+        isPersistent: keyboard_.persistent || false,
+        keyboard: rows,
+    };
+}
+export function replyKeyboardMarkupToTlObject(replyMarkup) {
+    const rows_ = new Array();
+    for (const row of replyMarkup.keyboard) {
+        const row_ = new Array();
+        for (const button of row) {
+            row_.push(keyboardButtonToTlObject(button));
+        }
+        rows_.push(new types.KeyboardButtonRow({ buttons: row_ }));
+    }
+    return new types.ReplyKeyboardMarkup({
+        resize: replyMarkup.resizeKeyboard || undefined,
+        singleUse: replyMarkup.oneTimeKeyboard || undefined,
+        selective: replyMarkup.selective || undefined,
+        persistent: replyMarkup.isPersistent || undefined,
+        rows: rows_,
+    });
+}

package/esm/types/3_message.d.ts

@@ -0,0 +1,22 @@
+import * as types from "../tl/2_types.js";
+import { ForceReply } from "./0_force_reply.js";
+import { MessageEntity } from "./0_message_entity.js";
+import { ReplyKeyboardRemove } from "./0_reply_keyboard_remove.js";
+import { Chat } from "./1_chat.js";
+import { User } from "./1_user.js";
+import { InlineKeyboardMarkup } from "./2_inline_keyboard_markup.js";
+import { ReplyKeyboardMarkup } from "./2_reply_keyboard_markup.js";
+export interface Message {
+    id: number;
+    from?: User;
+    chat: Chat;
+    text?: string;
+    caption?: string;
+    entities?: MessageEntity[];
+    captionEntities?: MessageEntity[];
+    date?: Date;
+    editDate?: Date;
+    views?: number;
+    replyMarkup?: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
+}
+export declare function constructMessage(message_: types.Message, users: types.TypeUser[], chats: types.TypeChat[]): Message;

package/esm/types/3_message.js

@@ -0,0 +1,87 @@
+import { UNREACHABLE } from "../utilities/0_control.js";
+import { cleanObject } from "../utilities/0_object.js";
+import * as types from "../tl/2_types.js";
+import { constructForceReply } from "./0_force_reply.js";
+import { constructMessageEntity } from "./0_message_entity.js";
+import { constructReplyKeyboardRemove } from "./0_reply_keyboard_remove.js";
+import { constructChat } from "./1_chat.js";
+import { constructUser } from "./1_user.js";
+import { constructInlineKeyboardMarkup } from "./2_inline_keyboard_markup.js";
+import { constructReplyKeyboardMarkup } from "./2_reply_keyboard_markup.js";
+export function constructMessage(message_, users, chats) {
+    let chat_ = null;
+    if (message_.peerId instanceof types.PeerUser) {
+        for (const user of users) {
+            if (user instanceof types.User && user.id == message_.peerId.userId) {
+                chat_ = constructChat(user);
+                break;
+            }
+        }
+    }
+    else if (message_.peerId instanceof types.PeerChat) {
+        for (const chat of chats) {
+            if (chat instanceof types.Chat && chat.id == message_.peerId.chatId) {
+                chat_ = constructChat(chat);
+                break;
+            }
+        }
+    }
+    else if (message_.peerId instanceof types.PeerChannel) {
+        for (const chat of chats) {
+            if (chat instanceof types.Channel && chat.id == message_.peerId.channelId) {
+                chat_ = constructChat(chat);
+                break;
+            }
+        }
+    }
+    if (!chat_) {
+        UNREACHABLE();
+    }
+    const message = { id: message_.id, chat: chat_, views: message_.views };
+    if (message_.fromId instanceof types.PeerUser) {
+        for (const user of users) {
+            if (user instanceof types.User && user.id == message_.fromId.userId) {
+                message.from = constructUser(user);
+                break;
+            }
+        }
+    }
+    if (message_.message) {
+        if (message_.media == undefined) {
+            message.text = message_.message;
+        }
+        else {
+            message.caption = message_.message;
+        }
+    }
+    if (message_.entities != undefined) {
+        if (message_.media == undefined) {
+            message.entities = message_.entities.map(constructMessageEntity).filter((v) => v);
+        }
+        else {
+            message.captionEntities = message_.entities.map(constructMessageEntity).filter((v) => v);
+        }
+    }
+    message.date = new Date(message_.date * 1000);
+    if (message_.editDate != undefined) {
+        message.editDate = new Date(message_.editDate * 1000);
+    }
+    if (message_.replyMarkup) {
+        if (message_.replyMarkup instanceof types.ReplyKeyboardMarkup) {
+            message.replyMarkup = constructReplyKeyboardMarkup(message_.replyMarkup);
+        }
+        else if (message_.replyMarkup instanceof types.ReplyInlineMarkup) {
+            message.replyMarkup = constructInlineKeyboardMarkup(message_.replyMarkup);
+        }
+        else if (message_.replyMarkup instanceof types.ReplyKeyboardHide) {
+            message.replyMarkup = constructReplyKeyboardRemove(message_.replyMarkup);
+        }
+        else if (message_.replyMarkup instanceof types.ReplyKeyboardForceReply) {
+            message.replyMarkup = constructForceReply(message_.replyMarkup);
+        }
+        else {
+            UNREACHABLE();
+        }
+    }
+    return cleanObject(message);
+}

package/esm/utilities/0_control.d.ts

@@ -0,0 +1 @@
+export declare function UNREACHABLE(): never;

package/esm/utilities/0_control.js

@@ -0,0 +1,3 @@
+export function UNREACHABLE() {
+    throw new Error("Unreachable");
+}

package/esm/utilities/0_object.d.ts

@@ -0,0 +1 @@
+export declare function cleanObject<T extends Record<string, any>>(object: T): T;

package/esm/utilities/0_object.js

@@ -0,0 +1,14 @@
+// deno-lint-ignore no-explicit-any
+export function cleanObject(object) {
+    for (const [k, v] of Object.entries(object)) {
+        switch (typeof v) {
+            case "undefined":
+                delete object[k];
+                break;
+            case "object":
+                // @ts-ignore: this works, no idea why it complains
+                object[k] = cleanObject(v);
+        }
+    }
+    return object;
+}

package/esm/utilities/0_types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/mod.js",
   "main": "./script/mod.js",
   "name": "@mtkruto/node",
-  "version": "0.0.834",
+  "version": "0.0.835",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "license": "LGPL-3.0-or-later",

package/script/client/client.d.ts

@@ -1,10 +1,14 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import * as types from "../tl/2_types.js";
 import * as functions from "../tl/3_functions.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { Storage } from "../storage/storage.js";
 import { DC, TransportProvider } from "../transport/transport_provider.js";
 import { MessageEntity } from "../types/0_message_entity.js";
+import { ReplyKeyboardRemove } from "../types/0_reply_keyboard_remove.js";
+import { ForceReply } from "../types/0_force_reply.js";
+import { ReplyKeyboardMarkup } from "../types/2_reply_keyboard_markup.js";
+import { InlineKeyboardMarkup } from "../types/2_inline_keyboard_markup.js";
 export declare const restartAuth: unique symbol;
 export declare enum ParseMode {
     None = "none",
@@ -136,5 +140,6 @@ export declare class Client extends ClientAbstract {
         replyToMessageId?: number;
         messageThreadId?: number;
         sendAs?: number | string;
-    }): Promise<types.TypeUpdates>;
+        replyMarkup?: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
+    }): Promise<import("../types/3_message.js").Message>;
 }

package/script/client/client.js

@@ -27,6 +27,8 @@ exports.Client = exports.ParseMode = exports.restartAuth = void 0;
 const deps_js_1 = require("../deps.js");
 const constants_js_1 = require("../constants.js");
 const _0_bigint_js_1 = require("../utilities/0_bigint.js");
+const _0_control_js_1 = require("../utilities/0_control.js");
+const _0_hash_js_1 = require("../utilities/0_hash.js");
 const _0_html_js_1 = require("../utilities/0_html.js");
 const _1_message_js_1 = require("../utilities/1_message.js");
 const _1_password_js_1 = require("../utilities/1_password.js");
@@ -40,8 +42,12 @@ const _6_message_container_js_1 = require("../tl/6_message_container.js");
 const client_abstract_js_1 = require("./client_abstract.js");
 const client_plain_js_1 = require("./client_plain.js");
 const storage_memory_js_1 = require("../storage/storage_memory.js");
-const _0_hash_js_1 = require("../utilities/0_hash.js");
 const _0_message_entity_js_1 = require("../types/0_message_entity.js");
+const _0_reply_keyboard_remove_js_1 = require("../types/0_reply_keyboard_remove.js");
+const _0_force_reply_js_1 = require("../types/0_force_reply.js");
+const _2_reply_keyboard_markup_js_1 = require("../types/2_reply_keyboard_markup.js");
+const _2_inline_keyboard_markup_js_1 = require("../types/2_inline_keyboard_markup.js");
+const _3_message_js_1 = require("../types/3_message.js");
 const d = (0, deps_js_1.debug)("client");
 exports.restartAuth = Symbol();
 var ParseMode;
@@ -607,7 +613,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
                         channelId = resolved.peer.channelId;
                     }
                     else {
-                        throw new Error("Unreachable");
+                        (0, _0_control_js_1.UNREACHABLE)();
                     }
                 }
                 if (userId) {
@@ -619,7 +625,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
                     return new types.InputPeerChannel({ channelId, accessHash: accessHash ?? 0n });
                 }
                 else {
-                    throw new Error("Unreachable");
+                    (0, _0_control_js_1.UNREACHABLE)();
                 }
             }
         }
@@ -654,6 +660,27 @@ class Client extends client_abstract_js_1.ClientAbstract {
                 }
             }
         }
+        let replyMarkup = undefined;
+        if (params?.replyMarkup) {
+            if ("inlineKeyboard" in params.replyMarkup) {
+                replyMarkup = await (0, _2_inline_keyboard_markup_js_1.inlineKeyboardMarkupToTlObject)(params.replyMarkup, async (v) => {
+                    const inputPeer = await this.getInputPeer(v).then((v) => v[_1_tl_object_js_1.as](types.InputPeerUser));
+                    return new types.InputUser({ userId: inputPeer.userId, accessHash: inputPeer.accessHash });
+                });
+            }
+            else if ("keyboard" in params.replyMarkup) {
+                replyMarkup = (0, _2_reply_keyboard_markup_js_1.replyKeyboardMarkupToTlObject)(params.replyMarkup);
+            }
+            else if ("removeKeyboard" in params.replyMarkup) {
+                replyMarkup = (0, _0_reply_keyboard_remove_js_1.replyKeyboardRemoveToTlObject)(params.replyMarkup);
+            }
+            else if ("forceReply" in params.replyMarkup) {
+                replyMarkup = (0, _0_force_reply_js_1.forceReplyToTlObject)(params.replyMarkup);
+            }
+            else {
+                throw new Error("The replyMarkup parameter has an unexpected type");
+            }
+        }
         const peer = await this.getInputPeer(chatId);
         const randomId = (0, _0_bigint_js_1.getRandomId)();
         const message = text;
@@ -664,7 +691,7 @@ class Client extends client_abstract_js_1.ClientAbstract {
         const topMsgId = params?.messageThreadId;
         const sendAs = params?.sendAs ? await this.getInputPeer(params.sendAs) : undefined;
         const entities = entities_?.length > 0 ? entities_.map((v) => (0, _0_message_entity_js_1.messageEntityToTlObject)(v)) : undefined;
-        return await this.invoke(new functions.MessagesSendMessage({
+        const updates = await this.invoke(new functions.MessagesSendMessage({
             peer,
             randomId,
             message,
@@ -675,7 +702,17 @@ class Client extends client_abstract_js_1.ClientAbstract {
             topMsgId,
             sendAs,
             entities,
-        }));
+            replyMarkup,
+        })).then((v) => v[_1_tl_object_js_1.as](types.Updates));
+        for (const update of updates.updates) {
+            if (update instanceof types.UpdateNewMessage) {
+                return (0, _3_message_js_1.constructMessage)(update.message[_1_tl_object_js_1.as](types.Message), updates.users, updates.chats);
+            }
+            else if (update instanceof types.UpdateNewChannelMessage) {
+                return (0, _3_message_js_1.constructMessage)(update.message[_1_tl_object_js_1.as](types.Message), updates.users, updates.chats);
+            }
+        }
+        (0, _0_control_js_1.UNREACHABLE)();
     }
 }
 exports.Client = Client;

package/script/client/client_abstract.d.ts

@@ -1,7 +1,7 @@
+import { MaybePromise } from "../utilities/0_types.js";
 import { Connection } from "../connection/connection.js";
 import { Transport } from "../transport/transport.js";
 import { DC } from "../transport/transport_provider.js";
-import { MaybePromise } from "../types.js";
 export declare abstract class ClientAbstract {
     protected transportProvider: import("../transport/transport_provider.js").TransportProvider;
     protected connection: Connection;

package/script/connection/connection.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 export declare abstract class Connection {
     abstract get connected(): boolean;
     abstract open(): MaybePromise<void>;

package/script/storage/storage.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { DC } from "../transport/transport_provider.js";
 export declare abstract class Storage {
     private _authKeyId;

package/script/storage/storage_local_storage.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { Storage } from "./storage.js";
 export declare class StorageLocalStorage extends Storage implements Storage {
     private readonly prefix;

package/script/storage/storage_memory.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { Storage } from "./storage.js";
 export declare class StorageMemory extends Storage implements Storage {
     protected map: Map<string, string>;

package/script/storage/storage_session_storage.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { Storage } from "./storage.js";
 export declare class StorageSessionStorage extends Storage implements Storage {
     private readonly prefix;

package/script/transport/transport.d.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import { CTR } from "../utilities/0_crypto.js";
 export declare abstract class Transport {
     protected initialized: boolean;

package/script/types/0_chat_administrator_rights.d.ts

@@ -0,0 +1,17 @@
+import * as types from "../tl/2_types.js";
+export interface ChatAdministratorRights {
+    isAnonymous: boolean;
+    canManageChat: boolean;
+    canDeleteMessages: boolean;
+    canManageVideoChats: boolean;
+    canRestrictMembers: boolean;
+    canPromoteMembers: boolean;
+    canChangeInfo: boolean;
+    canInviteUsers: boolean;
+    canPostMessages?: boolean;
+    canEditMessages?: boolean;
+    canPinMessages?: boolean;
+    canManageTopics?: boolean;
+}
+export declare function constructChatAdministratorRights(rights_: types.ChatAdminRights): ChatAdministratorRights;
+export declare function chatAdministratorRightsToTlObject(rights: ChatAdministratorRights): types.ChatAdminRights;