rubjs 1.0.0

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "rubjs",
+  "version": "1.0.0",
+  "main": "rubjs/index.js",
+  "types": "rubjs/index.d.ts",
+  "keywords": [
+    "javascript",
+    "Rubika",
+    "library"
+  ],
+  "module": "rubjs/index.js",
+  "exports": {
+    "import": "./rubjs/index.js",
+    "require": "./rubjs/index.js",
+    "types": "./rubjs/index.d.ts"
+  },
+  "author": "Hadi Rostami",
+  "license": "MIT",
+  "type": "commonjs",
+  "description": "A library for Rubika in JavaScript.",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "axios": "^1.7.9",
+    "better-sqlite3": "^11.8.1",
+    "input": "^1.0.1",
+    "node-rsa": "^1.1.1",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.1",
+    "typescript": "^5.7.3"
+  },
+  "files": [
+    "rubjs/",
+    "README.md"
+  ]
+}

package/rubjs/client.d.ts

@@ -0,0 +1,34 @@
+import Methods from "./methods";
+import Network from "./network";
+import SQLiteSession from "./session";
+interface Platform {
+    app_name: string;
+    app_version: string;
+    platform: string;
+    package: string;
+    lang_code: string;
+}
+type TypeUpdate = "show_activities" | "chat_updates" | "message_updates" | "show_notifications";
+type PlatformType = "Web" | "Android";
+declare class Client extends Methods {
+    defaultPlatform: Platform;
+    apiVersion: string;
+    userAgent: string;
+    key: Buffer<ArrayBuffer>;
+    decode_auth: string;
+    auth: string | null;
+    timeout: number;
+    network: Network;
+    privateKey: string | null;
+    sessionFile: string;
+    platform: PlatformType;
+    userGuid: string | null;
+    sessionDb: SQLiteSession;
+    eventHandlers: {
+        callback: Function;
+        filters: ((msg: any) => boolean)[];
+        updateType: TypeUpdate;
+    }[];
+    constructor(sessionFile: string, timeout?: number, platform?: PlatformType);
+}
+export default Client;

