@aracna/telegram-bot 1.9.3

package/declarations/childs/answer.d.ts

@@ -0,0 +1,9 @@
+import { FetchError } from '@aracna/core';
+import { AnswerCallbackQuery, AnswerInlineQuery, AnswerPreCheckoutQuery, AnswerShippingQuery, InlineQueryResult } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export 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>;
+}

package/declarations/childs/ban.d.ts

@@ -0,0 +1,6 @@
+import { FetchError } from '@aracna/core';
+import { BanChatMember } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Ban extends Child {
+    chatMember(chatID: number, userID: number, parameters?: Partial<BanChatMember>): Promise<boolean | FetchError>;
+}

package/declarations/childs/create.d.ts

@@ -0,0 +1,6 @@
+import { FetchError } from '@aracna/core';
+import { CreateNewStickerSet, InputSticker } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Create extends Child {
+    stickerSet(userID: number, format: string, name: string, title: string, stickers: InputSticker[], parameters: Partial<CreateNewStickerSet>): Promise<boolean | FetchError>;
+}

package/declarations/childs/delete.d.ts

@@ -0,0 +1,8 @@
+import { FetchError } from '@aracna/core';
+import { Child } from '../modules/child';
+export 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>;
+}

package/declarations/childs/download.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { FetchError } from '@aracna/core';
+import { API } from '../modules/api';
+import { Child } from '../modules/child';
+export declare class Download extends Child {
+    api: API;
+    file(id: string): Promise<Buffer | FetchError>;
+    userFirstProfilePhoto(id: number): Promise<Buffer | FetchError | Error>;
+}

package/declarations/childs/edit.d.ts

@@ -0,0 +1,10 @@
+import { FetchError } from '@aracna/core';
+import { EditMessageCaption, EditMessageLiveLocation, EditMessageMedia, EditMessageReplyMarkup, EditMessageText, InputMedia, Message } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export 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>;
+}

package/declarations/childs/export.d.ts

@@ -0,0 +1,5 @@
+import { FetchError } from '@aracna/core';
+import { Child } from '../modules/child';
+export declare class Export extends Child {
+    chatInviteLink(chatID: number): Promise<string | FetchError>;
+}

package/declarations/childs/forward.d.ts

@@ -0,0 +1,6 @@
+import { FetchError } from '@aracna/core';
+import { ForwardMessage, Message } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Forward extends Child {
+    message(chatID: number, fromChatID: number, messageID: number, parameters?: Partial<ForwardMessage>): Promise<Message | FetchError>;
+}

package/declarations/childs/get.d.ts

@@ -0,0 +1,15 @@
+import { FetchError } from '@aracna/core';
+import { BotCommand, Chat, ChatMember, File, GameHighScore, GetGameHighScores, GetUserProfilePhotos, StickerSet, User, UserProfilePhotos } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export 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 | 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>;
+}

package/declarations/childs/leave.d.ts

@@ -0,0 +1,5 @@
+import { FetchError } from '@aracna/core';
+import { Child } from '../modules/child';
+export declare class Leave extends Child {
+    chat(id: number): Promise<boolean | FetchError>;
+}

package/declarations/childs/pin.d.ts

@@ -0,0 +1,6 @@
+import { FetchError } from '@aracna/core';
+import { PinChatMessage } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Pin extends Child {
+    chatMessage(chatID: number, message: number, parameters?: Partial<PinChatMessage>): Promise<boolean | FetchError>;
+}

package/declarations/childs/polling.d.ts

@@ -0,0 +1,9 @@
+import { GetUpdates } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Polling extends Child {
+    active: boolean;
+    offset: number;
+    start(ms: number | undefined, parameters: Partial<GetUpdates>): void;
+    stop(): void;
+    private get;
+}

package/declarations/childs/privates/send.private.d.ts

@@ -0,0 +1,7 @@
+import { FetchError } from '@aracna/core';
+import { InlineKeyboardButton, Message, SendMessage } from '@aracna/telegram-bot-types';
+import { Child } from '../../modules/child';
+export 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>;
+}

package/declarations/childs/promote.d.ts

