@aracna/telegram-bot 1.9.13 → 2.0.1

package/requests/set-requests.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setChatAdministratorCustomTitle = setChatAdministratorCustomTitle;
+exports.setChatDescription = setChatDescription;
+exports.setChatMenuButton = setChatMenuButton;
+exports.setChatPermissions = setChatPermissions;
+exports.setChatPhoto = setChatPhoto;
+exports.setChatStickerSet = setChatStickerSet;
+exports.setChatTitle = setChatTitle;
+exports.setCustomEmojiStickerSetThumbnail = setCustomEmojiStickerSetThumbnail;
+exports.setGameScore = setGameScore;
+exports.setMessageReaction = setMessageReaction;
+exports.setMyCommands = setMyCommands;
+exports.setMyDefaultAdministratorRights = setMyDefaultAdministratorRights;
+exports.setMyDescription = setMyDescription;
+exports.setMyName = setMyName;
+exports.setMyShortDescription = setMyShortDescription;
+exports.setPassportDataErrors = setPassportDataErrors;
+exports.setStickerEmojiList = setStickerEmojiList;
+exports.setStickerKeywords = setStickerKeywords;
+exports.setStickerMaskPosition = setStickerMaskPosition;
+exports.setStickerPositionInSet = setStickerPositionInSet;
+exports.setStickerSetThumbnail = setStickerSetThumbnail;
+exports.setStickerSetTitle = setStickerSetTitle;
+const telegram_api_1 = require("../apis/telegram-api");
+async function setChatAdministratorCustomTitle(token, body) {
+    return telegram_api_1.TelegramAPI.post('setChatAdministratorCustomTitle', body, { token });
+}
+async function setChatDescription(token, body) {
+    return telegram_api_1.TelegramAPI.post('setChatDescription', body, { token });
+}
+async function setChatMenuButton(token, body) {
+    return telegram_api_1.TelegramAPI.post('setChatMenuButton', body, { token });
+}
+async function setChatPermissions(token, body) {
+    return telegram_api_1.TelegramAPI.post('setChatPermissions', body, { token });
+}
+async function setChatPhoto(token, body) {
+    return telegram_api_1.TelegramAPI.post('setChatPhoto', {
+        ...body,
+        photo: body.photo instanceof Blob ? `attach://photo_blob` : body.photo,
+        ...(body.photo instanceof Blob ? { photo_blob: body.photo } : {})
+    }, { token });
+}
+async function setChatStickerSet(token, body) {
+    return telegram_api_1.TelegramAPI.post('setChatStickerSet', body, { token });
+}
+async function setChatTitle(token, body) {
+    return telegram_api_1.TelegramAPI.post('setChatTitle', body, { token });
+}
+async function setCustomEmojiStickerSetThumbnail(token, body) {
+    return telegram_api_1.TelegramAPI.post('setCustomEmojiStickerSetThumbnail', body, { token });
+}
+async function setGameScore(token, body) {
+    return telegram_api_1.TelegramAPI.post('setGameScore', body, { token });
+}
+async function setMessageReaction(token, body) {
+    return telegram_api_1.TelegramAPI.post('setMessageReaction', body, { token });
+}
+async function setMyCommands(token, body) {
+    return telegram_api_1.TelegramAPI.post('setMyCommands', body, { token });
+}
+async function setMyDefaultAdministratorRights(token, body) {
+    return telegram_api_1.TelegramAPI.post('setMyDefaultAdministratorRights', body, { token });
+}
+async function setMyDescription(token, body) {
+    return telegram_api_1.TelegramAPI.post('setMyDescription', body, { token });
+}
+async function setMyName(token, body) {
+    return telegram_api_1.TelegramAPI.post('setMyName', body, { token });
+}
+async function setMyShortDescription(token, body) {
+    return telegram_api_1.TelegramAPI.post('setMyShortDescription', body, { token });
+}
+async function setPassportDataErrors(token, body) {
+    return telegram_api_1.TelegramAPI.post('setPassportDataErrors', body, { token });
+}
+async function setStickerEmojiList(token, body) {
+    return telegram_api_1.TelegramAPI.post('setStickerEmojiList', body, { token });
+}
+async function setStickerKeywords(token, body) {
+    return telegram_api_1.TelegramAPI.post('setStickerKeywords', body, { token });
+}
+async function setStickerMaskPosition(token, body) {
+    return telegram_api_1.TelegramAPI.post('setStickerMaskPosition', body, { token });
+}
+async function setStickerPositionInSet(token, body) {
+    return telegram_api_1.TelegramAPI.post('setStickerPositionInSet', body, { token });
+}
+async function setStickerSetThumbnail(token, body) {
+    return telegram_api_1.TelegramAPI.post('setStickerSetThumbnail', body, { token });
+}
+async function setStickerSetTitle(token, body) {
+    return telegram_api_1.TelegramAPI.post('setStickerSetTitle', body, { token });
+}

