cloudstorm 0.1.4 → 0.4.0

package/dist/Shard.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import DiscordConnector from "./connector/DiscordConnector";
+interface ShardEvents {
+    disconnect: [number, string, boolean];
+    error: [string];
+    ready: [boolean];
+    queueIdentify: [number];
+}
+interface Shard {
+    addListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    emit<E extends keyof ShardEvents>(event: E, ...args: ShardEvents[E]): boolean;
+    eventNames(): Array<keyof ShardEvents>;
+    listenerCount(event: keyof ShardEvents): number;
+    listeners(event: keyof ShardEvents): Array<(...args: Array<any>) => any>;
+    off<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    on<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    once<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    prependListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    prependOnceListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    rawListeners(event: keyof ShardEvents): Array<(...args: Array<any>) => any>;
+    removeAllListeners(event?: keyof ShardEvents): this;
+    removeListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+}
+/**
+ * Shard class, which provides a wrapper around the DiscordConnector with metadata like the id of the shard.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+declare class Shard extends EventEmitter {
+    id: number;
+    client: import("./Client");
+    ready: boolean;
+    connector: DiscordConnector;
+    static readonly default: typeof Shard;
+    /**
+     * Create a new Shard.
+     * @param id id of the shard.
+     * @param client Main class used for forwarding events.
+     */
+    constructor(id: number, client: import("./Client"));
+    /**
+     * Time in ms it took for Discord to ackknowledge an OP 1 HEARTBEAT.
+     */
+    get latency(): number;
+    /**
+     * Create a new connection to Discord.
+     */
+    connect(): void;
+    /**
+     * Close the current connection to Discord.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send an OP 3 PRESENCE_UPDATE to Discord.
+     * @param data Data to send.
+     */
+    presenceUpdate(data: import("discord-typings").GatewayPresenceUpdate): Promise<void>;
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE to Discord.
+     * @param data Data to send
+     */
+    voiceStateUpdate(data: import("discord-typings").VoiceStateUpdatePayload & {
+        self_deaf?: boolean;
+        self_mute?: boolean;
+    }): Promise<void>;
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS to Discord.
+     * @param data Data to send.
+     */
+    requestGuildMembers(data: import("discord-typings").GuildRequestMembersPayload & {
+        limit?: number;
+    }): Promise<void>;
+}
+export = Shard;

package/dist/Shard.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const events_1 = require("events");
+const DiscordConnector_1 = __importDefault(require("./connector/DiscordConnector"));
+const Constants_1 = require("./Constants");
+/**
+ * Shard class, which provides a wrapper around the DiscordConnector with metadata like the id of the shard.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+class Shard extends events_1.EventEmitter {
+    /**
+     * Create a new Shard.
+     * @param id id of the shard.
+     * @param client Main class used for forwarding events.
+     */
+    constructor(id, client) {
+        super();
+        this.id = id;
+        this.client = client;
+        this.ready = false;
+        this.connector = new DiscordConnector_1.default(id, client);
+        this.connector.on("event", (event) => {
+            const newEvent = Object.assign(event, { shard_id: this.id });
+            this.client.emit("event", newEvent);
+            switch (event.op) {
+                case Constants_1.GATEWAY_OP_CODES.DISPATCH:
+                    this.client.emit("dispatch", newEvent);
+                    break;
+                case Constants_1.GATEWAY_OP_CODES.VOICE_STATE_UPDATE:
+                    this.client.emit("voiceStateUpdate", newEvent);
+                    break;
+                default:
+                    break;
+            }
+        });
+        this.connector.on("disconnect", (...args) => {
+            this.ready = false;
+            this.emit("disconnect", ...args);
+        });
+        this.connector.on("error", (err) => {
+            this.emit("error", err);
+        });
+        this.connector.on("ready", (resume) => {
+            this.emit("ready", resume);
+        });
+        this.connector.on("queueIdentify", () => {
+            this.emit("queueIdentify", this.id);
+        });
+    }
+    /**
+     * Time in ms it took for Discord to ackknowledge an OP 1 HEARTBEAT.
+     */
+    get latency() {
+        return this.connector.latency;
+    }
+    /**
+     * Create a new connection to Discord.
+     */
+    connect() {
+        this.connector.connect();
+    }
+    /**
+     * Close the current connection to Discord.
+     */
+    disconnect() {
+        return this.connector.disconnect();
+    }
+    /**
+     * Send an OP 3 PRESENCE_UPDATE to Discord.
+     * @param data Data to send.
+     */
+    presenceUpdate(data) {
+        return this.connector.presenceUpdate(data);
+    }
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE to Discord.
+     * @param data Data to send
+     */
+    voiceStateUpdate(data) {
+        return this.connector.voiceStateUpdate(data);
+    }
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS to Discord.
+     * @param data Data to send.
+     */
+    requestGuildMembers(data) {
+        return this.connector.requestGuildMembers(data);
+    }
+}
+Shard.default = Shard;
+module.exports = Shard;