@@ -0,0 +1,6 @@
+import { FetchError } from '@aracna/core';
+import { PromoteChatMember } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Promote extends Child {
+    chatMember(chatID: number, userID: number, parameters?: Partial<PromoteChatMember>): Promise<boolean | FetchError>;
+}

package/declarations/childs/restrict.d.ts

@@ -0,0 +1,6 @@
+import { FetchError } from '@aracna/core';
+import { ChatPermissions, RestrictChatMember } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Restrict extends Child {
+    chatMember(chatID: number, userID: number, permissions: ChatPermissions, parameters?: Partial<RestrictChatMember>): Promise<boolean | FetchError>;
+}

package/declarations/childs/send.d.ts

@@ -0,0 +1,31 @@
+import { FetchError } from '@aracna/core';
+import { InlineKeyboardButton, LabeledPrice, Message, SendAnimation, SendAudio, SendContact, SendDice, SendDocument, SendGame, SendInvoice, SendLocation, SendMediaGroup, SendMessage, SendPhoto, SendPoll, SendSticker, SendVenue, SendVideo, SendVideoNote, SendVoice } from '@aracna/telegram-bot-types';
+import { InputMediaAlternative } from '../definitions/interfaces';
+import { InputFile } from '../definitions/types';
+import { Child } from '../modules/child';
+import { SendPrivate } from './privates/send.private';
+export 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;
+}

package/declarations/childs/set.d.ts

@@ -0,0 +1,17 @@
+import { FetchError } from '@aracna/core';
+import { BotCommand, ChatPermissions, PassportElementError, SetGameScore, SetMyCommands, SetStickerSetThumbnail } from '@aracna/telegram-bot-types';
+import { InputFile } from '../definitions/types';
+import { Child } from '../modules/child';
+export declare class Set 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>;
+}

package/declarations/childs/stop.d.ts

@@ -0,0 +1,7 @@
+import { FetchError } from '@aracna/core';
+import { Message, Poll, StopMessageLiveLocation, StopPoll } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Stop extends Child {
+    messageLiveLocation(parameters: StopMessageLiveLocation): Promise<Message | boolean | FetchError>;
+    poll(chatID: number, message: number, parameters?: Partial<StopPoll>): Promise<Poll | FetchError>;
+}

package/declarations/childs/unban.d.ts

@@ -0,0 +1,5 @@
+import { FetchError } from '@aracna/core';
+import { Child } from '../modules/child';
+export declare class Unban extends Child {
+    chatMember(chatID: number, userID: number): Promise<boolean | FetchError>;
+}

package/declarations/childs/unpin.d.ts

@@ -0,0 +1,5 @@
+import { FetchError } from '@aracna/core';
+import { Child } from '../modules/child';
+export declare class Unpin extends Child {
+    chatMessage(chatID: number): Promise<boolean | FetchError>;
+}

package/declarations/childs/upload.d.ts

@@ -0,0 +1,7 @@
+import { FetchError } from '@aracna/core';
+import { File } from '@aracna/telegram-bot-types';
+import { InputFile } from '../definitions/types';
+import { Child } from '../modules/child';
+export declare class Upload extends Child {
+    stickerFile(userID: number, format: string, sticker: InputFile): Promise<File | FetchError>;
+}

package/declarations/childs/webhook.d.ts

@@ -0,0 +1,8 @@
+import { FetchError } from '@aracna/core';
+import { SetWebhook } from '@aracna/telegram-bot-types';
+import { Child } from '../modules/child';
+export declare class Webhook extends Child {
+    delete(): Promise<boolean | FetchError>;
+    set(route?: string, parameters?: Partial<SetWebhook>): Promise<boolean | FetchError>;
+    url(route: string): string;
+}

package/declarations/definitions/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const REGEXP_COMMAND: RegExp;
+export declare const REGEXP_COMMAND_WITH_USERNAME: RegExp;

package/declarations/definitions/enums.d.ts

@@ -0,0 +1,22 @@
+export declare enum LoggerName {
+    MODULE = "TELEGRAM_MODULE"
+}
+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"
+}