package/requests/stop-requests.d.ts

@@ -0,0 +1,4 @@
+import type { FetchError } from '@aracna/core';
+import type { Message, Poll, StopMessageLiveLocation, StopPoll } from '@aracna/telegram-bot-types';
+export declare function stopMessageLiveLocation(token: string, body: StopMessageLiveLocation): Promise<Message | boolean | FetchError>;
+export declare function stopPoll(token: string, body: StopPoll): Promise<Poll | FetchError>;

package/requests/stop-requests.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopMessageLiveLocation = stopMessageLiveLocation;
+exports.stopPoll = stopPoll;
+const telegram_api_1 = require("../apis/telegram-api");
+async function stopMessageLiveLocation(token, body) {
+    return telegram_api_1.TelegramAPI.post('stopMessageLiveLocation', body, { token });
+}
+async function stopPoll(token, body) {
+    return telegram_api_1.TelegramAPI.post('stopPoll', body, { token });
+}

package/requests/unban-requests.d.ts

@@ -0,0 +1,4 @@
+import type { FetchError } from '@aracna/core';
+import type { UnbanChatMember, UnbanChatSenderChat } from '@aracna/telegram-bot-types';
+export declare function unbanChatMember(token: string, body: UnbanChatMember): Promise<boolean | FetchError>;
+export declare function unbanChatSenderChat(token: string, body: UnbanChatSenderChat): Promise<boolean | FetchError>;

package/requests/unban-requests.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unbanChatMember = unbanChatMember;
+exports.unbanChatSenderChat = unbanChatSenderChat;
+const telegram_api_1 = require("../apis/telegram-api");
+async function unbanChatMember(token, body) {
+    return telegram_api_1.TelegramAPI.post('unbanChatMember', body, { token });
+}
+async function unbanChatSenderChat(token, body) {
+    return telegram_api_1.TelegramAPI.post('unbanChatSenderChat', body, { token });
+}

package/requests/unhide-requests.d.ts

@@ -0,0 +1,3 @@
+import type { FetchError } from '@aracna/core';
+import type { HideGeneralForumTopic } from '@aracna/telegram-bot-types';
+export declare function unhideGeneralForumTopic(token: string, body: HideGeneralForumTopic): Promise<boolean | FetchError>;

package/requests/unhide-requests.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unhideGeneralForumTopic = unhideGeneralForumTopic;
+const telegram_api_1 = require("../apis/telegram-api");
+async function unhideGeneralForumTopic(token, body) {
+    return telegram_api_1.TelegramAPI.post('unhideGeneralForumTopic', body, { token });
+}

package/requests/unpin-requests.d.ts

@@ -0,0 +1,6 @@
+import type { FetchError } from '@aracna/core';
+import type { UnpinAllChatMessages, UnpinAllForumTopicMessages, UnpinAllGeneralForumTopicMessages, UnpinChatMessage } from '@aracna/telegram-bot-types';
+export declare function unpinAllChatMessages(token: string, body: UnpinAllChatMessages): Promise<boolean | FetchError>;
+export declare function unpinAllForumTopicMessages(token: string, body: UnpinAllForumTopicMessages): Promise<boolean | FetchError>;
+export declare function unpinAllGeneralForumTopicMessages(token: string, body: UnpinAllGeneralForumTopicMessages): Promise<boolean | FetchError>;
+export declare function unpinChatMessage(token: string, body: UnpinChatMessage): Promise<boolean | FetchError>;

