rubjs 3.0.0 → 3.0.1

package/lib/core/methods/utilities/downloadProfilePicture.d.ts

@@ -0,0 +1,4 @@
+import Client from "../../client";
+import { Buffer } from "buffer";
+declare function downloadProfilePicture(this: Client, object_guid: string): Promise<Buffer | null>;
+export default downloadProfilePicture;

package/lib/core/methods/utilities/downloadProfilePicture.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const undici_1 = require("undici");
+const buffer_1 = require("buffer");
+async function downloadProfilePicture(object_guid) {
+    const avatarsInfo = await this.getAvatars(object_guid);
+    if (!avatarsInfo || !avatarsInfo.avatars?.[0]?.main)
+        return null;
+    const avatar = avatarsInfo.avatars[0].main;
+    const url = `https://messenger${avatar.dc_id}.iranlms.ir/InternFile.ashx?id=${avatar.file_id}&ach=${avatar.access_hash_rec}`;
+    try {
+        const { statusCode, body } = await (0, undici_1.request)(url, {
+            method: "GET",
+        });
+        if (statusCode !== 200 || !body)
+            return null;
+        const chunks = [];
+        for await (const chunk of body) {
+            chunks.push(typeof chunk === "string" ? buffer_1.Buffer.from(chunk) : chunk);
+        }
+        return buffer_1.Buffer.concat(chunks);
+    }
+    catch (err) {
+        console.error("Failed to download profile picture:", err);
+        return null;
+    }
+}
+exports.default = downloadProfilePicture;

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

@@ -2,7 +2,7 @@ import run from './run';
 import requestSendFile from './requestSendFile';
 import start from './start';
 import thumbnail from './thumbnail';
-import useError from './useError';
 import usePlugin from './usePlugin';
-import runErrorMiddlewares from './runErrorMiddlewares';
-export { run, useError, usePlugin, requestSendFile, start, thumbnail, runErrorMiddlewares, };
+import download from './download';
+import downloadProfilePicture from './downloadProfilePicture';
+export { run, start, download, thumbnail, usePlugin, requestSendFile, downloadProfilePicture };

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runErrorMiddlewares = exports.thumbnail = exports.start = exports.requestSendFile = exports.usePlugin = exports.useError = exports.run = void 0;
+exports.downloadProfilePicture = exports.requestSendFile = exports.usePlugin = exports.thumbnail = exports.download = exports.start = exports.run = void 0;
 const run_1 = __importDefault(require("./run"));
 exports.run = run_1.default;
 const requestSendFile_1 = __importDefault(require("./requestSendFile"));
@@ -12,9 +12,9 @@ const start_1 = __importDefault(require("./start"));
 exports.start = start_1.default;
 const thumbnail_1 = __importDefault(require("./thumbnail"));
 exports.thumbnail = thumbnail_1.default;
-const useError_1 = __importDefault(require("./useError"));
-exports.useError = useError_1.default;
 const usePlugin_1 = __importDefault(require("./usePlugin"));
 exports.usePlugin = usePlugin_1.default;
-const runErrorMiddlewares_1 = __importDefault(require("./runErrorMiddlewares"));
-exports.runErrorMiddlewares = runErrorMiddlewares_1.default;
+const download_1 = __importDefault(require("./download"));
+exports.download = download_1.default;
+const downloadProfilePicture_1 = __importDefault(require("./downloadProfilePicture"));
+exports.downloadProfilePicture = downloadProfilePicture_1.default;

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

@@ -36,7 +36,6 @@ async function start() {
             }
         }
         let result = await this.sendCode(phone_number);
-        console.log(result);
         if (result.status == 'SendPassKey') {
             while (true) {
                 let pass_key = await (0, prompt_1.default)(`Password [${result.hint_pass_key}] > `);

package/lib/core/network/api.d.ts

@@ -0,0 +1,16 @@
+import Network from '.';
+interface SendPayloadInputs {
+    input?: Record<string, any>;
+    method?: string;
+    tmp_session: boolean;
+}
+/**
+ * Retrieves API and WSS server URLs
+ */
+export declare function getDcs(network: Network): Promise<boolean>;
+/**
+ * Sends a POST request with retry logic and enhanced error reporting
+ */
+export declare function sendRequest(network: Network, url: string, data: any): Promise<unknown>;
+export declare function sendPayload(network: Network, datas: SendPayloadInputs): Promise<any>;
+export {};

package/lib/core/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/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/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/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/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/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/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/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/network/websocket.js

@@ -0,0 +1,190 @@
+"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("../context/contextConstructors");
+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) {
+            // 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;
+            }
+            // filters
+            const passed = await checkFilters(ctx, filters);
+            if (passed) {
+                await handler(ctx);
+            }
+        }
+    }
+}
+// utils
+async function checkFilters(ctx, filters) {
+    for (const filter of filters) {
+        if (Array.isArray(filter)) {
+            // OR logic
+            const results = await Promise.all(filter.map((f) => Promise.resolve(f(ctx))));
+            if (!results.some(Boolean))
+                return false;
+        }
+        else {
+            // AND logic
+            const result = await Promise.resolve(filter(ctx));
+            if (!result)
+                return false;
+        }
+    }
+    return true;
+}
+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/index.d.ts

@@ -1,9 +1,11 @@
 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 Utils from './utils/utils';
+import { RubPlugin } from './types/client.type';
+import type MessageType from './core/context/message.type';
+import type ActivitiesType from './core/context/activities.type';
+import type ChatType from './core/context/chat.type';
+import type NotificationsType from './core/context/notifications.type';
 import * as Clients from './clients';
-export { Client, Filters, Utils, Middleware, MessageType, RubPlugin, ContextTypes, Clients, };
+export { Client, Filters, Utils, RubPlugin, ChatType, MessageType, ActivitiesType, NotificationsType, Clients, };
 export default Client;

package/lib/index.js

@@ -36,15 +36,13 @@ 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;
+exports.Clients = exports.Utils = exports.Filters = exports.Client = void 0;
 const client_1 = __importDefault(require("./core/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"));
+const utils_1 = __importDefault(require("./utils/utils"));
 exports.Utils = utils_1.default;
-const ContextTypes = __importStar(require("./types/index.type"));
-exports.ContextTypes = ContextTypes;
 const Clients = __importStar(require("./clients"));
 exports.Clients = Clients;
 exports.default = client_1.default;