ultra-telegram-framework 1.0.3

package/dist/core/composer.d.ts

@@ -0,0 +1,87 @@
+import { Context } from './context';
+import { PhotoSize, Document, Video, Voice, Location, LivePhoto } from '../types/telegram';
+/**
+ * Type for the error handling function.
+ */
+export type ErrorHandler<C extends Context = Context> = (err: unknown, ctx: C) => Promise<void> | void;
+/**
+ * Type for the next() function, which passes control to the next handler in the queue.
+ */
+export type NextFunction = () => Promise<void>;
+/**
+ * Strict type for editor autocompletion.
+ * Contains Update object keys, Message fields, and entity types (Entities).
+ */
+export type UpdateFilter = 'message' | 'edited_message' | 'channel_post' | 'edited_channel_post' | 'callback_query' | 'business_connection' | 'business_message' | 'edited_business_message' | 'deleted_business_messages' | 'message_reaction' | 'message_reaction_count' | 'chat_boost' | 'removed_chat_boost' | 'guest_message' | 'text' | 'photo' | 'document' | 'audio' | 'video' | 'voice' | 'animation' | 'sticker' | 'contact' | 'location' | 'live_photo' | 'command' | 'bot_command' | 'hashtag' | 'url' | 'mention' | 'email' | 'phone_number';
+/**
+ * Main type of our handler (middleware).
+ * It accepts the context (ctx) and the relay function (next).
+ */
+export type Middleware<C extends Context = Context> = (ctx: C, next: NextFunction) => Promise<unknown> | void;
+/**
+ * Helper type that guarantees the presence of certain fields in Message
+ * depending on the passed filter.
+ */
+export type NarrowedMessage<F extends UpdateFilter> = F extends 'text' ? {
+    text: string;
+} : F extends 'photo' ? {
+    photo: PhotoSize[];
+} : F extends 'document' ? {
+    document: Document;
+} : F extends 'video' ? {
+    video: Video;
+} : F extends 'voice' ? {
+    voice: Voice;
+} : F extends 'location' ? {
+    location: Location;
+} : F extends 'live_photo' ? {
+    live_photo: LivePhoto;
+    photo: PhotoSize[];
+} : {};
+/**
+ * Main type of the narrowed context.
+ * It extends the base context C, making certain fields MANDATORY.
+ */
+export type NarrowedContext<C extends Context, F extends UpdateFilter> = C & {
+    callbackQuery: F extends 'callback_query' ? NonNullable<C['callbackQuery']> : C['callbackQuery'];
+    message: F extends 'message' | 'text' | 'photo' | 'document' | 'audio' | 'video' | 'voice' | 'animation' | 'sticker' | 'contact' | 'location' | 'live_photo' | 'guest_message' | 'business_message' ? NonNullable<C['message']> & NarrowedMessage<F> : C['message'];
+};
+export declare class Composer<C extends Context = Context> {
+    private handlers;
+    private errorHandler?;
+    catch(handler: ErrorHandler<C>): this;
+    /**
+     * Adds a general handler or an ENTIRE MODULE (another Composer).
+     */
+    use(...middlewares: (Middleware<C> | Composer<C>)[]): this;
+    /**
+     * Registers a handler for a specific command (or an array of commands).
+     *
+     * @param command Command name without the slash (e.g., 'start' or ['start', 'help'])
+     * @param middlewares Functions that will be executed if the command matches
+     */
+    command(command: string | string[], ...middlewares: Middleware<C>[]): this;
+    /**
+     * Registers a handler for inline button clicks (callback_query).
+     *
+     * @param actionName String or regular expression to check callback_data
+     * @param middlewares Functions that will be executed on a match
+     */
+    action(actionName: string | RegExp, ...middlewares: Middleware<C>[]): this;
+    /**
+       * Registers a handler that will trigger under certain conditions (update type, presence of a field or entity).
+       * @param filter Field name or array of names (e.g., 'photo', 'document', 'callback_query')
+       * @param middlewares Handler functions that will be executed on a match
+       */
+    on<F extends UpdateFilter>(filter: F | F[], ...middlewares: Middleware<NarrowedContext<C, F>>[]): this;
+    /**
+     * Magic engine: collects an array of middlewares into a single execution chain.
+     * When one middleware calls next(), this function triggers the next one.
+     */
+    static compose<C extends Context>(middlewares: Middleware<C>[]): Middleware<C>;
+    /**
+     * Returns all handlers registered in this class as one large function.
+     * Wrapped in try...catch to intercept errors.
+     */
+    middleware(): Middleware<C>;
+}

package/dist/core/composer.js

@@ -0,0 +1,164 @@
+export class Composer {
+    constructor() {
+        // Here we store our entire chain of handlers
+        this.handlers = [];
+    }
+    catch(handler) {
+        this.errorHandler = handler;
+        return this;
+    }
+    /**
+     * Adds a general handler or an ENTIRE MODULE (another Composer).
+     */
+    use(...middlewares) {
+        middlewares.forEach(middleware => {
+            if (middleware instanceof Composer) {
+                // If it is a separate file with commands (module), we extract the chain from it
+                this.handlers.push(middleware.middleware());
+            }
+            else {
+                // If it is a regular function
+                this.handlers.push(middleware);
+            }
+        });
+        return this;
+    }
+    /**
+     * Registers a handler for a specific command (or an array of commands).
+     *
+     * @param command Command name without the slash (e.g., 'start' or ['start', 'help'])
+     * @param middlewares Functions that will be executed if the command matches
+     */
+    command(command, ...middlewares) {
+        const commands = Array.isArray(command) ? command : [command];
+        // Create a "filter middleware"
+        const filterMiddleware = async (ctx, next) => {
+            const text = ctx.text;
+            // If there is no text or it does not start with a slash - it's not a command
+            if (!text || !text.startsWith('/')) {
+                return next(); // Pass the relay further
+            }
+            // Extract the clean command name (ignore '@bot_username' if present)
+            const cmdText = text.split(' ')[0].split('@')[0].substring(1);
+            if (commands.includes(cmdText)) {
+                // If the command is ours, run the passed handlers
+                await Composer.compose(middlewares)(ctx, next);
+            }
+            else {
+                // If the command is not ours, proceed further
+                await next();
+            }
+        };
+        this.handlers.push(filterMiddleware);
+        return this;
+    }
+    /**
+     * Registers a handler for inline button clicks (callback_query).
+     *
+     * @param actionName String or regular expression to check callback_data
+     * @param middlewares Functions that will be executed on a match
+     */
+    action(actionName, ...middlewares) {
+        const filterMiddleware = async (ctx, next) => {
+            var _a;
+            // Check if the update contains a callback_query and its data
+            const callbackData = (_a = ctx.callbackQuery) === null || _a === void 0 ? void 0 : _a.data;
+            if (!callbackData) {
+                return next();
+            }
+            // Check for a match (if it's a string - exact match, if RegExp - pattern check)
+            const isMatch = typeof actionName === 'string'
+                ? callbackData === actionName
+                : actionName.test(callbackData);
+            if (isMatch) {
+                await Composer.compose(middlewares)(ctx, next);
+            }
+            else {
+                await next();
+            }
+        };
+        this.handlers.push(filterMiddleware);
+        return this;
+    }
+    /**
+       * Registers a handler that will trigger under certain conditions (update type, presence of a field or entity).
+       * @param filter Field name or array of names (e.g., 'photo', 'document', 'callback_query')
+       * @param middlewares Handler functions that will be executed on a match
+       */
+    on(filter, ...middlewares) {
+        const filters = Array.isArray(filter) ? filter : [filter];
+        const filterMiddleware = async (ctx, next) => {
+            const updateAny = ctx.update;
+            const messageAny = ctx.message;
+            const isMatch = filters.some(checking => {
+                // Merge entities from text and media file captions
+                const entities = (messageAny === null || messageAny === void 0 ? void 0 : messageAny.entities) || (messageAny === null || messageAny === void 0 ? void 0 : messageAny.caption_entities) || [];
+                // Check for commands
+                if (checking === 'command') {
+                    return entities.some((e) => e.type === 'bot_command');
+                }
+                // Check for other entities (hashtag, url, mention, etc.)
+                const isEntity = entities.some((e) => e.type === checking);
+                if (isEntity)
+                    return true;
+                // Check for the presence of a field (photo, document, text) in the UNIVERSAL message
+                if (messageAny && checking in messageAny)
+                    return true;
+                // Check for the presence of a field in the update root (e.g., callback_query)
+                if (checking in updateAny)
+                    return true;
+                return false;
+            });
+            if (isMatch) {
+                await Composer.compose(middlewares)(ctx, next);
+            }
+            else {
+                await next();
+            }
+        };
+        this.handlers.push(filterMiddleware);
+        return this;
+    }
+    /**
+     * Magic engine: collects an array of middlewares into a single execution chain.
+     * When one middleware calls next(), this function triggers the next one.
+     */
+    static compose(middlewares) {
+        return async (ctx, next) => {
+            let index = -1;
+            const dispatch = async (i) => {
+                if (i <= index)
+                    throw new Error('next() called multiple times in one middleware!');
+                index = i;
+                const middleware = middlewares[i];
+                if (!middleware) {
+                    // If the handlers are finished, call the final next
+                    return next();
+                }
+                // Call the current middleware and pass it the function to call the next one
+                await middleware(ctx, () => dispatch(i + 1));
+            };
+            await dispatch(0);
+        };
+    }
+    /**
+     * Returns all handlers registered in this class as one large function.
+     * Wrapped in try...catch to intercept errors.
+     */
+    middleware() {
+        const composed = Composer.compose(this.handlers);
+        return async (ctx, next) => {
+            try {
+                await composed(ctx, next);
+            }
+            catch (err) {
+                if (this.errorHandler) {
+                    await this.errorHandler(err, ctx);
+                }
+                else {
+                    throw err;
+                }
+            }
+        };
+    }
+}