package/requests/unpin-requests.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpinAllChatMessages = unpinAllChatMessages;
+exports.unpinAllForumTopicMessages = unpinAllForumTopicMessages;
+exports.unpinAllGeneralForumTopicMessages = unpinAllGeneralForumTopicMessages;
+exports.unpinChatMessage = unpinChatMessage;
+const telegram_api_1 = require("../apis/telegram-api");
+async function unpinAllChatMessages(token, body) {
+    return telegram_api_1.TelegramAPI.post('unpinAllChatMessages', body, { token });
+}
+async function unpinAllForumTopicMessages(token, body) {
+    return telegram_api_1.TelegramAPI.post('unpinAllForumTopicMessages', body, { token });
+}
+async function unpinAllGeneralForumTopicMessages(token, body) {
+    return telegram_api_1.TelegramAPI.post('unpinAllGeneralForumTopicMessages', body, { token });
+}
+async function unpinChatMessage(token, body) {
+    return telegram_api_1.TelegramAPI.post('unpinChatMessage', body, { token });
+}

package/requests/upload-requests.d.ts

@@ -0,0 +1,3 @@
+import type { FetchError } from '@aracna/core';
+import type { File, UploadStickerFile } from '@aracna/telegram-bot-types';
+export declare function uploadStickerFile(token: string, body: UploadStickerFile): Promise<File | FetchError>;

package/requests/upload-requests.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadStickerFile = uploadStickerFile;
+const telegram_api_1 = require("../apis/telegram-api");
+async function uploadStickerFile(token, body) {
+    return telegram_api_1.TelegramAPI.post('uploadStickerFile', body, { token });
+}

package/requests/webhook-requests.d.ts

@@ -0,0 +1,6 @@
+import type { FetchError } from '@aracna/core';
+import type { DeleteWebhook, SetWebhook, WebhookInfo } from '@aracna/telegram-bot-types';
+export declare function closeWebhook(token: string): Promise<boolean | FetchError>;
+export declare function deleteWebhook(token: string, body?: DeleteWebhook): Promise<boolean | FetchError>;
+export declare function getWebhookInfo(token: string): Promise<WebhookInfo | FetchError>;
+export declare function setWebhook(token: string, body: SetWebhook): Promise<boolean | FetchError>;

package/requests/webhook-requests.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeWebhook = closeWebhook;
+exports.deleteWebhook = deleteWebhook;
+exports.getWebhookInfo = getWebhookInfo;
+exports.setWebhook = setWebhook;
+const telegram_api_1 = require("../apis/telegram-api");
+const constants_1 = require("../definitions/constants");
+async function closeWebhook(token) {
+    return telegram_api_1.TelegramAPI.post('close', undefined, { token });
+}
+async function deleteWebhook(token, body) {
+    return telegram_api_1.TelegramAPI.post('deleteWebhook', body, { token });
+}
+async function getWebhookInfo(token) {
+    return telegram_api_1.TelegramAPI.post('getWebhookInfo', undefined, { token });
+}
+async function setWebhook(token, body) {
+    return telegram_api_1.TelegramAPI.post('setWebhook', { allowed_updates: constants_1.DEFAULT_ALLOWED_UPDATES, ...body }, { token });
+}

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

@@ -0,0 +1,3 @@
+import type { CallbackQueryBody, EncodeCallbackQueryBodyOptions } from '../definitions/interfaces';
+export declare function decodeCallbackQueryBody<T>(data?: string): CallbackQueryBody<T>;
+export declare function encodeCallbackQueryBody<T>(data: T, options?: EncodeCallbackQueryBodyOptions): string;

package/utils/callback-query-utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeCallbackQueryBody = decodeCallbackQueryBody;
+exports.encodeCallbackQueryBody = encodeCallbackQueryBody;
+const core_1 = require("@aracna/core");
+const constants_1 = require("../definitions/constants");
+function decodeCallbackQueryBody(data) {
+    let body;
+    if (!data) {
+        return (0, constants_1.DEFAULT_CALLBACK_QUERY_BODY)();
+    }
+    body = (0, core_1.tc)(() => (0, core_1.decodeJSON)((0, core_1.decodeText)((0, core_1.decodeBase64)(data)), (0, constants_1.DEFAULT_DECODE_JSON_OPTIONS)()));
+    if (body instanceof Error)
+        return (0, constants_1.DEFAULT_CALLBACK_QUERY_BODY)();
+    return body;
+}
+function encodeCallbackQueryBody(data, options) {
+    let body;
+    body = {
+        c: options?.chatID,
+        d: data,
+        m: options?.command
+    };
+    return (0, core_1.encodeBase64)((0, core_1.encodeText)((0, core_1.encodeJSON)(body, (0, constants_1.DEFAULT_ENCODE_JSON_OPTIONS)(), '{}')));
+}