package/rubjs/client.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const methods_1 = __importDefault(require("./methods"));
+const network_1 = __importDefault(require("./network"));
+const session_1 = __importDefault(require("./session"));
+class Client extends methods_1.default {
+    constructor(sessionFile, timeout, platform = "Web") {
+        super();
+        this.defaultPlatform = {
+            app_name: "Main",
+            app_version: "4.4.9",
+            platform: "Web",
+            package: "web.rubika.ir",
+            lang_code: "fa",
+        };
+        this.apiVersion = "6";
+        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`;
+        if (platform.toLowerCase() === "android") {
+            this.defaultPlatform.platform = "Android";
+            this.defaultPlatform["package"] = "app.rbmain.a";
+            this.defaultPlatform["app_version"] = "3.6.4";
+        }
+        this.sessionFile = sessionFile;
+        this.userGuid = null;
+        this.timeout = timeout !== null && timeout !== void 0 ? timeout : 0;
+        this.eventHandlers = [];
+        this.platform = platform;
+        this.sessionDb = new session_1.default(sessionFile);
+        this.network = new network_1.default(this);
+        this.auth = null;
+        this.privateKey = null;
+        this.eventHandlers = [];
+        const DBInformation = this.sessionDb.getSession();
+        if (DBInformation) {
+            this.auth = DBInformation.auth;
+            this.userGuid = DBInformation.guid;
+            this.privateKey = DBInformation.private_key;
+            if (typeof DBInformation.agent === "string")
+                this.userAgent = DBInformation.agent || this.userAgent;
+        }
+        this.start();
+    }
+}
+exports.default = Client;

package/rubjs/crypto/index.d.ts

@@ -0,0 +1,12 @@
+declare class Crypto {
+    static AES_IV: Buffer<ArrayBuffer>;
+    static decode_auth: (auth: string) => string;
+    static passphrase(auth: string): string;
+    static secret(length: number): string;
+    static decrypt(data_enc: string, key: Buffer<ArrayBufferLike>): string;
+    static encrypt(data: string, key: Buffer<ArrayBufferLike>): string;
+    static sign(data_enc: string, privateKey: string): string;
+    static createKeys(): any[];
+    static decrypt_RSA_OAEP(private_key: string, data: string): any;
+}
+export default Crypto;

package/rubjs/crypto/index.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 });
+const node_rsa_1 = __importDefault(require("node-rsa"));
+const crypto_1 = __importDefault(require("crypto"));
+class Crypto {
+    static passphrase(auth) {
+        if (auth.length !== 32) {
+            throw new Error("auth length should be 32 digits");
+        }
+        const resultList = [];
+        const chunks = auth.match(/.{8}/g);
+        if (!chunks || chunks.length !== 4) {
+            throw new Error("Invalid auth format");
+        }
+        const combined = chunks[2] + chunks[0] + chunks[3] + chunks[1];
+        for (const character of combined) {
+            const newChar = String.fromCharCode(((character.charCodeAt(0) - 97 + 9) % 26) + 97);
+            resultList.push(newChar);
+        }
+        return resultList.join("");
+    }
+    static secret(length) {
+        if (length <= 0 || !Number.isInteger(length)) {
+            throw new Error("Length must be a positive integer");
+        }
+        const characters = "abcdefghijklmnopqrstuvwxyz";
+        let secret = "";
+        for (let i = 0; i < length; i++) {
+            const randomIndex = Math.floor(Math.random() * characters.length);
+            secret += characters[randomIndex];
+        }
+        return secret;
+    }
+    static decrypt(data_enc, key) {
+        const decipher = crypto_1.default.createDecipheriv("aes-256-cbc", key, this.AES_IV);
+        let decrypted = decipher.update(data_enc, "base64", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+    }
+    static encrypt(data, key) {
+        const cipher = crypto_1.default.createCipheriv("aes-256-cbc", key, this.AES_IV);
+        let encrypted = cipher.update(data, "utf8", "base64");
+        encrypted += cipher.final("base64");
+        return encrypted;
+    }
+    static sign(data_enc, privateKey) {
+        if (!privateKey) {
+            throw new Error("Private key is not defined");
+        }
+        const sign = crypto_1.default.createSign("SHA256");
+        sign.update(data_enc);
+        sign.end();
+        const signature = sign.sign(privateKey, "base64");
+        return signature;
+    }
+    static createKeys() {
+        const keyPair = new node_rsa_1.default({
+            b: 1024,
+        });
+        let publicKey = Crypto.decode_auth(Buffer.from(keyPair.exportKey("pkcs1-public-pem"), "binary").toString("base64"));
+        let privateKey = keyPair.exportKey("pkcs1-private-pem");
+        return [publicKey, privateKey];
+    }
+    static decrypt_RSA_OAEP(private_key, data) {
+        const keyPair = new node_rsa_1.default(private_key);
+        const decrypted = keyPair.decrypt(data, "utf8");
+        return decrypted;
+    }
+}
+Crypto.AES_IV = Buffer.alloc(16, 0);
+Crypto.decode_auth = (auth) => {
+    let n = "";
+    const lowercase = "abcdefghijklmnopqrstuvwxyz";
+    const uppercase = lowercase.toUpperCase();
+    const digits = "0123456789";
+    for (const s of auth) {
+        if (lowercase.includes(s)) {
+            n += String.fromCharCode(((32 - (s.charCodeAt(0) - 97)) % 26) + 97);
+        }
+        else if (uppercase.includes(s)) {
+            n += String.fromCharCode(((29 - (s.charCodeAt(0) - 65)) % 26) + 65);
+        }
+        else if (digits.includes(s)) {
+            n += String.fromCharCode(((13 - (s.charCodeAt(0) - 48)) % 10) + 48);
+        }
+        else {
+            n += s;
+        }
+    }
+    return n;
+};
+exports.default = Crypto;

package/rubjs/index.d.ts

@@ -0,0 +1,4 @@
+import Client from "./client";
+import { Filters } from "./utils";
+export default Client;
+export { Filters, Client };

package/rubjs/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = exports.Filters = void 0;
+const client_1 = __importDefault(require("./client"));
+exports.Client = client_1.default;
+const utils_1 = require("./utils");
+Object.defineProperty(exports, "Filters", { enumerable: true, get: function () { return utils_1.Filters; } });
+exports.default = client_1.default;

package/rubjs/methods/advanced/builder.d.ts

@@ -0,0 +1,3 @@
+import Client from "../..";
+declare function builder(this: Client, name: string, input: object, tmp_session?: boolean): Promise<any>;
+export default builder;

package/rubjs/methods/advanced/builder.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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("../../crypto"));
+function builder(name_1, input_1) {
+    return __awaiter(this, arguments, void 0, function* (name, input, tmp_session = false) {
+        if (!this.auth)
+            this.auth = crypto_1.default.secret(32);
+        if (!this.key)
+            this.key = Buffer.from(crypto_1.default.passphrase(this.auth), "utf8");
+        let result = yield this.network.send({
+            input,
+            tmp_session,
+            method: name,
+        });
+        if (result) {
+            const data_enc = result.data_enc;
+            if (data_enc) {
+                const decrypted = crypto_1.default.decrypt(data_enc, this.key);
+                result = JSON.parse(decrypted);
+            }
+            const status = result.status;
+            const status_det = result.status_det;
+            if (status == "OK" && status_det == "OK") {
+                return result.data;
+            }
+        }
+    });
+}
+exports.default = builder;

package/rubjs/methods/advanced/index.d.ts

@@ -0,0 +1,2 @@
+import builder from "./builder";
+export { builder };

package/rubjs/methods/advanced/index.js

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

package/rubjs/methods/auth/index.d.ts

@@ -0,0 +1,4 @@
+import register_device from "./register_device";
+import send_code from "./send_code";
+import sign_in from "./sign_in";
+export { register_device, send_code, sign_in };

package/rubjs/methods/auth/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sign_in = exports.send_code = exports.register_device = void 0;
+const register_device_1 = __importDefault(require("./register_device"));
+exports.register_device = register_device_1.default;
+const send_code_1 = __importDefault(require("./send_code"));
+exports.send_code = send_code_1.default;
+const sign_in_1 = __importDefault(require("./sign_in"));
+exports.sign_in = sign_in_1.default;

package/rubjs/methods/auth/register_device.d.ts

@@ -0,0 +1,3 @@
+import Client from "../..";
+declare function register_device(this: Client): Promise<void>;
+export default register_device;

package/rubjs/methods/auth/register_device.js

@@ -0,0 +1,61 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const 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",
+};
+function getBrowser(userAgent, langCode, appVersion, ...args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const deviceModelMatch = userAgent
+            .toLowerCase()
+            .match(/(opera|chrome|safari|firefox|msie|trident)\/(\d+)/);
+        let deviceModel = "Unknown";
+        if (!deviceModelMatch) {
+            console.warn(`Cannot parse user-agent (${userAgent})`);
+        }
+        else {
+            deviceModel = `${deviceModelMatch[1]} ${deviceModelMatch[2]}`;
+        }
+        let systemVersion = "Unknown";
+        for (const [key, value] of Object.entries(systemVersions)) {
+            if (userAgent.includes(key)) {
+                systemVersion = value;
+                break;
+            }
+        }
+        const deviceHash = "2" + (((_a = userAgent.match(/\d+/g)) === null || _a === void 0 ? void 0 : _a.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,
+        };
+    });
+}
+function register_device() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield this.builder("registerDevice", yield getBrowser(this.userAgent, this.defaultPlatform.lang_code, this.defaultPlatform.app_version));
+        return result;
+    });
+}
+exports.default = register_device;

package/rubjs/methods/auth/send_code.d.ts

@@ -0,0 +1,4 @@
+import Client from "../..";
+import { SendCode } from "../../types";
+declare function send_code(this: Client, phone_number: string, pass_key?: string, send_type?: string): Promise<SendCode>;
+export default send_code;

package/rubjs/methods/auth/send_code.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function send_code(phone_number_1) {
+    return __awaiter(this, arguments, void 0, function* (phone_number, pass_key = null, send_type = "SMS") {
+        if (!["SMS", "Internal"].includes(send_type))
+            throw new Error("send_type can only be `SMS` or `Internal`.");
+        const data = {
+            phone_number,
+            pass_key,
+            send_type,
+        };
+        const result = yield this.builder("sendCode", data, true);
+        return result;
+    });
+}
+exports.default = send_code;

package/rubjs/methods/auth/sign_in.d.ts

@@ -0,0 +1,4 @@
+import Client from "../..";
+import { SignIn } from "../../types";
+declare function sign_in(this: Client, phone_code: string, phone_number: string, phone_code_hash: string, public_key: string): Promise<SignIn>;
+export default sign_in;

package/rubjs/methods/auth/sign_in.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function sign_in(phone_code, phone_number, phone_code_hash, public_key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const data = {
+            phone_code,
+            phone_number,
+            phone_code_hash,
+            public_key,
+        };
+        const result = yield this.builder("signIn", data, true);
+        return result;
+    });
+}
+exports.default = sign_in;

package/rubjs/methods/index.d.ts

@@ -0,0 +1,21 @@
+import Client from "..";
+import { UserInfo, SendCode, SignIn, MessageUpdate, ChatUpdates, ShowNotifications, ShowActivities } from "../types";
+declare class Methods {
+    private registerHandler;
+    on_message_updates(callback: (message: MessageUpdate) => void): void;
+    on_message_updates(filters: ((msg: MessageUpdate) => boolean)[], callback: (message: MessageUpdate) => void): void;
+    on_chat_updates(callback: (message: ChatUpdates) => void): void;
+    on_chat_updates(filters: ((msg: ChatUpdates) => boolean)[], callback: (message: ChatUpdates) => void): void;
+    on_show_activities(callback: (message: ShowActivities) => void): void;
+    on_show_activities(filters: ((msg: ShowActivities) => boolean)[], callback: (message: ShowActivities) => void): void;
+    on_show_notifications(callback: (message: ShowNotifications) => void): void;
+    on_show_notifications(filters: ((msg: ShowNotifications) => boolean)[], callback: (message: ShowNotifications) => void): void;
+    run: (this: Client) => Promise<void>;
+    start: (this: Client) => Promise<void>;
+    get_user_info: (this: Client) => Promise<UserInfo>;
+    register_device: (this: Client) => Promise<void>;
+    send_code: (this: Client, phone_number: string, pass_key?: string, send_type?: string) => Promise<SendCode>;
+    sign_in: (this: Client, phone_code: string, phone_number: string, phone_code_hash: string, public_key: string) => Promise<SignIn>;
+    builder: (this: Client, name: string, input: object, tmp_session?: boolean) => Promise<any>;
+}
+export default Methods;

package/rubjs/methods/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utilities_1 = require("./utilities");
+const users_1 = require("./users");
+const advanced_1 = require("./advanced");
+const auth_1 = require("./auth");
+class Methods {
+    registerHandler(updateType, arg1, arg2) {
+        let filters = [];
+        let callback;
+        if (typeof arg1 === "function") {
+            callback = arg1;
+        }
+        else {
+            filters = arg1;
+            callback = arg2;
+        }
+        this.eventHandlers.push({ callback, filters, updateType });
+    }
+    on_message_updates(arg1, arg2) {
+        this.registerHandler("message_updates", arg1, arg2);
+    }
+    on_chat_updates(arg1, arg2) {
+        this.registerHandler("chat_updates", arg1, arg2);
+    }
+    on_show_activities(arg1, arg2) {
+        this.registerHandler("show_activities", arg1, arg2);
+    }
+    on_show_notifications(arg1, arg2) {
+        this.registerHandler("show_notifications", arg1, arg2);
+    }
+}
+Methods.prototype.run = utilities_1.run;
+Methods.prototype.start = utilities_1.start;
+Methods.prototype.get_user_info = users_1.get_user_info;
+Methods.prototype.builder = advanced_1.builder;
+Methods.prototype.register_device = auth_1.register_device;
+Methods.prototype.send_code = auth_1.send_code;
+Methods.prototype.sign_in = auth_1.sign_in;
+exports.default = Methods;

package/rubjs/methods/users/get_user_info.d.ts

@@ -0,0 +1,4 @@
+import Client from "../..";
+import { UserInfo } from "../../types";
+declare function get_user_info(this: Client, user_guid?: string | null): Promise<UserInfo>;
+export default get_user_info;

package/rubjs/methods/users/get_user_info.js

@@ -0,0 +1,18 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function get_user_info() {
+    return __awaiter(this, arguments, void 0, function* (user_guid = null) {
+        const result = yield this.builder("getUserInfo", user_guid ? { user_guid } : {}, this.auth ? false : true);
+        return result;
+    });
+}
+exports.default = get_user_info;

package/rubjs/methods/users/index.d.ts

@@ -0,0 +1,2 @@
+import get_user_info from "./get_user_info";
+export { get_user_info };

package/rubjs/methods/users/index.js

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

package/rubjs/methods/utilities/index.d.ts

@@ -0,0 +1,3 @@
+import start from "./start";
+import run from "./run";
+export { start, run, };

package/rubjs/methods/utilities/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.run = exports.start = void 0;
+const start_1 = __importDefault(require("./start"));
+exports.start = start_1.default;
+const run_1 = __importDefault(require("./run"));
+exports.run = run_1.default;

package/rubjs/methods/utilities/on_chat_updates.d.ts

@@ -0,0 +1,4 @@
+import Client from "../..";
+import { MessageUpdate } from "../../types";
+declare function on_chat_updates(this: Client, filters: ((msg: any) => boolean)[], callback: (message: MessageUpdate) => void): Promise<void>;
+export default on_chat_updates;

package/rubjs/methods/utilities/on_chat_updates.js

@@ -0,0 +1,17 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function on_chat_updates(filters, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        this.eventHandlers.push({ callback, filters, updateType: "chat_updates" });
+    });
+}
+exports.default = on_chat_updates;

package/rubjs/methods/utilities/on_message_updates.d.ts

@@ -0,0 +1,4 @@
+import Client from "../..";
+import { MessageUpdate } from "../../types";
+declare function on_message_updates(this: Client, filters: ((msg: any) => boolean)[], callback: (message: MessageUpdate) => void): Promise<void>;
+export default on_message_updates;

package/rubjs/methods/utilities/on_message_updates.js

@@ -0,0 +1,17 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function on_message_updates(filters, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        this.eventHandlers.push({ callback, filters, updateType: "message_updates" });
+    });
+}
+exports.default = on_message_updates;

package/rubjs/methods/utilities/on_show_activities.d.ts

@@ -0,0 +1,4 @@
+import Client from "../..";
+import { MessageUpdate } from "../../types";
+declare function on_show_activities(this: Client, filters: ((msg: any) => boolean)[], callback: (message: MessageUpdate) => void): Promise<void>;
+export default on_show_activities;