@mtkruto/node 0.0.832 → 0.0.835

package/esm/types/0_keyboard_button_poll_type.d.ts

@@ -0,0 +1,3 @@
+export interface KeyboardButtonPollType {
+    type?: string;
+}

package/esm/types/0_login_url.d.ts

@@ -0,0 +1,6 @@
+export interface LoginUrl {
+    url: string;
+    forwardText?: string;
+    botUsername?: string;
+    requestWriteAccess?: boolean;
+}

package/esm/types/0_login_url.js

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

package/esm/types/0_message_entity.d.ts

@@ -84,7 +84,7 @@ export declare namespace MessageEntity {
     }
     interface CustomEmoji extends Base {
         type: MessageEntityType.CustomEmoji;
-        documentId: bigint;
+        customEmojiId: string;
     }
 }
 export type MessageEntity = MessageEntity.Mention | MessageEntity.Hashtag | MessageEntity.BotCommand | MessageEntity.URL | MessageEntity.EmailAddress | MessageEntity.Bold | MessageEntity.Italic | MessageEntity.Code | MessageEntity.Pre | MessageEntity.TextURL | MessageEntity.MentionName | MessageEntity.Cashtag | MessageEntity.Phone | MessageEntity.Underline | MessageEntity.Strike | MessageEntity.Blockquote | MessageEntity.BankCard | MessageEntity.Spoiler | MessageEntity.CustomEmoji;

package/esm/types/0_message_entity.js

@@ -77,7 +77,7 @@ export function constructMessageEntity(obj) {
         return { type: MessageEntityType.Spoiler, offset: obj.offset, length: obj.length };
     }
     else if (obj instanceof types.MessageEntityCustomEmoji) {
-        return { type: MessageEntityType.CustomEmoji, offset: obj.offset, length: obj.length, documentId: obj.documentId };
+        return { type: MessageEntityType.CustomEmoji, offset: obj.offset, length: obj.length, customEmojiId: String(obj.documentId) };
     }
     else {
         return null;
@@ -123,6 +123,6 @@ export function messageEntityToTlObject(entity) {
         case MessageEntityType.Spoiler:
             return new types.MessageEntitySpoiler({ offset, length });
         case MessageEntityType.CustomEmoji:
-            return new types.MessageEntityCustomEmoji({ offset, length, documentId: entity.documentId });
+            return new types.MessageEntityCustomEmoji({ offset, length, documentId: BigInt(entity.customEmojiId) });
     }
 }

package/esm/types/0_reply_keyboard_remove.d.ts

@@ -0,0 +1,7 @@
+import * as types from "../tl/2_types.js";
+export interface ReplyKeyboardRemove {
+    removeKeyboard: true;
+    selective?: boolean;
+}
+export declare function constructReplyKeyboardRemove(replyMarkup_: types.ReplyKeyboardHide): ReplyKeyboardRemove;
+export declare function replyKeyboardRemoveToTlObject(replyMarkup: ReplyKeyboardRemove): types.ReplyKeyboardHide;

package/esm/types/0_reply_keyboard_remove.js

@@ -0,0 +1,8 @@
+import { cleanObject } from "../utilities/0_object.js";
+import * as types from "../tl/2_types.js";
+export function constructReplyKeyboardRemove(replyMarkup_) {
+    return cleanObject({ removeKeyboard: true, selective: replyMarkup_.selective });
+}
+export function replyKeyboardRemoveToTlObject(replyMarkup) {
+    return new types.ReplyKeyboardHide({ selective: replyMarkup.selective || undefined });
+}

package/esm/types/0_web_app_info.d.ts

@@ -0,0 +1,4 @@
+export interface WebAppInfo {
+    url: string;
+}
+export declare function constructWebAppInfo(url: string): WebAppInfo;

package/esm/types/0_web_app_info.js

@@ -0,0 +1,3 @@
+export function constructWebAppInfo(url) {
+    return { url };
+}

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