package/dist/core/context/base-context.d.ts

@@ -0,0 +1,24 @@
+import { TelegramBotApi, Update, CallbackQuery, MaybeInaccessibleMessage } from "../../types/telegram";
+export declare abstract class BaseContext {
+    readonly update: Update;
+    readonly api: TelegramBotApi;
+    readonly message?: MaybeInaccessibleMessage;
+    readonly callbackQuery?: CallbackQuery;
+    constructor(update: Update, api: TelegramBotApi);
+    get chatId(): number | undefined;
+    get isMessageAccessible(): boolean;
+    get from(): import("../../types/telegram").User | undefined;
+    get text(): string | undefined;
+    protected getRequiredIds(operation: string): {
+        chatId: number;
+        messageId: number;
+    };
+    protected getRequiredIds(operation: string, force: true): {
+        chatId: number;
+        messageId: number;
+    };
+    protected getRequiredIds(operation: string, force: false): {
+        chatId: number;
+        messageId: number | undefined;
+    };
+}

package/dist/core/context/base-context.js

@@ -0,0 +1,56 @@
+export class BaseContext {
+    constructor(update, api) {
+        var _a;
+        this.update = update;
+        this.api = api;
+        this.message =
+            update.message ||
+                update.edited_message ||
+                update.channel_post ||
+                ((_a = update.callback_query) === null || _a === void 0 ? void 0 : _a.message) ||
+                update.business_message ||
+                update.guest_message;
+        this.callbackQuery = update.callback_query;
+    }
+    get chatId() {
+        var _a, _b, _c, _d, _e;
+        return (((_b = (_a = this.message) === null || _a === void 0 ? void 0 : _a.chat) === null || _b === void 0 ? void 0 : _b.id) ||
+            ((_c = this.update.my_chat_member) === null || _c === void 0 ? void 0 : _c.chat.id) ||
+            ((_d = this.update.chat_member) === null || _d === void 0 ? void 0 : _d.chat.id) ||
+            ((_e = this.update.chat_join_request) === null || _e === void 0 ? void 0 : _e.chat.id));
+    }
+    get isMessageAccessible() {
+        return !!this.message && this.message.date !== 0;
+    }
+    get from() {
+        var _a, _b;
+        const msg = this.message;
+        if (msg && "from" in msg)
+            return msg.from;
+        return ((_a = this.callbackQuery) === null || _a === void 0 ? void 0 : _a.from) || ((_b = this.update.inline_query) === null || _b === void 0 ? void 0 : _b.from);
+    }
+    get text() {
+        const msg = this.message;
+        if (!msg)
+            return undefined;
+        if ("text" in msg)
+            return msg.text;
+        if ("caption" in msg)
+            return msg.caption;
+        return undefined;
+    }
+    getRequiredIds(operation, force = true) {
+        var _a, _b;
+        const chatId = this.chatId;
+        if (!chatId)
+            throw new Error(`Cannot perform ${operation}: chat_id not found.`);
+        if (!force) {
+            return { chatId, messageId: this.isMessageAccessible ? (_a = this.message) === null || _a === void 0 ? void 0 : _a.message_id : undefined };
+        }
+        const messageId = (_b = this.message) === null || _b === void 0 ? void 0 : _b.message_id;
+        if (!this.isMessageAccessible || !messageId) {
+            throw new Error(`Cannot perform ${operation}: message is inaccessible or deleted.`);
+        }
+        return { chatId, messageId };
+    }
+}

