cloudstorm 0.1.4 → 0.4.0

package/index.d.ts

@@ -1,220 +0,0 @@
-declare module "Cloudstorm" {
-    import { EventEmitter } from "events";
-    import * as WebSocket from "ws";
-    import { IClientOptions as IWSOptions } from "ws";
-
-    export interface IWSMessage {
-        op: number;
-        d?: { [key: string]: any };
-        s?: number;
-    }
-
-    export interface IPresenceGame {
-        name: string;
-        type?: number;
-        url?: string;
-    }
-
-    export interface IPresence {
-        status?: string;
-        afk?: boolean;
-        since?: boolean;
-        game?: IPresenceGame;
-    }
-
-    export interface IClientOptions {
-        largeGuildThreshold?: number;
-        firstShardId?: number;
-        lastShardId?: number;
-        shardAmount?: number;
-        reconnect?: boolean;
-        initialPresence?: IPresence;
-    }
-
-    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 GATEWAY_OP_CODES {
-        DISPATCH: number;
-        HEARTBEAT: number;
-        IDENTIFY: number;
-        STATUS_UPDATE: number;
-        VOICE_STATE_UPDATE: number;
-        VOICE_SERVER_PING: number;
-        RESUME: number;
-        RECONNECT: number;
-        REQUEST_GUILD_MEMBERS: number;
-        INVALID_SESSION: number;
-        HELLO: number
-        HEARTBEAT_ACK: number;
-    }
-
-    export const GATEWAY_VERSION: number;
-
-    export class RatelimitBucket {
-        private fnQueue: Function[];
-        private limit: number;
-        private remaining: number;
-        private limitReset: number;
-        private resetTimeout: NodeJS.Timer | null;
-        private constructor(limit?: number, limitReset?: number);
-        protected queue<T extends Function>(fn: T): Promise<void>;
-        protected checkQueue(): void;
-        protected resetRemaining(): void;
-        protected dropQueue(): void;
-    }
-
-    export class BetterWs extends EventEmitter {
-        private ws: WebSocket;
-        private wsBucket: RatelimitBucket;
-        private statusBucket: RatelimitBucket;
-        private zlibInflate: any; // TODO: set type
-        private constructor(address: string, protocols: string[], options: IWSOptions);
-        protected get rawWs(): WebSocket;
-        protected bindWs(ws: WebSocket): void;
-        protected recreateWs(address: string, options?: IWSOptions): void;
-        protected onOpen(): void;
-        protected onMessage(message: string | Buffer | { [key: string]: any }): void;
-        protected onClose(code: number, reason: string): void;
-        protected sendMessage(data: { [key: string]: any }): Promise<void>;
-        protected close(code?: number, reason?: string): Promise<void>;
-        private on(event: "error", cb: (data: Error | string) => void): this;
-        private on(event: "ws_open", cb: () => void): this;
-        private on(event: "ws_message", cb: (data: { [key: string]: any }) => void): this;
-        private on(event: "ws_close", cb: (code: number, reason: string) => void): this;
-        private once(event: "error", cb: (data: Error | string) => void): this;
-        private once(event: "ws_open", cb: () => void): this;
-        private once(event: "ws_message", cb: (data: { [key: string]: any }) => void): this;
-        private once(event: "ws_close", cb: (code: number, reason: String) => void): this;
-    }
-
-    export class DiscordConnector extends EventEmitter { // TODO: add events
-        public id: number;
-        public client: Client;
-        public options: IClientOptions;
-        public reconnect: boolean;
-        public betterWs: BetterWs | null;
-        public heartbeatInterval: number | null;
-        public seq: number;
-        public status: string;
-        public sessionId: number | null;
-        public forceIdentify: boolean;
-        private constructor(id: number, client: Client);
-        protected connect(): void;
-        protected disconnect(): Promise<void>;
-        protected messageAction(message: IWSMessage): void;
-        protected reset(): void;
-        protected identify(force?: boolean): Promise<void>;
-        protected resume(): Promise<void>;
-        protected heartbeat(): void;
-        protected handleDispatch(message: IWSMessage): void;
-        protected handleWsClose(code: number, reason: string): void;
-        protected statusUpdate(data?: IPresence): void;
-        protected requestGuildMembers(data?: IRequestGuildMembers): Promise<void>;
-        private _checkPresenceData(data: IPresence): IPresence;
-        private _checkVoiceStateUpdateData(data: IVoiceStateUpdate): IVoiceStateUpdate;
-        private _checkRequestGuildMembersData(data: IRequestGuildMembers): IRequestGuildMembers;
-        private on(event: "queueIdentify", cb: (data: number) => void): this;
-        private once(event: "queueIdentify", cb: (data: number) => void): this;
-        private on(event: "event", cb: (data: IWSMessage) => void): this;
-        private once(event: "event", cb: (data: IWSMessage) => void): this;
-        private on(event: "ready", cb: (data: boolean) => void): this;
-        private once(event: "ready", cb: (data: boolean) => void): this;
-        private on(event: "error", cb: (data: Error | string) => void): this;
-        private once(event: "error", cb: (data: Error | string) => void): this;
-    }
-
-    export class Shard extends EventEmitter {
-        public client: Client;
-        public id: number;
-        public forceIdentify: boolean;
-        public ready: boolean;
-        public connector: DiscordConnector;
-        private constructor(id: number, client: Client);
-        private on(event: "disconnect", cb: () => void): this;
-        private on(event: "ready", cb: (data: boolean) => void): this;
-        private on(event: "error", cb: (data: Error) => void): this;
-        private on(event: "queueIdentify", cb: (data: number) => void): this;
-        private once(event: "disconnect", cb: () => void): this;
-        private once(event: "ready", cb: (data: boolean) => void): this;
-        private once(event: "error", cb: (data: Error) => void): this;
-        private once(event: "queueIdentify", cb: (data: number) => void): this;
-        protected connect(): void;
-        protected disconnect(): Promise<void>;
-        protected statusUpdate(data: IPresence): Promise<void>;
-        protected voiceStateUpdate(data: IVoiceStateUpdate): Promise<void>;
-        protected requestGuildMembers(data: IRequestGuildMembers): Promise<void>;
-    }
-
-    export class ShardManager {
-        public client: Client;
-        public options: IClientOptions;
-        public connectQueueInterval: NodeJS.Timer;
-        public shards: { [key: number]: Shard };
-        public connectQueue: Shard[];
-        public lastConnectAttempt: Date;
-        private constructor(client: Client);
-        private _connectShard(data: { action: string; shard: Shard }): void;
-        private _checkQueue(): void;
-        private _addListener(shard: Shard): void;
-        private _checkReady(): void;
-        private _checkDisconnect(): void;
-        protected spawn(): void;
-        protected disconnect(): void;
-        protected statusUpdate(data?: IPresence): void;
-        protected shardStatusUpdate(shardId: number, data?: IPresence): void;
-        protected voiceStateUpdate(shardId: number, data: IVoiceStateUpdate): Promise<void>;
-        protected requestGuildMembers(shardId: number, data: IRequestGuildMembers): Promise<void>:
-    }
-
-    export class Client extends EventEmitter { // TODO: add events
-        public token: string;
-        public httpToken: string;
-        public shardManager: ShardManager;
-        public options: IClientOptions;
-        public constructor(token: string, options?: IClientOptions);
-        public connect(): Promise<void>;
-        public getGateway(): Promise<string>;
-        public getGatewayBot(): Promise<IGatewayData>;
-        public disconnect(): void;
-        public statusUpdate(data: IPresence): void;
-        public shardStatusUpdate(shardId: number, data: IPresence): Promise<void>;
-        public voiceStateUpdate(shardId: number, data: IVoiceStateUpdate): Promise<void>;
-        public requestGuildMembers(shardId: number, data: IRequestGuildMembers): Promise<void>;
-        public on(event: "disconnected", cb: () => void): this;
-        public once(event: "disconnected", cb: () => void): this;
-        public on(event: "dispatch", cb: (data: { [key: string]: any }) => void): this;
-        public once(event: "dispatch", cb: (data: { [key: string]: any }) => void): this;
-        public on(event: "error", cb: (data: Error) => void): this;
-        public once(event: "error", cb: (data: Error) => void): this;
-        public on(event: "event", cb: (data: { [key: string]: any }) => void): this; // TODO: make interfaces for all events
-        public once(event: "event", cb: (data: { [key: string]: any }) => void): this; // TODO: ^
-        public on(event: "rawRecieve", cb: (data: { [key: string]: any }) => void): this;
-        public once(event: "rawRecieve", cb: (data: { [key: string]: any }) => void): this;
-        public on(event: "rawSend", cb: (data: { [key: string]: any }) => void): this;
-        public once(event: "rawSend", cb: (data: { [key: string]: any }) => void): this;
-        public on(event: "ready", cb: () => void): this;
-        public once(event: "ready", cb: () => void): this;
-        public on(event: "shardReady", cb: (data: IShardReady) => void): this;
-        public once(event: "shardReady", cb: (data: IShardReady) => void): this;
-        public on(event: "voiceStateUpdate", cb: (data: IVoiceStateUpdate) => void): this;
-        public once(event: "voiceStateUdpate", cb: (data: IVoiceStateUpdate) => void): this;
-        public on(event: "debug", cb: (data: string) => void): this;
-        public once(event: "debug", cb: (data: string) => void): this;
-    }
-}

