telegix 1.1.1

package/index.d.ts

@@ -0,0 +1,539 @@
+/**
+ * TypeScript definitions for Telegix
+ */
+
+export interface User {
+  id: number;
+  is_bot: boolean;
+  first_name: string;
+  last_name?: string;
+  username?: string;
+  language_code?: string;
+  is_premium?: boolean;
+  added_to_attachment_menu?: boolean;
+  can_join_groups?: boolean;
+  can_read_all_group_messages?: boolean;
+  supports_inline_queries?: boolean;
+}
+
+export interface Chat {
+  id: number;
+  type: 'private' | 'group' | 'supergroup' | 'channel';
+  title?: string;
+  username?: string;
+  first_name?: string;
+  last_name?: string;
+  is_forum?: boolean;
+}
+
+export interface Message {
+  message_id: number;
+  message_thread_id?: number;
+  from?: User;
+  sender_chat?: Chat;
+  date: number;
+  chat: Chat;
+  text?: string;
+  caption?: string;
+  entities?: any[];
+  caption_entities?: any[];
+  photo?: any[];
+  audio?: any;
+  document?: any;
+  video?: any;
+  voice?: any;
+  sticker?: any;
+  poll?: any;
+  dice?: any;
+  reply_to_message?: Message;
+  [key: string]: any;
+}
+
+export interface Update {
+  update_id: number;
+  message?: Message;
+  edited_message?: Message;
+  channel_post?: Message;
+  edited_channel_post?: Message;
+  inline_query?: any;
+  chosen_inline_result?: any;
+  callback_query?: any;
+  shipping_query?: any;
+  pre_checkout_query?: any;
+  poll?: any;
+  poll_answer?: any;
+  my_chat_member?: any;
+  chat_member?: any;
+  chat_join_request?: any;
+  message_reaction?: any;
+  [key: string]: any;
+}
+
+export type Middleware<C extends Context = Context> = (
+  ctx: C,
+  next: () => Promise<void>
+) => any;
+
+export class KeyboardBuilder {
+  resize(resize?: boolean): this;
+  persistent(persistent?: boolean): this;
+  oneTime(oneTime?: boolean): this;
+  placeholder(placeholder: string): this;
+  selectiveTarget(selective?: boolean): this;
+  toJSON(): object;
+}
+
+export class Markup {
+  static keyboard(buttons: any[], options?: any): KeyboardBuilder;
+  static inlineKeyboard(buttons: any[]): { inline_keyboard: any[][] };
+  static removeKeyboard(selective?: boolean): { remove_keyboard: true; selective: boolean };
+  static forceReply(selective?: boolean, placeholder?: string): { force_reply: true; selective: boolean; input_field_placeholder?: string };
+  static button: {
+    text(text: string): object;
+    callback(text: string, data: string): object;
+    url(text: string, url: string): object;
+    webApp(text: string, url: string): object;
+    contactRequest(text: string): object;
+    locationRequest(text: string): object;
+    pollRequest(text: string, type?: string): object;
+    switchToChat(text: string, query?: string): object;
+    switchToCurrentChat(text: string, query?: string): object;
+    login(text: string, url: string, options?: object): object;
+    pay(text?: string): object;
+    copyText(text: string, copyText: string): object;
+    requestUsers(text: string, requestId: number, options?: object): object;
+    requestChat(text: string, requestId: number, chatIsChannel?: boolean, options?: object): object;
+    switchInlineQueryChosenChat(text: string, query?: string, options?: object): object;
+    game(text?: string): object;
+    disabled(text: string): object;
+  };
+}
+
+export interface SceneContextScene {
+  session: any;
+  current: any;
+  state: any;
+  enter(sceneId: string, initialState?: object): Promise<void>;
+  reenter(): Promise<void>;
+  leave(): Promise<void>;
+}
+
+export interface SceneContextWizard {
+  cursor: number;
+  state: any;
+  selectStep(index: number): void;
+  next(): void;
+  back(): void;
+}
+
+export class Context {
+  update: Update;
+  telegram: Telegram;
+  api: Telegram;
+  botInfo: User | null;
+  state: Record<string, any>;
+  session?: any;
+  scene?: SceneContextScene;
+  wizard?: SceneContextWizard;
+  i18n?: { locale: string; t(key: string, params?: Record<string, any>): string };
+  match: RegExpMatchArray | string[] | null;
+  command: string | null;
+  payload: string | null;
+  matchedEntities?: any[];
+
+  constructor(update: Update, telegram: Telegram, botInfo?: User | null);
+
+  get updateType(): string;
+  get message(): Message | undefined;
+  get editedMessage(): Message | undefined;
+  get channelPost(): Message | undefined;
+  get editedChannelPost(): Message | undefined;
+  get businessConnection(): any | undefined;
+  get businessMessage(): Message | undefined;
+  get editedBusinessMessage(): Message | undefined;
+  get deletedBusinessMessages(): any | undefined;
+  get messageReaction(): any | undefined;
+  get messageReactionCount(): any | undefined;
+  get purchasedPaidMedia(): any | undefined;
+  get chatBoost(): any | undefined;
+  get removedChatBoost(): any | undefined;
+  get paidMessagePriceChanged(): any | undefined;
+  get stoppedMessageGeneration(): any | undefined;
+  get communityChatJoined(): any | undefined;
+  get callbackQuery(): any | undefined;
+  get inlineQuery(): any | undefined;
+  get chosenInlineResult(): any | undefined;
+  get shippingQuery(): any | undefined;
+  get preCheckoutQuery(): any | undefined;
+  get poll(): any | undefined;
+  get pollAnswer(): any | undefined;
+  get msg(): any;
+  get quoted(): any;
+  serialize(): any;
+  get from(): User | undefined;
+  get senderChat(): Chat | undefined;
+  get chat(): Chat | undefined;
+  get isForum(): boolean;
+  get chatId(): number | string | null;
+  get userId(): number | null;
+  get topicId(): number | null;
+  get messageThreadId(): number | null;
+  get text(): string | null;
+  get entities(): any[];
+
+  t(key: string, params?: Record<string, any>): string;
+  prompt(question: string | object, options?: { timeoutMs?: number; cancelOnCommand?: boolean }): Promise<Context>;
+  getMe(): Promise<User>;
+  getManagedBotAccessSettings(userId?: number): Promise<any>;
+  setManagedBotAccessSettings(settings: object, userId?: number): Promise<boolean>;
+
+  reply(text: string, extra?: object): Promise<Message>;
+  replyWithHTML(html: string, extra?: object): Promise<Message>;
+  replyWithMarkdown(markdown: string, extra?: object): Promise<Message>;
+  replyWithPhoto(photo: any, extra?: object): Promise<Message>;
+  replyWithAudio(audio: any, extra?: object): Promise<Message>;
+  replyWithDocument(document: any, extra?: object): Promise<Message>;
+  replyWithVideo(video: any, extra?: object): Promise<Message>;
+  replyWithAnimation(animation: any, extra?: object): Promise<Message>;
+  replyWithVoice(voice: any, extra?: object): Promise<Message>;
+  replyWithVideoNote(videoNote: any, extra?: object): Promise<Message>;
+  replyWithMediaGroup(media: any[], extra?: object): Promise<Message[]>;
+  replyWithLocation(latitude: number, longitude: number, extra?: object): Promise<Message>;
+  replyWithVenue(latitude: number, longitude: number, title: string, address: string, extra?: object): Promise<Message>;
+  replyWithContact(phoneNumber: string, firstName: string, extra?: object): Promise<Message>;
+  replyWithPoll(question: string, options: string[], extra?: object): Promise<Message>;
+  replyWithDice(extra?: object): Promise<Message>;
+  replyWithChatAction(action: string, extra?: object): Promise<boolean>;
+  replyWithInvoice(title: string, description: string, payload: string, currency: string, prices: Array<{label: string; amount: number}>, extra?: object): Promise<Message>;
+  replyWithPaidMedia(starCount: number, media: any[], extra?: object): Promise<Message>;
+  replyWithSticker(sticker: any, extra?: object): Promise<Message>;
+  replyWithGame(gameShortName: string, extra?: object): Promise<Message>;
+  createForumTopic(name: string, extra?: object): Promise<any>;
+  editForumTopic(messageThreadId?: number, extra?: object): Promise<boolean>;
+  closeForumTopic(messageThreadId?: number): Promise<boolean>;
+  reopenForumTopic(messageThreadId?: number): Promise<boolean>;
+  deleteForumTopic(messageThreadId?: number): Promise<boolean>;
+  unpinAllForumTopicMessages(messageThreadId?: number): Promise<boolean>;
+  sendGift(giftId: string, extra?: object): Promise<boolean>;
+  verifyUser(customDescription?: string): Promise<boolean>;
+  verifyChat(customDescription?: string): Promise<boolean>;
+  getUserChatBoosts(userId?: number): Promise<any>;
+  getBusinessConnection(): Promise<any>;
+  replyWithRichMessage(richMessage: any, extra?: object): Promise<Message>;
+  editRichMessageText(richMessage: any, extra?: object): Promise<Message | boolean>;
+  editRichMessageCaption(caption: string, extra?: object): Promise<Message | boolean>;
+  sendEphemeralMessage(text: string, ephemeralParameters: object, extra?: object): Promise<Message>;
+  getUserPersonalChatMessages(userId?: number, extra?: object): Promise<any>;
+  sendMessageDraft(text: string, extra?: object): Promise<boolean>;
+  sendRichMessageDraft(draft: any, extra?: object): Promise<boolean>;
+  react(emoji: string | any[]): Promise<boolean>;
+  answerCallbackQuery(text?: string, options?: object): Promise<boolean>;
+  answerInlineQuery(results: any[], options?: object): Promise<boolean>;
+  editMessageText(text: string, extra?: object): Promise<Message | boolean>;
+  editMessageCaption(caption: string, extra?: object): Promise<Message | boolean>;
+  editMessageMedia(media: object, extra?: object): Promise<Message | boolean>;
+  editMessageReplyMarkup(replyMarkup: object, extra?: object): Promise<Message | boolean>;
+  deleteMessage(messageId?: number): Promise<boolean>;
+  forwardMessage(toChatId: number | string, extra?: object): Promise<Message>;
+  copyMessage(toChatId: number | string, extra?: object): Promise<any>;
+  pinChatMessage(messageId?: number, extra?: object): Promise<boolean>;
+  unpinChatMessage(messageId?: number): Promise<boolean>;
+  unpinAllChatMessages(): Promise<boolean>;
+  leaveChat(): Promise<boolean>;
+  getChat(): Promise<Chat>;
+  getChatAdministrators(): Promise<any[]>;
+  getChatMember(userId?: number): Promise<any>;
+  banChatMember(userId: number, extra?: object): Promise<boolean>;
+  unbanChatMember(userId: number, extra?: object): Promise<boolean>;
+  restrictChatMember(userId: number, permissions: object, extra?: object): Promise<boolean>;
+  promoteChatMember(userId: number, rights?: object): Promise<boolean>;
+}
+
+export class Composer<C extends Context = Context> {
+  use(...middlewares: Middleware<C>[]): this;
+  on(updateTypes: string | string[], ...middlewares: Middleware<C>[]): this;
+  command(commands: string | RegExp | (string | RegExp)[], ...middlewares: Middleware<C>[]): this;
+  hears(triggers: string | RegExp | Function | (string | RegExp)[], ...middlewares: Middleware<C>[]): this;
+  action(triggers: string | RegExp | Function | (string | RegExp)[], ...middlewares: Middleware<C>[]): this;
+  inlineQuery(triggers: string | RegExp | Function | (string | RegExp)[], ...middlewares: Middleware<C>[]): this;
+  chatType(types: string | string[], ...middlewares: Middleware<C>[]): this;
+  business(...middlewares: Middleware<C>[]): this;
+  reaction(...middlewares: Middleware<C>[]): this;
+  boost(...middlewares: Middleware<C>[]): this;
+  forumTopic(...middlewares: Middleware<C>[]): this;
+  paidMedia(...middlewares: Middleware<C>[]): this;
+  entity(entityTypes: string | string[], ...middlewares: Middleware<C>[]): this;
+  filter(predicate: (ctx: C) => boolean | Promise<boolean>, ...middlewares: Middleware<C>[]): this;
+  drop(predicate: (ctx: C) => boolean | Promise<boolean>, ...middlewares: Middleware<C>[]): this;
+  branch(predicate: (ctx: C) => boolean | Promise<boolean>, trueMiddleware: Middleware<C>, falseMiddleware?: Middleware<C>): this;
+  middleware(): (ctx: C, next: () => Promise<void>) => Promise<any>;
+  static compose<C extends Context = Context>(middlewares: Middleware<C>[]): Middleware<C>;
+}
+
+export class BaseScene<C extends Context = Context> extends Composer<C> {
+  id: string;
+  constructor(id: string);
+  enter(...handlers: Middleware<C>[]): this;
+  leave(...handlers: Middleware<C>[]): this;
+}
+
+export class WizardScene<C extends Context = Context> extends BaseScene<C> {
+  constructor(id: string, ...steps: Middleware<C>[]);
+}
+
+export class Stage<C extends Context = Context> extends Composer<C> {
+  constructor(scenes?: BaseScene<C>[], options?: { defaultScene?: string });
+  register(scene: BaseScene<C>): this;
+}
+
+export const Scene: typeof BaseScene;
+
+export function escapeHtml(text: string): string;
+export function escapeMarkdown(text: string): string;
+
+export interface FormatHelpers {
+  escape(text: string): string;
+  bold(text: string): string;
+  italic(text: string): string;
+  underline(text: string): string;
+  strikethrough(text: string): string;
+  spoiler(text: string): string;
+  code(text: string): string;
+  pre(codeText: string, language?: string): string;
+  link(text: string, url: string): string;
+  mention(text: string, userId: number): string;
+  customEmoji(text: string, customEmojiId: string): string;
+  quote(text: string): string;
+  expandableBlockquote(text: string): string;
+}
+
+export interface FmtFunction extends FormatHelpers {
+  (strings: TemplateStringsArray, ...values: any[]): string;
+  html: FormatHelpers;
+  markdown: FormatHelpers;
+  raw(str: string): { rawHtml: string };
+}
+
+export const fmt: FmtFunction;
+export const Format: FmtFunction;
+export const html: FormatHelpers;
+export const markdown: FormatHelpers;
+
+export class RichMessageBuilder {
+  constructor(initialText?: string);
+  parseMode(mode: string): this;
+  text(text: string): this;
+  header(text: string, emoji?: string): this;
+  paragraph(text: string): this;
+  bold(text: string): this;
+  italic(text: string): this;
+  underline(text: string): this;
+  strikethrough(text: string): this;
+  code(codeText: string, language?: string): this;
+  quote(text: string, expandable?: boolean): this;
+  expandableQuote(text: string): this;
+  spoiler(text: string): this;
+  link(text: string, url: string): this;
+  mention(text: string, userId: number | string): this;
+  list(items: string[], bullet?: string): this;
+  numberedList(items: string[]): this;
+  badge(label: string, value: string | number, icon?: string): this;
+  divider(): this;
+  photo(url: string, caption?: string): this;
+  ephemeral(lifetimeSecondsOrParams?: number | object): this;
+  draftId(draftId?: number): this;
+  asDraft(): this;
+  button(buttons: object | object[]): this;
+  row(...buttons: object[]): this;
+  callback(text: string, data: string): this;
+  url(text: string, url: string): this;
+  disabled(text: string): this;
+  webApp(text: string, webAppUrl: string): this;
+  copyText(text: string, textToCopy: string): this;
+  keyboard(matrix: object[][]): this;
+  replyMarkup(markup: object): this;
+  extra(extra: object): this;
+  compileHtml(): string;
+  compile(): object;
+  build(): object;
+  toJSON(): object;
+  send(ctx: Context, chatId?: number | string, extra?: object): Promise<Message>;
+  sendDraft(ctx: Context, chatId?: number | string, extra?: object): Promise<boolean>;
+  edit(ctx: Context, messageId?: number, extra?: object): Promise<Message | boolean>;
+
+  static create(initialText?: string): RichMessageBuilder;
+  static card(title: string, description?: string, buttons?: object[]): RichMessageBuilder;
+  static draft(text: string, draftId?: number): RichMessageBuilder;
+  static ephemeral(text: string, lifetimeSeconds?: number): RichMessageBuilder;
+}
+
+export const RichMessage: typeof RichMessageBuilder;
+
+export class Telegram {
+  token: string;
+  apiRoot: string;
+  testEnv: boolean;
+  timeout: number;
+
+  constructor(token: string, options?: { apiRoot?: string; testEnv?: boolean; timeout?: number });
+  call(method: string, payload?: object, options?: object): Promise<any>;
+  getMe(): Promise<User>;
+  sendMessage(chatId: number | string, text: string, extra?: object): Promise<Message>;
+  sendPhoto(chatId: number | string, photo: any, extra?: object): Promise<Message>;
+  sendAudio(chatId: number | string, audio: any, extra?: object): Promise<Message>;
+  sendDocument(chatId: number | string, document: any, extra?: object): Promise<Message>;
+  sendVideo(chatId: number | string, video: any, extra?: object): Promise<Message>;
+  sendAnimation(chatId: number | string, animation: any, extra?: object): Promise<Message>;
+  sendVoice(chatId: number | string, voice: any, extra?: object): Promise<Message>;
+  sendLocation(chatId: number | string, latitude: number, longitude: number, extra?: object): Promise<Message>;
+  sendPoll(chatId: number | string, question: string, options: string[], extra?: object): Promise<Message>;
+  deleteMessage(chatId: number | string, messageId: number): Promise<boolean>;
+  getUpdates(offset?: number, limit?: number, timeout?: number, allowedUpdates?: string[]): Promise<Update[]>;
+  sendRichMessage(chatId: number | string, richMessage: any, extra?: object): Promise<Message>;
+  sendRichMessageDraft(chatId: number | string, draft: any, extra?: object): Promise<boolean>;
+  editRichMessageText(chatId: number | string, messageId: number, richMessage: any, extra?: object): Promise<Message | boolean>;
+  editRichMessageCaption(chatId: number | string, messageId: number, caption: string, extra?: object): Promise<Message | boolean>;
+  sendEphemeralMessage(chatId: number | string, text: string, ephemeralParameters: object, extra?: object): Promise<Message>;
+  editEphemeralMessageText(chatId: number | string, messageId: number, text: string, extra?: object): Promise<Message | boolean>;
+  editEphemeralMessageMedia(chatId: number | string, messageId: number, media: object, extra?: object): Promise<Message | boolean>;
+  editEphemeralMessageCaption(chatId: number | string, messageId: number, caption: string, extra?: object): Promise<Message | boolean>;
+  deleteEphemeralMessage(chatId: number | string, messageId: number): Promise<boolean>;
+  getManagedBotAccessSettings(userId: number, extra?: object): Promise<any>;
+  setManagedBotAccessSettings(userId: number, settings?: object, extra?: object): Promise<boolean>;
+  getUserPersonalChatMessages(userId: number, extra?: object): Promise<any>;
+  sendMessageDraft(chatId: number | string, text: string, extra?: object): Promise<boolean>;
+  setWebhook(url: string, extra?: object): Promise<boolean>;
+  deleteWebhook(extra?: object): Promise<boolean>;
+  getWebhookInfo(): Promise<any>;
+  [key: string]: any;
+}
+
+export class Telegix extends Composer {
+  token: string;
+  telegram: Telegram;
+  api: Telegram;
+  botInfo: User | null;
+
+  constructor(token: string, options?: object);
+  catch(handler: (err: Error, ctx?: Context) => void): this;
+  handleUpdate(update: Update): Promise<void>;
+  startPolling(options?: object): Promise<void>;
+  stop(reason?: string): Promise<void>;
+  launch(options?: { polling?: boolean | object; webhook?: object; dropPendingUpdates?: boolean }): Promise<User>;
+  webhookCallback(path?: string, options?: object): (req: any, res: any, next?: Function) => Promise<void>;
+}
+
+export class MemorySessionStore {
+  constructor(ttl?: number);
+  get(key: string): Promise<any>;
+  set(key: string, value: any): Promise<void>;
+  delete(key: string): Promise<void>;
+  clear(): Promise<void>;
+}
+
+export class FileSessionStore {
+  constructor(filePath?: string, ttl?: number);
+  get(key: string): Promise<any>;
+  set(key: string, value: any): Promise<void>;
+  delete(key: string): Promise<void>;
+  clear(): Promise<void>;
+}
+
+export class I18n {
+  defaultLocale: string;
+  translations: Record<string, any>;
+  constructor(options?: {
+    defaultLocale?: string;
+    translations?: Record<string, any>;
+    localeFn?: (ctx: Context) => string;
+    useSession?: boolean;
+  });
+  addTranslation(locale: string, dict: Record<string, any>): this;
+  addTranslations(translations: Record<string, Record<string, any>>): this;
+  t(locale: string, key: string, params?: Record<string, any>): string;
+  middleware(): Middleware;
+}
+
+export class RateLimiter {
+  constructor(options?: { windowMs?: number; limit?: number; keyFn?: (ctx: Context) => string | number; handler?: Middleware });
+  middleware(): Middleware;
+}
+
+export function rateLimit(options?: { windowMs?: number; limit?: number; keyFn?: (ctx: Context) => string | number; handler?: Middleware }): Middleware;
+
+export function session(options?: {
+  getSessionKey?: (ctx: Context) => string | null;
+  store?: any;
+  initial?: (ctx: Context) => any;
+  ttl?: number;
+}): Middleware;
+
+export function serializeMessage(msg: any): any;
+export function serializeUpdate(update: any): any;
+
+export class InlineQueryResultBuilder {
+  static article(id: string | number, title: string, messageText: string, options?: any): any;
+  static photo(id: string | number, photoUrl: string, options?: any): any;
+  static document(id: string | number, documentUrl: string, title: string, options?: any): any;
+}
+
+export function paginateInlineQuery(ctx: Context, items: any[], formatterFn: (item: any, index: number) => any, options?: any): Promise<boolean>;
+
+export function albumMiddleware(options?: { windowMs?: number }): Middleware;
+
+export function validateWebAppInitData(initDataStr: string, botToken: string, options?: { maxAgeSeconds?: number }): any;
+
+export function promptMiddleware(): Middleware;
+
+export function escapeMarkdownV2(str: string): string;
+export const mdv2: {
+  escape(str: string): string;
+  bold(text: string): string;
+  italic(text: string): string;
+  underline(text: string): string;
+  strikethrough(text: string): string;
+  spoiler(text: string): string;
+  code(text: string): string;
+  pre(text: string, language?: string): string;
+  link(text: string, url: string): string;
+};
+
+export function inlineDebounceMiddleware(options?: { windowMs?: number; cacheTtlMs?: number }): Middleware;
+export function chatActionMiddleware(action?: string, options?: { intervalMs?: number }): Middleware;
+
+export class InvoiceBuilder {
+  constructor(title: string, description: string, payload: string, currency?: string, prices?: any[]);
+  providerToken(token: string): this;
+  addPrice(label: string, amount: number): this;
+  maxTipAmount(amount: number): this;
+  suggestedTipAmounts(amounts: number[]): this;
+  photo(url: string, width?: number, height?: number, size?: number): this;
+  need(options: { name?: boolean; phoneNumber?: boolean; email?: boolean; shippingAddress?: boolean }): this;
+  send(ctx: Context, chatId?: number | string): Promise<any>;
+  build(): any;
+}
+
+export function answerShippingQuery(ctx: Context, ok: boolean, options?: any): Promise<any>;
+export function answerPreCheckoutQuery(ctx: Context, ok: boolean, options?: any): Promise<any>;
+
+export class TelegixManager {
+  constructor();
+  add(name: string, tokenOrOptions: string | any): Telegix;
+  get(name: string): Telegix | undefined;
+  remove(name: string): void;
+  launchAll(options?: any): Promise<any>;
+  stopAll(): void;
+}
+
+export class TelegixError extends Error {}
+export class TelegramError extends TelegixError {
+  errorCode: number;
+  description: string;
+  parameters: any;
+  retryAfter?: number;
+  migrateToChatId?: number;
+}
+export class NetworkError extends TelegixError {}
+export class PollingError extends TelegixError {}
+
+export default Telegix;

