@grammy-x/conversations 0.2.0 → 2.0.1

package/dist/index.cjs

@@ -0,0 +1,451 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  QuestionHelper: () => QuestionHelper,
+  createCustomConversation: () => createCustomConversation
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/question-helper.ts
+var import_grammy = require("grammy");
+var import_core = require("@grammy-x/core");
+function randomInteger(minimum, maximum) {
+  return Math.floor(Math.random() * (maximum - minimum + 1) + minimum);
+}
+var QuestionHelper = class {
+  conversation;
+  config;
+  ctx;
+  message_id;
+  constructor(conversation, ctx, config) {
+    this.conversation = conversation;
+    this.config = config ?? {};
+    this.ctx = ctx;
+  }
+  updateCtx = (ctx) => {
+    Object.keys(this.ctx).forEach((key) => delete this.ctx[key]);
+    Object.assign(this.ctx, ctx);
+  };
+  delete = async () => {
+    if (this.message_id) {
+      await this.ctx.api.deleteMessage(this.ctx.from.id, this.message_id);
+    }
+  };
+  back = async () => {
+    const gx = this.ctx.session?._gx;
+    if (gx?.history.length > 0) {
+      gx.history.pop();
+    }
+    const targetId = gx?.history.length > 0 ? gx.history.pop() : void 0;
+    if (targetId) {
+      const menu = import_core.GlobalMenuRegistry.get(targetId);
+      if (menu) return menu.send(this.ctx);
+    }
+  };
+  reply = async (text, options) => {
+    let newText = text;
+    const mergedOptions = { ...this.config, ...options };
+    if (mergedOptions.autoBold !== false) newText = `<b>${newText}</b>`;
+    if (options?.markup instanceof import_grammy.InlineKeyboard) mergedOptions.markup = options.markup;
+    if (!mergedOptions.markup) mergedOptions.markup = new import_grammy.InlineKeyboard();
+    if (mergedOptions.markup instanceof import_grammy.InlineKeyboard && this.config.markup instanceof import_grammy.InlineKeyboard)
+      mergedOptions.markup.append(this.config.markup);
+    if (mergedOptions.fastMenu && mergedOptions.markup instanceof import_grammy.InlineKeyboard) {
+      const markup = mergedOptions.markup;
+      markup.text(mergedOptions.fastMenuText ?? this.config?.fastMenuText ?? "Main Menu", mergedOptions.fastMenuCallbackData ?? "start");
+    }
+    if (options?.sendContinueButton && mergedOptions.continueInlineEnd && mergedOptions.markup instanceof import_grammy.InlineKeyboard) {
+      const markup = mergedOptions.markup;
+      markup.text(options?.continueButton ?? this.config?.continueButton ?? "Continue", "continue");
+    }
+    const message = await (0, import_core.smartReply)(this.ctx, text, {
+      options: {
+        entities: mergedOptions.entities,
+        reply_markup: mergedOptions.markup
+      },
+      messageToEdit: this.message_id,
+      newMessage: mergedOptions?.newMessage,
+      embolden: false,
+      dedent: false
+    });
+    this.message_id = message?.message_id ?? this.message_id;
+    return message;
+  };
+  getCallbackDataFromKeyboard = (keyboard) => {
+    if (keyboard && keyboard instanceof import_grammy.InlineKeyboard)
+      return keyboard.inline_keyboard.flat().map((b) => b.callback_data).filter(Boolean);
+    return [];
+  };
+  textParser = async (text, parser, validator, options) => {
+    const message = await this.reply(text, options);
+    const additionalTriggers = this.getCallbackDataFromKeyboard(options?.markup);
+    const answer = await this.conversation.waitUntil(
+      (ctx) => import_grammy.Context.has.callbackQuery(additionalTriggers)(ctx) || ctx.has(":text")
+    );
+    this.updateCtx(answer);
+    const callbackQuery = answer.callbackQuery?.data;
+    if (callbackQuery) return { callbackQuery, answerCtx: answer, message };
+    if (answer.message?.text?.startsWith("/")) {
+      await this.ctx.api.deleteMessage(this.ctx.from.id, answer.message.message_id).catch(() => {
+      });
+      const cmd = answer.message.text.split(" ")[0];
+      const err = new Error(`CommandInterrupt:${cmd}`);
+      err.name = "CommandInterruptError";
+      err.ctx = answer;
+      throw err;
+    }
+    const result = parser(answer.msg.text);
+    await this.ctx.api.deleteMessage(this.ctx.from.id, answer.msg.message_id).catch(() => {
+    });
+    if (!validator(result)) return await this.conversation.skip();
+    return { result, answerCtx: answer, message };
+  };
+  text = (text, options) => this.textParser(
+    text,
+    (r) => r,
+    () => true,
+    options
+  );
+  int = (text, options) => this.textParser(text, parseInt, (r) => !isNaN(r), options);
+  float = (text, options) => this.textParser(text, parseFloat, (r) => !isNaN(r), options);
+  chat = async (text, options) => {
+    const chat = options.chat;
+    const markup = new import_grammy.Keyboard().requestChat("\u0412\u044B\u0431\u0440\u0430\u0442\u044C \u0447\u0430\u0442 \u{1F50D}", randomInteger(0, 999999), {
+      chat_is_channel: chat.isChannel,
+      bot_administrator_rights: chat.requiredBotRights,
+      bot_is_member: chat.botIsMember,
+      request_photo: chat.requestPhoto,
+      request_title: chat.requestTitle,
+      request_username: chat.requestUsername ?? true,
+      user_administrator_rights: chat.requiredUserRights
+    }).oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":chat_shared");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.chat_shared;
+  };
+  user = async (text, options) => {
+    const user = options?.user;
+    const markup = new import_grammy.Keyboard().requestUsers("\u0412\u044B\u0431\u0440\u0430\u0442\u044C \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F \u{1F50D}", randomInteger(0, 999999), {
+      max_quantity: 1,
+      request_name: user?.requestName,
+      request_photo: user?.requestPhoto,
+      request_username: user?.requestUsername ?? true,
+      user_is_bot: user?.isBot,
+      user_is_premium: user?.isPremium
+    }).oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":users_shared");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.users_shared?.users[0];
+  };
+  users = async (text, options) => {
+    const users = options?.users;
+    const markup = new import_grammy.Keyboard().requestUsers("\u0412\u044B\u0431\u0440\u0430\u0442\u044C \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u0435\u0439 \u{1F50D}", randomInteger(0, 999999), {
+      max_quantity: users?.maxQuantity,
+      request_name: users?.requestName,
+      request_photo: users?.requestPhoto,
+      request_username: users?.requestUsername ?? true,
+      user_is_bot: users?.isBot,
+      user_is_premium: users?.isPremium
+    }).oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":users_shared");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.users_shared;
+  };
+  contact = async (text, options) => {
+    const markup = new import_grammy.Keyboard().requestContact("\u041F\u043E\u0434\u0435\u043B\u0438\u0442\u044C\u0441\u044F \u043A\u043E\u043D\u0442\u0430\u043A\u0442\u043E\u043C \u{1F4DE}").oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":contact");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.contact;
+  };
+  location = async (text, options) => {
+    const markup = new import_grammy.Keyboard().requestLocation("\u041F\u043E\u0434\u0435\u043B\u0438\u0442\u044C\u0441\u044F \u0433\u0435\u043E\u043F\u043E\u0437\u0438\u0446\u0438\u0435\u0439 \u{1F4CD}").oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":location");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.location;
+  };
+  poll = async (text, options) => {
+    const pollType = options?.poll?.type;
+    const markup = new import_grammy.Keyboard().requestPoll("\u041E\u0442\u043F\u0440\u0430\u0432\u0438\u0442\u044C \u043E\u043F\u0440\u043E\u0441 \u{1F4CA}", pollType).oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":poll");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.poll;
+  };
+  renderPaginationButtons = (pagesCount, currentPage, markup, columnCount, extraControls) => {
+    const oddColumnCount = columnCount % 2 === 0 ? columnCount + 1 : columnCount;
+    const emptyColumns = oddColumnCount >= 5 ? extraControls ? 0 : 1 : 0;
+    for (let i = 0; i < emptyColumns; i++) {
+      markup.text(" ", " ");
+    }
+    if (extraControls) {
+      markup.text(currentPage > 2 ? "\u22D8" : " ", "first");
+    }
+    markup.text(currentPage > 1 ? "\u2190" : " ", "prev");
+    markup.text(currentPage + " / " + pagesCount, "page");
+    markup.text(currentPage < pagesCount ? "\u2192" : " ", "next");
+    if (extraControls) {
+      markup.text(currentPage < pagesCount - 1 ? "\u22D9" : " ", "last");
+    }
+    for (let i = 0; i < emptyColumns; i++) {
+      markup.text(" ", " ");
+    }
+    return markup.row();
+  };
+  resetChoice = (session) => {
+    if (!session._gx.conversations) session._gx.conversations = {
+      currentChoices: /* @__PURE__ */ new Set(),
+      currentPage: 1
+    };
+    else {
+      session._gx.conversations.currentChoices = /* @__PURE__ */ new Set();
+      session._gx.conversations.currentPage = 1;
+    }
+  };
+  async basicChoice(text, choices, multi = false, options, inProgress) {
+    const markup = new import_grammy.InlineKeyboard();
+    const session = await this.conversation.external(
+      () => this.ctx.session
+    );
+    if (!session._gx.conversations) this.resetChoice(session);
+    await this.conversation.external(() => !inProgress && this.resetChoice(session));
+    let currentRow = [];
+    const columnCount = options?.columnCount ?? this.config.columnCount ?? 1;
+    const rowCount = options?.rowCount ?? this.config.rowCount ?? 3;
+    const filledChoices = options?.pagination?.enabled ? choices.concat(
+      Array.from({ length: columnCount * rowCount - choices.length % (columnCount * rowCount) }).map(
+        () => [" ", "empty"]
+      )
+    ) : choices;
+    const pagesCount = Math.ceil(choices.length / (columnCount * rowCount));
+    const currentPage = session._gx.conversations.currentPage ?? 1;
+    let currentRowId = 0;
+    for (const [choiceId, choice] of filledChoices.entries()) {
+      if (options?.pagination?.enabled && choiceId < (currentPage - 1) * columnCount * rowCount) continue;
+      const checked = session._gx.conversations.currentChoices.has(choice[1]);
+      currentRow.push([`${choice[0]}${checked ? " \u2705" : ""}`, choice[1]]);
+      if (currentRow.length === columnCount) {
+        currentRow.forEach(
+          ([label, value]) => markup.text(label, value == "empty" ? "empty" : `answer:${value}`)
+        );
+        markup.row();
+        currentRow = [];
+        currentRowId++;
+        if (options?.pagination?.enabled && (currentRowId === rowCount || choiceId === filledChoices.length - 1)) {
+          this.renderPaginationButtons(
+            pagesCount,
+            currentPage,
+            markup,
+            columnCount,
+            options?.pagination?.extraControls ?? false
+          );
+          break;
+        }
+      }
+    }
+    if (currentRow.length > 0) {
+      currentRow.forEach(([label, value]) => {
+        markup.text(label, `answer:${value}`);
+      });
+      markup.row();
+    }
+    const additionalTriggers = this.getCallbackDataFromKeyboard(options?.markup);
+    if (options?.markup instanceof import_grammy.InlineKeyboard) markup.append(options.markup).row();
+    const sendContinueButton = session._gx.conversations.currentChoices.size > 0;
+    const continueInlineEnd = options?.continueInlineEnd ?? this.config.continueInlineEnd;
+    if (multi && !options?.noChoiceAllowed && !continueInlineEnd && sendContinueButton)
+      markup.text(options?.continueButton ?? this.config?.continueButton ?? "Continue", "continue").row();
+    const messageText = typeof text === "function" ? await text(
+      Array.from(session._gx.conversations.currentChoices),
+      session._gx.conversations.currentPage,
+      pagesCount
+    ) : text;
+    const message = await this.reply(messageText, {
+      ...options,
+      markup,
+      continueButton: options?.continueButton,
+      continueInlineEnd,
+      sendContinueButton: continueInlineEnd && sendContinueButton
+    });
+    let additionalTriggerCalled;
+    let answer;
+    const paginationsCallbacks = ["prev", "next", "page", "empty", "first", "last"];
+    do {
+      answer = await this.conversation.waitForCallbackQuery([
+        ...choices.map((c) => `answer:${c[1]}`),
+        ...multi ? ["continue"] : [],
+        ...options?.pagination?.enabled ? paginationsCallbacks : [],
+        ...additionalTriggers
+      ]);
+      this.updateCtx(answer);
+      const callbackData2 = answer.callbackQuery.data;
+      additionalTriggerCalled = additionalTriggers.includes(callbackData2);
+      if (callbackData2 == "continue" || additionalTriggerCalled) {
+        const choices2 = Array.from(session._gx.conversations.currentChoices);
+        this.ctx.session._gx.conversations.currentChoices = /* @__PURE__ */ new Set();
+        if (additionalTriggerCalled) return { result: choices2, callbackQuery: callbackData2, message };
+        return { result: choices2, message };
+      }
+    } while (additionalTriggerCalled);
+    const questionData = session._gx.conversations;
+    const callbackData = answer.callbackQuery.data;
+    const data = callbackData.split(":")[1];
+    const skip = await this.conversation.external(async () => {
+      if (callbackData == "prev") questionData.currentPage = Math.max(currentPage - 1, 1);
+      if (callbackData == "next") questionData.currentPage = Math.min(currentPage + 1, pagesCount);
+      if (callbackData == "first") questionData.currentPage = 1;
+      if (callbackData == "last") questionData.currentPage = pagesCount;
+      if (data) {
+        if (questionData.currentChoices.has(data)) questionData.currentChoices.delete(data);
+        else questionData.currentChoices.add(data);
+      }
+      ;
+      this.ctx.session._gx.conversations = questionData;
+      if (paginationsCallbacks.includes(callbackData) && questionData.currentPage == currentPage) {
+        await this.ctx.answerCallbackQuery();
+        return true;
+      }
+    });
+    if (skip) return this.conversation.skip({ drop: true });
+    if (!multi && data) {
+      ;
+      this.ctx.session._gx.conversations.currentChoices = /* @__PURE__ */ new Set();
+      return {
+        result: data,
+        message
+      };
+    }
+    return this.basicChoice(text, choices, multi, options, true);
+  }
+  choice = async (text, choices, options) => this.basicChoice(text, choices, false, options);
+  multi = async (text, choices, options) => this.basicChoice(text, choices, true, options);
+  boolean = async (text, yesNoStrings, options) => {
+    const { result, message } = await this.choice(
+      text,
+      [
+        [yesNoStrings?.[0] ?? "\u2705 \u0414\u0430", "true"],
+        [yesNoStrings?.[1] ?? "\u274C \u041D\u0435\u0442", "false"]
+      ],
+      { columnCount: 2, ...options }
+    );
+    const boolResult = result === "true";
+    return { result: boolResult, message };
+  };
+  photo = async (text, options) => {
+    const message = await this.reply(text, options);
+    const answer = await this.conversation.waitFor(":photo");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    const photo = answer.msg.photo?.[0];
+    if (!photo) {
+      throw new Error("No photo found in update");
+    }
+    return photo.file_id;
+  };
+  file = async (text, options) => {
+    const message = await this.reply(text, options);
+    const answer = await this.conversation.waitFor(":file");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.document?.file_id;
+  };
+};
+
+// src/conversation.ts
+var import_conversations = require("@grammyjs/conversations");
+var import_hydrate = require("@grammyjs/hydrate");
+var import_core2 = require("@grammy-x/core");
+function createCustomConversation(builder, config) {
+  let cfg = typeof config === "string" ? { id: config } : config;
+  cfg = cfg ?? {};
+  const id = cfg.id ?? builder.name;
+  cfg.id = id;
+  import_core2.GlobalMenuRegistry.register({
+    menuName: id,
+    send: async (ctx) => {
+      if (!ctx.conversation) {
+        console.error(`[Grammy-X] Cannot enter conversation '${id}': ctx.conversation is undefined. Make sure bot.use(conversations()) is registered before components that use it.`);
+        return;
+      }
+      if (ctx.conversation.active) {
+        await ctx.conversation.exit();
+      }
+      return ctx.conversation.enter(id);
+    }
+  });
+  return (0, import_conversations.createConversation)(
+    (async (conversation, ctx) => {
+      await conversation.run((0, import_hydrate.hydrate)());
+      const gx = ctx.session?._gx;
+      if (gx && gx.history[gx.history.length - 1] !== id) {
+        gx.history.push(id);
+        if (gx.history.length > 20) gx.history.shift();
+      }
+      try {
+        return await builder(conversation, ctx);
+      } catch (e) {
+        if (e.name === "CommandInterruptError") {
+          const cmd = e.message.split(":")[1];
+          const opts = (0, import_core2.getGrammyXOptions)(e.ctx);
+          const targetMenu = opts?.interruptCommands?.[cmd];
+          if (targetMenu) {
+            try {
+              if (typeof targetMenu === "string") {
+                await e.ctx.menu.nav(targetMenu);
+              } else if (typeof targetMenu.send === "function") {
+                await targetMenu.send(e.ctx);
+              }
+            } catch (err) {
+              console.error(`Could not auto-nav to target menu for command ${cmd}`, err);
+            }
+          }
+          return;
+        }
+        throw e;
+      }
+    }),
+    cfg
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QuestionHelper,
+  createCustomConversation
+});

