@aracna/telegram-bot 1.9.14 → 2.0.3

package/apis/telegram-api.d.ts

@@ -0,0 +1,9 @@
+import { type FetchError, Queue, type RequestMethod, RestAPI } from '@aracna/core';
+import { TelegramApiDefinitions } from '../definitions/telegram-api-definitions';
+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>;
+}
+export declare const TelegramAPI: API;
+export {};

package/apis/telegram-api.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramAPI = void 0;
+const core_1 = require("@aracna/core");
+class API extends core_1.RestAPI {
+    queue = new core_1.Queue({ autostart: true });
+    async post(path, body, config) {
+        let fn, callback, promise;
+        promise = new core_1.DeferredPromise();
+        fn = async () => {
+            let response;
+            response = await super.post('/bot' + config.token + '/' + path, body, config);
+            if (response instanceof Error)
+                return response;
+            return response.data.result;
+        };
+        callback = (process) => {
+            if (process.fn === fn) {
+                promise.resolve(process.value);
+                this.queue.off('process-fulfill', callback);
+            }
+        };
+        this.queue.on('process-fulfill', callback);
+        this.queue.push(fn);
+        return promise.instance;
+    }
+    async transformBody(method, path, body, config) {
+        if (method !== 'POST') {
+            return;
+        }
+        if (!(0, core_1.isObject)(body)) {
+            return;
+        }
+        for (let key in body) {
+            if (body[key] instanceof Blob) {
+                return (0, core_1.serializeFormData)(body);
+            }
+        }
+        return body;
+    }
+}
+exports.TelegramAPI = new API('https://api.telegram.org', {
+    decode: {
+        json: {
+            castBigIntStringToBigInt: true,
+            castUnsafeIntToBigInt: true
+        }
+    },
+    encode: {
+        json: {
+            castBigIntToString: true
+        }
+    },
+    token: undefined
+});

package/apis/telegram-file-api.d.ts

@@ -0,0 +1,7 @@
+import { type FetchError, RestAPI } from '@aracna/core';
+import { TelegramApiDefinitions } from '../definitions/telegram-api-definitions';
+declare class API extends RestAPI<TelegramApiDefinitions.Config> {
+    get<V, W = undefined>(path: string, config: TelegramApiDefinitions.Config): Promise<V | FetchError<W>>;
+}
+export declare const TelegramFileAPI: API;
+export {};

package/apis/telegram-file-api.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramFileAPI = void 0;
+const core_1 = require("@aracna/core");
+class API extends core_1.RestAPI {
+    async get(path, config) {
+        let response;
+        response = await super.get('/file/bot' + config.token + '/' + path, config);
+        if (response instanceof Error)
+            return response;
+        return response.data;
+    }
+}
+exports.TelegramFileAPI = new API('https://api.telegram.org');

package/classes/client.d.ts

