@aracna/telegram-bot 1.9.3

package/index.d.ts

@@ -0,0 +1,498 @@
+/// <reference types="node" />
+
+import { AddStickerToSet } from '@aracna/telegram-bot-types';
+import { AnswerCallbackQuery } from '@aracna/telegram-bot-types';
+import { AnswerInlineQuery } from '@aracna/telegram-bot-types';
+import { AnswerPreCheckoutQuery } from '@aracna/telegram-bot-types';
+import { AnswerShippingQuery } from '@aracna/telegram-bot-types';
+import { API as API_2 } from '@aracna/core';
+import { APIConfig } from '@aracna/core';
+import { BanChatMember } from '@aracna/telegram-bot-types';
+import { BotCommand } from '@aracna/telegram-bot-types';
+import { CallbackQuery as CallbackQuery_2 } from '@aracna/telegram-bot-types';
+import { Chat } from '@aracna/telegram-bot-types';
+import { ChatJoinRequest } from '@aracna/telegram-bot-types';
+import { ChatMember } from '@aracna/telegram-bot-types';
+import { ChatMemberUpdated } from '@aracna/telegram-bot-types';
+import { ChatPermissions } from '@aracna/telegram-bot-types';
+import { ChosenInlineResult } from '@aracna/telegram-bot-types';
+import { Context as Context_2 } from 'vm';
+import { CreateNewStickerSet } from '@aracna/telegram-bot-types';
+import { EditMessageCaption } from '@aracna/telegram-bot-types';
+import { EditMessageLiveLocation } from '@aracna/telegram-bot-types';
+import { EditMessageMedia } from '@aracna/telegram-bot-types';
+import { EditMessageReplyMarkup } from '@aracna/telegram-bot-types';
+import { EditMessageText } from '@aracna/telegram-bot-types';
+import { FetchError } from '@aracna/core';
+import { File as File_2 } from '@aracna/telegram-bot-types';
+import { ForwardMessage } from '@aracna/telegram-bot-types';
+import { GameHighScore } from '@aracna/telegram-bot-types';
+import { GetGameHighScores } from '@aracna/telegram-bot-types';
+import { GetUpdates } from '@aracna/telegram-bot-types';
+import { GetUserProfilePhotos } from '@aracna/telegram-bot-types';
+import { InlineKeyboardButton } from '@aracna/telegram-bot-types';
+import { InlineQuery } from '@aracna/telegram-bot-types';
+import { InlineQueryResult } from '@aracna/telegram-bot-types';
+import { InputMedia } from '@aracna/telegram-bot-types';
+import { InputMediaAudio } from '@aracna/telegram-bot-types';
+import { InputMediaDocument } from '@aracna/telegram-bot-types';
+import { InputMediaPhoto } from '@aracna/telegram-bot-types';
+import { InputMediaVideo } from '@aracna/telegram-bot-types';
+import { InputSticker } from '@aracna/telegram-bot-types';
+import { LabeledPrice } from '@aracna/telegram-bot-types';
+import { LoginUrl } from '@aracna/telegram-bot-types';
+import { Message } from '@aracna/telegram-bot-types';
+import { MessageEntity } from '@aracna/telegram-bot-types';
+import { PassportElementError } from '@aracna/telegram-bot-types';
+import { PinChatMessage } from '@aracna/telegram-bot-types';
+import { Poll } from '@aracna/telegram-bot-types';
+import { PollAnswer } from '@aracna/telegram-bot-types';
+import { PreCheckoutQuery } from '@aracna/telegram-bot-types';
+import { PromoteChatMember } from '@aracna/telegram-bot-types';
+import { RequestMethod } from '@aracna/core';
+import { RestrictChatMember } from '@aracna/telegram-bot-types';
+import { SendAnimation } from '@aracna/telegram-bot-types';
+import { SendAudio } from '@aracna/telegram-bot-types';
+import { SendContact } from '@aracna/telegram-bot-types';
+import { SendDice } from '@aracna/telegram-bot-types';
+import { SendDocument } from '@aracna/telegram-bot-types';
+import { SendGame } from '@aracna/telegram-bot-types';
+import { SendInvoice } from '@aracna/telegram-bot-types';
+import { SendLocation } from '@aracna/telegram-bot-types';
+import { SendMediaGroup } from '@aracna/telegram-bot-types';
+import { SendMessage } from '@aracna/telegram-bot-types';
+import { SendPhoto } from '@aracna/telegram-bot-types';
+import { SendPoll } from '@aracna/telegram-bot-types';
+import { SendSticker } from '@aracna/telegram-bot-types';
+import { SendVenue } from '@aracna/telegram-bot-types';
+import { SendVideo } from '@aracna/telegram-bot-types';
+import { SendVideoNote } from '@aracna/telegram-bot-types';
+import { SendVoice } from '@aracna/telegram-bot-types';
+import { SetGameScore } from '@aracna/telegram-bot-types';
+import { SetMyCommands } from '@aracna/telegram-bot-types';
+import { SetStickerSetThumbnail } from '@aracna/telegram-bot-types';
+import { SetWebhook } from '@aracna/telegram-bot-types';
+import { ShippingQuery } from '@aracna/telegram-bot-types';
+import { StickerSet } from '@aracna/telegram-bot-types';
+import { StopMessageLiveLocation } from '@aracna/telegram-bot-types';
+import { StopPoll } from '@aracna/telegram-bot-types';
+import { Update } from '@aracna/telegram-bot-types';
+import { User } from '@aracna/telegram-bot-types';
+import { UserProfilePhotos } from '@aracna/telegram-bot-types';
+
+declare class _ {
+    api: ConfigurationAPI;
+    default: ConfigurationDefault;
+    handler: ConfigurationHandler;
+}
+
+declare class Add extends Child {
+    stickerToSet(userID: number, name: string, sticker: InputSticker, parameters: Partial<AddStickerToSet>): Promise<Message | 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>;
+}
+
+declare class API extends API_2 {
+    post<V, W, X = undefined>(path: string, body?: W, config?: APIConfig<void>): Promise<V | FetchError<X>>;
+    transformBody<V>(method: RequestMethod, path: string, body: V, config: APIConfig<void>): Promise<FormData>;
+}
+
+declare class Ban extends Child {
+    chatMember(chatID: number, userID: number, parameters?: Partial<BanChatMember>): Promise<boolean | FetchError>;
+}
+
+declare class Builder {
+    button: ButtonBuilder;
+}
+
+declare class ButtonBuilder {
+    callback<T>(text: string, data: T, type: string, chatID?: number): 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;
+}
+
+export declare interface CallbackQuery<T = any> extends CallbackQuery_2 {
+    body: CallbackQueryBody<T>;
+}
+
+export declare interface CallbackQueryBody<T = any> {
+    c?: number;
+    d: T;
+    t: string;
+}
+
+export declare class CallbackQueryUtils {
+    static decodeBody<T>(data?: string): CallbackQueryBody<T>;
+    static encodeBody<T>(data: T, type: string, chatID?: number): string;
+}
+
+declare class Child {
+    protected telegram: Telegram;
+    constructor(telegram: Telegram);
+}
+
+export declare class CommandUtils {
+    static getByContext<T extends UpdateType>(context: Context_2[T]): string;
+    static get(string?: string): string;
+    static omit(string: string): string;
+}
+
+declare interface ConfigurationAPI {
+    post: {
+        callback: {
+            success: <T, U>(body: T, result: U | Error) => void;
+        };
+    };
+}
+
+declare interface ConfigurationDefault {
+    buttons: {
+        text: (chatID: number) => Promise<InlineKeyboardButton[]>;
+        url: (chatID: number) => Promise<InlineKeyboardButton[]>;
+        login: (chatID: number) => Promise<InlineKeyboardButton[]>;
+        callback: (chatID: number) => Promise<InlineKeyboardButton[]>;
+        query: (chatID: number) => Promise<InlineKeyboardButton[]>;
+        queryCurrentChat: (chatID: number) => Promise<InlineKeyboardButton[]>;
+        game: (chatID: number) => Promise<InlineKeyboardButton[]>;
+        pay: (chatID: number) => Promise<InlineKeyboardButton[]>;
+    };
+}
+
+declare interface ConfigurationHandler {
+    send: {
+        buttons: {
+            empty: (chatID: number) => Error;
+        };
+    };
+}
+
+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 class ContextUtils {
+    static getChatID<T extends UpdateType>(context: Context[T]): number;
+    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]): number;
+    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;
+}
+
+declare class Create extends Child {
+    stickerSet(userID: number, format: string, name: string, title: string, stickers: InputSticker[], parameters: Partial<CreateNewStickerSet>): Promise<boolean | FetchError>;
+}
+
+declare class Delete extends Child {
+    chatPhoto(chatID: number): Promise<boolean | FetchError>;
+    chatStickerSet(chatID: number): Promise<boolean | FetchError>;
+    message(chatID: number, message: number): Promise<boolean | FetchError>;
+    stickerFromSet(sticker: string): Promise<boolean | FetchError>;
+}
+
+declare class Download extends Child {
+    api: API;
+    file(id: string): Promise<Buffer | FetchError>;
+    userFirstProfilePhoto(id: number): Promise<Buffer | FetchError | Error>;
+}
+
+declare class Edit extends Child {
+    messageCaption(parameters: EditMessageCaption): Promise<Message | FetchError>;
+    messageLiveLocation(latitude: number, longitude: number, parameters: Partial<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>;
+}
+
+declare class Export extends Child {
+    chatInviteLink(chatID: number): Promise<string | FetchError>;
+}
+
+declare class Forward extends Child {
+    message(chatID: number, fromChatID: number, messageID: number, parameters?: Partial<ForwardMessage>): Promise<Message | FetchError>;
+}
+
+declare class Get extends Child {
+    chat(id: number): Promise<Chat | FetchError>;
+    chatAdministrators(id: number): Promise<ChatMember[] | FetchError>;
+    chatMember(chatID: number, userID: number): Promise<ChatMember | FetchError>;
+    chatMemberCount(id: number): Promise<number | FetchError>;
+    commands(): Promise<BotCommand[] | FetchError>;
+    file(id: string): Promise<File_2 | FetchError>;
+    gameHighScores(userID: number, parameters?: Partial<GetGameHighScores>): Promise<GameHighScore | FetchError>;
+    me(): Promise<User | FetchError>;
+    stickerSet(name: string): Promise<StickerSet | FetchError>;
+    userProfilePhotos(id: number, parameters?: Partial<GetUserProfilePhotos>): Promise<UserProfilePhotos | FetchError>;
+}
+
+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 type HandlerMiddleware<T extends UpdateType> = (context: Context[T]) => any;
+
+export declare interface HandlerOptions {
+    deleteOnCallbackQuery?: boolean;
+    deleteOnReply?: boolean;
+    deleteOnMessageStart?: boolean;
+}
+
+export declare class HTMLUtils {
+    static tags: string[];
+    static sanitize(text: string): string;
+    static progress(value: number, minimum?: number, maximum?: number, size?: number): string;
+}
+
+export declare class InlineKeyboardUtils {
+    static getButtonsType(buttons: InlineKeyboardButton[]): string;
+}
+
+export declare type InputFile = File | string;
+
+declare interface InputMediaAlternative extends Omit<InputMediaAudio | InputMediaDocument | InputMediaPhoto | InputMediaVideo, 'media'> {
+    media: InputFile;
+}
+
+declare class Leave extends Child {
+    chat(id: number): Promise<boolean | FetchError>;
+}
+
+export declare interface MessageBody<T = any> {
+    chatID?: number;
+    data: T;
+    type: string;
+}
+
+declare class Pin extends Child {
+    chatMessage(chatID: number, message: number, parameters?: Partial<PinChatMessage>): Promise<boolean | FetchError>;
+}
+
+declare class Polling extends Child {
+    active: boolean;
+    offset: number;
+    start(ms: number | undefined, parameters: Partial<GetUpdates>): void;
+    stop(): void;
+    private get;
+}
+
+declare class Promote extends Child {
+    chatMember(chatID: number, userID: number, parameters?: Partial<PromoteChatMember>): Promise<boolean | FetchError>;
+}
+
+export declare interface ReplyToMessage<T = any> extends Message {
+    body: MessageBody<T>;
+}
+
+export declare class ReplyToMessageUtils {
+    static decodeBody<T>(entities: MessageEntity[]): MessageBody<T>;
+    static encodeBody<T>(data: T, type: string, chatID?: number): string;
+}
+
+declare class Restrict extends Child {
+    chatMember(chatID: number, userID: number, permissions: ChatPermissions, parameters?: Partial<RestrictChatMember>): Promise<boolean | FetchError>;
+}
+
+declare class Send extends Child {
+    private: SendPrivate;
+    animation(chatID: number, file: InputFile, parameters?: Partial<SendAnimation>): Promise<Message | FetchError>;
+    audio(chatID: number, file: InputFile, parameters?: Partial<SendAudio>): Promise<Message | FetchError>;
+    document(chatID: number, file: InputFile, parameters?: Partial<SendDocument>): Promise<Message | FetchError>;
+    buttons(chatID: number, text: string, buttons: InlineKeyboardButton[], parameters?: Partial<SendMessage>): Promise<Message | FetchError | Error>;
+    chatAction(chatID: number, action: string): Promise<boolean | FetchError>;
+    contact(chatID: number, phoneNumber: string, firstName: string, parameters?: Partial<SendContact>): Promise<Message | FetchError>;
+    dice(chatID: number, parameters?: Partial<SendDice>): Promise<Message | FetchError>;
+    game(chatID: number, gameShortName: string, parameters?: Partial<SendGame>): Promise<Message | FetchError>;
+    html(chatID: number, text: string, parameters?: Partial<SendMessage>): Promise<Message | FetchError>;
+    invoice(chatID: number, title: string, description: string, payload: string, providerToken: string, startParameter: string, currency: string, prices: LabeledPrice[], parameters?: Partial<SendInvoice>): Promise<Message | FetchError>;
+    location(chatID: number, latitude: number, longitude: number, parameters?: Partial<SendLocation>): Promise<Message | FetchError>;
+    mediaGroup(chatID: number, media: InputMediaAlternative[], parameters?: Partial<SendMediaGroup>): Promise<Message | FetchError>;
+    message(chatID: number, text: string, parameters?: Partial<SendMessage>): Promise<Message | FetchError>;
+    photo(chatID: number, file: InputFile, parameters?: Partial<SendPhoto>): Promise<Message | FetchError>;
+    poll(chatID: number, question: string, options: string[], parameters?: Partial<SendPoll>): Promise<Message | FetchError>;
+    repliable<T>(chatID: number, text: string, data: T, type: string, parameters?: Partial<SendMessage>, fromChatID?: number): Promise<Message | FetchError>;
+    sticker(chatID: number, file: InputFile, parameters?: Partial<SendSticker>): Promise<Message | FetchError>;
+    venue(chatID: number, latitude: number, longitude: number, title: string, address: string, parameters?: Partial<SendVenue>): Promise<Message | FetchError>;
+    video(chatID: number, file: InputFile, parameters?: Partial<SendVideo>): Promise<Message | FetchError>;
+    videoNote(chatID: number, file: InputFile, parameters?: Partial<SendVideoNote>): Promise<Message | FetchError>;
+    voice(chatID: number, file: InputFile, parameters?: Partial<SendVoice>): Promise<Message | FetchError>;
+    private file;
+}
+
+declare class SendPrivate extends Child {
+    buttons(chatIDs: [number, number], text: string, buttons: InlineKeyboardButton[], parameters?: Partial<SendMessage>): Promise<Message | FetchError | Error>;
+    repliable<T>(chatIDs: [number, number], text: string, data: T, type: string, parameters?: Partial<SendMessage>): Promise<Message | FetchError | Error>;
+}
+
+declare class Set_2 extends Child {
+    chatAdministratorCustomTitle(chatID: number, userID: number, customTitle: string): Promise<boolean | FetchError>;
+    chatDescription(chatID: number, description: string): Promise<boolean | FetchError>;
+    chatPermissions(chatID: number, permissions: ChatPermissions): Promise<boolean | FetchError>;
+    chatPhoto(chatID: number, photo: InputFile): Promise<boolean | FetchError>;
+    chatStickerSet(chatID: number, stickerSetName: string): Promise<boolean | FetchError>;
+    chatTitle(chatID: number, title: string): Promise<boolean | FetchError>;
+    commands(commands: BotCommand[], parameters?: Partial<SetMyCommands>): Promise<boolean | FetchError>;
+    gameScore(userID: number, score: number, parameters?: Partial<SetGameScore>): Promise<boolean | FetchError>;
+    passportDataErrors(userID: number, errors: PassportElementError[]): Promise<boolean | FetchError>;
+    stickerPositionInSet(sticker: string, position: number): Promise<boolean | FetchError>;
+    stickerSetThumb(name: string, userID: number, parameters?: Partial<SetStickerSetThumbnail>): Promise<boolean | FetchError>;
+}
+
+export declare interface Start<T = any> extends Message {
+    body: MessageBody<T>;
+}
+
+export declare class StartUtils {
+    static decodeBody<T>(text?: string): MessageBody<T>;
+    static encodeBody<T>(data: T, type: string, chatID?: number): string;
+    static encodeBodyToHREF<T>(username: string, data: T, type: string, chatID?: number): string;
+    static encodeBodyToAnchorTag<T>(username: string, data: T, type: string, children: string, chatID?: number): string;
+}
+
+declare class Stop extends Child {
+    messageLiveLocation(parameters: StopMessageLiveLocation): Promise<Message | boolean | FetchError>;
+    poll(chatID: number, message: number, parameters?: Partial<StopPoll>): Promise<Poll | FetchError>;
+}
+
+export declare class Telegram {
+    /** INTERNAL */
+    api: API;
+    handlers: Handler[];
+    hostname: string;
+    id: number;
+    name: TelegramName;
+    port: number;
+    token: string;
+    username: string;
+    /** BUILDERS */
+    builder: Builder;
+    /** CHILDS */
+    add: Add;
+    answer: Answer;
+    create: Create;
+    delete: Delete;
+    download: Download;
+    edit: Edit;
+    export: Export;
+    forward: Forward;
+    get: Get;
+    ban: Ban;
+    leave: Leave;
+    pin: Pin;
+    polling: Polling;
+    promote: Promote;
+    restrict: Restrict;
+    send: Send;
+    set: Set_2;
+    stop: Stop;
+    unban: Unban;
+    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;
+    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();
+}
+
+export declare const TelegramConfiguration: _;
+
+export declare enum TelegramLoggerName {
+    MODULE = "TELEGRAM_MODULE"
+}
+
+declare interface TelegramName {
+    first: string;
+    last: string;
+}
+
+declare class Unban extends Child {
+    chatMember(chatID: number, userID: number): Promise<boolean | FetchError>;
+}
+
+declare class Unpin extends Child {
+    chatMessage(chatID: number): 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"
+}
+
+declare class Upload extends Child {
+    stickerFile(userID: number, format: string, sticker: InputFile): Promise<File_2 | FetchError>;
+}
+
+declare class Webhook extends Child {
+    delete(): Promise<boolean | FetchError>;
+    set(route?: string, parameters?: Partial<SetWebhook>): Promise<boolean | FetchError>;
+    url(route: string): string;
+}
+
+export { }

package/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartUtils = exports.ReplyToMessageUtils = exports.InlineKeyboardUtils = exports.HTMLUtils = exports.ContextUtils = exports.CommandUtils = exports.CallbackQueryUtils = exports.Telegram = exports.TelegramConfiguration = exports.UpdateType = exports.TelegramLoggerName = void 0;
+var enums_1 = require("./definitions/enums");
+Object.defineProperty(exports, "TelegramLoggerName", { enumerable: true, get: function () { return enums_1.LoggerName; } });
+Object.defineProperty(exports, "UpdateType", { enumerable: true, get: function () { return enums_1.UpdateType; } });
+var configuration_1 = require("./modules/configuration");
+Object.defineProperty(exports, "TelegramConfiguration", { enumerable: true, get: function () { return configuration_1.Configuration; } });
+var telegram_1 = require("./modules/telegram");
+Object.defineProperty(exports, "Telegram", { enumerable: true, get: function () { return telegram_1.Telegram; } });
+var callback_query_utils_1 = require("./utils/callback.query.utils");
+Object.defineProperty(exports, "CallbackQueryUtils", { enumerable: true, get: function () { return callback_query_utils_1.CallbackQueryUtils; } });
+var command_utils_1 = require("./utils/command.utils");
+Object.defineProperty(exports, "CommandUtils", { enumerable: true, get: function () { return command_utils_1.CommandUtils; } });
+var context_utils_1 = require("./utils/context.utils");
+Object.defineProperty(exports, "ContextUtils", { enumerable: true, get: function () { return context_utils_1.ContextUtils; } });
+var html_utils_1 = require("./utils/html.utils");
+Object.defineProperty(exports, "HTMLUtils", { enumerable: true, get: function () { return html_utils_1.HTMLUtils; } });
+var inline_keyboard_utils_1 = require("./utils/inline.keyboard.utils");
+Object.defineProperty(exports, "InlineKeyboardUtils", { enumerable: true, get: function () { return inline_keyboard_utils_1.InlineKeyboardUtils; } });
+var reply_to_message_utils_1 = require("./utils/reply.to.message.utils");
+Object.defineProperty(exports, "ReplyToMessageUtils", { enumerable: true, get: function () { return reply_to_message_utils_1.ReplyToMessageUtils; } });
+var start_utils_1 = require("./utils/start.utils");
+Object.defineProperty(exports, "StartUtils", { enumerable: true, get: function () { return start_utils_1.StartUtils; } });

package/loggers/module.logger.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleLogger = void 0;
+const core_1 = require("@aracna/core");
+const enums_1 = require("../definitions/enums");
+exports.ModuleLogger = new core_1.Logger(enums_1.LoggerName.MODULE);

package/modules/api.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API = void 0;
+const core_1 = require("@aracna/core");
+class API extends core_1.API {
+    async post(path, body, config) {
+        let response;
+        response = await this.handle(core_1.RequestMethod.POST, path, body, config);
+        if (response instanceof Error)
+            return response;
+        return response.data.result;
+    }
+    async transformBody(method, path, body, config) {
+        switch (method) {
+            case core_1.RequestMethod.GET:
+            case core_1.RequestMethod.POST:
+                await core_1.Polyfill.blob();
+                await core_1.Polyfill.file();
+                await core_1.Polyfill.formData();
+                return (0, core_1.serializeFormData)(typeof body === 'object' ? body : {});
+            default:
+                return (0, core_1.serializeFormData)({});
+        }
+    }
+}
+exports.API = API;

package/modules/builder.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Builder = void 0;
+const button_builder_1 = require("../builders/button.builder");
+class Builder {
+    button = new button_builder_1.ButtonBuilder();
+}
+exports.Builder = Builder;

package/modules/child.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Child = void 0;
+class Child {
+    telegram;
+    constructor(telegram) {
+        this.telegram = telegram;
+    }
+}
+exports.Child = Child;

package/modules/configuration.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = void 0;
+const dummy_1 = require("./dummy");
+class _ {
+    api = dummy_1.Dummy.configurationAPI;
+    default = dummy_1.Dummy.configurationDefault;
+    handler = dummy_1.Dummy.configurationHandler;
+}
+exports.Configuration = new _();

package/modules/dummy.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dummy = void 0;
+const enums_1 = require("../definitions/enums");
+class Dummy {
+    static get callbackQueryBody() {
+        return {
+            c: undefined,
+            d: 0,
+            t: ''
+        };
+    }
+    static get configurationAPI() {
+        return {
+            post: {
+                callback: {
+                    success: () => null
+                }
+            }
+        };
+    }
+    static get configurationDefault() {
+        return {
+            buttons: {
+                callback: async () => [],
+                game: async () => [],
+                login: async () => [],
+                pay: async () => [],
+                query: async () => [],
+                queryCurrentChat: async () => [],
+                text: async () => [],
+                url: async () => []
+            }
+        };
+    }
+    static get configurationHandler() {
+        return { send: { buttons: { empty: () => new Error() } } };
+    }
+    static get handler() {
+        return {
+            id: '',
+            key: '',
+            middleware: () => null,
+            options: {
+                deleteOnCallbackQuery: true,
+                deleteOnMessageStart: true,
+                deleteOnReply: true
+            },
+            type: enums_1.UpdateType.MESSAGE
+        };
+    }
+    static get messageBody() {
+        return { chatID: undefined, data: undefined, type: '' };
+    }
+}
+exports.Dummy = Dummy;