package/declarations/definitions/interfaces.d.ts

@@ -0,0 +1,97 @@
+import { FetchResponse } from '@aracna/core';
+import { CallbackQuery as NativeCallbackQuery, ChatJoinRequest, ChatMemberUpdated, ChosenInlineResult, InlineKeyboardButton, InlineQuery, InputMediaAudio, InputMediaDocument, InputMediaPhoto, InputMediaVideo, Message, Poll, PollAnswer, PreCheckoutQuery, SendMediaGroup, ShippingQuery } from '@aracna/telegram-bot-types';
+import { UpdateType } from './enums';
+import { HandlerMiddleware, InputFile } from './types';
+export interface APIResponse<T> extends FetchResponse<APIResponseData<T>> {
+}
+export interface APIResponseData<T> {
+    ok: boolean;
+    result: T;
+}
+export interface CallbackQuery<T = any> extends NativeCallbackQuery {
+    body: CallbackQueryBody<T>;
+}
+export interface CallbackQueryBody<T = any> {
+    c?: number;
+    d: T;
+    t: string;
+}
+export interface ConfigurationAPI {
+    post: {
+        callback: {
+            success: <T, U>(body: T, result: U | Error) => void;
+        };
+    };
+}
+export 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[]>;
+    };
+}
+export interface ConfigurationHandler {
+    send: {
+        buttons: {
+            empty: (chatID: number) => Error;
+        };
+    };
+}
+export 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 interface Handler<T extends UpdateType = any, U extends HandlerOptions = HandlerOptions> {
+    description?: string;
+    id: string;
+    key?: string;
+    middleware: HandlerMiddleware<T>;
+    options: U;
+    type: UpdateType;
+}
+export interface HandlerOptions {
+    deleteOnCallbackQuery?: boolean;
+    deleteOnReply?: boolean;
+    deleteOnMessageStart?: boolean;
+}
+export interface InputMediaAlternative extends Omit<InputMediaAudio | InputMediaDocument | InputMediaPhoto | InputMediaVideo, 'media'> {
+    media: InputFile;
+}
+export interface MessageBody<T = any> {
+    chatID?: number;
+    data: T;
+    type: string;
+}
+export interface ReplyToMessage<T = any> extends Message {
+    body: MessageBody<T>;
+}
+export interface SendMediaGroupAlternative extends Omit<SendMediaGroup, 'media'> {
+    media: InputMediaAlternative[];
+}
+export interface Start<T = any> extends Message {
+    body: MessageBody<T>;
+}
+export interface TelegramName {
+    first: string;
+    last: string;
+}

package/declarations/definitions/types.d.ts

@@ -0,0 +1,4 @@
+import { UpdateType } from './enums';
+import { Context } from './interfaces';
+export declare type HandlerMiddleware<T extends UpdateType> = (context: Context[T]) => any;
+export declare type InputFile = File | string;

package/declarations/index.d.ts

@@ -0,0 +1,12 @@
+export { LoggerName as TelegramLoggerName, UpdateType } from './definitions/enums';
+export { CallbackQuery, CallbackQueryBody, Context, Handler, HandlerOptions, MessageBody, ReplyToMessage, Start } from './definitions/interfaces';
+export { HandlerMiddleware, InputFile } from './definitions/types';
+export { Configuration as TelegramConfiguration } from './modules/configuration';
+export { Telegram } from './modules/telegram';
+export { CallbackQueryUtils } from './utils/callback.query.utils';
+export { CommandUtils } from './utils/command.utils';
+export { ContextUtils } from './utils/context.utils';
+export { HTMLUtils } from './utils/html.utils';
+export { InlineKeyboardUtils } from './utils/inline.keyboard.utils';
+export { ReplyToMessageUtils } from './utils/reply.to.message.utils';
+export { StartUtils } from './utils/start.utils';

package/declarations/loggers/module.logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '@aracna/core';
+export declare const ModuleLogger: Logger;

package/declarations/modules/api.d.ts

@@ -0,0 +1,5 @@
+import { API as CoreAPI, APIConfig, FetchError, RequestMethod } from '@aracna/core';
+export declare class API extends CoreAPI {
+    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>;
+}

