@mtcute/core 0.31.0 → 0.32.0

package/highlevel/types/bots/keyboards/factories.d.ts

@@ -1,21 +1,24 @@
-import { InlineKeyboardMarkup, ReplyKeyboardForceReply, ReplyKeyboardHide, ReplyKeyboardMarkup, ReplyMarkup } from './types.js';
+import { BotKeyboardButtonStyle, CallbackButton, CopyButton, DisabledButton, GameButton, InlineKeyboardMarkup, InputInlineKeyboardButton, InputReplyKeyboardButton, PayButton, ReplyKeyboardForceReply, ReplyKeyboardHide, ReplyKeyboardMarkup, ReplyMarkup, RequestContactButton, RequestGeoButton, RequestPeerButton, RequestPollButton, SwitchInlineButton, TextButton, UrlAuthButton, UrlButton, UserProfileButton, WebViewButton } from './types.js';
 import { tl } from '../../../../tl/index.js';
 import { BotKeyboardBuilder } from './builder.js';
-/** Create a keyboard builder */
-export declare function builder(maxRowWidth?: number | null): BotKeyboardBuilder;
+/** Create a builder for an inline keyboard */
+export declare function builder(maxRowWidth?: number | null): BotKeyboardBuilder<InputInlineKeyboardButton>;
+/** Create a builder for a reply keyboard */
+export declare function replyBuilder(maxRowWidth?: number | null): BotKeyboardBuilder<InputReplyKeyboardButton>;
 /**
  * Create an inline keyboard markup
  *
  * @param buttons  Two-dimensional array of buttons
+ * @param params  Additional parameters for the keyboard
  */
-export declare function inline(buttons: tl.TypeKeyboardButton[][]): InlineKeyboardMarkup;
+export declare function inline(buttons: InputInlineKeyboardButton[][], params?: Omit<InlineKeyboardMarkup, 'type' | 'buttons'>): InlineKeyboardMarkup;
 /**
  * Create a reply keyboard markup
  *
  * @param buttons  Two-dimensional array of buttons
  * @param params  Additional parameters for the keyboard
  */
-export declare function reply(buttons: tl.TypeKeyboardButton[][], params?: Omit<ReplyKeyboardMarkup, 'type' | 'buttons'>): ReplyKeyboardMarkup;
+export declare function reply(buttons: InputReplyKeyboardButton[][], params?: Omit<ReplyKeyboardMarkup, 'type' | 'buttons'>): ReplyKeyboardMarkup;
 /**
  * Hide the previously sent reply keyboard
  *
@@ -29,6 +32,9 @@ export declare function hideReply(selective?: boolean): ReplyKeyboardHide;
  * Force the user to send a reply
  */
 export declare function forceReply(params?: Omit<ReplyKeyboardForceReply, 'type'>): ReplyKeyboardForceReply;
+interface ButtonOptions {
+    style?: BotKeyboardButtonStyle;
+}
 /**
  * Create a text-only keyboard button.
  *
@@ -36,7 +42,7 @@ export declare function forceReply(params?: Omit<ReplyKeyboardForceReply, 'type'
  *
  * @param text  Button text
  */
-export declare function text(text: string): tl.RawKeyboardButton;
+export declare function text(text: string, options?: ButtonOptions): TextButton;
 /**
  * Create a keyboard button requesting for user's contact.
  * Available only for private chats.
@@ -45,7 +51,7 @@ export declare function text(text: string): tl.RawKeyboardButton;
  *
  * @param text  Button text
  */
-export declare function requestContact(text: string): tl.RawKeyboardButtonRequestPhone;
+export declare function requestContact(text: string, options?: ButtonOptions): RequestContactButton;
 /**
  * Create a keyboard button requesting for user's geo location.
  * Available only for private chats.
@@ -54,7 +60,7 @@ export declare function requestContact(text: string): tl.RawKeyboardButtonReques
  *
  * @param text  Button text
  */
