@prajwalshete/telegram-plugin 0.0.0-stage → 0.1.0

package/dist/telegram/errors.d.ts

@@ -0,0 +1,37 @@
+/** Telegram answered with `ok: false` (or a non-JSON error body). */
+export declare class TelegramApiError extends Error {
+  readonly name = "TelegramApiError";
+  /** Bot API method name (`sendMessage`). */
+  readonly method: string;
+  /** HTTP status. */
+  readonly status: number;
+  /** `error_code` from the body (usually equals `status`). */
+  readonly errorCode: number;
+  /** Telegram's `description` text. */
+  readonly description: string;
+  /** Seconds, from `parameters.retry_after` (429). */
+  readonly retryAfter: number | undefined;
+  /** From `parameters.migrate_to_chat_id` (group became a supergroup). */
+  readonly migrateToChatId: number | undefined;
+  constructor(init: {
+    method: string;
+    status: number;
+    errorCode: number;
+    description: string;
+    retryAfter?: number | undefined;
+    migrateToChatId?: number | undefined;
+  });
+  toJSON(): Record<string, unknown>;
+}
+/** The request never got a Telegram answer: connection failure or our own timeout. */
+export declare class TelegramNetworkError extends Error {
+  readonly name = "TelegramNetworkError";
+  /** Bot API method name. */
+  readonly method: string;
+  /** `network` = connection failed, `timeout` = our timeout fired, `aborted` = the caller's signal aborted. */
+  readonly reason: "network" | "timeout" | "aborted";
+  constructor(method: string, reason: "network" | "timeout" | "aborted");
+  toJSON(): Record<string, unknown>;
+}
+/** Type guard for {@link TelegramApiError}. */
+export declare function isTelegramApiError(e: unknown): e is TelegramApiError;

package/dist/telegram/errors.js

@@ -0,0 +1,62 @@
+// src/telegram/errors.ts
+/** Telegram answered with `ok: false` (or a non-JSON error body). */
+var TelegramApiError = class extends Error {
+	name = "TelegramApiError";
+	/** Bot API method name (`sendMessage`). */
+	method;
+	/** HTTP status. */
+	status;
+	/** `error_code` from the body (usually equals `status`). */
+	errorCode;
+	/** Telegram's `description` text. */
+	description;
+	/** Seconds, from `parameters.retry_after` (429). */
+	retryAfter;
+	/** From `parameters.migrate_to_chat_id` (group became a supergroup). */
+	migrateToChatId;
+	constructor(init) {
+		super(`Telegram ${init.method} failed: ${init.errorCode} ${init.description}`);
+		this.method = init.method;
+		this.status = init.status;
+		this.errorCode = init.errorCode;
+		this.description = init.description;
+		this.retryAfter = init.retryAfter;
+		this.migrateToChatId = init.migrateToChatId;
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			method: this.method,
+			status: this.status,
+			errorCode: this.errorCode,
+			description: this.description,
+			retryAfter: this.retryAfter,
+			migrateToChatId: this.migrateToChatId
+		};
+	}
+};
+/** The request never got a Telegram answer: connection failure or our own timeout. */
+var TelegramNetworkError = class extends Error {
+	name = "TelegramNetworkError";
+	/** Bot API method name. */
+	method;
+	/** `network` = connection failed, `timeout` = our timeout fired, `aborted` = the caller's signal aborted. */
+	reason;
+	constructor(method, reason) {
+		super(`Telegram ${method} ${reason === "network" ? "network error" : reason}`);
+		this.method = method;
+		this.reason = reason;
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			method: this.method,
+			reason: this.reason
+		};
+	}
+};
+/** Type guard for {@link TelegramApiError}. */
+function isTelegramApiError(e) {
+	return e instanceof TelegramApiError;
+}
+export { TelegramApiError, TelegramNetworkError, isTelegramApiError };

package/dist/telegram/inbound.d.ts

