rubjs 2.9.3 → 3.0.1

package/README.md

@@ -1,63 +1,70 @@
 <p align="center">
   <br>
-  <b>فریمورک API روبیکا برای جاوااسکریپت</b>
+  <b>فریم‌ورک قدرتمند روبیکا برای جاوااسکریپت </b>
 </p>
 
 # RubJS
 
-> یک فریمورک مدرن، زیبا و کاملاً غیرهمزمان (Asynchronous) برای تعامل با API رسمی روبیکا با استفاده از زبان جاوااسکریپت
+> یک فریم‌ورک مدرن، زیبا و کاملاً غیرهمزمان برای تعامل با API رسمی روبیکا 
 
 ---
 
-### معرفی
+## 🚀 معرفی
 
-**RubJS** فریمورکی پیشرفته و در عین حال ساده برای کار با API روبیکا است که به شما امکان می‌دهد به‌راحتی از طریق یک حساب کاربری (کلاینت سفارشی) با روبیکا ارتباط برقرار کنید. این فریمورک به صورت کامل غیرهمزمان طراحی شده تا بهترین کارایی را در برنامه‌های مدرن جاوااسکریپتی ارائه دهد.
+**RubJS** یک فریم‌ورک سبک و ماژولار برای توسعه سریع ربات‌های روبیکایی است. این فریم‌ورک با معماری مبتنی بر Fileter-Base سیستم فرمان‌دهی، زمان‌بندی و تایپ‌سیف، به شما این امکان را می‌دهد که در کمترین زمان، ربات‌هایی سریع، تمیز و قابل گسترش بسازید.
 
 ---
 
-### نمونه کد اولیه
+## ⚡ نمونه کد اولیه
 
-```javascript
+```js
 const { Client, Utils, Filters } = require("rubjs");
 
-const bot = new Client("bot");
+const bot = new Client("rubjs");
 
-const object_guid = "object_guid";
-
-const customFilter = (msg) => msg.object_guid === object_guid;
+bot.command("/admin", [Filters.isPrivate], async (ctx) => {
+  await ctx.reply("شما ادمین هستید ✅");
+});
 