package/declarations/modules/builder.d.ts

@@ -0,0 +1,4 @@
+import { ButtonBuilder } from '../builders/button.builder';
+export declare class Builder {
+    button: ButtonBuilder;
+}

package/declarations/modules/child.d.ts

@@ -0,0 +1,5 @@
+import type { Telegram } from './telegram';
+export declare class Child {
+    protected telegram: Telegram;
+    constructor(telegram: Telegram);
+}

package/declarations/modules/configuration.d.ts

@@ -0,0 +1,8 @@
+import { ConfigurationAPI, ConfigurationDefault, ConfigurationHandler } from '../definitions/interfaces';
+declare class _ {
+    api: ConfigurationAPI;
+    default: ConfigurationDefault;
+    handler: ConfigurationHandler;
+}
+export declare const Configuration: _;
+export {};

package/declarations/modules/dummy.d.ts

@@ -0,0 +1,9 @@
+import { CallbackQueryBody, ConfigurationAPI, ConfigurationDefault, ConfigurationHandler, Handler, MessageBody } from '../definitions/interfaces';
+export declare class Dummy {
+    static get callbackQueryBody(): CallbackQueryBody;
+    static get configurationAPI(): ConfigurationAPI;
+    static get configurationDefault(): ConfigurationDefault;
+    static get configurationHandler(): ConfigurationHandler;
+    static get handler(): Handler<any, any>;
+    static get messageBody(): MessageBody;
+}

package/declarations/modules/telegram.d.ts

@@ -0,0 +1,87 @@
+import { BotCommand, CallbackQuery, ChatJoinRequest, ChatMemberUpdated, ChosenInlineResult, InlineQuery, Message, Poll, PollAnswer, PreCheckoutQuery, ShippingQuery, Update } from '@aracna/telegram-bot-types';
+import { Add } from '../childs/add';
+import { Answer } from '../childs/answer';
+import { Ban } from '../childs/ban';
+import { Create } from '../childs/create';
+import { Delete } from '../childs/delete';
+import { Download } from '../childs/download';
+import { Edit } from '../childs/edit';
+import { Export } from '../childs/export';
+import { Forward } from '../childs/forward';
+import { Get } from '../childs/get';
+import { Leave } from '../childs/leave';
+import { Pin } from '../childs/pin';
+import { Polling } from '../childs/polling';
+import { Promote } from '../childs/promote';
+import { Restrict } from '../childs/restrict';
+import { Send } from '../childs/send';
+import { Set } from '../childs/set';
+import { Stop } from '../childs/stop';
+import { Unban } from '../childs/unban';
+import { Unpin } from '../childs/unpin';
+import { Upload } from '../childs/upload';
+import { Webhook } from '../childs/webhook';
+import { UpdateType } from '../definitions/enums';
+import { Handler, HandlerOptions, TelegramName } from '../definitions/interfaces';
+import { HandlerMiddleware } from '../definitions/types';
+import { API } from './api';
+import { Builder } from './builder';
+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;
+    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): 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();
+}

package/declarations/utils/callback.query.utils.d.ts

@@ -0,0 +1,5 @@
+import { CallbackQueryBody } from '../definitions/interfaces';
+export declare class CallbackQueryUtils {
+    static decodeBody<T>(data?: string): CallbackQueryBody<T>;
+    static encodeBody<T>(data: T, type: string, chatID?: number): string;
+}

package/declarations/utils/command.utils.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { Context } from 'vm';
+import { UpdateType } from '../definitions/enums';
+export declare class CommandUtils {
+    static getByContext<T extends UpdateType>(context: Context[T]): string;
+    static get(string?: string): string;
+    static omit(string: string): string;
+}

package/declarations/utils/context.utils.d.ts

@@ -0,0 +1,13 @@
+import { Chat, User } from '@aracna/telegram-bot-types';
+import { UpdateType } from '../definitions/enums';
+import { Context } from '../definitions/interfaces';
+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;
+}

package/declarations/utils/html.utils.d.ts

