rubjs 3.0.0 → 3.1.1

package/lib/core/client/network/api.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDcs = getDcs;
+exports.sendRequest = sendRequest;
+exports.sendPayload = sendPayload;
+const undici_1 = require("undici");
+const crypto_1 = __importDefault(require("../crypto"));
+/**
+ * Retrieves API and WSS server URLs
+ */
+async function getDcs(network) {
+    const url = 'https://getdcmess.iranlms.ir/';
+    const RETRY_DELAY = 3000;
+    while (true) {
+        try {
+            const res = await (0, undici_1.request)(url, {
+                method: 'GET',
+                dispatcher: network.agent,
+            });
+            if (res.statusCode === 200) {
+                const body = (await res.body.json());
+                if (body?.data) {
+                    const dcs = body.data;
+                    network.apiUrl = `${dcs.API[dcs.default_api]}/`;
+                    network.wssUrl = dcs.socket[dcs.default_socket];
+                    return true;
+                }
+            }
+            console.warn('[getDcs] Unexpected status or data format:', res.statusCode);
+        }
+        catch (error) {
+            console.error('[getDcs] Error:', error);
+        }
+        await network.delay(RETRY_DELAY);
+    }
+}
+/**
+ * Sends a POST request with retry logic and enhanced error reporting
+ */
+async function sendRequest(network, url, data) {
+    const MAX_ATTEMPTS = 3;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+            const res = await (0, undici_1.request)(url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...network.headers,
+                },
+                body: JSON.stringify(data),
+                dispatcher: network.agent,
+            });
+            if (res.statusCode === 200) {
+                const responseData = await res.body.json();
+                return responseData;
+            }
+            else {
+                console.warn(`[request] Attempt ${attempt}: Unexpected status ${res.statusCode}`);
+            }
+        }
+        catch (error) {
+            console.error(`[request] Attempt ${attempt} failed:`, error);
+        }
+        await network.delay(1000);
+    }
+    throw new Error(`[request] Failed after ${MAX_ATTEMPTS} attempts: ${url}`);
+}
+async function sendPayload(network, datas) {
+    await network.getDcs();
+    while (!network.apiUrl) {
+        await network.delay(1000);
+    }
+    const { auth, decode_auth, key, privateKey } = network.client;
+    if (!key)
+        return;
+    const credentialsKey = datas.tmp_session ? 'tmp_session' : 'auth';
+    const credentialsValue = datas.tmp_session ? auth : decode_auth;
+    const dataPayload = JSON.stringify({
+        client: network.defaultPlatform,
+        method: datas.method,
+        input: datas.input,
+    });
+    const payload = {
+        api_version: '6',
+        data_enc: crypto_1.default.encrypt(dataPayload, key),
+        [credentialsKey]: credentialsValue,
+    };
+    if (!datas.tmp_session && privateKey) {
+        payload.sign = crypto_1.default.sign(payload.data_enc, privateKey);
+    }
+    return network.request(network.apiUrl, payload);
+}

package/lib/core/client/network/file.d.ts

@@ -0,0 +1,3 @@
+import Network from '.';
+export declare function uploadFile(network: Network, filePath: string, chunkSize?: number): Promise<any>;
+export declare function download(network: Network, dc_id: number, file_id: number, access_hash: string, size: number, chunk?: number): Promise<Buffer>;

package/lib/core/client/network/file.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFile = uploadFile;
+exports.download = download;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const undici_1 = require("undici");
+async function uploadFile(network, filePath, chunkSize = 1048576) {
+    if (!fs_1.default.existsSync(filePath))
+        throw new Error('File not found in the given path');
+    const stat = await fs_1.default.promises.stat(filePath);
+    const fileSize = stat.size;
+    const fileName = path_1.default.basename(filePath);
+    const mime = filePath.split('.').pop();
+    let result = await network.client.requestSendFile(fileName, fileSize, mime);
+    let id = result.id;
+    let dc_id = result.dc_id;
+    let upload_url = result.upload_url;
+    let access_hash_send = result.access_hash_send;
+    let totalParts = Math.ceil(fileSize / chunkSize);
+    const stream = fs_1.default.createReadStream(filePath, { highWaterMark: chunkSize });
+    let index = 0;
+    for await (const chunk of stream) {
+        try {
+            const res = await (0, undici_1.request)(upload_url, {
+                method: 'POST',
+                headers: {
+                    auth: network.client.auth,
+                    'file-id': id,
+                    'total-part': totalParts.toString(),
+                    'part-number': (index + 1).toString(),
+                    'chunk-size': chunk.length.toString(),
+                    'access-hash-send': access_hash_send,
+                },
+                body: chunk,
+                dispatcher: network.agent,
+            });
+            const response = await res.body.json();
+            if (response.status === 'ERROR_TRY_AGAIN') {
+                console.log('Retrying upload...');
+                stream.close();
+                result = await network.client.requestSendFile(fileName, fileSize, mime);
+                id = result.id;
+                dc_id = result.dc_id;
+                upload_url = result.upload_url;
+                access_hash_send = result.access_hash_send;
+                index = 0;
+                return uploadFile(network, filePath, chunkSize);
+            }
+            index++;
+            if (response.status === 'OK' &&
+                response.status_det === 'OK' &&
+                response.data?.access_hash_rec) {
+                return {
+                    mime,
+                    size: fileSize,
+                    dc_id,
+                    file_id: id,
+                    file_name: fileName,
+                    access_hash_rec: response.data.access_hash_rec,
+                };
+            }
+        }
+        catch (error) {
+            console.error('Upload error:', error);
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+        }
+    }
+    throw new Error('Upload failed completely.');
+}
+async function download(network, dc_id, file_id, access_hash, size, chunk = 131072) {
+    const headersBase = {
+        auth: network.client.auth,
+        'access-hash-rec': access_hash,
+        'file-id': String(file_id),
+        'user-agent': network.userAgent,
+    };
+    const base_url = `https://messenger${dc_id}.iranlms.ir`;
+    const fetchChunk = async (start_index, last_index) => {
+        const headers = {
+            ...headersBase,
+            'start-index': String(start_index),
+            'last-index': String(last_index),
+        };
+        try {
+            const { body, statusCode } = await (0, undici_1.request)(`${base_url}/GetFile.ashx`, {
+                method: 'POST',
+                headers,
+            });
+            if (statusCode !== 200 || !body)
+                return Buffer.alloc(0);
+            const chunks = [];
+            for await (const chunk of body) {
+                chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+            }
+            return Buffer.concat(chunks);
+        }
+        catch (err) {
+            console.error(`[fetchChunk] Failed at ${start_index}-${last_index}`, err);
+            return Buffer.alloc(0);
+        }
+    };
+    let result = Buffer.alloc(0);
+    let start_index = 0;
+    while (start_index < size) {
+        const last_index = Math.min(start_index + chunk, size) - 1;
+        const chunkData = await fetchChunk(start_index, last_index);
+        if (chunkData.length === 0)
+            break;
+        result = Buffer.concat([result, chunkData]);
+        start_index = last_index + 1;
+    }
+    return result;
+}

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

@@ -0,0 +1,25 @@
+import Client from '../client';
+import { Agent, WebSocket as UndiciWebSocket } from 'undici';
+import { delay } from './utils';
+import { NetworkTypes } from '../types/index.type';
+export default class Network {
+    client: Client;
+    headers: Record<string, string>;
+    defaultPlatform: NetworkTypes.Platform;
+    agent: Agent;
+    userAgent: string;
+    ws?: InstanceType<typeof UndiciWebSocket>;
+    apiUrl?: string;
+    wssUrl?: string;
+    heartbeatInterval?: NodeJS.Timeout;
+    inactivityTimeout?: NodeJS.Timeout;
+    reconnecting: boolean;
+    constructor(client: Client);
+    getDcs: () => Promise<boolean>;
+    request: (url: string, data: any) => Promise<unknown>;
+    send: (opts: any) => Promise<any>;
+    getUpdates: () => Promise<void>;
+    uploadFile: (filePath: string, chunkSize?: number) => Promise<any>;
+    download: (dc_id: number, file_id: number, access_hash: string, size: number, chunk?: number) => Promise<Buffer<ArrayBufferLike>>;
+    delay: typeof delay;
+}

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

@@ -0,0 +1,31 @@
+"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 utils_1 = require("./utils");
+const api_1 = require("./api");
+const websocket_1 = require("./websocket");
+const user_agents_1 = __importDefault(require("user-agents"));
+const file_1 = require("./file");
+class Network {
+    constructor(client) {
+        this.client = client;
+        this.userAgent = new user_agents_1.default().toString();
+        this.reconnecting = false;
+        this.getDcs = () => (0, api_1.getDcs)(this);
+        this.request = (url, data) => (0, api_1.sendRequest)(this, url, data);
+        this.send = (opts) => (0, api_1.sendPayload)(this, opts);
+        this.getUpdates = async () => (0, websocket_1.setupWebSocket)(this);
+        this.uploadFile = (filePath, chunkSize) => (0, file_1.uploadFile)(this, filePath, chunkSize);
+        this.download = (dc_id, file_id, access_hash, size, chunk = 131072) => (0, file_1.download)(this, dc_id, file_id, access_hash, size, chunk);
+        this.delay = utils_1.delay;
+        this.defaultPlatform = (0, utils_1.resolvePlatform)(client.platform);
+        this.headers = (0, utils_1.buildHeaders)(client.platform);
+        this.agent = new undici_1.Agent({
+            connect: { rejectUnauthorized: false },
+        });
+    }
+}
+exports.default = Network;

package/lib/core/client/network/utils.d.ts

@@ -0,0 +1,9 @@
+export declare function delay(ms: number): Promise<unknown>;
+export declare function resolvePlatform(platform: string): {
+    app_name: string;
+    app_version: string;
+    platform: string;
+    package: string;
+    lang_code: string;
+};
+export declare function buildHeaders(platform: string): Record<string, string>;

package/lib/core/client/network/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+exports.resolvePlatform = resolvePlatform;
+exports.buildHeaders = buildHeaders;
+const user_agents_1 = __importDefault(require("user-agents"));
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolvePlatform(platform) {
+    const isAndroid = platform?.toLowerCase() === 'android';
+    return {
+        app_name: 'Main',
+        app_version: isAndroid ? '3.6.4' : '4.4.9',
+        platform: isAndroid ? 'Android' : 'Web',
+        package: isAndroid ? 'app.rbmain.a' : 'web.rubika.ir',
+        lang_code: 'fa',
+    };
+}
+function buildHeaders(platform) {
+    const headers = {
+        'content-type': 'application/json',
+        connection: 'keep-alive',
+        'user-agent': new user_agents_1.default().toString(),
+    };
+    if (platform.toLowerCase() !== 'android') {
+        headers.origin = 'https://web.rubika.ir';
+        headers.referer = 'https://web.rubika.ir/';
+    }
+    return headers;
+}

package/lib/core/client/network/websocket.d.ts

@@ -0,0 +1,3 @@
+import Network from '.';
+export declare function setupWebSocket(network: Network): Promise<void>;
+export declare function openSocket(network: Network): Promise<void>;

package/lib/core/client/network/websocket.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWebSocket = setupWebSocket;
+exports.openSocket = openSocket;
+const crypto_1 = __importDefault(require("../crypto"));
+const undici_1 = require("undici");
+const contextConstructors_1 = require("../contexts/contextConstructors");
+const checkFilters_1 = require("../../../utils/checkFilters");
+const TYPES = {
+    chat: 'chat_updates',
+    message: 'message_updates',
+    activities: 'show_activities',
+    notifications: 'show_notifications',
+};
+async function setupWebSocket(network) {
+    while (!network.wssUrl) {
+        await network.delay(1000);
+    }
+    network.ws = new undici_1.WebSocket(network.wssUrl);
+    network.ws.addEventListener('open', async () => await openSocket(network));
+    network.ws.addEventListener('message', async (event) => await getMessage(event.data, network));
+    network.ws.addEventListener('error', async () => {
+        if (!network.reconnecting) {
+            console.error('WebSocket error, reconnecting...');
+            network.reconnecting = true;
+            await resetConnection(network);
+        }
+    });
+    network.ws.addEventListener('close', async () => {
+        if (!network.reconnecting) {
+            console.warn('WebSocket closed, reconnecting...');
+            network.reconnecting = true;
+            await resetConnection(network);
+        }
+    });
+}
+async function openSocket(network) {
+    try {
+        console.log('Starting bot...');
+        if (network.ws && network.ws.readyState === undici_1.WebSocket.OPEN) {
+            const payload = JSON.stringify({
+                api_version: '5',
+                auth: network.client.auth,
+                data: '',
+                method: 'handShake',
+            });
+            network.ws.send(payload);
+            if (network.heartbeatInterval)
+                clearInterval(network.heartbeatInterval);
+            network.heartbeatInterval = setInterval(() => {
+                try {
+                    if (network.ws?.readyState === undici_1.WebSocket.OPEN) {
+                        network.ws.send(JSON.stringify({}));
+                    }
+                }
+                catch (err) {
+                    console.error('Error sending heartbeat', err);
+                }
+            }, 30000);
+        }
+        else {
+            console.warn('WebSocket is not open; cannot send handshake');
+        }
+    }
+    catch (err) {
+        console.error('Error during openSocket execution', err);
+    }
+}
+async function resetConnection(network) {
+    network.ws?.close();
+    network.ws = undefined;
+    setTimeout(async () => {
+        try {
+            await network.getUpdates();
+        }
+        catch (e) {
+            console.error('Failed to reconnect:', e);
+        }
+        finally {
+            network.reconnecting = false;
+        }
+    }, 5000);
+}
+function resetInactivityTimer(network) {
+    if (network.inactivityTimeout)
+        clearTimeout(network.inactivityTimeout);
+    network.inactivityTimeout = setTimeout(() => {
+        console.warn('No updates received for 10 minutes. Reconnecting WebSocket...');
+        void resetConnection(network).catch((err) => {
+            console.error('Error during inactivity reset:', err);
+        });
+    }, 10 * 60 * 1000);
+}
+async function getMessage(message, network) {
+    try {
+        const { data_enc } = JSON.parse(message);
+        if (!data_enc || !network.client.key)
+            return;
+        resetInactivityTimer(network);
+        const update = JSON.parse(crypto_1.default.decrypt(data_enc, network.client.key));
+        const tasks = [];
+        for (const ctxKey of Object.keys(TYPES)) {
+            const updateKey = TYPES[ctxKey];
+            const author_title = getAuthorTitle(update);
+            const items = update[updateKey];
+            if (!Array.isArray(items) || items.length === 0)
+                continue;
+            const handlers = network.client.handlers[ctxKey];
+            if (!handlers || handlers.length === 0)
+                continue;
+            tasks.push(handleCategory(ctxKey, handlers, items, network, author_title));
+        }
+        if (tasks.length === 1) {
+            await tasks[0];
+        }
+        else if (tasks.length > 1) {
+            await Promise.all(tasks);
+        }
+    }
+    catch (err) {
+        console.error('[getMessage] Failed to decrypt or process message:', err);
+    }
+}
+async function handleCategory(type, handlers, updates, network, author_title) {
+    const CtxClass = contextConstructors_1.ContextConstructors[type];
+    if (!CtxClass) {
+        console.warn(`[handleCategory] No constructor found for type: ${type}`);
+        return;
+    }
+    for (let update of updates) {
+        if (!update.message)
+            update.message = {};
+        update.client_guid = network.client.userGuid;
+        update.message.author_title = author_title;
+        const ctx = new CtxClass(network.client, update);
+        for (const { filters, handler, prefix } of handlers) {
+            // filters
+            const passed = await (0, checkFilters_1.checkFilters)(ctx, filters);
+            if (passed) {
+                // Prefix logic
+                if (type === 'message' && prefix) {
+                    const text = ctx.message.text;
+                    if (!text)
+                        continue;
+                    if (typeof prefix === 'string' && text !== prefix)
+                        continue;
+                    if (prefix instanceof RegExp && !prefix.test(text))
+                        continue;
+                }
+                await handler(ctx);
+            }
+        }
+    }
+}
+// utils
+const getAuthorTitle = (update) => {
+    const notification = update.show_notifications?.[0];
+    const chatUpdate = update.chat_updates?.[0];
+    if (notification) {
+        const objectGuid = notification?.message_data?.object_guid;
+        if (objectGuid?.startsWith('u0'))
+            return notification.title;
+        else if (objectGuid?.startsWith('g0'))
+            return notification.text?.split(':')[0];
+    }
+    else if (chatUpdate) {
+        return chatUpdate.chat?.last_message?.author_title || 'Unknown User';
+    }
+    else
+        return 'Unknown User';
+};

package/lib/{types → core/client/types}/client.type.d.ts

@@ -1,8 +1,8 @@
-import Client from '../core/client';
-import Chat from './chat.type';
-import { Activities } from './index.type';
-import Message from './message.type';
-import Notifications from './notifications.type';
+import Client from '../client';
+import Chat from '../contexts/chat.type';
+import Activities from '../contexts/activities.type';
+import Message from '../contexts/message.type';
+import Notifications from '../contexts/notifications.type';
 export interface Session {
     iv: string;
     enData: string;
@@ -17,17 +17,15 @@ export interface RubPlugin {
     version?: string;
     run: PluginFunction;
 }
-export type ContextMap = {
+export interface ContextMap {
     chat: Chat;
     message: Message;
     activities: Activities;
     notifications: Notifications;
-};
-export type Middleware<C> = (ctx: C, next: () => Promise<void>) => Promise<void>;
-export type Handler<C> = (ctx: C) => Promise<void>;
-export type MiddlewareChain<C> = [...Middleware<C>[], Handler<C>];
-export interface Command<C> {
-    pattern: string | RegExp;
-    middlewares: MiddlewareChain<C>;
 }
+export type Handler<T> = {
+    filters: Array<(ctx: T) => boolean | Promise<boolean>>;
+    handler: (ctx: T) => Promise<void>;
+    prefix?: string | RegExp;
+};
 export {};

package/lib/{types → core/client/types}/index.type.d.ts

@@ -2,6 +2,4 @@ import * as ClientTypes from './client.type';
 import * as SessionTypes from './session.type';
 import * as NetworkTypes from './network.type';
 import * as DecoratorsTypes from './decorators.type';
-import Message from './message.type';
-import Activities from './activities.type';
-export { ClientTypes, SessionTypes, NetworkTypes, DecoratorsTypes, Message, Activities, };
+export { ClientTypes, SessionTypes, NetworkTypes, DecoratorsTypes, };

package/lib/{types → core/client/types}/index.type.js

@@ -32,11 +32,8 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Activities = exports.Message = exports.DecoratorsTypes = exports.NetworkTypes = exports.SessionTypes = exports.ClientTypes = void 0;
+exports.DecoratorsTypes = exports.NetworkTypes = exports.SessionTypes = exports.ClientTypes = void 0;
 const ClientTypes = __importStar(require("./client.type"));
 exports.ClientTypes = ClientTypes;
 const SessionTypes = __importStar(require("./session.type"));
@@ -45,7 +42,3 @@ const NetworkTypes = __importStar(require("./network.type"));
 exports.NetworkTypes = NetworkTypes;
 const DecoratorsTypes = __importStar(require("./decorators.type"));
 exports.DecoratorsTypes = DecoratorsTypes;
-const message_type_1 = __importDefault(require("./message.type"));
-exports.Message = message_type_1.default;
-const activities_type_1 = __importDefault(require("./activities.type"));
-exports.Activities = activities_type_1.default;

package/lib/core/client/types/session.type.d.ts

@@ -0,0 +1,11 @@
+export interface ClientSession {
+    phone: string;
+    auth: string;
+    guid: string;
+    agent: string;
+    private_key: string;
+}
+export interface BotSession {
+    token: string;
+}
+export type SessionData = ClientSession | BotSession;

package/lib/core/client/types/session.type.js

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

package/lib/exceptions/index.d.ts

@@ -0,0 +1,6 @@
+export declare class BuilderException extends Error {
+    code: string;
+    data?: any | undefined;
+    constructor(message: string, code: string, data?: any | undefined);
+}
+export declare const MeaagesErrors: Record<string, string>;

package/lib/exceptions/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeaagesErrors = exports.BuilderException = void 0;
+class BuilderException extends Error {
+    constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'BuilderException';
+    }
+}
+exports.BuilderException = BuilderException;
+exports.MeaagesErrors = {
+    INVALID_ACCESS: ' invalid access error:',
+    INVALID_INPUT: ' invalid input error:',
+};

package/lib/index.d.ts

@@ -1,9 +1,13 @@
-import Client from './core/client';
-import Filters from './core/filters';
-import Utils from './core/utils';
-import { Middleware, RubPlugin } from './types/client.type';
-import type MessageType from './types/message.type';
-import * as ContextTypes from './types/index.type';
+import Client from './core/client/client';
+import ClientFilters from './core/client/filters';
+import ClientUtils from './utils/utils';
+import Bot from './core/bot/bot';
+import BotFilters from './core/bot/filters';
+import { RubPlugin } from './core/client/types/client.type';
+import type MessageType from './core/client/contexts/message.type';
+import type ActivitiesType from './core/client/contexts/activities.type';
+import type ChatType from './core/client/contexts/chat.type';
+import type NotificationsType from './core/client/contexts/notifications.type';
 import * as Clients from './clients';
-export { Client, Filters, Utils, Middleware, MessageType, RubPlugin, ContextTypes, Clients, };
+export { Client, ClientFilters, ClientUtils, Bot, BotFilters, RubPlugin, ChatType, MessageType, ActivitiesType, NotificationsType, Clients, };
 export default Client;

package/lib/index.js

@@ -36,15 +36,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Clients = exports.ContextTypes = exports.Utils = exports.Filters = exports.Client = void 0;
-const client_1 = __importDefault(require("./core/client"));
+exports.Clients = exports.BotFilters = exports.Bot = exports.ClientUtils = exports.ClientFilters = exports.Client = void 0;
+// client
+const client_1 = __importDefault(require("./core/client/client"));
 exports.Client = client_1.default;
-const filters_1 = __importDefault(require("./core/filters"));
-exports.Filters = filters_1.default;
-const utils_1 = __importDefault(require("./core/utils"));
-exports.Utils = utils_1.default;
-const ContextTypes = __importStar(require("./types/index.type"));
-exports.ContextTypes = ContextTypes;
+const filters_1 = __importDefault(require("./core/client/filters"));
+exports.ClientFilters = filters_1.default;
+const utils_1 = __importDefault(require("./utils/utils"));
+exports.ClientUtils = utils_1.default;
+// robot
+const bot_1 = __importDefault(require("./core/bot/bot"));
+exports.Bot = bot_1.default;
+const filters_2 = __importDefault(require("./core/bot/filters"));
+exports.BotFilters = filters_2.default;
 const Clients = __importStar(require("./clients"));
 exports.Clients = Clients;
 exports.default = client_1.default;

package/lib/utils/checkFilters.d.ts

@@ -0,0 +1 @@
+export declare function checkFilters(ctx: any, filters: (Function | Function[])[]): Promise<boolean>;