@@ -0,0 +1,60 @@
+import * as types from "../tl/2_types.js";
+import { ChatPhoto } from "./0_chat_photo.js";
+export declare enum ChatType {
+    Private = "private",
+    Group = "group",
+    Supergroup = "supergroup",
+    Channel = "channel"
+}
+export declare namespace Chat {
+    interface Base {
+        type: ChatType;
+        id: number;
+        photo?: ChatPhoto;
+    }
+    interface Private extends Base {
+        type: ChatType.Private;
+        isBot?: boolean;
+        firstName: string;
+        lastName?: string;
+        username?: string;
+        also?: string[];
+        photo?: ChatPhoto.User;
+        isScam: boolean;
+        isFake: boolean;
+        isSupport: boolean;
+        isVerified: boolean;
+        isRestricted?: boolean;
+        restrictionReason?: types.RestrictionReason[];
+    }
+    interface Group extends Base {
+        type: ChatType.Group;
+        title: string;
+        photo?: ChatPhoto.Chat;
+        isCreator: boolean;
+    }
+    interface ChannelBase extends Base {
+        title: string;
+        username?: string;
+        also?: string[];
+        photo?: ChatPhoto.Chat;
+        isScam: boolean;
+        isFake: boolean;
+        isVerified: boolean;
+        isRestricted: boolean;
+        restrictionReason?: types.RestrictionReason[];
+    }
+    interface Channel extends ChannelBase {
+        type: ChatType.Channel;
+        title: string;
+        username?: string;
+        also?: string[];
+    }
+    interface Supergroup extends ChannelBase {
+        type: ChatType.Supergroup;
+    }
+}
+export type Chat = Chat.Private | Chat.Group | Chat.Supergroup | Chat.Channel;
+export declare function constructChat(chat: types.User): Chat.Private;
+export declare function constructChat(chat: types.Chat): Chat.Group;
+export declare function constructChat(chat: types.Channel): Chat.Supergroup | Chat.Channel;

package/esm/types/1_chat.js

@@ -0,0 +1,70 @@
+import { ZERO_CHANNEL_ID } from "../constants.js";
+import { UNREACHABLE } from "../utilities/0_control.js";
+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 var ChatType;
+(function (ChatType) {
+    ChatType["Private"] = "private";
+    ChatType["Group"] = "group";
+    ChatType["Supergroup"] = "supergroup";
+    ChatType["Channel"] = "channel";
+})(ChatType || (ChatType = {}));
+export function constructChat(chat) {
+    if (chat instanceof types.User) {
+        const chat_ = {
+            type: ChatType.Private,
+            isBot: chat.bot || false,
+            id: Number(chat.id),
+            firstName: chat.firstName || "",
+            lastName: chat.lastName,
+            isScam: chat.scam || false,
+            isFake: chat.fake || false,
+            isSupport: chat.support || false,
+            isVerified: chat.verified || false,
+        };
+        if (chat_.isBot) {
+            chat_.isRestricted = chat.restricted || false;
+            chat_.restrictionReason = chat.restrictionReason?.map((v) => v[as](types.RestrictionReason));
+        }
+        if (chat.photo instanceof types.UserProfilePhoto) {
+            chat_.photo = constructChatPhoto(chat.photo);
+        }
+        return cleanObject(chat_);
+    }
+    else if (chat instanceof types.Chat) {
+        const chat_ = {
+            type: ChatType.Group,
+            id: Number(-chat.id),
+            title: chat.title,
+            isCreator: chat.creator || false,
+        };
+        if (chat.photo instanceof types.ChatPhoto) {
+            chat_.photo = constructChatPhoto(chat.photo);
+        }
+        return cleanObject(chat_);
+    }
+    else if (chat instanceof types.Channel) {
+        let chat_;
+        const { title, scam: isScam = false, fake: isFake = false, verified: isVerified = false, restricted: isRestricted = false, } = chat;
+        if (chat.megagroup) {
+            chat_ = { id: ZERO_CHANNEL_ID + -Number(chat.id), type: ChatType.Supergroup, title, isScam, isFake, isVerified, isRestricted };
+        }
+        else {
+            chat_ = { id: ZERO_CHANNEL_ID + -Number(chat.id), type: ChatType.Channel, title, isScam, isFake, isVerified, isRestricted };
+        }
+        chat_.username = chat.username;
+        chat_.also = chat.usernames?.map((v) => v[as](types.Username)).map((v) => v.username);
+        if (chat_.isRestricted) {
+            chat_.restrictionReason = chat.restrictionReason?.map((v) => v[as](types.RestrictionReason));
+        }
+        if (chat.photo instanceof types.ChatPhoto) {
+            chat_.photo = constructChatPhoto(chat.photo);
+        }
+        return cleanObject(chat_);
+    }
+    else {
+        UNREACHABLE();
+    }
+}

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