@@ -0,0 +1,40 @@
+import { TgChat, TgMessage, TgMessageEntity, TgUpdate, TgUser } from "./update.js";
+/** Dispatcher route for an update (see {@link classifyUpdate}). */
+export type UpdateClass = "lifecycle" | "command" | "callback" | "text" | "media" | "other";
+/** Top-level update field name (`message`, `callback_query`, …), stored as `tg_update.kind`. */
+export declare function updateType(update: TgUpdate): string;
+/** True when the message is a service message about chat membership or migration. */
+export declare function isLifecycleMessage(m: TgMessage): boolean;
+/**
+ * Routes an update. Order follows docs/02 §4.1: lifecycle → command → callback → text → media → other.
+ * Edited messages are `other` so an edit never re-runs a command.
+ */
+export declare function classifyUpdate(update: TgUpdate): UpdateClass;
+/** The message an update carries (message, edited message, or the callback's message). */
+export declare function updateMessage(update: TgUpdate): TgMessage | undefined;
+/** The chat an update belongs to (message, callback message, or membership change). */
+export declare function updateChat(update: TgUpdate): TgChat | undefined;
+/** The user who caused an update (callback, message, edit, or membership change). */
+export declare function updateFrom(update: TgUpdate): TgUser | undefined;
+/** A parsed `/command` message (see {@link parseCommand}). */
+export interface ParsedCommand {
+  /** Lower-case command without `/` and without `@bot`. */
+  command: string;
+  /** Whitespace-separated arguments. */
+  args: string[];
+  /** Everything after the command, trimmed (for free-form args). */
+  argsText: string;
+  /** `@username` suffix if present (without `@`). */
+  mention: string | null;
+  /** The command is addressed to a different bot: ignore it. */
+  mentionedOther: boolean;
+}
+/**
+ * Parses `/cmd`, `/cmd args`, `/cmd@Bot args`. Returns null for non-commands. When entities are given, a
+ * `bot_command` entity must start at offset 0 (as Telegram marks it); otherwise the text shape decides.
+ */
+export declare function parseCommand(text: string | undefined, entities: readonly TgMessageEntity[] | undefined, botUsername: string | null | undefined): ParsedCommand | null;
+/** Deep-link payload of `/start <payload>`, or null when absent or not `[A-Za-z0-9_-]{1,64}`. */
+export declare function parseStartPayload(cmd: ParsedCommand | null): string | null;
+/** True when `payload` is a valid `/start` deep-link payload (`[A-Za-z0-9_-]{1,64}`). */
+export declare function isValidStartPayload(payload: string): boolean;

package/dist/telegram/inbound.js

@@ -0,0 +1,72 @@
+// src/telegram/inbound.ts
+/** Top-level update field name (`message`, `callback_query`, …), stored as `tg_update.kind`. */
+function updateType(update) {
+	for (const key of Object.keys(update)) if (key !== "update_id") return key;
+	return "unknown";
+}
+/** True when the message is a service message about chat membership or migration. */
+function isLifecycleMessage(m) {
+	return m.migrate_to_chat_id !== void 0 || m.migrate_from_chat_id !== void 0 || m.new_chat_members !== void 0 || m.left_chat_member !== void 0 || m.group_chat_created === true || m.supergroup_chat_created === true || m.forum_topic_created !== void 0;
+}
+/**
+* Routes an update. Order follows docs/02 §4.1: lifecycle → command → callback → text → media → other.
+* Edited messages are `other` so an edit never re-runs a command.
+*/
+function classifyUpdate(update) {
+	if (update.my_chat_member || update.chat_member) return "lifecycle";
+	if (update.callback_query) return "callback";
+	const m = update.message;
+	if (!m) return "other";
+	if (isLifecycleMessage(m)) return "lifecycle";
+	if (m.text !== void 0) return commandEntity(m.text, m.entities) ? "command" : "text";
+	if (m.photo !== void 0 || m.document !== void 0) return "media";
+	return "other";
+}
+/** The message an update carries (message, edited message, or the callback's message). */
+function updateMessage(update) {
+	return update.message ?? update.edited_message ?? update.callback_query?.message;
+}
+/** The chat an update belongs to (message, callback message, or membership change). */
+function updateChat(update) {
+	return updateMessage(update)?.chat ?? update.my_chat_member?.chat ?? update.chat_member?.chat;
+}
+/** The user who caused an update (callback, message, edit, or membership change). */
+function updateFrom(update) {
+	return update.callback_query?.from ?? update.message?.from ?? update.edited_message?.from ?? update.my_chat_member?.from ?? update.chat_member?.from;
+}
+const COMMAND_RE = /^\/([A-Za-z0-9_]{1,32})(?:@([A-Za-z0-9_]{3,64}))?(?=\s|$)/;
+function commandEntity(text, entities) {
+	if (entities) return entities.some((e) => e.type === "bot_command" && e.offset === 0);
+	return COMMAND_RE.test(text);
+}
+/**
+* Parses `/cmd`, `/cmd args`, `/cmd@Bot args`. Returns null for non-commands. When entities are given, a
+* `bot_command` entity must start at offset 0 (as Telegram marks it); otherwise the text shape decides.
+*/
+function parseCommand(text, entities, botUsername) {
+	if (!text || !commandEntity(text, entities)) return null;
+	const m = COMMAND_RE.exec(text);
+	if (!m?.[1]) return null;
+	const mention = m[2] ?? null;
+	const self = botUsername?.replace(/^@/, "").toLowerCase();
+	const argsText = text.slice(m[0].length).trim();
+	return {
+		command: m[1].toLowerCase(),
+		args: argsText === "" ? [] : argsText.split(/\s+/),
+		argsText,
+		mention,
+		mentionedOther: mention !== null && mention.toLowerCase() !== self
+	};
+}
+const START_PAYLOAD_RE = /^[A-Za-z0-9_-]{1,64}$/;
+/** Deep-link payload of `/start <payload>`, or null when absent or not `[A-Za-z0-9_-]{1,64}`. */
+function parseStartPayload(cmd) {
+	if (cmd?.command !== "start" || cmd.args.length !== 1) return null;
+	const payload = cmd.args[0] ?? "";
+	return START_PAYLOAD_RE.test(payload) ? payload : null;
+}
+/** True when `payload` is a valid `/start` deep-link payload (`[A-Za-z0-9_-]{1,64}`). */
+function isValidStartPayload(payload) {
+	return START_PAYLOAD_RE.test(payload);
+}
+export { classifyUpdate, isLifecycleMessage, isValidStartPayload, parseCommand, parseStartPayload, updateChat, updateFrom, updateMessage, updateType };