@@ -0,0 +1,46 @@
+import { FetchError } from '@aracna/core';
+import type { BotCommand, BusinessConnection, BusinessMessagesDeleted, CallbackQuery, ChatBoostRemoved, ChatBoostUpdated, ChatJoinRequest, ChatMemberUpdated, ChosenInlineResult, InlineQuery, Message, MessageReactionCountUpdated, MessageReactionUpdated, Poll, PollAnswer, PreCheckoutQuery, ShippingQuery, Update } from '@aracna/telegram-bot-types';
+import type { ClientConnectionOptions, ClientConnectionOptionsPolling, ClientDisconnectOptions, ClientListener, ClientListenerOptions } from '../definitions/interfaces';
+import type { ClientConnectionMode, ClientListenerMiddleware, UpdateType } from '../definitions/types';
+export declare class Client {
+    protected listeners: ClientListener[];
+    protected readonly id: string;
+    protected offset?: number;
+    protected token: string;
+    constructor(token: string);
+    connect(mode: ClientConnectionMode, options?: ClientConnectionOptions): Promise<void | FetchError | Error>;
+    disconnect(options?: ClientDisconnectOptions): Promise<void>;
+    on<T extends UpdateType, U extends ClientListenerOptions>(type: T, middleware: ClientListenerMiddleware<T>, options?: U): void;
+    handle(update: Update): void;
+    protected handleBusinessConnection(connection: BusinessConnection): ClientListener | undefined;
+    protected handleBusinessMessage(message: Message): ClientListener | undefined;
+    protected handleCallbackQuery(query: CallbackQuery): ClientListener | undefined;
+    protected handleChannelPost(post: Message): ClientListener | undefined;
+    protected handleChatBoost(boost: ChatBoostUpdated): ClientListener | undefined;
+    protected handleChatJoinRequest(request: ChatJoinRequest): ClientListener | undefined;
+    protected handleChatMember(member: ChatMemberUpdated): ClientListener | undefined;
+    protected handleChosenInlineResult(result: ChosenInlineResult): ClientListener | undefined;
+    protected handleDeletedBusinessMessages(deleted: BusinessMessagesDeleted): ClientListener | undefined;
+    protected handleEditedBusinessMessage(message: Message): ClientListener | undefined;
+    protected handleEditedChannelPost(post: Message): ClientListener | undefined;
+    protected handleEditedMessage(message: Message): ClientListener | undefined;
+    protected handleInlineQuery(query: InlineQuery): ClientListener | undefined;
+    protected handleMessage(message: Message): ClientListener | undefined;
+    protected handleMessageReaction(reaction: MessageReactionUpdated): ClientListener | undefined;
+    protected handleMessageReactionCount(count: MessageReactionCountUpdated): ClientListener | undefined;
+    protected handleMyChatMember(member: ChatMemberUpdated): ClientListener | undefined;
+    protected handlePoll(poll: Poll): ClientListener | undefined;
+    protected handlePollAnswer(answer: PollAnswer): ClientListener | undefined;
+    protected handlePreCheckoutQuery(query: PreCheckoutQuery): ClientListener | undefined;
+    protected handleRemovedChatBoost(removed: ChatBoostRemoved): ClientListener | undefined;
+    protected handleReplyToMessage(reply: Message): ClientListener | undefined;
+    protected handleShippingQuery(query: ShippingQuery): ClientListener | undefined;
+    protected handleStart(start: Message): ClientListener | undefined;
+    protected poll(options?: ClientConnectionOptionsPolling): Promise<void>;
+    protected findListener<T extends UpdateType, U extends ClientListenerOptions>(type: UpdateType, command?: string): ClientListener<T, U> | undefined;
+    getCommands(): BotCommand[];
+    getListeners(): ClientListener[];
+    getToken(): string;
+    setToken(token: string): this;
+    protected get listenerIDs(): string[];
+}

package/classes/client.js