package/utils/command-utils.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from 'vm';
+import type { UpdateType } from '../definitions/types';
+export declare function getCommandByContext<T extends UpdateType>(context: Context[T]): string | undefined;
+export declare function getCommand(string: string | undefined): string | undefined;
+export declare function omitCommand(string: string | undefined): string;

package/utils/command-utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandByContext = getCommandByContext;
+exports.getCommand = getCommand;
+exports.omitCommand = omitCommand;
+const core_1 = require("@aracna/core");
+const constants_1 = require("../definitions/constants");
+function getCommandByContext(context) {
+    let string;
+    switch (true) {
+        case (0, core_1.hasObjectProperty)(context, 'caption'):
+            string = (0, core_1.getObjectProperty)(context, 'caption', '');
+            break;
+        case (0, core_1.hasObjectProperty)(context, 'text'):
+            string = (0, core_1.getObjectProperty)(context, 'text', '');
+            break;
+    }
+    return getCommand(string);
+}
+function getCommand(string) {
+    if (typeof string !== 'string') {
+        return;
+    }
+    return constants_1.REGEXP_COMMAND.exec(string.slice(0, 512))?.[0].slice(1);
+}
+function omitCommand(string) {
+    return string?.replace(constants_1.REGEXP_COMMAND_WITH_USERNAME, '').trim() ?? '';
+}

package/utils/context-utils.d.ts

@@ -0,0 +1,11 @@
+import type { Chat, User } from '@aracna/telegram-bot-types';
+import type { Context } from '../definitions/interfaces';
+import type { UpdateType } from '../definitions/types';
+export declare function getContextChat<T extends UpdateType>(context: Context[T]): Chat | undefined;
+export declare function getContextChatID<T extends UpdateType>(context: Context[T]): bigint | number | undefined;
+export declare function getContextChatType<T extends UpdateType>(context: Context[T]): string | undefined;
+export declare function getContextUser<T extends UpdateType>(context: Context[T]): User | undefined;
+export declare function getContextUserFirstName<T extends UpdateType>(context: Context[T]): string | undefined;
+export declare function getContextUserID<T extends UpdateType>(context: Context[T]): bigint | number | undefined;
+export declare function getContextUserLastName<T extends UpdateType>(context: Context[T]): string | undefined;
+export declare function getContextUserUsername<T extends UpdateType>(context: Context[T]): string | undefined;

package/utils/context-utils.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContextChat = getContextChat;
+exports.getContextChatID = getContextChatID;
+exports.getContextChatType = getContextChatType;
+exports.getContextUser = getContextUser;
+exports.getContextUserFirstName = getContextUserFirstName;
+exports.getContextUserID = getContextUserID;
+exports.getContextUserLastName = getContextUserLastName;
+exports.getContextUserUsername = getContextUserUsername;
+const core_1 = require("@aracna/core");
+function getContextChat(context) {
+    if ((0, core_1.hasObjectProperty)(context, 'chat')) {
+        return (0, core_1.getObjectProperty)(context, 'chat');
+    }
+    if ((0, core_1.hasObjectProperty)(context, 'message.chat')) {
+        return (0, core_1.getObjectProperty)(context, 'message.chat');
+    }
+}
+function getContextChatID(context) {
+    return getContextChat(context)?.id;
+}
+function getContextChatType(context) {
+    return getContextChat(context)?.type;
+}
+function getContextUser(context) {
+    if ((0, core_1.hasObjectProperty)(context, 'from')) {
+        return (0, core_1.getObjectProperty)(context, 'from');
+    }
+}
+function getContextUserFirstName(context) {
+    return getContextUser(context)?.first_name;
+}
+function getContextUserID(context) {
+    return getContextUser(context)?.id;
+}
+function getContextUserLastName(context) {
+    return getContextUser(context)?.last_name;
+}
+function getContextUserUsername(context) {
+    return getContextUser(context)?.username;
+}

package/utils/html-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getProgressHTML(value: number, min?: number, max?: number, size?: number): string;
+export declare function sanitizeHTML(text: string): string;