package/dist/telegram/index.d.ts

@@ -0,0 +1,8 @@
+import { ParsedUpdate, TgCallbackQuery, TgChat, TgChatMember, TgChatMemberUpdated, TgDocument, TgForumTopicCreated, TgMessage, TgMessageEntity, TgPhotoSize, TgUpdate, TgUser, parseUpdate } from "./update.js";
+import { AnswerCallbackQueryParams, BotCommand, BotCommandScope, BotUser, ButtonStyle, ChatAction, ChatFullInfo, ChatId, CommandScopeParams, DeleteMessageParams, DeleteWebhookParams, EditMessageReplyMarkupParams, EditMessageTextParams, ForceReply, GetUpdatesParams, InlineKeyboardButton, InlineKeyboardMarkup, InputFile, InputFileUpload, KeyboardButton, LinkPreviewOptions, MethodName, MethodResults, ParseMode, ReplyKeyboardMarkup, ReplyKeyboardRemove, ReplyMarkup, ReplyParameters, SendChatActionParams, SendDocumentParams, SendMessageParams, SendOptions, SendPhotoParams, SetMyCommandsParams, SetWebhookParams, TgFile, UpdateType, WebhookInfo } from "./types.js";
+import { BotApi, CallOptions, DEFAULT_TELEGRAM_BASE_URL, DEFAULT_TELEGRAM_TIMEOUT_MS, FetchLike, TelegramClient, TelegramClientOptions, TokenGetter, fetchTelegram } from "./client.js";
+import { ParsedCommand, UpdateClass, classifyUpdate, isLifecycleMessage, isValidStartPayload, parseCommand, parseStartPayload, updateChat, updateFrom, updateMessage, updateType } from "./inbound.js";
+import { TelegramOutcome, TelegramOutcomeKind, TelegramOutcomeReason, classifyTelegramError, settle } from "./classify.js";
+import { TelegramApiError, TelegramNetworkError, isTelegramApiError } from "./errors.js";
+import { inputFile, isInputFileUpload } from "./multipart.js";
+export { type AnswerCallbackQueryParams, BotApi, type BotCommand, type BotCommandScope, type BotUser, type ButtonStyle, CallOptions, type ChatAction, type ChatFullInfo, type ChatId, type CommandScopeParams, DEFAULT_TELEGRAM_BASE_URL, DEFAULT_TELEGRAM_TIMEOUT_MS, type DeleteMessageParams, type DeleteWebhookParams, type EditMessageReplyMarkupParams, type EditMessageTextParams, FetchLike, type ForceReply, type GetUpdatesParams, type InlineKeyboardButton, type InlineKeyboardMarkup, type InputFile, type InputFileUpload, type KeyboardButton, type LinkPreviewOptions, type MethodName, type MethodResults, type ParseMode, ParsedCommand, ParsedUpdate, type ReplyKeyboardMarkup, type ReplyKeyboardRemove, type ReplyMarkup, type ReplyParameters, type SendChatActionParams, type SendDocumentParams, type SendMessageParams, type SendOptions, type SendPhotoParams, type SetMyCommandsParams, type SetWebhookParams, TelegramApiError, TelegramClient, TelegramClientOptions, TelegramNetworkError, TelegramOutcome, TelegramOutcomeKind, TelegramOutcomeReason, TgCallbackQuery, TgChat, TgChatMember, TgChatMemberUpdated, TgDocument, type TgFile, TgForumTopicCreated, TgMessage, TgMessageEntity, TgPhotoSize, TgUpdate, TgUser, TokenGetter, UpdateClass, type UpdateType, type WebhookInfo, classifyTelegramError, classifyUpdate, fetchTelegram, inputFile, isInputFileUpload, isLifecycleMessage, isTelegramApiError, isValidStartPayload, parseCommand, parseStartPayload, parseUpdate, settle, updateChat, updateFrom, updateMessage, updateType };