@@ -0,0 +1,409 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const core_1 = require("@aracna/core");
+const constants_1 = require("../definitions/constants");
+const class_logger_1 = require("../loggers/class-logger");
+const delete_requests_1 = require("../requests/delete-requests");
+const get_requests_1 = require("../requests/get-requests");
+const webhook_requests_1 = require("../requests/webhook-requests");
+const callback_query_utils_1 = require("../utils/callback-query-utils");
+const command_utils_1 = require("../utils/command-utils");
+const reply_to_message_utils_1 = require("../utils/reply-to-message-utils");
+const start_message_utils_1 = require("../utils/start-message-utils");
+class Client {
+    listeners;
+    id;
+    offset;
+    token;
+    constructor(token) {
+        this.listeners = [];
+        this.id = (0, core_1.generateRandomString)({ prefix: 'telegram-client' });
+        this.token = token;
+    }
+    async connect(mode, options) {
+        switch (mode) {
+            case 'polling':
+                (0, core_1.setInterval)(() => this.poll(options?.polling), options?.polling?.ms ?? constants_1.DEFAULT_CLIENT_POLLING_MS, this.id, { autorun: true });
+                class_logger_1.ClassLogger.info('Telegram', 'connect', `The client is now polling the updates.`);
+                break;
+            case 'webhook': {
+                let del, set;
+                if (!options?.webhook?.url) {
+                    return new Error(`The webhook URL is required.`);
+                }
+                del = await (0, webhook_requests_1.deleteWebhook)(this.token, options.webhook.delete);
+                if (del instanceof Error)
+                    return del;
+                class_logger_1.ClassLogger.verbose('Telegram', 'connect', `The webhook has been deleted.`);
+                set = await (0, webhook_requests_1.setWebhook)(this.token, options.webhook);
+                if (set instanceof Error)
+                    return set;
+                class_logger_1.ClassLogger.info('Telegram', 'connect', `The webhook has been set.`);
+                break;
+            }
+        }
+    }
+    async disconnect(options) {
+        this.offset = undefined;
+        class_logger_1.ClassLogger.verbose('Telegram', 'disconnect', `The offset has been reset.`, [this.offset]);
+        (0, core_1.clearInterval)(this.id);
+        class_logger_1.ClassLogger.info('Telegram', 'disconnect', `The client has been disconnected.`);
+        await (0, webhook_requests_1.deleteWebhook)(this.token, options?.webhook);
+        class_logger_1.ClassLogger.info('Telegram', 'disconnect', `The webhook has been deleted.`);
+    }
+    on(type, middleware, options) {
+        let listener, potential;
+        listener = {
+            command: options?.command,
+            description: options?.description,
+            id: (0, core_1.generateRandomString)({ blacklist: this.listenerIDs }),
+            middleware: middleware,
+            type: type,
+            options: (0, core_1.mergeObjects)((0, constants_1.DEFAULT_CLIENT_LISTENER_OPTIONS)(), (0, core_1.omitObjectProperties)(options ?? {}, ['description', 'key']))
+        };
+        potential = this.findListener(listener.type, listener.command);
+        if (potential) {
+            potential.middleware = middleware;
+            class_logger_1.ClassLogger.verbose('Telegram', 'register', `The listener has been updated.`, listener);
+            return;
+        }
+        this.listeners.push(listener);
+        class_logger_1.ClassLogger.verbose('Telegram', 'register', `The listener has been registered.`, listener);
+    }
+    handle(update) {
+        let listener;
+        switch (true) {
+            case (0, core_1.hasObjectProperty)(update, 'business_connection'):
+                listener = this.handleBusinessConnection(update.business_connection);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'business_message'):
+                listener = this.handleBusinessMessage(update.business_message);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'callback_query.data'):
+                listener = this.handleCallbackQuery(update.callback_query);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'channel_post'):
+                listener = this.handleChannelPost(update.channel_post);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'chat_boost'):
+                listener = this.handleChatBoost(update.chat_boost);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'chat_join_request'):
+                listener = this.handleChatJoinRequest(update.chat_join_request);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'chat_member'):
+                listener = this.handleChatMember(update.chat_member);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'chosen_inline_result'):
+                listener = this.handleChosenInlineResult(update.chosen_inline_result);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'deleted_business_messages'):
+                listener = this.handleDeletedBusinessMessages(update.deleted_business_messages);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'edited_business_message'):
+                listener = this.handleEditedBusinessMessage(update.edited_business_message);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'edited_channel_post'):
+                listener = this.handleEditedChannelPost(update.edited_channel_post);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'edited_message'):
+                listener = this.handleEditedMessage(update.edited_message);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'inline_query'):
+                listener = this.handleInlineQuery(update.inline_query);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'message_reaction'):
+                listener = this.handleMessageReaction(update.message_reaction);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'message_reaction_count'):
+                listener = this.handleMessageReactionCount(update.message_reaction_count);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'message.reply_to_message.text'):
+                listener = this.handleReplyToMessage(update.message);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'message'):
+                if (update.message?.text?.startsWith('/start')) {
+                    listener = this.handleStart(update.message);
+                    break;
+                }
+                listener = this.handleMessage(update.message);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'my_chat_member'):
+                listener = this.handleMyChatMember(update.my_chat_member);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'poll'):
+                listener = this.handlePoll(update.poll);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'poll_answer'):
+                listener = this.handlePollAnswer(update.poll_answer);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'pre_checkout_query'):
+                listener = this.handlePreCheckoutQuery(update.pre_checkout_query);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'removed_chat_boost'):
+                listener = this.handleRemovedChatBoost(update.removed_chat_boost);
+                break;
+            case (0, core_1.hasObjectProperty)(update, 'shipping_query'):
+                listener = this.handleShippingQuery(update.shipping_query);
+                break;
+            default:
+                return class_logger_1.ClassLogger.error('Telegram', 'handle', `Failed to handle the update.`, update);
+        }
+        if (listener) {
+            return class_logger_1.ClassLogger.info('Telegram', 'handle', `A ${listener.type} update has been handled.`, update, listener);
+        }
+        class_logger_1.ClassLogger.warn('Telegram', 'handle', `Failed to find the matching listener.`, update);
+    }
+    handleBusinessConnection(connection) {
+        let listener;
+        listener = this.findListener('business_connection');
+        if (!listener)
+            return;
+        listener.middleware(connection);
+        return listener;
+    }
+    handleBusinessMessage(message) {
+        let listener;
+        listener = this.findListener('business_message');
+        if (!listener)
+            return;
+        listener.middleware(message);
+        return listener;
+    }
+    handleCallbackQuery(query) {
+        let listener, body;
+        body = (0, callback_query_utils_1.decodeCallbackQueryBody)(query.data);
+        (0, core_1.setObjectProperty)(query, 'body', body);
+        listener = this.findListener('callback_query', body.m);
+        if (!listener)
+            return;
+        listener.middleware(query);
+        if (listener.options.deleteOnCallbackQuery && query.message) {
+            (0, delete_requests_1.deleteMessage)(this.token, { chat_id: body.c ? query.from.id : query.message.chat.id, message_id: query.message.message_id });
+        }
+        return listener;
+    }
+    handleChannelPost(post) {
+        let listener;
+        listener = this.findListener('channel_post');
+        if (!listener)
+            return;
+        listener.middleware(post);
+        return listener;
+    }
+    handleChatBoost(boost) {
+        let listener;
+        listener = this.findListener('chat_boost');
+        if (!listener)
+            return;
+        listener.middleware(boost);
+        return listener;
+    }
+    handleChatJoinRequest(request) {
+        let listener;
+        listener = this.findListener('chat_join_request');
+        if (!listener)
+            return;
+        listener.middleware(request);
+        return listener;
+    }
+    handleChatMember(member) {
+        let listener;
+        listener = this.findListener('chat_member');
+        if (!listener)
+            return;
+        listener.middleware(member);
+        return listener;
+    }
+    handleChosenInlineResult(result) {
+        let listener;
+        listener = this.findListener('chosen_inline_result');
+        if (!listener)
+            return;
+        listener.middleware(result);
+        return listener;
+    }
+    handleDeletedBusinessMessages(deleted) {
+        let listener;
+        listener = this.findListener('deleted_business_messages');
+        if (!listener)
+            return;
+        listener.middleware(deleted);
+        return listener;
+    }
+    handleEditedBusinessMessage(message) {
+        let listener;
+        listener = this.findListener('edited_business_message');
+        if (!listener)
+            return;
+        listener.middleware(message);
+        return listener;
+    }
+    handleEditedChannelPost(post) {
+        let listener;
+        listener = this.findListener('edited_channel_post');
+        if (!listener)
+            return;
+        listener.middleware(post);
+        return listener;
+    }
+    handleEditedMessage(message) {
+        let listener;
+        listener = this.findListener('edited_message');
+        if (!listener)
+            return;
+        listener.middleware(message);
+        return listener;
+    }
+    handleInlineQuery(query) {
+        let listener;
+        listener = this.findListener('inline_query');
+        if (!listener)
+            return;
+        listener.middleware(query);
+        return listener;
+    }
+    handleMessage(message) {
+        let listener;
+        listener = this.findListener('message', (0, command_utils_1.getCommand)(message.text));
+        if (!listener)
+            return;
+        listener.middleware(message);
+        return listener;
+    }
+    handleMessageReaction(reaction) {
+        let listener;
+        listener = this.findListener('message_reaction');
+        if (!listener)
+            return;
+        listener.middleware(reaction);
+        return listener;
+    }
+    handleMessageReactionCount(count) {
+        let listener;
+        listener = this.findListener('message_reaction_count');
+        if (!listener)
+            return;
+        listener.middleware(count);
+        return listener;
+    }
+    handleMyChatMember(member) {
+        let listener;
+        listener = this.findListener('my_chat_member');
+        if (!listener)
+            return;
+        listener.middleware(member);
+        return listener;
+    }
+    handlePoll(poll) {
+        let listener;
+        listener = this.findListener('poll');
+        if (!listener)
+            return;
+        listener.middleware(poll);
+        return listener;
+    }
+    handlePollAnswer(answer) {
+        let listener;
+        listener = this.findListener('poll_answer');
+        if (!listener)
+            return;
+        listener.middleware(answer);
+        return listener;
+    }
+    handlePreCheckoutQuery(query) {
+        let listener;
+        listener = this.findListener('pre_checkout_query');
+        if (!listener)
+            return;
+        listener.middleware(query);
+        return listener;
+    }
+    handleRemovedChatBoost(removed) {
+        let listener;
+        listener = this.findListener('removed_chat_boost');
+        if (!listener)
+            return;
+        listener.middleware(removed);
+        return listener;
+    }
+    handleReplyToMessage(reply) {
+        let body, listener;
+        body = (0, reply_to_message_utils_1.decodeReplyToMessageBody)(reply.reply_to_message?.entities ?? []);
+        (0, core_1.setObjectProperty)(reply, 'body', body);
+        listener = this.findListener('reply_to_message', body.m);
+        if (!listener)
+            return;
+        listener.middleware(reply);
+        if (listener.id.length > 0 && listener.options.deleteOnReply && reply.from && reply.reply_to_message) {
+            (0, delete_requests_1.deleteMessages)(this.token, { chat_id: reply.from.id, message_ids: [reply.message_id, reply.reply_to_message.message_id] });
+        }
+        return listener;
+    }
+    handleShippingQuery(query) {
+        let listener;
+        listener = this.findListener('shipping_query');
+        if (!listener)
+            return;
+        listener.middleware(query);
+        return listener;
+    }
+    handleStart(start) {
+        let listener, body;
+        body = (0, start_message_utils_1.decodeStartBody)(start.text);
+        (0, core_1.setObjectProperty)(start, 'body', body);
+        listener = this.findListener('start', body.m);
+        if (!listener)
+            return;
+        listener.middleware(start);
+        if (listener.id.length > 0 && listener.options.deleteOnMessageStart) {
+            (0, delete_requests_1.deleteMessage)(this.token, { chat_id: body.c ? start.from?.id ?? 0n : start.chat.id, message_id: start.message_id });
+        }
+        return listener;
+    }
+    async poll(options) {
+        let body, updates;
+        body = {
+            allowed_updates: options?.allowed_updates ?? constants_1.DEFAULT_ALLOWED_UPDATES,
+            limit: options?.limit,
+            offset: options?.offset ?? this.offset,
+            timeout: options?.timeout
+        };
+        updates = await (0, get_requests_1.getUpdates)(this.token, body);
+        if (updates instanceof Error)
+            return;
+        for (let update of updates) {
+            this.handle(update);
+        }
+        this.offset = updates.length > 0 ? updates[updates.length - 1].update_id + 1 : this.offset;
+        class_logger_1.ClassLogger.verbose('Telegram', 'poll', `The offset has been set.`, [this.offset]);
+        if (typeof options?.offset === 'number' && typeof this.offset === 'number' && (0, core_1.isIntervalSet)(this.id)) {
+            (0, core_1.clearInterval)(this.id);
+            (0, core_1.setInterval)(() => this.poll({ ...options, offset: undefined }), options?.ms ?? constants_1.DEFAULT_CLIENT_POLLING_MS, this.id, { autorun: true });
+        }
+    }
+    findListener(type, command) {
+        return this.listeners.find((listener) => listener.command === command && listener.type === type);
+    }
+    getCommands() {
+        return this.listeners
+            .filter((listener) => typeof listener.command === 'string' && listener.type === 'message')
+            .map((listener) => ({ command: listener.command ?? '', description: listener.description ?? '' }));
+    }
+    getListeners() {
+        return this.listeners;
+    }
+    getToken() {
+        return this.token;
+    }
+    setToken(token) {
+        this.token = token;
+        class_logger_1.ClassLogger.verbose('Telegram', 'setToken', `The token has been set.`, [this.token]);
+        return this;
+    }
+    get listenerIDs() {
+        return this.listeners.reduce((r, v) => [...r, v.id], []);
+    }
+}
+exports.Client = Client;