package/index.js

@@ -0,0 +1,38 @@
+/**
+ * Telegix - Lightweight Telegram Bot API Framework
+ * @author KazeDevID
+ * @license MIT
+ */
+
+export { Telegix } from './lib/telegix.js';
+export { Telegram, normalizeTelegramPayload } from './lib/api.js';
+export { Context } from './lib/context.js';
+export { Composer, compose } from './lib/composer.js';
+export { Markup, KeyboardBuilder } from './lib/markup.js';
+export { session, MemorySessionStore, FileSessionStore } from './lib/session.js';
+export { Polling } from './lib/polling.js';
+export { createWebhookCallback } from './lib/webhook.js';
+export { fmt, Format, escapeHtml, escapeMarkdown, html, markdown } from './lib/format.js';
+export { RichMessage, RichMessageBuilder } from './lib/rich.js';
+export { Scene, BaseScene, WizardScene, Stage } from './lib/scenes.js';
+export { I18n } from './lib/i18n.js';
+export { RateLimiter, rateLimit } from './lib/ratelimit.js';
+export { serializeMessage, serializeUpdate } from './lib/serialize.js';
+export { InlineQueryResultBuilder, paginateInlineQuery } from './lib/inline.js';
+export { albumMiddleware } from './lib/album.js';
+export { validateWebAppInitData } from './lib/webapp.js';
+export { promptMiddleware } from './lib/prompt.js';
+export { escapeMarkdownV2, mdv2 } from './lib/markdownv2.js';
+export { inlineDebounceMiddleware } from './lib/inline-debounce.js';
+export { chatActionMiddleware } from './lib/chataction.js';
+export { InvoiceBuilder, answerShippingQuery, answerPreCheckoutQuery } from './lib/payment.js';
+export { TelegixManager } from './lib/cluster.js';
+export {
+  TelegixError,
+  TelegramError,
+  NetworkError,
+  PollingError,
+} from './lib/errors.js';
+
+import { Telegix } from './lib/telegix.js';
+export default Telegix;