package/dist/telegram/multipart.d.ts

@@ -0,0 +1,5 @@
+import { InputFileUpload } from "./types.js";
+/** Type guard: is `v` an {@link InputFileUpload} (`{ data, filename }`)? */
+export declare function isInputFileUpload(v: unknown): v is InputFileUpload;
+/** Builds an upload for `sendDocument` / `sendPhoto`. */
+export declare function inputFile(data: InputFileUpload["data"], filename: string, mime?: string): InputFileUpload;

package/dist/telegram/multipart.js

@@ -0,0 +1,47 @@
+// src/telegram/multipart.ts
+/** Type guard: is `v` an {@link InputFileUpload} (`{ data, filename }`)? */
+function isInputFileUpload(v) {
+	if (typeof v !== "object" || v === null) return false;
+	const o = v;
+	return typeof o.filename === "string" && o.data !== void 0 && o.data !== null;
+}
+/** Builds an upload for `sendDocument` / `sendPhoto`. */
+function inputFile(data, filename, mime) {
+	return mime === void 0 ? {
+		data,
+		filename
+	} : {
+		data,
+		filename,
+		mime
+	};
+}
+async function toBlob(file) {
+	const type = file.mime ?? "application/octet-stream";
+	const { data } = file;
+	if (data instanceof Blob) return file.mime && data.type !== file.mime ? new Blob([data], { type }) : data;
+	if (data instanceof ReadableStream) {
+		const buf = await new Response(data).arrayBuffer();
+		return new Blob([buf], { type });
+	}
+	if (data instanceof Uint8Array) return new Blob([data.slice()], { type });
+	return new Blob([data], { type });
+}
+/** Encodes Bot API params: JSON, or `multipart/form-data` when any param is a file upload (`contentType` null then: fetch sets the boundary). */
+async function encodeBody(params) {
+	const entries = Object.entries(params).filter(([, v]) => v !== void 0);
+	if (!entries.some(([, v]) => isInputFileUpload(v))) return {
+		body: JSON.stringify(Object.fromEntries(entries)),
+		contentType: "application/json"
+	};
+	const form = new FormData();
+	for (const [key, value] of entries) if (isInputFileUpload(value)) form.append(key, await toBlob(value), value.filename);
+	else if (typeof value === "string") form.append(key, value);
+	else if (typeof value === "number" || typeof value === "boolean") form.append(key, String(value));
+	else form.append(key, JSON.stringify(value));
+	return {
+		body: form,
+		contentType: null
+	};
+}
+export { encodeBody, inputFile, isInputFileUpload };

package/dist/telegram/types.d.ts