@@ -0,0 +1,5 @@
+export declare class HTMLUtils {
+    static tags: string[];
+    static sanitize(text: string): string;
+    static progress(value: number, minimum?: number, maximum?: number, size?: number): string;
+}

package/declarations/utils/inline.keyboard.utils.d.ts

@@ -0,0 +1,4 @@
+import { InlineKeyboardButton } from '@aracna/telegram-bot-types';
+export declare class InlineKeyboardUtils {
+    static getButtonsType(buttons: InlineKeyboardButton[]): string;
+}

package/declarations/utils/reply.to.message.utils.d.ts

@@ -0,0 +1,6 @@
+import { MessageEntity } from '@aracna/telegram-bot-types';
+import { MessageBody } from '../definitions/interfaces';
+export declare class ReplyToMessageUtils {
+    static decodeBody<T>(entities: MessageEntity[]): MessageBody<T>;
+    static encodeBody<T>(data: T, type: string, chatID?: number): string;
+}

package/declarations/utils/start.utils.d.ts

@@ -0,0 +1,7 @@
+import { MessageBody } from '../definitions/interfaces';
+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;
+}

package/definitions/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGEXP_COMMAND_WITH_USERNAME = exports.REGEXP_COMMAND = void 0;
+// export const REGEXP_ARRAY: RegExp = /^\[.+\]$/
+exports.REGEXP_COMMAND = /\/[a-z_]+/m;
+exports.REGEXP_COMMAND_WITH_USERNAME = /\/[a-zA-Z0-9_@]+/;
+// export const REGEXP_ID: RegExp = /^[a-z0-9]{16}$/
+// export const REGEXP_NUMBER: RegExp = /^(\+|-)?[0-9]+(\.[0-9])?[0-9]*$/
+// export const REGEXP_OBJECT: RegExp = /^\{.+\}$/
+// export const REGEXP_REPLY_TO_MESSAGE_CHAT_ID: RegExp = /:\s(\+|-)?[0-9]+/m
+// export const REGEXP_USERNAME: RegExp = /[a-zA-Z_0-9]{5,32}/

package/definitions/enums.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateType = exports.LoggerName = void 0;
+var LoggerName;
+(function (LoggerName) {
+    LoggerName["MODULE"] = "TELEGRAM_MODULE";
+})(LoggerName = exports.LoggerName || (exports.LoggerName = {}));
+var UpdateType;
+(function (UpdateType) {
+    UpdateType["CALLBACK_QUERY"] = "CALLBACK_QUERY";
+    UpdateType["CHANNEL_POST"] = "CHANNEL_POST";
+    UpdateType["CHAT_JOIN_REQUEST"] = "CHAT_JOIN_REQUEST";
+    UpdateType["CHAT_MEMBER"] = "CHAT_MEMBER";
+    UpdateType["CHOSEN_INLINE_RESULT"] = "CHOSEN_INLINE_RESULT";
+    UpdateType["DOCUMENT"] = "DOCUMENT";
+    UpdateType["EDITED_CHANNEL_POST"] = "EDITED_CHANNEL_POST";
+    UpdateType["EDITED_MESSAGE"] = "EDITED_MESSAGE";
+    UpdateType["INLINE_QUERY"] = "INLINE_QUERY";
+    UpdateType["MESSAGE"] = "MESSAGE";
+    UpdateType["MY_CHAT_MEMBER"] = "MY_CHAT_MEMBER";
+    UpdateType["POLL"] = "POLL";
+    UpdateType["POLL_ANSWER"] = "POLL_ANSWER";
+    UpdateType["PRE_CHECKOUT_QUERY"] = "PRE_CHECKOUT_QUERY";
+    UpdateType["REPLY_TO_MESSAGE"] = "REPLY_TO_MESSAGE";
+    UpdateType["SHIPPING_QUERY"] = "SHIPPING_QUERY";
+    UpdateType["START"] = "START";
+})(UpdateType = exports.UpdateType || (exports.UpdateType = {}));

package/definitions/interfaces.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const enums_1 = require("./enums");

package/definitions/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });