rubjs 3.0.1 → 3.1.2

package/lib/core/bot/methods/messages/editChatKeypad.d.ts

@@ -0,0 +1,4 @@
+import Bot from '../../bot';
+import { ChatKeypadTypeEnum, Keypad } from '../../types/models';
+declare function editChatKeypad(this: Bot, chat_id: string, chat_keypad: Keypad, chat_keypad_type?: ChatKeypadTypeEnum): Promise<any>;
+export default editChatKeypad;

package/lib/core/bot/methods/messages/editChatKeypad.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("../../types/models");
+async function editChatKeypad(chat_id, chat_keypad, chat_keypad_type = models_1.ChatKeypadTypeEnum.New) {
+    const data = {
+        chat_id,
+        chat_keypad,
+        chat_keypad_type,
+    };
+    return await this.builder('editChatKeypad', data);
+}
+exports.default = editChatKeypad;

package/lib/core/bot/methods/messages/editMessageKeypad.d.ts

@@ -0,0 +1,4 @@
+import Bot from '../../bot';
+import { InlineKeypad } from '../../types/models';
+declare function editMessageKeypad(this: Bot, chat_id: string, message_id: string, inline_keypad?: InlineKeypad): Promise<any>;
+export default editMessageKeypad;

package/lib/core/bot/methods/messages/editMessageKeypad.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function editMessageKeypad(chat_id, message_id, inline_keypad) {
+    const data = {
+        chat_id,
+        message_id,
+        inline_keypad,
+    };
+    return await this.builder('editMessageKeypad', data);
+}
+exports.default = editMessageKeypad;

package/lib/core/bot/methods/messages/editMessageText.d.ts

@@ -0,0 +1,3 @@
+import Bot from '../../bot';
+declare function editMessageText(this: Bot, chat_id: string, text: string, message_id: string): Promise<any>;
+export default editMessageText;

package/lib/core/bot/methods/messages/editMessageText.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function editMessageText(chat_id, text, message_id) {
+    return await this.builder('editMessageText', {
+        chat_id,
+        message_id,
+        text,
+    });
+}
+exports.default = editMessageText;

package/lib/core/bot/methods/messages/forwardMessage.d.ts

@@ -0,0 +1,3 @@
+import Bot from '../../bot';
+declare function forwardMessage(this: Bot, from_chat_id: string, message_id: string, to_chat_id: string, disable_notification?: boolean): Promise<any>;
+export default forwardMessage;

package/lib/core/bot/methods/messages/forwardMessage.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function forwardMessage(from_chat_id, message_id, to_chat_id, disable_notification = false) {
+    return await this.builder('forwardMessage', {
+        from_chat_id,
+        message_id,
+        to_chat_id,
+        disable_notification,
+    });
+}
+exports.default = forwardMessage;

package/lib/core/bot/methods/messages/index.d.ts

@@ -0,0 +1,10 @@
+import deleteMessage from './deleteMessage';
+import editChatKeypad from './editChatKeypad';
+import editMessageKeypad from './editMessageKeypad';
+import editMessageText from './editMessageText';
+import forwardMessage from './forwardMessage';
+import sendContact from './sendContact';
+import sendLocation from './sendLocation';
+import sendMessage from './sendMessage';
+import sendPoll from './sendPoll';
+export { sendMessage, sendPoll, sendLocation, sendContact, forwardMessage, editMessageText, deleteMessage, editMessageKeypad, editChatKeypad, };

package/lib/core/bot/methods/messages/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editChatKeypad = exports.editMessageKeypad = exports.deleteMessage = exports.editMessageText = exports.forwardMessage = exports.sendContact = exports.sendLocation = exports.sendPoll = exports.sendMessage = void 0;
+const deleteMessage_1 = __importDefault(require("./deleteMessage"));
+exports.deleteMessage = deleteMessage_1.default;
+const editChatKeypad_1 = __importDefault(require("./editChatKeypad"));
+exports.editChatKeypad = editChatKeypad_1.default;
+const editMessageKeypad_1 = __importDefault(require("./editMessageKeypad"));
+exports.editMessageKeypad = editMessageKeypad_1.default;
+const editMessageText_1 = __importDefault(require("./editMessageText"));
+exports.editMessageText = editMessageText_1.default;
+const forwardMessage_1 = __importDefault(require("./forwardMessage"));
+exports.forwardMessage = forwardMessage_1.default;
+const sendContact_1 = __importDefault(require("./sendContact"));
+exports.sendContact = sendContact_1.default;
+const sendLocation_1 = __importDefault(require("./sendLocation"));
+exports.sendLocation = sendLocation_1.default;
+const sendMessage_1 = __importDefault(require("./sendMessage"));
+exports.sendMessage = sendMessage_1.default;
+const sendPoll_1 = __importDefault(require("./sendPoll"));
+exports.sendPoll = sendPoll_1.default;

package/lib/core/bot/methods/messages/sendContact.d.ts

@@ -0,0 +1,4 @@
+import Bot from '../../bot';
+import { ChatKeypadTypeEnum, Keypad } from '../../types/models';
+declare function sendContact(this: Bot, chat_id: string, first_name: string, last_name: string, phone_number: string, chat_keypad: Keypad, inline_keypad: Keypad, disable_notification?: boolean, reply_to_message_id?: string, chat_keypad_type?: ChatKeypadTypeEnum): Promise<any>;
+export default sendContact;

package/lib/core/bot/methods/messages/sendContact.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("../../types/models");
+async function sendContact(chat_id, first_name, last_name, phone_number, chat_keypad, inline_keypad, disable_notification = false, reply_to_message_id, chat_keypad_type) {
+    const data = {
+        chat_id,
+        first_name,
+        last_name,
+        phone_number,
+        chat_keypad,
+        inline_keypad,
+        disable_notification,
+        reply_to_message_id,
+        chat_keypad_type,
+    };
+    if (chat_keypad && !chat_keypad_type) {
+        data.chat_keypad_type = models_1.ChatKeypadTypeEnum.New;
+    }
+    if (inline_keypad && chat_keypad_type) {
+        data.chat_keypad_type = models_1.ChatKeypadTypeEnum.None;
+    }
+    return await this.builder('sendContact', data);
+}
+exports.default = sendContact;

package/lib/core/bot/methods/messages/sendLocation.d.ts

@@ -0,0 +1,4 @@
+import Bot from '../../bot';
+import { ChatKeypadTypeEnum, Keypad } from '../../types/models';
+declare function sendLocation(this: Bot, chat_id: string, latitude: string, longitude: string, chat_keypad: Keypad, inline_keypad: Keypad, disable_notification?: boolean, reply_to_message_id?: string, chat_keypad_type?: ChatKeypadTypeEnum): Promise<any>;
+export default sendLocation;

package/lib/core/bot/methods/messages/sendLocation.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("../../types/models");
+async function sendLocation(chat_id, latitude, longitude, chat_keypad, inline_keypad, disable_notification = false, reply_to_message_id, chat_keypad_type) {
+    const data = {
+        chat_id,
+        latitude,
+        longitude,
+        chat_keypad,
+        inline_keypad,
+        disable_notification,
+        reply_to_message_id,
+        chat_keypad_type,
+    };
+    if (chat_keypad && !chat_keypad_type) {
+        data.chat_keypad_type = models_1.ChatKeypadTypeEnum.New;
+    }
+    if (inline_keypad && chat_keypad_type) {
+        data.chat_keypad_type = models_1.ChatKeypadTypeEnum.None;
+    }
+    return await this.builder('sendLocation', data);
+}
+exports.default = sendLocation;

package/lib/core/bot/methods/messages/sendMessage.d.ts

@@ -0,0 +1,4 @@
+import Bot from '../../bot';
+import { ChatKeypadTypeEnum, InlineKeypad, Keypad } from '../../types/models';
+declare function sendMessage(this: Bot, chat_id: string, text: string, chat_keypad?: Keypad, inline_keypad?: InlineKeypad, disable_notification?: boolean, reply_to_message_id?: string, chat_keypad_type?: ChatKeypadTypeEnum): Promise<any>;
+export default sendMessage;

package/lib/core/bot/methods/messages/sendMessage.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("../../types/models");
+async function sendMessage(chat_id, text, chat_keypad, inline_keypad, disable_notification = false, reply_to_message_id, chat_keypad_type) {
+    const data = {
+        chat_id,
+        text,
+        chat_keypad,
+        inline_keypad,
+        disable_notification,
+        reply_to_message_id,
+        chat_keypad_type,
+    };
+    if (chat_keypad && !chat_keypad_type) {
+        data.chat_keypad_type = models_1.ChatKeypadTypeEnum.New;
+    }
+    if (inline_keypad && chat_keypad_type) {
+        data.chat_keypad_type = models_1.ChatKeypadTypeEnum.None;
+    }
+    return await this.builder('sendMessage', data);
+}
+exports.default = sendMessage;

package/lib/core/bot/methods/messages/sendPoll.d.ts

@@ -0,0 +1,3 @@
+import Bot from '../../bot';
+declare function sendPoll(this: Bot, chat_id: string, question: string, options: string[]): Promise<any>;
+export default sendPoll;

package/lib/core/bot/methods/messages/sendPoll.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function sendPoll(chat_id, question, options) {
+    return await this.builder('sendPoll', { chat_id, question, options });
+}
+exports.default = sendPoll;

package/lib/core/bot/methods/settings/index.d.ts

@@ -0,0 +1,3 @@
+import setCommands from './setCommands';
+import updateBotEndpoints from './updateBotEndpoints';
+export { setCommands, updateBotEndpoints };

package/lib/core/bot/methods/settings/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateBotEndpoints = exports.setCommands = void 0;
+const setCommands_1 = __importDefault(require("./setCommands"));
+exports.setCommands = setCommands_1.default;
+const updateBotEndpoints_1 = __importDefault(require("./updateBotEndpoints"));
+exports.updateBotEndpoints = updateBotEndpoints_1.default;

package/lib/core/bot/methods/settings/setCommands.d.ts

@@ -0,0 +1,4 @@
+import Bot from '../../bot';
+import { Commend } from '../../types/models';
+declare function setCommands(this: Bot, commands: Commend[]): Promise<any>;
+export default setCommands;

package/lib/core/bot/methods/settings/setCommands.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function setCommands(commands) {
+    return await this.builder('setCommands', { bot_commands: commands });
+}
+exports.default = setCommands;

package/lib/core/bot/methods/settings/updateBotEndpoints.d.ts

@@ -0,0 +1,4 @@
+import Bot from '../../bot';
+import { UpdateEndpointTypeEnum } from '../../types/models';
+declare function updateBotEndpoints(this: Bot, url: string, endpoint_type: UpdateEndpointTypeEnum): Promise<any>;
+export default updateBotEndpoints;

package/lib/core/bot/methods/settings/updateBotEndpoints.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function updateBotEndpoints(url, endpoint_type) {
+    return await this.builder('updateBotEndpoints', {
+        url,
+        type: endpoint_type,
+    });
+}
+exports.default = updateBotEndpoints;

package/lib/core/bot/methods/utilities/getUpdates.d.ts

@@ -0,0 +1,3 @@
+import Bot from '../../bot';
+declare function getUpdates(this: Bot, offset_id?: string, limit?: number): Promise<any>;
+export default getUpdates;

package/lib/core/bot/methods/utilities/getUpdates.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function getUpdates(offset_id, limit = 10) {
+    return await this.builder('getUpdates', { offset_id, limit });
+}
+exports.default = getUpdates;

package/lib/core/bot/methods/utilities/handleUpdates.d.ts

@@ -0,0 +1,4 @@
+import { FastifyReply, FastifyRequest } from 'fastify';
+import Bot from '../../bot';
+declare function handleUpdates(this: Bot, req: FastifyRequest, res: FastifyReply): Promise<never>;
+export default handleUpdates;

package/lib/core/bot/methods/utilities/handleUpdates.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const message_context_1 = __importDefault(require("../../contexts/message.context"));
+const inline_context_1 = __importDefault(require("../../contexts/inline.context"));
+const models_1 = require("../../types/models");
+const checkFilters_1 = require("../../../../utils/checkFilters");
+const checkTypes = [models_1.UpdateTypeEnum.UpdatedMessage, models_1.UpdateTypeEnum.NewMessage];
+async function handleUpdates(req, res) {
+    const data = req.body;
+    if (data?.update) {
+        for (let { prefix, filters, handler } of this.handlers.message) {
+            const ctx = new message_context_1.default(this, data.update);
+            const passed = await (0, checkFilters_1.checkFilters)(ctx, filters);
+            if (passed) {
+                if (prefix) {
+                    if (!checkTypes.includes(ctx.type))
+                        continue;
+                    const text = ctx.updated_message?.text || ctx.new_message?.text || '';
+                    if (typeof prefix === 'string' && text !== prefix)
+                        continue;
+                    if (prefix instanceof RegExp && !prefix.test(text))
+                        continue;
+                }
+                await handler(ctx);
+            }
+        }
+    }
+    else if (data?.inline_message) {
+        for (let { filters, handler } of this.handlers.inline) {
+            const ctx = new inline_context_1.default(this, data.inline_message);
+            const passed = await (0, checkFilters_1.checkFilters)(ctx, filters);
+            if (passed)
+                await handler(ctx);
+        }
+    }
+    return res.code(200).send({ status: 'OK' });
+}
+exports.default = handleUpdates;

package/lib/core/bot/methods/utilities/index.d.ts

@@ -0,0 +1,5 @@
+import run from './run';
+import start from './start';
+import getUpdates from './getUpdates';
+import setupWebhook from './webhook';
+export { run, start, getUpdates, setupWebhook };

package/lib/core/bot/methods/utilities/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWebhook = exports.getUpdates = exports.start = exports.run = void 0;
+const run_1 = __importDefault(require("./run"));
+exports.run = run_1.default;
+const start_1 = __importDefault(require("./start"));
+exports.start = start_1.default;
+const getUpdates_1 = __importDefault(require("./getUpdates"));
+exports.getUpdates = getUpdates_1.default;
+const webhook_1 = __importDefault(require("./webhook"));
+exports.setupWebhook = webhook_1.default;

package/lib/core/bot/methods/utilities/run.d.ts

@@ -0,0 +1,4 @@
+import Bot from '../../bot';
+import { UpdateEndpointTypeEnum } from '../../types/models';
+declare function run(this: Bot, url?: string, host?: string, port?: number, updates?: UpdateEndpointTypeEnum[]): Promise<void>;
+export default run;

package/lib/core/bot/methods/utilities/run.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("../../types/models");
+async function run(url, host, port = 3000, updates = [
+    models_1.UpdateEndpointTypeEnum.ReceiveInlineMessage,
+    models_1.UpdateEndpointTypeEnum.ReceiveUpdate,
+]) {
+    while (!this.initialize) {
+        await this.network.delay(2000);
+    }
+    await this.setupWebhook(url, host, port, updates);
+}
+exports.default = run;

package/lib/core/bot/methods/utilities/start.d.ts

@@ -0,0 +1,3 @@
+import Bot from '../../bot';
+declare function start(this: Bot, token?: string): Promise<void>;
+export default start;

package/lib/core/bot/methods/utilities/start.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompt_1 = __importDefault(require("../../../../utils/prompt"));
+async function start(token) {
+    if (!token) {
+        const DB = this.sessionDB.getSession();
+        if (DB) {
+            this.sendToken = DB.token;
+        }
+    }
+    else {
+        this.sendToken = token;
+    }
+    try {
+        const res = await this.getMe();
+        this.bot = res.bot;
+    }
+    catch {
+        const token = await (0, prompt_1.default)('[start] Please enter your bot token: ');
+        await this.start(token);
+    }
+    this.initialize = true;
+}
+exports.default = start;

package/lib/core/bot/methods/utilities/webhook.d.ts

@@ -0,0 +1,4 @@
+import Bot from '../../bot';
+import { UpdateEndpointTypeEnum } from '../../types/models';
+declare function setupWebhook(this: Bot, url?: string, host?: string, port?: number, updates?: UpdateEndpointTypeEnum[]): Promise<void>;
+export default setupWebhook;

package/lib/core/bot/methods/utilities/webhook.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const json_bigint_1 = __importDefault(require("json-bigint"));
+const handleUpdates_1 = __importDefault(require("./handleUpdates"));
+const localtunnel_1 = __importDefault(require("localtunnel"));
+const JSONbig = (0, json_bigint_1.default)({ storeAsString: true });
+function handleParser(_, body, done) {
+    try {
+        const json = JSONbig.parse(body.toString());
+        done(null, JSON.parse(JSON.stringify(json)));
+    }
+    catch (err) {
+        done(err, undefined);
+    }
+}
+async function manageTunnelWithWebhook(port, updates, url) {
+    const setEndpoints = async (url) => {
+        for (let update of updates) {
+            const res = await this.updateBotEndpoints(url, update);
+            if (res.status != 'Done')
+                console.error(`[ manageTunnelWithWebhook ] status updateBotEndpoints is ${res.status} for update: ${update}`);
+        }
+        console.log('start robot...');
+    };
+    if (url) {
+        return await setEndpoints(url);
+    }
+    while (true) {
+        try {
+            const tunnel = await (0, localtunnel_1.default)({ port });
+            await setEndpoints(tunnel.url);
+            await new Promise((resolve) => tunnel.on('close', resolve));
+            console.warn('🚪 Tunnel closed. Reconnecting...');
+        }
+        catch (err) {
+            console.error('❌ Tunnel failed:', err);
+            await new Promise((r) => setTimeout(r, 3000));
+        }
+    }
+}
+function lowerFirstChar(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+async function setupWebhook(url, host = '0.0.0.0', port = 3000, updates = []) {
+    this.server.addContentTypeParser('application/json', { parseAs: 'string' }, handleParser);
+    this.server.get('/', handleUpdates_1.default.bind(this));
+    this.server.post('/', handleUpdates_1.default.bind(this));
+    for (let update of updates) {
+        this.server.post(`/${lowerFirstChar(update)}`, handleUpdates_1.default.bind(this));
+    }
+    await this.server.listen({ port, host });
+    await manageTunnelWithWebhook.bind(this)(port, updates, url);
+}
+exports.default = setupWebhook;

package/lib/core/bot/network/index.d.ts

@@ -0,0 +1,9 @@
+import Bot from '../bot';
+import { Agent } from 'undici';
+export default class Network {
+    bot: Bot;
+    agent: Agent;
+    constructor(bot: Bot);
+    request(method: string, data: any): Promise<any>;
+    delay(ms: number): Promise<unknown>;
+}

package/lib/core/bot/network/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const undici_1 = require("undici");
+const json_bigint_1 = __importDefault(require("json-bigint"));
+const JSONbig = (0, json_bigint_1.default)({ storeAsString: true });
+class Network {
+    constructor(bot) {
+        this.bot = bot;
+        this.agent = new undici_1.Agent({
+            connect: { rejectUnauthorized: false },
+        });
+    }
+    async request(method, data) {
+        const MAX_ATTEMPTS = 3;
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+            try {
+                const res = await (0, undici_1.request)(`${this.bot.BASE_URL}/${this.bot.sendToken}/${method}`, {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json',
+                    },
+                    body: JSON.stringify(data),
+                    dispatcher: this.agent,
+                });
+                if (res.statusCode === 200) {
+                    const responseData = await res.body.text();
+                    const data = JSONbig.parse(responseData);
+                    console.log(data);
+                    return JSON.parse(JSON.stringify(data));
+                }
+                else {
+                    console.warn(`[request] Attempt ${attempt}: Unexpected status ${res.statusCode}`);
+                }
+            }
+            catch (error) {
+                console.error(`[request] Attempt ${attempt} failed:`, error);
+            }
+            await this.delay(1000);
+        }
+        throw new Error(`[request] Failed after ${MAX_ATTEMPTS} attempts: ${method}`);
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.default = Network;

package/lib/core/bot/network/polling.js

@@ -0,0 +1,44 @@
+"use strict";
+// import fs from 'fs';
+// import Network from '.';
+// import Message from '../contexts/message.context';
+// export default async function polling(network: Network) {
+// 	console.log('start robot with polling mode...');
+// 	let next_offset_id: string | undefined = loadOffset();
+// 	setInterval(async () => {
+// 		try {
+// 			const res = await network.bot.getUpdates(next_offset_id);
+// 			for (let m of res.updates) {
+// 				if (isNaN(m.new_message?.time || m.updated_message?.time)) continue;
+// 				const messageTime =
+// 					Number(m.new_message?.time || m.updated_message?.time) | 0;
+// 				const nowTime = Math.floor(Date.now() / 1000);
+// 				if (nowTime - messageTime < 5) {
+// 					m = new Message(network.bot, m);
+// 					for (let handler of network.bot.handlers) {
+// 						if (
+// 							handler.filters.length === 0 ||
+// 							handler.filters.every((filter) => filter(m))
+// 						) {
+// 							await handler.handler(m);
+// 						}
+// 					}
+// 				}
+// 			}
+// 			if (res.next_offset_id) {
+// 				next_offset_id = res.next_offset_id;
+// 				saveOffset(next_offset_id as string);
+// 			}
+// 		} catch (e) {
+// 			console.error('Error occurred while polling:', e);
+// 		}
+// 	}, 1000);
+// }
+// function saveOffset(offset: string) {
+// 	fs.writeFileSync('offset.json', JSON.stringify({ offset }));
+// }
+// function loadOffset(): string | undefined {
+// 	if (!fs.existsSync('offset.json')) return undefined;
+// 	const data = fs.readFileSync('offset.json', 'utf8');
+// 	return JSON.parse(data).offset;
+// }

package/lib/core/bot/types/bot.type.d.ts

@@ -0,0 +1,28 @@
+import InlineMessage from '../contexts/inline.context';
+import Message from '../contexts/message.context';
+export interface Session {
+    iv: string;
+    enData: string;
+}
+export type SessionType = string | Session;
+export interface BotType {
+    bot_id: string;
+    bot_title: string;
+    avatar: {
+        file_id: string;
+    };
+    description: string;
+    username: string;
+    start_message: string;
+}
+export interface ContextMap {
+    message: Message;
+    inline: InlineMessage;
+}
+export type FilterFn<T> = (ctx: T) => boolean | Promise<boolean>;
+export type NestedFilter<T> = Array<FilterFn<T> | FilterFn<T>[]>;
+export type Handler<T> = {
+    filters: NestedFilter<T>;
+    handler: (ctx: T) => Promise<void>;
+    prefix?: string | RegExp;
+};