package/dist/ShardManager.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+import Shard from "./Shard";
+/**
+ * Class used for managing shards for the user.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+declare class ShardManager {
+    client: import("./Client");
+    options: import("./Client")["options"];
+    shards: {
+        [id: number]: Shard;
+    };
+    connectQueue: Array<{
+        action: string;
+        shard: Shard;
+    }>;
+    lastConnectionAttempt: number | null;
+    connectQueueInterval: NodeJS.Timeout;
+    static readonly default: typeof ShardManager;
+    /**
+     * Create a new ShardManager.
+     */
+    constructor(client: import("./Client"));
+    /**
+     * Create shard instances and add them to the connection queue.
+     */
+    spawn(): void;
+    /**
+     * Disconnect all shards facilitated by this manager.
+     */
+    disconnect(): void;
+    /**
+     * Actually connect/re-identify a single shard spawned by this manager by calling it's connect() or identify() method and reset the connection timer.
+     * @param data Object with a shard and action key.
+     */
+    private _connectShard;
+    /**
+     * Check if there are shards that have been spawned by this manager that are not connected yet and connect them if over 6 seconds have passed since the last attempt.
+     */
+    private _checkQueue;
+    /**
+     * Add event listeners to a shard to that the manager can act on received events.
+     * @param shard Shard to add the event listeners to.
+     */
+    private _addListener;
+    /**
+     * Checks if all shards spawned by this manager are ready.
+     */
+    private _checkReady;
+    /**
+     * Checks if all shards spawned by this manager are disconnected.
+     */
+    private _checkDisconnect;
+    /**
+     * Update the status of all currently connected shards which have been spawned by this manager.
+     * @param data Data to send.
+     */
+    presenceUpdate(data: import("discord-typings").GatewayPresenceUpdate): Promise<void>;
+    /**
+     * Update the status of a single connected shard which has been spawned by this manager.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    shardPresenceUpdate(shardId: number, data: import("discord-typings").GatewayPresenceUpdate): Promise<void>;
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE with a certain shard.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    voiceStateUpdate(shardId: number, data: import("discord-typings").VoiceStateUpdatePayload & {
+        self_deaf?: boolean;
+        self_mute?: boolean;
+    }): Promise<void>;
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS with a certain shard.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    requestGuildMembers(shardId: number, data: import("discord-typings").GuildRequestMembersPayload & {
+        limit?: number;
+    }): Promise<void>;
+}
+export = ShardManager;

package/dist/ShardManager.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const Shard_1 = __importDefault(require("./Shard"));
+/**
+ * Class used for managing shards for the user.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+class ShardManager {
+    /**
+     * Create a new ShardManager.
+     */
+    constructor(client) {
+        this.client = client;
+        this.options = client.options;
+        if (!this.options.connectQueueInterval) {
+            this.options.connectQueueInterval = 1000 * 5;
+        }
+        this.shards = {};
+        this.connectQueue = [];
+        this.lastConnectionAttempt = null;
+        this.connectQueueInterval = setInterval(() => {
+            this._checkQueue();
+        }, this.options.connectQueueInterval);
+    }
+    /**
+     * Create shard instances and add them to the connection queue.
+     */
+    spawn() {
+        const firstShardID = this.options.firstShardId ? this.options.firstShardId : 0;
+        const lastShardId = this.options.lastShardId ? this.options.lastShardId : 0;
+        for (let i = firstShardID; i < lastShardId + 1; i++) {
+            this.client.emit("debug", `Spawned shard ${i}`);
+            this.shards[i] = new Shard_1.default(i, this.client);
+            this.connectQueue.push({ action: "connect", shard: this.shards[i] });
+            this._addListener(this.shards[i]);
+        }
+    }
+    /**
+     * Disconnect all shards facilitated by this manager.
+     */
+    disconnect() {
+        for (const shardKey in this.shards) {
+            if (this.shards[shardKey]) {
+                const shard = this.shards[shardKey];
+                shard.disconnect();
+            }
+        }
+    }
+    /**
+     * Actually connect/re-identify a single shard spawned by this manager by calling it's connect() or identify() method and reset the connection timer.
+     * @param data Object with a shard and action key.
+     */
+    _connectShard(data) {
+        const { action, shard } = data;
+        this.client.emit("debug", `${action === "connect" ? "Connecting" : "Identifying"} Shard ${shard.id} Status: ${shard.connector.status} Ready: ${shard.ready}`);
+        if ((this.lastConnectionAttempt || 0) <= Date.now() - 6000) {
+            if (action === "identify") {
+                this.lastConnectionAttempt = Date.now();
+                shard.connector.identify(true);
+            }
+            else {
+                if (shard.connector.status !== "connecting" && !shard.ready) {
+                    this.lastConnectionAttempt = Date.now();
+                    shard.connect();
+                }
+            }
+        }
+    }
+    /**
+     * Check if there are shards that have been spawned by this manager that are not connected yet and connect them if over 6 seconds have passed since the last attempt.
+     */
+    _checkQueue() {
+        // this.client.emit("debug", `Checking queue Length: ${this.connectQueue.length} LastAttempt: ${this.lastConnectionAttempt} Current Time: ${Date.now()}`);
+        if (this.connectQueue.length > 0 && ((this.lastConnectionAttempt || 0) <= Date.now() - 6000)) {
+            const toConnect = this.connectQueue.splice(0, 1);
+            for (const shard of toConnect) {
+                this._connectShard(shard);
+            }
+        }
+    }
+    /**
+     * Add event listeners to a shard to that the manager can act on received events.
+     * @param shard Shard to add the event listeners to.
+     */
+    _addListener(shard) {
+        shard.on("ready", (resume) => {
+            this.shards[shard.id].ready = true;
+            this.client.emit("debug", `Shard ${shard.id} ${resume ? "has resumed" : "is ready"}`);
+            this.client.emit("shardReady", { id: shard.id, ready: !resume });
+            this._checkReady();
+        });
+        shard.on("error", (error) => {
+            this.client.emit("error", error);
+        });
+        shard.on("disconnect", (code, reason, gracefulClose) => {
+            this.client.emit("debug", `Websocket of shard ${shard.id} closed with code ${code} and reason: ${reason ? reason : "None"}`);
+            if (code === 1000 && gracefulClose) {
+                this._checkDisconnect();
+                return;
+            }
+            this.connectQueue.push({ action: "connect", shard });
+        });
+        shard.on("queueIdentify", (shardId) => {
+            if (!this.shards[shardId]) {
+                this.client.emit("debug", `Received a queueIdentify event for not existing shard ${shardId}`);
+                return;
+            }
+            this.connectQueue.unshift({ action: "identify", shard: this.shards[shardId] });
+        });
+    }
+    /**
+     * Checks if all shards spawned by this manager are ready.
+     */
+    _checkReady() {
+        for (const shardId in this.shards) {
+            if (this.shards[shardId]) {
+                if (!this.shards[shardId].ready) {
+                    return;
+                }
+            }
+        }
+        this.client.emit("ready");
+    }
+    /**
+     * Checks if all shards spawned by this manager are disconnected.
+     */
+    _checkDisconnect() {
+        for (const shardId in this.shards) {
+            if (this.shards[shardId]) {
+                if (this.shards[shardId].connector.status !== "disconnected") {
+                    return;
+                }
+            }
+        }
+        this.client.emit("disconnected");
+    }
+    /**
+     * Update the status of all currently connected shards which have been spawned by this manager.
+     * @param data Data to send.
+     */
+    async presenceUpdate(data) {
+        for (const shardKey in this.shards) {
+            if (this.shards[shardKey]) {
+                const shard = this.shards[shardKey];
+                this.shardPresenceUpdate(shard.id, data);
+            }
+        }
+    }
+    /**
+     * Update the status of a single connected shard which has been spawned by this manager.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    shardPresenceUpdate(shardId, data) {
+        return new Promise((res, rej) => {
+            const shard = this.shards[shardId];
+            if (!shard) {
+                rej(new Error(`Shard ${shardId} does not exist`));
+            }
+            if (!shard.ready) {
+                shard.once("ready", () => {
+                    shard.presenceUpdate(data).then(result => res(result)).catch(e => rej(e));
+                });
+            }
+            shard.presenceUpdate(data).then(result => res(result)).catch(e => rej(e));
+        });
+    }
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE with a certain shard.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    voiceStateUpdate(shardId, data) {
+        return new Promise((res, rej) => {
+            const shard = this.shards[shardId];
+            if (!shard) {
+                rej(new Error(`Shard ${shardId} does not exist`));
+            }
+            if (!shard.ready) {
+                shard.once("ready", () => {
+                    shard.voiceStateUpdate(data).then(result => res(result)).catch(e => rej(e));
+                });
+            }
+            shard.voiceStateUpdate(data).then(result => res(result)).catch(e => rej(e));
+        });
+    }
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS with a certain shard.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    requestGuildMembers(shardId, data) {
+        return new Promise((res, rej) => {
+            const shard = this.shards[shardId];
+            if (!shard) {
+                rej(new Error(`Shard ${shardId} does not exist`));
+            }
+            if (!shard.ready) {
+                shard.once("ready", () => {
+                    shard.requestGuildMembers(data).then(result => res(result)).catch(e => rej(e));
+                });
+            }
+            shard.requestGuildMembers(data).then(result => res(result)).catch(e => rej(e));
+        });
+    }
+}
+ShardManager.default = ShardManager;
+module.exports = ShardManager;

package/dist/Types.d.ts

@@ -0,0 +1,70 @@
+import Constants from "./Constants";
+export interface IntentFlags {
+    GUILDS: number;
+    GUILD_MEMBERS: number;
+    GUILD_BANS: number;
+    GUILD_EMOJIS_AND_STICKERS: number;
+    GUILD_INTEGRATIONS: number;
+    GUILD_WEBHOOKS: number;
+    GUILD_INVITES: number;
+    GUILD_VOICE_STATES: number;
+    GUILD_PRESENCES: number;
+    GUILD_MESSAGES: number;
+    GUILD_MESSAGE_REACTIONS: number;
+    GUILD_MESSAGE_TYPING: number;
+    DIRECT_MESSAGES: number;
+    DIRECT_MESSAGE_REACTIONS: number;
+    DIRECT_MESSAGE_TYPING: number;
+}
+export declare type IntentResolvable = number | Array<number> | keyof IntentFlags | Array<keyof IntentFlags>;
+export interface IWSMessage {
+    op: typeof Constants["GATEWAY_OP_CODES"][keyof typeof Constants.GATEWAY_OP_CODES];
+    d?: any;
+    s?: number;
+    t?: string;
+}
+export interface IGatewayMessage extends IWSMessage {
+    shard_id: number;
+}
+export interface IPresenceActivity {
+    name: string;
+    type?: 0 | 1 | 2 | 3 | 5;
+    url?: string;
+}
+export interface IPresence {
+    status?: "online" | "idle" | "dnd" | "offline";
+    afk?: boolean;
+    since?: boolean;
+    activities?: Array<IPresenceActivity> | null;
+}
+export interface IClientOptions {
+    largeGuildThreshold?: number;
+    firstShardId?: number;
+    lastShardId?: number;
+    shardAmount?: number;
+    reconnect?: boolean;
+    initialPresence?: IPresence;
+    intents?: IntentResolvable;
+    connectQueueInterval?: number;
+    snowtransferInstance?: import("snowtransfer").SnowTransfer;
+    ws?: IClientWSOptions;
+}
+export interface IVoiceStateUpdate {
+    guild_id: string;
+    channel_id?: string | null;
+    self_mute?: boolean;
+    self_deaf?: boolean;
+}
+export interface IRequestGuildMembers {
+    guild_id: string;
+    query?: string | null;
+    limit?: number;
+}
+export interface IShardReady {
+    id: number;
+    ready: boolean;
+}
+export interface IClientWSOptions {
+    compress?: boolean;
+    socket?: import("ws").ClientOptions;
+}

package/dist/Types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/connector/DiscordConnector.d.ts

@@ -0,0 +1,142 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import BetterWs from "../structures/BetterWs";
+interface ConnectorEvents {
+    queueIdentify: [number];
+    event: [import("../Types").IWSMessage];
+    ready: [boolean];
+    error: [string];
+    disconnect: [number, string, boolean];
+}
+interface DiscordConnector {
+    addListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    emit<E extends keyof ConnectorEvents>(event: E, ...args: ConnectorEvents[E]): boolean;
+    eventNames(): Array<keyof ConnectorEvents>;
+    listenerCount(event: keyof ConnectorEvents): number;
+    listeners(event: keyof ConnectorEvents): Array<(...args: Array<any>) => any>;
+    off<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    on<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    once<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    prependListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    prependOnceListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    rawListeners(event: keyof ConnectorEvents): Array<(...args: Array<any>) => any>;
+    removeAllListeners(event?: keyof ConnectorEvents): this;
+    removeListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+}
+/**
+ * Class used for acting based on received events.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+declare class DiscordConnector extends EventEmitter {
+    id: number;
+    client: import("../Client");
+    options: import("../Client")["options"];
+    reconnect: boolean;
+    betterWs: BetterWs | null;
+    heartbeatTimeout: NodeJS.Timeout | null;
+    heartbeatInterval: number;
+    _trace: string | null;
+    seq: number;
+    status: string;
+    sessionId: string | null;
+    lastACKAt: number;
+    lastHeartbeatSend: number;
+    latency: number;
+    static readonly default: typeof DiscordConnector;
+    /**
+     * Create a new Discord Connector.
+     * @param id id of the shard that created this class.
+     * @param client Main client instance.
+     */
+    constructor(id: number, client: import("../Client"));
+    /**
+     * Connect to Discord.
+     */
+    connect(): void;
+    /**
+     * Close the websocket connection and disconnect.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Called with a parsed Websocket message to execute further actions.
+     * @param message Message that was received.
+     */
+    private messageAction;
+    /**
+     * Reset this connector to be ready to resume or hard reconnect, then connect.
+     * @param resume Whether or not the client intends to send an OP 6 RESUME later.
+     */
+    private _reconnect;
+    /**
+     * Hard reset this connector.
+     */
+    private reset;
+    /**
+     * Clear the heart beat interval, set it to null and set the cached heartbeat_interval as 0.
+     */
+    private clearHeartBeat;
+    /**
+     * Send an OP 2 IDENTIFY to the gateway or an OP 6 RESUME if forceful identify is falsy.
+     * @param force Whether CloudStorm should send an OP 2 IDENTIFY even if there's a session that could be resumed.
+     */
+    identify(force?: boolean): Promise<void>;
+    /**
+     * Send an OP 6 RESUME to the gateway.
+     */
+    private resume;
+    /**
+     * Send an OP 1 HEARTBEAT to the gateway.
+     */
+    private heartbeat;
+    /**
+     * Handle dispatch events.
+     * @param message Message received from the websocket.
+     */
+    private handleDispatch;
+    /**
+     * Handle a close from the underlying websocket.
+     * @param code Websocket close code.
+     * @param reason Close reason if any.
+     */
+    private handleWsClose;
+    /**
+     * Send an OP 3 PRESENCE_UPDATE to the gateway.
+     * @param data Presence data to send.
+     */
+    presenceUpdate(data: import("discord-typings").GatewayPresenceUpdate): Promise<void>;
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE to the gateway.
+     * @param data Voice state update data to send.
+     */
+    voiceStateUpdate(data: import("discord-typings").VoiceStateUpdatePayload & {
+        self_deaf?: boolean;
+        self_mute?: boolean;
+    }): Promise<void>;
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS to the gateway.
+     * @param data Data to send.
+     */
+    requestGuildMembers(data: import("discord-typings").GuildRequestMembersPayload & {
+        limit?: number;
+    }): Promise<void>;
+    /**
+     * Checks presence data and fills in missing elements.
+     * @param data Data to send.
+     * @returns Data after it's fixed/checked.
+     */
+    private _checkPresenceData;
+    /**
+     * Checks voice state update data and fills in missing elements.
+     * @param data Data to send.
+     * @returns Data after it's fixed/checked.
+     */
+    private _checkVoiceStateUpdateData;
+    /**
+     * Checks request guild members data and fills in missing elements.
+     * @param data Data to send.
+     * @returns Data after it's fixed/checked.
+     */
+    private _checkRequestGuildMembersData;
+}
+export = DiscordConnector;