@@ -0,0 +1,271 @@
+import { TgChatMember, TgMessage, TgUser } from "./update.js";
+/** Telegram ids fit in 52 bits; a JS number holds them. Strings are accepted for ids stored as TEXT. */
+export type ChatId = number | string;
+/** Bot API `parse_mode`; the plugin always sends `HTML`. */
+export type ParseMode = "HTML" | "MarkdownV2";
+/** 9.4 button colours. */
+export type ButtonStyle = "danger" | "success" | "primary";
+interface ButtonBase {
+  text: string;
+  style?: ButtonStyle;
+  icon_custom_emoji_id?: string;
+  /** 10.3: shown but not pressable. */
+  disabled?: boolean;
+}
+/** Exactly one action field per button (the ones the plugin uses). */
+export type InlineKeyboardButton = ButtonBase & ({
+  callback_data: string;
+} | {
+  url: string;
+} | {
+  copy_text: {
+    text: string;
+  };
+} | {
+  switch_inline_query_current_chat: string;
+});
+/** Bot API `InlineKeyboardMarkup`. */
+export interface InlineKeyboardMarkup {
+  inline_keyboard: InlineKeyboardButton[][];
+}
+/** Bot API `KeyboardButton` (text-only subset). */
+export interface KeyboardButton {
+  text: string;
+  style?: ButtonStyle;
+}
+/** Bot API `ReplyKeyboardMarkup` (custom reply keyboard). */
+export interface ReplyKeyboardMarkup {
+  keyboard: KeyboardButton[][];
+  is_persistent?: boolean;
+  resize_keyboard?: boolean;
+  one_time_keyboard?: boolean;
+  input_field_placeholder?: string;
+  selective?: boolean;
+}
+/** Bot API `ReplyKeyboardRemove`. */
+export interface ReplyKeyboardRemove {
+  remove_keyboard: true;
+  selective?: boolean;
+}
+/** Bot API `ForceReply` (used by dialogs to ask for an answer). */
+export interface ForceReply {
+  force_reply: true;
+  input_field_placeholder?: string;
+  selective?: boolean;
+}
+/** Any `reply_markup` value. */
+export type ReplyMarkup = InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
+/** Bot API `LinkPreviewOptions`. */
+export interface LinkPreviewOptions {
+  is_disabled?: boolean;
+  url?: string;
+  prefer_small_media?: boolean;
+  prefer_large_media?: boolean;
+  show_above_text?: boolean;
+}
+/** Bot API `ReplyParameters` (reply to a message). */
+export interface ReplyParameters {
+  message_id: number;
+  chat_id?: ChatId;
+  allow_sending_without_reply?: boolean;
+}
+/** Options shared by the send methods. */
+export interface SendOptions {
+  message_thread_id?: number;
+  disable_notification?: boolean;
+  protect_content?: boolean;
+  reply_parameters?: ReplyParameters;
+  reply_markup?: ReplyMarkup;
+}
+/** `sendMessage` params (text ≤ 4096 chars after entity parsing). */
+export interface SendMessageParams extends SendOptions {
+  chat_id: ChatId;
+  text: string;
+  parse_mode?: ParseMode;
+  link_preview_options?: LinkPreviewOptions;
+}
+/** A file to upload with multipart. `data` is read once; a stream is buffered into a Blob before sending. */
+export interface InputFileUpload {
+  data: Blob | ArrayBuffer | Uint8Array | ReadableStream<Uint8Array>;
+  filename: string;
+  mime?: string;
+}
+/** An upload, or a `file_id` / HTTP URL string already known to Telegram. */
+export type InputFile = InputFileUpload | string;
+/** `sendDocument` params (caption ≤ 1024 chars; uploads ≤ 50 MB). */
+export interface SendDocumentParams extends SendOptions {
+  chat_id: ChatId;
+  document: InputFile;
+  caption?: string;
+  parse_mode?: ParseMode;
+  disable_content_type_detection?: boolean;
+}
+/** `sendPhoto` params (caption ≤ 1024 chars). */
+export interface SendPhotoParams extends SendOptions {
+  chat_id: ChatId;
+  photo: InputFile;
+  caption?: string;
+  parse_mode?: ParseMode;
+  has_spoiler?: boolean;
+}
+/** `sendChatAction` actions the plugin uses. */
+export type ChatAction = "typing" | "upload_document" | "upload_photo" | "record_voice" | "find_location";
+/** `sendChatAction` params. */
+export interface SendChatActionParams {
+  chat_id: ChatId;
+  action: ChatAction;
+  message_thread_id?: number;
+}
+/** `editMessageText` params. */
+export interface EditMessageTextParams {
+  chat_id: ChatId;
+  message_id: number;
+  text: string;
+  parse_mode?: ParseMode;
+  link_preview_options?: LinkPreviewOptions;
+  reply_markup?: InlineKeyboardMarkup;
+}
+/** `editMessageReplyMarkup` params; omit `reply_markup` to remove the keyboard. */
+export interface EditMessageReplyMarkupParams {
+  chat_id: ChatId;
+  message_id: number;
+  reply_markup?: InlineKeyboardMarkup;
+}
+/** `deleteMessage` params. */
+export interface DeleteMessageParams {
+  chat_id: ChatId;
+  message_id: number;
+}
+/** `answerCallbackQuery` params (`text` ≤ 200 chars, shown as a toast or alert). */
+export interface AnswerCallbackQueryParams {
+  callback_query_id: string;
+  text?: string;
+  show_alert?: boolean;
+  url?: string;
+  cache_time?: number;
+}
+/** Update field names for `allowed_updates` (open-ended for newer types). */
+export type UpdateType = "message" | "edited_message" | "callback_query" | "my_chat_member" | "chat_member" | "channel_post" | "edited_channel_post" | "inline_query" | "chat_join_request" | (string & {});
+/** `setWebhook` params; `secret_token` comes back as `X-Telegram-Bot-Api-Secret-Token`. */
+export interface SetWebhookParams {
+  url: string;
+  secret_token?: string;
+  allowed_updates?: UpdateType[];
+  max_connections?: number;
+  drop_pending_updates?: boolean;
+}
+/** `deleteWebhook` params. */
+export interface DeleteWebhookParams {
+  drop_pending_updates?: boolean;
+}
+/** `getWebhookInfo` result (dates are Unix seconds). */
+export interface WebhookInfo {
+  url: string;
+  has_custom_certificate: boolean;
+  pending_update_count: number;
+  ip_address?: string;
+  last_error_date?: number;
+  last_error_message?: string;
+  last_synchronization_error_date?: number;
+  max_connections?: number;
+  allowed_updates?: string[];
+}
+/** `getUpdates` params (polling mode). */
+export interface GetUpdatesParams {
+  offset?: number;
+  limit?: number;
+  /** Long-poll seconds; keep it below the client timeout. */
+  timeout?: number;
+  allowed_updates?: UpdateType[];
+}
+/** One menu command for `setMyCommands`. */
+export interface BotCommand {
+  command: string;
+  description: string;
+  /** 10.2: the user's command is hidden from other group members. */
+  is_ephemeral?: boolean;
+}
+/** Bot API `BotCommandScope`: which chats/users a command list applies to. */
+export type BotCommandScope = {
+  type: "default";
+} | {
+  type: "all_private_chats";
+} | {
+  type: "all_group_chats";
+} | {
+  type: "all_chat_administrators";
+} | {
+  type: "chat";
+  chat_id: ChatId;
+} | {
+  type: "chat_administrators";
+  chat_id: ChatId;
+} | {
+  type: "chat_member";
+  chat_id: ChatId;
+  user_id: number;
+};
+/** `setMyCommands` params (`language_code` = ISO 639-1, or omitted for the default list). */
+export interface SetMyCommandsParams {
+  commands: BotCommand[];
+  scope?: BotCommandScope;
+  language_code?: string;
+}
+/** Scope + language selector for `getMyCommands` / `deleteMyCommands`. */
+export interface CommandScopeParams {
+  scope?: BotCommandScope;
+  language_code?: string;
+}
+/** Bot user from getMe. */
+export interface BotUser extends TgUser {
+  is_bot: true;
+  username: string;
+  can_join_groups?: boolean;
+  can_read_all_group_messages?: boolean;
+  supports_inline_queries?: boolean;
+}
+/** Bot API `File` from `getFile`; download it with `BotApi.downloadFile(file_path)`. */
+export interface TgFile {
+  file_id: string;
+  file_unique_id: string;
+  file_size?: number;
+  file_path?: string;
+}
+/** Bot API `ChatFullInfo` from `getChat` (subset; other fields pass through). */
+export interface ChatFullInfo {
+  id: number;
+  type: string;
+  title?: string;
+  username?: string;
+  first_name?: string;
+  last_name?: string;
+  is_forum?: boolean;
+  [key: string]: unknown;
+}
+/** Results of every typed method (keys are Bot API method names). */
+export interface MethodResults {
+  getMe: BotUser;
+  setWebhook: true;
+  deleteWebhook: true;
+  getWebhookInfo: WebhookInfo;
+  getUpdates: unknown[];
+  setMyCommands: true;
+  deleteMyCommands: true;
+  getMyCommands: BotCommand[];
+  sendMessage: TgMessage;
+  sendDocument: TgMessage;
+  sendPhoto: TgMessage;
+  sendChatAction: true;
+  /** A Message, or `true` for inline messages. */
+  editMessageText: TgMessage | true;
+  editMessageReplyMarkup: TgMessage | true;
+  deleteMessage: true;
+  answerCallbackQuery: true;
+  getFile: TgFile;
+  getChat: ChatFullInfo;
+  getChatMember: TgChatMember;
+  leaveChat: true;
+}
+/** Names of the typed Bot API methods. */
+export type MethodName = keyof MethodResults;
+export {};