package/dist/core/context/reply-context.d.ts

@@ -0,0 +1,234 @@
+import { Message, SendMessageParams, SendPhotoParams, InputFile, InlineKeyboardMarkup, ReplyKeyboardMarkup, ReplyKeyboardRemove, ForceReply, InlineKeyboardButton, SendVideoParams, SendDocumentParams, SendLivePhotoParams, SendGiftParams, AnswerCallbackQueryParams, ReactionType, EditMessageTextParams, MessageId, EditMessageCaptionParams, SendInvoiceParams, AnswerShippingQueryParams, SendPaidMediaParams, InputPaidMediaPhoto, InputPaidMediaVideo, InputPaidMediaLivePhoto, SendMediaGroupParams, InputMediaDocument, InputMediaAudio, InputMediaPhoto, InputMediaVideo, InputMediaLivePhoto, InputPollOption, SendPollParams, InlineQueryResult, AnswerGuestQueryParams, SentGuestMessage, SendGameParams, SetGameScoreParams, GameHighScore, DeleteMessageReactionParams, DeleteAllMessageReactionsParams, SendMessageDraftParams } from "../../types/telegram";
+import { InlineKeyboard, ReplyKeyboard } from "../keyboard";
+import { BaseContext } from "./base-context";
+export declare abstract class ReplyContext extends BaseContext {
+    reply(text: string, options?: Omit<SendMessageParams, "chat_id" | "text">): Promise<Message>;
+    /**
+     * Reply to the current message with a keyboard (Inline or Reply)
+     * @param text - message text
+     * @param keyboard - keyboard
+     * @param options - parameters object
+     * @returns `Promise<Message>`
+     */
+    replyWithKeyboard(text: string, keyboard: InlineKeyboard | ReplyKeyboard | InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply, options?: Omit<SendMessageParams, "chat_id" | "text" | "reply_markup">): Promise<Message>;
+    /**
+   * Quick reply with an Inline keyboard
+   * @param text - message text
+   * @param buttons - keyboard
+   * @param options - parameters object
+   * @returns `Promise<Message>`
+   */
+    replyWithInlineKeyboard(text: string, buttons: InlineKeyboardButton[][] | InlineKeyboard, options?: Omit<SendMessageParams, "chat_id" | "text" | "reply_markup">): Promise<Message>;
+    /**
+     * Reply to the current message with a photo
+     * @param photo URL of the image or `file_id`
+     * @param options Parameters object or just the notification text
+     * @returns `Promise<Message>`
+     */
+    replyWithPhoto(photo: string | InputFile, options?: Omit<SendPhotoParams, "chat_id" | "photo">): Promise<Message>;
+    /**
+       * Reply to the current message with a video file
+       * @param video URL of the video or `file_id`
+       * @param options Parameters object or just the notification text
+       * @returns `Promise<Message>`
+       */
+    replyWithVideo(video: string | InputFile, options?: Omit<SendVideoParams, "chat_id" | "video">): Promise<Message>;
+    /**
+      * Reply to the current message with a document (file)
+      * @param document URL of the file or `file_id`
+      * @param options Parameters object or just the notification text
+      * @returns `Promise<Message>`
+      */
+    replyWithDocument(document: string | InputFile, options?: Omit<SendDocumentParams, "chat_id" | "document">): Promise<Message>;
+    /**
+     * Reply to the current message with a "live photo" (Live Photo)
+     * @param photo URL of the photo or `file_id`
+     * @param livePhoto URL of the "live photo" or `file_id`
+     * @param options Parameters object or just the notification text
+     * @returns `Promise<Message>`
+     */
+    replyWithLivePhoto(photo: string | InputFile, livePhoto: string | InputFile, options?: Omit<SendLivePhotoParams, "chat_id" | "photo" | "live_photo">): Promise<Message>;
+    /**
+      * Send a gift (Star Gift) to the current user
+      * @param giftId Gift ID
+      * @param options Parameters object
+      * @returns `Promise<boolean>`
+      */
+    sendGift(giftId: string, options?: Omit<SendGiftParams, "user_id" | "chat_id" | "gift_id">): Promise<boolean>;
+    /**
+      * Remove loading indicator from an inline button
+      * @param params Parameters object or just the notification text
+      * @returns `Promise<boolean>`
+      */
+    answerCbQuery(params?: (Omit<AnswerCallbackQueryParams, "callback_query_id">) | string): Promise<boolean>;
+    /**
+  * React to the current message
+  * @param reactions Array of reactions (e.g.: `[{ type: "emoji", emoji: "👍" }]`)
+  * @returns `Promise<boolean>`
+  */
+    react(reactions: ReactionType[]): Promise<boolean>;
+    /**
+    * Send chat action status to the current chat (e.g., "typing", "upload_photo")
+    * @param action Action status (e.g., "typing", "upload_photo")
+    * @returns `Promise<boolean>`
+    */
+    replyWithChatAction(action: "typing" | "upload_photo" | "record_video" | "upload_video" | "record_voice" | "upload_voice" | "upload_document" | "choose_sticker" | "find_location" | "record_video_note" | "upload_video_note"): Promise<boolean>;
+    /**
+      * Delete the current message
+      * @returns `Promise<boolean>`
+      */
+    deleteMessage(): Promise<boolean>;
+    /**
+   * Edit the text of the current message
+   * @param text Message text
+   * @param options Additional parameters
+   * @returns `Promise<Message | boolean>`
+   */
+    editMessage(text: string, options?: Omit<EditMessageTextParams, "chat_id" | "text" | "message_id">): Promise<Message | boolean>;
+    /**
+       * Forward the current message to another chat
+       * @param toChatId ID of the chat where the message is forwarded
+       * @returns `Promise<Message>`
+       */
+    forwardTo(toChatId: string | number): Promise<Message>;
+    /**
+    * Copy the current message to another chat
+    * @param toChatId ID of the chat where the message is copied
+    * @returns `Promise<MessageId>`
+    */
+    copyTo(toChatId: string | number): Promise<MessageId>;
+    /**
+     * Returns command arguments (everything that follows the command name).
+     * Example: for the message "/start ref_123", it will return "ref_123".
+     * If it is just "/start", it will return an empty string.
+     * @returns `string`
+     */
+    get payload(): string;
+    /**
+     * ID of the user who initiated the event
+     * @returns `number | undefined`
+     */
+    get senderId(): number | undefined;
+    /**
+      * Change only the inline keyboard of the current message
+      * @param replyMarkup - keyboard
+      * @returns `Promise<Message | boolean>`
+      */
+    editReplyMarkup(replyMarkup?: InlineKeyboardMarkup): Promise<Message | boolean>;
+    /**
+   * Change the caption of the current media file (photo/video)
+   * @param caption - caption
+   * @param options - parameters object
+   * @returns `Promise<Message | boolean>`
+   */
+    editCaption(caption: string, options?: Omit<EditMessageCaptionParams, "chat_id" | "message_id" | "caption">): Promise<Message | boolean>;
+    /**
+     * Get the list of administrators of the current chat
+     * @returns `Promise<ChatMember[]>`
+     */
+    getAdministrators(): Promise<import("../../types/telegram").ChatMember[]>;
+    /**
+     * Get information about a specific member in the current chat
+     * @param userId User ID
+     * @returns `Promise<ChatMember>`
+     */
+    getMember(userId: number): Promise<import("../../types/telegram").ChatMember>;
+    /**
+     * Leave the current chat (group/channel)
+     * @returns `Promise<boolean>`
+     */
+    leaveChat(): Promise<boolean>;
+    /**
+     * Send an invoice to the current chat
+     * @param params Parameters object
+     * @returns `Promise<Message>`
+     */
+    replyWithInvoice(params: Omit<SendInvoiceParams, "chat_id">): Promise<Message>;
+    /**
+     * Answer a shipping query (Shipping Query)
+     * @param ok Is everything okay
+     * @param options Additional parameters
+     * @returns `Promise<boolean>`
+     */
+    answerShippingQuery(ok: boolean, options?: Omit<AnswerShippingQueryParams, "shipping_query_id" | "ok">): Promise<boolean>;
+    /**
+     * Answer a pre-checkout query (Pre-checkout Query)
+     * @param ok Is everything okay
+     * @param errorMessage Error message
+     * @returns `Promise<boolean>`
+     */
+    answerPreCheckoutQuery(ok: boolean, errorMessage?: string): Promise<boolean>;
+    /**
+     * Send a game to the current chat
+     * @param gameShortName - short name of the game
+     * @param options - parameters object
+     * @returns `Promise<Message>`
+     */
+    replyWithGame(gameShortName: string, options?: Omit<SendGameParams, "chat_id" | "game_short_name">): Promise<Message>;
+    /**
+     * Set a high score for a player in the game
+     * @param score - game score
+     * @param options - parameters object
+     * @returns `Promise<Message | boolean>`
+     */
+    setGameScore(score: number, options?: Omit<SetGameScoreParams, "user_id" | "score">): Promise<Message | boolean>;
+    /**
+     * Get high scores table for the game
+     * @returns `Promise<GameHighScore[]>`
+     */
+    getGameHighScores(): Promise<GameHighScore[]>;
+    /**
+     * Answer a guest query (Guest Mode)
+     * @param result - query result
+     * @param options - parameters object
+     * @returns `Promise<SentGuestMessage>`
+     */
+    answerGuest(result: InlineQueryResult, options?: Omit<AnswerGuestQueryParams, "guest_query_id" | "result">): Promise<SentGuestMessage>;
+    /**
+     * Delete reaction on the current message.
+     * By default, deletes the reaction of the user who initiated the event.
+     * @param options - parameters object
+     * @returns `Promise<boolean>`
+     */
+    deleteReaction(options?: Omit<DeleteMessageReactionParams, "chat_id" | "message_id">): Promise<boolean>;
+    /**
+     * Delete all reactions of a specific user in the current chat (up to 10,000).
+     * By default, deletes the reactions of the user who initiated the event.
+     * @param options - parameters object
+     * @returns `Promise<boolean>`
+     */
+    deleteAllReactions(options?: Omit<DeleteAllMessageReactionsParams, "chat_id">): Promise<boolean>;
+    /**
+     * Send a poll or quiz (Poll / Quiz) to the current chat.
+     * Supports new API 10.0 features: media, explanation_media, 1 answer option.
+     * @param question - poll text
+     * @param pollOptions - answer options
+     * @param options - parameters object
+     * @returns `Promise<Message>`
+     */
+    replyWithPoll(question: string, pollOptions: (string | InputPollOption)[], options?: Omit<SendPollParams, "chat_id" | "question" | "options">): Promise<Message>;
+    /**
+     * Streaming a temporary message (Draft) for generating responses (e.g., AI).
+     * This ephemeral message lives for 30 seconds. After completion, it is mandatory to call a regular reply().
+     * @param draftId - unique stream identifier (must be > 0). Identical IDs animate changes.
+     * @param options - parameters object
+     * @returns `Promise<boolean>`
+     */
+    replyWithDraft(draftId: number, options?: Omit<SendMessageDraftParams, "draft_id">): Promise<boolean>;
+    /**
+     * Send a group of media files (album).
+     * Supports photos, videos, audio, documents, and new Live Photos (API 10.0).
+     * @param media - array of media files
+     * @param options - parameters object
+     * @returns `Promise<Message[]>`
+     */
+    replyWithMediaGroup(media: InputMediaAudio[] | InputMediaDocument[] | Array<InputMediaPhoto | InputMediaVideo | InputMediaLivePhoto>, options?: Omit<SendMediaGroupParams, "chat_id" | "media">): Promise<Message[]>;
+    /**
+     * Send paid media, for viewing which the user must pay with Telegram Stars.
+     * @param starCount - number of stars the user must pay
+     * @param media - array of media files
+     * @param options - parameters object
+     * @returns `Promise<Message>`
+     */
+    replyWithPaidMedia(starCount: number, media: (InputPaidMediaPhoto | InputPaidMediaVideo | InputPaidMediaLivePhoto)[], options?: Omit<SendPaidMediaParams, "chat_id" | "star_count" | "media">): Promise<Message>;
+}