-export declare function requestGeo(text: string): tl.RawKeyboardButtonRequestGeoLocation;
+export declare function requestGeo(text: string, options?: ButtonOptions): RequestGeoButton;
 /**
  * Create a keyboard button requesting the user to create and send a poll.
  * Available only for private chats.
@@ -64,7 +70,16 @@ export declare function requestGeo(text: string): tl.RawKeyboardButtonRequestGeo
  * @param text  Button text
  * @param quiz  If set, only quiz polls can be sent
  */
-export declare function requestPoll(text: string, quiz?: boolean): tl.RawKeyboardButtonRequestPoll;
+export declare function requestPoll(text: string, quiz?: boolean, options?: ButtonOptions): RequestPollButton;
+/**
+ * Button to request a peer from the user
+ *
+ * Used for reply keyboards, not inline!
+ *
+ * @param text  Text of the button
+ * @param buttonId  ID of the button that will later be passed to the service message
+ */
+export declare function requestPeer(text: string, buttonId: number, params: ButtonOptions & Omit<RequestPeerButton, 'type' | 'text' | 'buttonId' | 'style'>): RequestPeerButton;
 /**
  * Create a keyboard button with a link.
  *
@@ -73,24 +88,22 @@ export declare function requestPoll(text: string, quiz?: boolean): tl.RawKeyboar
  * @param text  Button text
  * @param url  URL
  */
-export declare function url(text: string, url: string, options?: {
-    style?: tl.RawKeyboardButtonStyle;
-}): tl.RawKeyboardButtonUrl;
+export declare function url(text: string, url: string, options?: ButtonOptions): UrlButton;
 /**
- * Create a keyboard button with a link.
+ * Create a keyboard button with callback data.
  *
  * Used for inline keyboards, not reply!
  *
  * @param text  Button text
  * @param data  Callback data (1-64 bytes). String will be converted to `Buffer`
- * @param requiresPassword
- *   Whether the user should verify their identity by entering 2FA password.
- *   See more: {@link tl.RawKeyboardButtonCallback#requiresPassword}
  */
-export declare function callback(text: string, data: string | Uint8Array, options?: {
+export declare function callback(text: string, data: string | Uint8Array, options?: ButtonOptions & {
+    /**
+     * Whether the user should verify their identity by entering 2FA password.
+     * See more: {@link tl.RawInlineButtonTypeCallback#requiresPassword}
+     */
     requiresPassword?: boolean;
-    style?: tl.RawKeyboardButtonStyle;
-}): tl.RawKeyboardButtonCallback;
+}): CallbackButton;
 /**
  * Button to force a user to switch to inline mode.
  *
@@ -101,20 +114,8 @@ export declare function callback(text: string, data: string | Uint8Array, option
  * Used for inline keyboards, not reply!
  *
  * @param text  Button text
- * @param query  Inline query (can be empty or omitted)
  */
-export declare function switchInline(text: string, options?: {
-    /**
-     * Inline query (can be empty or omitted)
-     */
-    query?: string;
-    /**
-     * If set, pressing the button will insert the bot's username
-     * and the specified inline query in the current chat's input field
-     */
-    currentChat?: boolean;
-    style?: tl.RawKeyboardButtonStyle;
-}): tl.RawKeyboardButtonSwitchInline;
+export declare function switchInline(text: string, options?: ButtonOptions & Omit<SwitchInlineButton, 'type' | 'text' | 'style'>): SwitchInlineButton;
 /**
  * Button to start a game
  *
@@ -125,9 +126,7 @@ export declare function switchInline(text: string, options?: {
  * game is inferred from {@link InputMedia.game},
  * thus this button should only be used with it.
  */
-export declare function game(text: string, options?: {
-    style?: tl.RawKeyboardButtonStyle;
-}): tl.RawKeyboardButtonGame;
+export declare function game(text: string, options?: ButtonOptions): GameButton;
 /**
  * Button to pay for a product.
  *
@@ -138,95 +137,65 @@ export declare function game(text: string, options?: {
  * invoice is inferred from {@link InputMedia.invoice},
  * thus this button should only be used with it.
  */
-export declare function pay(text: string, options?: {
-    style?: tl.RawKeyboardButtonStyle;
-}): tl.RawKeyboardButtonBuy;
+export declare function pay(text: string, options?: ButtonOptions): PayButton;
 /**
  * Button to authorize a user
  *
  * Used for inline keyboards, not reply!
  *
  * @param text  Button label
- * @param url  Authorization URL (see {@link tl.RawInputKeyboardButtonUrlAuth})
+ * @param url  Authorization URL (see {@link tl.RawInputInlineButtonTypeUrlAuth})
  * @param params
  */
-export declare function urlAuth(text: string, url: string, params?: {
-    /**
-     * Button label when forwarded
-     */
-    fwdText?: string;
-    /**
-     * Whether to request the permission for
-     * your bot to send messages to the user
-     */
-    requestWriteAccess?: boolean;
-    style?: tl.RawKeyboardButtonStyle;
-    /**
-     * Bot, which will be used for user authorization.
-     * `url` domain must be the same as the domain linked
-     * with the bot.
-     *
-     * @default  current bot
-     */
-    bot?: tl.TypeInputUser;
-}): tl.RawInputKeyboardButtonUrlAuth;
+export declare function urlAuth(text: string, url: string, params?: ButtonOptions & Omit<UrlAuthButton, 'type' | 'text' | 'url' | 'style'>): UrlAuthButton;
 /**
  * Button to open webview
  *
  * Used for both inline keyboards and reply ones
+ * (in the latter case it is sent as a simple webview button)
  *
  * @param text  Button label
  * @param url  WebView URL
  */
-export declare function webView(text: string, url: string, options?: {
-    style?: tl.RawKeyboardButtonStyle;
-}): tl.RawKeyboardButtonWebView;
+export declare function webView(text: string, url: string, options?: ButtonOptions): WebViewButton;
 /**
  * Button to open user profile
  *
+ * Used for inline keyboards, not reply!
+ *
  * @param text  Text of the button
  * @param user  User to be opened (use {@link TelegramClient.resolvePeer})
  */
-export declare function userProfile(text: string, user: tl.TypeInputPeer, options?: {
-    style?: tl.RawKeyboardButtonStyle;
-}): tl.RawInputKeyboardButtonUserProfile;
+export declare function userProfile(text: string, user: tl.TypeInputPeer, options?: ButtonOptions): UserProfileButton;
 /**
- * Button to request a peer from the user
+ * Button to copy text to the user's clipboard
  *
- * @param text  Text of the button
- * @param buttonId  ID of the button that will later be passed to the service message
+ * Used for inline keyboards, not reply!
  */
-export declare function requestPeer(text: string, buttonId: number, params: {
-    /**
-     * Peer type, along with filters
-     */
-    peerType: tl.TypeRequestPeerType;
-    /**
-     * Maximum number of peers to be selected
-     *
-     * @default  1
-     */
-    count?: number;
-    style?: tl.RawKeyboardButtonStyle;
-}): tl.RawKeyboardButtonRequestPeer;
+export declare function copy(params: ButtonOptions & Omit<CopyButton, 'type' | 'style'>): CopyButton;
 /**
- * Button to copy text to the user's clipboard
+ * Button that does nothing when pressed
+ *
+ * Used for inline keyboards, not reply!
  */
-export declare function copy(params: {
-    text: string;
-    copyText?: string;
-    style?: tl.RawKeyboardButtonStyle;
-}): tl.RawKeyboardButtonCopy;
+export declare function disabled(text: string, options?: ButtonOptions): DisabledButton;
 /**
  * Find a button in the keyboard by its text or by predicate
  *
  * @param buttons  Two-dimensional array of buttons
  * @param predicate  Button text or predicate function
  */
-export declare function findButton(buttons: tl.TypeKeyboardButton[][], predicate: string | ((btn: tl.TypeKeyboardButton) => boolean)): tl.TypeKeyboardButton | null;
+export declare function findButton<T extends {
+    text: string;
+}>(buttons: T[][], predicate: string | ((btn: T) => boolean)): T | null;
 /** @internal */
 export declare function _rowsTo2d(rows: tl.RawKeyboardButtonRow[]): tl.TypeKeyboardButton[][];
 /** @internal */
-export declare function _2dToRows(arr: tl.TypeKeyboardButton[][], inline: boolean): tl.RawKeyboardButtonRow[];
+export declare function _inlineRowsTo2d(rows: tl.RawKeyboardInlineButtonRow[]): tl.TypeKeyboardInlineButton[][];
+/** @internal */
+export declare function _2dToRows(arr: InputReplyKeyboardButton[][]): tl.RawKeyboardButtonRow[];
+/** @internal */
+export declare function _2dToInlineRows(arr: InputInlineKeyboardButton[][]): tl.RawKeyboardInlineButtonRow[];
 /** @internal */
 export declare function _convertToTl(obj?: ReplyMarkup): tl.TypeReplyMarkup | undefined;
+export {};

package/highlevel/types/bots/keyboards/factories.js

@@ -2,15 +2,19 @@ import { utf8 } from "@fuman/utils";
 import { assertNever } from "../../../../types/utils.js";
 import { toInputUser } from "../../../utils/peer-utils.js";
 import { BotKeyboardBuilder } from "./builder.js";
+import { _toReplyButton, _toInlineButton } from "./normalize.js";
 import { isAnyReplyMarkup } from "../../../../tl/inner-tl.js";
 function builder(maxRowWidth) {
   return new BotKeyboardBuilder(maxRowWidth);
 }
-function inline(buttons) {
-  return {
-    type: "inline",
-    buttons
-  };
+function replyBuilder(maxRowWidth) {
+  return new BotKeyboardBuilder(maxRowWidth);
+}
+function inline(buttons, params = {}) {
+  const ret = params;
+  ret.type = "inline";
+  ret.buttons = buttons;
+  return ret;
 }
 function reply(buttons, params = {}) {
   const ret = params;
@@ -29,116 +33,61 @@ function forceReply(params = {}) {
   ret.type = "force_reply";
   return ret;
 }
-function text(text2) {
-  return {
-    _: "keyboardButton",
-    text: text2
-  };
+function text(text2, options) {
+  return { type: "text", text: text2, style: options?.style };
 }
-function requestContact(text2) {
-  return {
-    _: "keyboardButtonRequestPhone",
-    text: text2
-  };
+function requestContact(text2, options) {
+  return { type: "request_contact", text: text2, style: options?.style };
 }
-function requestGeo(text2) {
-  return {
-    _: "keyboardButtonRequestGeoLocation",
-    text: text2
-  };
+function requestGeo(text2, options) {
+  return { type: "request_geo", text: text2, style: options?.style };
 }
-function requestPoll(text2, quiz) {
-  return {
-    _: "keyboardButtonRequestPoll",
-    text: text2,
-    quiz
-  };
+function requestPoll(text2, quiz, options) {
+  return { type: "request_poll", text: text2, quiz, style: options?.style };
+}
+function requestPeer(text2, buttonId, params) {
+  return { ...params, type: "request_peer", text: text2, buttonId, style: params.style };
 }
 function url(text2, url2, options) {
-  return {
-    _: "keyboardButtonUrl",
-    text: text2,
-    url: url2,
-    style: options?.style
-  };
+  return { type: "url", text: text2, url: url2, style: options?.style };
 }
 function callback(text2, data, options) {
   return {
-    _: "keyboardButtonCallback",
+    type: "callback",
     text: text2,
+    data: typeof data === "string" ? utf8.encoder.encode(data) : data,
     requiresPassword: options?.requiresPassword,
-    style: options?.style,
-    data: typeof data === "string" ? utf8.encoder.encode(data) : data
+    style: options?.style
   };
 }
 function switchInline(text2, options) {
-  return {
-    _: "keyboardButtonSwitchInline",
-    samePeer: options?.currentChat,
-    style: options?.style,
-    text: text2,
-    query: options?.query ?? ""
-  };
+  return { ...options, type: "switch_inline", text: text2, style: options?.style };
 }
 function game(text2, options) {
-  return { _: "keyboardButtonGame", text: text2, style: options?.style };
+  return { type: "game", text: text2, style: options?.style };
 }
 function pay(text2, options) {
-  return { _: "keyboardButtonBuy", text: text2, style: options?.style };
+  return { type: "pay", text: text2, style: options?.style };
 }
 function urlAuth(text2, url2, params = {}) {
-  return {
-    _: "inputKeyboardButtonUrlAuth",
-    text: text2,
-    url: url2,
-    bot: params.bot ?? {
-      _: "inputUserSelf"
-    },
-    fwdText: params.fwdText,
-    requestWriteAccess: params.requestWriteAccess,
-    style: params.style
-  };
+  return { ...params, type: "url_auth", text: text2, url: url2, style: params.style };
 }
 function webView(text2, url2, options) {
-  return {
-    _: "keyboardButtonWebView",
-    text: text2,
-    url: url2,
-    style: options?.style
-  };
+  return { type: "webview", text: text2, url: url2, style: options?.style };
 }
 function userProfile(text2, user, options) {
-  return {
-    _: "inputKeyboardButtonUserProfile",
-    text: text2,
-    userId: toInputUser(user),
-    style: options?.style
-  };
-}
-function requestPeer(text2, buttonId, params) {
-  return {
-    _: "keyboardButtonRequestPeer",
-    text: text2,
-    buttonId,
-    peerType: params.peerType,
-    maxQuantity: params.count ?? 1,
-    style: params.style
-  };
+  return { type: "user_profile", text: text2, user: toInputUser(user), style: options?.style };
 }
 function copy(params) {
-  return {
-    _: "keyboardButtonCopy",
-    text: params.text,
-    copyText: params?.copyText ?? params.text,
-    style: params.style
-  };
+  return { ...params, type: "copy", style: params.style };
+}
+function disabled(text2, options) {
+  return { type: "disabled", text: text2, style: options?.style };
 }
 function findButton(buttons, predicate) {
   if (typeof predicate === "string") {
     const text2 = predicate;
-    predicate = (btn) => {
-      return "text" in btn && btn.text === text2;
-    };
+    predicate = (btn) => btn.text === text2;
   }
   for (const row of buttons) {
     for (const btn of row) {
@@ -152,21 +101,14 @@ function findButton(buttons, predicate) {
 function _rowsTo2d(rows) {
   return rows.map((it) => it.buttons);
 }
-function _2dToRows(arr, inline2) {
-  return arr.map((row) => {
-    if (!inline2) {
-      row = row.map(
-        (btn) => btn._ === "keyboardButtonWebView" ? {
-          ...btn,
-          _: "keyboardButtonSimpleWebView"
-        } : btn
-      );
-    }
-    return {
-      _: "keyboardButtonRow",
-      buttons: row
-    };
-  });
+function _inlineRowsTo2d(rows) {
+  return rows.map((it) => it.buttons);
+}
+function _2dToRows(arr) {
+  return arr.map((row) => ({ _: "keyboardButtonRow", buttons: row.map(_toReplyButton) }));
+}
+function _2dToInlineRows(arr) {
+  return arr.map((row) => ({ _: "keyboardInlineButtonRow", buttons: row.map(_toInlineButton) }));
 }
 function _convertToTl(obj) {
   if (!obj) return obj;
@@ -179,8 +121,9 @@ function _convertToTl(obj) {
         singleUse: obj.singleUse,
         selective: obj.selective,
         persistent: obj.persistent,
+        forceReply: obj.forceReply,
         placeholder: obj.placeholder,
-        rows: _2dToRows(obj.buttons, false)
+        rows: _2dToRows(obj.buttons)
       };
     case "reply_hide":
       return {
@@ -197,19 +140,23 @@ function _convertToTl(obj) {
     case "inline":
       return {
         _: "replyInlineMarkup",
-        rows: _2dToRows(obj.buttons, true)
+        forceReply: obj.forceReply,
+        rows: _2dToInlineRows(obj.buttons)
       };
     default:
       assertNever();
   }
 }
 export {
+  _2dToInlineRows,
   _2dToRows,
   _convertToTl,
+  _inlineRowsTo2d,
   _rowsTo2d,
   builder,
   callback,
   copy,
+  disabled,
   findButton,
   forceReply,
   game,
@@ -217,6 +164,7 @@ export {
   inline,
   pay,
   reply,
+  replyBuilder,
   requestContact,
   requestGeo,
   requestPeer,

package/highlevel/types/bots/keyboards/index.d.cts

@@ -8,8 +8,8 @@ export {
  *
  * You can also use the type-discriminated objects directly.
  *
- * > **Note**: Button creation functions are intended to be used
- * > with inline reply markup, unless stated otherwise
- * > in the description.
+ * > **Note**: Buttons are split into inline-only and reply-only ones
+ * > (see the description of each function), and passing one where the
+ * > other is expected is a type error.
  */
 BotKeyboard, };

package/highlevel/types/bots/keyboards/index.d.ts

@@ -8,8 +8,8 @@ export {
  *
  * You can also use the type-discriminated objects directly.
  *
- * > **Note**: Button creation functions are intended to be used
- * > with inline reply markup, unless stated otherwise
- * > in the description.
+ * > **Note**: Buttons are split into inline-only and reply-only ones
+ * > (see the description of each function), and passing one where the
+ * > other is expected is a type error.
  */
 BotKeyboard, };

package/highlevel/types/bots/keyboards/normalize.cjs

@@ -0,0 +1,131 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("../../../../types/errors.cjs");
+function toKeyboardStyle(style) {
+  if (!style) return void 0;
+  return {
+    _: "keyboardButtonStyle",
+    bgPrimary: style.bgPrimary,
+    bgDanger: style.bgDanger,
+    bgSuccess: style.bgSuccess,
+    icon: style.icon
+  };
+}
+function _toRichButtonStyle(style) {
+  if (!style) return void 0;
+  return {
+    _: "richButtonStyle",
+    bgPrimary: style.bgPrimary,
+    bgDanger: style.bgDanger,
+    bgSuccess: style.bgSuccess,
+    link: style.link
+  };
+}
+function _toInlineButtonType(btn) {
+  switch (btn.type) {
+    case "url":
+      return { _: "inlineButtonTypeUrl", url: btn.url };
+    case "webview":
+      return { _: "inlineButtonTypeWebView", url: btn.url };
+    case "callback":
+      return { _: "inlineButtonTypeCallback", data: btn.data, requiresPassword: btn.requiresPassword };
+    case "switch_inline":
+      return {
+        _: "inlineButtonTypeSwitchInline",
+        samePeer: btn.currentChat,
+        query: btn.query ?? "",
+        peerTypes: btn.peerTypes
+      };
+    case "game":
+      return { _: "inlineButtonTypeGame" };
+    case "pay":
+      return { _: "inlineButtonTypeBuy" };
+    case "url_auth":
+      return {
+        _: "inputInlineButtonTypeUrlAuth",
+        url: btn.url,
+        fwdText: btn.fwdText,
+        requestWriteAccess: btn.requestWriteAccess,
+        bot: btn.bot ?? { _: "inputUserSelf" }
+      };
+    case "user_profile":
+      return { _: "inputInlineButtonTypeUserProfile", userId: btn.user };
+    case "copy":
+      return { _: "inlineButtonTypeCopy", copyText: btn.copyText ?? btn.text };
+    case "disabled":
+      return { _: "inlineButtonTypeDisabled" };
+    default:
+      throw new errors.MtArgumentError(`"${btn.type}" buttons can only be used in reply keyboards`);
+  }
+}
+function toReplyButtonType(btn) {
+  switch (btn.type) {
+    case "text":
+      return { _: "buttonTypeDefault" };
+    case "request_contact":
+      return { _: "buttonTypeRequestPhone" };
+    case "request_geo":
+      return { _: "buttonTypeRequestGeoLocation" };
+    case "request_poll":
+      return { _: "buttonTypeRequestPoll", quiz: btn.quiz };
+    case "webview":
+      return { _: "buttonTypeSimpleWebView", url: btn.url };
+    case "request_peer":
+      if (btn.nameRequested || btn.usernameRequested || btn.photoRequested) {
+        return {
+          _: "inputButtonTypeRequestPeer",
+          nameRequested: btn.nameRequested,
+          usernameRequested: btn.usernameRequested,
+          photoRequested: btn.photoRequested,
+          buttonId: btn.buttonId,
+          peerType: btn.peerType,
+          maxQuantity: btn.count ?? 1
+        };
+      }
+      return {
+        _: "buttonTypeRequestPeer",
+        buttonId: btn.buttonId,
+        peerType: btn.peerType,
+        maxQuantity: btn.count ?? 1
+      };
+    default:
+      throw new errors.MtArgumentError(`"${btn.type}" buttons can only be used in inline keyboards`);
+  }
+}
+function _toInlineButton(btn) {
+  if ("_" in btn) {
+    if (btn._ !== "keyboardInlineButton") {
+      throw new errors.MtArgumentError("reply keyboard buttons cannot be used in inline keyboards");
+    }
+    return btn;
+  }
+  return {
+    _: "keyboardInlineButton",
+    text: btn.text,
+    type: _toInlineButtonType(btn),
+    style: toKeyboardStyle(btn.style)
+  };
+}
+function _toReplyButton(btn) {
+  if ("_" in btn) {
+    if (btn._ !== "keyboardButton") {
+      throw new errors.MtArgumentError("inline keyboard buttons cannot be used in reply keyboards");
+    }
+    return btn;
+  }
+  return {
+    _: "keyboardButton",
+    text: btn.text,
+    type: toReplyButtonType(btn),
+    style: toKeyboardStyle(btn.style)
+  };
+}
+exports._toInlineButton = _toInlineButton;
+exports._toInlineButtonType = _toInlineButtonType;
+exports._toReplyButton = _toReplyButton;
+exports._toRichButtonStyle = _toRichButtonStyle;

package/highlevel/types/bots/keyboards/normalize.d.cts

@@ -0,0 +1,10 @@
+import { tl } from '../../../../tl/index.js';
+import { BotKeyboardButton, BotKeyboardButtonStyle, InputInlineKeyboardButton, InputReplyKeyboardButton } from './types.js';
+/** @internal */
+export declare function _toRichButtonStyle(style?: BotKeyboardButtonStyle): tl.RawRichButtonStyle | undefined;
+/** @internal */
+export declare function _toInlineButtonType(btn: BotKeyboardButton): tl.TypeInlineButtonType;
+/** @internal */
+export declare function _toInlineButton(btn: InputInlineKeyboardButton): tl.TypeKeyboardInlineButton;
+/** @internal */
+export declare function _toReplyButton(btn: InputReplyKeyboardButton): tl.TypeKeyboardButton;