-bot.onMessageUpdates([customFilter, Filters.isText], async (message) => {
-  await message.reply(`Hello ${Utils.Italic("from")} ${Utils.Bold("RubJS")}!`);
+bot.command("message", [Filters.isGroup], async (ctx) => {
+  await ctx.reply("سلام");
 });
 
 bot.run();
 ```
+## ✨ ویژگی‌ها
+
 <div dir="rtl">
 
-## ویژگی‌ها
-> **آماده و سریع**:
-به سادگی با نصب از npm آماده استفاده است و در کمترین زمان می‌توانید شروع به توسعه کنید.
+### پشتیبانی از پلاگین‌ها (Plugin System)  
+امکان افزودن قابلیت‌های جدید با پلاگین‌های جداگانه
+
+### طراحی Filters-based  
+اجرای نوع جدیدی از فیلتر روی پیام ها  برای فیلت کردن پیام کاربران
+
+### تایپ‌سیف کامل (TypeScript Ready)  
+طراحی شده با پشتیبانی کامل از تایپ‌ها برای توسعه‌دهندگان حرفه‌ای.
 
-> **سادگی در عین قدرت**:
-رابط کاربری ساده و قابل فهم که در عین حال تمام قابلیت‌های پیشرفته و رسمی API روبیکا را پوشش می‌دهد.
+### سیستم فرمان‌ها (Commands)  
+استفاده از `bot.command(pattern, handler)` برای مدیریت پیام‌های فرمان‌محور.
 
-> **طراحی زیبا و مدرن**:
-انتزاع مناسب از جزئیات سطح پایین، برای تمرکز روی منطق برنامه و توسعه سریع‌تر.
+### ابزارهای داخلی توسعه  
+مثل `Utils.Bold`, `Utils.Italic` و ... برای زیباتر کردن پاسخ‌ها به کاربر.
 
-> **کاملاً غیرهمزمان**:
-تمامی عملیات به صورت async/await انجام می‌شود تا تجربه توسعه روان و بهینه داشته باشید.
 
-> **دسترسی کامل به API**:
-امکان اجرای تمامی عملیات رسمی کلاینت روبیکا و استفاده از امکانات پیشرفته در برنامه شما.
 </div>
 
 
-## نصب
+
+## 📦 نصب
+
+
 ```bash
 npm install rubjs
 ```
 
+
 ### مستندات و آموزش‌ها
 برای مشاهده مستندات کامل، نمونه‌های بیشتر و راهنمای استفاده، به صفحه رسمی مستندات RubJS مراجعه کنید:
 
-🔗 [مشاهده مستندات RubJS](https://hadi-rostami.github.io/rubjs-docs/)
+🔗 [مشاهده مستندات RubJS](https://hadi-rostami.github.io/rubjs-docs/)

package/lib/clients/VoiceChatClient.d.ts

@@ -0,0 +1,31 @@
+import Client from '..';
+declare class VoiceChatClient {
+    private pc;
+    private source;
+    private track;
+    private ffmpeg?;
+    private frameSize;
+    private playlist;
+    private currentIndex;
+    private chatGuid?;
+    private voiceChatId?;
+    private client?;
+    private isPaused;
+    private lastPosition;
+    private audioTimer?;
+    private updateTimers;
+    private isManualSkip;
+    private getMusicUrl?;
+    constructor(getMusicUrl?: () => Promise<string>);
+    play(filePath?: string): Promise<void>;
+    stop(): void;
+    resume(): void;
+    next(): Promise<void>;
+    previous(): void;
+    addToPlaylist(filePath: string): void;
+    removeFromPlaylist(filePath: string): void;
+    joinVoiceChat(chatGuid: string, voiceChatId: string, client: Client): Promise<void>;
+    private setTimers;
+    private clearTimers;
+}
+export default VoiceChatClient;

package/lib/clients/VoiceChatClient.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const optional_require_1 = require("optional-require");
+const optionalWrtc = (0, optional_require_1.optionalRequire)('wrtc');
+class VoiceChatClient {
+    constructor(getMusicUrl) {
+        this.frameSize = 960 * 2; // 960 samples * 2 bytes
+        this.playlist = [];
+        this.currentIndex = 0;
+        this.isPaused = false;
+        this.lastPosition = 0;
+        this.updateTimers = [];
+        this.isManualSkip = false;
+        if (!optionalWrtc) {
+            throw new Error('wrtc module is not installed.');
+        }
+        this.pc = new optionalWrtc.RTCPeerConnection();
+        this.source = new optionalWrtc.nonstandard.RTCAudioSource();
+        this.track = this.source.createTrack();
+        this.pc.addTrack(this.track);
+        this.getMusicUrl = getMusicUrl;
+    }
+    async play(filePath) {
+        this.stop(); // clean up previous
+        if (!filePath) {
+            if (!this.playlist.length && this.getMusicUrl) {
+                this.playlist = [await this.getMusicUrl()];
+            }
+            filePath = this.playlist[this.currentIndex];
+        }
+        if (!filePath || !this.chatGuid || !this.voiceChatId || !this.client) {
+            throw new Error('Voice chat not initialized.');
+        }
+        this.isPaused = false;
+        this.isManualSkip = false;
+        const seekArgs = this.lastPosition > 0 ? ['-ss', this.lastPosition.toString()] : [];
+        this.ffmpeg = (0, child_process_1.spawn)('ffmpeg', [
+            '-loglevel', 'quiet',
+            '-re',
+            '-threads', '1',
+            '-protocol_whitelist', 'file,http,https,tcp,tls',
+            ...seekArgs,
+            '-i', filePath,
+            '-acodec', 'pcm_s16le',
+            '-ar', '48000',
+            '-ac', '1',
+            '-f', 's16le',
+            'pipe:1',
+        ]);
+        this.audioTimer = setInterval(() => {
+            if (!this.ffmpeg || this.isPaused)
+                return;
+            const chunk = this.ffmpeg.stdout.read(this.frameSize);
+            if (!chunk)
+                return;
+            const samples = new Int16Array(chunk.buffer, chunk.byteOffset, chunk.length / 2);
+            this.source.onData({ samples, sampleRate: 48000 });
+            this.lastPosition += 0.02;
+        }, 20); // 20ms = 960 samples
+        this.ffmpeg.on('close', async () => {
+            clearInterval(this.audioTimer);
+            if (!this.isManualSkip && !this.isPaused) {
+                await this.next();
+            }
+            this.isManualSkip = false;
+        });
+        this.setTimers();
+    }
+    stop() {
+        this.ffmpeg?.kill();
+        this.ffmpeg = undefined;
+        this.isPaused = true;
+        clearInterval(this.audioTimer);
+        this.clearTimers();
+    }
+    resume() {
+        if (this.isPaused)
+            this.play(this.playlist[this.currentIndex]);
+    }
+    async next() {
+        if (this.currentIndex + 1 < this.playlist.length) {
+            this.isManualSkip = true;
+            this.currentIndex++;
+            this.lastPosition = 0;
+            this.play(this.playlist[this.currentIndex]);
+        }
+        else if (this.getMusicUrl) {
+            this.playlist.push(await this.getMusicUrl());
+            await this.next();
+        }
+    }
+    previous() {
+        if (this.currentIndex > 0) {
+            this.isManualSkip = true;
+            this.currentIndex--;
+            this.lastPosition = 0;
+            this.play(this.playlist[this.currentIndex]);
+        }
+    }
+    addToPlaylist(filePath) {
+        this.playlist.push(filePath);
+    }
+    removeFromPlaylist(filePath) {
+        const index = this.playlist.indexOf(filePath);
+        if (index !== -1) {
+            this.playlist.splice(index, 1);
+            if (index <= this.currentIndex && this.currentIndex > 0) {
+                this.currentIndex--;
+            }
+        }
+    }
+    async joinVoiceChat(chatGuid, voiceChatId, client) {
+        this.chatGuid = chatGuid;
+        this.voiceChatId = voiceChatId;
+        this.client = client;
+        const offer = await this.pc.createOffer();
+        if (!offer.sdp || !client.userGuid)
+            return;
+        await this.pc.setLocalDescription(offer);
+        const connect = await client.joinGroupVoiceChat(chatGuid, voiceChatId, offer.sdp, client.userGuid);
+        await this.pc.setRemoteDescription(new optionalWrtc.RTCSessionDescription({
+            type: 'answer',
+            sdp: connect.sdp_answer_data,
+        }));
+        await client.setVoiceChatState(chatGuid, voiceChatId);
+    }
+    setTimers() {
+        this.clearTimers();
+        this.updateTimers.push(setInterval(async () => {
+            if (this.client && this.chatGuid && this.voiceChatId) {
+                await this.client.getGroupVoiceChatUpdates(this.chatGuid, this.voiceChatId);
+            }
+        }, 10 * 1000));
+        this.updateTimers.push(setInterval(async () => {
+            if (this.client && this.chatGuid && this.voiceChatId &&
+                this.client.userGuid && !this.isPaused) {
+                await this.client.sendVoiceChatActivity(this.chatGuid, this.voiceChatId, this.client.userGuid);
+            }
+        }, 2 * 1000));
+    }
+    clearTimers() {
+        this.updateTimers.forEach(clearInterval);
+        this.updateTimers = [];
+    }
+}
+exports.default = VoiceChatClient;

package/lib/clients/index.d.ts

@@ -0,0 +1,3 @@
+import LoginClient from './loginClient';
+import VoiceChatClient from './VoiceChatClient';
+export { LoginClient, VoiceChatClient };

package/lib/clients/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.VoiceChatClient = exports.LoginClient = void 0;
+const loginClient_1 = __importDefault(require("./loginClient"));
+exports.LoginClient = loginClient_1.default;
+const VoiceChatClient_1 = __importDefault(require("./VoiceChatClient"));
+exports.VoiceChatClient = VoiceChatClient_1.default;

package/lib/clients/loginClient.d.ts

@@ -0,0 +1,47 @@
+import Network from './network_login';
+interface AuthResult {
+    isOk: boolean;
+    status?: string;
+    phone_code_hash?: string;
+    code_digits_count?: number;
+    auth?: string;
+    key?: Buffer;
+    decode_auth?: string;
+    phone_number?: string;
+}
+interface AuthFace {
+    auth: string;
+    key: Buffer;
+    privateKey: any;
+    decode_auth?: string;
+}
+declare class LoginClient {
+    static systemVersions: Record<string, string>;
+    static sendCode(phone_number: string, pass_key?: string): Promise<AuthResult>;
+    static signIn(phone_code: string, datas: AuthResult, sessionPath?: string): Promise<{
+        isOk: boolean;
+        status: string;
+        sessionData?: undefined;
+    } | {
+        isOk: boolean;
+        status: string;
+        sessionData: {
+            phone: any;
+            auth: string;
+            guid: any;
+            agent: string;
+            private_key: string;
+        };
+    } | undefined>;
+    static registerDevice(network: Network, datas: AuthFace): Promise<void>;
+    static getBrowser(userAgent: string, langCode: string, appVersion: string): Promise<{
+        token: string;
+        lang_code: string;
+        token_type: string;
+        app_version: string;
+        system_version: string;
+        device_model: string;
+        device_hash: string;
+    }>;
+}
+export default LoginClient;

package/lib/clients/loginClient.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("../core/crypto"));
+const network_login_1 = __importDefault(require("./network_login"));
+const session_1 = __importDefault(require("../core/session"));
+class LoginClient {
+    static async sendCode(phone_number, pass_key) {
+        const network = new network_login_1.default();
+        const data = {
+            phone_number,
+            pass_key: pass_key || null,
+            send_type: 'SMS',
+        };
+        const result = await network.bulder('sendCode', data, {}, true);
+        if (result)
+            return {
+                isOk: true,
+                status: result.status,
+                phone_code_hash: result.phone_code_hash,
+                code_digits_count: result.code_digits_count,
+                auth: result.auth_data,
+                key: result.key_data,
+                phone_number,
+            };
+        return {
+            isOk: false,
+        };
+    }
+    static async signIn(phone_code, datas, sessionPath) {
+        if (!datas.auth || !datas.key)
+            return;
+        const network = new network_login_1.default();
+        const [publicKey, privateKey] = crypto_1.default.createKeys();
+        const data = {
+            phone_code,
+            phone_number: datas.phone_number,
+            phone_code_hash: datas.phone_code_hash,
+            public_key: publicKey,
+        };
+        const auth = {
+            auth: datas.auth,
+            key: datas.key,
+            privateKey,
+        };
+        const response = await network.bulder('signIn', data, auth, true);
+        if (response?.status === 'CodeIsInvalid') {
+            return { isOk: false, status: 'CodeIsInvalid' };
+        }
+        if (!response)
+            return { isOk: false, status: 'CodeIsInvalid' };
+        const sampleAuth = crypto_1.default.decrypt_RSA_OAEP(privateKey, response.auth);
+        auth.key = Buffer.from(crypto_1.default.passphrase(sampleAuth), 'utf8');
+        auth.auth = sampleAuth;
+        auth.decode_auth = crypto_1.default.decode_auth(sampleAuth);
+        await this.registerDevice(network, auth);
+        const sessionData = {
+            phone: response.user.phone,
+            auth: auth.auth,
+            guid: response.user.user_guid,
+            agent: network.userAgent,
+            private_key: privateKey,
+        };
+        if (sessionPath) {
+            const session = new session_1.default(sessionPath);
+            session.saveSession(sessionData);
+        }
+        return { isOk: true, status: 'Sucessfull', sessionData };
+    }
+    static async registerDevice(network, datas) {
+        const browserData = await this.getBrowser(network.userAgent, network.defaultPlatform.lang_code, network.defaultPlatform.app_version);
+        await network.bulder('registerDevice', browserData, datas);
+    }
+    static async getBrowser(userAgent, langCode, appVersion) {
+        const match = userAgent
+            .toLowerCase()
+            .match(/(opera|chrome|safari|firefox|msie|trident)\/(\d+)/);
+        if (!match) {
+            throw new Error(`Cannot parse user-agent: ${userAgent}`);
+        }
+        const deviceModel = `${match[1]} ${match[2]}`;
+        const systemVersion = Object.entries(this.systemVersions).find(([key]) => userAgent.includes(key))?.[1] || 'Unknown';
+        const deviceHash = '2' + (userAgent.match(/\d+/g)?.join('') || '');
+        return {
+            token: '',
+            lang_code: langCode,
+            token_type: 'Web',
+            app_version: `WB_${appVersion}`,
+            system_version: systemVersion,
+            device_model: deviceModel.charAt(0).toUpperCase() + deviceModel.slice(1),
+            device_hash: deviceHash,
+        };
+    }
+}
+LoginClient.systemVersions = {
+    'Windows NT 10.0': 'Windows 10',
+    'Windows NT 6.2': 'Windows 8',
+    'Windows NT 6.1': 'Windows 7',
+    'Windows NT 6.0': 'Windows Vista',
+    'Windows NT 5.1': 'Windows XP',
+    'Windows NT 5.0': 'Windows 2000',
+    Mac: 'Mac/iOS',
+    X11: 'UNIX',
+    Linux: 'Linux',
+};
+exports.default = LoginClient;

package/lib/clients/network_login.d.ts

@@ -0,0 +1,47 @@
+interface PlatformInfo {
+    app_name: string;
+    app_version: string;
+    platform: string;
+    package: string;
+    lang_code: string;
+}
+interface AuthInfo {
+    auth?: string;
+    decode_auth?: string;
+    key?: Buffer;
+    privateKey?: string;
+}
+interface SendOptions {
+    input?: Record<string, any>;
+    method?: string;
+    tmp_session?: boolean;
+}
+interface ServerResponse {
+    data_enc?: string;
+    status?: string;
+    status_det?: string;
+    data?: Record<string, any>;
+}
+declare class Network {
+    private headers;
+    private agent;
+    private apiUrl;
+    defaultPlatform: PlatformInfo;
+    userAgent: string;
+    constructor();
+    /**
+     * Retrieves API and WSS server URLs
+     */
+    getDcs(): Promise<boolean>;
+    /**
+     * Sends a POST request with retry logic and enhanced error reporting
+     */
+    request(url: string, data: Record<string, any>): Promise<any>;
+    send({ input, method, tmp_session }: SendOptions, { auth, decode_auth, key, privateKey }: AuthInfo): Promise<ServerResponse | undefined>;
+    bulder(name: string, input: Record<string, any>, { auth, key, decode_auth, privateKey }: AuthInfo, tmp_session?: boolean): Promise<Record<string, any> | undefined>;
+    /**
+     * Delay utility
+     */
+    delay(ms: number): Promise<void>;
+}
+export default Network;

package/lib/clients/network_login.js

@@ -0,0 +1,137 @@
+"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 crypto_1 = __importDefault(require("../core/crypto"));
+class Network {
+    constructor() {
+        this.apiUrl = null;
+        this.defaultPlatform = {
+            app_name: 'Main',
+            app_version: '4.4.9',
+            platform: 'Web',
+            package: 'web.rubika.ir',
+            lang_code: 'fa',
+        };
+        this.userAgent = `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36`;
+        this.headers = {
+            origin: 'https://web.rubika.ir',
+            referer: 'https://web.rubika.ir/',
+            'content-type': 'application/json',
+            connection: 'keep-alive',
+            'user-agent': this.userAgent,
+        };
+        this.agent = new undici_1.Agent({
+            connect: {
+                rejectUnauthorized: false,
+            },
+        });
+    }
+    /**
+     * Retrieves API and WSS server URLs
+     */
+    async getDcs() {
+        const url = 'https://getdcmess.iranlms.ir/';
+        const RETRY_DELAY = 3000;
+        while (true) {
+            try {
+                const res = await (0, undici_1.request)(url, {
+                    method: 'GET',
+                    dispatcher: this.agent,
+                });
+                if (res.statusCode === 200) {
+                    const body = (await res.body.json());
+                    if (body?.data) {
+                        const dcs = body.data;
+                        this.apiUrl = `${dcs.API[dcs.default_api]}/`;
+                        return true;
+                    }
+                }
+                console.warn('[getDcs] Unexpected status or data format:', res.statusCode);
+            }
+            catch (error) {
+                console.error('[getDcs] Error:', error);
+            }
+            await this.delay(RETRY_DELAY);
+        }
+    }
+    /**
+     * Sends a POST request with retry logic and enhanced error reporting
+     */
+    async request(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',
+                        ...this.headers,
+                    },
+                    body: JSON.stringify(data),
+                    dispatcher: this.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 this.delay(1000);
+        }
+        throw new Error(`[request] Failed after ${MAX_ATTEMPTS} attempts: ${url}`);
+    }
+    async send({ input = {}, method = 'getUserInfo', tmp_session }, { auth, decode_auth, key, privateKey }) {
+        if (!this.apiUrl)
+            await this.getDcs();
+        const payload = {
+            api_version: '6',
+            [tmp_session ? 'tmp_session' : 'auth']: tmp_session ? auth : decode_auth,
+        };
+        const data_enc = JSON.stringify({
+            client: this.defaultPlatform,
+            method,
+            input,
+        });
+        payload['data_enc'] = crypto_1.default.encrypt(data_enc, key);
+        if (!tmp_session && privateKey) {
+            payload['sign'] = crypto_1.default.sign(payload['data_enc'], privateKey);
+        }
+        return await this.request(this.apiUrl, payload);
+    }
+    async bulder(name, input, { auth, key, decode_auth, privateKey }, tmp_session = false) {
+        if (!auth)
+            auth = crypto_1.default.secret(32);
+        if (!key)
+            key = Buffer.from(crypto_1.default.passphrase(auth), 'utf8');
+        const result = await this.send({
+            input,
+            tmp_session,
+            method: name,
+        }, { auth, key, decode_auth, privateKey });
+        if (result) {
+            const { data_enc } = result;
+            if (data_enc) {
+                const decrypted = crypto_1.default.decrypt(data_enc, key);
+                const parsed = JSON.parse(decrypted);
+                if (parsed.status === 'OK' && parsed.status_det === 'OK') {
+                    return { ...parsed.data, auth_data: auth, key_data: key };
+                }
+            }
+        }
+    }
+    /**
+     * Delay utility
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.default = Network;

package/lib/core/client.d.ts

@@ -0,0 +1,29 @@
+import Network from './network';
+import Methods from './methods';
+import SessionManager from './session';
+import Message from './context/message.type';
+import { ClientTypes } from '../types/index.type';
+import { ContextMap, Handler } from '../types/client.type';
+export default class Client extends Methods {
+    private session;
+    platform: ClientTypes.PlatformType;
+    timeout: number;
+    initialize: boolean;
+    key?: Buffer<ArrayBuffer>;
+    privateKey?: string;
+    decode_auth?: string;
+    auth?: string;
+    sessionDb: SessionManager;
+    network: Network;
+    plugins: ClientTypes.RubPlugin[];
+    errorMiddlewares: ClientTypes.ErrorMiddleware[];
+    userGuid?: string;
+    handlers: {
+        [K in keyof ContextMap]: Handler<ContextMap[K]>[];
+    };
+    constructor(session: ClientTypes.SessionType, platform?: ClientTypes.PlatformType, timeout?: number);
+    on<T extends keyof typeof this.handlers>(type: T, handler: (ctx: ContextMap[T]) => Promise<void>): void;
+    on<T extends keyof typeof this.handlers>(type: T, filters: Array<(ctx: ContextMap[T]) => boolean | Promise<boolean>>, handler: (ctx: ContextMap[T]) => Promise<void>): void;
+    command(prefix: string | RegExp, handler: (ctx: Message) => Promise<void>): void;
+    command(prefix: string | RegExp, filters: Array<(ctx: Message) => boolean | Promise<boolean>>, handler: (ctx: Message) => Promise<void>): void;
+}