package/definitions/constants.d.ts

@@ -1,2 +1,12 @@
+import { DecodeJsonOptions, EncodeJsonOptions } from '@aracna/core';
+import { CallbackQueryBody, ClientListenerOptions, ReplyToMessageBody, StartBody } from './interfaces';
+export declare const DEFAULT_ALLOWED_UPDATES: string[];
+export declare const DEFAULT_CALLBACK_QUERY_BODY: () => CallbackQueryBody<any>;
+export declare const DEFAULT_CLIENT_LISTENER_OPTIONS: () => ClientListenerOptions;
+export declare const DEFAULT_CLIENT_POLLING_MS: number;
+export declare const DEFAULT_DECODE_JSON_OPTIONS: () => DecodeJsonOptions;
+export declare const DEFAULT_ENCODE_JSON_OPTIONS: () => EncodeJsonOptions;
+export declare const DEFAULT_REPLY_TO_MESSAGE_BODY: () => ReplyToMessageBody<any>;
+export declare const DEFAULT_START_MESSAGE_BODY: () => StartBody<any>;
 export declare const REGEXP_COMMAND: RegExp;
 export declare const REGEXP_COMMAND_WITH_USERNAME: RegExp;

package/definitions/constants.js

@@ -1,5 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REGEXP_COMMAND_WITH_USERNAME = exports.REGEXP_COMMAND = void 0;
+exports.REGEXP_COMMAND_WITH_USERNAME = exports.REGEXP_COMMAND = exports.DEFAULT_START_MESSAGE_BODY = exports.DEFAULT_REPLY_TO_MESSAGE_BODY = exports.DEFAULT_ENCODE_JSON_OPTIONS = exports.DEFAULT_DECODE_JSON_OPTIONS = exports.DEFAULT_CLIENT_POLLING_MS = exports.DEFAULT_CLIENT_LISTENER_OPTIONS = exports.DEFAULT_CALLBACK_QUERY_BODY = exports.DEFAULT_ALLOWED_UPDATES = void 0;
+exports.DEFAULT_ALLOWED_UPDATES = [
+    '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',
+    'shipping_query'
+];
+const DEFAULT_CALLBACK_QUERY_BODY = () => ({
+    d: null
+});
+exports.DEFAULT_CALLBACK_QUERY_BODY = DEFAULT_CALLBACK_QUERY_BODY;
+const DEFAULT_CLIENT_LISTENER_OPTIONS = () => ({
+    deleteOnCallbackQuery: false,
+    deleteOnMessageStart: false,
+    deleteOnReply: false
+});
+exports.DEFAULT_CLIENT_LISTENER_OPTIONS = DEFAULT_CLIENT_LISTENER_OPTIONS;
+exports.DEFAULT_CLIENT_POLLING_MS = 1000;
+const DEFAULT_DECODE_JSON_OPTIONS = () => ({
+    castBigIntStringToBigInt: true,
+    castUnsafeIntToBigInt: true
+});
+exports.DEFAULT_DECODE_JSON_OPTIONS = DEFAULT_DECODE_JSON_OPTIONS;
+const DEFAULT_ENCODE_JSON_OPTIONS = () => ({
+    castBigIntToString: true
+});
+exports.DEFAULT_ENCODE_JSON_OPTIONS = DEFAULT_ENCODE_JSON_OPTIONS;
+const DEFAULT_REPLY_TO_MESSAGE_BODY = () => ({
+    d: null
+});
+exports.DEFAULT_REPLY_TO_MESSAGE_BODY = DEFAULT_REPLY_TO_MESSAGE_BODY;
+const DEFAULT_START_MESSAGE_BODY = () => ({
+    d: null
+});
+exports.DEFAULT_START_MESSAGE_BODY = DEFAULT_START_MESSAGE_BODY;
 exports.REGEXP_COMMAND = /\/[a-z_]+/m;
 exports.REGEXP_COMMAND_WITH_USERNAME = /\/[a-zA-Z0-9_@]+/;

package/definitions/enums.d.ts

@@ -1,22 +1,3 @@
 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"
+    CLASS = "TELEGRAM_CLASS"
 }

package/definitions/enums.js

@@ -1,27 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UpdateType = exports.LoggerName = void 0;
+exports.LoggerName = void 0;
 var LoggerName;
 (function (LoggerName) {
-    LoggerName["MODULE"] = "TELEGRAM_MODULE";
+    LoggerName["CLASS"] = "TELEGRAM_CLASS";
 })(LoggerName || (exports.LoggerName = 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 = UpdateType = {}));