package/lib/album.js

@@ -0,0 +1,57 @@
+/**
+ * Telegix - Media Group (Album) Collector Middleware
+ * Automatically batches multiple photos/videos sent together as an album into ctx.album
+ */
+
+export function albumMiddleware(options = {}) {
+  const windowMs = options.windowMs || 400;
+  const pendingAlbums = new Map();
+
+  return async (ctx, next) => {
+    const msg = ctx.msg || ctx.message;
+    const mediaGroupId = msg?.raw?.media_group_id || msg?.media_group_id;
+
+    if (!mediaGroupId) {
+      return next();
+    }
+
+    if (pendingAlbums.has(mediaGroupId)) {
+      const albumEntry = pendingAlbums.get(mediaGroupId);
+      albumEntry.messages.push(msg);
+      albumEntry.contexts.push(ctx);
+      return;
+    }
+
+    const albumEntry = {
+      messages: [msg],
+      contexts: [ctx],
+      timer: null,
+    };
+
+    return new Promise((resolve) => {
+      albumEntry.timer = setTimeout(async () => {
+        pendingAlbums.delete(mediaGroupId);
+
+        const albumData = {
+          mediaGroupId,
+          messages: albumEntry.messages,
+          count: albumEntry.messages.length,
+        };
+
+        for (const c of albumEntry.contexts) {
+          c.album = albumData;
+        }
+
+        try {
+          await next();
+          resolve();
+        } catch (err) {
+          resolve();
+          throw err;
+        }
+      }, windowMs);
+
+      pendingAlbums.set(mediaGroupId, albumEntry);
+    });
+  };
+}