@aracna/telegram-bot 1.9.14 → 2.0.1

package/index.d.ts

@@ -12,14 +12,16 @@ import type { BotDescription } from '@aracna/telegram-bot-types';
 import type { BotName } from '@aracna/telegram-bot-types';
 import type { BotShortDescription } from '@aracna/telegram-bot-types';
 import type { BusinessConnection } from '@aracna/telegram-bot-types';
+import type { BusinessMessagesDeleted } from '@aracna/telegram-bot-types';
 import type { CallbackQuery as CallbackQuery_2 } from '@aracna/telegram-bot-types';
 import type { Chat } from '@aracna/telegram-bot-types';
 import type { ChatAdministratorRights } from '@aracna/telegram-bot-types';
+import type { ChatBoostRemoved } from '@aracna/telegram-bot-types';
+import type { ChatBoostUpdated } from '@aracna/telegram-bot-types';
 import type { ChatInviteLink } from '@aracna/telegram-bot-types';
 import type { ChatJoinRequest } from '@aracna/telegram-bot-types';
 import type { ChatMember } from '@aracna/telegram-bot-types';
 import type { ChatMemberUpdated } from '@aracna/telegram-bot-types';
-import type { ChatPermissions } from '@aracna/telegram-bot-types';
 import type { ChosenInlineResult } from '@aracna/telegram-bot-types';
 import type { CloseForumTopic } from '@aracna/telegram-bot-types';
 import type { CloseGeneralForumTopic } from '@aracna/telegram-bot-types';
@@ -52,7 +54,9 @@ import type { EditMessageReplyMarkup } from '@aracna/telegram-bot-types';
 import type { EditMessageText } from '@aracna/telegram-bot-types';
 import type { ExportChatInviteLink } from '@aracna/telegram-bot-types';
 import { FetchError } from '@aracna/core';
+import type { FetchResponse } from '@aracna/core';
 import type { File as File_2 } from '@aracna/telegram-bot-types';
+import type { ForumTopic } from '@aracna/telegram-bot-types';
 import type { ForwardMessage } from '@aracna/telegram-bot-types';
 import type { ForwardMessages } from '@aracna/telegram-bot-types';
 import type { GameHighScore } from '@aracna/telegram-bot-types';
@@ -78,36 +82,32 @@ import type { GetUserProfilePhotos } from '@aracna/telegram-bot-types';
 import type { HideGeneralForumTopic } from '@aracna/telegram-bot-types';
 import type { InlineKeyboardButton } from '@aracna/telegram-bot-types';
 import type { InlineQuery } from '@aracna/telegram-bot-types';
-import type { InlineQueryResult } from '@aracna/telegram-bot-types';
-import type { InputMedia } from '@aracna/telegram-bot-types';
 import type { InputMediaAudio } from '@aracna/telegram-bot-types';
 import type { InputMediaDocument } from '@aracna/telegram-bot-types';
 import type { InputMediaPhoto } from '@aracna/telegram-bot-types';
 import type { InputMediaVideo } from '@aracna/telegram-bot-types';
-import type { InputPollOption } from '@aracna/telegram-bot-types';
-import type { InputSticker } from '@aracna/telegram-bot-types';
-import type { LabeledPrice } from '@aracna/telegram-bot-types';
 import type { LeaveChat } from '@aracna/telegram-bot-types';
+import { Logger } from '@aracna/core';
 import type { LoginUrl } from '@aracna/telegram-bot-types';
-import type { MaskPosition } from '@aracna/telegram-bot-types';
 import type { MenuButton } from '@aracna/telegram-bot-types';
 import type { Message } from '@aracna/telegram-bot-types';
 import type { MessageEntity } from '@aracna/telegram-bot-types';
 import type { MessageId } from '@aracna/telegram-bot-types';
-import type { PassportElementError } from '@aracna/telegram-bot-types';
+import type { MessageReactionCountUpdated } from '@aracna/telegram-bot-types';
+import type { MessageReactionUpdated } from '@aracna/telegram-bot-types';
 import type { PinChatMessage } from '@aracna/telegram-bot-types';
 import type { Poll } from '@aracna/telegram-bot-types';
 import type { PollAnswer } from '@aracna/telegram-bot-types';
 import type { PreCheckoutQuery } from '@aracna/telegram-bot-types';
 import type { PromoteChatMember } from '@aracna/telegram-bot-types';
-import type { ReactionType } from '@aracna/telegram-bot-types';
+import { Queue } from '@aracna/core';
 import type { RefundStarPayment } from '@aracna/telegram-bot-types';
 import type { ReopenForumTopic } from '@aracna/telegram-bot-types';
 import type { ReopenGeneralForumTopic } from '@aracna/telegram-bot-types';
 import type { ReplaceStickerInSet } from '@aracna/telegram-bot-types';
 import { RequestMethod } from '@aracna/core';
 import { RestAPI } from '@aracna/core';
-import { RestApiConfig } from '@aracna/core';
+import type { RestApiConfig } from '@aracna/core';
 import type { RestrictChatMember } from '@aracna/telegram-bot-types';
 import type { RevokeChatInviteLink } from '@aracna/telegram-bot-types';
 import type { SendAnimation } from '@aracna/telegram-bot-types';
@@ -159,6 +159,7 @@ import type { Sticker } from '@aracna/telegram-bot-types';
 import type { StickerSet } from '@aracna/telegram-bot-types';
 import type { StopMessageLiveLocation } from '@aracna/telegram-bot-types';
 import type { StopPoll } from '@aracna/telegram-bot-types';
+import type { SwitchInlineQueryChosenChat } from '@aracna/telegram-bot-types';
 import type { UnbanChatMember } from '@aracna/telegram-bot-types';
 import type { UnbanChatSenderChat } from '@aracna/telegram-bot-types';
 import type { UnpinAllChatMessages } from '@aracna/telegram-bot-types';
@@ -170,534 +171,567 @@ import type { UploadStickerFile } from '@aracna/telegram-bot-types';
 import type { User } from '@aracna/telegram-bot-types';
 import type { UserChatBoosts } from '@aracna/telegram-bot-types';
 import type { UserProfilePhotos } from '@aracna/telegram-bot-types';
+import type { WebAppInfo } from '@aracna/telegram-bot-types';
 import type { WebhookInfo } from '@aracna/telegram-bot-types';
 
-declare class Add extends Child {
-    stickerToSet(userID: bigint, name: string, sticker: InputSticker, parameters?: Partial<AddStickerToSet>): Promise<Message | FetchError>;
-}
+export declare function addTelegramStickerToSet(token: string, body: AddStickerToSet): Promise<boolean | FetchError>;
 
-declare class Answer extends Child {
-    callbackQuery(id: string, parameters?: Partial<AnswerCallbackQuery>): Promise<boolean | FetchError>;
-    inlineQuery(id: string, results: InlineQueryResult[], parameters?: Partial<AnswerInlineQuery>): Promise<boolean | FetchError>;
-    preCheckoutQuery(id: string, ok: boolean, parameters?: Partial<AnswerPreCheckoutQuery>): Promise<boolean | FetchError>;
-    shippingQuery(id: string, ok: boolean, parameters?: Partial<AnswerShippingQuery>): Promise<boolean | FetchError>;
-    webAppQuery(id: string, result: InlineQueryResult, parameters?: Partial<AnswerWebAppQuery>): Promise<SentWebAppMessage | FetchError>;
-}
+export declare function answerTelegramCallbackQuery(token: string, body: AnswerCallbackQuery): Promise<boolean | FetchError>;
 
-declare class API extends RestAPI {
-    post<V, W, X = undefined>(path: string, body?: W, config?: RestApiConfig<void>): Promise<V | FetchError<X>>;
-    transformBody<V>(method: RequestMethod, path: string, body: V, config: RestApiConfig<void>): Promise<FormData>;
-}
+export declare function answerTelegramInlineQuery(token: string, body: AnswerInlineQuery): Promise<boolean | FetchError>;
 
-declare class Approve extends Child {
-    chatJoinRequest(parameters: ApproveChatJoinRequest): Promise<boolean | FetchError>;
-}
+export declare function answerTelegramPreCheckoutQuery(token: string, body: AnswerPreCheckoutQuery): Promise<boolean | FetchError>;
 