@@ -0,0 +1,33 @@
+import { MaybePromise } from "../utilities/0_types.js";
+import * as types from "../tl/2_types.js";
+import { WebAppInfo } from "./0_web_app_info.js";
+import { LoginUrl } from "./0_login_url.js";
+export declare namespace InlineKeyboardButton {
+    interface Base {
+        text: string;
+    }
+    interface URL extends Base {
+        url: string;
+    }
+    interface Callback extends Base {
+        callbackData: string;
+    }
+    interface WebApp extends Base {
+        webApp: WebAppInfo;
+    }
+    interface Login extends Base {
+        loginUrl: LoginUrl;
+    }
+    interface SwitchInline extends Base {
+        switchInlineQuery: string;
+    }
+    interface SwitchInlineCurrent extends Base {
+        switchInlineQueryCurrentChat: string;
+    }
+    interface Pay extends Base {
+        pay: boolean;
+    }
+}
+export type InlineKeyboardButton = InlineKeyboardButton.URL | InlineKeyboardButton.Callback | InlineKeyboardButton.WebApp | InlineKeyboardButton.Login | InlineKeyboardButton.SwitchInline | InlineKeyboardButton.SwitchInlineCurrent | InlineKeyboardButton.Pay;
+export declare function constructInlineKeyboardButton(button_: types.TypeKeyboardButton): InlineKeyboardButton;
+export declare function inlineKeyboardButtonToTlObject(button: InlineKeyboardButton, usernameResolver: (username: string) => MaybePromise<types.InputUser>): Promise<types.KeyboardButtonURL | types.KeyboardButtonCallback | types.KeyboardButtonSwitchInline | types.KeyboardButtonBuy | types.InputKeyboardButtonURLAuth | types.KeyboardButtonWebView>;

package/esm/types/1_inline_keyboard_button.js

@@ -0,0 +1,63 @@
+import { UNREACHABLE } from "../utilities/0_control.js";
+import * as types from "../tl/2_types.js";
+import { constructWebAppInfo } from "./0_web_app_info.js";
+export function constructInlineKeyboardButton(button_) {
+    if (button_ instanceof types.KeyboardButtonURL) {
+        return { text: button_.text, url: button_.url };
+    }
+    else if (button_ instanceof types.KeyboardButtonCallback) {
+        return { text: button_.text, callbackData: new TextDecoder().decode(button_.data) };
+    }
+    else if (button_ instanceof types.KeyboardButtonWebView || button_ instanceof types.KeyboardButtonSimpleWebView) {
+        return { text: button_.text, webApp: constructWebAppInfo(button_.url) };
+    }
+    else if (button_ instanceof types.KeyboardButtonURLAuth) {
+        return { text: button_.text, loginUrl: { url: button_.url, forwardText: button_.fwdText } };
+    }
+    else if (button_ instanceof types.KeyboardButtonSwitchInline) {
+        if (button_.samePeer) {
+            return { text: button_.text, switchInlineQueryCurrentChat: button_.query };
+        }
+        else {
+            return { text: button_.text, switchInlineQuery: button_.query };
+        }
+    }
+    else if (button_ instanceof types.KeyboardButtonBuy) {
+        return { text: button_.text, pay: true };
+    }
+    else {
+        UNREACHABLE();
+    }
+}
+export async function inlineKeyboardButtonToTlObject(button, usernameResolver) {
+    if ("url" in button) {
+        return new types.KeyboardButtonURL({ text: button.text, url: button.url });
+    }
+    else if ("callbackData" in button) {
+        return new types.KeyboardButtonCallback({ text: button.text, data: new TextEncoder().encode(button.callbackData) });
+    }
+    else if ("webApp" in button) {
+        return new types.KeyboardButtonWebView({ text: button.text, url: button.webApp.url });
+    }
+    else if ("loginUrl" in button) {
+        return new types.InputKeyboardButtonURLAuth({
+            text: button.text,
+            url: button.loginUrl.url,
+            fwdText: button.loginUrl.forwardText,
+            bot: button.loginUrl.botUsername ? await usernameResolver(button.loginUrl.botUsername) : new types.InputUserSelf(),
+            requestWriteAccess: button.loginUrl.requestWriteAccess || undefined,
+        });
+    }
+    else if ("switchInlineQuery" in button) {
+        return new types.KeyboardButtonSwitchInline({ text: button.text, query: button.switchInlineQuery });
+    }
+    else if ("switchInlineQueryCurrentChat" in button) {
+        return new types.KeyboardButtonSwitchInline({ text: button.text, query: button.switchInlineQueryCurrentChat, samePeer: true });
+    }
+    else if ("pay" in button) {
+        return new types.KeyboardButtonBuy({ text: button.text });
+    }
+    else {
+        UNREACHABLE();
+    }
+}

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

@@ -0,0 +1,43 @@
+import * as types from "../tl/2_types.js";
+import { ChatAdministratorRights } from "./0_chat_administrator_rights.js";
+import { KeyboardButtonPollType } from "./0_keyboard_button_poll_type.js";
+import { WebAppInfo } from "./0_web_app_info.js";
+export declare namespace KeyboardButton {
+    interface Text {
+        text: string;
+    }
+    interface RequestUser extends Text {
+        requestUser: {
+            requestId: number;
+            userIsBot?: boolean;
+            userIsPremium?: boolean;
+        };
+    }
+    interface RequestChat extends Text {
+        requestChat: {
+            requestId: number;
+            chatIsChannel: boolean;
+            chatIsForum?: boolean;
+            chatHasUsername?: boolean;
+            chatIsCreated?: boolean;
+            userAdministratorRights?: ChatAdministratorRights;
+            botAdministratorRights?: ChatAdministratorRights;
+            botIsMember?: boolean;
+        };
+    }
+    interface RequestContact extends Text {
+        requestContact: true;
+    }
+    interface RequestLocation extends Text {
+        requestLocation: true;
+    }
+    interface RequestPoll extends Text {
+        requestPoll: KeyboardButtonPollType;
+    }
+    interface WebApp extends Text {
+        webApp: WebAppInfo;
+    }
+}
+export type KeyboardButton = KeyboardButton.Text | KeyboardButton.RequestUser | KeyboardButton.RequestChat | KeyboardButton.RequestContact | KeyboardButton.RequestLocation | KeyboardButton.RequestPoll | KeyboardButton.WebApp;
+export declare function constructKeyboardButton(button_: types.TypeKeyboardButton): KeyboardButton;
+export declare function keyboardButtonToTlObject(button: KeyboardButton): types.KeyboardButtonRequestPhone | types.KeyboardButtonRequestGeoLocation | types.KeyboardButtonRequestPoll | types.KeyboardButtonWebView | types.KeyboardButtonRequestPeer;

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;