rubjs 2.9.2 → 3.0.0

package/lib/core/crypto.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/lib/core/filters.d.ts

@@ -0,0 +1,33 @@
+import { MessageUpdate, FileInline } from "../types/decorators.type";
+declare class Filters {
+    static findKey(message: any, key: string): any;
+    static guidType(message: MessageUpdate, startWith: string): boolean;
+    static isMention(message: MessageUpdate): boolean;
+    static isMarkdown(message: MessageUpdate): boolean;
+    static isReply(message: MessageUpdate): boolean;
+    static isEdited(message: MessageUpdate): boolean;
+    static isLink(message: MessageUpdate): boolean;
+    static isText(message: MessageUpdate): boolean;
+    static isGroup(message: MessageUpdate): boolean;
+    static isChannel(message: MessageUpdate): boolean;
+    static isPrivate(message: MessageUpdate): boolean;
+    static isForward(message: MessageUpdate): boolean;
+    static fileInline(message: MessageUpdate): FileInline | undefined;
+    static isFileInline(message: MessageUpdate): boolean;
+    static isFile(message: MessageUpdate): boolean;
+    static isPhoto(message: MessageUpdate): boolean;
+    static isSticker(message: MessageUpdate): boolean;
+    static isVideo(message: MessageUpdate): boolean;
+    static isVoice(message: MessageUpdate): boolean;
+    static isGif(message: MessageUpdate): boolean;
+    static isMusic(message: MessageUpdate): boolean;
+    static isLocation(message: MessageUpdate): boolean;
+    static isContact(message: MessageUpdate): boolean;
+    static isPoll(message: MessageUpdate): boolean;
+    static isLive(message: MessageUpdate): boolean;
+    static isEvent(message: MessageUpdate): boolean;
+    static isLength(length: number, object_guid?: string): (message: MessageUpdate) => boolean;
+    static startsWithCommand(text: string, object_guid?: string, length?: number): (message: MessageUpdate) => boolean | undefined;
+    static equalCommand(text: string, object_guid?: string): (message: MessageUpdate) => boolean | undefined;
+}
+export default Filters;

package/lib/core/filters.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Filters {
+    static findKey(message, key) {
+        if (!message || typeof message !== "object") {
+            return undefined;
+        }
+        const messageKeys = Object.keys(message);
+        if (messageKeys.includes(key)) {
+            return message[key];
+        }
+        for (const messageKey of messageKeys) {
+            const value = message[messageKey];
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    if (typeof item === "object") {
+                        const found = Filters.findKey(item, key);
+                        if (found !== undefined)
+                            return found;
+                    }
+                }
+            }
+            if (typeof value === "object") {
+                const found = Filters.findKey(value, key);
+                if (found !== undefined)
+                    return found;
+            }
+        }
+        return undefined;
+    }
+    static guidType(message, startWith) {
+        const result = Filters.findKey(message, "object_guid");
+        return result?.startsWith(startWith) ?? false;
+    }
+    static isMention(message) {
+        return !!Filters.findKey(message.message?.metadata?.meta_data_parts, "link");
+    }
+    static isMarkdown(message) {
+        return !!Filters.findKey(message.message, "metadata");
+    }
+    static isReply(message) {
+        return !!Filters.findKey(message, "reply_to_message_id");
+    }
+    static isEdited(message) {
+        return !!Filters.findKey(message, "is_edited");
+    }
+    static isLink(message) {
+        const link = Filters.findKey(message, "text");
+        if (!link)
+            return false;
+        const RUBIKA_LINK_PATTERN = /\brubika\.ir\b/;
+        const USERNAME_PATTERN = /@([a-zA-Z0-9_]{3,32})/;
+        return (link.includes("http") ||
+            RUBIKA_LINK_PATTERN.test(link) ||
+            USERNAME_PATTERN.test(link));
+    }
+    static isText(message) {
+        return !!Filters.findKey(message, "text");
+    }
+    static isGroup(message) {
+        return Filters.guidType(message, "g0");
+    }
+    static isChannel(message) {
+        return Filters.guidType(message, "c0");
+    }
+    static isPrivate(message) {
+        return Filters.guidType(message, "u0");
+    }
+    static isForward(message) {
+        return !!Filters.findKey(message, "forwarded_from");
+    }
+    static fileInline(message) {
+        return message.message?.file_inline;
+    }
+    static isFileInline(message) {
+        return ["FileInline", "FileInlineCaption"].includes(message.message?.type);
+    }
+    static isFile(message) {
+        return Filters.fileInline(message)?.type === "File";
+    }
+    static isPhoto(message) {
+        return Filters.fileInline(message)?.type === "Image";
+    }
+    static isSticker(message) {
+        return Filters.fileInline(message)?.type === "Sticker";
+    }
+    static isVideo(message) {
+        return Filters.fileInline(message)?.type === "Video";
+    }
+    static isVoice(message) {
+        return Filters.fileInline(message)?.type === "Voice";
+    }
+    static isGif(message) {
+        return Filters.fileInline(message)?.type === "Gif";
+    }
+    static isMusic(message) {
+        return Filters.fileInline(message)?.type === "Music";
+    }
+    static isLocation(message) {
+        return !!Filters.findKey(message.message, "location");
+    }
+    static isContact(message) {
+        return !!Filters.findKey(message.message, "contact_message");
+    }
+    static isPoll(message) {
+        return !!Filters.findKey(message, "poll");
+    }
+    static isLive(message) {
+        return !!Filters.findKey(message, "live_data");
+    }
+    static isEvent(message) {
+        return !!Filters.findKey(message, "event_data");
+    }
+    static isLength(length, object_guid) {
+        return (message) => {
+            if (object_guid) {
+                if (object_guid !== message.object_guid)
+                    return false;
+            }
+            if (message?.message?.text) {
+                return message?.message?.text.length === length;
+            }
+            return false;
+        };
+    }
+    static startsWithCommand(text, object_guid, length) {
+        return (message) => {
+            if (object_guid) {
+                if (object_guid !== message.object_guid)
+                    return false;
+            }
+            if (message?.message?.text) {
+                if (length) {
+                    if (message?.message?.text.length !== length)
+                        return false;
+                }
+                return message.message.text.startsWith(text);
+            }
+        };
+    }
+    static equalCommand(text, object_guid) {
+        return (message) => {
+            if (object_guid) {
+                if (object_guid !== message.object_guid)
+                    return false;
+            }
+            if (message?.message?.text) {
+                return message.message.text === text;
+            }
+        };
+    }
+}
+exports.default = Filters;

