@core-ease/telegram-kit 3.0.1

package/dist/index.mjs

@@ -0,0 +1,478 @@
+"use client";
+import { getWebApp, isInTelegram, expand, disableVerticalSwipes, enableClosingConfirmation, ready, setHeaderColor, setBackgroundColor, setBottomBarColor } from './chunk-B3PWALX5.mjs';
+export { addToHomeScreen, biometric, bootstrapTelegramWebApp, checkHomeScreenStatus, close, cloudStorage, deviceStorage, dialog, disableClosingConfirmation, disableVerticalSwipes, downloadFile, enableClosingConfirmation, enableVerticalSwipes, expand, fullscreen, getRawUserData, getTheme, getUserAvatarUrl, getUserDisplayName, getUserIdentifier, getUserInfoWithAvatar, getViewport, getWebApp, haptic, hideKeyboard, invokeCustomMethod, isInTelegram, isVersionAtLeast, location, openExternalLink, openInvoice, openTelegramLink, orientation, readClipboard, ready, requestChat, requestContact, requestEmojiStatusAccess, requestWriteAccess, safeInvoke, scanQr, sdk_exports as sdk, secureStorage, setBackgroundColor, setBottomBarColor, setEmojiStatus, setHeaderColor, shareMessage, shareToStory, switchInlineQuery, useAccelerometer, useBiometric, useCloudStorage, useDeviceOrientation, useDeviceStorage, useDownloadFile, useGyroscope, useHapticFeedback, useHideKeyboard, useHomeScreen, useInitData, useInvokeCustomMethod, useIsActive, useLocation, useOrientationLock, useReadTextFromClipboard, useReady, useRequestChat, useRequestContact, useRequestEmojiStatusAccess, useRequestWriteAccess, useSafeArea, useScanQrPopup, useSecureStorage, useSetEmojiStatus, useShareMessage, useShareToStory, useShowAlert, useShowConfirm, useShowPopup, useSwitchInlineQuery, useTelegramBackButton, useTelegramEvent, useTelegramFullscreen, useTelegramMainButton, useTelegramSecondaryButton, useTelegramSettingsButton, useTelegramStartParam, useTelegramTheme, useTelegramUser, useTelegramViewport, useTelegramWebApp } from './chunk-B3PWALX5.mjs';
+import { __spreadProps, __spreadValues } from './chunk-PXO36YTU.mjs';
+import { createContext, useContext, useRef, useEffect, useState, useLayoutEffect } from 'react';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+// src/core/dev.ts
+function isDevMode() {
+  var _a;
+  if (typeof window === "undefined") return false;
+  return typeof process !== "undefined" && ((_a = process.env) == null ? void 0 : _a.NODE_ENV) === "development" || new URLSearchParams(window.location.search).has("tg_dev");
+}
+var defaultCtx = {
+  ready: false,
+  inTelegram: false,
+  isDevBypass: false,
+  webApp: null,
+  user: null,
+  colorScheme: "dark",
+  startParam: null
+};
+var TelegramContext = createContext(defaultCtx);
+function useTelegram() {
+  return useContext(TelegramContext);
+}
+function applyColorScheme(scheme) {
+  if (typeof document === "undefined") return;
+  if (scheme === "dark") {
+    document.documentElement.classList.add("dark");
+  } else {
+    document.documentElement.classList.remove("dark");
+  }
+}
+function TelegramProvider({
+  children,
+  options = {}
+}) {
+  const {
+    onUserReady,
+    onReady,
+    loadingComponent = null,
+    notInTelegramComponent = null,
+    allowOutsideTelegram = false,
+    autoExpand = true,
+    autoDisableVerticalSwipes = true,
+    autoEnableClosingConfirmation = false,
+    headerColor,
+    backgroundColor,
+    bottomBarColor
+  } = options;
+  const onUserReadyRef = useRef(onUserReady);
+  const onReadyRef = useRef(onReady);
+  useEffect(() => {
+    onUserReadyRef.current = onUserReady;
+  });
+  useEffect(() => {
+    onReadyRef.current = onReady;
+  });
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [ctx, setCtx] = useState(defaultCtx);
+  useLayoutEffect(() => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const wa = getWebApp();
+    const inTg = isInTelegram();
+    const devBypass = !inTg && isDevMode();
+    let user = null;
+    let startParam = null;
+    let colorScheme = "dark";
+    if (wa) {
+      if (autoExpand) expand();
+      if (autoDisableVerticalSwipes) disableVerticalSwipes();
+      if (autoEnableClosingConfirmation) enableClosingConfirmation();
+      colorScheme = (_a = wa.colorScheme) != null ? _a : "dark";
+      user = (_c = (_b = wa.initDataUnsafe) == null ? void 0 : _b.user) != null ? _c : null;
+      startParam = (_e = (_d = wa.initDataUnsafe) == null ? void 0 : _d.start_param) != null ? _e : null;
+      if (user) (_f = onUserReadyRef.current) == null ? void 0 : _f.call(onUserReadyRef, user);
+      (_g = onReadyRef.current) == null ? void 0 : _g.call(onReadyRef, wa);
+    }
+    applyColorScheme(colorScheme);
+    setCtx({
+      ready: true,
+      inTelegram: inTg,
+      isDevBypass: devBypass,
+      webApp: wa,
+      user,
+      colorScheme,
+      startParam
+    });
+    setIsInitialized(true);
+    ready();
+  }, [autoExpand, autoDisableVerticalSwipes, autoEnableClosingConfirmation]);
+  useEffect(() => {
+    if (!ctx.ready) return;
+    if (headerColor) setHeaderColor(headerColor);
+    if (backgroundColor) setBackgroundColor(backgroundColor);
+    if (bottomBarColor) setBottomBarColor(bottomBarColor);
+  }, [ctx.ready, headerColor, backgroundColor, bottomBarColor]);
+  useEffect(() => {
+    const wa = ctx.webApp;
+    if (!wa) return;
+    const handleThemeChanged = () => {
+      var _a;
+      const scheme = (_a = wa.colorScheme) != null ? _a : "dark";
+      applyColorScheme(scheme);
+      setCtx((prev) => prev.colorScheme === scheme ? prev : __spreadProps(__spreadValues({}, prev), { colorScheme: scheme }));
+    };
+    wa.onEvent("themeChanged", handleThemeChanged);
+    return () => wa.offEvent("themeChanged", handleThemeChanged);
+  }, [ctx.webApp]);
+  if (!isInitialized) return /* @__PURE__ */ jsx(Fragment, { children: loadingComponent });
+  if (ctx.ready && !ctx.inTelegram && !ctx.isDevBypass && !allowOutsideTelegram) {
+    return /* @__PURE__ */ jsx(Fragment, { children: notInTelegramComponent });
+  }
+  return /* @__PURE__ */ jsx(TelegramContext.Provider, { value: ctx, children });
+}
+
+// src/utils/format.ts
+var TelegramFormattedText = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  toString() {
+    return this.raw;
+  }
+};
+function isFragment(part) {
+  return part instanceof TelegramFormattedText;
+}
+function joinParts(parts, escape) {
+  return parts.map((part) => isFragment(part) ? part.raw : escape(part)).join("");
+}
+var MARKDOWN_V2_RESERVED = /[_*[\]()~`>#+\-=|{}.!\\]/g;
+var MARKDOWN_V2_CODE_RESERVED = /[`\\]/g;
+var MARKDOWN_V2_LINK_URL_RESERVED = /[)\\]/g;
+function escapeMarkdownV2(text) {
+  return text.replace(MARKDOWN_V2_RESERVED, (ch) => `\\${ch}`);
+}
+function escapeMarkdownV2Code(text) {
+  return text.replace(MARKDOWN_V2_CODE_RESERVED, (ch) => `\\${ch}`);
+}
+function escapeMarkdownV2LinkUrl(url) {
+  return url.replace(MARKDOWN_V2_LINK_URL_RESERVED, (ch) => `\\${ch}`);
+}
+function createMarkdownV2Formatter() {
+  const wrap = (raw) => new TelegramFormattedText(raw);
+  const t = (parts) => joinParts(parts, escapeMarkdownV2);
+  return {
+    escape: escapeMarkdownV2,
+    escapeCode: escapeMarkdownV2Code,
+    escapeLinkUrl: escapeMarkdownV2LinkUrl,
+    text: (...parts) => wrap(t(parts)),
+    bold: (...parts) => wrap(`*${t(parts)}*`),
+    italic: (...parts) => wrap(`_${t(parts)}_`),
+    underline: (...parts) => wrap(`__${t(parts)}__`),
+    strikethrough: (...parts) => wrap(`~${t(parts)}~`),
+    spoiler: (...parts) => wrap(`||${t(parts)}||`),
+    code: (text) => wrap(`\`${escapeMarkdownV2Code(text)}\``),
+    pre: (text, language) => wrap(`\`\`\`${language != null ? language : ""}
+${escapeMarkdownV2Code(text)}
+\`\`\``),
+    link: (url, ...parts) => wrap(`[${t(parts)}](${escapeMarkdownV2LinkUrl(url)})`),
+    mentionUser: (userId, ...parts) => wrap(`[${t(parts)}](tg://user?id=${userId})`),
+    customEmoji: (emojiId, fallbackEmoji) => wrap(`![${escapeMarkdownV2(fallbackEmoji)}](tg://emoji?id=${emojiId})`),
+    raw: (raw) => wrap(raw)
+  };
+}
+function escapeHTML(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHTMLAttribute(text) {
+  return escapeHTML(text).replace(/"/g, "&quot;");
+}
+function createHtmlFormatter() {
+  const wrap = (raw) => new TelegramFormattedText(raw);
+  const t = (parts) => joinParts(parts, escapeHTML);
+  return {
+    escape: escapeHTML,
+    escapeAttribute: escapeHTMLAttribute,
+    text: (...parts) => wrap(t(parts)),
+    bold: (...parts) => wrap(`<b>${t(parts)}</b>`),
+    italic: (...parts) => wrap(`<i>${t(parts)}</i>`),
+    underline: (...parts) => wrap(`<u>${t(parts)}</u>`),
+    strikethrough: (...parts) => wrap(`<s>${t(parts)}</s>`),
+    spoiler: (...parts) => wrap(`<tg-spoiler>${t(parts)}</tg-spoiler>`),
+    code: (text) => wrap(`<code>${escapeHTML(text)}</code>`),
+    pre: (text, language) => wrap(
+      language ? `<pre><code class="language-${escapeHTMLAttribute(language)}">${escapeHTML(text)}</code></pre>` : `<pre>${escapeHTML(text)}</pre>`
+    ),
+    link: (url, ...parts) => wrap(`<a href="${escapeHTMLAttribute(url)}">${t(parts)}</a>`),
+    mentionUser: (userId, ...parts) => wrap(`<a href="tg://user?id=${userId}">${t(parts)}</a>`),
+    blockquote: (...parts) => wrap(`<blockquote>${t(parts)}</blockquote>`),
+    expandableBlockquote: (...parts) => wrap(`<blockquote expandable>${t(parts)}</blockquote>`),
+    customEmoji: (emojiId, fallbackEmoji) => wrap(`<tg-emoji emoji-id="${escapeHTMLAttribute(emojiId)}">${escapeHTML(fallbackEmoji)}</tg-emoji>`),
+    raw: (rawHtml) => wrap(rawHtml)
+  };
+}
+var md = createMarkdownV2Formatter();
+var html = createHtmlFormatter();
+var TELEGRAM_TEXT_LIMITS = {
+  MESSAGE: 4096,
+  CAPTION: 1024,
+  BUTTON_TEXT: 64,
+  CALLBACK_DATA: 64,
+  START_PARAMETER: 64,
+  BOT_DESCRIPTION: 512,
+  BOT_SHORT_DESCRIPTION: 120,
+  CHAT_TITLE: 128,
+  POLL_QUESTION: 300,
+  POLL_OPTION: 100
+};
+function isHighSurrogate(code) {
+  return code >= 55296 && code <= 56319;
+}
+function isLowSurrogate(code) {
+  return code >= 56320 && code <= 57343;
+}
+function truncateText(text, maxLength, ellipsis = "\u2026") {
+  if (text.length <= maxLength) return text;
+  let cut = Math.max(0, maxLength - ellipsis.length);
+  if (cut > 0 && isHighSurrogate(text.charCodeAt(cut - 1)) && isLowSurrogate(text.charCodeAt(cut))) {
+    cut -= 1;
+  }
+  return text.slice(0, cut) + ellipsis;
+}
+
+// src/utils/links.ts
+function bytesToBase64Url(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlToBytes(base64url) {
+  const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+var START_PARAM_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+function isValidStartParam(param) {
+  return START_PARAM_PATTERN.test(param);
+}
+function encodeStartParam(value) {
+  const encoded = bytesToBase64Url(new TextEncoder().encode(value));
+  if (encoded.length > 64) {
+    throw new Error(
+      `[@core-ease/telegram-kit] encodeStartParam: the encoded value is ${encoded.length} characters, exceeding Telegram's 64-character limit for start parameters. Pass a shorter payload (e.g. a numeric/short ID you look up server-side, instead of embedding full data).`
+    );
+  }
+  return encoded;
+}
+function decodeStartParam(param) {
+  return new TextDecoder().decode(base64UrlToBytes(param));
+}
+function resolveStartParam(options) {
+  if (options.startParam !== void 0 && options.data !== void 0) {
+    throw new Error("[@core-ease/telegram-kit] Provide either `startParam` or `data`, not both.");
+  }
+  if (options.data !== void 0) return encodeStartParam(options.data);
+  if (options.startParam !== void 0) {
+    if (!isValidStartParam(options.startParam)) {
+      throw new Error(
+        `[@core-ease/telegram-kit] "${options.startParam}" is not a valid Telegram start parameter (allowed characters: A-Z a-z 0-9 _ -, max 64 chars). Use \`data\` instead to auto-encode arbitrary text.`
+      );
+    }
+    return options.startParam;
+  }
+  return void 0;
+}
+function buildStartLink(options) {
+  const param = resolveStartParam(options);
+  const base = `https://t.me/${options.botUsername}`;
+  return param ? `${base}?start=${param}` : base;
+}
+function buildStartAppLink(options) {
+  const param = resolveStartParam(options);
+  const base = options.appName ? `https://t.me/${options.botUsername}/${options.appName}` : `https://t.me/${options.botUsername}`;
+  const query = new URLSearchParams();
+  if (param) query.set("startapp", param);
+  if (options.mode) query.set("mode", options.mode);
+  const queryString = query.toString();
+  return queryString ? `${base}?${queryString}` : base;
+}
+function buildShareLink(options) {
+  const query = new URLSearchParams({ url: options.url });
+  if (options.text) query.set("text", options.text);
+  return `https://t.me/share/url?${query.toString()}`;
+}
+var TME_HOSTNAMES = /* @__PURE__ */ new Set(["t.me", "telegram.me", "telegram.dog"]);
+function parseTelegramLink(link) {
+  var _a, _b, _c, _d;
+  let url;
+  try {
+    url = new URL(link);
+  } catch (e) {
+    return { type: "unknown", url: link };
+  }
+  if (url.protocol === "tg:") {
+    const action = url.hostname || url.pathname.replace(/^\/+/, "");
+    if (action === "resolve") {
+      const domain = url.searchParams.get("domain");
+      const start2 = url.searchParams.get("start");
+      const startapp2 = url.searchParams.get("startapp");
+      const mode2 = (_a = url.searchParams.get("mode")) != null ? _a : void 0;
+      if (domain && start2) return { type: "bot-start", username: domain, startParam: start2 };
+      if (domain && startapp2 !== null) {
+        return { type: "mini-app", username: domain, startParam: startapp2 || void 0, mode: mode2 };
+      }
+      if (domain) return { type: "profile", username: domain };
+    }
+    if (action === "join") {
+      const invite = url.searchParams.get("invite");
+      if (invite) return { type: "join-chat", inviteHash: invite };
+    }
+    return { type: "unknown", url: link };
+  }
+  if (!TME_HOSTNAMES.has(url.hostname)) {
+    return { type: "unknown", url: link };
+  }
+  const segments = url.pathname.split("/").filter(Boolean);
+  if (segments.length === 0) return { type: "unknown", url: link };
+  if (segments[0].startsWith("+")) {
+    return { type: "join-chat", inviteHash: segments[0].slice(1) };
+  }
+  if (segments[0] === "joinchat" && segments[1]) {
+    return { type: "join-chat", inviteHash: segments[1] };
+  }
+  if (segments[0] === "share" && segments[1] === "url") {
+    return {
+      type: "share",
+      url: (_b = url.searchParams.get("url")) != null ? _b : void 0,
+      text: (_c = url.searchParams.get("text")) != null ? _c : void 0
+    };
+  }
+  if (segments[0] === "c" && segments[1] && segments[2]) {
+    const messageId = Number(segments[2]);
+    return { type: "private-channel-post", internalChatId: segments[1], messageId };
+  }
+  const username = segments[0];
+  const startapp = url.searchParams.get("startapp");
+  const start = url.searchParams.get("start");
+  const mode = (_d = url.searchParams.get("mode")) != null ? _d : void 0;
+  if (segments.length >= 2) {
+    return { type: "mini-app", username, appName: segments[1], startParam: startapp != null ? startapp : void 0, mode };
+  }
+  if (startapp !== null) {
+    return { type: "mini-app", username, startParam: startapp || void 0, mode };
+  }
+  if (start !== null) {
+    return { type: "bot-start", username, startParam: start };
+  }
+  return { type: "profile", username };
+}
+
+// src/utils/keyboards.ts
+var InlineKeyboardBuilder = class _InlineKeyboardBuilder {
+  constructor() {
+    this.rows = [[]];
+  }
+  currentRow() {
+    return this.rows[this.rows.length - 1];
+  }
+  add(button) {
+    this.currentRow().push(button);
+    return this;
+  }
+  text(text, callbackData) {
+    return this.add({ text, callback_data: callbackData });
+  }
+  url(text, url) {
+    return this.add({ text, url });
+  }
+  webApp(text, url) {
+    return this.add({ text, web_app: { url } });
+  }
+  login(text, loginUrl) {
+    return this.add({ text, login_url: typeof loginUrl === "string" ? { url: loginUrl } : loginUrl });
+  }
+  switchInline(text, query = "") {
+    return this.add({ text, switch_inline_query: query });
+  }
+  switchInlineCurrentChat(text, query = "") {
+    return this.add({ text, switch_inline_query_current_chat: query });
+  }
+  switchInlineChosenChat(text, query) {
+    return this.add({ text, switch_inline_query_chosen_chat: query != null ? query : {} });
+  }
+  copyText(text, copyText) {
+    return this.add({ text, copy_text: typeof copyText === "string" ? { text: copyText } : copyText });
+  }
+  pay(text = "Pay") {
+    return this.add({ text, pay: true });
+  }
+  callbackGame(text) {
+    return this.add({ text, callback_game: {} });
+  }
+  button(button) {
+    return this.add(button);
+  }
+  row() {
+    if (this.currentRow().length > 0) this.rows.push([]);
+    return this;
+  }
+  static columns(buttons, perRow) {
+    const builder = new _InlineKeyboardBuilder();
+    buttons.forEach((button, i) => {
+      if (i > 0 && i % perRow === 0) builder.row();
+      builder.button(button);
+    });
+    return builder;
+  }
+  build() {
+    const rows = this.rows.filter((row) => row.length > 0);
+    return { inline_keyboard: rows };
+  }
+};
+var ReplyKeyboardBuilder = class {
+  constructor() {
+    this.rows = [[]];
+  }
+  currentRow() {
+    return this.rows[this.rows.length - 1];
+  }
+  add(button) {
+    this.currentRow().push(button);
+    return this;
+  }
+  text(label) {
+    return this.add({ text: label });
+  }
+  requestContact(label) {
+    return this.add({ text: label, request_contact: true });
+  }
+  requestLocation(label) {
+    return this.add({ text: label, request_location: true });
+  }
+  requestPoll(label, type) {
+    return this.add({ text: label, request_poll: { type } });
+  }
+  webApp(label, url) {
+    return this.add({ text: label, web_app: { url } });
+  }
+  requestUsers(label, params) {
+    return this.add({ text: label, request_users: params });
+  }
+  requestChat(label, params) {
+    return this.add({ text: label, request_chat: params });
+  }
+  button(button) {
+    return this.add(button);
+  }
+  row() {
+    if (this.currentRow().length > 0) this.rows.push([]);
+    return this;
+  }
+  build(options = {}) {
+    var _a;
+    const rows = this.rows.filter((row) => row.length > 0);
+    return {
+      keyboard: rows,
+      resize_keyboard: (_a = options.resize) != null ? _a : true,
+      one_time_keyboard: options.oneTime,
+      selective: options.selective,
+      input_field_placeholder: options.placeholder,
+      is_persistent: options.persistent
+    };
+  }
+};
+function removeKeyboard(selective) {
+  return { remove_keyboard: true, selective };
+}
+function forceReply(options) {
+  return { force_reply: true, input_field_placeholder: options == null ? void 0 : options.placeholder, selective: options == null ? void 0 : options.selective };
+}
+
+export { InlineKeyboardBuilder, ReplyKeyboardBuilder, TELEGRAM_TEXT_LIMITS, TelegramFormattedText, TelegramProvider, buildShareLink, buildStartAppLink, buildStartLink, decodeStartParam, encodeStartParam, escapeHTML, escapeHTMLAttribute, escapeMarkdownV2, escapeMarkdownV2Code, escapeMarkdownV2LinkUrl, forceReply, html, isValidStartParam, md, parseTelegramLink, removeKeyboard, truncateText, useTelegram };

package/dist/keyboards/index.d.mts

@@ -0,0 +1,50 @@
+import { bS as LoginUrl, ct as SwitchInlineQueryChosenChat, cu as CopyTextButton, bG as InlineKeyboardButton, bH as InlineKeyboardMarkup, cv as KeyboardButtonPollType, cw as KeyboardButtonRequestUsers, cx as KeyboardButtonRequestChat, bO as KeyboardButton, c2 as ReplyKeyboardMarkup, bt as ForceReply, c3 as ReplyKeyboardRemove } from '../bot-D8BnLWIi.mjs';
+
+declare class InlineKeyboardBuilder {
+    private rows;
+    private currentRow;
+    private add;
+    text(text: string, callbackData: string): this;
+    url(text: string, url: string): this;
+    webApp(text: string, url: string): this;
+    login(text: string, loginUrl: string | LoginUrl): this;
+    switchInline(text: string, query?: string): this;
+    switchInlineCurrentChat(text: string, query?: string): this;
+    switchInlineChosenChat(text: string, query?: SwitchInlineQueryChosenChat): this;
+    copyText(text: string, copyText: string | CopyTextButton): this;
+    pay(text?: string): this;
+    callbackGame(text: string): this;
+    button(button: InlineKeyboardButton): this;
+    row(): this;
+    static columns(buttons: InlineKeyboardButton[], perRow: number): InlineKeyboardBuilder;
+    build(): InlineKeyboardMarkup;
+}
+interface ReplyKeyboardBuildOptions {
+    resize?: boolean;
+    oneTime?: boolean;
+    selective?: boolean;
+    placeholder?: string;
+    persistent?: boolean;
+}
+declare class ReplyKeyboardBuilder {
+    private rows;
+    private currentRow;
+    private add;
+    text(label: string): this;
+    requestContact(label: string): this;
+    requestLocation(label: string): this;
+    requestPoll(label: string, type?: KeyboardButtonPollType['type']): this;
+    webApp(label: string, url: string): this;
+    requestUsers(label: string, params: KeyboardButtonRequestUsers): this;
+    requestChat(label: string, params: KeyboardButtonRequestChat): this;
+    button(button: KeyboardButton): this;
+    row(): this;
+    build(options?: ReplyKeyboardBuildOptions): ReplyKeyboardMarkup;
+}
+declare function removeKeyboard(selective?: boolean): ReplyKeyboardRemove;
+declare function forceReply(options?: {
+    placeholder?: string;
+    selective?: boolean;
+}): ForceReply;
+
+export { InlineKeyboardBuilder, type ReplyKeyboardBuildOptions, ReplyKeyboardBuilder, forceReply, removeKeyboard };

package/dist/keyboards/index.d.ts

@@ -0,0 +1,50 @@
+import { bS as LoginUrl, ct as SwitchInlineQueryChosenChat, cu as CopyTextButton, bG as InlineKeyboardButton, bH as InlineKeyboardMarkup, cv as KeyboardButtonPollType, cw as KeyboardButtonRequestUsers, cx as KeyboardButtonRequestChat, bO as KeyboardButton, c2 as ReplyKeyboardMarkup, bt as ForceReply, c3 as ReplyKeyboardRemove } from '../bot-D8BnLWIi.js';
+
+declare class InlineKeyboardBuilder {
+    private rows;
+    private currentRow;
+    private add;
+    text(text: string, callbackData: string): this;
+    url(text: string, url: string): this;
+    webApp(text: string, url: string): this;
+    login(text: string, loginUrl: string | LoginUrl): this;
+    switchInline(text: string, query?: string): this;
+    switchInlineCurrentChat(text: string, query?: string): this;
+    switchInlineChosenChat(text: string, query?: SwitchInlineQueryChosenChat): this;
+    copyText(text: string, copyText: string | CopyTextButton): this;
+    pay(text?: string): this;
+    callbackGame(text: string): this;
+    button(button: InlineKeyboardButton): this;
+    row(): this;
+    static columns(buttons: InlineKeyboardButton[], perRow: number): InlineKeyboardBuilder;
+    build(): InlineKeyboardMarkup;
+}
+interface ReplyKeyboardBuildOptions {
+    resize?: boolean;
+    oneTime?: boolean;
+    selective?: boolean;
+    placeholder?: string;
+    persistent?: boolean;
+}
+declare class ReplyKeyboardBuilder {
+    private rows;
+    private currentRow;
+    private add;
+    text(label: string): this;
+    requestContact(label: string): this;
+    requestLocation(label: string): this;
+    requestPoll(label: string, type?: KeyboardButtonPollType['type']): this;
+    webApp(label: string, url: string): this;
+    requestUsers(label: string, params: KeyboardButtonRequestUsers): this;
+    requestChat(label: string, params: KeyboardButtonRequestChat): this;
+    button(button: KeyboardButton): this;
+    row(): this;
+    build(options?: ReplyKeyboardBuildOptions): ReplyKeyboardMarkup;
+}
+declare function removeKeyboard(selective?: boolean): ReplyKeyboardRemove;
+declare function forceReply(options?: {
+    placeholder?: string;
+    selective?: boolean;
+}): ForceReply;
+
+export { InlineKeyboardBuilder, type ReplyKeyboardBuildOptions, ReplyKeyboardBuilder, forceReply, removeKeyboard };