package/index.js

@@ -1,10 +0,0 @@
-'use strict';
-let Client = require('./src/Client');
-
-function createClient(...args) {
-    return new Client(...args);
-}
-
-createClient.Client = Client;
-createClient.Constants = require('./src/Constants');
-module.exports = createClient;

package/src/Client.js

@@ -1,229 +0,0 @@
-'use strict';
-let version = require('../package.json').version;
-let EventEmitter;
-try {
-    EventEmitter = require('eventemitter3');
-} catch (e) {
-    EventEmitter = require('events').EventEmitter;
-}
-let Erlpack;
-try {
-    Erlpack = require('erlpack');
-// eslint-disable-next-line no-empty
-} catch (e) {
-
-}
-const Constants = require('./Constants');
-const SnowTransfer = require('snowtransfer');
-const ShardManager = require('./ShardManager');
-
-/**
- * Main class used for receiving events and interacting with the discord gateway
- * @extends {EventEmitter} EventEmitter
- */
-class Client extends EventEmitter {
-    /**
-     * Create a new Client to connect to the gateway
-     * @param {String} token - token received from creating a discord bot user, which will be used to connect to the gateway
-     * @param {Object} [options]
-     * @param {Number} [options.largeGuildThreshold=250] - Value between 50 and 250 at which the discord gateway stops sending offline guild members
-     * @param {Number} [options.firstShardId=0] - Id of the first shard that should be started
-     * @param {Number} [options.lastShardId=0] - Id of the last shard that should be started, not to be confused with shardAmount, lastShardId tells CloudStorm the range of shardId's to spawn,
-     * so you can use this parameter to run multi-process sharding where one CloudStorm instance running multiple shards runs in one process.
-     * Set it to shardAmount-1 if you are unsure about what it does.
-     * @param {Number} [options.shardAmount=1] - Amount of **total** shards connecting to discord
-     * @param {Boolean} [options.reconnect=true] - If the bot should automatically reconnect to discord if it get's disconnected, **leave it set to true unless you know what you are doing**
-     * @param {Presence} [options.initialPresence] - If you want to start the bot with an initial presence, you may set it here
-     * @property {ShardManager} shardManager - shard manager used for managing a pool of shards (connections) to the discord gateway, discord requires you to shard your bot at 2500 guilds,
-     * but you may do it earlier.
-     * @property {String} version - version of this package, exposed so you can use it easier.
-     * @constructor
-     * @returns {Client} a new CloudStorm instance
-     */
-    constructor(token, options = {}) {
-        super();
-        if (!token) {
-            throw new Error('Missing token!');
-        }
-        this.options = {
-            largeGuildThreshold: 250,
-            firstShardId: 0,
-            lastShardId: 0,
-            shardAmount: 1,
-            reconnect: true
-        };
-        this.token = token.startsWith('Bot ') ? token.substring(4) : token;
-        Object.assign(this.options, options);
-        this.options.token = token;
-        this.shardManager = new ShardManager(this);
-        this.version = version;
-        this._restClient = new SnowTransfer(token);
-    }
-
-    /**
-     * Create one or more connections (depending on the selected amount of shards) to the discord gateway
-     * @returns {Promise.<void>} This function returns a promise which is solely used for awaiting the getGateway() method's return value
-     */
-    async connect() {
-        let gatewayUrl = await this.getGateway();
-        this._updateEndpoint(gatewayUrl);
-        this.shardManager.spawn();
-    }
-
-    /**
-     * Get the gateway endpoint to connect to
-     * @returns {Promise.<String>} String url with the Gateway Endpoint to connect to
-     */
-    async getGateway() {
-        let gatewayData = await this._restClient.bot.getGateway();
-        return gatewayData.url;
-    }
-
-    /**
-     * Get the GatewayData including recommended amount of shards
-     * @returns {Promise.<GatewayData>} Object with url and shards to use to connect to discord
-     */
-    async getGatewayBot() {
-        return this._restClient.bot.getGatewayBot();
-    }
-
-    /**
-     * Disconnect the bot gracefully,
-     * you will receive a 'disconnected' Event once the bot successfully shutdown
-     */
-    disconnect() {
-        return this.shardManager.disconnect();
-    }
-
-    /**
-     * Send a status update to discord, which updates the status of all shards
-     * @param {Presence} data - Presence on a server, contains online status and game (if any)
-     * @param {String} [data.status=online] - Status of the bot, use one of the [status types](https://discordapp.com/developers/docs/topics/gateway#gateway-status-update-status-types)
-     * @param {Game} [data.game=null] - Game object which is used for showing games/streams
-     * @param {String} [data.game.name] - name of the game (required when data.game is not null)
-     * @param {Number} [data.game.type=0] - type of the game, see [game types](https://discordapp.com/developers/docs/topics/gateway#gateway-status-update-status-types)
-     * @param {String} [data.game.url] - url of the game, used when streaming in combination with data.game.type=1 to provide a link to the account of streamer, **only https://twitch.tv is supported atm**
-     * @returns {Promise.<void>} Promise that's resolved once all shards have sent the websocket payload
-     * @example
-     * //Connect bot to discord and set status to do not disturb and game to "Memes are Dreams"
-     * let bot = new CloudStorm(token)
-     * await bot.connect()
-     * bot.on('ready', () => {
-     *   // Bot is connected to discord and ready so we can update the status
-     *   bot.statusUpdate({status:'dnd', game:{name:'Memes are Dreams'}})
-     * });
-     */
-    statusUpdate(data) {
-        this.shardManager.statusUpdate(data);
-    }
-
-    /**
-     * Send a status update to discord, which updates the status of a single shard
-     * @param {Number} shardId Id of the shard that should update it's status
-     * @param {Presence} data - Presence on a server, contains online status and game (if any)
-     * @param {String} [data.status=online] - Status of the bot, use one of the [status types](https://discordapp.com/developers/docs/topics/gateway#gateway-status-update-status-types)
-     * @param {Game} [data.game=null] - Game object which is used for showing games/streams
-     * @param {String} [data.game.name] - name of the game (required when data.game is not null)
-     * @param {Number} [data.game.type=0] - type of the game, see [game types](https://discordapp.com/developers/docs/topics/gateway#gateway-status-update-status-types)
-     * @param {String} [data.game.url] - url of the game, used when streaming in combination with data.game.type=1 to provide a link to the account of streamer, **only https://twitch.tv is supported atm**
-     * @returns {Promise.<void>} Promise that's resolved once the shard has sent the websocket payload
-     * @example
-     * //Connect bot to discord and set status to do not disturb and game to "Im shard 0"
-     * let bot = new CloudStorm(token)
-     * await bot.connect()
-     * bot.on('ready', () => {
-     *   // Bot is connected to discord and ready so we can update the status of shard 0
-     *   bot.shardStatusUpdate(0, {status:'dnd', game:{name:'Im shard 0'}})
-     * });
-     */
-    shardStatusUpdate(shardId, data) {
-        return this.shardManager.shardStatusUpdate(shardId, data);
-    }
-
-    /**
-     * Send a voice state update to discord, this does **not** allow you to send audio with cloudstorm itself,
-     * it just provides the necessary data for another application to send audio data to discord
-     * @param {Number} shardId - id of the shard that should send the payload
-     * @param {VoiceStateUpdate} data - voice state update data to send
-     * @param {String} data.guild_id - id of the guild where the channel exists
-     * @param {String|null} data.channel_id - id of the channel to join or null if leaving channel
-     * @param {Boolean} data.self_mute - if the client is muted
-     * @param {Boolean} data.self_deaf - if the client is deafened
-     * @returns {Promise.<void>} - Promise that's resolved once the payload was sent to discord
-     * @example
-     * //Connect bot to discord and join a voice channel
-     * let bot = new CloudStorm(token)
-     * await bot.connect()
-     * bot.on('ready', () => {
-     *   // Bot is connected to discord and ready so we can join a voice channel
-     *   // We will use shard 0 as the shard to send the payload
-     *   bot.voiceStateUpdate(0, {guild_id:'id', channel_id:'id', self_mute:false, self_deaf:false})
-     * });
-     */
-    voiceStateUpdate(shardId, data) {
-        return this.shardManager.voiceStateUpdate(shardId, data);
-    }
-
-    /**
-     * Send a request guild members update to discord
-     * @param {Number} shardId - id of the shard that should send the payload
-     * @param {RequestGuildMembers} data - request payload to send, see below for details
-     * @param {String} data.guild_id - id of the guild
-     * @param {String} [data.query=null] - string that the username starts with or empty to match all members
-     * @param {Number} [data.limit=0] - limit of members that should be returned or 0 to return all
-     * @returns {Promise.<void>} - Promise that's resolved once the payload was send to discord
-     * @example
-     * //Connect bot to discord and set status to do not disturb and game to "Memes are Dreams"
-     * let bot = new CloudStorm(token)
-     * await bot.connect()
-     * bot.on('ready', () => {
-     *   // Bot is connected to discord and ready so we can send the request guild members payload
-     *   // We will use shard 0 as the shard to send the payload
-     *   bot.requestGuildMembers(0, {guild_id:'id'})
-     * });
-     */
-    requestGuildMembers(shardId, data) {
-        if (!data.guild_id) {
-            throw new Error('You need to pass a guild_id');
-        }
-        return this.shardManager.requestGuildMembers(shardId, data);
-    }
-
-    _updateEndpoint(gatewayUrl) {
-        this.options.endpoint = `${gatewayUrl}?v=${Constants.GATEWAY_VERSION}&encoding=${Erlpack ? 'etf' : 'json'}&compress=zlib-stream`;
-    }
-}
-
-/**
- * @typedef {Object} RequestGuildMembers
- * @property {String} guild_id - id of the guild
- * @property {String} query - string that the username starts with or empty to match all members
- * @property {Number} limit - limit of members that should be returned or 0 to return all
- * @private
- */
-
-/**
- * @typedef {Object} VoiceStateUpdate
- * @property {String} guild_id - id of the guild
- * @property {String|null} channel_id - id of the channel to join or null if leaving channel
- * @property {Boolean} self_mute - if the client is muted
- * @property {Boolean} self_deaf - if the client is deafened
- * @private
- */
-
-/**
- * @typedef {Object} Presence - Presence on a server, contains online status and game (if any)
- * @property {String} status - Status of the bot, use one of the [status types](https://discordapp.com/developers/docs/topics/gateway#gateway-status-update-status-types)
- * @property {Game} game - Game to set
- * @private
- */
-
-/**
- * @typedef {Object} Game - Game object which is used for showing games/streams
- * @property {String} name - name of the game
- * @property {Number} [type=0] - type of the game, see [game types](https://discordapp.com/developers/docs/topics/gateway#gateway-status-update-status-types)
- * @property {String} [url] - url of the game, used when streaming in combination with type 1 to provide a link to the account of streamer, **only https://twitch.tv is supported atm**
- * @private
- */
-
-module.exports = Client;