-declare class Ban extends Child {
-    chatMember(parameters: BanChatMember): Promise<boolean | FetchError>;
-    chatSenderChat(parameters: BanChatSenderChat): Promise<boolean | FetchError>;
-}
+export declare function answerTelegramShippingQuery(token: string, body: AnswerShippingQuery): Promise<boolean | FetchError>;
+
+export declare function answerTelegramWebAppQuery(token: string, body: AnswerWebAppQuery): Promise<SentWebAppMessage | FetchError>;
 
-declare class Builder {
-    button: ButtonBuilder;
+declare class API extends RestAPI<TelegramApiDefinitions.Config> {
+    queue: Queue;
+    post<V, W, X = undefined>(path: string, body: W | undefined, config: TelegramApiDefinitions.Config): Promise<V | FetchError<X>>;
+    transformBody<V>(method: RequestMethod, path: string, body: V, config: TelegramApiDefinitions.Config): Promise<V | FormData | undefined>;
 }
 
-declare class ButtonBuilder {
-    callback<T>(text: string, data: T, type: string, chatID?: bigint): InlineKeyboardButton;
-    game(text: string, game: string): InlineKeyboardButton;
-    login(text: string, url: string, fields?: Partial<LoginUrl>): InlineKeyboardButton;
-    pay(text: string): InlineKeyboardButton;
-    query(text: string, query: string): InlineKeyboardButton;
-    queryCurrentChat(text: string, query: string): InlineKeyboardButton;
-    text(text: string): InlineKeyboardButton;
-    url(text: string, url: string): InlineKeyboardButton;
+declare class API_2 extends RestAPI<TelegramApiDefinitions.Config> {
+    get<V, W = undefined>(path: string, config: TelegramApiDefinitions.Config): Promise<V | FetchError<W>>;
 }
 
-export declare interface CallbackQuery<T = any> extends CallbackQuery_2 {
+export declare function approveTelegramChatJoinRequest(token: string, body: ApproveChatJoinRequest): Promise<boolean | FetchError>;
+
+export declare function banTelegramChatMember(token: string, body: BanChatMember): Promise<boolean | FetchError>;
+
+export declare function banTelegramChatSenderChat(token: string, body: BanChatSenderChat): Promise<boolean | FetchError>;
+
+export declare interface CallbackQuery<T = unknown> extends CallbackQuery_2 {
     body: CallbackQueryBody<T>;
 }
 
-export declare interface CallbackQueryBody<T = any> {
-    c?: bigint;
+export declare interface CallbackQueryBody<T = unknown> {
+    c?: bigint | number;
     d: T;
-    t: string;
+    m?: string;
 }
 
-export declare class CallbackQueryUtils {
-    static decodeBody<T>(data?: string): CallbackQueryBody<T>;
-    static encodeBody<T>(data: T, type: string, chatID?: bigint): string;
-}
+export declare function closeTelegramForumTopic(token: string, body: CloseForumTopic): Promise<boolean | FetchError>;
 
-declare class Child {
-    protected telegram: Telegram;
-    constructor(telegram: Telegram);
-}
+export declare function closeTelegramGeneralForumTopic(token: string, body: CloseGeneralForumTopic): Promise<boolean | FetchError>;
 
-declare class Close extends Child {
-    forumTopic(chatID: bigint, messageThreadID: number, parameters?: Partial<CloseForumTopic>): Promise<boolean | FetchError>;
-    generalForumTopic(chatID: bigint, parameters?: Partial<CloseGeneralForumTopic>): Promise<boolean | FetchError>;
-}
+export declare function closeTelegramWebhook(token: string): Promise<boolean | FetchError>;
 
-export declare class CommandUtils {
-    static getByContext<T extends UpdateType>(context: Context_2[T]): string;
-    static get(string?: string): string;
-    static omit(string: string): string;
+export declare interface Context {
+    business_connection: BusinessConnection;
+    business_message: Message;
+    callback_query: CallbackQuery;
+    channel_post: Message;
+    chat_boost: ChatBoostUpdated;
+    chat_join_request: ChatJoinRequest;
+    chat_member: ChatMemberUpdated;
+    chosen_inline_result: ChosenInlineResult;
+    deleted_business_messages: BusinessMessagesDeleted;
+    document: Message;
+    edited_business_message: Message;
+    edited_channel_post: Message;
+    edited_message: Message;
+    inline_query: InlineQuery;
+    message: Message;
+    message_reaction: MessageReactionUpdated;
+    message_reaction_count: MessageReactionCountUpdated;
+    my_chat_member: ChatMemberUpdated;
+    poll: Poll;
+    poll_answer: PollAnswer;
+    pre_checkout_query: PreCheckoutQuery;
+    removed_chat_boost: ChatBoostRemoved;
+    reply_to_message: ReplyToMessage;
+    shipping_query: ShippingQuery;
+    start: Start;
 }
 
-declare interface ConfigurationAPI {
-    post: {
-        callback: {
-            success: <T, U>(body: T, result: U | Error) => void;
-        };
-    };
-}
+export declare function copyTelegramMessage(token: string, body: CopyMessage): Promise<MessageId | FetchError>;
 
-declare class ConfigurationBuilder {
-    api: ConfigurationAPI;
-    default: ConfigurationDefault;
-    handler: ConfigurationHandler;
-}
+export declare function copyTelegramMessages(token: string, body: CopyMessages): Promise<MessageId[] | FetchError>;
 
-declare interface ConfigurationDefault {
-    buttons: {
-        text: (chatID: bigint) => Promise<InlineKeyboardButton[]>;
-        url: (chatID: bigint) => Promise<InlineKeyboardButton[]>;
-        login: (chatID: bigint) => Promise<InlineKeyboardButton[]>;
-        callback: (chatID: bigint) => Promise<InlineKeyboardButton[]>;
-        query: (chatID: bigint) => Promise<InlineKeyboardButton[]>;
-        queryCurrentChat: (chatID: bigint) => Promise<InlineKeyboardButton[]>;
-        game: (chatID: bigint) => Promise<InlineKeyboardButton[]>;
-        pay: (chatID: bigint) => Promise<InlineKeyboardButton[]>;
-    };
-}
+export declare function createTelegramChatInviteLink(token: string, body: CreateChatInviteLink): Promise<ChatInviteLink | FetchError>;
 
-declare interface ConfigurationHandler {
-    send: {
-        buttons: {
-            empty: (chatID: bigint) => Error;
-        };
-    };
-}
+export declare function createTelegramChatSubscriptionInviteLink(token: string, body: CreateChatSubscriptionInviteLink): Promise<ChatInviteLink | FetchError>;
 
-export declare interface Context {
-    [UpdateType.CALLBACK_QUERY]: CallbackQuery;
-    [UpdateType.CHANNEL_POST]: Message;
-    [UpdateType.CHAT_JOIN_REQUEST]: ChatJoinRequest;
-    [UpdateType.CHAT_MEMBER]: ChatMemberUpdated;
-    [UpdateType.CHOSEN_INLINE_RESULT]: ChosenInlineResult;
-    [UpdateType.DOCUMENT]: Message;
-    [UpdateType.EDITED_CHANNEL_POST]: Message;
-    [UpdateType.EDITED_MESSAGE]: Message;
-    [UpdateType.INLINE_QUERY]: InlineQuery;
-    [UpdateType.MESSAGE]: Message;
-    [UpdateType.MY_CHAT_MEMBER]: ChatMemberUpdated;
-    [UpdateType.POLL]: Poll;
-    [UpdateType.POLL_ANSWER]: PollAnswer;
-    [UpdateType.PRE_CHECKOUT_QUERY]: PreCheckoutQuery;
-    [UpdateType.REPLY_TO_MESSAGE]: ReplyToMessage;
-    [UpdateType.SHIPPING_QUERY]: ShippingQuery;
-    [UpdateType.START]: Start;
-}
+export declare function createTelegramForumTopic(token: string, body: CreateForumTopic): Promise<ForumTopic | FetchError>;
 
-export declare class ContextUtils {
-    static getChatID<T extends UpdateType>(context: Context[T]): bigint;
-    static getChatType<T extends UpdateType>(context: Context[T]): string;
-    static getChat<T extends UpdateType>(context: Context[T]): Chat;
-    static getUserID<T extends UpdateType>(context: Context[T]): bigint;
-    static getUserFirstName<T extends UpdateType>(context: Context[T]): string;
-    static getUserLastName<T extends UpdateType>(context: Context[T]): string;
-    static getUserUsername<T extends UpdateType>(context: Context[T]): string;
-    static getUser<T extends UpdateType>(context: Context[T]): User;
-}
+export declare function createTelegramInvoiceLink(token: string, body: CreateInvoiceLink): Promise<string | FetchError>;
 
-declare class Copy extends Child {
-    message(messageID: number, parameters: Omit<CopyMessage, 'message_id'>): Promise<MessageId | FetchError>;
-    messages(messageIDs: number[], parameters: Omit<CopyMessages, 'message_ids'>): Promise<MessageId[] | FetchError>;
-}
+export declare function createTelegramNewStickerSet(token: string, body: CreateNewStickerSet): Promise<boolean | FetchError>;
 
-declare class Create extends Child {
-    chatInviteLink(chatID: bigint, parameters?: Partial<CreateChatInviteLink>): Promise<ChatInviteLink | FetchError>;
-    chatSubscriptionInviteLink(chatID: bigint, parameters: Omit<CreateChatSubscriptionInviteLink, 'chat_id'>): Promise<ChatInviteLink | FetchError>;
-    forumTopic(chatID: bigint, name: string, parameters?: Partial<CreateForumTopic>): Promise<boolean | FetchError<undefined>>;
-    invoiceLink(prices: LabeledPrice[], parameters: Omit<CreateInvoiceLink, 'prices'>): Promise<string | FetchError>;
-    stickerSet(userID: bigint, stickers: InputSticker[], parameters: Omit<CreateNewStickerSet, 'stickers' | 'user_id'>): Promise<boolean | FetchError>;
-}
+export declare function declineTelegramChatJoinRequest(token: string, body: DeclineChatJoinRequest): Promise<boolean | FetchError>;
 
-declare class Decline extends Child {
-    chatJoinRequest(parameters: DeclineChatJoinRequest): Promise<boolean | FetchError>;
-}
+export declare function decodeTelegramCallbackQueryBody<T>(data?: string): CallbackQueryBody<T>;
 
-declare class Delete extends Child {
-    chatPhoto(chatID: bigint, parameters?: Partial<DeleteChatPhoto>): Promise<boolean | FetchError>;
-    chatStickerSet(chatID: bigint, parameters?: Partial<DeleteChatStickerSet>): Promise<boolean | FetchError>;
-    commands(parameters?: Partial<DeleteMyCommands>): Promise<boolean | FetchError>;
-    forumTopic(chatID: bigint, messageThreadID: number, parameters?: Partial<DeleteForumTopic>): Promise<boolean | FetchError>;
-    message(chatID: bigint, messageID: number, parameters?: Partial<DeleteMessage>): Promise<boolean | FetchError>;
-    messages(chatID: bigint, messageIDs: number[], parameters?: Partial<DeleteMessages>): Promise<boolean | FetchError>;
-    stickerFromSet(sticker: string, parameters?: Partial<DeleteStickerFromSet>): Promise<boolean | FetchError>;
-    stickerSet(name: string, parameters?: Partial<DeleteStickerSet>): Promise<boolean | FetchError>;
-}
+export declare function decodeTelegramReplyToMessageBody<T>(entities: MessageEntity[]): ReplyToMessageBody<T>;
 
-declare class Download extends Child {
-    api: API;
-    file(id: string): Promise<Buffer | FetchError>;
-    userFirstProfilePhoto(id: bigint): Promise<Buffer | FetchError | Error>;
-}
+export declare function decodeTelegramStartBody<T>(text: string | undefined): StartBody<T>;
 
-declare class Edit extends Child {
-    chatInviteLink(chatID: bigint, inviteLink: string, parameters?: Partial<EditChatInviteLink>): Promise<ChatInviteLink | FetchError>;
-    chatSubscriptionInviteLInk(chatID: bigint, inviteLink: string, parameters?: Partial<EditChatSubscriptionInviteLink>): Promise<ChatInviteLink | FetchError>;
-    forumTopic(chatID: bigint, messageThreadID: number, parameters?: Partial<EditForumTopic>): Promise<boolean | FetchError>;
-    generalForumTopic(chatID: bigint, name: string, parameters?: Partial<EditGeneralForumTopic>): Promise<boolean | FetchError>;
-    messageCaption(parameters: EditMessageCaption): Promise<Message | FetchError>;
-    messageLiveLocation(parameters: EditMessageLiveLocation): Promise<Message | FetchError>;
-    messageMedia(media: InputMedia, parameters?: Partial<EditMessageMedia>): Promise<Message | FetchError>;
-    messageReplyMarkup(parameters: EditMessageReplyMarkup): Promise<Message | FetchError>;
-    messageText(text: string, parameters?: Partial<EditMessageText>): Promise<Message | FetchError>;
-}
+export declare const DEFAULT_TELEGRAM_ALLOWED_UPDATES: string[];
 
-declare class Export extends Child {
-    chatInviteLink(chatID: bigint, parameters?: Partial<ExportChatInviteLink>): Promise<string | FetchError>;
-}
+export declare const DEFAULT_TELEGRAM_CALLBACK_QUERY_BODY: () => CallbackQueryBody<any>;
 
-declare class Forward extends Child {
-    message(messageID: number, parameters: Omit<ForwardMessage, 'message_id'>): Promise<Message | FetchError>;
-    messages(messageIDs: number[], parameters: Omit<ForwardMessages, 'message_ids'>): Promise<MessageId[] | FetchError>;
-}
+export declare const DEFAULT_TELEGRAM_CLIENT_LISTENER_OPTIONS: () => TelegramClientListenerOptions;
 
-declare class Get extends Child {
-    businessConnection(businessConnectionID: string, parameters?: Partial<GetBusinessConnection>): Promise<BusinessConnection | FetchError>;
-    chat(chatID: bigint, parameters?: Partial<GetChat>): Promise<Chat | FetchError>;
-    chatAdministrators(chatID: bigint, parameters?: Partial<GetChatAdministrators>): Promise<ChatMember[] | FetchError>;
-    chatMember(parameters: GetChatMember): Promise<ChatMember | FetchError>;
-    chatMemberCount(chatID: bigint, parameters?: Partial<GetChatMemberCount>): Promise<bigint | FetchError>;
-    chatMenuButton(chatID: bigint, parameters?: Partial<GetChatMenuButton>): Promise<MenuButton | FetchError>;
-    commands(parameters?: Partial<GetMyCommands>): Promise<BotCommand[] | FetchError>;
-    customEmojiStickers(customEmojiIDs: string[], parameters?: Partial<GetCustomEmojiStickers>): Promise<Sticker[] | FetchError>;
-    defaultAdministratorRights(parameters?: Partial<GetMyDefaultAdministratorRights>): Promise<ChatAdministratorRights | FetchError>;
-    description(parameters?: Partial<GetMyDescription>): Promise<BotDescription | FetchError>;
-    file(fileID: string, parameters?: Partial<GetFile>): Promise<File_2 | FetchError>;
-    forumTopicIconStickers(): Promise<Sticker[] | FetchError>;
-    gameHighScores(userID: bigint, parameters?: Partial<GetGameHighScores>): Promise<GameHighScore | FetchError>;
-    me(): Promise<User | FetchError>;
-    name(parameters?: Partial<GetMyName>): Promise<BotName | FetchError>;
-    shortDescription(parameters?: Partial<GetMyShortDescription>): Promise<BotShortDescription | FetchError>;
-    starTransactions(parameters?: Partial<GetStarTransactions>): Promise<StarTransactions | FetchError>;
-    stickerSet(name: string, parameters?: Partial<GetStickerSet>): Promise<StickerSet | FetchError>;
-    updates(parameters?: Partial<GetUpdates>): Promise<Update[] | FetchError>;
-    userChatBoosts(parameters: GetUserChatBoosts): Promise<UserChatBoosts | FetchError>;
-    userProfilePhotos(userID: bigint, parameters?: Partial<GetUserProfilePhotos>): Promise<UserProfilePhotos | FetchError>;
-}
+export declare const DEFAULT_TELEGRAM_CLIENT_POLLING_MS: number;
 
-export declare interface Handler<T extends UpdateType = any, U extends HandlerOptions = HandlerOptions> {
-    description?: string;
-    id: string;
-    key?: string;
-    middleware: HandlerMiddleware<T>;
-    options: U;
-    type: UpdateType;
-}
+export declare const DEFAULT_TELEGRAM_REPLY_TO_MESSAGE_BODY: () => ReplyToMessageBody<any>;
 
-export declare type HandlerMiddleware<T extends UpdateType> = (context: Context[T]) => any;
+export declare const DEFAULT_TELEGRAM_START_MESSAGE_BODY: () => StartBody<any>;
 
-export declare interface HandlerOptions {
-    deleteOnCallbackQuery?: boolean;
-    deleteOnReply?: boolean;
-    deleteOnMessageStart?: boolean;
+export declare function deleteTelegramChatPhoto(token: string, body: DeleteChatPhoto): Promise<boolean | FetchError>;
+
+export declare function deleteTelegramChatStickerSet(token: string, body: DeleteChatStickerSet): Promise<boolean | FetchError>;
+
+export declare function deleteTelegramCommands(token: string, body?: DeleteMyCommands): Promise<boolean | FetchError>;
+
+export declare function deleteTelegramForumTopic(token: string, body: DeleteForumTopic): Promise<boolean | FetchError>;
+
+export declare function deleteTelegramMessage(token: string, body: DeleteMessage): Promise<boolean | FetchError>;
+
+export declare function deleteTelegramMessages(token: string, body: DeleteMessages): Promise<boolean | FetchError>;
+
+export declare function deleteTelegramStickerFromSet(token: string, body: DeleteStickerFromSet): Promise<boolean | FetchError>;
+
+export declare function deleteTelegramStickerSet(token: string, body: DeleteStickerSet): Promise<boolean | FetchError>;
+
+export declare function deleteTelegramWebhook(token: string, body?: DeleteWebhook): Promise<boolean | FetchError>;
+
+export declare function downloadTelegramFile(token: string, fileID: string): Promise<Blob | FetchError>;
+
+export declare function downloadTelegramUserFirstProfilePhoto(token: string, userID: bigint | number): Promise<Blob | FetchError | Error>;
+
+export declare interface EditMessageMediaAlternative extends Omit<EditMessageMedia, 'media'> {
+    media: InputMediaAlternative;
 }
 
-declare class Hide extends Child {
-    generalForumTopic(chatID: bigint, parameters?: Partial<HideGeneralForumTopic>): Promise<boolean | FetchError>;
+export declare function editTelegramChatInviteLink(token: string, body: EditChatInviteLink): Promise<ChatInviteLink | FetchError>;
+
+export declare function editTelegramChatSubscriptionInviteLink(token: string, body: EditChatSubscriptionInviteLink): Promise<ChatInviteLink | FetchError>;
+
+export declare function editTelegramForumTopic(token: string, body: EditForumTopic): Promise<boolean | FetchError>;
+
+export declare function editTelegramGeneralForumTopic(token: string, body: EditGeneralForumTopic): Promise<boolean | FetchError>;
+
+export declare function editTelegramMessageCaption(token: string, body: EditMessageCaption): Promise<Message | FetchError>;
+
+export declare function editTelegramMessageLiveLocation(token: string, body: EditMessageLiveLocation): Promise<Message | FetchError>;
+
+export declare function editTelegramMessageMedia(token: string, body: EditMessageMediaAlternative): Promise<Message | FetchError>;
+
+export declare function editTelegramMessageReplyMarkup(token: string, body: EditMessageReplyMarkup): Promise<Message | FetchError>;
+
+export declare function editTelegramMessageText(token: string, body: EditMessageText): Promise<Message | FetchError>;
+
+export declare function encodeTelegramCallbackQueryBody<T>(data: T, options?: EncodeTelegramCallbackQueryBodyOptions): string;
+
+export declare interface EncodeTelegramCallbackQueryBodyOptions {
+    chatID?: bigint | number;
+    command?: string;
 }
 
-export declare class HTMLUtils {
-    static tags: string[];
-    static sanitize(text: string): string;
-    static progress(value: number, min?: number, max?: number, size?: number): string;
+export declare function encodeTelegramReplyToMessageBody<T>(data: T, options?: EncodeTelegramReplyToMessageBodyOptions): string;
+
+export declare interface EncodeTelegramReplyToMessageBodyOptions {
+    chatID?: bigint | number;
+    command?: string;
 }
 
-export declare class InlineKeyboardUtils {
-    static getButtonsType(buttons: InlineKeyboardButton[]): string;
+export declare function encodeTelegramReplyToMessageBodyToAnchorTag<T>(data: T, options?: EncodeTelegramReplyToMessageBodyOptions): string;
+
+export declare function encodeTelegramReplyToMessageBodyToURL<T>(data: T, options?: EncodeTelegramReplyToMessageBodyOptions): string;
+
+export declare function encodeTelegramStartBody<T>(data: T, options?: EncodeTelegramStartBodyOptions): string;
+
+export declare interface EncodeTelegramStartBodyOptions {
+    chatID?: bigint | number;
+    command?: string;
 }
 
+export declare function encodeTelegramStartBodyToAnchorTag<T>(username: string, children: string, data: T, options?: EncodeTelegramStartBodyOptions): string;
+
+export declare function encodeTelegramStartBodyToText<T>(data: T, options?: EncodeTelegramStartBodyOptions): string;
+
+export declare function encodeTelegramStartBodyToURL<T>(username: string, data: T, options?: EncodeTelegramStartBodyOptions): string;
+
+export declare function exportTelegramChatInviteLink(token: string, body: ExportChatInviteLink): Promise<string | FetchError>;
+
+export declare function forwardTelegramMessage(token: string, body: ForwardMessage): Promise<Message | FetchError>;
+
+export declare function forwardTelegramMessages(token: string, body: ForwardMessages): Promise<MessageId[] | FetchError>;
+
+export declare function getMyTelegramCommands(token: string, body?: GetMyCommands): Promise<BotCommand[] | FetchError>;
+
+export declare function getMyTelegramDefaultAdministratorRights(token: string, body?: GetMyDefaultAdministratorRights): Promise<ChatAdministratorRights | FetchError>;
+
+export declare function getMyTelegramDescription(token: string, body?: GetMyDescription): Promise<BotDescription | FetchError>;
+
+export declare function getMyTelegramName(token: string, body?: GetMyName): Promise<BotName | FetchError>;
+
+export declare function getMyTelegramShortDescription(token: string, body?: GetMyShortDescription): Promise<BotShortDescription | FetchError>;
+
+export declare function getTelegramBusinessConnection(token: string, body: GetBusinessConnection): Promise<BusinessConnection | FetchError>;
+
+export declare function getTelegramChat(token: string, body: GetChat): Promise<Chat | FetchError>;
+
+export declare function getTelegramChatAdministrators(token: string, body: GetChatAdministrators): Promise<ChatMember[] | FetchError>;
+
+export declare function getTelegramChatMember(token: string, body: GetChatMember): Promise<ChatMember | FetchError>;
+
+export declare function getTelegramChatMemberCount(token: string, body: GetChatMemberCount): Promise<number | FetchError>;
+
+export declare function getTelegramChatMenuButton(token: string, body: GetChatMenuButton): Promise<MenuButton | FetchError>;
+
+export declare function getTelegramCommand(string: string | undefined): string | undefined;
+
+export declare function getTelegramCommandByContext<T extends UpdateType>(context: Context_2[T]): string | undefined;
+
+export declare function getTelegramContextChat<T extends UpdateType>(context: Context[T]): Chat | undefined;
+
+export declare function getTelegramContextChatID<T extends UpdateType>(context: Context[T]): bigint | number | undefined;
+
+export declare function getTelegramContextChatType<T extends UpdateType>(context: Context[T]): string | undefined;
+
+export declare function getTelegramContextUser<T extends UpdateType>(context: Context[T]): User | undefined;
+
+export declare function getTelegramContextUserFirstName<T extends UpdateType>(context: Context[T]): string | undefined;
+
+export declare function getTelegramContextUserID<T extends UpdateType>(context: Context[T]): bigint | number | undefined;
+
+export declare function getTelegramContextUserLastName<T extends UpdateType>(context: Context[T]): string | undefined;
+
+export declare function getTelegramContextUserUsername<T extends UpdateType>(context: Context[T]): string | undefined;
+
+export declare function getTelegramCustomEmojiStickers(token: string, body: GetCustomEmojiStickers): Promise<Sticker[] | FetchError>;
+
+export declare function getTelegramFile(token: string, body: GetFile): Promise<File_2 | FetchError>;
+
+export declare function getTelegramForumTopicIconStickers(token: string): Promise<Sticker[] | FetchError>;
+
+export declare function getTelegramGameHighScores(token: string, body: GetGameHighScores): Promise<GameHighScore[] | FetchError>;
+
+export declare function getTelegramInlineKeyboardCallbackButton<T>(text: string, data: T, options?: EncodeTelegramCallbackQueryBodyOptions): InlineKeyboardButton;
+
+export declare function getTelegramInlineKeyboardGameButton(text: string, game: string): InlineKeyboardButton;
+
+export declare function getTelegramInlineKeyboardLoginButton(text: string, url: string, fields?: Partial<LoginUrl>): InlineKeyboardButton;
+
+export declare function getTelegramInlineKeyboardPayButton(text: string): InlineKeyboardButton;
+
+export declare function getTelegramInlineKeyboardQueryButton(text: string, query: string): InlineKeyboardButton;
+
+export declare function getTelegramInlineKeyboardQueryChosenChatButton(text: string, query: SwitchInlineQueryChosenChat): InlineKeyboardButton;
+
+export declare function getTelegramInlineKeyboardQueryCurrentChatButton(text: string, query: string): InlineKeyboardButton;
+
+export declare function getTelegramInlineKeyboardTextButton(text: string): InlineKeyboardButton;
+
+export declare function getTelegramInlineKeyboardUrlButton(text: string, url: string): InlineKeyboardButton;
+
+export declare function getTelegramInlineKeyboardWebAppButton(text: string, app: WebAppInfo): InlineKeyboardButton;
+
+export declare function getTelegramMe(token: string): Promise<User | FetchError>;
+
+export declare function getTelegramProgressHTML(value: number, min?: number, max?: number, size?: number): string;
+
+export declare function getTelegramStarTransactions(token: string, body?: GetStarTransactions): Promise<StarTransactions | FetchError>;
+
+export declare function getTelegramStickerSet(token: string, body: GetStickerSet): Promise<StickerSet | FetchError>;
+
+export declare function getTelegramUpdates(token: string, body?: GetUpdates): Promise<Update[] | FetchError>;
+
+export declare function getTelegramUserChatBoosts(token: string, body: GetUserChatBoosts): Promise<UserChatBoosts | FetchError>;
+
+export declare function getTelegramUserProfilePhotos(token: string, body: GetUserProfilePhotos): Promise<UserProfilePhotos | FetchError>;
+
+export declare function getTelegramWebhookInfo(token: string): Promise<WebhookInfo | FetchError>;
+
+export declare function hideTelegramGeneralForumTopic(token: string, body: HideGeneralForumTopic): Promise<boolean | FetchError>;
+
 export declare type InputFile = File | string;
 
-declare interface InputMediaAlternative extends Omit<InputMediaAudio | InputMediaDocument | InputMediaPhoto | InputMediaVideo, 'media'> {
+export declare interface InputMediaAlternative extends Omit<InputMediaAudio | InputMediaDocument | InputMediaPhoto | InputMediaVideo, 'media'> {
     media: InputFile;
 }
 
-declare interface InputPaidMediaAlternative extends Omit<InputMediaPhoto | InputMediaVideo, 'media'> {
+export declare interface InputPaidMediaAlternative extends Omit<InputMediaPhoto | InputMediaVideo, 'media'> {
     media: InputFile;
 }
 
-declare class Leave extends Child {
-    chat(chatID: bigint, parameters?: Partial<LeaveChat>): Promise<boolean | FetchError>;
-}
+export declare function leaveTelegramChat(token: string, body: LeaveChat): Promise<boolean | FetchError>;
 
-declare class Log extends Child {
-    out(): Promise<boolean | FetchError>;
-}
+export declare function logOutTelegram(token: string): Promise<boolean | FetchError>;
 
-export declare interface MessageBody<T = any> {
-    chatID?: bigint;
-    data: T;
-    type: string;
-}
+export declare function omitTelegramCommand(string: string | undefined): string;
 
-declare class Pin extends Child {
-    chatMessage(chatID: bigint, messageID: number, parameters?: Partial<PinChatMessage>): Promise<boolean | FetchError>;
-}
+export declare function pinTelegramChatMessage(token: string, body: PinChatMessage): Promise<boolean | FetchError>;
 
-declare class Polling extends Child {
-    active: boolean;
-    offset: number;
-    start(ms?: number, parameters?: Partial<GetUpdates>): void;
-    stop(): void;
-    private get;
-}
+export declare function promoteTelegramChatMember(token: string, body: PromoteChatMember): Promise<boolean | FetchError>;
 
-declare class Promote extends Child {
-    chatMember(parameters: PromoteChatMember): Promise<boolean | FetchError>;
-}
+export declare function refundTelegramStarPayment(token: string, body: RefundStarPayment): Promise<boolean | FetchError>;
 
-declare class Refund extends Child {
-    starPayment(userID: bigint, telegramPaymentChargeID: string, parameters?: Partial<RefundStarPayment>): Promise<boolean | FetchError>;
-}
+export declare const REGEXP_TELEGRAM_COMMAND: RegExp;
 
-declare class Reopen extends Child {
-    forumTopic(chatID: bigint, messageThreadID: number, parameters?: Partial<ReopenForumTopic>): Promise<boolean | FetchError>;
-    generalForumTopic(chatID: bigint, parameters?: Partial<ReopenGeneralForumTopic>): Promise<boolean | FetchError>;
-}
+export declare const REGEXP_TELEGRAM_COMMAND_WITH_USERNAME: RegExp;
 
-declare class Replace extends Child {
-    stickerInSet(userID: bigint, sticker: InputSticker, parameters: Omit<ReplaceStickerInSet, 'sticker' | 'user_id'>): Promise<boolean | FetchError>;
-}
+export declare function reopenTelegramForumTopic(token: string, body: ReopenForumTopic): Promise<boolean | FetchError>;
 
-export declare interface ReplyToMessage<T = any> extends Message {
-    body: MessageBody<T>;
-}
+export declare function reopenTelegramGeneralForumTopic(token: string, body: ReopenGeneralForumTopic): Promise<boolean | FetchError>;
 
-export declare class ReplyToMessageUtils {
-    static decodeBody<T>(entities: MessageEntity[]): MessageBody<T>;
-    static encodeBody<T>(data: T, type: string, chatID?: bigint): string;
-}
+export declare function replaceTelegramStickerInSet(token: string, body: ReplaceStickerInSet): Promise<boolean | FetchError>;
 
-declare class Restrict extends Child {
-    chatMember(permissions: ChatPermissions, parameters: Omit<RestrictChatMember, 'permissions'>): Promise<boolean | FetchError>;
+export declare interface ReplyToMessage<T = unknown> extends Message {
+    body: ReplyToMessageBody<T>;
 }
 
-declare class Revoke extends Child {
-    chatInviteLink(chatID: bigint, inviteLink: string, parameters?: Partial<RevokeChatInviteLink>): Promise<ChatInviteLink | FetchError>;
+export declare interface ReplyToMessageBody<T = unknown> {
+    c?: bigint | number;
+    d: T;
+    m?: string;
 }
 
-declare class Send extends Child {
-    private: SendPrivate;
-    animation(chatID: bigint, file: InputFile, parameters?: Partial<SendAnimation>): Promise<Message | FetchError>;
-    audio(chatID: bigint, file: InputFile, parameters?: Partial<SendAudio>): Promise<Message | FetchError>;
-    document(chatID: bigint, file: InputFile, parameters?: Partial<SendDocument>): Promise<Message | FetchError>;
-    buttons(chatID: bigint, text: string, buttons: InlineKeyboardButton[], parameters?: Partial<SendMessage>): Promise<Message | FetchError | Error>;
-    chatAction(chatID: bigint, action: string, parameters?: Partial<SendChatAction>): Promise<boolean | FetchError>;
-    contact(chatID: bigint, parameters: Omit<SendContact, 'chat_id'>): Promise<Message | FetchError>;
-    dice(chatID: bigint, parameters?: Partial<SendDice>): Promise<Message | FetchError>;
-    game(chatID: bigint, gameShortName: string, parameters?: Partial<SendGame>): Promise<Message | FetchError>;
-    html(chatID: bigint, text: string, parameters?: Partial<SendMessage>): Promise<Message | FetchError>;
-    invoice(chatID: bigint, prices: LabeledPrice[], parameters: Omit<SendInvoice, 'chat_id' | 'prices'>): Promise<Message | FetchError>;
-    location(chatID: bigint, parameters: Omit<SendLocation, 'chat_id'>): Promise<Message | FetchError>;
-    mediaGroup(chatID: bigint, media: InputMediaAlternative[], parameters?: Partial<SendMediaGroup>): Promise<Message | FetchError>;
-    message(chatID: bigint, text: string, parameters?: Partial<SendMessage>): Promise<Message | FetchError>;
-    paidMedia(chatID: bigint, media: InputPaidMediaAlternative[], stars: number, parameters?: Partial<SendPaidMedia>): Promise<Message | FetchError>;
-    photo(chatID: bigint, file: InputFile, parameters?: Partial<SendPhoto>): Promise<Message | FetchError>;
-    poll(chatID: bigint, question: string, options: InputPollOption[], parameters?: Partial<SendPoll>): Promise<Message | FetchError>;
-    repliable<T>(chatID: bigint, data: T, parameters: Omit<SendRepliable, 'chat_id' | 'data'>): Promise<Message | FetchError>;
-    sticker(chatID: bigint, file: InputFile, parameters?: Partial<SendSticker>): Promise<Message | FetchError>;
-    venue(chatID: bigint, parameters: Omit<SendVenue, 'chat_id'>): Promise<Message | FetchError>;
-    video(chatID: bigint, file: InputFile, parameters?: Partial<SendVideo>): Promise<Message | FetchError>;
-    videoNote(chatID: bigint, file: InputFile, parameters?: Partial<SendVideoNote>): Promise<Message | FetchError>;
-    voice(chatID: bigint, file: InputFile, parameters?: Partial<SendVoice>): Promise<Message | FetchError>;
-    private file;
+export declare function restrictTelegramChatMember(token: string, body: RestrictChatMember): Promise<boolean | FetchError>;
+
+export declare function revokeTelegramChatInviteLink(token: string, body: RevokeChatInviteLink): Promise<ChatInviteLink | FetchError>;
+
+export declare function sanitizeTelegramHTML(text: string): string;
+
+declare interface SendMediaGroupAlternative extends Omit<SendMediaGroup, 'media'> {
+    media: InputMediaAlternative[];
 }
 
-declare class SendPrivate extends Child {
-    buttons(chatIDs: [bigint, bigint], text: string, buttons: InlineKeyboardButton[], parameters?: Partial<SendMessage>): Promise<Message | FetchError | Error>;
-    repliable<T>(chatIDs: [bigint, bigint], data: T, parameters: Omit<SendRepliable, 'chat_id' | 'data' | 'from_chat_id'>): Promise<Message | FetchError | Error>;
+declare interface SendPaidMediaAlternative extends Omit<SendPaidMedia, 'media'> {
+    media: InputPaidMediaAlternative[];
 }
 
-declare interface SendRepliable<T = any> extends SendMessage {
+export declare interface SendRepliableMessage<T = unknown> extends SendMessage {
+    command?: string;
     data: T;
     from_chat_id?: bigint;
-    text: string;
-    type: string;
 }
 
-declare class Set_2 extends Child {
-    chatAdministratorCustomTitle(customTitle: string, parameters: Omit<SetChatAdministratorCustomTitle, 'custom_title'>): Promise<boolean | FetchError>;
-    chatDescription(chatID: bigint, description?: string, parameters?: Partial<SetChatDescription>): Promise<boolean | FetchError>;
-    chatMenuButton(chatID: bigint, menuButton?: MenuButton, parameters?: Partial<SetChatMenuButton>): Promise<boolean | FetchError>;
-    chatPermissions(chatID: bigint, permissions: ChatPermissions, parameters?: Partial<SetChatPermissions>): Promise<boolean | FetchError>;
-    chatPhoto(chatID: bigint, photo: InputFile, parameters?: Partial<SetChatPhoto>): Promise<boolean | FetchError>;
-    chatStickerSet(chatID: bigint, stickerSetName: string, parameters?: Partial<SetChatStickerSet>): Promise<boolean | FetchError>;
-    chatTitle(chatID: bigint, title: string, parameters?: Partial<SetChatTitle>): Promise<boolean | FetchError>;
-    commands(commands: BotCommand[], parameters?: Partial<SetMyCommands>): Promise<boolean | FetchError>;
-    customEmojiStickerSetThumbnail(name: string, customEmojiID?: string, parameters?: Partial<SetCustomEmojiStickerSetThumbnail>): Promise<boolean | FetchError>;
-    defaultAdministratorRights(rights: ChatAdministratorRights, parameters?: Partial<SetMyDefaultAdministratorRights>): Promise<boolean | FetchError>;
-    description(description?: string, parameters?: Partial<SetMyDescription>): Promise<boolean | FetchError>;
-    gameScore(userID: bigint, score: number, parameters?: Partial<SetGameScore>): Promise<boolean | FetchError>;
-    messageReaction(chatID: bigint, messageID: number, reaction: ReactionType[], parameters?: Partial<SetMessageReaction>): Promise<boolean | FetchError>;
-    name(name?: string, parameters?: Partial<SetMyName>): Promise<boolean | FetchError>;
-    passportDataErrors(userID: bigint, errors: PassportElementError[], parameters?: Partial<SetPassportDataErrors>): Promise<boolean | FetchError>;
-    shortDescription(shortDescription?: string, parameters?: Partial<SetMyShortDescription>): Promise<boolean | FetchError>;
-    stickerEmojiList(sticker: string, emojis: string[], parameters?: Partial<SetStickerEmojiList>): Promise<boolean | FetchError>;
-    stickerKeywords(sticker: string, keywords?: string[], parameters?: Partial<SetStickerKeywords>): Promise<boolean | FetchError>;
-    stickerMaskPosition(sticker: string, maskPosition?: MaskPosition, parameters?: Partial<SetStickerMaskPosition>): Promise<boolean | FetchError>;
-    stickerPositionInSet(sticker: string, position: number, parameters?: Partial<SetStickerPositionInSet>): Promise<boolean | FetchError>;
-    stickerSetThumbnail(userID: bigint, parameters: Omit<SetStickerSetThumbnail, 'user_id'>): Promise<boolean | FetchError>;
-    stickerSetTitle(name: string, title: string, parameters?: Partial<SetStickerSetTitle>): Promise<boolean | FetchError>;
-}
+export declare function sendTelegramAnimation(token: string, body: SendAnimation): Promise<Message | FetchError>;
+
+export declare function sendTelegramAudio(token: string, body: SendAudio): Promise<Message | FetchError>;
+
+export declare function sendTelegramChatAction(token: string, body: SendChatAction): Promise<boolean | FetchError>;
+
+export declare function sendTelegramContact(token: string, body: SendContact): Promise<Message | FetchError>;
+
+export declare function sendTelegramDice(token: string, body: SendDice): Promise<Message | FetchError>;
+
+export declare function sendTelegramDocument(token: string, body: SendDocument): Promise<Message | FetchError>;
+
+export declare function sendTelegramGame(token: string, body: SendGame): Promise<Message | FetchError>;
+
+export declare function sendTelegramInvoice(token: string, body: SendInvoice): Promise<Message | FetchError>;
+
+export declare function sendTelegramLocation(token: string, body: SendLocation): Promise<Message | FetchError>;
+
+export declare function sendTelegramMediaGroup(token: string, body: SendMediaGroupAlternative): Promise<Message[] | FetchError>;
+
+export declare function sendTelegramMessage(token: string, body: SendMessage): Promise<Message | FetchError>;
+
+export declare function sendTelegramMessageHTML(token: string, body: SendMessage): Promise<Message | FetchError>;
+
+export declare function sendTelegramPaidMedia(token: string, body: SendPaidMediaAlternative): Promise<Message | FetchError>;
+
+export declare function sendTelegramPhoto(token: string, body: SendPhoto): Promise<Message | FetchError>;
+
+export declare function sendTelegramPoll(token: string, body: SendPoll): Promise<Message | FetchError>;
+
+export declare function sendTelegramRepliableMessage<T>(token: string, body: SendRepliableMessage<T>): Promise<Message | FetchError>;
+
+export declare function sendTelegramSticker(token: string, body: SendSticker): Promise<Message | FetchError>;
+
+export declare function sendTelegramVenue(token: string, body: SendVenue): Promise<Message | FetchError>;
+
+export declare function sendTelegramVideo(token: string, body: SendVideo): Promise<Message | FetchError>;
+
+export declare function sendTelegramVideoNote(token: string, body: SendVideoNote): Promise<Message | FetchError>;
 
-export declare interface Start<T = any> extends Message {
-    body: MessageBody<T>;
+export declare function sendTelegramVoice(token: string, body: SendVoice): Promise<Message | FetchError>;
+
+export declare function setMyTelegramCommands(token: string, body: SetMyCommands): Promise<boolean | FetchError>;
+
+export declare function setMyTelegramDefaultAdministratorRights(token: string, body: SetMyDefaultAdministratorRights): Promise<boolean | FetchError>;
+
+export declare function setMyTelegramDescription(token: string, body: SetMyDescription): Promise<boolean | FetchError>;
+
+export declare function setMyTelegramName(token: string, body: SetMyName): Promise<boolean | FetchError>;
+
+export declare function setMyTelegramShortDescription(token: string, body: SetMyShortDescription): Promise<boolean | FetchError>;
+
+export declare function setTelegramChatAdministratorCustomTitle(token: string, body: SetChatAdministratorCustomTitle): Promise<boolean | FetchError>;
+
+export declare function setTelegramChatDescription(token: string, body: SetChatDescription): Promise<boolean | FetchError>;
+
+export declare function setTelegramChatMenuButton(token: string, body: SetChatMenuButton): Promise<boolean | FetchError>;
+
+export declare function setTelegramChatPermissions(token: string, body: SetChatPermissions): Promise<boolean | FetchError>;
+
+export declare function setTelegramChatPhoto(token: string, body: SetChatPhoto): Promise<boolean | FetchError>;
+
+export declare function setTelegramChatStickerSet(token: string, body: SetChatStickerSet): Promise<boolean | FetchError>;
+
+export declare function setTelegramChatTitle(token: string, body: SetChatTitle): Promise<boolean | FetchError>;
+
+export declare function setTelegramCustomEmojiStickerSetThumbnail(token: string, body: SetCustomEmojiStickerSetThumbnail): Promise<boolean | FetchError>;
+
+export declare function setTelegramGameScore(token: string, body: SetGameScore): Promise<boolean | FetchError>;
+
+export declare function setTelegramMessageReaction(token: string, body: SetMessageReaction): Promise<boolean | FetchError>;
+
+export declare function setTelegramPassportDataErrors(token: string, body: SetPassportDataErrors): Promise<boolean | FetchError>;
+
+export declare function setTelegramStickerEmojiList(token: string, body: SetStickerEmojiList): Promise<boolean | FetchError>;
+
+export declare function setTelegramStickerKeywords(token: string, body: SetStickerKeywords): Promise<boolean | FetchError>;
+
+export declare function setTelegramStickerMaskPosition(token: string, body: SetStickerMaskPosition): Promise<boolean | FetchError>;
+
+export declare function setTelegramStickerPositionInSet(token: string, body: SetStickerPositionInSet): Promise<boolean | FetchError>;
+
+export declare function setTelegramStickerSetThumbnail(token: string, body: SetStickerSetThumbnail): Promise<boolean | FetchError>;
+
+export declare function setTelegramStickerSetTitle(token: string, body: SetStickerSetTitle): Promise<boolean | FetchError>;
+
+export declare function setTelegramWebhook(token: string, body: SetWebhook): Promise<boolean | FetchError>;
+
+export declare interface Start<T = unknown> extends Message {
+    body: StartBody<T>;
 }
 
-export declare class StartUtils {
-    static decodeBody<T>(text?: string): MessageBody<T>;
-    static encodeBody<T>(data: T, type: string, chatID?: bigint): string;
-    static encodeBodyToHREF<T>(username: string, data: T, type: string, chatID?: bigint): string;
-    static encodeBodyToAnchorTag<T>(username: string, data: T, type: string, children: string, chatID?: bigint): string;
+export declare interface StartBody<T = unknown> {
+    c?: bigint | number;
+    d: T;
+    m?: string;
 }
 
-declare class Stop extends Child {
-    messageLiveLocation(parameters: StopMessageLiveLocation): Promise<Message | boolean | FetchError>;
-    poll(chatID: bigint, messageID: number, parameters?: Partial<StopPoll>): Promise<Poll | FetchError>;
+export declare function stopTelegramMessageLiveLocation(token: string, body: StopMessageLiveLocation): Promise<Message | boolean | FetchError>;
+
+export declare function stopTelegramPoll(token: string, body: StopPoll): Promise<Poll | FetchError>;
+
+export declare const TelegramAPI: API;
+
+export declare namespace TelegramApiDefinitions {
+    export interface Config extends RestApiConfig {
+        token: string | undefined;
+    }
+    export interface Response<T> extends FetchResponse<ResponseData<T>> {
+    }
+    export interface ResponseData<T> {
+        ok: boolean;
+        result: T;
+    }
 }
 
-export declare class Telegram {
-    /** INTERNAL */
-    api: API;
-    handlers: Handler[];
-    hostname: string;
-    id: bigint;
-    name: TelegramName;
-    port: number;
-    token: string;
-    username: string;
-    /** BUILDERS */
-    builder: Builder;
-    /** CHILDS */
-    add: Add;
-    answer: Answer;
-    approve: Approve;
-    ban: Ban;
-    close: Close;
-    copy: Copy;
-    create: Create;
-    decline: Decline;
-    delete: Delete;
-    download: Download;
-    edit: Edit;
-    export: Export;
-    forward: Forward;
-    get: Get;
-    hide: Hide;
-    leave: Leave;
-    log: Log;
-    pin: Pin;
-    polling: Polling;
-    promote: Promote;
-    refund: Refund;
-    reopen: Reopen;
-    replace: Replace;
-    restrict: Restrict;
-    revoke: Revoke;
-    send: Send;
-    set: Set_2;
-    stop: Stop;
-    unban: Unban;
-    unhide: Unhide;
-    unpin: Unpin;
-    upload: Upload;
-    webhook: Webhook;
-    constructor(token: string, hostname?: string, port?: number);
-    on<T extends UpdateType, U extends HandlerOptions>(type: T, middleware: HandlerMiddleware<T>, key?: string, description?: string, options?: U): void;
+export declare const TelegramClassLogger: Logger;
+
+export declare class TelegramClient {
+    protected listeners: TelegramClientListener[];
+    protected readonly id: string;
+    protected offset?: number;
+    protected token: string;
+    constructor(token: string);
+    connect(mode: TelegramClientConnectionMode, options?: TelegramClientConnectionOptions): Promise<void | FetchError | Error>;
+    disconnect(options?: TelegramClientDisconnectOptions): Promise<void>;
+    on<T extends UpdateType, U extends TelegramClientListenerOptions>(type: T, middleware: TelegramClientListenerMiddleware<T>, options?: U): void;
     handle(update: Update): void;
-    handleCallbackQuery(query: CallbackQuery_2): Handler;
-    handleChannelPost(post: Message): Handler;
-    handleChatJoinRequest(request: ChatJoinRequest): Handler;
-    handleChatMember(member: ChatMemberUpdated): Handler;
-    handleChosenInlineResult(result: ChosenInlineResult): Handler;
-    handleDocument(document: Message): Handler;
-    handleEditedChannelPost(post: Message): Handler;
-    handleEditedMessage(message: Message): Handler;
-    handleInlineQuery(query: InlineQuery): Handler;
-    handleMessage(message: Message): Handler;
-    handleMyChatMember(member: ChatMemberUpdated): Handler;
-    handlePoll(poll: Poll): Handler;
-    handlePollAnswer(answer: PollAnswer): Handler;
-    handlePreCheckoutQuery(query: PreCheckoutQuery): Handler;
-    handleReplyToMessage(reply: Message): Handler;
-    handleShippingQuery(query: ShippingQuery): Handler;
-    handleStart(start: Message): Handler;
-    private findMatchingHandler;
-    get commands(): BotCommand[];
-    private get handlerIDs();
+    protected handleBusinessConnection(connection: BusinessConnection): TelegramClientListener | undefined;
+    protected handleBusinessMessage(message: Message): TelegramClientListener | undefined;
+    protected handleCallbackQuery(query: CallbackQuery_2): TelegramClientListener | undefined;
+    protected handleChannelPost(post: Message): TelegramClientListener | undefined;
+    protected handleChatBoost(boost: ChatBoostUpdated): TelegramClientListener | undefined;
+    protected handleChatJoinRequest(request: ChatJoinRequest): TelegramClientListener | undefined;
+    protected handleChatMember(member: ChatMemberUpdated): TelegramClientListener | undefined;
+    protected handleChosenInlineResult(result: ChosenInlineResult): TelegramClientListener | undefined;
+    protected handleDeletedBusinessMessages(deleted: BusinessMessagesDeleted): TelegramClientListener | undefined;
+    protected handleEditedBusinessMessage(message: Message): TelegramClientListener | undefined;
+    protected handleEditedChannelPost(post: Message): TelegramClientListener | undefined;
+    protected handleEditedMessage(message: Message): TelegramClientListener | undefined;
+    protected handleInlineQuery(query: InlineQuery): TelegramClientListener | undefined;
+    protected handleMessage(message: Message): TelegramClientListener | undefined;
+    protected handleMessageReaction(reaction: MessageReactionUpdated): TelegramClientListener | undefined;
+    protected handleMessageReactionCount(count: MessageReactionCountUpdated): TelegramClientListener | undefined;
+    protected handleMyChatMember(member: ChatMemberUpdated): TelegramClientListener | undefined;
+    protected handlePoll(poll: Poll): TelegramClientListener | undefined;
+    protected handlePollAnswer(answer: PollAnswer): TelegramClientListener | undefined;
+    protected handlePreCheckoutQuery(query: PreCheckoutQuery): TelegramClientListener | undefined;
+    protected handleRemovedChatBoost(removed: ChatBoostRemoved): TelegramClientListener | undefined;
+    protected handleReplyToMessage(reply: Message): TelegramClientListener | undefined;
+    protected handleShippingQuery(query: ShippingQuery): TelegramClientListener | undefined;
+    protected handleStart(start: Message): TelegramClientListener | undefined;
+    protected poll(options?: TelegramClientConnectionOptionsPolling): Promise<void>;
+    protected findListener<T extends UpdateType, U extends TelegramClientListenerOptions>(type: UpdateType, command?: string): TelegramClientListener<T, U> | undefined;
+    getCommands(): BotCommand[];
+    getListeners(): TelegramClientListener[];
+    getToken(): string;
+    setToken(token: string): this;
+    protected get listenerIDs(): string[];
+}
+
+export declare type TelegramClientConnectionMode = 'polling' | 'webhook';
+
+export declare interface TelegramClientConnectionOptions {
+    polling?: TelegramClientConnectionOptionsPolling;
+    webhook?: TelegramClientConnectionOptionsWebhook;
+}
+
+export declare interface TelegramClientConnectionOptionsPolling extends GetUpdates {
+    ms?: number;
+}
+
+export declare interface TelegramClientConnectionOptionsWebhook extends SetWebhook {
+    delete?: DeleteWebhook;
+}
+
+export declare interface TelegramClientDisconnectOptions {
+    webhook?: DeleteWebhook;
+}
+
+export declare interface TelegramClientListener<T extends UpdateType = any, U extends TelegramClientListenerOptions = TelegramClientListenerOptions> {
+    command?: string;
+    description?: string;
+    id: string;
+    middleware: TelegramClientListenerMiddleware<T>;
+    options: Omit<U, 'command' | 'description'>;
+    type: UpdateType;
 }
 
-export declare const TelegramConfiguration: ConfigurationBuilder;
+export declare type TelegramClientListenerMiddleware<T extends UpdateType> = (context: Context[T]) => any;
 
-export declare enum TelegramLoggerName {
-    MODULE = "TELEGRAM_MODULE"
+export declare interface TelegramClientListenerOptions {
+    command?: string;
+    deleteOnCallbackQuery?: boolean;
+    deleteOnReply?: boolean;
+    deleteOnMessageStart?: boolean;
+    description?: string;
 }
 
-declare interface TelegramName {
-    first: string;
-    last: string;
-}
+export declare const TelegramFileAPI: API_2;
 
-declare class Unban extends Child {
-    chatMember(parameters: UnbanChatMember): Promise<boolean | FetchError>;
-    chatSenderChat(parameters: UnbanChatSenderChat): Promise<boolean | FetchError>;
+export declare enum TelegramLoggerName {
+    CLASS = "TELEGRAM_CLASS"
 }
 
-declare class Unhide extends Child {
-    generalForumTopic(chatID: bigint, parameters?: Partial<HideGeneralForumTopic>): Promise<boolean | FetchError>;
-}
+export declare function unbanTelegramChatMember(token: string, body: UnbanChatMember): Promise<boolean | FetchError>;
 
-declare class Unpin extends Child {
-    allChatMessages(chatID: bigint, parameters?: Partial<UnpinAllChatMessages>): Promise<boolean | FetchError>;
-    allForumTopicMessages(chatID: bigint, messageThreadID: number, parameters?: Partial<UnpinAllForumTopicMessages>): Promise<boolean | FetchError>;
-    allGeneralForumTopicMessages(chatID: bigint, parameters?: Partial<UnpinAllGeneralForumTopicMessages>): Promise<boolean | FetchError>;
-    chatMessage(chatID: bigint, parameters?: Partial<UnpinChatMessage>): Promise<boolean | FetchError>;
-}
+export declare function unbanTelegramChatSenderChat(token: string, body: UnbanChatSenderChat): Promise<boolean | FetchError>;
 
-export declare enum UpdateType {
-    CALLBACK_QUERY = "CALLBACK_QUERY",
-    CHANNEL_POST = "CHANNEL_POST",
-    CHAT_JOIN_REQUEST = "CHAT_JOIN_REQUEST",
-    CHAT_MEMBER = "CHAT_MEMBER",
-    CHOSEN_INLINE_RESULT = "CHOSEN_INLINE_RESULT",
-    DOCUMENT = "DOCUMENT",
-    EDITED_CHANNEL_POST = "EDITED_CHANNEL_POST",
-    EDITED_MESSAGE = "EDITED_MESSAGE",
-    INLINE_QUERY = "INLINE_QUERY",
-    MESSAGE = "MESSAGE",
-    MY_CHAT_MEMBER = "MY_CHAT_MEMBER",
-    POLL = "POLL",
-    POLL_ANSWER = "POLL_ANSWER",
-    PRE_CHECKOUT_QUERY = "PRE_CHECKOUT_QUERY",
-    REPLY_TO_MESSAGE = "REPLY_TO_MESSAGE",
-    SHIPPING_QUERY = "SHIPPING_QUERY",
-    START = "START"
-}
+export declare function unhideTelegramGeneralForumTopic(token: string, body: HideGeneralForumTopic): Promise<boolean | FetchError>;
 
-declare class Upload extends Child {
-    stickerFile(userID: bigint, parameters: Omit<UploadStickerFile, 'user_id'>): Promise<File_2 | FetchError>;
-}
+export declare function unpinAllTelegramChatMessages(token: string, body: UnpinAllChatMessages): Promise<boolean | FetchError>;
 
-declare class Webhook extends Child {
-    close(): Promise<boolean | FetchError>;
-    delete(parameters?: Partial<DeleteWebhook>): Promise<boolean | FetchError>;
-    getInfo(): Promise<WebhookInfo | FetchError>;
-    set(route?: string, parameters?: Partial<SetWebhook>): Promise<boolean | FetchError>;
-    url(route: string): string;
-}
+export declare function unpinAllTelegramForumTopicMessages(token: string, body: UnpinAllForumTopicMessages): Promise<boolean | FetchError>;
+
+export declare function unpinAllTelegramGeneralForumTopicMessages(token: string, body: UnpinAllGeneralForumTopicMessages): Promise<boolean | FetchError>;
+
+export declare function unpinTelegramChatMessage(token: string, body: UnpinChatMessage): Promise<boolean | FetchError>;
+
+export declare type UpdateType = 'business_connection' | 'business_message' | 'callback_query' | 'channel_post' | 'chat_boost' | 'chat_join_request' | 'chat_member' | 'chosen_inline_result' | 'deleted_business_messages' | 'edited_business_message' | 'edited_channel_post' | 'edited_message' | 'inline_query' | 'message' | 'message_reaction' | 'message_reaction_count' | 'my_chat_member' | 'poll' | 'poll_answer' | 'pre_checkout_query' | 'removed_chat_boost' | 'reply_to_message' | 'shipping_query' | 'start';
+
+export declare function uploadTelegramStickerFile(token: string, body: UploadStickerFile): Promise<File_2 | FetchError>;
 
 export { }