@xbibzlibrary/telebibz 3.1.1 → 3.1.3

package/index.d.ts

@@ -1,106 +1,310 @@
-// index.d.ts — tipe ringkas untuk autocompletion editor (autocorrect).
-// v3: tipe longgar (JS-first) — parity grammY.
-type Context = any; type Bot = any;
+// Public TypeScript surface for @xbibzlibrary/telebibz.
+import type { ApiMethods, Opts } from './types/telegram-bot-api/methods.js';
+import type { InputRichBlock, InputRichMessage, InputRichMessageMedia } from './types/telegram-bot-api/rich.js';
+export * as TelegramTypes from './types/telegram-bot-api/mod.js';
+export type * from './types/telegram-bot-api/rich.js';
 
-declare module '@xbibzlibrary/telebibz' {
-  type Color = 'danger' | 'success' | 'primary';
-  type Handler = (ctx: Context) => unknown;
+export type TelegramFileInput = string | File;
+export type TelegramMethodName = keyof ApiMethods<TelegramFileInput>;
+export type TelegramApiMethods = ApiMethods<TelegramFileInput>;
+export type TelegramApiPayloads = Opts<TelegramFileInput>;
+export type TelegramMethodArguments<M extends TelegramMethodName> = Parameters<ApiMethods<TelegramFileInput>[M]>;
+export type TelegramMethodPayload<M extends TelegramMethodName> = Opts<TelegramFileInput>[M];
+export type TelegramMethodResult<M extends TelegramMethodName> = ReturnType<ApiMethods<TelegramFileInput>[M]>;
+export const TELEGRAM_API_METHODS: readonly TelegramMethodName[];
 
-  type WizardMode = 'send' | 'edit' | 'delete';
-  type WizardButton = string | { text: string; value?: unknown };
-  interface WizardStep {
-    key: string;
-    ask: string | ((ctx: Context) => string | Promise<string>);
-    parse?: (text: string, ctx: Context) => unknown | Promise<unknown>;
-    validate?: (value: unknown, ctx: Context) => string | null | Promise<string | null>;
-    opts?: Record<string, unknown>;
-    /** Tombol pilihan: ['A','B'] | [{text,value}] | baris eksplisit [['A'],['B','C']]. */
-    buttons?: Array<WizardButton | WizardButton[]>;
-    /** true → tombol inline (callback), default reply keyboard. */
-    inline?: boolean;
-    /** true/string → tolak ketikan bebas, wajib pilih tombol. */
-    onlyButtons?: boolean | string;
-    /** Override mode tampilan per langkah. */
-    mode?: WizardMode;
-    /** Reply keyboard sekali pakai. */
-    oneTime?: boolean;
-  }
-  interface WizardDef {
-    steps: WizardStep[];
-    done: (answers: Record<string, unknown>, ctx: Context) => unknown;
-    cancelWords?: string[];
-    onCancel?: (ctx: Context) => unknown;
-    /** 'send' (default) | 'edit' satu pesan | 'delete' tanya-hapus per langkah. */
-    mode?: WizardMode;
-    /** Hapus pesan tanya terakhir saat wizard selesai (default: true bila mode 'delete'). */
-    cleanup?: boolean;
-    /** Singkirkan reply keyboard saat selesai (default: true bila tombol reply pernah dipakai). */
-    removeKeyboard?: boolean;
-  }
+export interface ApiClient {
+  readonly token: string;
+  config: { use(transformer: (prev: (method: string, payload?: any) => Promise<any>, method: string, payload?: any) => any): ApiClient['config'] };
+  callApi<M extends TelegramMethodName>(method: M, ...args: TelegramMethodArguments<M>): Promise<TelegramMethodResult<M>>;
+  raw<M extends TelegramMethodName>(method: M, ...args: TelegramMethodArguments<M>): Promise<TelegramMethodResult<M>>;
+  sendRichMessage(payload: TelegramMethodPayload<'sendRichMessage'>): Promise<TelegramMethodResult<'sendRichMessage'>>;
+  sendLivePhoto(payload: TelegramMethodPayload<'sendLivePhoto'>): Promise<TelegramMethodResult<'sendLivePhoto'>>;
+  sendMessageDraft(payload: TelegramMethodPayload<'sendMessageDraft'>): Promise<TelegramMethodResult<'sendMessageDraft'>>;
+  sendRichMessageDraft(payload: TelegramMethodPayload<'sendRichMessageDraft'>): Promise<TelegramMethodResult<'sendRichMessageDraft'>>;
+  answerGuestQuery(payload: TelegramMethodPayload<'answerGuestQuery'>): Promise<TelegramMethodResult<'answerGuestQuery'>>;
+  editEphemeralMessageText(payload: TelegramMethodPayload<'editEphemeralMessageText'>): Promise<TelegramMethodResult<'editEphemeralMessageText'>>;
+  editEphemeralMessageMedia(payload: TelegramMethodPayload<'editEphemeralMessageMedia'>): Promise<TelegramMethodResult<'editEphemeralMessageMedia'>>;
+  editEphemeralMessageCaption(payload: TelegramMethodPayload<'editEphemeralMessageCaption'>): Promise<TelegramMethodResult<'editEphemeralMessageCaption'>>;
+  editEphemeralMessageReplyMarkup(payload: TelegramMethodPayload<'editEphemeralMessageReplyMarkup'>): Promise<TelegramMethodResult<'editEphemeralMessageReplyMarkup'>>;
+  deleteEphemeralMessage(payload: TelegramMethodPayload<'deleteEphemeralMessage'>): Promise<TelegramMethodResult<'deleteEphemeralMessage'>>;
+  [method: string]: any;
+}
 
-  interface TeleBibzOpts {
-    allowedUpdates?: string[];
-    onError?: (err: unknown, ctx?: Context) => unknown;
-    silent?: boolean;
-    dropPending?: boolean;
-    session?: { initial?: () => unknown; getKey?: (ctx: Context) => string | undefined; storage?: unknown };
-    transport?: (method: string, payload?: object) => Promise<unknown>;
-  }
+export type Handler = (ctx: Context, next?: () => Promise<unknown>) => unknown;
+export type WizardMode = 'send' | 'edit' | 'delete';
+export type WizardButton = string | { text: string; value?: unknown };
+export type Color = 'danger' | 'success' | 'primary';
 
-  class TeleBibz {
-    constructor(token: string, opts?: TeleBibzOpts);
-    api: any;
-    botInfo: any;
-    use(...mw: any[]): this;
-    cmd(names: string | string[], ...mw: Handler[]): this;
-    hears(match: string | RegExp, ...mw: Handler[]): this;
-    action(trigs: string | RegExp | string[], ...mw: Handler[]): this;
-    on(filter: string | string[], ...mw: Handler[]): this;
-    start(replies: string | Handler): this;
-    wizard(id: string, def: WizardDef, bindCommand?: boolean): this;
-    wizardStart(ctx: Context, id: string): Promise<unknown>;
-    wizardActive(ctx: Context): boolean;
-    wizardCancel(ctx: Context): Promise<boolean>;
-    wizardEdit(ctx: Context, text: string, extra?: object): Promise<unknown>;
-    wizardDelete(ctx: Context): Promise<boolean>;
-    broadcast(ids: Array<number | string>, pesan: any, opts?: { delay?: number }): Promise<{ terkirim: number; gagal: number; errors: Array<{ chatId: any; pesan: string }> }>;
-    launch(opts?: Record<string, unknown>): Promise<this>;
-    handleUpdate(update: any): Promise<void>;
-    webhook(...args: any[]): any;
-    stop(): Promise<void>;
-  }
+export interface WizardStep {
+  key: string;
+  ask: string | ((ctx: Context) => string | Promise<string>);
+  parse?: (text: unknown, ctx: Context) => unknown | Promise<unknown>;
+  validate?: (value: unknown, ctx: Context) => string | null | Promise<string | null>;
+  opts?: Record<string, unknown>;
+  buttons?: Array<WizardButton | WizardButton[]>;
+  inline?: boolean;
+  onlyButtons?: boolean | string;
+  mode?: WizardMode;
+  oneTime?: boolean;
+}
+export interface WizardDef {
+  steps: WizardStep[];
+  done: (answers: Record<string, unknown>, ctx: Context) => unknown;
+  cancelWords?: string[];
+  onCancel?: (ctx: Context) => unknown;
+  mode?: WizardMode;
+  cleanup?: boolean;
+  removeKeyboard?: boolean;
+}
+export interface SessionOptions {
+  initial?: () => Record<string, unknown>;
+  getKey?: (ctx: Context) => string | undefined;
+  storage?: {
+    read(key: string): unknown | Promise<unknown>;
+    write(key: string, value: Record<string, unknown>): unknown | Promise<unknown>;
+    delete(key: string): unknown | Promise<unknown>;
+  } | Map<string, Record<string, unknown>>;
+}
+export interface TeleBibzOptions {
+  allowedUpdates?: string[];
+  onError?: (err: unknown, ctx?: Context) => unknown;
+  silent?: boolean;
+  dropPending?: boolean;
+  session?: SessionOptions;
+  transport?: (method: string, payload?: Record<string, unknown>) => Promise<unknown>;
+  apiRoot?: string;
+  proxy?: string;
+  timeoutMs?: number;
+  headers?: Record<string, string>;
+}
 
-  function btn(text: string, callbackData: string | number, style?: Color, iconId?: string): any;
-  function url(text: string, link: string, style?: Color, iconId?: string): any;
-  function webApp(text: string, link: string, iconId?: string): any;
-  function copy(text: string, value: string, iconId?: string): any;
-  function kb(rows: any[][]): { reply_markup: { inline_keyboard: any[][] } };
-  namespace kb {
-    function markup(rows: any[][]): { inline_keyboard: any[][] };
-    function confirm(yesData: string, noData: string, labelYes?: string, labelNo?: string): any;
-  }
+export class Context {
+  constructor(update: any, api: any, me?: any);
+  update: any;
+  api: ApiClient;
+  me?: any;
+  msg?: any;
+  chat?: any;
+  from?: any;
+  chatId?: number | string;
+  msgId?: number;
+  guestQueryId?: string;
+  session: Record<string, any>;
+  match?: string;
+  reply(text: string, extra?: object): Promise<any>;
+  replyWithRichMessage(content: InputRichMessage<TelegramFileInput>, extra?: object): Promise<any>;
+  replyWithLivePhoto(livePhoto: TelegramFileInput, photo: TelegramFileInput, extra?: object): Promise<any>;
+  replyEphemeral(text: string, receiverUserId: number, extra?: object): Promise<any>;
+  sendMessageDraft(draftId: number, text: string, extra?: object): Promise<any>;
+  sendRichMessageDraft(draftId: number, content: TelegramMethodPayload<'sendRichMessageDraft'>['rich_message'], extra?: object): Promise<any>;
+  replyWithHTML(text: string, extra?: object): Promise<any>;
+  replyWithMarkdown(text: string, extra?: object): Promise<any>;
+  replyWithPhoto(photo: any, extra?: object): Promise<any>;
+  replyWithVideo(video: any, extra?: object): Promise<any>;
+  replyWithAudio(audio: any, extra?: object): Promise<any>;
+  replyWithDocument(document: any, extra?: object): Promise<any>;
+  replyWithAnimation(animation: any, extra?: object): Promise<any>;
+  replyWithVoice(voice: any, extra?: object): Promise<any>;
+  replyWithVideoNote(videoNote: any, extra?: object): Promise<any>;
+  replyWithSticker(sticker: any, extra?: object): Promise<any>;
+  replyWithMediaGroup(media: any[], extra?: object): Promise<any>;
+  replyWithLocation(latitude: number, longitude: number, extra?: object): Promise<any>;
+  replyWithVenue(latitude: number, longitude: number, title: string, address: string, extra?: object): Promise<any>;
+  replyWithContact(phone: string, firstName: string, extra?: object): Promise<any>;
+  replyWithPoll(question: string, options: any[], extra?: object): Promise<any>;
+  replyWithDice(emoji?: string, extra?: object): Promise<any>;
+  replyWithInvoice(title: string, description: string, payload: string, currency: string, prices: any[], extra?: object): Promise<any>;
+  replyWithChatAction(action?: string, extra?: object): Promise<any>;
+  forwardMessage(to: number | string, from?: number | string, messageId?: number, extra?: object): Promise<any>;
+  copyMessage(to: number | string, from?: number | string, messageId?: number, extra?: object): Promise<any>;
+  editMessageText(text: string, extra?: object): Promise<any>;
+  editRichMessage(content: InputRichMessage<TelegramFileInput>, extra?: object): Promise<any>;
+  editEphemeralMessageText(receiverUserId: number, ephemeralMessageId: number, text: string, extra?: object): Promise<any>;
+  editEphemeralRichMessage(receiverUserId: number, ephemeralMessageId: number, content: InputRichMessage<TelegramFileInput>, extra?: object): Promise<any>;
+  editEphemeralMessageMedia(receiverUserId: number, ephemeralMessageId: number, media: any, extra?: object): Promise<any>;
+  editEphemeralMessageCaption(receiverUserId: number, ephemeralMessageId: number, extra?: object): Promise<any>;
+  editEphemeralMessageReplyMarkup(receiverUserId: number, ephemeralMessageId: number, extra?: object): Promise<any>;
+  deleteEphemeralMessage(receiverUserId: number, ephemeralMessageId: number): Promise<any>;
+  editMessageCaption(extra?: object): Promise<any>;
+  editMessageMedia(media: any, extra?: object): Promise<any>;
+  editMessageReplyMarkup(extra?: object): Promise<any>;
+  deleteMessage(chatId?: number | string, messageId?: number): Promise<any>;
+  deleteMessages(ids: number[]): Promise<any>;
+  react(emoji?: string, extra?: object): Promise<any>;
+  answerCallbackQuery(extra?: object | string): Promise<any>;
+  answerInlineQuery(results: any[], extra?: object): Promise<any>;
+  answerGuestQuery(result: any): Promise<any>;
+  getFile(): Promise<any>;
+  downloadFile(dest: string): Promise<string>;
+  [key: string]: any;
+}
 
-  const wizard: {
-    define: (id: string, def: WizardDef) => string;
-    start: (ctx: Context, id: string) => Promise<unknown>;
-    active: (ctx: Context) => boolean;
-    cancel: (ctx: Context) => Promise<boolean>;
-    editAsk: (ctx: Context, text: string, extra?: object) => Promise<unknown>;
-    deleteAsk: (ctx: Context) => Promise<boolean>;
-    KEY: string;
-  };
+export class Composer {
+  use(...middleware: any[]): this;
+  on(filter: string | string[], ...middleware: Handler[]): this;
+  hears(match: string | RegExp, ...middleware: Handler[]): this;
+  command(names: string | string[], ...middleware: Handler[]): this;
+  callbackQuery(triggers: string | RegExp | Array<string | RegExp>, ...middleware: Handler[]): this;
+  filter(predicate: (ctx: Context) => unknown, ...middleware: Handler[]): Composer;
+  drop(predicate: (ctx: Context) => unknown, ...middleware: Handler[]): Composer;
+  branch(predicate: (ctx: Context) => unknown, yes: any, no: any): this;
+  route(router: string | ((ctx: Context) => unknown), routes: Record<string, any>): this;
+  lazy(factory: (ctx: Context) => any): this;
+  fork(...middleware: Handler[]): this;
+  errorBoundary(handler: (err: BotError, next: () => Promise<unknown>) => unknown, ...middleware: Handler[]): Composer;
+  middleware(): Handler;
+  run(ctx: Context, next?: () => Promise<unknown>): Promise<unknown>;
+}
+export class BotError extends Error { error: unknown; ctx: Context; }
 
-  function humanize(err: unknown): { pesan: string; saran: string | null; method?: string; code?: number };
-  const log: { info: Function; ok: Function; warn: Function; error: Function; banner: Function };
-  const say: { html: (text: string, extra?: object) => object };
+export class TeleBibz {
+  constructor(token: string, opts?: TeleBibzOptions);
+  api: ApiClient;
+  botInfo?: any;
+  use(...middleware: Handler[]): this;
+  cmd(names: string | string[], ...middleware: Handler[]): this;
+  hears(match: string | RegExp, ...middleware: Handler[]): this;
+  action(triggers: string | RegExp | Array<string | RegExp>, ...middleware: Handler[]): this;
+  on(filter: string | string[], ...middleware: Handler[]): this;
+  start(replies: string | Handler): this;
+  wizard(id: string, def: WizardDef, bindCommand?: boolean): this;
+  wizardStart(ctx: Context, id: string): Promise<unknown>;
+  wizardActive(ctx: Context): boolean;
+  wizardCancel(ctx: Context): Promise<boolean>;
+  wizardEdit(ctx: Context, text: string, extra?: object): Promise<unknown>;
+  wizardDelete(ctx: Context): Promise<boolean>;
+  broadcast(ids: Array<number | string>, message: any, opts?: { delay?: number }): Promise<{ terkirim: number; gagal: number; errors: Array<{ chatId: any; pesan: string }> }>;
+  init(): Promise<any>;
+  launch(opts?: Record<string, unknown>): Promise<this>;
+  handleUpdate(update: any): Promise<void>;
+  webhook(opts?: { secretToken?: string; maxBodyBytes?: number }): (req: any, res: any) => Promise<void>;
+  stop(): void;
+  readonly runPromise?: Promise<void>;
+}
+export { TeleBibz as Bot };
 
-  class File { constructor(src: any, filename?: string, type?: string); src: any; filename: string; data(): Promise<Buffer>; }
-  const InputFile: typeof File;
-  const InlineKeyboard: any;
-  const Keyboard: any;
-  class ApiError extends Error { description: string; error_code?: number; method?: string; payload?: any; }
-  const Composer: any; const BotError: any; const session: any; const Api: any;
+export function session(opts?: SessionOptions): Handler;
+export function btn(text: string, callbackData: string | number, style?: Color, iconId?: string): any;
+export function url(text: string, link: string, style?: Color, iconId?: string): any;
+export function webApp(text: string, link: string, iconId?: string): any;
+export function copy(text: string, value: string, iconId?: string): any;
+export function kb(rows: any[][]): { reply_markup: { inline_keyboard: any[][] } };
+export namespace kb {
+  function markup(rows: any[][]): { inline_keyboard: any[][] };
+  function confirm(yesData: string, noData: string, labelYes?: string, labelNo?: string): any;
+}
+export class InlineKeyboard {
+  constructor(rows?: any[][]);
+  text(text: string, data: string, style?: Color, iconId?: string): this;
+  url(text: string, link: string, style?: Color, iconId?: string): this;
+  webApp(text: string, link: string, iconId?: string): this;
+  copy(text: string, value: string, iconId?: string): this;
+  row(): this;
+  build(): { reply_markup: { inline_keyboard: any[][] } };
+}
+export class Keyboard {
+  text(text: string): this;
+  requestContact(text: string): this;
+  requestLocation(text: string): this;
+  row(): this;
+  resized(value?: boolean): this;
+  oneTime(value?: boolean): this;
+  build(): any;
+}
+
+export class Menu extends Composer {
+  constructor(id: string);
+  text(label: string, handler?: Handler): this;
+  url(label: string, link: string, opts?: object): this;
+  webApp(label: string, link: string): this;
+  submenu(label: string, targetId: string): this;
+  back(label?: string, parentId?: string): this;
+  row(): this;
+  render(ctx: Context): Promise<any>;
+}
+export class MenuContainer extends Composer {
+  create(id: string): Menu;
+  get(id: string): Menu | undefined;
 }
 
-import { Menu as _M } from './lib/menus';
-export {};
+export class File {
+  constructor(src: any, filename?: string, type?: string);
+  src: any;
+  filename: string;
+  type?: string;
+  data(): Promise<Uint8Array>;
+}
+export class InputFile extends File {}
+export const InputMediaBuilder: {
+  photo(media: any, extra?: object): any;
+  video(media: any, extra?: object): any;
+  livePhoto(media: any, photo: any, extra?: object): any;
+  document(media: any, extra?: object): any;
+  audio(media: any, extra?: object): any;
+  animation(media: any, extra?: object): any;
+};
+export const InputPaidMediaBuilder: {
+  photo(media: any, extra?: object): any;
+  video(media: any, extra?: object): any;
+  livePhoto(media: any, photo: any, extra?: object): any;
+};
+export class RichMessageBuilder {
+  html(value: string): this;
+  markdown(value: string): this;
+  blocks(value?: InputRichBlock<TelegramFileInput>[]): this;
+  add(...blocks: InputRichBlock<TelegramFileInput>[]): this;
+  media(items: InputRichMessageMedia<TelegramFileInput>[]): this;
+  rtl(value?: boolean): this;
+  skipEntityDetection(value?: boolean): this;
+  build(): InputRichMessage<TelegramFileInput>;
+  buildDraft(): TelegramMethodPayload<'sendRichMessageDraft'>['rich_message'];
+}
+export const rich: {
+  html(html: string, options?: Partial<InputRichMessage<TelegramFileInput>>): InputRichMessage<TelegramFileInput>;
+  markdown(markdown: string, options?: Partial<InputRichMessage<TelegramFileInput>>): InputRichMessage<TelegramFileInput>;
+  blocks(blocks: InputRichBlock<TelegramFileInput>[], options?: Partial<InputRichMessage<TelegramFileInput>>): InputRichMessage<TelegramFileInput>;
+  draftHtml(html: string, options?: Partial<InputRichMessage<TelegramFileInput>>): TelegramMethodPayload<'sendRichMessageDraft'>['rich_message'];
+  draftMarkdown(markdown: string, options?: Partial<InputRichMessage<TelegramFileInput>>): TelegramMethodPayload<'sendRichMessageDraft'>['rich_message'];
+  draftBlocks(blocks: InputRichBlock<TelegramFileInput>[], options?: Partial<InputRichMessage<TelegramFileInput>>): TelegramMethodPayload<'sendRichMessageDraft'>['rich_message'];
+  block(type: string, props?: Record<string, unknown>): InputRichBlock<TelegramFileInput>;
+  [builder: string]: (...args: any[]) => any;
+};
+export function inputRichMessage(content: Partial<InputRichMessage<TelegramFileInput>>, options?: Partial<InputRichMessage<TelegramFileInput>>): InputRichMessage<TelegramFileInput>;
+
+export function makeApi(token: string, transport?: TeleBibzOptions['transport'], transportOpts?: TeleBibzOptions): ApiClient;
+export function createTransport(token: string, opts?: { apiRoot?: string; proxy?: string; timeoutMs?: number; headers?: Record<string, string> }): TeleBibzOptions['transport'];
+export class ApiError extends Error {
+  description: string;
+  error_code?: number;
+  method?: string;
+  payload?: any;
+  parameters: Record<string, any>;
+}
+export function autoRetry(opts?: { maxRetry?: number; baseDelayMs?: number }): Function;
+export function throttler(opts?: { perSecond?: number }): Function;
+export function limiter(opts?: { windowMs?: number; limit?: number; onExceeded?: Handler }): Handler;
+export function broadcast(api: any, ids: Array<number | string>, message: any, opts?: { delay?: number }): Promise<any>;
+export function matchInlineQuery(trigger: string | RegExp): (ctx: Context) => boolean;
+export const iq: Record<string, (...args: any[]) => any>;
+export function humanize(error: unknown): { pesan: string; saran: string | null; method?: string; code?: number | string };
+export const wizard: {
+  define(id: string, def: WizardDef): string;
+  get(id: string): WizardDef | undefined;
+  start(ctx: Context, id: string): Promise<unknown>;
+  active(ctx: Context): boolean;
+  cancel(ctx: Context): Promise<boolean>;
+  editAsk(ctx: Context, text: string, extra?: object): Promise<unknown>;
+  deleteAsk(ctx: Context): Promise<boolean>;
+  middleware(): Handler;
+  KEY: string;
+};
+export const log: {
+  info(...args: any[]): void;
+  ok(...args: any[]): void;
+  warn(...args: any[]): void;
+  error(...args: any[]): void;
+  paint(code: string, text: unknown): string;
+  banner(title: string, rows?: string[], developer?: string): void;
+};
+export const say: { html(text: string, extra?: object): object };

package/index.js

@@ -4,7 +4,9 @@
 
 const { TeleBibz } = require('./lib/telebibz');
 const { ApiError, createTransport } = require('./lib/net');
-const { File, InputFile, InputMediaBuilder } = require('./lib/file');
+const { File, InputFile, InputMediaBuilder, InputPaidMediaBuilder } = require('./lib/file');
+const { rich, RichMessageBuilder, inputRichMessage } = require('./lib/rich');
+const { TELEGRAM_API_METHODS } = require('./lib/telegram-methods');
 const { btn, url, webApp, copy, kb, InlineKeyboard, Keyboard } = require('./lib/keyboard');
 const wizard = require('./lib/wizard');
 const { humanize } = require('./lib/errors');
@@ -32,7 +34,11 @@ module.exports = {
   // percakapan
   wizard,
   // file & media
-  File, InputFile, InputMediaBuilder,
+  File, InputFile, InputMediaBuilder, InputPaidMediaBuilder,
+  // Rich Messages (Bot API 10.3)
+  rich, RichMessageBuilder, inputRichMessage,
+  // complete raw Bot API method registry (185 methods)
+  TELEGRAM_API_METHODS,
   // api & transport
   makeApi, createTransport, ApiError,
   // anti-spam & keandalan

package/lib/api.js

@@ -11,10 +11,12 @@ class ApiConfig {
 }
 
 class ApiBase {
-  constructor(token, transport) {
+  constructor(token, transport, transportOpts = {}) {
     this.token = token;
+    this.transportOpts = transportOpts;
+    this.apiRoot = (transportOpts.apiRoot || 'https://api.telegram.org').replace(/\/$/, '');
     this.config = new ApiConfig();
-    this._base = transport || createTransport(token, {});
+    this._base = transport || createTransport(token, transportOpts);
     this.raw = (method, payload = {}) => this.callApi(method, payload);
   }
 
@@ -34,6 +36,18 @@ class ApiBase {
 
   /* ---- pesan ---- */
   sendMessage(chat_id, text, extra = {}) { return this.callApi('sendMessage', { chat_id, text, ...extra }); }
+
+  // Bot API 10.x rich content, streaming drafts, guest queries and ephemeral messages.
+  sendRichMessage(payload) { return this.callApi('sendRichMessage', payload); }
+  sendLivePhoto(payload) { return this.callApi('sendLivePhoto', payload); }
+  sendMessageDraft(payload) { return this.callApi('sendMessageDraft', payload); }
+  sendRichMessageDraft(payload) { return this.callApi('sendRichMessageDraft', payload); }
+  answerGuestQuery(payload) { return this.callApi('answerGuestQuery', payload); }
+  editEphemeralMessageText(payload) { return this.callApi('editEphemeralMessageText', payload); }
+  editEphemeralMessageMedia(payload) { return this.callApi('editEphemeralMessageMedia', payload); }
+  editEphemeralMessageCaption(payload) { return this.callApi('editEphemeralMessageCaption', payload); }
+  editEphemeralMessageReplyMarkup(payload) { return this.callApi('editEphemeralMessageReplyMarkup', payload); }
+  deleteEphemeralMessage(payload) { return this.callApi('deleteEphemeralMessage', payload); }
   forwardMessage(chat_id, from_chat_id, message_id, extra = {}) { return this.callApi('forwardMessage', { chat_id, from_chat_id, message_id, ...extra }); }
   forwardMessages(chat_id, from_chat_id, message_ids, extra = {}) { return this.callApi('forwardMessages', { chat_id, from_chat_id, message_ids, ...extra }); }
   copyMessage(chat_id, from_chat_id, message_id, extra = {}) { return this.callApi('copyMessage', { chat_id, from_chat_id, message_id, ...extra }); }
@@ -71,7 +85,7 @@ class ApiBase {
     const f = await this.getFile(file_id);
     const axios = require('axios');
     const fs = require('fs');
-    const url = `https://api.telegram.org/file/bot${this.token}/${f.file_path}`;
+    const url = `${this.apiRoot}/file/bot${this.token}/${f.file_path}`;
     const res = await axios.get(url, { responseType: 'stream', ...axiosOpts });
     const out = fs.createWriteStream(dest);
     await new Promise((ok, no) => { res.data.pipe(out); out.on('finish', ok); out.on('error', no); res.data.on('error', no); });
@@ -136,13 +150,13 @@ class ApiBase {
  * Implementasi: kalau nama ada di ApiBase, pakai definisi resminya; kalau
  * tidak, fallback jadi satu-argumen-payload.
  */
-function makeApi(token, transport) {
-  const base = new ApiBase(token, transport);
+function makeApi(token, transport, transportOpts = {}) {
+  const base = new ApiBase(token, transport, transportOpts);
   return new Proxy(base, {
     get(target, prop, recv) {
       const v = Reflect.get(target, prop, recv);
       if (v !== undefined) return typeof v === 'function' ? v.bind(target) : v;
-      if (typeof prop === 'string' && /^[a-z][a-zA-Z0-9]*$/.test(prop)) {
+      if (typeof prop === 'string' && !['then', 'catch', 'finally'].includes(prop) && /^[a-z][a-zA-Z0-9]*$/.test(prop)) {
         return (payload = {}) => target.callApi(prop, payload);
       }
       return undefined;

package/lib/composer.js

@@ -8,6 +8,7 @@ const UPDATE_FIELDS = {
   message: (u) => u.message, edited_message: (u) => u.edited_message,
   channel_post: (u) => u.channel_post, edited_channel_post: (u) => u.edited_channel_post,
   business_message: (u) => u.business_message, edited_business_message: (u) => u.edited_business_message,
+  deleted_business_messages: (u) => u.deleted_business_messages, guest_message: (u) => u.guest_message,
   callback_query: (u) => u.callback_query, inline_query: (u) => u.inline_query,
   chat_join_request: (u) => u.chat_join_request, chat_member: (u) => u.chat_member,
   my_chat_member: (u) => u.my_chat_member, message_reaction: (u) => u.message_reaction,
@@ -15,6 +16,8 @@ const UPDATE_FIELDS = {
   business_connection: (u) => u.business_connection, poll: (u) => u.poll, poll_answer: (u) => u.poll_answer,
   chosen_inline_result: (u) => u.chosen_inline_result, shipping_query: (u) => u.shipping_query,
   pre_checkout_query: (u) => u.pre_checkout_query, purchased_paid_media: (u) => u.purchased_paid_media,
+  chat_boost: (u) => u.chat_boost, removed_chat_boost: (u) => u.removed_chat_boost,
+  stopped_message_generation: (u) => u.stopped_message_generation,
 };
 const MSG_PROPS = {
   text: (m) => typeof m.text === 'string', caption: (m) => typeof m.caption === 'string',
@@ -28,7 +31,6 @@ const MSG_PROPS = {
   via_bot: (m) => !!m.via_bot, reply_to_message: (m) => !!m.reply_to_message, entities: (m) => Array.isArray(m.entities),
   media: (m) => Array.isArray(m.photo) || !!m.video || !!m.document || !!m.audio,
   data: () => false, // khusus callback_query ditangani di bawah
-  successful_payment: (m) => !!m.successful_payment,
 };
 
 /** filter 'message:photo', ':text', 'callback_query': → fungsi (ctx) => boolean */
@@ -69,7 +71,12 @@ class Composer {
   on(filter, ...mw) { [].concat(filter).forEach((f) => this.stack.push({ match: compileFilter(f), fns: mw })); return this; }
   hears(re, ...mw) {
     [].concat(re).forEach((r) => this.stack.push({
-      match: (ctx) => { const m = msgOf(ctx.update); const t = m && (m.text || m.caption || ''); return !!t && r.test(t); },
+      match: (ctx) => {
+        const m = msgOf(ctx.update); const t = m && (m.text || m.caption || '');
+        if (!t) return false;
+        if (r instanceof RegExp) r.lastIndex = 0;
+        return r.test(t);
+      },
       fns: mw,
     }));
     return this;
@@ -97,7 +104,11 @@ class Composer {
       match: (ctx) => {
         const q = ctx.callback_query || ctx.update.callback_query;
         if (!q || typeof q.data !== 'string') return false;
-        return list.some((t) => t instanceof RegExp ? t.test(q.data) : String(t) === q.data);
+        return list.some((t) => {
+          if (!(t instanceof RegExp)) return String(t) === q.data;
+          t.lastIndex = 0;
+          return t.test(q.data);
+        });
       },
       fns: mw,
     });