package/src/Constants.js

@@ -1,16 +0,0 @@
-'use strict';
-module.exports.GATEWAY_OP_CODES = {
-    DISPATCH: 0,
-    HEARTBEAT: 1,
-    IDENTIFY: 2,
-    STATUS_UPDATE: 3,
-    VOICE_STATE_UPDATE: 4,
-    VOICE_SERVER_PING: 5,
-    RESUME: 6,
-    RECONNECT: 7,
-    REQUEST_GUILD_MEMBERS: 8,
-    INVALID_SESSION: 9,
-    HELLO: 10,
-    HEARTBEAT_ACK: 11
-};
-module.exports.GATEWAY_VERSION = 6;

package/src/Shard.js

@@ -1,174 +0,0 @@
-'use strict';
-let EventEmitter;
-try {
-    EventEmitter = require('eventemitter3');
-} catch (e) {
-    EventEmitter = require('events').EventEmitter;
-}
-const DiscordConnector = require('./connector/DiscordConnector');
-const OP_CODES = require('./Constants').GATEWAY_OP_CODES;
-
-/**
- * @typedef Shard
- * @description 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
- * @property {Number} id - Id of the shard
- * @property {Client} client - main class used for forwarding events
- * @property {Boolean} forceIdentify - whether the connector should not try to resume and re-identify
- * @property {Boolean} ready - if this shard has successfully connected and identified with the gateway
- * @property {DiscordConnector} connector - connector used for connecting to discord
- */
-class Shard extends EventEmitter {
-    /**
-     * Create a new Shard
-     * @param {Number} id - Id of the shard
-     * @param {Client} client - main class used for forwarding events
-     * @private
-     */
-    constructor(id, client) {
-        super();
-        this.id = id;
-        this.client = client;
-        this.forceIdentify = false;
-        this.ready = false;
-        this.connector = new DiscordConnector(id, client);
-        this.connector.on('event', (event) => {
-            event.shard_id = this.id;
-            /**
-             * @event Client#event
-             * @type {Object}
-             * @description Emitted when an event is received from discord, this event is a raw discord event.
-             *
-             * Packets that are guaranteed to be emitted to you are OP 0 (DISPATCH) and OP 4 (VOICE STATE UPDATE)
-             *
-             * **Other OPs may be catched by the library and used for internal processing, so you should not count on them**
-             * @example
-             * //Connect bot to discord and listen for received events
-             * let bot = new CloudStorm(token)
-             * await bot.connect()
-             * bot.on('event', (event) => {
-             *   // Do something with the event
-             * });
-             */
-            this.client.emit('event', event);
-            switch (event.op) {
-                case OP_CODES.DISPATCH:
-                    /**
-                     * @event Client#dispatch
-                     * @type {Object}
-                     * @description Emitted when a OP **dispatch** event is received by the bot
-                     *
-                     * Dispatch events are usual events that happen on discord like message_create, presence_update, etc..
-                     */
-                    this.client.emit('dispatch', event);
-                    break;
-                case OP_CODES.VOICE_STATE_UPDATE:
-                    /**
-                     * @event Client#voiceStateUpdate
-                     * @type {Object}
-                     * @description Emitted when a OP **voice state update** event is received by the bot
-                     * @property {String} guild_id - id of the guild
-                     * @property {String|null} channel_id - id of the channel that was joined or null if the user is leaving the channel
-                     * @property {Boolean} self_mute - if the user is muted
-                     * @property {Boolean} self_deaf - if the user is deafened
-                     */
-                    this.client.emit('voiceStateUpdate', event);
-                    break;
-                default:
-                    break;
-            }
-        });
-        this.connector.on('disconnect', (...args) => {
-            this.ready = false;
-            /**
-             * @event Shard#disconnect
-             * @type {void}
-             * @description Emitted when the shard get's disconnected from the gateway
-             * @private
-             */
-            this.emit('disconnect', ...args);
-        });
-        this.connector.on('error', (err) => {
-            /**
-             * @event Shard#error
-             * @type {Error}
-             * @description Emitted when the shard (or internal components of it) error
-             * @private
-             */
-            this.emit('error', err);
-        });
-        this.connector.on('ready', (resume) => {
-            /**
-             * @event Shard#ready
-             * @type {Boolean}
-             * @description Emitted when the shard turns ready, has a boolean that can be used to check if the shard got a full ready or just a resume
-             * @private
-             */
-            this.emit('ready', resume);
-        });
-        this.connector.on('queueIdentify', () => {
-            /**
-             * @event Shard#queueIdentify
-             * @type {Number}
-             * @description Emitted when the underlying connector received an op9 code to tell the shard manager that the shard needs to be queued for re-identifying
-             * @private
-             */
-            this.emit('queueIdentify', this.id);
-        });
-    }
-
-    /**
-     * Create a new Connection to discord
-     * @protected
-     */
-    connect() {
-        if (this.forceIdentify) {
-            this.connector.forceIdentify = true;
-            this.forceIdentify = false;
-        }
-        this.connector.connect();
-    }
-
-    /**
-     * Close the current connection
-     * @returns {Promise.<void>}
-     * @protected
-     */
-    disconnect() {
-        return this.connector.disconnect();
-    }
-
-    /**
-     * Send a status update payload to discord
-     * @param {Presence} data - data to send
-     * @returns {Promise.<void>}
-     * @protected
-     */
-    statusUpdate(data) {
-        return this.connector.statusUpdate(data);
-    }
-
-    /**
-     * Send a voice state update payload to discord
-     * @param {VoiceStateUpdate} data - data to send
-     * @returns {Promise.<void>}
-     * @protected
-     */
-    voiceStateUpdate(data) {
-        return this.connector.voiceStateUpdate(data);
-    }
-
-    /**
-     * Send a request guild members payload to discord
-     * @param {RequestGuildMembers} data - data to send
-     * @returns {Promise.<void>}
-     * @protected
-     */
-    requestGuildMembers(data) {
-        return this.connector.requestGuildMembers(data);
-    }
-
-}
-
-module.exports = Shard;