package/utils/html-utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProgressHTML = getProgressHTML;
+exports.sanitizeHTML = sanitizeHTML;
+const core_1 = require("@aracna/core");
+const tags = ['b', 'strong', 'i', 'em', 'u', 'ins', 's', 'strike', 'del', 'span', 'tg-spoiler', 'a', 'code', 'pre', '/', '"'];
+function getProgressHTML(value, min = 0, max = 100, size = 20) {
+    let percentage, steps;
+    percentage = (0, core_1.getNumberPercentage)(value, { min, max });
+    steps = new Array(size).fill(0).map((_, index) => ((index * max) / size < percentage ? '=' : ' '));
+    return `<code>[${steps.join('')}]</code>`;
+}
+function sanitizeHTML(text) {
+    return text
+        .replace(/&/gm, '&amp;')
+        .replace(new RegExp(`<(?!(${tags.join('|')}))`, 'gm'), '&lt;')
+        .replace(new RegExp(`(?<!(${tags.join('|')}))>`, 'gm'), '&gt;');
+}

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

@@ -0,0 +1,12 @@
+import type { InlineKeyboardButton, LoginUrl, SwitchInlineQueryChosenChat, WebAppInfo } from '@aracna/telegram-bot-types';
+import { EncodeCallbackQueryBodyOptions } from '../definitions/interfaces';
+export declare function getInlineKeyboardCallbackButton<T>(text: string, data: T, options?: EncodeCallbackQueryBodyOptions): InlineKeyboardButton;
+export declare function getInlineKeyboardGameButton(text: string, game: string): InlineKeyboardButton;
+export declare function getInlineKeyboardLoginButton(text: string, url: string, fields?: Partial<LoginUrl>): InlineKeyboardButton;
+export declare function getInlineKeyboardPayButton(text: string): InlineKeyboardButton;
+export declare function getInlineKeyboardQueryButton(text: string, query: string): InlineKeyboardButton;
+export declare function getInlineKeyboardQueryChosenChatButton(text: string, query: SwitchInlineQueryChosenChat): InlineKeyboardButton;
+export declare function getInlineKeyboardQueryCurrentChatButton(text: string, query: string): InlineKeyboardButton;
+export declare function getInlineKeyboardTextButton(text: string): InlineKeyboardButton;
+export declare function getInlineKeyboardUrlButton(text: string, url: string): InlineKeyboardButton;
+export declare function getInlineKeyboardWebAppButton(text: string, app: WebAppInfo): InlineKeyboardButton;

package/utils/inline-keyboard-utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInlineKeyboardCallbackButton = getInlineKeyboardCallbackButton;
+exports.getInlineKeyboardGameButton = getInlineKeyboardGameButton;
+exports.getInlineKeyboardLoginButton = getInlineKeyboardLoginButton;
+exports.getInlineKeyboardPayButton = getInlineKeyboardPayButton;
+exports.getInlineKeyboardQueryButton = getInlineKeyboardQueryButton;
+exports.getInlineKeyboardQueryChosenChatButton = getInlineKeyboardQueryChosenChatButton;
+exports.getInlineKeyboardQueryCurrentChatButton = getInlineKeyboardQueryCurrentChatButton;
+exports.getInlineKeyboardTextButton = getInlineKeyboardTextButton;
+exports.getInlineKeyboardUrlButton = getInlineKeyboardUrlButton;
+exports.getInlineKeyboardWebAppButton = getInlineKeyboardWebAppButton;
+const callback_query_utils_1 = require("./callback-query-utils");
+function getInlineKeyboardCallbackButton(text, data, options) {
+    return { text: text, callback_data: (0, callback_query_utils_1.encodeCallbackQueryBody)(data, options) };
+}
+function getInlineKeyboardGameButton(text, game) {
+    return { text: text, callback_game: game };
+}
+function getInlineKeyboardLoginButton(text, url, fields) {
+    return { text: text, login_url: { url: url, ...fields } };
+}
+function getInlineKeyboardPayButton(text) {
+    return { text: text, pay: true };
+}
+function getInlineKeyboardQueryButton(text, query) {
+    return { text: text, switch_inline_query: query };
+}
+function getInlineKeyboardQueryChosenChatButton(text, query) {
+    return { text: text, switch_inline_query_chosen_chat: query };
+}
+function getInlineKeyboardQueryCurrentChatButton(text, query) {
+    return { text: text, switch_inline_query_current_chat: query };
+}
+function getInlineKeyboardTextButton(text) {
+    return { text: text };
+}
+function getInlineKeyboardUrlButton(text, url) {
+    return { text: text, url: url };
+}
+function getInlineKeyboardWebAppButton(text, app) {
+    return { text: text, web_app: app };
+}

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

