@mtkruto/node 0.0.834 → 0.0.835

package/esm/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/esm/client/client.js

@@ -1,6 +1,8 @@
 import { debug, gunzip } from "../deps.js";
 import { ackThreshold, DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_INITIAL_DC, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER, MAX_CHANNEL_ID, MAX_CHAT_ID, USERNAME_TTL, ZERO_CHANNEL_ID } from "../constants.js";
 import { bigIntFromBuffer, getRandomBigInt, getRandomId } from "../utilities/0_bigint.js";
+import { UNREACHABLE } from "../utilities/0_control.js";
+import { sha1 } from "../utilities/0_hash.js";
 import { parseHtml } from "../utilities/0_html.js";
 import { decryptMessage, encryptMessage, getMessageId } from "../utilities/1_message.js";
 import { checkPassword } from "../utilities/1_password.js";
@@ -14,8 +16,12 @@ import { MessageContainer } from "../tl/6_message_container.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { ClientPlain } from "./client_plain.js";
 import { StorageMemory } from "../storage/storage_memory.js";
-import { sha1 } from "../utilities/0_hash.js";
 import { messageEntityToTlObject } from "../types/0_message_entity.js";
+import { replyKeyboardRemoveToTlObject } from "../types/0_reply_keyboard_remove.js";
+import { forceReplyToTlObject } from "../types/0_force_reply.js";
+import { replyKeyboardMarkupToTlObject } from "../types/2_reply_keyboard_markup.js";
+import { inlineKeyboardMarkupToTlObject } from "../types/2_inline_keyboard_markup.js";
+import { constructMessage } from "../types/3_message.js";
 const d = debug("client");
 export const restartAuth = Symbol();
 export var ParseMode;
@@ -581,7 +587,7 @@ export class Client extends ClientAbstract {
                         channelId = resolved.peer.channelId;
                     }
                     else {
-                        throw new Error("Unreachable");
+                        UNREACHABLE();
                     }
                 }
                 if (userId) {
@@ -593,7 +599,7 @@ export class Client extends ClientAbstract {
                     return new types.InputPeerChannel({ channelId, accessHash: accessHash ?? 0n });
                 }
                 else {
-                    throw new Error("Unreachable");
+                    UNREACHABLE();
                 }
             }
         }
@@ -628,6 +634,27 @@ export class Client extends ClientAbstract {
                 }
             }
         }
+        let replyMarkup = undefined;
+        if (params?.replyMarkup) {
+            if ("inlineKeyboard" in params.replyMarkup) {
+                replyMarkup = await inlineKeyboardMarkupToTlObject(params.replyMarkup, async (v) => {
+                    const inputPeer = await this.getInputPeer(v).then((v) => v[as](types.InputPeerUser));
+                    return new types.InputUser({ userId: inputPeer.userId, accessHash: inputPeer.accessHash });
+                });
+            }
+            else if ("keyboard" in params.replyMarkup) {
+                replyMarkup = replyKeyboardMarkupToTlObject(params.replyMarkup);
+            }
+            else if ("removeKeyboard" in params.replyMarkup) {
+                replyMarkup = replyKeyboardRemoveToTlObject(params.replyMarkup);
+            }
+            else if ("forceReply" in params.replyMarkup) {
+                replyMarkup = forceReplyToTlObject(params.replyMarkup);
+            }
+            else {
+                throw new Error("The replyMarkup parameter has an unexpected type");
+            }
+        }
         const peer = await this.getInputPeer(chatId);
         const randomId = getRandomId();
         const message = text;
@@ -638,7 +665,7 @@ export class Client extends ClientAbstract {
         const topMsgId = params?.messageThreadId;
         const sendAs = params?.sendAs ? await this.getInputPeer(params.sendAs) : undefined;
         const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v)) : undefined;
-        return await this.invoke(new functions.MessagesSendMessage({
+        const updates = await this.invoke(new functions.MessagesSendMessage({
             peer,
             randomId,
             message,
@@ -649,6 +676,16 @@ export class Client extends ClientAbstract {
             topMsgId,
             sendAs,
             entities,
-        }));
+            replyMarkup,
+        })).then((v) => v[as](types.Updates));
+        for (const update of updates.updates) {
+            if (update instanceof types.UpdateNewMessage) {
+                return constructMessage(update.message[as](types.Message), updates.users, updates.chats);
+            }
+            else if (update instanceof types.UpdateNewChannelMessage) {
+                return constructMessage(update.message[as](types.Message), updates.users, updates.chats);
+            }
+        }
+        UNREACHABLE();
     }
 }

package/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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;

package/esm/types/0_chat_administrator_rights.js

@@ -0,0 +1,38 @@
+import * as types from "../tl/2_types.js";
+export function constructChatAdministratorRights(rights_) {
+    const rights = {
+        isAnonymous: rights_.anonymous || false,
+        canManageChat: rights_.other || false,
+        canDeleteMessages: rights_.deleteMessages || false,
+        canManageVideoChats: rights_.manageCall || false,
+        canRestrictMembers: rights_.banUsers || false,
+        canPromoteMembers: rights_.addAdmins || false,
+        canChangeInfo: rights_.changeInfo || false,
+        canInviteUsers: rights_.inviteUsers || false,
+    };
+    if (rights_.postMessages) {
+        rights.canPostMessages = rights_.postMessages;
+    }
+    if (rights_.editMessages) {
+        rights.canEditMessages = rights_.editMessages;
+    }
+    if (rights_.pinMessages) {
+        rights.canPinMessages = rights_.pinMessages;
+    }
+    if (rights_.manageTopics) {
+        rights.canManageTopics = rights_.manageTopics;
+    }
+    return rights;
+}
+export function chatAdministratorRightsToTlObject(rights) {
+    return new types.ChatAdminRights({
+        anonymous: rights.isAnonymous || undefined,
+        other: rights.canManageChat || undefined,
+        deleteMessages: rights.canDeleteMessages || undefined,
+        manageCall: rights.canManageChat || undefined,
+        banUsers: rights.canRestrictMembers || undefined,
+        addAdmins: rights.canPromoteMembers || undefined,
+        changeInfo: rights.canChangeInfo || undefined,
+        inviteUsers: rights.canInviteUsers || undefined,
+    });
+}

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

@@ -0,0 +1,24 @@
+import * as types from "../tl/2_types.js";
+export declare enum ChatPhotoType {
+    Chat = "chat",
+    User = "user"
+}
+export declare namespace ChatPhoto {
+    interface Base {
+        type: ChatPhotoType;
+        hasVideo: boolean;
+        photoId: bigint;
+        strippedThumb?: Uint8Array;
+        dcId: number;
+    }
+    interface User extends Base {
+        type: ChatPhotoType;
+        personal: boolean;
+    }
+    interface Chat extends Base {
+        type: ChatPhotoType;
+    }
+}
+export type ChatPhoto = ChatPhoto.User | ChatPhoto.Chat;
+export declare function constructChatPhoto(photo: types.ChatPhoto): ChatPhoto.Chat;
+export declare function constructChatPhoto(photo: types.UserProfilePhoto): ChatPhoto.User;

package/esm/types/0_chat_photo.js

@@ -0,0 +1,28 @@
+import * as types from "../tl/2_types.js";
+export var ChatPhotoType;
+(function (ChatPhotoType) {
+    ChatPhotoType["Chat"] = "chat";
+    ChatPhotoType["User"] = "user";
+})(ChatPhotoType || (ChatPhotoType = {}));
+export function constructChatPhoto(photo) {
+    const { hasVideo = false, photoId, strippedThumb, dcId } = photo;
+    if (photo instanceof types.ChatPhoto) {
+        return {
+            type: ChatPhotoType.Chat,
+            hasVideo,
+            photoId,
+            strippedThumb,
+            dcId,
+        };
+    }
+    else {
+        return {
+            type: ChatPhotoType.User,
+            personal: photo.personal || false,
+            hasVideo,
+            photoId,
+            strippedThumb,
+            dcId,
+        };
+    }
+}

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

@@ -0,0 +1,8 @@
+import * as types from "../tl/2_types.js";
+export interface ForceReply {
+    forceReply: true;
+    inputFieldPlaceholder?: string;
+    selective?: boolean;
+}
+export declare function constructForceReply(replyMarkup_: types.ReplyKeyboardForceReply): ForceReply;
+export declare function forceReplyToTlObject(replyMarkup: ForceReply): types.ReplyKeyboardForceReply;

package/esm/types/0_force_reply.js

@@ -0,0 +1,17 @@
+import * as types from "../tl/2_types.js";
+export function constructForceReply(replyMarkup_) {
+    const replyMarkup = { forceReply: true };
+    if (replyMarkup_.placeholder) {
+        replyMarkup.inputFieldPlaceholder = replyMarkup_.placeholder;
+    }
+    if (replyMarkup_.selective) {
+        replyMarkup.selective = true;
+    }
+    return replyMarkup;
+}
+export function forceReplyToTlObject(replyMarkup) {
+    return new types.ReplyKeyboardForceReply({
+        selective: replyMarkup.selective || undefined,
+        placeholder: replyMarkup.inputFieldPlaceholder,
+    });
+}

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;