package/lib/core/methods/advanced/builder.d.ts

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

package/lib/core/methods/advanced/builder.js

@@ -0,0 +1,30 @@
+"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("../../crypto"));
+async function builder(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 = await 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/lib/core/methods/auth/logout.d.ts

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

package/lib/core/methods/auth/logout.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function logout() {
+    return await this.builder("logout", {});
+}
+exports.default = logout;

package/lib/core/methods/auth/registerDevice.d.ts

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

package/lib/core/methods/auth/registerDevice.js

@@ -0,0 +1,47 @@
+"use strict";
+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",
+};
+async function getBrowser(userAgent, langCode, appVersion) {
+    const deviceModelMatch = userAgent
+        .toLowerCase()
+        .match(/(opera|chrome|safari|firefox|msie|trident)\/(\d+)/);
+    let deviceModel = "Unknown";
+    if (!deviceModelMatch) {
+        throw new Error(`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" + (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,
+    };
+}
+async function registerDevice() {
+    const result = await this.builder("registerDevice", await getBrowser(this.network.userAgent, this.network.defaultPlatform.lang_code, this.network.defaultPlatform.app_version));
+    return result;
+}
+exports.default = registerDevice;

package/lib/core/methods/auth/sendCode.d.ts

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

package/lib/core/methods/auth/sendCode.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function sendCode(phone_number, pass_key, send_type = "SMS") {
+    if (!["SMS", "Internal"].includes(send_type)) {
+        console.warn("`send_type` should be `SMS` or `Internal`. Using default `SMS`.");
+        send_type = "SMS";
+    }
+    const data = {
+        phone_number,
+        pass_key,
+        send_type,
+    };
+    const result = await this.builder("sendCode", data, true);
+    return result;
+}
+exports.default = sendCode;

package/lib/core/methods/auth/signIn.d.ts

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

package/lib/core/methods/auth/signIn.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function signIn(phone_code, phone_number, phone_code_hash, public_key) {
+    const data = {
+        phone_code,
+        phone_number,
+        phone_code_hash,
+        public_key,
+    };
+    const result = await this.builder("signIn", data, true);
+    return result;
+}
+exports.default = signIn;

package/lib/core/methods/channels/addChannel.d.ts

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

package/lib/core/methods/channels/addChannel.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function addChannel(title, description, member_guids) {
+    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 await this.builder("addChannel", input);
+}
+exports.default = addChannel;

package/lib/core/methods/channels/addChannelMembers.d.ts

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

package/lib/core/methods/channels/addChannelMembers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function addChannelMembers(channel_guid, member_guids) {
+    if (typeof member_guids === "string")
+        member_guids = [member_guids];
+    return await this.builder("addChannelMembers", {
+        channel_guid,
+        member_guids,
+    });
+}
+exports.default = addChannelMembers;

package/lib/core/methods/channels/banChannelMember.d.ts

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

package/lib/core/methods/channels/banChannelMember.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function banChannelMember(channel_guid, member_guid, action = "Set") {
+    if (!["Set", "Unset"].includes(action)) {
+        console.warn(`${action} argument can only be in ["Set", "Unset"]. Using default "Set".`);
+        action = "Set";
+    }
+    return await this.builder("banChannelMember", {
+        channel_guid,
+        member_guid,
+        action,
+    });
+}
+exports.default = banChannelMember;

package/lib/core/methods/channels/cancelChangeObjectOwner.d.ts

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

package/lib/core/methods/channels/cancelChangeObjectOwner.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function cancelChangeObjectOwner(object_guid) {
+    return await this.builder("cancelChangeObjectOwner", { object_guid });
+}
+exports.default = cancelChangeObjectOwner;

package/lib/core/methods/channels/channelPreviewByJoinLink.d.ts

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

package/lib/core/methods/channels/channelPreviewByJoinLink.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function channelPreviewByJoinLink(link) {
+    if (link.includes("/"))
+        link = link.split("/")[-1];
+    return await this.builder("channelPreviewByJoinLink", { hash_link: link });
+}
+exports.default = channelPreviewByJoinLink;

package/lib/core/methods/channels/checkChannelUsername.d.ts

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

package/lib/core/methods/channels/checkChannelUsername.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function checkChannelUsername(username) {
+    return await this.builder("checkChannelUsername", {
+        username: username.replace("@", ""),
+    });
+}
+exports.default = checkChannelUsername;

package/lib/core/methods/channels/createChannelVoiceChat.d.ts

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

package/lib/core/methods/channels/createChannelVoiceChat.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function createChannelVoiceChat(channel_guid) {
+    return await this.builder("createChannelVoiceChat", { channel_guid });
+}
+exports.default = createChannelVoiceChat;

package/lib/core/methods/channels/discardChannelVoiceChat.d.ts

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

package/lib/core/methods/channels/discardChannelVoiceChat.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function discardChannelVoiceChat(channel_guid, voice_chat_id) {
+    return await this.builder("discardChannelVoiceChat", {
+        channel_guid,
+        voice_chat_id,
+    });
+}
+exports.default = discardChannelVoiceChat;

package/lib/core/methods/channels/editChannelInfo.d.ts

@@ -0,0 +1,4 @@
+import Client from "../../client";
+type ChatHistory = "Hidden" | "Visible";
+declare function editChannelInfo(this: Client, channel_guid: string, title?: string, description?: string, channel_type?: string, sign_messages?: boolean, is_restricted_content?: boolean, chat_reaction_setting?: {}, chat_history_for_new_members?: ChatHistory): Promise<any>;
+export default editChannelInfo;

package/lib/core/methods/channels/editChannelInfo.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function editChannelInfo(channel_guid, title, description, channel_type, sign_messages, is_restricted_content, chat_reaction_setting, chat_history_for_new_members) {
+    let input = { channel_guid, updated_parameters: [] };
+    if (title) {
+        input.title = title;
+        input.updated_parameters.push("title");
+    }
+    if (description !== undefined) {
+        input.description = description;
+        input.updated_parameters.push("description");
+    }
+    if (channel_type !== undefined) {
+        input.channel_type = channel_type;
+        input.updated_parameters.push("channel_type");
+    }
+    if (sign_messages !== undefined) {
+        input.sign_messages = sign_messages;
+        input.updated_parameters.push("sign_messages");
+    }
+    if (chat_reaction_setting !== undefined) {
+        input.chat_reaction_setting = chat_reaction_setting;
+        input.updated_parameters.push("chat_reaction_setting");
+    }
+    if (is_restricted_content !== undefined) {
+        input.is_restricted_content = is_restricted_content;
+        input.updated_parameters.push("is_restricted_content");
+    }
+    if (chat_history_for_new_members) {
+        if (!["Hidden", "Visible"].includes(chat_history_for_new_members)) {
+            console.warn('`chat_history_for_new_members` should be in `["Hidden", "Visible"]`. Using default "Hidden".');
+            chat_history_for_new_members = "Hidden";
+        }
+        input.chat_history_for_new_members = chat_history_for_new_members;
+        input.updated_parameters.push("chat_history_for_new_members");
+    }
+    return await this.builder("editChannelInfo", input);
+}
+exports.default = editChannelInfo;

package/lib/core/methods/channels/getBannedChannelMembers.d.ts

@@ -0,0 +1,3 @@
+import Client from "../../client";
+declare function getBannedChannelMembers(this: Client, channel_guid: string, start_id?: string): Promise<any>;
+export default getBannedChannelMembers;

package/lib/core/methods/channels/getBannedChannelMembers.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function getBannedChannelMembers(channel_guid, start_id) {
+    return await this.builder("getBannedChannelMembers", {
+        channel_guid,
+        start_id,
+    });
+}
+exports.default = getBannedChannelMembers;

package/lib/core/methods/channels/getChannelAdminAccessList.d.ts

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

package/lib/core/methods/channels/getChannelAdminAccessList.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function getChannelAdminAccessList(channel_guid, member_guid) {
+    return await this.builder("getChannelAdminAccessList", {
+        channel_guid,
+        member_guid,
+    });
+}
+exports.default = getChannelAdminAccessList;

package/lib/core/methods/channels/getChannelAdminMembers.d.ts

@@ -0,0 +1,3 @@
+import Client from "../../client";
+declare function getChannelAdminMembers(this: Client, channel_guid: string, start_id?: string): Promise<any>;
+export default getChannelAdminMembers;

package/lib/core/methods/channels/getChannelAdminMembers.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function getChannelAdminMembers(channel_guid, start_id) {
+    return await this.builder("getChannelAdminMembers", {
+        channel_guid,
+        start_id,
+    });
+}
+exports.default = getChannelAdminMembers;