@@ -0,0 +1,6 @@
+import type { MessageEntity } from '@aracna/telegram-bot-types';
+import type { EncodeReplyToMessageBodyOptions, ReplyToMessageBody } from '../definitions/interfaces';
+export declare function decodeReplyToMessageBody<T>(entities: MessageEntity[]): ReplyToMessageBody<T>;
+export declare function encodeReplyToMessageBody<T>(data: T, options?: EncodeReplyToMessageBodyOptions): string;
+export declare function encodeReplyToMessageBodyToAnchorTag<T>(data: T, options?: EncodeReplyToMessageBodyOptions): string;
+export declare function encodeReplyToMessageBodyToURL<T>(data: T, options?: EncodeReplyToMessageBodyOptions): string;

package/utils/reply-to-message-utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeReplyToMessageBody = decodeReplyToMessageBody;
+exports.encodeReplyToMessageBody = encodeReplyToMessageBody;
+exports.encodeReplyToMessageBodyToAnchorTag = encodeReplyToMessageBodyToAnchorTag;
+exports.encodeReplyToMessageBodyToURL = encodeReplyToMessageBodyToURL;
+const core_1 = require("@aracna/core");
+const constants_1 = require("../definitions/constants");
+function decodeReplyToMessageBody(entities) {
+    let entity, encoded, body;
+    entity = entities[entities.length - 1];
+    if (!entity?.url)
+        return (0, constants_1.DEFAULT_REPLY_TO_MESSAGE_BODY)();
+    encoded = new URL(entity.url).searchParams.get('a');
+    if (!encoded)
+        return (0, constants_1.DEFAULT_REPLY_TO_MESSAGE_BODY)();
+    body = (0, core_1.tc)(() => (0, core_1.decodeJSON)((0, core_1.decodeText)((0, core_1.decodeBase64)(encoded)), (0, constants_1.DEFAULT_DECODE_JSON_OPTIONS)()));
+    if (body instanceof Error)
+        return (0, constants_1.DEFAULT_REPLY_TO_MESSAGE_BODY)();
+    return body;
+}
+function encodeReplyToMessageBody(data, options) {
+    let body;
+    body = {
+        c: options?.chatID,
+        d: data,
+        m: options?.command
+    };
+    return (0, core_1.encodeBase64)((0, core_1.encodeText)((0, core_1.encodeJSON)(body, (0, constants_1.DEFAULT_ENCODE_JSON_OPTIONS)(), '{}')));
+}
+function encodeReplyToMessageBodyToAnchorTag(data, options) {
+    return `\n<a href="${encodeReplyToMessageBodyToURL(data, options)}">ㅤ</a>`;
+}
+function encodeReplyToMessageBodyToURL(data, options) {
+    return (0, core_1.appendSearchParamsToURL)('https://t.me', { a: encodeReplyToMessageBody(data, options) });
+}

package/utils/start-message-utils.d.ts

@@ -0,0 +1,6 @@
+import type { EncodeStartBodyOptions, StartBody } from '../definitions/interfaces';
+export declare function decodeStartBody<T>(text: string | undefined): StartBody<T>;
+export declare function encodeStartBody<T>(data: T, options?: EncodeStartBodyOptions): string;
+export declare function encodeStartBodyToAnchorTag<T>(username: string, children: string, data: T, options?: EncodeStartBodyOptions): string;
+export declare function encodeStartBodyToText<T>(data: T, options?: EncodeStartBodyOptions): string;
+export declare function encodeStartBodyToURL<T>(username: string, data: T, options?: EncodeStartBodyOptions): string;