package/dist/index.d.cts

@@ -0,0 +1,116 @@
+import * as grammy_types from 'grammy/types';
+import { ChatAdministratorRights, ChatShared, UsersShared, Contact, Location, Poll } from 'grammy/types';
+import { Conversation, ConversationConfig } from '@grammyjs/conversations';
+import { Context, InlineKeyboard, Keyboard, MiddlewareFn } from 'grammy';
+
+type MaybePromise<T> = PromiseLike<T> | T;
+type ButtonsMarkup = InlineKeyboard | Keyboard;
+interface QuestionParameters {
+    markup?: ButtonsMarkup;
+    autoBold?: boolean;
+    entities?: any[];
+    fastMenu?: boolean;
+    fastMenuCallbackData?: string;
+    fastMenuText?: string;
+    newMessage?: boolean;
+}
+interface QuestionCallbackParameters extends QuestionParameters {
+    columnCount?: number;
+    noChoiceAllowed?: boolean;
+    rowCount?: number;
+    continueButton?: string;
+    pagination?: {
+        enabled: boolean;
+        extraControls?: boolean;
+    };
+}
+interface QuestionMultiParameters extends QuestionCallbackParameters {
+    continueInlineEnd?: boolean;
+}
+interface QuestionChatParameters extends QuestionParameters {
+    chat: {
+        requiredUserRights?: ChatAdministratorRights;
+        requiredBotRights?: ChatAdministratorRights;
+        botIsMember?: boolean;
+        isChannel: boolean;
+        requestTitle?: boolean;
+        requestUsername?: boolean;
+        requestPhoto?: boolean;
+    };
+}
+interface QuestionUserParameters extends QuestionParameters {
+    user?: {
+        isBot?: boolean;
+        isPremium?: boolean;
+        requestName?: boolean;
+        requestUsername?: boolean;
+        requestPhoto?: boolean;
+    };
+}
+interface QuestionUsersParameters extends QuestionParameters {
+    users?: {
+        maxQuantity?: number;
+        isBot?: boolean;
+        isPremium?: boolean;
+        requestName?: boolean;
+        requestUsername?: boolean;
+        requestPhoto?: boolean;
+    };
+}
+interface QuestionPollParameters extends QuestionParameters {
+    poll?: {
+        type?: "regular" | "quiz";
+    };
+}
+type QuestionUniversalParameters = Partial<QuestionMultiParameters & QuestionChatParameters & QuestionUserParameters & QuestionUsersParameters & QuestionPollParameters>;
+interface TextParserResult<R> {
+    result?: R;
+    callbackQuery?: string;
+    answerCtx?: any;
+    message?: any;
+}
+declare class QuestionHelper<C extends Context = Context, T extends Conversation<C> = Conversation<C>> {
+    private conversation;
+    private config;
+    private ctx;
+    message_id?: number;
+    constructor(conversation: T, ctx: C, config?: QuestionUniversalParameters);
+    private updateCtx;
+    delete: () => Promise<void>;
+    back: () => Promise<unknown>;
+    private reply;
+    private getCallbackDataFromKeyboard;
+    private textParser;
+    text: (text: string, options?: QuestionParameters) => Promise<TextParserResult<string>>;
+    int: (text: string, options?: QuestionParameters) => Promise<TextParserResult<number>>;
+    float: (text: string, options?: QuestionParameters) => Promise<TextParserResult<number>>;
+    chat: (text: string, options: QuestionChatParameters) => Promise<ChatShared>;
+    user: (text: string, options?: QuestionUserParameters) => Promise<grammy_types.SharedUser>;
+    users: (text: string, options?: QuestionUsersParameters) => Promise<UsersShared>;
+    contact: (text: string, options?: QuestionParameters) => Promise<Contact>;
+    location: (text: string, options?: QuestionParameters) => Promise<Location>;
+    poll: (text: string, options?: QuestionPollParameters) => Promise<Poll>;
+    private renderPaginationButtons;
+    private resetChoice;
+    private basicChoice;
+    choice: <const R_1 extends string>(text: string, choices: [string, R_1][], options?: QuestionCallbackParameters) => Promise<{
+        result: R_1;
+        message: any;
+    }>;
+    multi: <const R_1 extends string>(text: string | ((choices: R_1[], currentPage: number, pagesCount: number) => MaybePromise<string>), choices: [string, R_1][], options?: QuestionCallbackParameters) => Promise<{
+        result: R_1[];
+        callbackData?: string;
+        message: any;
+    }>;
+    boolean: (text: string, yesNoStrings?: string[], options?: QuestionCallbackParameters) => Promise<{
+        result: boolean;
+        message: any;
+    }>;
+    photo: (text: string, options?: QuestionParameters) => Promise<string>;
+    file: (text: string, options?: QuestionParameters) => Promise<string>;
+}
+
+type ConversationFn<C extends Context = Context> = (conversation: Conversation<C>, ctx: C) => unknown | Promise<unknown>;
+declare function createCustomConversation<C extends Context = Context>(builder: ConversationFn<C>, config?: string | ConversationConfig): MiddlewareFn<any>;
+
+export { type ConversationFn, QuestionHelper, createCustomConversation };

