rubjs 2.4.1 → 2.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rubjs",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "main": "rubjs/index.js",
   "types": "rubjs/index.d.ts",
   "keywords": [

package/rubjs/client.d.ts

@@ -0,0 +1,35 @@
+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;
+    initialize: boolean;
+    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,48 @@
+"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 = [];
+        this.initialize = false;
+        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,7 @@
+import Client from "./client";
+import Crypto from "./crypto";
+import Markdown from "./parser";
+import * as Types from "./types";
+import { Filters, Utils } from "./utils";
+export default Client;
+export { Client, Crypto, Markdown, Utils, Filters, Types };

package/rubjs/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Types = exports.Filters = exports.Utils = exports.Markdown = exports.Crypto = exports.Client = void 0;
+const client_1 = __importDefault(require("./client"));
+exports.Client = client_1.default;
+const crypto_1 = __importDefault(require("./crypto"));
+exports.Crypto = crypto_1.default;
+const parser_1 = __importDefault(require("./parser"));
+exports.Markdown = parser_1.default;
+const Types = __importStar(require("./types"));
+exports.Types = Types;
+const utils_1 = require("./utils");
+Object.defineProperty(exports, "Filters", { enumerable: true, get: function () { return utils_1.Filters; } });
+Object.defineProperty(exports, "Utils", { enumerable: true, get: function () { return utils_1.Utils; } });
+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,5 @@
+import registerDevice from './registerDevice';
+import sendCode from './sendCode';
+import signIn from './signIn';
+import logout from './logout';
+export { registerDevice, sendCode, signIn, logout };

package/rubjs/methods/auth/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logout = exports.signIn = exports.sendCode = exports.registerDevice = void 0;
+const registerDevice_1 = __importDefault(require("./registerDevice"));
+exports.registerDevice = registerDevice_1.default;
+const sendCode_1 = __importDefault(require("./sendCode"));
+exports.sendCode = sendCode_1.default;
+const signIn_1 = __importDefault(require("./signIn"));
+exports.signIn = signIn_1.default;
+const logout_1 = __importDefault(require("./logout"));
+exports.logout = logout_1.default;

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

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

package/rubjs/methods/auth/logout.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 logout() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.builder("logout", {});
+    });
+}
+exports.default = logout;

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

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

package/rubjs/methods/auth/registerDevice.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 registerDevice() {
+    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 = registerDevice;

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

@@ -0,0 +1,3 @@
+import Client from "../..";
+declare function sendCode(this: Client, phone_number: string, pass_key?: string, send_type?: string): Promise<any>;
+export default sendCode;

package/rubjs/methods/auth/sendCode.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 sendCode(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 = sendCode;

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

@@ -0,0 +1,3 @@
+import Client from "../..";
+declare function signIn(this: Client, phone_code: string, phone_number: string, phone_code_hash: string, public_key: string): Promise<any>;
+export default signIn;

package/rubjs/methods/auth/signIn.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 signIn(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 = signIn;

package/rubjs/methods/channels/addChannel.d.ts

@@ -0,0 +1,3 @@
+import Client from "../..";
+declare function addChannel(this: Client, title: string, description?: string, member_guids?: string[]): Promise<any>;
+export default addChannel;

package/rubjs/methods/channels/addChannel.js

@@ -0,0 +1,26 @@
+"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 addChannel(title, description, member_guids) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let input = { title };
+        if (description)
+            input.description = description;
+        if (member_guids) {
+            if (typeof member_guids === "string") {
+                member_guids = [member_guids];
+            }
+            input.member_guids = member_guids;
+        }
+        return yield this.builder("addChannel", input);
+    });
+}
+exports.default = addChannel;

package/rubjs/methods/channels/addChannelMembers.d.ts

@@ -0,0 +1,3 @@
+import Client from "../..";
+declare function addChannelMembers(this: Client, channel_guid: string, member_guids: string[] | string): Promise<any>;
+export default addChannelMembers;

package/rubjs/methods/channels/addChannelMembers.js

@@ -0,0 +1,22 @@
+"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 addChannelMembers(channel_guid, member_guids) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof member_guids === "string")
+            member_guids = [member_guids];
+        return yield this.builder("addChannelMembers", {
+            channel_guid,
+            member_guids,
+        });
+    });
+}
+exports.default = addChannelMembers;

package/rubjs/methods/channels/banChannelMember.d.ts

@@ -0,0 +1,3 @@
+import Client from "../..";
+declare function banChannelMember(this: Client, channel_guid: string, member_guid: string, action?: "Set" | "Unset"): Promise<any>;
+export default banChannelMember;

package/rubjs/methods/channels/banChannelMember.js

@@ -0,0 +1,23 @@
+"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 banChannelMember(channel_guid_1, member_guid_1) {
+    return __awaiter(this, arguments, void 0, function* (channel_guid, member_guid, action = "Set") {
+        if (!["Set", "Unset"].includes(action))
+            throw new Error(`${action} argument can only be in ["Set", "Unset"]`);
+        return yield this.builder("banChannelMember", {
+            channel_guid,
+            member_guid,
+            action,
+        });
+    });
+}
+exports.default = banChannelMember;

package/rubjs/methods/channels/cancelChangeObjectOwner.d.ts

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

package/rubjs/methods/channels/cancelChangeObjectOwner.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 cancelChangeObjectOwner(object_guid) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield this.builder("cancelChangeObjectOwner", { object_guid });
+    });
+}
+exports.default = cancelChangeObjectOwner;

package/rubjs/methods/channels/channelPreviewByJoinLink.d.ts

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

package/rubjs/methods/channels/channelPreviewByJoinLink.js

@@ -0,0 +1,19 @@
+"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 channelPreviewByJoinLink(link) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (link.includes("/"))
+            link = link.split("/")[-1];
+        return yield this.builder("channelPreviewByJoinLink", { hash_link: link });
+    });
+}
+exports.default = channelPreviewByJoinLink;

package/rubjs/methods/channels/checkChannelUsername.d.ts

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