package/utils/start-message-utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeStartBody = decodeStartBody;
+exports.encodeStartBody = encodeStartBody;
+exports.encodeStartBodyToAnchorTag = encodeStartBodyToAnchorTag;
+exports.encodeStartBodyToText = encodeStartBodyToText;
+exports.encodeStartBodyToURL = encodeStartBodyToURL;
+const core_1 = require("@aracna/core");
+const constants_1 = require("../definitions/constants");
+function decodeStartBody(text) {
+    let encoded, body;
+    if (!text) {
+        return (0, constants_1.DEFAULT_START_MESSAGE_BODY)();
+    }
+    encoded = text.replace('/start', '').trim();
+    if (encoded.length <= 0)
+        return (0, constants_1.DEFAULT_START_MESSAGE_BODY)();
+    body = (0, core_1.tc)(() => (0, core_1.decodeJSON)((0, core_1.decodeText)((0, core_1.decodeBase64)(encoded)), (0, constants_1.DEFAULT_DECODE_JSON_OPTIONS)()));
+    if (body instanceof Error)
+        return (0, constants_1.DEFAULT_START_MESSAGE_BODY)();
+    return body;
+}
+function encodeStartBody(data, options) {
+    let body;
+    body = {
+        c: options?.chatID,
+        d: data,
+        m: options?.command
+    };
+    return (0, core_1.encodeBase64)((0, core_1.encodeText)((0, core_1.encodeJSON)(body, (0, constants_1.DEFAULT_ENCODE_JSON_OPTIONS)(), '{}')));
+}
+function encodeStartBodyToAnchorTag(username, children, data, options) {
+    return `<a href="${encodeStartBodyToURL(username, data, options)}">${children}</a>`;
+}
+function encodeStartBodyToText(data, options) {
+    return `/start ${encodeStartBody(data, options)}`;
+}
+function encodeStartBodyToURL(username, data, options) {
+    return (0, core_1.appendSearchParamsToURL)(`https://t.me/${username}`, { start: encodeStartBody(data, options) });
+}

package/builders/button.builder.d.ts

@@ -1,11 +0,0 @@
-import { InlineKeyboardButton, LoginUrl } from '@aracna/telegram-bot-types';
-export 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;
-}

package/builders/button.builder.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ButtonBuilder = void 0;
-const callback_query_utils_1 = require("../utils/callback.query.utils");
-class ButtonBuilder {
-    callback(text, data, type, chatID) {
-        return { text: text, callback_data: callback_query_utils_1.CallbackQueryUtils.encodeBody(data, type, chatID) };
-    }
-    game(text, game) {
-        return { text: text, callback_game: game };
-    }
-    login(text, url, fields) {
-        return { text: text, login_url: { url: url, ...fields } };
-    }
-    pay(text) {
-        return { text: text, pay: true };
-    }
-    query(text, query) {
-        return { text: text, switch_inline_query: query };
-    }
-    queryCurrentChat(text, query) {
-        return { text: text, switch_inline_query_current_chat: query };
-    }
-    text(text) {
-        return { text: text };
-    }
-    url(text, url) {
-        return { text: text, url: url };
-    }
-}
-exports.ButtonBuilder = ButtonBuilder;

package/childs/add.d.ts

@@ -1,6 +0,0 @@
-import { FetchError } from '@aracna/core';
-import { AddStickerToSet, InputSticker, Message } from '@aracna/telegram-bot-types';
-import { Child } from '../modules/child';
-export declare class Add extends Child {
-    stickerToSet(userID: number, name: string, sticker: InputSticker, parameters: Partial<AddStickerToSet>): Promise<Message | FetchError>;
-}

package/childs/add.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Add = void 0;
-const child_1 = require("../modules/child");
-class Add extends child_1.Child {
-    async stickerToSet(userID, name, sticker, parameters) {
-        return this.telegram.api.post('addStickerToSet', { sticker: sticker, ...parameters, name: name, user_id: userID });
-    }
-}
-exports.Add = Add;

package/childs/answer.d.ts

@@ -1,9 +0,0 @@
-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/childs/answer.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Answer = void 0;
-const child_1 = require("../modules/child");
-class Answer extends child_1.Child {
-    async callbackQuery(id, parameters) {
-        return this.telegram.api.post('answerCallbackQuery', { callback_query_id: id, ...parameters });
-    }
-    async inlineQuery(id, results, parameters) {
-        return this.telegram.api.post('answerInlineQuery', { inline_query_id: id, results: results, ...parameters });
-    }
-    async preCheckoutQuery(id, ok, parameters) {
-        return this.telegram.api.post('answerPreCheckoutQuery', { ok: ok, pre_checkout_query_id: id, ...parameters });
-    }
-    async shippingQuery(id, ok, parameters) {
-        return this.telegram.api.post('answerShippingQuery', { ok: ok, shipping_query_id: id, ...parameters });
-    }
-}
-exports.Answer = Answer;

package/childs/ban.d.ts

@@ -1,6 +0,0 @@
-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/childs/ban.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ban = void 0;
-const child_1 = require("../modules/child");
-class Ban extends child_1.Child {
-    async chatMember(chatID, userID, parameters) {
-        return this.telegram.api.post('banChatMember', { chat_id: chatID, user_id: userID, ...parameters });
-    }
-}
-exports.Ban = Ban;