package/dist/index.d.ts

@@ -0,0 +1,116 @@
+import * as grammy_types from 'grammy/types';
+import { ChatAdministratorRights, ChatShared, UsersShared, Contact, Location, Poll } from 'grammy/types';
+import { Conversation, ConversationConfig } from '@grammyjs/conversations';
+import { Context, InlineKeyboard, Keyboard, MiddlewareFn } from 'grammy';
+
+type MaybePromise<T> = PromiseLike<T> | T;
+type ButtonsMarkup = InlineKeyboard | Keyboard;
+interface QuestionParameters {
+    markup?: ButtonsMarkup;
+    autoBold?: boolean;
+    entities?: any[];
+    fastMenu?: boolean;
+    fastMenuCallbackData?: string;
+    fastMenuText?: string;
+    newMessage?: boolean;
+}
+interface QuestionCallbackParameters extends QuestionParameters {
+    columnCount?: number;
+    noChoiceAllowed?: boolean;
+    rowCount?: number;
+    continueButton?: string;
+    pagination?: {
+        enabled: boolean;
+        extraControls?: boolean;
+    };
+}
+interface QuestionMultiParameters extends QuestionCallbackParameters {
+    continueInlineEnd?: boolean;
+}
+interface QuestionChatParameters extends QuestionParameters {
+    chat: {
+        requiredUserRights?: ChatAdministratorRights;
+        requiredBotRights?: ChatAdministratorRights;
+        botIsMember?: boolean;
+        isChannel: boolean;
+        requestTitle?: boolean;
+        requestUsername?: boolean;
+        requestPhoto?: boolean;
+    };
+}
+interface QuestionUserParameters extends QuestionParameters {
+    user?: {
+        isBot?: boolean;
+        isPremium?: boolean;
+        requestName?: boolean;
+        requestUsername?: boolean;
+        requestPhoto?: boolean;
+    };
+}
+interface QuestionUsersParameters extends QuestionParameters {
+    users?: {
+        maxQuantity?: number;
+        isBot?: boolean;
+        isPremium?: boolean;
+        requestName?: boolean;
+        requestUsername?: boolean;
+        requestPhoto?: boolean;
+    };
+}
+interface QuestionPollParameters extends QuestionParameters {
+    poll?: {
+        type?: "regular" | "quiz";
+    };
+}
+type QuestionUniversalParameters = Partial<QuestionMultiParameters & QuestionChatParameters & QuestionUserParameters & QuestionUsersParameters & QuestionPollParameters>;
+interface TextParserResult<R> {
+    result?: R;
+    callbackQuery?: string;
+    answerCtx?: any;
+    message?: any;
+}
+declare class QuestionHelper<C extends Context = Context, T extends Conversation<C> = Conversation<C>> {
+    private conversation;
+    private config;
+    private ctx;
+    message_id?: number;
+    constructor(conversation: T, ctx: C, config?: QuestionUniversalParameters);
+    private updateCtx;
+    delete: () => Promise<void>;
+    back: () => Promise<unknown>;
+    private reply;
+    private getCallbackDataFromKeyboard;
+    private textParser;
+    text: (text: string, options?: QuestionParameters) => Promise<TextParserResult<string>>;
+    int: (text: string, options?: QuestionParameters) => Promise<TextParserResult<number>>;
+    float: (text: string, options?: QuestionParameters) => Promise<TextParserResult<number>>;
+    chat: (text: string, options: QuestionChatParameters) => Promise<ChatShared>;
+    user: (text: string, options?: QuestionUserParameters) => Promise<grammy_types.SharedUser>;
+    users: (text: string, options?: QuestionUsersParameters) => Promise<UsersShared>;
+    contact: (text: string, options?: QuestionParameters) => Promise<Contact>;
+    location: (text: string, options?: QuestionParameters) => Promise<Location>;
+    poll: (text: string, options?: QuestionPollParameters) => Promise<Poll>;
+    private renderPaginationButtons;
+    private resetChoice;
+    private basicChoice;
+    choice: <const R_1 extends string>(text: string, choices: [string, R_1][], options?: QuestionCallbackParameters) => Promise<{
+        result: R_1;
+        message: any;
+    }>;
+    multi: <const R_1 extends string>(text: string | ((choices: R_1[], currentPage: number, pagesCount: number) => MaybePromise<string>), choices: [string, R_1][], options?: QuestionCallbackParameters) => Promise<{
+        result: R_1[];
+        callbackData?: string;
+        message: any;
+    }>;
+    boolean: (text: string, yesNoStrings?: string[], options?: QuestionCallbackParameters) => Promise<{
+        result: boolean;
+        message: any;
+    }>;
+    photo: (text: string, options?: QuestionParameters) => Promise<string>;
+    file: (text: string, options?: QuestionParameters) => Promise<string>;
+}
+
+type ConversationFn<C extends Context = Context> = (conversation: Conversation<C>, ctx: C) => unknown | Promise<unknown>;
+declare function createCustomConversation<C extends Context = Context>(builder: ConversationFn<C>, config?: string | ConversationConfig): MiddlewareFn<any>;
+
+export { type ConversationFn, QuestionHelper, createCustomConversation };