diff --git a/.eslintrc.json b/.eslintrc.json
index 9b7c229b..f524f5f7 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -1,47 +1,65 @@
 {
-  "extends": "eslint:recommended",
+  "extends": ["eslint:recommended", "plugin:prettier/recommended"],
+  "plugins": ["import"],
   "parserOptions": {
-    "ecmaVersion": 2018
+    "ecmaVersion": 2019
   },
   "env": {
     "es6": true,
     "node": true
   },
-  "overrides": [
-    { "files": ["*.browser.js"], "env": { "browser": true } }
-  ],
+  "overrides": [{ "files": ["*.browser.js"], "env": { "browser": true } }],
   "rules": {
+    "import/order": [
+      "error",
+      {
+        "groups": ["builtin", "external", "internal", "index", "sibling", "parent"],
+        "alphabetize": {
+          "order": "asc"
+        }
+      }
+    ],
+    "prettier/prettier": [
+      2,
+      {
+        "printWidth": 120,
+        "singleQuote": true,
+        "quoteProps": "as-needed",
+        "trailingComma": "all",
+        "endOfLine": "lf"
+      }
+    ],
+    "strict": ["error", "global"],
     "no-await-in-loop": "warn",
     "no-compare-neg-zero": "error",
-    "no-extra-parens": ["warn", "all", {
-      "nestedBinaryExpressions": false
-    }],
     "no-template-curly-in-string": "error",
     "no-unsafe-negation": "error",
-    "valid-jsdoc": ["error", {
-      "requireReturn": false,
-      "requireReturnDescription": false,
-      "prefer": {
-        "return": "returns",
-        "arg": "param"
-      },
-      "preferType": {
-        "String": "string",
-        "Number": "number",
-        "Boolean": "boolean",
-        "Symbol": "symbol",
-        "object": "Object",
-        "function": "Function",
-        "array": "Array",
-        "date": "Date",
-        "error": "Error",
-        "null": "void"
+    "valid-jsdoc": [
+      "error",
+      {
+        "requireReturn": false,
+        "requireReturnDescription": false,
+        "prefer": {
+          "return": "returns",
+          "arg": "param"
+        },
+        "preferType": {
+          "String": "string",
+          "Number": "number",
+          "Boolean": "boolean",
+          "Symbol": "symbol",
+          "object": "Object",
+          "function": "Function",
+          "array": "Array",
+          "date": "Date",
+          "error": "Error",
+          "null": "void"
+        }
       }
-    }],
+    ],
 
     "accessor-pairs": "warn",
     "array-callback-return": "error",
-    "complexity": "warn",
     "consistent-return": "error",
     "curly": ["error", "multi-line", "consistent"],
     "dot-location": ["error", "property"],
@@ -99,7 +117,6 @@
     "func-names": "error",
     "func-name-matching": "error",
     "func-style": ["error", "declaration", { "allowArrowFunctions": true }],
-    "indent": ["error", 2, { "SwitchCase": 1 }],
     "key-spacing": "error",
     "keyword-spacing": "error",
     "max-depth": "error",
@@ -111,7 +128,6 @@
     "no-array-constructor": "error",
     "no-inline-comments": "error",
     "no-lonely-if": "error",
-    "no-mixed-operators": "error",
     "no-multiple-empty-lines": ["error", { "max": 2, "maxEOF": 1, "maxBOF": 0 }],
     "no-new-object": "error",
     "no-spaced-func": "error",
@@ -121,18 +137,20 @@
     "nonblock-statement-body-position": "error",
     "object-curly-spacing": ["error", "always"],
     "operator-assignment": "error",
-    "operator-linebreak": ["error", "after"],
     "padded-blocks": ["error", "never"],
     "quote-props": ["error", "as-needed"],
     "quotes": ["error", "single", { "avoidEscape": true, "allowTemplateLiterals": true }],
     "semi-spacing": "error",
     "semi": "error",
     "space-before-blocks": "error",
-    "space-before-function-paren": ["error", {
-      "anonymous": "never",
-      "named": "never",
-      "asyncArrow": "always"
-    }],
+    "space-before-function-paren": [
+      "error",
+      {
+        "anonymous": "never",
+        "named": "never",
+        "asyncArrow": "always"
+      }
+    ],
     "space-in-parens": "error",
     "space-infix-ops": "error",
     "space-unary-ops": "error",
diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 9f84b107..84ecd2d4 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -7,11 +7,12 @@ pull request. We use ESLint to enforce a consistent coding style, so having that
 is a great boon to your development process.
 
 ## Setup
+
 To get ready to work on the codebase, please do the following:
 
 1. Fork & clone the repository, and make sure you're on the **master** branch
 2. Run `npm install`
-3. If you're working on voice, also run `npm install node-opus` or `npm install opusscript`
+3. If you're working on voice, also run `npm install @discordjs/opus` or `npm install opusscript`
 4. Code your heart out!
 5. Run `npm test` to run ESLint and ensure any JSDoc changes are valid
 6. [Submit a pull request](https://github.com/discordjs/discord.js/compare)
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 00000000..6aa35f01
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,11 @@
+# These are supported funding model platforms
+
+# github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+# patreon: # Replace with a single Patreon username
+# open_collective: # Replace with a single Open Collective username
+# ko_fi: # Replace with a single Ko-fi username
+# tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+# custom: # Replace with a single custom sponsorship URL
+
+github: amishshah
+patreon: discordjs
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index c497cb4f..caa9425b 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,9 +1,11 @@
 ---
+
 name: Bug report
 about: Report incorrect or unexpected behaviour of discord.js
-
+title: ''
+labels: 's: unverified, type: bug'
+assignees: ''
 ---
-
 <!--
 If you need help with discord.js installation or usage, please go to the discord.js Discord server instead:
   https://discord.gg/bRCvFy9
@@ -13,26 +15,25 @@ You won't receive any basic help here.
 
 **Please describe the problem you are having in as much detail as possible:**
 
-
 **Include a reproducible code sample here, if possible:**
+
 ```js
-
 // Place your code here
-
 ```
 
 **Further details:**
+
 - discord.js version:
 - Node.js version:
 - Operating system:
 - Priority this issue should have – please be realistic and elaborate if possible:
 
 <!--
-If either of these applies to you, please check the respective checkbox: [ ] becomes [x].
+If this applies to you, please check the respective checkbox: [ ] becomes [x].
 You don't have to modify the text to suit your particular situation – if you want to
 elaborate, please do so in the description.
 While it's not a requirement to test your issue on the master branch, it would make fixing
 the problem a lot easier for us, so please do so if possible.
 -->
-- [ ] I found this issue while running code on a __user account__
+
 - [ ] I have also tested the issue on latest master, commit hash:
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..2584693c
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: discord.js discord server
+    url: https://discord.gg/bRCvFy9
+    about: Please use this Discord Server to ask questions and get support. We don't typically answer questions here and they will likely be closed and redirected to the Discord server.
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
index ee9d888a..5510d5f0 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,9 +1,11 @@
 ---
+
 name: Feature request
 about: Request a feature for the core discord.js library
-
+title: ''
+labels: 'type: enhancement'
+assignees: ''
 ---
-
 <!--
 If you need help with discord.js installation or usage, please go to the discord.js Discord server instead:
   https://discord.gg/bRCvFy9
diff --git a/.github/ISSUE_TEMPLATE/question---general-support-request.md b/.github/ISSUE_TEMPLATE/question---general-support-request.md
deleted file mode 100644
index 8ec717c9..00000000
--- a/.github/ISSUE_TEMPLATE/question---general-support-request.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-name: Question / General support request
-about: Ask for help in Discord instead - https://discord.gg/bRCvFy9
-
----
-
-Seriously, we only use this issue tracker for bugs in the library itself and feature requests for it.
-We don't typically answer questions or help with support issues here.
-Instead, please ask in one of the support channels in our Discord server:
-
-https://discord.gg/bRCvFy9
-
-Any issues that don't directly involve a bug in the library or a feature request will likely be closed and redirected to the Discord server.
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 18440786..3de83cd6 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,11 +1,12 @@
 **Please describe the changes this PR makes and why it should be merged:**
 
-
 **Status**
+
 - [ ] Code changes have been tested against the Discord API, or there are no code changes
 - [ ] I know how to update typings and have done so, or typings don't need updating
 
-**Semantic versioning classification:**  
+**Semantic versioning classification:**
+
 - [ ] This PR changes the library's interface (methods or parameters added)
   - [ ] This PR includes breaking changes (methods removed or renamed, parameters moved or removed)
 - [ ] This PR **only** includes non-code changes, like changes to documentation, README, etc.
diff --git a/.github/SUPPORT.md b/.github/SUPPORT.md
new file mode 100644
index 00000000..032cbc2b
--- /dev/null
+++ b/.github/SUPPORT.md
@@ -0,0 +1,7 @@
+# Seeking support?
+
+We're sorry, we only use this issue tracker for bugs in the library itself and feature requests for it. We are not able to provide general support or answser questions on the issue tracker.
+
+Should you want to ask such questions, please post in one of our support channels in our Discord server: https://discord.gg/bRCvFy9
+
+Any issues that don't directly involve a bug in the library or a feature request will likely be closed and redirected to the Discord server.
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
new file mode 100644
index 00000000..4deae773
--- /dev/null
+++ b/.github/workflows/deploy.yml
@@ -0,0 +1,47 @@
+name: Deployment
+on:
+  push:
+    branches:
+      - '*'
+      - '!webpack'
+      - '!docs'
+jobs:
+  docs:
+    name: Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@master
+
+      - name: Install Node v12
+        uses: actions/setup-node@master
+        with:
+          node-version: 12
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build and deploy documentation
+        uses: discordjs/action-docs@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  webpack:
+    name: webpack
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@master
+
+      - name: Install Node v12
+        uses: actions/setup-node@master
+        with:
+          node-version: 12
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build and deploy webpack
+        uses: discordjs/action-webpack@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/test-cron.yml b/.github/workflows/test-cron.yml
new file mode 100644
index 00000000..10f97e38
--- /dev/null
+++ b/.github/workflows/test-cron.yml
@@ -0,0 +1,58 @@
+name: Testing Cron
+on:
+  schedule:
+    - cron: '0 */12 * * *'
+jobs:
+  lint:
+    name: ESLint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v1
+
+      - name: Install Node v12
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Run ESLint
+        uses: icrawl/action-eslint@v1
+
+  typings:
+    name: TSLint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v1
+
+      - name: Install Node v12
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Run TSLint
+        run: npm run lint:typings
+
+  docs:
+    name: Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v1
+
+      - name: Install Node v12
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Test documentation
+        run: npm run docs:test
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 00000000..6bdfc296
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,56 @@
+name: Testing
+on: [push, pull_request]
+jobs:
+  lint:
+    name: ESLint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Install Node v12
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Run ESLint
+        uses: icrawl/action-eslint@v1
+
+  typings:
+    name: TSLint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Install Node v12
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Run TSLint
+        run: npm run lint:typings
+
+  docs:
+    name: Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Install Node v12
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Test documentation
+        run: npm run docs:test
diff --git a/.tern-project b/.tern-project
index 3c8015ce..f5ce9480 100644
--- a/.tern-project
+++ b/.tern-project
@@ -1,12 +1,8 @@
 {
   "ecmaVersion": 7,
   "libs": [],
-  "loadEagerly": [
-    "./src/*.js"
-  ],
-  "dontLoad": [
-    "node_modules/**"
-  ],
+  "loadEagerly": ["./src/*.js"],
+  "dontLoad": ["node_modules/**"],
   "plugins": {
     "es_modules": {},
     "node": {},
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 3b89d2af..00000000
--- a/.travis.yml
+++ /dev/null
@@ -1,19 +0,0 @@
-language: node_js
-node_js:
-  - 8
-  - 9
-install: npm install
-script: bash ./travis/test.sh
-jobs:
-  include:
-    - stage: deploy
-      node_js: 9
-      script: bash ./travis/deploy.sh
-      env:
-        - ENCRYPTION_LABEL="af862fa96d3e"
-        - COMMIT_AUTHOR_EMAIL="amishshah.2k@gmail.com"
-cache:
-  directories:
-    - node_modules
-dist: trusty
-sudo: false
diff --git a/LICENSE b/LICENSE
index 5f32c795..9997d13f 100644
--- a/LICENSE
+++ b/LICENSE
@@ -175,7 +175,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2015 - 2018 Amish Shah
+   Copyright 2015 - 2020 Amish Shah
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
diff --git a/README.md b/README.md
index c4cb7c5e..fe534e74 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@
     <a href="https://discord.gg/bRCvFy9"><img src="https://discordapp.com/api/guilds/222078108977594368/embed.png" alt="Discord server" /></a>
     <a href="https://www.npmjs.com/package/discord.js"><img src="https://img.shields.io/npm/v/discord.js.svg?maxAge=3600" alt="NPM version" /></a>
     <a href="https://www.npmjs.com/package/discord.js"><img src="https://img.shields.io/npm/dt/discord.js.svg?maxAge=3600" alt="NPM downloads" /></a>
-    <a href="https://travis-ci.org/discordjs/discord.js"><img src="https://travis-ci.org/discordjs/discord.js.svg" alt="Build status" /></a>
+    <a href="https://github.com/discordjs/discord.js/actions"><img src="https://github.com/discordjs/discord.js/workflows/Testing/badge.svg" alt="Build status" /></a>
     <a href="https://david-dm.org/discordjs/discord.js"><img src="https://img.shields.io/david/discordjs/discord.js.svg?maxAge=3600" alt="Dependencies" /></a>
     <a href="https://www.patreon.com/discordjs"><img src="https://img.shields.io/badge/donate-patreon-F96854.svg" alt="Patreon" /></a>
   </p>
@@ -17,9 +17,22 @@
   </p>
 </div>
 
+## Table of contents
+
+- [About](#about)
+- [Installation](#installation)
+  - [Audio engines](#audio-engines)
+  - [Optional packages](#optional-packages)
+- [Example Usage](#example-usage)
+- [Links](#links)
+  - [Extensions](#extensions)
+- [Contributing](#contributing)
+- [Help](#help)
+
 ## About
-discord.js is a powerful [Node.js](https://nodejs.org) module that allows you to interact with the
-[Discord API](https://discordapp.com/developers/docs/intro) very easily.
+
+discord.js is a powerful [Node.js](https://nodejs.org) module that allows you to easily interact with the
+[Discord API](https://discordapp.com/developers/docs/intro).
 
 - Object-oriented
 - Predictable abstractions
@@ -27,28 +40,32 @@ discord.js is a powerful [Node.js](https://nodejs.org) module that allows you to
 - 100% coverage of the Discord API
 
 ## Installation
-**Node.js 8.0.0 or newer is required.**  
+
+**Node.js 11.0.0 or newer is required.**  
 Ignore any warnings about unmet peer dependencies, as they're all optional.
 
-Without voice support: `npm install discord.js`  
-With voice support ([node-opus](https://www.npmjs.com/package/node-opus)): `npm install discord.js node-opus`  
-With voice support ([opusscript](https://www.npmjs.com/package/opusscript)): `npm install discord.js opusscript`
+Without voice support: `npm install discordjs/discord.js`  
+With voice support ([@discordjs/opus](https://www.npmjs.com/package/@discordjs/opus)): `npm install discordjs/discord.js @discordjs/opus`  
+With voice support ([opusscript](https://www.npmjs.com/package/opusscript)): `npm install discordjs/discord.js opusscript`
 
 ### Audio engines
-The preferred audio engine is node-opus, as it performs significantly better than opusscript. When both are available, discord.js will automatically choose node-opus.
-Using opusscript is only recommended for development environments where node-opus is tough to get working.
-For production bots, using node-opus should be considered a necessity, especially if they're going to be running on multiple servers.
+
+The preferred audio engine is @discordjs/opus, as it performs significantly better than opusscript. When both are available, discord.js will automatically choose @discordjs/opus.
+Using opusscript is only recommended for development environments where @discordjs/opus is tough to get working.
+For production bots, using @discordjs/opus should be considered a necessity, especially if they're going to be running on multiple servers.
 
 ### Optional packages
-- [zlib-sync](https://www.npmjs.com/package/zlib-sync) for significantly faster WebSocket data inflation (`npm install zlib-sync`)
+
+- [zlib-sync](https://www.npmjs.com/package/zlib-sync) for WebSocket data compression and inflation (`npm install zlib-sync`)
 - [erlpack](https://github.com/discordapp/erlpack) for significantly faster WebSocket data (de)serialisation (`npm install discordapp/erlpack`)
 - One of the following packages can be installed for faster voice packet encryption and decryption:
-    - [sodium](https://www.npmjs.com/package/sodium) (`npm install sodium`)
-    - [libsodium.js](https://www.npmjs.com/package/libsodium-wrappers) (`npm install libsodium-wrappers`)
-- [uws](https://www.npmjs.com/package/@discordjs/uws) for a much faster WebSocket connection (`npm install @discordjs/uws`)
-- [bufferutil](https://www.npmjs.com/package/bufferutil) for a much faster WebSocket connection when *not* using uws (`npm install bufferutil`)
+  - [sodium](https://www.npmjs.com/package/sodium) (`npm install sodium`)
+  - [libsodium.js](https://www.npmjs.com/package/libsodium-wrappers) (`npm install libsodium-wrappers`)
+- [bufferutil](https://www.npmjs.com/package/bufferutil) for a much faster WebSocket connection (`npm install bufferutil`)
+- [utf-8-validate](https://www.npmjs.com/package/utf-8-validate) in combination with `bufferutil` for much faster WebSocket processing (`npm install utf-8-validate`)
 
 ## Example usage
+
 ```js
 const Discord = require('discord.js');
 const client = new Discord.Client();
@@ -67,23 +84,28 @@ client.login('token');
 ```
 
 ## Links
-* [Website](https://discord.js.org/) ([source](https://github.com/discordjs/website))
-* [Documentation](https://discord.js.org/#/docs)
-* [Guide](https://discordjs.guide/) ([source](https://github.com/discordjs/guide))
-* [Discord.js Discord server](https://discord.gg/bRCvFy9)
-* [Discord API Discord server](https://discord.gg/discord-api)
-* [GitHub](https://github.com/discordjs/discord.js)
-* [NPM](https://www.npmjs.com/package/discord.js)
-* [Related libraries](https://discordapi.com/unofficial/libs.html)
+
+- [Website](https://discord.js.org/) ([source](https://github.com/discordjs/website))
+- [Documentation](https://discord.js.org/#/docs/main/master/general/welcome)
+- [Guide](https://discordjs.guide/) ([source](https://github.com/discordjs/guide)) - this is still for stable  
+  See also the [Update Guide](https://discordjs.guide/additional-info/changes-in-v12.html), including updated and removed items in the library.
+- [Discord.js Discord server](https://discord.gg/bRCvFy9)
+- [Discord API Discord server](https://discord.gg/discord-api)
+- [GitHub](https://github.com/discordjs/discord.js)
+- [NPM](https://www.npmjs.com/package/discord.js)
+- [Related libraries](https://discordapi.com/unofficial/libs.html)
 
 ### Extensions
-* [RPC](https://www.npmjs.com/package/discord-rpc) ([source](https://github.com/discordjs/RPC))
+
+- [RPC](https://www.npmjs.com/package/discord-rpc) ([source](https://github.com/discordjs/RPC))
 
 ## Contributing
+
 Before creating an issue, please ensure that it hasn't already been reported/suggested, and double-check the
 [documentation](https://discord.js.org/#/docs).  
 See [the contribution guide](https://github.com/discordjs/discord.js/blob/master/.github/CONTRIBUTING.md) if you'd like to submit a PR.
 
 ## Help
+
 If you don't understand something in the documentation, you are experiencing problems, or you just need a gentle
 nudge in the right direction, please don't hesitate to join our official [Discord.js Server](https://discord.gg/bRCvFy9).
diff --git a/docs/examples/attachments.md b/docs/examples/attachments.md
index 40261805..21295acc 100644
--- a/docs/examples/attachments.md
+++ b/docs/examples/attachments.md
@@ -24,13 +24,13 @@ client.on('ready', () => {
 });
 
 client.on('message', message => {
-	// If the message is '!rip'
-	if (message.content === '!rip') {
-		// Create the attachment using MessageAttachment
-		const attachment = new MessageAttachment('https://i.imgur.com/w3duR07.png');
-		// Send the attachment in the message channel
-		message.channel.send(attachment);
-	}
+  // If the message is '!rip'
+  if (message.content === '!rip') {
+    // Create the attachment using MessageAttachment
+    const attachment = new MessageAttachment('https://i.imgur.com/w3duR07.png');
+    // Send the attachment in the message channel
+    message.channel.send(attachment);
+  }
 });
 
 // Log our bot in using the token from https://discordapp.com/developers/applications/me
@@ -59,13 +59,13 @@ client.on('ready', () => {
 });
 
 client.on('message', message => {
-	// If the message is '!rip'
-	if (message.content === '!rip') {
-		// Create the attachment using MessageAttachment
-		const attachment = new MessageAttachment('https://i.imgur.com/w3duR07.png');
-		// Send the attachment in the message channel with a content
-		message.channel.send(`${message.author},`, attachment);
-	}
+  // If the message is '!rip'
+  if (message.content === '!rip') {
+    // Create the attachment using MessageAttachment
+    const attachment = new MessageAttachment('https://i.imgur.com/w3duR07.png');
+    // Send the attachment in the message channel with a content
+    message.channel.send(`${message.author},`, attachment);
+  }
 });
 
 // Log our bot in using the token from https://discordapp.com/developers/applications/me
@@ -96,13 +96,13 @@ client.on('ready', () => {
 });
 
 client.on('message', message => {
-	// If the message is '!rip'
-	if (message.content === '!rip') {
-		// Create the attachment using MessageAttachment
-		const attachment = new MessageAttachment('./rip.png');
-		// Send the attachment in the message channel with a content
-		message.channel.send(`${message.author},`, attachment);
-	}
+  // If the message is '!rip'
+  if (message.content === '!rip') {
+    // Create the attachment using MessageAttachment
+    const attachment = new MessageAttachment('./rip.png');
+    // Send the attachment in the message channel with a content
+    message.channel.send(`${message.author},`, attachment);
+  }
 });
 
 // Log our bot in using the token from https://discordapp.com/developers/applications/me
@@ -137,21 +137,21 @@ client.on('ready', () => {
 });
 
 client.on('message', message => {
-	// If the message is '!memes'
-	if (message.content === '!memes') {
-		// Get the buffer from the 'memes.txt', assuming that the file exists
-		const buffer = fs.readFileSync('./memes.txt');
+  // If the message is '!memes'
+  if (message.content === '!memes') {
+    // Get the buffer from the 'memes.txt', assuming that the file exists
+    const buffer = fs.readFileSync('./memes.txt');
 
-		/**
-		 * Create the attachment using MessageAttachment,
-		 * overwritting the default file name to 'memes.txt'
-		 * Read more about it over at
-		 * http://discord.js.org/#/docs/main/master/class/MessageAttachment
-		 */
-		const attachment = new MessageAttachment(buffer, 'memes.txt');
-		// Send the attachment in the message channel with a content
-		message.channel.send(`${message.author}, here are your memes!`, attachment);
-	}
+    /**
+     * Create the attachment using MessageAttachment,
+     * overwritting the default file name to 'memes.txt'
+     * Read more about it over at
+     * http://discord.js.org/#/docs/main/master/class/MessageAttachment
+     */
+    const attachment = new MessageAttachment(buffer, 'memes.txt');
+    // Send the attachment in the message channel with a content
+    message.channel.send(`${message.author}, here are your memes!`, attachment);
+  }
 });
 
 // Log our bot in using the token from https://discordapp.com/developers/applications/me
diff --git a/docs/examples/embed.js b/docs/examples/embed.js
index e1e1d56d..a0392127 100644
--- a/docs/examples/embed.js
+++ b/docs/examples/embed.js
@@ -1,3 +1,5 @@
+'use strict';
+
 /**
  * An example of how you can send embeds
  */
@@ -26,7 +28,7 @@ client.on('message', message => {
       // Set the title of the field
       .setTitle('A slick little embed')
       // Set the color of the embed
-      .setColor(0xFF0000)
+      .setColor(0xff0000)
       // Set the main content of the embed
       .setDescription('Hello, this is a slick embed!');
     // Send the embed to the same channel as the message
diff --git a/docs/examples/greeting.js b/docs/examples/greeting.js
index 14288922..314a7598 100644
--- a/docs/examples/greeting.js
+++ b/docs/examples/greeting.js
@@ -19,7 +19,7 @@ client.on('ready', () => {
 // Create an event listener for new guild members
 client.on('guildMemberAdd', member => {
   // Send the message to a designated channel on a server:
-  const channel = member.guild.channels.find('name', 'member-log');
+  const channel = member.guild.channels.cache.find(ch => ch.name === 'member-log');
   // Do nothing if the channel wasn't found on this server
   if (!channel) return;
   // Send the message, mentioning the member
diff --git a/docs/examples/moderation.md b/docs/examples/moderation.md
index b299d57f..36481a46 100644
--- a/docs/examples/moderation.md
+++ b/docs/examples/moderation.md
@@ -4,7 +4,7 @@ In here, you'll see some basic examples for kicking and banning a member.
 
 ## Kicking a member
 
-Let's say you have a member that you'd like to kick. Here is an example of how you *can* do it.
+Let's say you have a member that you'd like to kick. Here is an example of how you _can_ do it.
 
 ```js
 // Import the discord.js module
@@ -41,24 +41,27 @@ client.on('message', message => {
          * Make sure you run this on a member, not a user!
          * There are big differences between a user and a member
          */
-        member.kick('Optional reason that will display in the audit logs').then(() => {
-          // We let the message author know we were able to kick the person
-          message.reply(`Successfully kicked ${user.tag}`);
-        }).catch(err => {
-          // An error happened
-          // This is generally due to the bot not being able to kick the member,
-          // either due to missing permissions or role hierarchy
-          message.reply('I was unable to kick the member');
-          // Log the error
-          console.error(err);
-        });
+        member
+          .kick('Optional reason that will display in the audit logs')
+          .then(() => {
+            // We let the message author know we were able to kick the person
+            message.reply(`Successfully kicked ${user.tag}`);
+          })
+          .catch(err => {
+            // An error happened
+            // This is generally due to the bot not being able to kick the member,
+            // either due to missing permissions or role hierarchy
+            message.reply('I was unable to kick the member');
+            // Log the error
+            console.error(err);
+          });
       } else {
         // The mentioned user isn't in this guild
-        message.reply('That user isn\'t in this guild!');
+        message.reply("That user isn't in this guild!");
       }
-    // Otherwise, if no user was mentioned
+      // Otherwise, if no user was mentioned
     } else {
-      message.reply('You didn\'t mention the user to kick!');
+      message.reply("You didn't mention the user to kick!");
     }
   }
 });
@@ -112,26 +115,29 @@ client.on('message', message => {
          * Read more about what ban options there are over at
          * https://discord.js.org/#/docs/main/master/class/GuildMember?scrollTo=ban
          */
-        member.ban({
-          reason: 'They were bad!',
-        }).then(() => {
-          // We let the message author know we were able to ban the person
-          message.reply(`Successfully banned ${user.tag}`);
-        }).catch(err => {
-          // An error happened
-          // This is generally due to the bot not being able to ban the member,
-          // either due to missing permissions or role hierarchy
-          message.reply('I was unable to ban the member');
-          // Log the error
-          console.error(err);
-        });
+        member
+          .ban({
+            reason: 'They were bad!',
+          })
+          .then(() => {
+            // We let the message author know we were able to ban the person
+            message.reply(`Successfully banned ${user.tag}`);
+          })
+          .catch(err => {
+            // An error happened
+            // This is generally due to the bot not being able to ban the member,
+            // either due to missing permissions or role hierarchy
+            message.reply('I was unable to ban the member');
+            // Log the error
+            console.error(err);
+          });
       } else {
         // The mentioned user isn't in this guild
-        message.reply('That user isn\'t in this guild!');
+        message.reply("That user isn't in this guild!");
       }
     } else {
-    // Otherwise, if no user was mentioned
-      message.reply('You didn\'t mention the user to ban!');
+      // Otherwise, if no user was mentioned
+      message.reply("You didn't mention the user to ban!");
     }
   }
 });
diff --git a/docs/general/faq.md b/docs/general/faq.md
index 950f4d9c..b0835890 100644
--- a/docs/general/faq.md
+++ b/docs/general/faq.md
@@ -1,23 +1,30 @@
 # Frequently Asked Questions
-These are just questions that get asked frequently, that usually have a common resolution.
-If you have issues not listed here, please ask in the [official Discord server](https://discord.gg/bRCvFy9).
-Always make sure to read the documentation.
+
+These questions are some of the most frequently asked.
 
 ## No matter what, I get `SyntaxError: Block-scoped declarations (let, const, function, class) not yet supported outside strict mode`‽
-Update to Node.js 8.0.0 or newer.
+
+Update to Node.js 11.0.0 or newer.
 
 ## How do I get voice working?
+
 - Install FFMPEG.
-- Install either the `node-opus` package or the `opusscript` package.
-  node-opus is greatly preferred, due to it having significantly better performance.
+- Install either the `@discordjs/opus` package or the `opusscript` package.
+  @discordjs/opus is greatly preferred, due to it having significantly better performance.
 
 ## How do I install FFMPEG?
+
 - **npm:** `npm install ffmpeg-binaries`
 - **Ubuntu 16.04:** `sudo apt install ffmpeg`
 - **Ubuntu 14.04:** `sudo apt-get install libav-tools`
 - **Windows:** `npm install ffmpeg-binaries` or see the [FFMPEG section of AoDude's guide](https://github.com/bdistin/OhGodMusicBot/blob/master/README.md#download-ffmpeg).
 
-## How do I set up node-opus?
-- **Ubuntu:** Simply run `npm install node-opus`, and it's done. Congrats!
+## How do I set up @discordjs/opus?
+
+- **Ubuntu:** Simply run `npm install @discordjs/opus`, and it's done. Congrats!
 - **Windows:** Run `npm install --global --production windows-build-tools` in an admin command prompt or PowerShell.
-  Then, running `npm install node-opus` in your bot's directory should successfully build it. Woo!
+  Then, running `npm install @discordjs/opus` in your bot's directory should successfully build it. Woo!
+
+Other questions can be found at the [official Discord.js guide](https://discordjs.guide/popular-topics/common-questions.html)
+If you have issues not listed here or on the guide, feel free to ask in the [official Discord.js server](https://discord.gg/bRCvFy9).
+Always make sure to read the [documentation](https://discord.js.org/#/docs/main/stable/general/welcome).
diff --git a/docs/general/updating.md b/docs/general/updating.md
index 0eab3f4b..9c7cff42 100644
--- a/docs/general/updating.md
+++ b/docs/general/updating.md
@@ -1,72 +1,87 @@
 # Version 11.1.0
+
 v11.1.0 features improved voice and gateway stability, as well as support for new features such as audit logs and searching for messages.
 See [the changelog](https://github.com/discordjs/discord.js/releases/tag/11.1.0) for a full list of changes, including
 information about deprecations.
 
 # Version 11
+
 Version 11 contains loads of new and improved features, optimisations, and bug fixes.
 See [the changelog](https://github.com/discordjs/discord.js/releases/tag/11.0.0) for a full list of changes.
 
 ## Significant additions
-* Message Reactions and Embeds (rich text)
-* Support for uws and erlpack for better performance
-* OAuthApplication support
-* Web distributions
+
+- Message Reactions and Embeds (rich text)
+- Support for uws and erlpack for better performance
+- OAuthApplication support
+- Web distributions
 
 ## Breaking changes
+
 ### Client.login() no longer supports logging in with email + password
+
 Logging in with an email and password has always been heavily discouraged since the advent of proper token support, but in v11 we have made the decision to completely remove the functionality, since Hammer & Chisel have [officially stated](https://github.com/hammerandchisel/discord-api-docs/issues/69#issuecomment-223886862) it simply shouldn't be done.
 
 User accounts can still log in with tokens just like bot accounts. To obtain the token for a user account, you can log in to Discord with that account, and use Ctrl + Shift + I to open the developer tools. In the console tab, evaluating `localStorage.token` will give you the token for that account.
 
 ### ClientUser.setEmail()/setPassword() now require the current password, as well as setUsername() on user accounts
+
 Since you can no longer log in with email and password, you must provide the current account password to the `setEmail()`, `setPassword()`, and `setUsername()` methods for user accounts (self-bots).
 
 ### Removed TextBasedChannel.sendTTSMessage()
+
 This method was deemed to be an entirely pointless shortcut that virtually nobody even used.
 The same results can be achieved by passing options to `send()` or `sendMessage()`.
 
 Example:
+
 ```js
 channel.send('Hi there', { tts: true });
 ```
 
 ### Using Collection.find()/exists() with IDs will throw an error
+
 This is simply to help prevent a common mistake that is made frequently.
 To find something or check its existence using an ID, you should use `.get()` and `.has()` which are part of the [ES6 Map class](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Map), which Collection is an extension of.
 
 # Version 10
+
 Version 10's non-BC changes focus on cleaning up some inconsistencies that exist in previous versions.
 Upgrading from v9 should be quick and painless.
 
 ## Client options
+
 All client options have been converted to camelCase rather than snake_case, and `max_message_cache` was renamed to `messageCacheMaxSize`.
 
 v9 code example:
+
 ```js
 const client = new Discord.Client({
   disable_everyone: true,
   max_message_cache: 500,
   message_cache_lifetime: 120,
-  message_sweep_interval: 60
+  message_sweep_interval: 60,
 });
 ```
 
 v10 code example:
+
 ```js
 const client = new Discord.Client({
   disableEveryone: true,
   messageCacheMaxSize: 500,
   messageCacheLifetime: 120,
-  messageSweepInterval: 60
+  messageSweepInterval: 60,
 });
 ```
 
 ## Presences
+
 Presences have been completely restructured.
 Previous versions of discord.js assumed that users had the same presence amongst all guilds - with the introduction of sharding, however, this is no longer the case.
 
 v9 discord.js code may look something like this:
+
 ```js
 User.status; // the status of the user
 User.game; // the game that the user is playing
@@ -81,6 +96,7 @@ Additionally, the introduction of the Presence class keeps all of the presence d
 A user may have an entirely different presence between two different guilds.**
 
 v10 code:
+
 ```js
 MemberOrUser.presence.status; // the status of the member or user
 MemberOrUser.presence.game; // the game that the member or user is playing
@@ -90,41 +106,46 @@ ClientUser.setPresence(fullPresence); // status and game combined
 ```
 
 ## Voice
+
 Voice has been rewritten internally, but in a backwards-compatible manner.
 There is only one breaking change here; the `disconnected` event was renamed to `disconnect`.
 Several more events have been made available to a VoiceConnection, so see the documentation.
 
 ## Events
+
 Many events have been renamed or had their arguments change.
 
 ### Client events
-|    Version   9                                       |    Version   10                               |
-|------------------------------------------------------|-----------------------------------------------|
-|    guildMemberAdd(guild, member)                     |    guildMemberAdd(member)                     |
-|    guildMemberAvailable(guild, member)               |    guildMemberAvailable(member)               |
-|    guildMemberRemove(guild, member)                  |    guildMemberRemove(member)                  |
-|    guildMembersChunk(guild, members)                 |    guildMembersChunk(members)                 |
-|    guildMemberUpdate(guild, oldMember, newMember)    |    guildMemberUpdate(oldMember, newMember)    |
-|    guildRoleCreate(guild, role)                      |    roleCreate(role)                           |
-|    guildRoleDelete(guild, role)                      |    roleDelete(role)                           |
-|    guildRoleUpdate(guild, oldRole, newRole)          |    roleUpdate(oldRole, newRole)               |
+
+| Version 9                                      | Version 10                              |
+| ---------------------------------------------- | --------------------------------------- |
+| guildMemberAdd(guild, member)                  | guildMemberAdd(member)                  |
+| guildMemberAvailable(guild, member)            | guildMemberAvailable(member)            |
+| guildMemberRemove(guild, member)               | guildMemberRemove(member)               |
+| guildMembersChunk(guild, members)              | guildMembersChunk(members)              |
+| guildMemberUpdate(guild, oldMember, newMember) | guildMemberUpdate(oldMember, newMember) |
+| guildRoleCreate(guild, role)                   | roleCreate(role)                        |
+| guildRoleDelete(guild, role)                   | roleDelete(role)                        |
+| guildRoleUpdate(guild, oldRole, newRole)       | roleUpdate(oldRole, newRole)            |
 
 The guild parameter that has been dropped from the guild-related events can still be derived using `member.guild` or `role.guild`.
 
 ### VoiceConnection events
+
 | Version 9    | Version 10 |
-|--------------|------------|
+| ------------ | ---------- |
 | disconnected | disconnect |
 
 ## Dates and timestamps
+
 All dates/timestamps on the structures have been refactored to have a consistent naming scheme and availability.
 All of them are named similarly to this:  
 **Date:** `Message.createdAt`  
 **Timestamp:** `Message.createdTimestamp`  
 See the docs for each structure to see which date/timestamps are available on them.
 
-
 # Version 9
+
 The version 9 (v9) rewrite takes a much more object-oriented approach than previous versions,
 which allows your code to be much more readable and manageable.
 It's been rebuilt from the ground up and should be much more stable, fixing caching issues that affected
@@ -137,18 +158,21 @@ into other more relevant classes where they belong.
 Because of this, you will need to convert most of your calls over to the new methods.
 
 Here are a few examples of methods that have changed:
-* `Client.sendMessage(channel, message)` ==> `TextChannel.sendMessage(message)`
-  * `Client.sendMessage(user, message)` ==> `User.sendMessage(message)`
-* `Client.updateMessage(message, "New content")` ==> `Message.edit("New Content")`
-* `Client.getChannelLogs(channel, limit)` ==> `TextChannel.fetchMessages({options})`
-* `Server.detailsOfUser(User)` ==> `Server.members.get(User).properties` (retrieving a member gives a GuildMember object)
-* `Client.joinVoiceChannel(voicechannel)` => `VoiceChannel.join()`
+
+- `Client.sendMessage(channel, message)` ==> `TextChannel.sendMessage(message)`
+  - `Client.sendMessage(user, message)` ==> `User.sendMessage(message)`
+- `Client.updateMessage(message, "New content")` ==> `Message.edit("New Content")`
+- `Client.getChannelLogs(channel, limit)` ==> `TextChannel.fetchMessages({options})`
+- `Server.detailsOfUser(User)` ==> `Server.members.get(User).properties` (retrieving a member gives a GuildMember object)
+- `Client.joinVoiceChannel(voicechannel)` => `VoiceChannel.join()`
 
 A couple more important details:
-* `Client.loginWithToken("token")` ==> `client.login("token")`
-* `Client.servers.length` ==> `client.guilds.size` (all instances of `server` are now `guild`)
+
+- `Client.loginWithToken("token")` ==> `client.login("token")`
+- `Client.servers.length` ==> `client.guilds.size` (all instances of `server` are now `guild`)
 
 ## No more callbacks!
+
 Version 9 eschews callbacks in favour of Promises. This means all code relying on callbacks must be changed.  
 For example, the following code:
 
@@ -159,7 +183,7 @@ client.getChannelLogs(channel, 100, function(messages) {
 ```
 
 ```js
-channel.fetchMessages({limit: 100}).then(messages => {
+channel.fetchMessages({ limit: 100 }).then(messages => {
   console.log(`${messages.size} messages found`);
 });
 ```
diff --git a/docs/general/welcome.md b/docs/general/welcome.md
index eb94f475..b3168194 100644
--- a/docs/general/welcome.md
+++ b/docs/general/welcome.md
@@ -18,14 +18,16 @@
 </div>
 
 # Welcome!
+
 Welcome to the discord.js v12 documentation.
 
 v12 is still very much a work-in-progress, as we're aiming to make it the best it can possibly be before releasing.
 Only use it if you are fond of living life on the bleeding edge.
 
 ## About
-discord.js is a powerful [Node.js](https://nodejs.org) module that allows you to interact with the
-[Discord API](https://discordapp.com/developers/docs/intro) very easily.
+
+discord.js is a powerful [Node.js](https://nodejs.org) module that allows you to easily interact with the
+[Discord API](https://discordapp.com/developers/docs/intro).
 
 - Object-oriented
 - Predictable abstractions
@@ -33,28 +35,32 @@ discord.js is a powerful [Node.js](https://nodejs.org) module that allows you to
 - 100% coverage of the Discord API
 
 ## Installation
-**Node.js 8.0.0 or newer is required.**  
+
+**Node.js 11.0.0 or newer is required.**  
 Ignore any warnings about unmet peer dependencies, as they're all optional.
 
-Without voice support: `npm install discord.js`  
-With voice support ([node-opus](https://www.npmjs.com/package/node-opus)): `npm install discord.js node-opus`  
-With voice support ([opusscript](https://www.npmjs.com/package/opusscript)): `npm install discord.js opusscript`
+Without voice support: `npm install discordjs/discord.js`  
+With voice support ([@discordjs/opus](https://www.npmjs.com/package/@discordjs/opus)): `npm install discordjs/discord.js @discordjs/opus`  
+With voice support ([opusscript](https://www.npmjs.com/package/opusscript)): `npm install discordjs/discord.js opusscript`
 
 ### Audio engines
-The preferred audio engine is node-opus, as it performs significantly better than opusscript. When both are available, discord.js will automatically choose node-opus.
-Using opusscript is only recommended for development environments where node-opus is tough to get working.
-For production bots, using node-opus should be considered a necessity, especially if they're going to be running on multiple servers.
+
+The preferred audio engine is @discordjs/opus, as it performs significantly better than opusscript. When both are available, discord.js will automatically choose @discordjs/opus.
+Using opusscript is only recommended for development environments where @discordjs/opus is tough to get working.
+For production bots, using @discordjs/opus should be considered a necessity, especially if they're going to be running on multiple servers.
 
 ### Optional packages
-- [zlib-sync](https://www.npmjs.com/package/zlib-sync) for significantly faster WebSocket data inflation (`npm install zlib-sync`)
+
+- [zlib-sync](https://www.npmjs.com/package/zlib-sync) for WebSocket data compression and inflation (`npm install zlib-sync`)
 - [erlpack](https://github.com/discordapp/erlpack) for significantly faster WebSocket data (de)serialisation (`npm install discordapp/erlpack`)
 - One of the following packages can be installed for faster voice packet encryption and decryption:
-    - [sodium](https://www.npmjs.com/package/sodium) (`npm install sodium`)
-    - [libsodium.js](https://www.npmjs.com/package/libsodium-wrappers) (`npm install libsodium-wrappers`)
-- [uws](https://www.npmjs.com/package/@discordjs/uws) for a much faster WebSocket connection (`npm install @discordjs/uws`)
-- [bufferutil](https://www.npmjs.com/package/bufferutil) for a much faster WebSocket connection when *not* using uws (`npm install bufferutil`)
+  - [sodium](https://www.npmjs.com/package/sodium) (`npm install sodium`)
+  - [libsodium.js](https://www.npmjs.com/package/libsodium-wrappers) (`npm install libsodium-wrappers`)
+- [bufferutil](https://www.npmjs.com/package/bufferutil) for a much faster WebSocket connection (`npm install bufferutil`)
+- [utf-8-validate](https://www.npmjs.com/package/utf-8-validate) in combination with `bufferutil` for much faster WebSocket processing (`npm install utf-8-validate`)
 
 ## Example usage
+
 ```js
 const Discord = require('discord.js');
 const client = new Discord.Client();
@@ -73,23 +79,28 @@ client.login('token');
 ```
 
 ## Links
-* [Website](https://discord.js.org/) ([source](https://github.com/discordjs/website))
-* [Documentation](https://discord.js.org/#/docs)
-* [Guide](https://discordjs.guide/) ([source](https://github.com/discordjs/guide))
-* [Discord.js Discord server](https://discord.gg/bRCvFy9)
-* [Discord API Discord server](https://discord.gg/discord-api)
-* [GitHub](https://github.com/discordjs/discord.js)
-* [NPM](https://www.npmjs.com/package/discord.js)
-* [Related libraries](https://discordapi.com/unofficial/libs.html)
+
+- [Website](https://discord.js.org/) ([source](https://github.com/discordjs/website))
+- [Documentation](https://discord.js.org/#/docs/main/master/general/welcome)
+- [Guide](https://discordjs.guide/) ([source](https://github.com/discordjs/guide)) - this is still for stable  
+  See also the WIP [Update Guide](https://discordjs.guide/additional-info/changes-in-v12.html) also including updated and removed items in the library.
+- [Discord.js Discord server](https://discord.gg/bRCvFy9)
+- [Discord API Discord server](https://discord.gg/discord-api)
+- [GitHub](https://github.com/discordjs/discord.js)
+- [NPM](https://www.npmjs.com/package/discord.js)
+- [Related libraries](https://discordapi.com/unofficial/libs.html)
 
 ### Extensions
-* [RPC](https://www.npmjs.com/package/discord-rpc) ([source](https://github.com/discordjs/RPC))
+
+- [RPC](https://www.npmjs.com/package/discord-rpc) ([source](https://github.com/discordjs/RPC))
 
 ## Contributing
+
 Before creating an issue, please ensure that it hasn't already been reported/suggested, and double-check the
 [documentation](https://discord.js.org/#/docs).  
 See [the contribution guide](https://github.com/discordjs/discord.js/blob/master/.github/CONTRIBUTING.md) if you'd like to submit a PR.
 
 ## Help
+
 If you don't understand something in the documentation, you are experiencing problems, or you just need a gentle
 nudge in the right direction, please don't hesitate to join our official [Discord.js Server](https://discord.gg/bRCvFy9).
diff --git a/docs/index.yml b/docs/index.yml
index 7c5b3b28..17578057 100644
--- a/docs/index.yml
+++ b/docs/index.yml
@@ -12,6 +12,8 @@
       path: voice.md
     - name: Web builds
       path: web.md
+    - name: Partials
+      path: partials.md
 - name: Examples
   files:
     - name: Ping
diff --git a/docs/topics/partials.md b/docs/topics/partials.md
new file mode 100644
index 00000000..4b58f435
--- /dev/null
+++ b/docs/topics/partials.md
@@ -0,0 +1,65 @@
+# Partials
+
+Partials allow you to receive events that contain uncached instances, providing structures that contain very minimal
+data. For example, if you were to receive a `messageDelete` event with an uncached message, normally Discord.js would
+discard the event. With partials, you're able to receive the event, with a Message object that contains just an ID.
+
+## Opting in
+
+Partials are opt-in, and you can enable them in the Client options by specifying [PartialTypes](/#/docs/main/master/typedef/PartialType):
+
+```js
+// Accept partial messages, DM channels, and reactions when emitting events
+new Client({ partials: ['MESSAGE', 'CHANNEL', 'REACTION'] });
+```
+
+## Usage & warnings
+
+<warn>The only guaranteed data a partial structure can store is its ID. All other properties/methods should be
+considered invalid/defunct while accessing a partial structure.</warn>
+
+After opting-in with the above, you begin to allow partial messages and channels in your caches, so it's important
+to check whether they're safe to access whenever you encounter them, whether it be in events or through normal cache
+usage.
+
+All instance of structures that you opted-in for will have a `partial` property. As you'd expect, this value is `true`
+when the instance is partial. Partial structures are only guaranteed to contain an ID, any other properties and methods
+no longer carry their normal type guarantees.
+
+This means you have to take time to consider possible parts of your program that might need checks put in place to
+prevent accessing partial data:
+
+```js
+client.on('messageDelete', message => {
+  console.log(`${message.id} was deleted!`);
+  // Partial messages do not contain any content so skip them
+  if (!message.partial) {
+    console.log(`It had content: "${message.content}"`);
+  }
+});
+
+// You can also try to upgrade partials to full instances:
+client.on('messageReactionAdd', async (reaction, user) => {
+  // If a message gains a reaction and it is uncached, fetch and cache the message
+  // You should account for any errors while fetching, it could return API errors if the resource is missing
+  if (reaction.message.partial) await reaction.message.fetch();
+  // Now the message has been cached and is fully available:
+  console.log(`${reaction.message.author}'s message "${reaction.message.content}" gained a reaction!`);
+  // Fetches and caches the reaction itself, updating resources that were possibly defunct.
+  if (reaction.partial) await reaction.fetch();
+  // Now the reaction is fully available and the properties will be reflected accurately:
+  console.log(`${reaction.count} user(s) have given the same reaction to this message!`);
+});
+```
+
+<info>If a message is deleted and both the message and channel are uncached, you must enable both 'MESSAGE' and
+'CHANNEL' in the client options to receive the messageDelete event.</info>
+
+## Why?
+
+This allows developers to listen to events that contain uncached data, which is useful if you're running a moderation
+bot or any bot that relies on still receiving updates to resources you don't have cached -- message reactions are a
+good example.
+
+Currently, the only type of channel that can be uncached is a DM channel, there is no reason why guild channels should
+not be cached.
diff --git a/docs/topics/voice.md b/docs/topics/voice.md
index e48b8b32..cb20dd5c 100644
--- a/docs/topics/voice.md
+++ b/docs/topics/voice.md
@@ -1,20 +1,23 @@
 # Introduction to Voice
+
 Voice in discord.js can be used for many things, such as music bots, recording or relaying audio.
 
 In discord.js, you can use voice by connecting to a `VoiceChannel` to obtain a `VoiceConnection`, where you can start streaming and receiving audio.
 
 To get started, make sure you have:
-* FFmpeg - `npm install ffmpeg-binaries`
-* an opus encoder, choose one from below:
-  * `npm install node-opus` (better performance)
-  * `npm install opusscript`
-* a good network connection
 
-The preferred opus engine is node-opus, as it performs significantly better than opusscript. When both are available, discord.js will automatically choose node-opus.
-Using opusscript is only recommended for development environments where node-opus is tough to get working.
-For production bots, using node-opus should be considered a necessity, especially if they're going to be running on multiple servers.
+- FFmpeg - `npm install ffmpeg-static`
+- an opus encoder, choose one from below:
+  - `npm install @discordjs/opus` (better performance)
+  - `npm install opusscript`
+- a good network connection
+
+The preferred opus engine is @discordjs/opus, as it performs significantly better than opusscript. When both are available, discord.js will automatically choose @discordjs/opus.
+Using opusscript is only recommended for development environments where @discordjs/opus is tough to get working.
+For production bots, using @discordjs/opus should be considered a necessity, especially if they're going to be running on multiple servers.
 
 ## Joining a voice channel
+
 The example below reacts to a message and joins the sender's voice channel, catching any errors. This is important
 as it allows us to obtain a `VoiceConnection` that we can start to stream audio with.
 
@@ -41,10 +44,12 @@ client.on('message', async message => {
 ```
 
 ## Streaming to a Voice Channel
+
 In the previous example, we looked at how to join a voice channel in order to obtain a `VoiceConnection`. Now that we
 have obtained a voice connection, we can start streaming audio to it.
 
 ### Introduction to playing on voice connections
+
 The most basic example of playing audio over a connection would be playing a local file:
 
 ```js
@@ -71,12 +76,9 @@ We can also pass in options when we first play the stream:
 ```js
 const dispatcher = connection.play('/home/discord/audio.mp3', {
   volume: 0.5,
-  passes: 3
 });
 ```
 
-These are just a subset of the options available (consult documentation for a full list). Most users may be interested in the `passes` option, however. As audio is sent over UDP, there is a chance packets may not arrive. Increasing the number of passes, e.g. to `3` gives you a better chance that your packets reach your recipients, at the cost of triple the bandwidth. We recommend not going over 5 passes.
-
 ### What can I play?
 
 Discord.js allows you to play a lot of things:
@@ -84,9 +86,7 @@ Discord.js allows you to play a lot of things:
 ```js
 // ReadableStreams, in this example YouTube audio
 const ytdl = require('ytdl-core');
-connection.play(ytdl(
-  'https://www.youtube.com/watch?v=ZlAU_w7-Xp8',
-  { filter: 'audioonly' }));
+connection.play(ytdl('https://www.youtube.com/watch?v=ZlAU_w7-Xp8', { filter: 'audioonly' }));
 
 // Files on the internet
 connection.play('http://www.sample-videos.com/audio/mp3/wave.mp3');
@@ -99,11 +99,11 @@ New to v12 is the ability to play OggOpus and WebmOpus streams with much better
 
 ```js
 connection.play(fs.createReadStream('./media.webm'), {
-  type: 'webm/opus'
+  type: 'webm/opus',
 });
 
 connection.play(fs.createReadStream('./media.ogg'), {
-  type: 'ogg/opus'
+  type: 'ogg/opus',
 });
 ```
 
@@ -114,7 +114,7 @@ Make sure to consult the documentation for a full list of what you can play - th
 A voice broadcast is very useful for "radio" bots, that play the same audio across multiple channels. It means audio is only transcoded once, and is much better on performance.
 
 ```js
-const broadcast = client.createVoiceBroadcast();
+const broadcast = client.voice.createBroadcast();
 
 broadcast.on('subscribe', dispatcher => {
   console.log('New broadcast subscriber!');
@@ -122,7 +122,7 @@ broadcast.on('subscribe', dispatcher => {
 
 broadcast.on('unsubscribe', dispatcher => {
   console.log('Channel unsubscribed from broadcast :(');
-})
+});
 ```
 
 `broadcast` is an instance of `VoiceBroadcast`, which has the same `play` method you are used to with regular VoiceConnections:
@@ -136,4 +136,5 @@ connection.play(broadcast);
 It's important to note that the `dispatcher` stored above is a `BroadcastDispatcher` - it controls all the dispatcher subscribed to the broadcast, e.g. setting the volume of this dispatcher affects the volume of all subscribers.
 
 ## Voice Receive
+
 coming soon&trade;
diff --git a/docs/topics/web.md b/docs/topics/web.md
index 86305121..87a85327 100644
--- a/docs/topics/web.md
+++ b/docs/topics/web.md
@@ -1,26 +1,32 @@
 # Web builds
+
 In addition to your usual Node applications, discord.js has special distributions available that are capable of running in web browsers.
 This is useful for client-side web apps that need to interact with the Discord API.
 [Webpack 3](https://webpack.js.org/) is used to build these.
 
 ## Restrictions
+
 - Any voice-related functionality is unavailable, as there is currently no audio encoding/decoding capabilities without external native libraries,
   which web browsers do not support.
 - The ShardingManager cannot be used, since it relies on being able to spawn child processes for shards.
 - None of the native optional packages are usable.
 
 ### Require Library
+
 If you are making your own webpack project, you can require `discord.js/browser` wherever you need to use discord.js, like so:
+
 ```js
 const Discord = require('discord.js/browser');
 // do something with Discord like you normally would
 ```
 
 ### Webpack File
+
 You can obtain your desired version of discord.js' web build from the [webpack branch](https://github.com/discordjs/discord.js/tree/webpack) of the GitHub repository.
 There is a file for each branch and version of the library, and the ones ending in `.min.js` are minified to substantially reduce the size of the source code.
 
 Include the file on the page just as you would any other JS library, like so:
+
 ```html
 <script type="text/javascript" src="discord.VERSION.min.js"></script>
 ```
@@ -29,6 +35,7 @@ Rather than importing discord.js with `require('discord.js')`, the entire `Disco
 The usage of the API isn't any different from using it in Node.js.
 
 #### Example
+
 ```html
 <script type="text/javascript" src="discord.11.1.0.min.js"></script>
 <script type="text/javascript">
diff --git a/jsdoc.json b/jsdoc.json
index e64f528d..3bf2d096 100644
--- a/jsdoc.json
+++ b/jsdoc.json
@@ -1,3 +1,3 @@
 {
-	"plugins": ["node_modules/jsdoc-strip-async-await"]
+  "plugins": ["node_modules/jsdoc-strip-async-await"]
 }
diff --git a/package.json b/package.json
index 4f27bf48..99e61132 100644
--- a/package.json
+++ b/package.json
@@ -8,9 +8,10 @@
     "test": "npm run lint && npm run docs:test && npm run lint:typings",
     "docs": "docgen --source src --custom docs/index.yml --output docs/docs.json",
     "docs:test": "docgen --source src --custom docs/index.yml",
-    "lint": "eslint src *.js",
-    "lint:fix": "eslint --fix src",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
     "lint:typings": "tslint typings/index.d.ts",
+    "prettier": "prettier --write --single-quote --print-width 120 --trailing-comma all --end-of-line lf src/**/*.js typings/**/*.ts",
     "build:browser": "webpack",
     "prepublishOnly": "npm run test && NODE_ENV=production npm run build:browser"
   },
@@ -35,61 +36,130 @@
   "runkitExampleFilename": "./docs/examples/ping.js",
   "unpkg": "./webpack/discord.min.js",
   "dependencies": {
-    "form-data": "^2.3.2",
-    "node-fetch": "^2.1.2",
-    "pako": "^1.0.0",
-    "prism-media": "amishshah/prism-media",
-    "tweetnacl": "^1.0.0",
-    "ws": "^6.0.0"
+    "@discordjs/collection": "^0.1.5",
+    "abort-controller": "^3.0.0",
+    "form-data": "^3.0.0",
+    "node-fetch": "^2.6.0",
+    "prism-media": "^1.2.0",
+    "setimmediate": "^1.0.5",
+    "tweetnacl": "^1.0.3",
+    "ws": "^7.2.1"
   },
   "peerDependencies": {
-    "@discordjs/uws": "^10.149.0",
-    "bufferutil": "^4.0.0",
+    "bufferutil": "^4.0.1",
     "erlpack": "discordapp/erlpack",
-    "libsodium-wrappers": "^0.7.3",
-    "sodium": "^2.0.3",
-    "zlib-sync": "^0.1.4"
+    "libsodium-wrappers": "^0.7.6",
+    "sodium": "^3.0.2",
+    "utf-8-validate": "^5.0.2",
+    "zlib-sync": "^0.1.6"
+  },
+  "peerDependenciesMeta": {
+    "bufferutil": {
+      "optional": true
+    },
+    "erlpack": {
+      "optional": true
+    },
+    "libsodium-wrappers": {
+      "optional": true
+    },
+    "sodium": {
+      "optional": true
+    },
+    "utf-8-validate": {
+      "optional": true
+    },
+    "zlib-sync": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@types/node": "^10.7.1",
+    "@commitlint/cli": "^8.3.5",
+    "@commitlint/config-angular": "^8.3.4",
+    "@types/node": "^10.12.24",
+    "@types/ws": "^7.2.1",
     "discord.js-docgen": "discordjs/docgen",
-    "eslint": "^5.4.0",
+    "dtslint": "^3.0.0",
+    "eslint": "^6.8.0",
+    "eslint-config-prettier": "^6.10.0",
+    "eslint-plugin-import": "^2.20.1",
+    "eslint-plugin-prettier": "^3.1.2",
+    "husky": "^4.2.3",
+    "jest": "^25.1.0",
     "json-filter-loader": "^1.0.0",
-    "terser-webpack-plugin": "^1.1.0",
-    "tslint": "^5.11.0",
-    "tslint-config-typings": "^0.3.1",
-    "typescript": "^3.0.1",
-    "webpack": "^4.17.0",
-    "webpack-cli": "^3.1.0"
+    "lint-staged": "^10.0.8",
+    "prettier": "^1.19.1",
+    "terser-webpack-plugin": "^1.2.2",
+    "tslint": "^6.0.0",
+    "typescript": "^3.8.2",
+    "webpack": "^4.41.6",
+    "webpack-cli": "^3.3.11"
   },
   "engines": {
-    "node": ">=8.0.0"
+    "node": ">=12.0.0"
   },
   "browser": {
+    "@discordjs/opus": false,
     "https": false,
     "ws": false,
-    "uws": false,
-    "@discordjs/uws": false,
     "erlpack": false,
     "prism-media": false,
     "opusscript": false,
     "node-opus": false,
     "tweetnacl": false,
     "sodium": false,
+    "worker_threads": false,
     "zlib-sync": false,
     "src/sharding/Shard.js": false,
     "src/sharding/ShardClientUtil.js": false,
     "src/sharding/ShardingManager.js": false,
     "src/client/voice/ClientVoiceManager.js": false,
+    "src/client/voice/VoiceBroadcast.js": false,
     "src/client/voice/VoiceConnection.js": false,
+    "src/client/voice/dispatcher/BroadcastDispatcher.js": false,
+    "src/client/voice/dispatcher/StreamDispatcher.js": false,
     "src/client/voice/networking/VoiceUDPClient.js": false,
     "src/client/voice/networking/VoiceWebSocket.js": false,
-    "src/client/voice/dispatcher/StreamDispatcher.js": false,
     "src/client/voice/player/AudioPlayer.js": false,
+    "src/client/voice/player/BasePlayer.js": false,
+    "src/client/voice/player/BroadcastAudioPlayer.js": false,
     "src/client/voice/receiver/PacketHandler.js": false,
     "src/client/voice/receiver/Receiver.js": false,
+    "src/client/voice/util/PlayInterface.js": false,
     "src/client/voice/util/Secretbox.js": false,
-    "src/client/voice/util/VolumeInterface.js": false,
-    "src/client/voice/VoiceBroadcast.js": false
+    "src/client/voice/util/Silence.js": false,
+    "src/client/voice/util/VolumeInterface.js": false
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged",
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
+    }
+  },
+  "lint-staged": {
+    "*.js": "eslint --fix",
+    "*.ts": "prettier --write --single-quote --print-width 120 --trailing-comma all --end-of-line lf"
+  },
+  "commitlint": {
+    "extends": ["@commitlint/config-angular"],
+    "rules": {
+      "type-enum": [
+        2,
+        "always",
+        [
+          "chore",
+          "build",
+          "ci",
+          "docs",
+          "feat",
+          "fix",
+          "perf",
+          "refactor",
+          "revert",
+          "style",
+          "test"
+        ]
+      ]
+    }
   }
 }
diff --git a/src/WebSocket.js b/src/WebSocket.js
index c6f4209f..90dd51bb 100644
--- a/src/WebSocket.js
+++ b/src/WebSocket.js
@@ -1,35 +1,47 @@
+'use strict';
+
 const { browser } = require('./util/Constants');
-const querystring = require('querystring');
+
+let erlpack;
+
 try {
-  var erlpack = require('erlpack');
+  erlpack = require('erlpack');
   if (!erlpack.pack) erlpack = null;
-} catch (err) {} // eslint-disable-line no-empty
+} catch {} // eslint-disable-line no-empty
+
+let TextDecoder;
 
 if (browser) {
+  TextDecoder = window.TextDecoder; // eslint-disable-line no-undef
   exports.WebSocket = window.WebSocket; // eslint-disable-line no-undef
 } else {
-  try {
-    exports.WebSocket = require('@discordjs/uws');
-  } catch (err) {
-    exports.WebSocket = require('ws');
-  }
+  TextDecoder = require('util').TextDecoder;
+  exports.WebSocket = require('ws');
 }
 
+const ab = new TextDecoder();
+
 exports.encoding = erlpack ? 'etf' : 'json';
 
 exports.pack = erlpack ? erlpack.pack : JSON.stringify;
 
-exports.unpack = data => {
-  if (!erlpack || data[0] === '{') return JSON.parse(data);
-  if (!(data instanceof Buffer)) data = Buffer.from(new Uint8Array(data));
+exports.unpack = (data, type) => {
+  if (exports.encoding === 'json' || type === 'json') {
+    if (typeof data !== 'string') {
+      data = ab.decode(data);
+    }
+    return JSON.parse(data);
+  }
+  if (!Buffer.isBuffer(data)) data = Buffer.from(new Uint8Array(data));
   return erlpack.unpack(data);
 };
 
 exports.create = (gateway, query = {}, ...args) => {
   const [g, q] = gateway.split('?');
   query.encoding = exports.encoding;
-  if (q) query = Object.assign(querystring.parse(q), query);
-  const ws = new exports.WebSocket(`${g}?${querystring.stringify(query)}`, ...args);
+  query = new URLSearchParams(query);
+  if (q) new URLSearchParams(q).forEach((v, k) => query.set(k, v));
+  const ws = new exports.WebSocket(`${g}?${query}`, ...args);
   if (browser) ws.binaryType = 'arraybuffer';
   return ws;
 };
diff --git a/src/client/BaseClient.js b/src/client/BaseClient.js
index 6e671f99..a381e1aa 100644
--- a/src/client/BaseClient.js
+++ b/src/client/BaseClient.js
@@ -1,7 +1,10 @@
+'use strict';
+
+require('setimmediate');
 const EventEmitter = require('events');
 const RESTManager = require('../rest/RESTManager');
-const Util = require('../util/Util');
 const { DefaultOptions } = require('../util/Constants');
+const Util = require('../util/Util');
 
 /**
  * The base class for all clients.
@@ -25,6 +28,13 @@ class BaseClient extends EventEmitter {
      */
     this._intervals = new Set();
 
+    /**
+     * Intervals set by {@link BaseClient#setImmediate} that are still active
+     * @type {Set<Immediate>}
+     * @private
+     */
+    this._immediates = new Set();
+
     /**
      * The options the client was instantiated with
      * @type {ClientOptions}
@@ -53,10 +63,12 @@ class BaseClient extends EventEmitter {
    * Destroys all assets used by the base client.
    */
   destroy() {
-    for (const t of this._timeouts) clearTimeout(t);
-    for (const i of this._intervals) clearInterval(i);
+    for (const t of this._timeouts) this.clearTimeout(t);
+    for (const i of this._intervals) this.clearInterval(i);
+    for (const i of this._immediates) this.clearImmediate(i);
     this._timeouts.clear();
     this._intervals.clear();
+    this._immediates.clear();
   }
 
   /**
@@ -106,6 +118,27 @@ class BaseClient extends EventEmitter {
     this._intervals.delete(interval);
   }
 
+  /**
+   * Sets an immediate that will be automatically cancelled if the client is destroyed.
+   * @param {Function} fn Function to execute
+   * @param {...*} args Arguments for the function
+   * @returns {Immediate}
+   */
+  setImmediate(fn, ...args) {
+    const immediate = setImmediate(fn, ...args);
+    this._immediates.add(immediate);
+    return immediate;
+  }
+
+  /**
+   * Clears an immediate.
+   * @param {Immediate} immediate Immediate to cancel
+   */
+  clearImmediate(immediate) {
+    clearImmediate(immediate);
+    this._immediates.delete(immediate);
+  }
+
   toJSON(...props) {
     return Util.flatten(this, { domain: false }, ...props);
   }
diff --git a/src/client/Client.js b/src/client/Client.js
index b87d21c9..c2567137 100644
--- a/src/client/Client.js
+++ b/src/client/Client.js
@@ -1,24 +1,24 @@
+'use strict';
+
 const BaseClient = require('./BaseClient');
-const Permissions = require('../util/Permissions');
-const ClientManager = require('./ClientManager');
+const ActionsManager = require('./actions/ActionsManager');
 const ClientVoiceManager = require('./voice/ClientVoiceManager');
 const WebSocketManager = require('./websocket/WebSocketManager');
-const ActionsManager = require('./actions/ActionsManager');
-const Collection = require('../util/Collection');
+const { Error, TypeError, RangeError } = require('../errors');
+const ChannelManager = require('../managers/ChannelManager');
+const GuildEmojiManager = require('../managers/GuildEmojiManager');
+const GuildManager = require('../managers/GuildManager');
+const UserManager = require('../managers/UserManager');
+const ShardClientUtil = require('../sharding/ShardClientUtil');
+const ClientApplication = require('../structures/ClientApplication');
+const Invite = require('../structures/Invite');
 const VoiceRegion = require('../structures/VoiceRegion');
 const Webhook = require('../structures/Webhook');
-const Invite = require('../structures/Invite');
-const ClientApplication = require('../structures/ClientApplication');
-const ShardClientUtil = require('../sharding/ShardClientUtil');
-const VoiceBroadcast = require('./voice/VoiceBroadcast');
-const UserStore = require('../stores/UserStore');
-const ChannelStore = require('../stores/ChannelStore');
-const GuildStore = require('../stores/GuildStore');
-const GuildEmojiStore = require('../stores/GuildEmojiStore');
-const { Events, browser } = require('../util/Constants');
+const Collection = require('../util/Collection');
+const { Events, browser, DefaultOptions } = require('../util/Constants');
 const DataResolver = require('../util/DataResolver');
+const Permissions = require('../util/Permissions');
 const Structures = require('../util/Structures');
-const { Error, TypeError, RangeError } = require('../errors');
 
 /**
  * The main hub for interacting with the Discord API, and the starting point for any bot.
@@ -31,27 +31,50 @@ class Client extends BaseClient {
   constructor(options = {}) {
     super(Object.assign({ _tokenType: 'Bot' }, options));
 
-    // Obtain shard details from environment
-    if (!browser && !this.options.shardId && 'SHARD_ID' in process.env) {
-      this.options.shardId = Number(process.env.SHARD_ID);
+    // Obtain shard details from environment or if present, worker threads
+    let data = process.env;
+    try {
+      // Test if worker threads module is present and used
+      data = require('worker_threads').workerData || data;
+    } catch {
+      // Do nothing
     }
-    if (!browser && !this.options.shardCount && 'SHARD_COUNT' in process.env) {
-      this.options.shardCount = Number(process.env.SHARD_COUNT);
+
+    if (this.options.shards === DefaultOptions.shards) {
+      if ('SHARDS' in data) {
+        this.options.shards = JSON.parse(data.SHARDS);
+      }
+    }
+
+    if (this.options.shardCount === DefaultOptions.shardCount) {
+      if ('SHARD_COUNT' in data) {
+        this.options.shardCount = Number(data.SHARD_COUNT);
+      } else if (Array.isArray(this.options.shards)) {
+        this.options.shardCount = this.options.shards.length;
+      }
+    }
+
+    const typeofShards = typeof this.options.shards;
+
+    if (typeofShards === 'undefined' && typeof this.options.shardCount === 'number') {
+      this.options.shards = Array.from({ length: this.options.shardCount }, (_, i) => i);
+    }
+
+    if (typeofShards === 'number') this.options.shards = [this.options.shards];
+
+    if (Array.isArray(this.options.shards)) {
+      this.options.shards = [
+        ...new Set(
+          this.options.shards.filter(item => !isNaN(item) && item >= 0 && item < Infinity && item === (item | 0)),
+        ),
+      ];
     }
 
     this._validateOptions();
 
-    /**
-     * The manager of the client
-     * @type {ClientManager}
-     * @private
-     */
-    this.manager = new ClientManager(this);
-
     /**
      * The WebSocket manager of the client
      * @type {WebSocketManager}
-     * @private
      */
     this.ws = new WebSocketManager(this);
 
@@ -65,7 +88,6 @@ class Client extends BaseClient {
     /**
      * The voice manager of the client (`null` in browsers)
      * @type {?ClientVoiceManager}
-     * @private
      */
     this.voice = !browser ? new ClientVoiceManager(this) : null;
 
@@ -73,28 +95,32 @@ class Client extends BaseClient {
      * Shard helpers for the client (only if the process was spawned from a {@link ShardingManager})
      * @type {?ShardClientUtil}
      */
-    this.shard = !browser && process.env.SHARDING_MANAGER ? ShardClientUtil.singleton(this) : null;
+    this.shard =
+      !browser && process.env.SHARDING_MANAGER
+        ? ShardClientUtil.singleton(this, process.env.SHARDING_MANAGER_MODE)
+        : null;
 
     /**
      * All of the {@link User} objects that have been cached at any point, mapped by their IDs
-     * @type {UserStore<Snowflake, User>}
+     * @type {UserManager}
      */
-    this.users = new UserStore(this);
+    this.users = new UserManager(this);
 
     /**
      * All of the guilds the client is currently handling, mapped by their IDs -
      * as long as sharding isn't being used, this will be *every* guild the bot is a member of
-     * @type {GuildStore<Snowflake, Guild>}
+     * @type {GuildManager}
      */
-    this.guilds = new GuildStore(this);
+    this.guilds = new GuildManager(this);
 
     /**
      * All of the {@link Channel}s that the client is currently handling, mapped by their IDs -
      * as long as sharding isn't being used, this will be *every* channel in *every* guild the bot
-     * is a member of, and all DM channels
-     * @type {ChannelStore<Snowflake, Channel>}
+     * is a member of. Note that DM channels will not be initially cached, and thus not be present
+     * in the Manager without their explicit fetching or use.
+     * @type {ChannelManager}
      */
-    this.channels = new ChannelStore(this);
+    this.channels = new ChannelManager(this);
 
     const ClientPresence = Structures.get('ClientPresence');
     /**
@@ -129,79 +155,20 @@ class Client extends BaseClient {
      */
     this.readyAt = null;
 
-    /**
-     * Active voice broadcasts that have been created
-     * @type {VoiceBroadcast[]}
-     */
-    this.broadcasts = [];
-
-    /**
-     * Previous heartbeat pings of the websocket (most recent first, limited to three elements)
-     * @type {number[]}
-     */
-    this.pings = [];
-
     if (this.options.messageSweepInterval > 0) {
       this.setInterval(this.sweepMessages.bind(this), this.options.messageSweepInterval * 1000);
     }
   }
 
-  /**
-   * Timestamp of the latest ping's start time
-   * @type {number}
-   * @readonly
-   * @private
-   */
-  get _pingTimestamp() {
-    return this.ws.connection ? this.ws.connection.lastPingTimestamp : 0;
-  }
-
-  /**
-   * Current status of the client's connection to Discord
-   * @type {?Status}
-   * @readonly
-   */
-  get status() {
-    return this.ws.connection ? this.ws.connection.status : null;
-  }
-
-  /**
-   * How long it has been since the client last entered the `READY` state in milliseconds
-   * @type {?number}
-   * @readonly
-   */
-  get uptime() {
-    return this.readyAt ? Date.now() - this.readyAt : null;
-  }
-
-  /**
-   * Average heartbeat ping of the websocket, obtained by averaging the {@link Client#pings} property
-   * @type {number}
-   * @readonly
-   */
-  get ping() {
-    return this.pings.reduce((prev, p) => prev + p, 0) / this.pings.length;
-  }
-
-  /**
-   * All active voice connections that have been established, mapped by guild ID
-   * @type {Collection<Snowflake, VoiceConnection>}
-   * @readonly
-   */
-  get voiceConnections() {
-    if (browser) return new Collection();
-    return this.voice.connections;
-  }
-
   /**
    * All custom emojis that the client has access to, mapped by their IDs
-   * @type {GuildEmojiStore<Snowflake, GuildEmoji>}
+   * @type {GuildEmojiManager}
    * @readonly
    */
   get emojis() {
-    const emojis = new GuildEmojiStore({ client: this });
-    for (const guild of this.guilds.values()) {
-      if (guild.available) for (const emoji of guild.emojis.values()) emojis.set(emoji.id, emoji);
+    const emojis = new GuildEmojiManager({ client: this });
+    for (const guild of this.guilds.cache.values()) {
+      if (guild.available) for (const emoji of guild.emojis.cache.values()) emojis.cache.set(emoji.id, emoji);
     }
     return emojis;
   }
@@ -216,13 +183,12 @@ class Client extends BaseClient {
   }
 
   /**
-   * Creates a voice broadcast.
-   * @returns {VoiceBroadcast}
+   * How long it has been since the client last entered the `READY` state in milliseconds
+   * @type {?number}
+   * @readonly
    */
-  createVoiceBroadcast() {
-    const broadcast = new VoiceBroadcast(this);
-    this.broadcasts.push(broadcast);
-    return broadcast;
+  get uptime() {
+    return this.readyAt ? Date.now() - this.readyAt : null;
   }
 
   /**
@@ -232,15 +198,30 @@ class Client extends BaseClient {
    * @example
    * client.login('my token');
    */
-  login(token = this.token) {
-    return new Promise((resolve, reject) => {
-      if (!token || typeof token !== 'string') throw new Error('TOKEN_INVALID');
-      token = token.replace(/^Bot\s*/i, '');
-      this.manager.connectToWebSocket(token, resolve, reject);
-    }).catch(e => {
+  async login(token = this.token) {
+    if (!token || typeof token !== 'string') throw new Error('TOKEN_INVALID');
+    this.token = token = token.replace(/^(Bot|Bearer)\s*/i, '');
+    this.emit(
+      Events.DEBUG,
+      `Provided token: ${token
+        .split('.')
+        .map((val, i) => (i > 1 ? val.replace(/./g, '*') : val))
+        .join('.')}`,
+    );
+
+    if (this.options.presence) {
+      this.options.ws.presence = await this.presence._parse(this.options.presence);
+    }
+
+    this.emit(Events.DEBUG, 'Preparing to connect to the gateway...');
+
+    try {
+      await this.ws.connect();
+      return this.token;
+    } catch (error) {
       this.destroy();
-      return Promise.reject(e);
-    });
+      throw error;
+    }
   }
 
   /**
@@ -249,7 +230,8 @@ class Client extends BaseClient {
    */
   destroy() {
     super.destroy();
-    return this.manager.destroy();
+    this.ws.destroy();
+    this.token = null;
   }
 
   /**
@@ -263,7 +245,9 @@ class Client extends BaseClient {
    */
   fetchInvite(invite) {
     const code = DataResolver.resolveInviteCode(invite);
-    return this.api.invites(code).get({ query: { with_counts: true } })
+    return this.api
+      .invites(code)
+      .get({ query: { with_counts: true } })
       .then(data => new Invite(this, data));
   }
 
@@ -278,12 +262,15 @@ class Client extends BaseClient {
    *   .catch(console.error);
    */
   fetchWebhook(id, token) {
-    return this.api.webhooks(id, token).get().then(data => new Webhook(this, data));
+    return this.api
+      .webhooks(id, token)
+      .get()
+      .then(data => new Webhook(this, data));
   }
 
   /**
    * Obtains the available voice regions from Discord.
-   * @returns {Collection<string, VoiceRegion>}
+   * @returns {Promise<Collection<string, VoiceRegion>>}
    * @example
    * client.fetchVoiceRegions()
    *   .then(regions => console.log(`Available regions are: ${regions.map(region => region.name).join(', ')}`))
@@ -311,10 +298,10 @@ class Client extends BaseClient {
    */
   sweepMessages(lifetime = this.options.messageCacheLifetime) {
     if (typeof lifetime !== 'number' || isNaN(lifetime)) {
-      throw new TypeError('CLIENT_INVALID_OPTION', 'Lifetime', 'a number');
+      throw new TypeError('INVALID_TYPE', 'lifetime', 'number');
     }
     if (lifetime <= 0) {
-      this.emit(Events.DEBUG, 'Didn\'t sweep messages - lifetime is unlimited');
+      this.emit(Events.DEBUG, "Didn't sweep messages - lifetime is unlimited");
       return -1;
     }
 
@@ -323,17 +310,19 @@ class Client extends BaseClient {
     let channels = 0;
     let messages = 0;
 
-    for (const channel of this.channels.values()) {
+    for (const channel of this.channels.cache.values()) {
       if (!channel.messages) continue;
       channels++;
 
-      messages += channel.messages.sweep(
-        message => now - (message.editedTimestamp || message.createdTimestamp) > lifetimeMs
+      messages += channel.messages.cache.sweep(
+        message => now - (message.editedTimestamp || message.createdTimestamp) > lifetimeMs,
       );
     }
 
-    this.emit(Events.DEBUG,
-      `Swept ${messages} messages older than ${lifetime} seconds in ${channels} text-based channels`);
+    this.emit(
+      Events.DEBUG,
+      `Swept ${messages} messages older than ${lifetime} seconds in ${channels} text-based channels`,
+    );
     return messages;
   }
 
@@ -342,7 +331,9 @@ class Client extends BaseClient {
    * @returns {Promise<ClientApplication>}
    */
   fetchApplication() {
-    return this.api.oauth2.applications('@me').get()
+    return this.api.oauth2
+      .applications('@me')
+      .get()
       .then(app => new ClientApplication(this, app));
   }
 
@@ -355,33 +346,24 @@ class Client extends BaseClient {
    *   .then(link => console.log(`Generated bot invite link: ${link}`))
    *   .catch(console.error);
    */
-  generateInvite(permissions) {
+  async generateInvite(permissions) {
     permissions = Permissions.resolve(permissions);
-    return this.fetchApplication().then(application =>
-      `https://discordapp.com/oauth2/authorize?client_id=${application.id}&permissions=${permissions}&scope=bot`
-    );
+    const application = await this.fetchApplication();
+    const query = new URLSearchParams({
+      client_id: application.id,
+      permissions: permissions,
+      scope: 'bot',
+    });
+    return `${this.options.http.api}${this.api.oauth2.authorize}?${query}`;
   }
 
   toJSON() {
     return super.toJSON({
       readyAt: false,
-      broadcasts: false,
-      pings: false,
       presences: false,
     });
   }
 
-  /**
-   * Adds a ping to {@link Client#pings}.
-   * @param {number} startTime Starting time of the ping
-   * @private
-   */
-  _pong(startTime) {
-    this.pings.unshift(Date.now() - startTime);
-    if (this.pings.length > 3) this.pings.length = 3;
-    this.ws.lastHeartbeatAck = true;
-  }
-
   /**
    * Calls {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval} on a script
    * with the client as `this`.
@@ -398,18 +380,14 @@ class Client extends BaseClient {
    * @param {ClientOptions} [options=this.options] Options to validate
    * @private
    */
-  _validateOptions(options = this.options) { // eslint-disable-line complexity
-    if (typeof options.shardCount !== 'number' || isNaN(options.shardCount)) {
-      throw new TypeError('CLIENT_INVALID_OPTION', 'shardCount', 'a number');
+  _validateOptions(options = this.options) {
+    if (typeof options.shardCount !== 'number' || isNaN(options.shardCount) || options.shardCount < 1) {
+      throw new TypeError('CLIENT_INVALID_OPTION', 'shardCount', 'a number greater than or equal to 1');
     }
-    if (typeof options.shardId !== 'number' || isNaN(options.shardId)) {
-      throw new TypeError('CLIENT_INVALID_OPTION', 'shardId', 'a number');
-    }
-    if (options.shardCount < 0) throw new RangeError('CLIENT_INVALID_OPTION', 'shardCount', 'at least 0');
-    if (options.shardId < 0) throw new RangeError('CLIENT_INVALID_OPTION', 'shardId', 'at least 0');
-    if (options.shardId !== 0 && options.shardId >= options.shardCount) {
-      throw new RangeError('CLIENT_INVALID_OPTION', 'shardId', 'less than shardCount');
+    if (options.shards && !(options.shards === 'auto' || Array.isArray(options.shards))) {
+      throw new TypeError('CLIENT_INVALID_OPTION', 'shards', "'auto', a number or array of numbers");
     }
+    if (options.shards && !options.shards.length) throw new RangeError('CLIENT_INVALID_PROVIDED_SHARDS');
     if (typeof options.messageCacheMaxSize !== 'number' || isNaN(options.messageCacheMaxSize)) {
       throw new TypeError('CLIENT_INVALID_OPTION', 'messageCacheMaxSize', 'a number');
     }
@@ -422,19 +400,22 @@ class Client extends BaseClient {
     if (typeof options.fetchAllMembers !== 'boolean') {
       throw new TypeError('CLIENT_INVALID_OPTION', 'fetchAllMembers', 'a boolean');
     }
-    if (typeof options.disableEveryone !== 'boolean') {
-      throw new TypeError('CLIENT_INVALID_OPTION', 'disableEveryone', 'a boolean');
+    if (typeof options.disableMentions !== 'string') {
+      throw new TypeError('CLIENT_INVALID_OPTION', 'disableMentions', 'a string');
+    }
+    if (!Array.isArray(options.partials)) {
+      throw new TypeError('CLIENT_INVALID_OPTION', 'partials', 'an Array');
     }
     if (typeof options.restWsBridgeTimeout !== 'number' || isNaN(options.restWsBridgeTimeout)) {
       throw new TypeError('CLIENT_INVALID_OPTION', 'restWsBridgeTimeout', 'a number');
     }
+    if (typeof options.restRequestTimeout !== 'number' || isNaN(options.restRequestTimeout)) {
+      throw new TypeError('CLIENT_INVALID_OPTION', 'restRequestTimeout', 'a number');
+    }
     if (typeof options.restSweepInterval !== 'number' || isNaN(options.restSweepInterval)) {
       throw new TypeError('CLIENT_INVALID_OPTION', 'restSweepInterval', 'a number');
     }
-    if (typeof options.internalSharding !== 'boolean') {
-      throw new TypeError('CLIENT_INVALID_OPTION', 'internalSharding', 'a boolean');
-    }
-    if (!(options.disabledEvents instanceof Array)) {
+    if (!Array.isArray(options.disabledEvents)) {
       throw new TypeError('CLIENT_INVALID_OPTION', 'disabledEvents', 'an Array');
     }
     if (typeof options.retryLimit !== 'number' || isNaN(options.retryLimit)) {
diff --git a/src/client/ClientManager.js b/src/client/ClientManager.js
deleted file mode 100644
index e6d10782..00000000
--- a/src/client/ClientManager.js
+++ /dev/null
@@ -1,70 +0,0 @@
-const { Events, Status } = require('../util/Constants');
-const { Error } = require('../errors');
-
-/**
- * Manages the state and background tasks of the client.
- * @private
- */
-class ClientManager {
-  constructor(client) {
-    /**
-     * The client that instantiated this Manager
-     * @type {Client}
-     */
-    this.client = client;
-
-    /**
-     * The heartbeat interval
-     * @type {?number}
-     */
-    this.heartbeatInterval = null;
-  }
-
-  /**
-   * The status of the client
-   * @readonly
-   * @type {number}
-   */
-  get status() {
-    return this.connection ? this.connection.status : Status.IDLE;
-  }
-
-  /**
-   * Connects the client to the WebSocket.
-   * @param {string} token The authorization token
-   * @param {Function} resolve Function to run when connection is successful
-   * @param {Function} reject Function to run when connection fails
-   */
-  connectToWebSocket(token, resolve, reject) {
-    this.client.emit(Events.DEBUG, `Authenticated using token ${token}`);
-    this.client.token = token;
-    const timeout = this.client.setTimeout(() => reject(new Error('WS_CONNECTION_TIMEOUT')), 1000 * 300);
-    this.client.api.gateway.get().then(async res => {
-      if (this.client.options.presence != null) { // eslint-disable-line eqeqeq
-        const presence = await this.client.presence._parse(this.client.options.presence);
-        this.client.options.ws.presence = presence;
-        this.client.presence.patch(presence);
-      }
-      const gateway = `${res.url}/`;
-      this.client.emit(Events.DEBUG, `Using gateway ${gateway}`);
-      this.client.ws.connect(gateway);
-      this.client.ws.connection.once('error', reject);
-      this.client.ws.connection.once('close', event => {
-        if (event.code === 4004) reject(new Error('TOKEN_INVALID'));
-        if (event.code === 4010) reject(new Error('SHARDING_INVALID'));
-        if (event.code === 4011) reject(new Error('SHARDING_REQUIRED'));
-      });
-      this.client.once(Events.READY, () => {
-        resolve(token);
-        this.client.clearTimeout(timeout);
-      });
-    }, reject);
-  }
-
-  destroy() {
-    this.client.ws.destroy();
-    if (this.client.user) this.client.token = null;
-  }
-}
-
-module.exports = ClientManager;
diff --git a/src/client/WebhookClient.js b/src/client/WebhookClient.js
index 0a848d80..cea66319 100644
--- a/src/client/WebhookClient.js
+++ b/src/client/WebhookClient.js
@@ -1,5 +1,7 @@
-const Webhook = require('../structures/Webhook');
+'use strict';
+
 const BaseClient = require('./BaseClient');
+const Webhook = require('../structures/Webhook');
 
 /**
  * The webhook client.
diff --git a/src/client/actions/Action.js b/src/client/actions/Action.js
index 8fdadc92..d9519b5c 100644
--- a/src/client/actions/Action.js
+++ b/src/client/actions/Action.js
@@ -1,3 +1,7 @@
+'use strict';
+
+const { PartialTypes } = require('../../util/Constants');
+
 /*
 
 ABOUT ACTIONS
@@ -18,6 +22,82 @@ class GenericAction {
   handle(data) {
     return data;
   }
+
+  getPayload(data, manager, id, partialType, cache) {
+    const existing = manager.cache.get(id);
+    if (!existing && this.client.options.partials.includes(partialType)) {
+      return manager.add(data, cache);
+    }
+    return existing;
+  }
+
+  getChannel(data) {
+    const id = data.channel_id || data.id;
+    return (
+      data.channel ||
+      this.getPayload(
+        {
+          id,
+          guild_id: data.guild_id,
+          recipients: [data.author || { id: data.user_id }],
+        },
+        this.client.channels,
+        id,
+        PartialTypes.CHANNEL,
+      )
+    );
+  }
+
+  getMessage(data, channel, cache) {
+    const id = data.message_id || data.id;
+    return (
+      data.message ||
+      this.getPayload(
+        {
+          id,
+          channel_id: channel.id,
+          guild_id: data.guild_id || (channel.guild ? channel.guild.id : null),
+        },
+        channel.messages,
+        id,
+        PartialTypes.MESSAGE,
+        cache,
+      )
+    );
+  }
+
+  getReaction(data, message, user) {
+    const id = data.emoji.id || decodeURIComponent(data.emoji.name);
+    return this.getPayload(
+      {
+        emoji: data.emoji,
+        count: message.partial ? null : 0,
+        me: user ? user.id === this.client.user.id : false,
+      },
+      message.reactions,
+      id,
+      PartialTypes.REACTION,
+    );
+  }
+
+  getMember(data, guild) {
+    const id = data.user.id;
+    return this.getPayload(
+      {
+        user: {
+          id,
+        },
+      },
+      guild.members,
+      id,
+      PartialTypes.GUILD_MEMBER,
+    );
+  }
+
+  getUser(data) {
+    const id = data.user_id;
+    return data.user || this.getPayload({ id }, this.client.users, id, PartialTypes.USER);
+  }
 }
 
 module.exports = GenericAction;
diff --git a/src/client/actions/ActionsManager.js b/src/client/actions/ActionsManager.js
index 9e44f426..7e1df121 100644
--- a/src/client/actions/ActionsManager.js
+++ b/src/client/actions/ActionsManager.js
@@ -1,3 +1,5 @@
+'use strict';
+
 class ActionsManager {
   constructor(client) {
     this.client = client;
@@ -9,23 +11,30 @@ class ActionsManager {
     this.register(require('./MessageReactionAdd'));
     this.register(require('./MessageReactionRemove'));
     this.register(require('./MessageReactionRemoveAll'));
+    this.register(require('./MessageReactionRemoveEmoji'));
     this.register(require('./ChannelCreate'));
     this.register(require('./ChannelDelete'));
     this.register(require('./ChannelUpdate'));
     this.register(require('./GuildDelete'));
     this.register(require('./GuildUpdate'));
+    this.register(require('./InviteCreate'));
+    this.register(require('./InviteDelete'));
     this.register(require('./GuildMemberRemove'));
     this.register(require('./GuildBanRemove'));
     this.register(require('./GuildRoleCreate'));
     this.register(require('./GuildRoleDelete'));
     this.register(require('./GuildRoleUpdate'));
+    this.register(require('./PresenceUpdate'));
     this.register(require('./UserUpdate'));
+    this.register(require('./VoiceStateUpdate'));
     this.register(require('./GuildEmojiCreate'));
     this.register(require('./GuildEmojiDelete'));
     this.register(require('./GuildEmojiUpdate'));
     this.register(require('./GuildEmojisUpdate'));
     this.register(require('./GuildRolesPositionUpdate'));
     this.register(require('./GuildChannelsPositionUpdate'));
+    this.register(require('./GuildIntegrationsUpdate'));
+    this.register(require('./WebhooksUpdate'));
   }
 
   register(Action) {
diff --git a/src/client/actions/ChannelCreate.js b/src/client/actions/ChannelCreate.js
index 09e74f0f..fa60a0b3 100644
--- a/src/client/actions/ChannelCreate.js
+++ b/src/client/actions/ChannelCreate.js
@@ -1,12 +1,19 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class ChannelCreateAction extends Action {
   handle(data) {
     const client = this.client;
-    const existing = client.channels.has(data.id);
+    const existing = client.channels.cache.has(data.id);
     const channel = client.channels.add(data);
     if (!existing && channel) {
+      /**
+       * Emitted whenever a channel is created.
+       * @event Client#channelCreate
+       * @param {DMChannel|GuildChannel} channel The channel that was created
+       */
       client.emit(Events.CHANNEL_CREATE, channel);
     }
     return { channel };
diff --git a/src/client/actions/ChannelDelete.js b/src/client/actions/ChannelDelete.js
index f183bbc7..2956d72f 100644
--- a/src/client/actions/ChannelDelete.js
+++ b/src/client/actions/ChannelDelete.js
@@ -1,4 +1,7 @@
+'use strict';
+
 const Action = require('./Action');
+const DMChannel = require('../../structures/DMChannel');
 const { Events } = require('../../util/Constants');
 
 class ChannelDeleteAction extends Action {
@@ -9,11 +12,21 @@ class ChannelDeleteAction extends Action {
 
   handle(data) {
     const client = this.client;
-    let channel = client.channels.get(data.id);
+    let channel = client.channels.cache.get(data.id);
 
     if (channel) {
       client.channels.remove(channel.id);
       channel.deleted = true;
+      if (channel.messages && !(channel instanceof DMChannel)) {
+        for (const message of channel.messages.cache.values()) {
+          message.deleted = true;
+        }
+      }
+      /**
+       * Emitted whenever a channel is deleted.
+       * @event Client#channelDelete
+       * @param {DMChannel|GuildChannel} channel The channel that was deleted
+       */
       client.emit(Events.CHANNEL_DELETE, channel);
     }
 
@@ -21,10 +34,4 @@ class ChannelDeleteAction extends Action {
   }
 }
 
-/**
- * Emitted whenever a channel is deleted.
- * @event Client#channelDelete
- * @param {GroupDMChannel|GuildChannel} channel The channel that was deleted
- */
-
 module.exports = ChannelDeleteAction;
diff --git a/src/client/actions/ChannelUpdate.js b/src/client/actions/ChannelUpdate.js
index ac2d4f69..06bb71b8 100644
--- a/src/client/actions/ChannelUpdate.js
+++ b/src/client/actions/ChannelUpdate.js
@@ -1,12 +1,25 @@
+'use strict';
+
 const Action = require('./Action');
+const Channel = require('../../structures/Channel');
+const { ChannelTypes } = require('../../util/Constants');
 
 class ChannelUpdateAction extends Action {
   handle(data) {
     const client = this.client;
 
-    const channel = client.channels.get(data.id);
+    let channel = client.channels.cache.get(data.id);
     if (channel) {
       const old = channel._update(data);
+
+      if (ChannelTypes[channel.type.toUpperCase()] !== data.type) {
+        const newChannel = Channel.create(this.client, data, channel.guild);
+        for (const [id, message] of channel.messages.cache) newChannel.messages.cache.set(id, message);
+        newChannel._typing = new Map(channel._typing);
+        channel = newChannel;
+        this.client.channels.cache.set(channel.id, channel);
+      }
+
       return {
         old,
         updated: channel,
diff --git a/src/client/actions/GuildBanRemove.js b/src/client/actions/GuildBanRemove.js
index 782b5fe2..fc28e113 100644
--- a/src/client/actions/GuildBanRemove.js
+++ b/src/client/actions/GuildBanRemove.js
@@ -1,11 +1,19 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class GuildBanRemove extends Action {
   handle(data) {
     const client = this.client;
-    const guild = client.guilds.get(data.guild_id);
+    const guild = client.guilds.cache.get(data.guild_id);
     const user = client.users.add(data.user);
+    /**
+     * Emitted whenever a member is unbanned from a guild.
+     * @event Client#guildBanRemove
+     * @param {Guild} guild The guild that the unban occurred in
+     * @param {User} user The user that was unbanned
+     */
     if (guild && user) client.emit(Events.GUILD_BAN_REMOVE, guild, user);
   }
 }
diff --git a/src/client/actions/GuildChannelsPositionUpdate.js b/src/client/actions/GuildChannelsPositionUpdate.js
index 863d7dc5..a393167e 100644
--- a/src/client/actions/GuildChannelsPositionUpdate.js
+++ b/src/client/actions/GuildChannelsPositionUpdate.js
@@ -1,13 +1,15 @@
+'use strict';
+
 const Action = require('./Action');
 
 class GuildChannelsPositionUpdate extends Action {
   handle(data) {
     const client = this.client;
 
-    const guild = client.guilds.get(data.guild_id);
+    const guild = client.guilds.cache.get(data.guild_id);
     if (guild) {
       for (const partialChannel of data.channels) {
-        const channel = guild.channels.get(partialChannel.id);
+        const channel = guild.channels.cache.get(partialChannel.id);
         if (channel) channel.rawPosition = partialChannel.position;
       }
     }
diff --git a/src/client/actions/GuildDelete.js b/src/client/actions/GuildDelete.js
index 1bf237bd..69cd9143 100644
--- a/src/client/actions/GuildDelete.js
+++ b/src/client/actions/GuildDelete.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
@@ -10,15 +12,21 @@ class GuildDeleteAction extends Action {
   handle(data) {
     const client = this.client;
 
-    let guild = client.guilds.get(data.id);
+    let guild = client.guilds.cache.get(data.id);
     if (guild) {
-      for (const channel of guild.channels.values()) {
+      for (const channel of guild.channels.cache.values()) {
         if (channel.type === 'text') channel.stopTyping(true);
       }
 
       if (guild.available && data.unavailable) {
         // Guild is unavailable
         guild.available = false;
+
+        /**
+         * Emitted whenever a guild becomes unavailable, likely due to a server outage.
+         * @event Client#guildUnavailable
+         * @param {Guild} guild The guild that has become unavailable
+         */
         client.emit(Events.GUILD_UNAVAILABLE, guild);
 
         // Stops the GuildDelete packet thinking a guild was actually deleted,
@@ -28,13 +36,20 @@ class GuildDeleteAction extends Action {
         };
       }
 
-      for (const channel of guild.channels.values()) this.client.channels.remove(channel.id);
-      if (guild.voiceConnection) guild.voiceConnection.disconnect();
+      for (const channel of guild.channels.cache.values()) this.client.channels.remove(channel.id);
+      if (guild.voice && guild.voice.connection) guild.voice.connection.disconnect();
 
       // Delete guild
-      client.guilds.remove(guild.id);
+      client.guilds.cache.delete(guild.id);
       guild.deleted = true;
+
+      /**
+       * Emitted whenever a guild kicks the client or the guild is deleted/left.
+       * @event Client#guildDelete
+       * @param {Guild} guild The guild that was deleted
+       */
       client.emit(Events.GUILD_DELETE, guild);
+
       this.deleted.set(guild.id, guild);
       this.scheduleForDeletion(guild.id);
     } else {
@@ -49,10 +64,4 @@ class GuildDeleteAction extends Action {
   }
 }
 
-/**
- * Emitted whenever a guild becomes unavailable, likely due to a server outage.
- * @event Client#guildUnavailable
- * @param {Guild} guild The guild that has become unavailable
- */
-
 module.exports = GuildDeleteAction;
diff --git a/src/client/actions/GuildEmojiCreate.js b/src/client/actions/GuildEmojiCreate.js
index 7fc955a0..379c62e0 100644
--- a/src/client/actions/GuildEmojiCreate.js
+++ b/src/client/actions/GuildEmojiCreate.js
@@ -1,18 +1,19 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class GuildEmojiCreateAction extends Action {
   handle(guild, createdEmoji) {
     const emoji = guild.emojis.add(createdEmoji);
+    /**
+     * Emitted whenever a custom emoji is created in a guild.
+     * @event Client#emojiCreate
+     * @param {GuildEmoji} emoji The emoji that was created
+     */
     this.client.emit(Events.GUILD_EMOJI_CREATE, emoji);
     return { emoji };
   }
 }
 
-/**
- * Emitted whenever a custom emoji is created in a guild.
- * @event Client#emojiCreate
- * @param {GuildEmoji} emoji The emoji that was created
- */
-
 module.exports = GuildEmojiCreateAction;
diff --git a/src/client/actions/GuildEmojiDelete.js b/src/client/actions/GuildEmojiDelete.js
index 82df6ec8..42af70c1 100644
--- a/src/client/actions/GuildEmojiDelete.js
+++ b/src/client/actions/GuildEmojiDelete.js
@@ -1,19 +1,20 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class GuildEmojiDeleteAction extends Action {
   handle(emoji) {
-    emoji.guild.emojis.remove(emoji.id);
+    emoji.guild.emojis.cache.delete(emoji.id);
     emoji.deleted = true;
+    /**
+     * Emitted whenever a custom emoji is deleted in a guild.
+     * @event Client#emojiDelete
+     * @param {GuildEmoji} emoji The emoji that was deleted
+     */
     this.client.emit(Events.GUILD_EMOJI_DELETE, emoji);
     return { emoji };
   }
 }
 
-/**
- * Emitted whenever a custom emoji is deleted in a guild.
- * @event Client#emojiDelete
- * @param {GuildEmoji} emoji The emoji that was deleted
- */
-
 module.exports = GuildEmojiDeleteAction;
diff --git a/src/client/actions/GuildEmojiUpdate.js b/src/client/actions/GuildEmojiUpdate.js
index e6accf2c..9fa59c96 100644
--- a/src/client/actions/GuildEmojiUpdate.js
+++ b/src/client/actions/GuildEmojiUpdate.js
@@ -1,19 +1,20 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class GuildEmojiUpdateAction extends Action {
   handle(current, data) {
     const old = current._update(data);
+    /**
+     * Emitted whenever a custom emoji is updated in a guild.
+     * @event Client#emojiUpdate
+     * @param {GuildEmoji} oldEmoji The old emoji
+     * @param {GuildEmoji} newEmoji The new emoji
+     */
     this.client.emit(Events.GUILD_EMOJI_UPDATE, old, current);
     return { emoji: current };
   }
 }
 
-/**
- * Emitted whenever a custom emoji is updated in a guild.
- * @event Client#emojiUpdate
- * @param {GuildEmoji} oldEmoji The old emoji
- * @param {GuildEmoji} newEmoji The new emoji
- */
-
 module.exports = GuildEmojiUpdateAction;
diff --git a/src/client/actions/GuildEmojisUpdate.js b/src/client/actions/GuildEmojisUpdate.js
index aaa89847..77119333 100644
--- a/src/client/actions/GuildEmojisUpdate.js
+++ b/src/client/actions/GuildEmojisUpdate.js
@@ -1,15 +1,17 @@
+'use strict';
+
 const Action = require('./Action');
 
 class GuildEmojisUpdateAction extends Action {
   handle(data) {
-    const guild = this.client.guilds.get(data.guild_id);
+    const guild = this.client.guilds.cache.get(data.guild_id);
     if (!guild || !guild.emojis) return;
 
-    const deletions = new Map(guild.emojis);
+    const deletions = new Map(guild.emojis.cache);
 
     for (const emoji of data.emojis) {
       // Determine type of emoji event
-      const cachedEmoji = guild.emojis.get(emoji.id);
+      const cachedEmoji = guild.emojis.cache.get(emoji.id);
       if (cachedEmoji) {
         deletions.delete(emoji.id);
         if (!cachedEmoji.equals(emoji)) {
diff --git a/src/client/actions/GuildIntegrationsUpdate.js b/src/client/actions/GuildIntegrationsUpdate.js
new file mode 100644
index 00000000..bbce0760
--- /dev/null
+++ b/src/client/actions/GuildIntegrationsUpdate.js
@@ -0,0 +1,19 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class GuildIntegrationsUpdate extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    /**
+     * Emitted whenever a guild integration is updated
+     * @event Client#guildIntegrationsUpdate
+     * @param {Guild} guild The guild whose integrations were updated
+     */
+    if (guild) client.emit(Events.GUILD_INTEGRATIONS_UPDATE, guild);
+  }
+}
+
+module.exports = GuildIntegrationsUpdate;
diff --git a/src/client/actions/GuildMemberRemove.js b/src/client/actions/GuildMemberRemove.js
index 2e0a1d8c..f0fe3b38 100644
--- a/src/client/actions/GuildMemberRemove.js
+++ b/src/client/actions/GuildMemberRemove.js
@@ -1,29 +1,30 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events, Status } = require('../../util/Constants');
 
 class GuildMemberRemoveAction extends Action {
-  handle(data) {
+  handle(data, shard) {
     const client = this.client;
-    const guild = client.guilds.get(data.guild_id);
+    const guild = client.guilds.cache.get(data.guild_id);
     let member = null;
     if (guild) {
-      member = guild.members.get(data.user.id);
+      member = this.getMember(data, guild);
       guild.memberCount--;
       if (member) {
-        guild.voiceStates.delete(member.id);
         member.deleted = true;
-        guild.members.remove(member.id);
-        if (client.status === Status.READY) client.emit(Events.GUILD_MEMBER_REMOVE, member);
+        guild.members.cache.delete(member.id);
+        /**
+         * Emitted whenever a member leaves a guild, or is kicked.
+         * @event Client#guildMemberRemove
+         * @param {GuildMember} member The member that has left/been kicked from the guild
+         */
+        if (shard.status === Status.READY) client.emit(Events.GUILD_MEMBER_REMOVE, member);
       }
+      guild.voiceStates.cache.delete(data.user.id);
     }
     return { guild, member };
   }
 }
 
-/**
- * Emitted whenever a member leaves a guild, or is kicked.
- * @event Client#guildMemberRemove
- * @param {GuildMember} member The member that has left/been kicked from the guild
- */
-
 module.exports = GuildMemberRemoveAction;
diff --git a/src/client/actions/GuildRoleCreate.js b/src/client/actions/GuildRoleCreate.js
index b4930399..d7d52144 100644
--- a/src/client/actions/GuildRoleCreate.js
+++ b/src/client/actions/GuildRoleCreate.js
@@ -1,24 +1,25 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class GuildRoleCreate extends Action {
   handle(data) {
     const client = this.client;
-    const guild = client.guilds.get(data.guild_id);
+    const guild = client.guilds.cache.get(data.guild_id);
     let role;
     if (guild) {
-      const already = guild.roles.has(data.role.id);
+      const already = guild.roles.cache.has(data.role.id);
       role = guild.roles.add(data.role);
+      /**
+       * Emitted whenever a role is created.
+       * @event Client#roleCreate
+       * @param {Role} role The role that was created
+       */
       if (!already) client.emit(Events.GUILD_ROLE_CREATE, role);
     }
     return { role };
   }
 }
 
-/**
- * Emitted whenever a role is created.
- * @event Client#roleCreate
- * @param {Role} role The role that was created
- */
-
 module.exports = GuildRoleCreate;
diff --git a/src/client/actions/GuildRoleDelete.js b/src/client/actions/GuildRoleDelete.js
index ce6bcaed..51754b35 100644
--- a/src/client/actions/GuildRoleDelete.js
+++ b/src/client/actions/GuildRoleDelete.js
@@ -1,17 +1,24 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class GuildRoleDeleteAction extends Action {
   handle(data) {
     const client = this.client;
-    const guild = client.guilds.get(data.guild_id);
+    const guild = client.guilds.cache.get(data.guild_id);
     let role;
 
     if (guild) {
-      role = guild.roles.get(data.role_id);
+      role = guild.roles.cache.get(data.role_id);
       if (role) {
-        guild.roles.remove(data.role_id);
+        guild.roles.cache.delete(data.role_id);
         role.deleted = true;
+        /**
+         * Emitted whenever a guild role is deleted.
+         * @event Client#roleDelete
+         * @param {Role} role The role that was deleted
+         */
         client.emit(Events.GUILD_ROLE_DELETE, role);
       }
     }
@@ -20,10 +27,4 @@ class GuildRoleDeleteAction extends Action {
   }
 }
 
-/**
- * Emitted whenever a guild role is deleted.
- * @event Client#roleDelete
- * @param {Role} role The role that was deleted
- */
-
 module.exports = GuildRoleDeleteAction;
diff --git a/src/client/actions/GuildRoleUpdate.js b/src/client/actions/GuildRoleUpdate.js
index 2437264f..faea1202 100644
--- a/src/client/actions/GuildRoleUpdate.js
+++ b/src/client/actions/GuildRoleUpdate.js
@@ -1,17 +1,25 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class GuildRoleUpdateAction extends Action {
   handle(data) {
     const client = this.client;
-    const guild = client.guilds.get(data.guild_id);
+    const guild = client.guilds.cache.get(data.guild_id);
 
     if (guild) {
       let old = null;
 
-      const role = guild.roles.get(data.role.id);
+      const role = guild.roles.cache.get(data.role.id);
       if (role) {
         old = role._update(data.role);
+        /**
+         * Emitted whenever a guild role is updated.
+         * @event Client#roleUpdate
+         * @param {Role} oldRole The role before the update
+         * @param {Role} newRole The role after the update
+         */
         client.emit(Events.GUILD_ROLE_UPDATE, old, role);
       }
 
@@ -28,11 +36,4 @@ class GuildRoleUpdateAction extends Action {
   }
 }
 
-/**
- * Emitted whenever a guild role is updated.
- * @event Client#roleUpdate
- * @param {Role} oldRole The role before the update
- * @param {Role} newRole The role after the update
- */
-
 module.exports = GuildRoleUpdateAction;
diff --git a/src/client/actions/GuildRolesPositionUpdate.js b/src/client/actions/GuildRolesPositionUpdate.js
index af29702a..d7abca97 100644
--- a/src/client/actions/GuildRolesPositionUpdate.js
+++ b/src/client/actions/GuildRolesPositionUpdate.js
@@ -1,13 +1,15 @@
+'use strict';
+
 const Action = require('./Action');
 
 class GuildRolesPositionUpdate extends Action {
   handle(data) {
     const client = this.client;
 
-    const guild = client.guilds.get(data.guild_id);
+    const guild = client.guilds.cache.get(data.guild_id);
     if (guild) {
       for (const partialRole of data.roles) {
-        const role = guild.roles.get(partialRole.id);
+        const role = guild.roles.cache.get(partialRole.id);
         if (role) role.rawPosition = partialRole.position;
       }
     }
diff --git a/src/client/actions/GuildUpdate.js b/src/client/actions/GuildUpdate.js
index b828bb10..78a8afb9 100644
--- a/src/client/actions/GuildUpdate.js
+++ b/src/client/actions/GuildUpdate.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
@@ -5,9 +7,15 @@ class GuildUpdateAction extends Action {
   handle(data) {
     const client = this.client;
 
-    const guild = client.guilds.get(data.id);
+    const guild = client.guilds.cache.get(data.id);
     if (guild) {
       const old = guild._update(data);
+      /**
+       * Emitted whenever a guild is updated - e.g. name change.
+       * @event Client#guildUpdate
+       * @param {Guild} oldGuild The guild before the update
+       * @param {Guild} newGuild The guild after the update
+       */
       client.emit(Events.GUILD_UPDATE, old, guild);
       return {
         old,
@@ -22,11 +30,4 @@ class GuildUpdateAction extends Action {
   }
 }
 
-/**
- * Emitted whenever a guild is updated - e.g. name change.
- * @event Client#guildUpdate
- * @param {Guild} oldGuild The guild before the update
- * @param {Guild} newGuild The guild after the update
- */
-
 module.exports = GuildUpdateAction;
diff --git a/src/client/actions/InviteCreate.js b/src/client/actions/InviteCreate.js
new file mode 100644
index 00000000..63813315
--- /dev/null
+++ b/src/client/actions/InviteCreate.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const Action = require('./Action');
+const Invite = require('../../structures/Invite');
+const { Events } = require('../../util/Constants');
+
+class InviteCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (!channel && !guild) return false;
+
+    const inviteData = Object.assign(data, { channel, guild });
+    const invite = new Invite(client, inviteData);
+    /**
+     * Emitted when an invite is created.
+     * <info> This event only triggers if the client has `MANAGE_GUILD` permissions for the guild,
+     * or `MANAGE_CHANNEL` permissions for the channel.</info>
+     * @event Client#inviteCreate
+     * @param {Invite} invite The invite that was created
+     */
+    client.emit(Events.INVITE_CREATE, invite);
+    return { invite };
+  }
+}
+
+module.exports = InviteCreateAction;
diff --git a/src/client/actions/InviteDelete.js b/src/client/actions/InviteDelete.js
new file mode 100644
index 00000000..92692c3e
--- /dev/null
+++ b/src/client/actions/InviteDelete.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const Action = require('./Action');
+const Invite = require('../../structures/Invite');
+const { Events } = require('../../util/Constants');
+
+class InviteDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (!channel && !guild) return false;
+
+    const inviteData = Object.assign(data, { channel, guild });
+    const invite = new Invite(client, inviteData);
+
+    /**
+     * Emitted when an invite is deleted.
+     * <info> This event only triggers if the client has `MANAGE_GUILD` permissions for the guild,
+     * or `MANAGE_CHANNEL` permissions for the channel.</info>
+     * @event Client#inviteDelete
+     * @param {Invite} invite The invite that was deleted
+     */
+    client.emit(Events.INVITE_DELETE, invite);
+    return { invite };
+  }
+}
+
+module.exports = InviteDeleteAction;
diff --git a/src/client/actions/MessageCreate.js b/src/client/actions/MessageCreate.js
index aebc0d38..71387075 100644
--- a/src/client/actions/MessageCreate.js
+++ b/src/client/actions/MessageCreate.js
@@ -1,16 +1,18 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class MessageCreateAction extends Action {
   handle(data) {
     const client = this.client;
-    const channel = client.channels.get(data.channel_id);
+    const channel = client.channels.cache.get(data.channel_id);
     if (channel) {
-      const existing = channel.messages.get(data.id);
+      const existing = channel.messages.cache.get(data.id);
       if (existing) return { message: existing };
       const message = channel.messages.add(data);
       const user = message.author;
-      const member = channel.guild ? channel.guild.member(user) : null;
+      let member = message.member;
       channel.lastMessageID = data.id;
       if (user) {
         user.lastMessageID = data.id;
@@ -21,6 +23,11 @@ class MessageCreateAction extends Action {
         member.lastMessageChannelID = channel.id;
       }
 
+      /**
+       * Emitted whenever a message is created.
+       * @event Client#message
+       * @param {Message} message The created message
+       */
       client.emit(Events.MESSAGE_CREATE, message);
       return { message };
     }
@@ -29,10 +36,4 @@ class MessageCreateAction extends Action {
   }
 }
 
-/**
- * Emitted whenever a message is created.
- * @event Client#message
- * @param {Message} message The created message
- */
-
 module.exports = MessageCreateAction;
diff --git a/src/client/actions/MessageDelete.js b/src/client/actions/MessageDelete.js
index c31c39cb..0210625f 100644
--- a/src/client/actions/MessageDelete.js
+++ b/src/client/actions/MessageDelete.js
@@ -1,17 +1,23 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class MessageDeleteAction extends Action {
   handle(data) {
     const client = this.client;
-    const channel = client.channels.get(data.channel_id);
+    const channel = this.getChannel(data);
     let message;
-
     if (channel) {
-      message = channel.messages.get(data.id);
+      message = this.getMessage(data, channel);
       if (message) {
-        channel.messages.delete(message.id);
+        channel.messages.cache.delete(message.id);
         message.deleted = true;
+        /**
+         * Emitted whenever a message is deleted.
+         * @event Client#messageDelete
+         * @param {Message} message The deleted message
+         */
         client.emit(Events.MESSAGE_DELETE, message);
       }
     }
@@ -20,10 +26,4 @@ class MessageDeleteAction extends Action {
   }
 }
 
-/**
- * Emitted whenever a message is deleted.
- * @event Client#messageDelete
- * @param {Message} message The deleted message
- */
-
 module.exports = MessageDeleteAction;
diff --git a/src/client/actions/MessageDeleteBulk.js b/src/client/actions/MessageDeleteBulk.js
index e12eaa73..8686b1d3 100644
--- a/src/client/actions/MessageDeleteBulk.js
+++ b/src/client/actions/MessageDeleteBulk.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Action = require('./Action');
 const Collection = require('../../util/Collection');
 const { Events } = require('../../util/Constants');
@@ -5,20 +7,32 @@ const { Events } = require('../../util/Constants');
 class MessageDeleteBulkAction extends Action {
   handle(data) {
     const client = this.client;
-    const channel = client.channels.get(data.channel_id);
+    const channel = client.channels.cache.get(data.channel_id);
 
     if (channel) {
       const ids = data.ids;
       const messages = new Collection();
       for (const id of ids) {
-        const message = channel.messages.get(id);
+        const message = this.getMessage(
+          {
+            id,
+            guild_id: data.guild_id,
+          },
+          channel,
+          false,
+        );
         if (message) {
           message.deleted = true;
           messages.set(message.id, message);
-          channel.messages.delete(id);
+          channel.messages.cache.delete(id);
         }
       }
 
+      /**
+       * Emitted whenever messages are deleted in bulk.
+       * @event Client#messageDeleteBulk
+       * @param {Collection<Snowflake, Message>} messages The deleted messages, mapped by their ID
+       */
       if (messages.size > 0) client.emit(Events.MESSAGE_BULK_DELETE, messages);
       return { messages };
     }
@@ -26,10 +40,4 @@ class MessageDeleteBulkAction extends Action {
   }
 }
 
-/**
- * Emitted whenever messages are deleted in bulk.
- * @event Client#messageDeleteBulk
- * @param {Collection<Snowflake, Message>} messages The deleted messages, mapped by their ID
- */
-
 module.exports = MessageDeleteBulkAction;
diff --git a/src/client/actions/MessageReactionAdd.js b/src/client/actions/MessageReactionAdd.js
index 0708d338..22287dbd 100644
--- a/src/client/actions/MessageReactionAdd.js
+++ b/src/client/actions/MessageReactionAdd.js
@@ -1,4 +1,8 @@
+'use strict';
+
 const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+const { PartialTypes } = require('../../util/Constants');
 
 /*
 { user_id: 'id',
@@ -9,31 +13,38 @@ const Action = require('./Action');
 
 class MessageReactionAdd extends Action {
   handle(data) {
-    const user = data.user || this.client.users.get(data.user_id);
-    if (!user) return false;
-    // Verify channel
-    const channel = data.channel || this.client.channels.get(data.channel_id);
-    if (!channel || channel.type === 'voice') return false;
-    // Verify message
-    const message = data.message || channel.messages.get(data.message_id);
-    if (!message) return false;
     if (!data.emoji) return false;
+
+    const user = this.getUser(data);
+    if (!user) return false;
+
+    // Verify channel
+    const channel = this.getChannel(data);
+    if (!channel || channel.type === 'voice') return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
     // Verify reaction
+    if (message.partial && !this.client.options.partials.includes(PartialTypes.REACTION)) return false;
     const reaction = message.reactions.add({
       emoji: data.emoji,
-      count: 0,
+      count: message.partial ? null : 0,
       me: user.id === this.client.user.id,
     });
+    if (!reaction) return false;
     reaction._add(user);
+    /**
+     * Emitted whenever a reaction is added to a cached message.
+     * @event Client#messageReactionAdd
+     * @param {MessageReaction} messageReaction The reaction object
+     * @param {User} user The user that applied the guild or reaction emoji
+     */
+    this.client.emit(Events.MESSAGE_REACTION_ADD, reaction, user);
+
     return { message, reaction, user };
   }
 }
 
-/**
- * Emitted whenever a reaction is added to a cached message.
- * @event Client#messageReactionAdd
- * @param {MessageReaction} messageReaction The reaction object
- * @param {User} user The user that applied the guild or reaction emoji
- */
-
 module.exports = MessageReactionAdd;
diff --git a/src/client/actions/MessageReactionRemove.js b/src/client/actions/MessageReactionRemove.js
index 63e349f7..a40aa755 100644
--- a/src/client/actions/MessageReactionRemove.js
+++ b/src/client/actions/MessageReactionRemove.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
@@ -10,31 +12,33 @@ const { Events } = require('../../util/Constants');
 
 class MessageReactionRemove extends Action {
   handle(data) {
-    const user = this.client.users.get(data.user_id);
-    if (!user) return false;
-    // Verify channel
-    const channel = this.client.channels.get(data.channel_id);
-    if (!channel || channel.type === 'voice') return false;
-    // Verify message
-    const message = channel.messages.get(data.message_id);
-    if (!message) return false;
     if (!data.emoji) return false;
+
+    const user = this.getUser(data);
+    if (!user) return false;
+
+    // Verify channel
+    const channel = this.getChannel(data);
+    if (!channel || channel.type === 'voice') return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
     // Verify reaction
-    const emojiID = data.emoji.id || decodeURIComponent(data.emoji.name);
-    const reaction = message.reactions.get(emojiID);
+    const reaction = this.getReaction(data, message, user);
     if (!reaction) return false;
     reaction._remove(user);
+    /**
+     * Emitted whenever a reaction is removed from a cached message.
+     * @event Client#messageReactionRemove
+     * @param {MessageReaction} messageReaction The reaction object
+     * @param {User} user The user whose emoji or reaction emoji was removed
+     */
     this.client.emit(Events.MESSAGE_REACTION_REMOVE, reaction, user);
 
     return { message, reaction, user };
   }
 }
 
-/**
- * Emitted whenever a reaction is removed from a cached message.
- * @event Client#messageReactionRemove
- * @param {MessageReaction} messageReaction The reaction object
- * @param {User} user The user whose emoji or reaction emoji was removed
- */
-
 module.exports = MessageReactionRemove;
diff --git a/src/client/actions/MessageReactionRemoveAll.js b/src/client/actions/MessageReactionRemoveAll.js
index ac03c6e8..14b79bf0 100644
--- a/src/client/actions/MessageReactionRemoveAll.js
+++ b/src/client/actions/MessageReactionRemoveAll.js
@@ -1,15 +1,19 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
 class MessageReactionRemoveAll extends Action {
   handle(data) {
-    const channel = this.client.channels.get(data.channel_id);
+    // Verify channel
+    const channel = this.getChannel(data);
     if (!channel || channel.type === 'voice') return false;
 
-    const message = channel.messages.get(data.message_id);
+    // Verify message
+    const message = this.getMessage(data, channel);
     if (!message) return false;
 
-    message.reactions.clear();
+    message.reactions.cache.clear();
     this.client.emit(Events.MESSAGE_REACTION_REMOVE_ALL, message);
 
     return { message };
diff --git a/src/client/actions/MessageReactionRemoveEmoji.js b/src/client/actions/MessageReactionRemoveEmoji.js
new file mode 100644
index 00000000..143702c0
--- /dev/null
+++ b/src/client/actions/MessageReactionRemoveEmoji.js
@@ -0,0 +1,28 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class MessageReactionRemoveEmoji extends Action {
+  handle(data) {
+    const channel = this.getChannel(data);
+    if (!channel || channel.type === 'voice') return false;
+
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    const reaction = this.getReaction(data, message);
+    if (!reaction) return false;
+    if (!message.partial) message.reactions.cache.delete(reaction.emoji.id || reaction.emoji.name);
+
+    /**
+     * Emitted when a bot removes an emoji reaction from a cached message.
+     * @event Client#messageReactionRemoveEmoji
+     * @param {MessageReaction} reaction The reaction that was removed
+     */
+    this.client.emit(Events.MESSAGE_REACTION_REMOVE_EMOJI, reaction);
+    return { reaction };
+  }
+}
+
+module.exports = MessageReactionRemoveEmoji;
diff --git a/src/client/actions/MessageUpdate.js b/src/client/actions/MessageUpdate.js
index 4fbdce4e..07e2aacb 100644
--- a/src/client/actions/MessageUpdate.js
+++ b/src/client/actions/MessageUpdate.js
@@ -1,12 +1,13 @@
+'use strict';
+
 const Action = require('./Action');
 
 class MessageUpdateAction extends Action {
   handle(data) {
-    const client = this.client;
-
-    const channel = client.channels.get(data.channel_id);
+    const channel = this.getChannel(data);
     if (channel) {
-      const message = channel.messages.get(data.id);
+      const { id, channel_id, guild_id, author, timestamp, type } = data;
+      const message = this.getMessage({ id, channel_id, guild_id, author, timestamp, type }, channel);
       if (message) {
         message.patch(data);
         return {
diff --git a/src/client/actions/PresenceUpdate.js b/src/client/actions/PresenceUpdate.js
new file mode 100644
index 00000000..f74fbeb5
--- /dev/null
+++ b/src/client/actions/PresenceUpdate.js
@@ -0,0 +1,44 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class PresenceUpdateAction extends Action {
+  handle(data) {
+    let user = this.client.users.cache.get(data.user.id);
+    if (!user && data.user.username) user = this.client.users.add(data.user);
+    if (!user) return;
+
+    if (data.user && data.user.username) {
+      if (!user.equals(data.user)) this.client.actions.UserUpdate.handle(data.user);
+    }
+
+    const guild = this.client.guilds.cache.get(data.guild_id);
+    if (!guild) return;
+
+    let oldPresence = guild.presences.cache.get(user.id);
+    if (oldPresence) oldPresence = oldPresence._clone();
+    let member = guild.members.cache.get(user.id);
+    if (!member && data.status !== 'offline') {
+      member = guild.members.add({
+        user,
+        roles: data.roles,
+        deaf: false,
+        mute: false,
+      });
+      this.client.emit(Events.GUILD_MEMBER_AVAILABLE, member);
+    }
+    guild.presences.add(Object.assign(data, { guild }));
+    if (member && this.client.listenerCount(Events.PRESENCE_UPDATE)) {
+      /**
+       * Emitted whenever a guild member's presence (e.g. status, activity) is changed.
+       * @event Client#presenceUpdate
+       * @param {?Presence} oldPresence The presence before the update, if one at all
+       * @param {Presence} newPresence The presence after the update
+       */
+      this.client.emit(Events.PRESENCE_UPDATE, oldPresence, member.presence);
+    }
+  }
+}
+
+module.exports = PresenceUpdateAction;
diff --git a/src/client/actions/UserUpdate.js b/src/client/actions/UserUpdate.js
index de796db2..7279ca7d 100644
--- a/src/client/actions/UserUpdate.js
+++ b/src/client/actions/UserUpdate.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Action = require('./Action');
 const { Events } = require('../../util/Constants');
 
@@ -5,19 +7,20 @@ class UserUpdateAction extends Action {
   handle(data) {
     const client = this.client;
 
-    if (client.user) {
-      if (client.user.equals(data)) {
-        return {
-          old: client.user,
-          updated: client.user,
-        };
-      }
+    const newUser = client.users.cache.get(data.id);
+    const oldUser = newUser._update(data);
 
-      const oldUser = client.user._update(data);
-      client.emit(Events.USER_UPDATE, oldUser, client.user);
+    if (!oldUser.equals(newUser)) {
+      /**
+       * Emitted whenever a user's details (e.g. username) are changed.
+       * @event Client#userUpdate
+       * @param {User} oldUser The user before the update
+       * @param {User} newUser The user after the update
+       */
+      client.emit(Events.USER_UPDATE, oldUser, newUser);
       return {
         old: oldUser,
-        updated: client.user,
+        updated: newUser,
       };
     }
 
diff --git a/src/client/actions/VoiceStateUpdate.js b/src/client/actions/VoiceStateUpdate.js
new file mode 100644
index 00000000..6f2ee9dd
--- /dev/null
+++ b/src/client/actions/VoiceStateUpdate.js
@@ -0,0 +1,44 @@
+'use strict';
+
+const Action = require('./Action');
+const VoiceState = require('../../structures/VoiceState');
+const { Events } = require('../../util/Constants');
+
+class VoiceStateUpdate extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      // Update the state
+      const oldState = guild.voiceStates.cache.has(data.user_id)
+        ? guild.voiceStates.cache.get(data.user_id)._clone()
+        : new VoiceState(guild, { user_id: data.user_id });
+
+      const newState = guild.voiceStates.add(data);
+
+      // Get the member
+      let member = guild.members.cache.get(data.user_id);
+      if (member && data.member) {
+        member._patch(data.member);
+      } else if (data.member && data.member.user && data.member.joined_at) {
+        member = guild.members.add(data.member);
+      }
+
+      // Emit event
+      if (member && member.user.id === client.user.id) {
+        client.emit('debug', `[VOICE] received voice state update: ${JSON.stringify(data)}`);
+        client.voice.onVoiceStateUpdate(data);
+      }
+
+      /**
+       * Emitted whenever a member changes voice state - e.g. joins/leaves a channel, mutes/unmutes.
+       * @event Client#voiceStateUpdate
+       * @param {VoiceState} oldState The voice state before the update
+       * @param {VoiceState} newState The voice state after the update
+       */
+      client.emit(Events.VOICE_STATE_UPDATE, oldState, newState);
+    }
+  }
+}
+
+module.exports = VoiceStateUpdate;
diff --git a/src/client/actions/WebhooksUpdate.js b/src/client/actions/WebhooksUpdate.js
new file mode 100644
index 00000000..fdf9c56d
--- /dev/null
+++ b/src/client/actions/WebhooksUpdate.js
@@ -0,0 +1,19 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class WebhooksUpdate extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+    /**
+     * Emitted whenever a guild text channel has its webhooks changed.
+     * @event Client#webhookUpdate
+     * @param {TextChannel} channel The channel that had a webhook update
+     */
+    if (channel) client.emit(Events.WEBHOOKS_UPDATE, channel);
+  }
+}
+
+module.exports = WebhooksUpdate;
diff --git a/src/client/voice/ClientVoiceManager.js b/src/client/voice/ClientVoiceManager.js
index d55a809f..1eab8089 100644
--- a/src/client/voice/ClientVoiceManager.js
+++ b/src/client/voice/ClientVoiceManager.js
@@ -1,19 +1,22 @@
-const Collection = require('../../util/Collection');
-const { VoiceStatus } = require('../../util/Constants');
+'use strict';
+
+const VoiceBroadcast = require('./VoiceBroadcast');
 const VoiceConnection = require('./VoiceConnection');
 const { Error } = require('../../errors');
+const Collection = require('../../util/Collection');
 
 /**
- * Manages all the voice stuff for the client.
- * @private
+ * Manages voice connections for the client
  */
 class ClientVoiceManager {
   constructor(client) {
     /**
      * The client that instantiated this voice manager
      * @type {Client}
+     * @readonly
+     * @name ClientVoiceManager#client
      */
-    this.client = client;
+    Object.defineProperty(this, 'client', { value: client });
 
     /**
      * A collection mapping connection IDs to the Connection objects
@@ -21,23 +24,39 @@ class ClientVoiceManager {
      */
     this.connections = new Collection();
 
-    this.client.on('self.voiceServer', this.onVoiceServer.bind(this));
-    this.client.on('self.voiceStateUpdate', this.onVoiceStateUpdate.bind(this));
+    /**
+     * Active voice broadcasts that have been created
+     * @type {VoiceBroadcast[]}
+     */
+    this.broadcasts = [];
+  }
+
+  /**
+   * Creates a voice broadcast.
+   * @returns {VoiceBroadcast}
+   */
+  createBroadcast() {
+    const broadcast = new VoiceBroadcast(this.client);
+    this.broadcasts.push(broadcast);
+    return broadcast;
   }
 
   onVoiceServer({ guild_id, token, endpoint }) {
+    this.client.emit('debug', `[VOICE] voiceServer guild: ${guild_id} token: ${token} endpoint: ${endpoint}`);
     const connection = this.connections.get(guild_id);
     if (connection) connection.setTokenAndEndpoint(token, endpoint);
   }
 
   onVoiceStateUpdate({ guild_id, session_id, channel_id }) {
     const connection = this.connections.get(guild_id);
+    this.client.emit('debug', `[VOICE] connection? ${!!connection}, ${guild_id} ${session_id} ${channel_id}`);
     if (!connection) return;
-    if (!channel_id && connection.status !== VoiceStatus.DISCONNECTED) {
+    if (!channel_id) {
       connection._disconnect();
+      this.connections.delete(guild_id);
       return;
     }
-    connection.channel = this.client.channels.get(channel_id);
+    connection.channel = this.client.channels.cache.get(channel_id);
     connection.setSessionID(session_id);
   }
 
@@ -45,6 +64,7 @@ class ClientVoiceManager {
    * Sets up a request to join a voice channel.
    * @param {VoiceChannel} channel The voice channel to join
    * @returns {Promise<VoiceConnection>}
+   * @private
    */
   joinChannel(channel) {
     return new Promise((resolve, reject) => {
@@ -62,6 +82,10 @@ class ClientVoiceManager {
         return;
       } else {
         connection = new VoiceConnection(this, channel);
+        connection.on('debug', msg =>
+          this.client.emit('debug', `[VOICE (${channel.guild.id}:${connection.status})]: ${msg}`),
+        );
+        connection.authenticate();
         this.connections.set(channel.guild.id, connection);
       }
 
@@ -70,12 +94,13 @@ class ClientVoiceManager {
         reject(reason);
       });
 
+      connection.on('error', reject);
+
       connection.once('authenticated', () => {
         connection.once('ready', () => {
           resolve(connection);
           connection.removeListener('error', reject);
         });
-        connection.on('error', reject);
         connection.once('disconnect', () => this.connections.delete(channel.guild.id));
       });
     });
diff --git a/src/client/voice/VoiceBroadcast.js b/src/client/voice/VoiceBroadcast.js
index 1bc4e282..f84e6682 100644
--- a/src/client/voice/VoiceBroadcast.js
+++ b/src/client/voice/VoiceBroadcast.js
@@ -1,17 +1,19 @@
+'use strict';
+
 const EventEmitter = require('events');
 const BroadcastAudioPlayer = require('./player/BroadcastAudioPlayer');
-const DispatcherSet = require('./util/DispatcherSet');
 const PlayInterface = require('./util/PlayInterface');
+const { Events } = require('../../util/Constants');
 
 /**
  * A voice broadcast can be played across multiple voice connections for improved shared-stream efficiency.
  *
  * Example usage:
  * ```js
- * const broadcast = client.createVoiceBroadcast();
+ * const broadcast = client.voice.createBroadcast();
  * broadcast.play('./music.mp3');
  * // Play "music.mp3" in all voice connections that the client is in
- * for (const connection of client.voiceConnections.values()) {
+ * for (const connection of client.voice.connections.values()) {
  *   connection.play(broadcast);
  * }
  * ```
@@ -25,13 +27,18 @@ class VoiceBroadcast extends EventEmitter {
      * @type {Client}
      */
     this.client = client;
-    this.dispatchers = new DispatcherSet(this);
+    /**
+     * The subscribed StreamDispatchers of this broadcast
+     * @type {StreamDispatcher[]}
+     */
+    this.subscribers = [];
     this.player = new BroadcastAudioPlayer(this);
   }
 
   /**
    * The current master dispatcher, if any. This dispatcher controls all that is played by subscribed dispatchers.
    * @type {?BroadcastDispatcher}
+   * @readonly
    */
   get dispatcher() {
     return this.player.dispatcher;
@@ -52,7 +59,50 @@ class VoiceBroadcast extends EventEmitter {
    * broadcast.play('http://www.sample-videos.com/audio/mp3/wave.mp3');
    * @returns {BroadcastDispatcher}
    */
-  play() { return null; }
+  play() {
+    return null;
+  }
+
+  /**
+   * Ends the broadcast, unsubscribing all subscribed channels and deleting the broadcast
+   */
+  end() {
+    for (const dispatcher of this.subscribers) this.delete(dispatcher);
+    const index = this.client.voice.broadcasts.indexOf(this);
+    if (index !== -1) this.client.voice.broadcasts.splice(index, 1);
+  }
+
+  add(dispatcher) {
+    const index = this.subscribers.indexOf(dispatcher);
+    if (index === -1) {
+      this.subscribers.push(dispatcher);
+      /**
+       * Emitted whenever a stream dispatcher subscribes to the broadcast.
+       * @event VoiceBroadcast#subscribe
+       * @param {StreamDispatcher} subscriber The subscribed dispatcher
+       */
+      this.emit(Events.VOICE_BROADCAST_SUBSCRIBE, dispatcher);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  delete(dispatcher) {
+    const index = this.subscribers.indexOf(dispatcher);
+    if (index !== -1) {
+      this.subscribers.splice(index, 1);
+      dispatcher.destroy();
+      /**
+       * Emitted whenever a stream dispatcher unsubscribes to the broadcast.
+       * @event VoiceBroadcast#unsubscribe
+       * @param {StreamDispatcher} dispatcher The unsubscribed dispatcher
+       */
+      this.emit(Events.VOICE_BROADCAST_UNSUBSCRIBE, dispatcher);
+      return true;
+    }
+    return false;
+  }
 }
 
 PlayInterface.applyToClass(VoiceBroadcast);
diff --git a/src/client/voice/VoiceConnection.js b/src/client/voice/VoiceConnection.js
index 9bec8150..465c5373 100644
--- a/src/client/voice/VoiceConnection.js
+++ b/src/client/voice/VoiceConnection.js
@@ -1,19 +1,26 @@
-const VoiceWebSocket = require('./networking/VoiceWebSocket');
+'use strict';
+
+const EventEmitter = require('events');
 const VoiceUDP = require('./networking/VoiceUDPClient');
-const Util = require('../../util/Util');
-const { OPCodes, VoiceOPCodes, VoiceStatus, Events } = require('../../util/Constants');
+const VoiceWebSocket = require('./networking/VoiceWebSocket');
 const AudioPlayer = require('./player/AudioPlayer');
 const VoiceReceiver = require('./receiver/Receiver');
-const EventEmitter = require('events');
-const { Error } = require('../../errors');
 const PlayInterface = require('./util/PlayInterface');
+const Silence = require('./util/Silence');
+const { Error } = require('../../errors');
+const { OPCodes, VoiceOPCodes, VoiceStatus, Events } = require('../../util/Constants');
 const Speaking = require('../../util/Speaking');
+const Util = require('../../util/Util');
 
-const SUPPORTED_MODES = [
-  'xsalsa20_poly1305_lite',
-  'xsalsa20_poly1305_suffix',
-  'xsalsa20_poly1305',
-];
+// Workaround for Discord now requiring silence to be sent before being able to receive audio
+class SingleSilence extends Silence {
+  _read() {
+    super._read();
+    this.push(null);
+  }
+}
+
+const SUPPORTED_MODES = ['xsalsa20_poly1305_lite', 'xsalsa20_poly1305_suffix', 'xsalsa20_poly1305'];
 
 /**
  * Represents a connection to a guild's voice server.
@@ -113,14 +120,13 @@ class VoiceConnection extends EventEmitter {
      * The voice receiver of this connection
      * @type {VoiceReceiver}
      */
-    this.receiver = null;
-
-    this.authenticate();
+    this.receiver = new VoiceReceiver(this);
   }
 
   /**
    * The client that instantiated this connection
    * @type {Client}
+   * @readonly
    */
   get client() {
     return this.voiceManager.client;
@@ -144,35 +150,54 @@ class VoiceConnection extends EventEmitter {
     if (this.speaking.equals(value)) return;
     if (this.status !== VoiceStatus.CONNECTED) return;
     this.speaking = new Speaking(value).freeze();
-    this.sockets.ws.sendPacket({
-      op: VoiceOPCodes.SPEAKING,
-      d: {
-        speaking: this.speaking.bitfield,
-        delay: 0,
-        ssrc: this.authentication.ssrc,
-      },
-    }).catch(e => {
-      this.emit('debug', e);
-    });
+    this.sockets.ws
+      .sendPacket({
+        op: VoiceOPCodes.SPEAKING,
+        d: {
+          speaking: this.speaking.bitfield,
+          delay: 0,
+          ssrc: this.authentication.ssrc,
+        },
+      })
+      .catch(e => {
+        this.emit('debug', e);
+      });
+  }
+
+  /**
+   * The voice state of this connection
+   * @type {VoiceState}
+   */
+  get voice() {
+    return this.channel.guild.voice;
   }
 
   /**
    * Sends a request to the main gateway to join a voice channel.
    * @param {Object} [options] The options to provide
+   * @returns {Promise<Shard>}
    * @private
    */
   sendVoiceStateUpdate(options = {}) {
-    options = Util.mergeDefault({
-      guild_id: this.channel.guild.id,
-      channel_id: this.channel.id,
-      self_mute: false,
-      self_deaf: false,
-    }, options);
+    options = Util.mergeDefault(
+      {
+        guild_id: this.channel.guild.id,
+        channel_id: this.channel.id,
+        self_mute: this.voice ? this.voice.selfMute : false,
+        self_deaf: this.voice ? this.voice.selfDeaf : false,
+      },
+      options,
+    );
 
-    this.client.ws.send({
-      op: OPCodes.VOICE_STATE_UPDATE,
-      d: options,
-    });
+    this.emit('debug', `Sending voice state update: ${JSON.stringify(options)}`);
+
+    return this.channel.guild.shard.send(
+      {
+        op: OPCodes.VOICE_STATE_UPDATE,
+        d: options,
+      },
+      true,
+    );
   }
 
   /**
@@ -183,6 +208,7 @@ class VoiceConnection extends EventEmitter {
    * @returns {void}
    */
   setTokenAndEndpoint(token, endpoint) {
+    this.emit('debug', `Token "${token}" and endpoint "${endpoint}"`);
     if (!endpoint) {
       // Signifies awaiting endpoint stage
       return;
@@ -194,6 +220,7 @@ class VoiceConnection extends EventEmitter {
     }
 
     endpoint = endpoint.match(/([^:]*)/)[0];
+    this.emit('debug', `Endpoint resolved as ${endpoint}`);
 
     if (!endpoint) {
       this.authenticateFailed('VOICE_INVALID_ENDPOINT');
@@ -215,6 +242,7 @@ class VoiceConnection extends EventEmitter {
    * @private
    */
   setSessionID(sessionID) {
+    this.emit('debug', `Setting sessionID ${sessionID} (stored as "${this.authentication.sessionID}")`);
     if (!sessionID) {
       this.authenticateFailed('VOICE_SESSION_ABSENT');
       return;
@@ -240,7 +268,7 @@ class VoiceConnection extends EventEmitter {
    */
   checkAuthenticated() {
     const { token, endpoint, sessionID } = this.authentication;
-
+    this.emit('debug', `Authenticated with sessionID ${sessionID}`);
     if (token && endpoint && sessionID) {
       this.status = VoiceStatus.CONNECTING;
       /**
@@ -258,7 +286,8 @@ class VoiceConnection extends EventEmitter {
    * @private
    */
   authenticateFailed(reason) {
-    clearTimeout(this.connectTimeout);
+    this.client.clearTimeout(this.connectTimeout);
+    this.emit('debug', `Authenticate failed - ${reason}`);
     if (this.status === VoiceStatus.AUTHENTICATING) {
       /**
        * Emitted when we fail to initiate a voice connection.
@@ -293,8 +322,7 @@ class VoiceConnection extends EventEmitter {
    */
   authenticate() {
     this.sendVoiceStateUpdate();
-    this.connectTimeout = this.client.setTimeout(
-      () => this.authenticateFailed('VOICE_CONNECTION_TIMEOUT'), 15000);
+    this.connectTimeout = this.client.setTimeout(() => this.authenticateFailed('VOICE_CONNECTION_TIMEOUT'), 15000);
   }
 
   /**
@@ -308,6 +336,7 @@ class VoiceConnection extends EventEmitter {
     this.authentication.endpoint = endpoint;
     this.speaking = new Speaking().freeze();
     this.status = VoiceStatus.RECONNECTING;
+    this.emit('debug', `Reconnecting to ${endpoint}`);
     /**
      * Emitted when the voice connection is reconnecting (typically after a region change).
      * @event VoiceConnection#reconnecting
@@ -321,7 +350,8 @@ class VoiceConnection extends EventEmitter {
    */
   disconnect() {
     this.emit('closing');
-    clearTimeout(this.connectTimeout);
+    this.emit('debug', 'disconnect() triggered');
+    this.client.clearTimeout(this.connectTimeout);
     const conn = this.voiceManager.connections.get(this.channel.guild.id);
     if (conn === this) this.voiceManager.connections.delete(this.channel.guild.id);
     this.sendVoiceStateUpdate({
@@ -344,7 +374,6 @@ class VoiceConnection extends EventEmitter {
     this.emit('disconnect');
   }
 
-
   /**
    * Cleans up after disconnect.
    * @private
@@ -354,11 +383,14 @@ class VoiceConnection extends EventEmitter {
     this.speaking = new Speaking().freeze();
     const { ws, udp } = this.sockets;
 
+    this.emit('debug', 'Connection clean up');
+
     if (ws) {
       ws.removeAllListeners('error');
       ws.removeAllListeners('ready');
       ws.removeAllListeners('sessionDescription');
       ws.removeAllListeners('speaking');
+      ws.shutdown();
     }
 
     if (udp) udp.removeAllListeners('error');
@@ -372,6 +404,7 @@ class VoiceConnection extends EventEmitter {
    * @private
    */
   connect() {
+    this.emit('debug', `Connect triggered`);
     if (this.status !== VoiceStatus.RECONNECTING) {
       if (this.sockets.ws) throw new Error('WS_CONNECTION_EXISTS');
       if (this.sockets.udp) throw new Error('UDP_CONNECTION_EXISTS');
@@ -385,11 +418,15 @@ class VoiceConnection extends EventEmitter {
 
     const { ws, udp } = this.sockets;
 
+    ws.on('debug', msg => this.emit('debug', msg));
+    udp.on('debug', msg => this.emit('debug', msg));
     ws.on('error', err => this.emit('error', err));
     udp.on('error', err => this.emit('error', err));
     ws.on('ready', this.onReady.bind(this));
     ws.on('sessionDescription', this.onSessionDescription.bind(this));
-    ws.on('speaking', this.onSpeaking.bind(this));
+    ws.on('startSpeaking', this.onStartSpeaking.bind(this));
+
+    this.sockets.ws.connect();
   }
 
   /**
@@ -398,7 +435,7 @@ class VoiceConnection extends EventEmitter {
    * @private
    */
   onReady(data) {
-    this.authentication = data;
+    Object.assign(this.authentication, data);
     for (let mode of data.modes) {
       if (SUPPORTED_MODES.includes(mode)) {
         this.authentication.mode = mode;
@@ -417,14 +454,27 @@ class VoiceConnection extends EventEmitter {
   onSessionDescription(data) {
     Object.assign(this.authentication, data);
     this.status = VoiceStatus.CONNECTED;
-    clearTimeout(this.connectTimeout);
-    this.receiver = new VoiceReceiver(this);
-    /**
-     * Emitted once the connection is ready, when a promise to join a voice channel resolves,
-     * the connection will already be ready.
-     * @event VoiceConnection#ready
-     */
-    this.emit('ready');
+    const ready = () => {
+      this.client.clearTimeout(this.connectTimeout);
+      this.emit('debug', `Ready with authentication details: ${JSON.stringify(this.authentication)}`);
+      /**
+       * Emitted once the connection is ready, when a promise to join a voice channel resolves,
+       * the connection will already be ready.
+       * @event VoiceConnection#ready
+       */
+      this.emit('ready');
+    };
+    if (this.dispatcher) {
+      ready();
+    } else {
+      // This serves to provide support for voice receive, sending audio is required to receive it.
+      const dispatcher = this.play(new SingleSilence(), { type: 'opus' });
+      dispatcher.once('finish', ready);
+    }
+  }
+
+  onStartSpeaking({ user_id, ssrc, speaking }) {
+    this.ssrcMap.set(+ssrc, { userID: user_id, speaking: speaking });
   }
 
   /**
@@ -432,11 +482,10 @@ class VoiceConnection extends EventEmitter {
    * @param {Object} data The received data
    * @private
    */
-  onSpeaking({ user_id, ssrc, speaking }) {
+  onSpeaking({ user_id, speaking }) {
     speaking = new Speaking(speaking).freeze();
     const guild = this.channel.guild;
-    const user = this.client.users.get(user_id);
-    this.ssrcMap.set(+ssrc, user_id);
+    const user = this.client.users.cache.get(user_id);
     const old = this._speaking.get(user_id);
     this._speaking.set(user_id, speaking);
     /**
diff --git a/src/client/voice/dispatcher/BroadcastDispatcher.js b/src/client/voice/dispatcher/BroadcastDispatcher.js
index 90cff6a4..ae8d412e 100644
--- a/src/client/voice/dispatcher/BroadcastDispatcher.js
+++ b/src/client/voice/dispatcher/BroadcastDispatcher.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const StreamDispatcher = require('./StreamDispatcher');
 
 /**
@@ -13,7 +15,7 @@ class BroadcastDispatcher extends StreamDispatcher {
 
   _write(chunk, enc, done) {
     if (!this.startTime) this.startTime = Date.now();
-    for (const dispatcher of this.broadcast.dispatchers) {
+    for (const dispatcher of this.broadcast.subscribers) {
       dispatcher._write(chunk, enc);
     }
     this._step(done);
@@ -27,6 +29,12 @@ class BroadcastDispatcher extends StreamDispatcher {
     super._destroy(err, cb);
   }
 
+  /**
+   * Set the bitrate of the current Opus encoder if using a compatible Opus stream.
+   * @param {number} value New bitrate, in kbps
+   * If set to 'auto', 48kbps will be used
+   * @returns {boolean} true if the bitrate has been successfully changed.
+   */
   setBitrate(value) {
     if (!value || !this.streams.opus || !this.streams.opus.setBitrate) return false;
     const bitrate = value === 'auto' ? 48 : value;
diff --git a/src/client/voice/dispatcher/StreamDispatcher.js b/src/client/voice/dispatcher/StreamDispatcher.js
index 7bb0ef1b..62c46d37 100644
--- a/src/client/voice/dispatcher/StreamDispatcher.js
+++ b/src/client/voice/dispatcher/StreamDispatcher.js
@@ -1,14 +1,15 @@
-const VolumeInterface = require('../util/VolumeInterface');
-const { Writable } = require('stream');
+'use strict';
 
+const { Writable } = require('stream');
 const secretbox = require('../util/Secretbox');
 const Silence = require('../util/Silence');
+const VolumeInterface = require('../util/VolumeInterface');
 
 const FRAME_LENGTH = 20;
 const CHANNELS = 2;
 const TIMESTAMP_INC = (48000 / 100) * CHANNELS;
 
-const MAX_NONCE_SIZE = (2 ** 32) - 1;
+const MAX_NONCE_SIZE = 2 ** 32 - 1;
 const nonce = Buffer.alloc(24);
 
 /**
@@ -29,11 +30,8 @@ const nonce = Buffer.alloc(24);
  * @extends {WritableStream}
  */
 class StreamDispatcher extends Writable {
-  constructor(
-    player,
-    { seek = 0, volume = 1, passes = 1, fec, plp, bitrate = 96, highWaterMark = 12 } = {},
-    streams) {
-    const streamOptions = { seek, volume, passes, fec, plp, bitrate, highWaterMark };
+  constructor(player, { seek = 0, volume = 1, fec, plp, bitrate = 96, highWaterMark = 12 } = {}, streams) {
+    const streamOptions = { seek, volume, fec, plp, bitrate, highWaterMark };
     super(streamOptions);
     /**
      * The Audio Player that controls this dispatcher
@@ -65,15 +63,14 @@ class StreamDispatcher extends Writable {
     this.count = 0;
 
     this.on('finish', () => {
-      // Still emitting end for backwards compatibility, probably remove it in the future!
-      this.emit('end');
+      this._cleanup();
       this._setSpeaking(0);
     });
 
-    if (typeof volume !== 'undefined') this.setVolume(volume);
+    this.setVolume(volume);
+    this.setBitrate(bitrate);
     if (typeof fec !== 'undefined') this.setFEC(fec);
     if (typeof plp !== 'undefined') this.setPLP(plp);
-    if (typeof bitrate !== 'undefined') this.setBitrate(bitrate);
 
     const streamError = (type, err) => {
       /**
@@ -112,12 +109,16 @@ class StreamDispatcher extends Writable {
   }
 
   _destroy(err, cb) {
+    this._cleanup();
+    super._destroy(err, cb);
+  }
+
+  _cleanup() {
     if (this.player.dispatcher === this) this.player.dispatcher = null;
     const { streams } = this;
-    if (streams.broadcast) streams.broadcast.dispatchers.delete(this);
-    if (streams.opus) streams.opus.unpipe(this);
+    if (streams.broadcast) streams.broadcast.delete(this);
+    if (streams.opus) streams.opus.destroy();
     if (streams.ffmpeg) streams.ffmpeg.destroy();
-    super._destroy(err, cb);
   }
 
   /**
@@ -139,12 +140,16 @@ class StreamDispatcher extends Writable {
   /**
    * Whether or not playback is paused
    * @type {boolean}
+   * @readonly
    */
-  get paused() { return Boolean(this.pausedSince); }
+  get paused() {
+    return Boolean(this.pausedSince);
+  }
 
   /**
-   * Total time that this dispatcher has been paused
+   * Total time that this dispatcher has been paused in milliseconds
    * @type {number}
+   * @readonly
    */
   get pausedTime() {
     return this._silentPausedTime + this._pausedTime + (this.paused ? Date.now() - this.pausedSince : 0);
@@ -170,6 +175,7 @@ class StreamDispatcher extends Writable {
   /**
    * The time (in milliseconds) that the dispatcher has actually been playing audio for
    * @type {number}
+   * @readonly
    */
   get streamTime() {
     return this.count * FRAME_LENGTH;
@@ -178,6 +184,7 @@ class StreamDispatcher extends Writable {
   /**
    * The time (in milliseconds) that the dispatcher has been playing audio for, taking into account skips and pauses
    * @type {number}
+   * @readonly
    */
   get totalStreamTime() {
     return Date.now() - this.startTime;
@@ -224,7 +231,7 @@ class StreamDispatcher extends Writable {
       done();
     };
     if (!this.streams.broadcast) {
-      const next = FRAME_LENGTH + (this.count * FRAME_LENGTH) - (Date.now() - this.startTime - this._pausedTime);
+      const next = FRAME_LENGTH + this.count * FRAME_LENGTH - (Date.now() - this.startTime - this._pausedTime);
       setTimeout(() => {
         if ((!this.pausedSince || this._silence) && this._writeCallback) this._writeCallback();
       }, next);
@@ -252,10 +259,7 @@ class StreamDispatcher extends Writable {
       this._nonce++;
       if (this._nonce > MAX_NONCE_SIZE) this._nonce = 0;
       this._nonceBuffer.writeUInt32BE(this._nonce, 0);
-      return [
-        secretbox.methods.close(buffer, this._nonceBuffer, secret_key),
-        this._nonceBuffer.slice(0, 4),
-      ];
+      return [secretbox.methods.close(buffer, this._nonceBuffer, secret_key), this._nonceBuffer.slice(0, 4)];
     } else if (mode === 'xsalsa20_poly1305_suffix') {
       const random = secretbox.methods.random(24);
       return [secretbox.methods.close(buffer, random, secret_key), random];
@@ -278,24 +282,20 @@ class StreamDispatcher extends Writable {
   }
 
   _sendPacket(packet) {
-    let repeats = this.streamOptions.passes;
     /**
      * Emitted whenever the dispatcher has debug information.
      * @event StreamDispatcher#debug
      * @param {string} info The debug info
      */
     this._setSpeaking(1);
-    while (repeats--) {
-      if (!this.player.voiceConnection.sockets.udp) {
-        this.emit('debug', 'Failed to send a packet - no UDP socket');
-        return;
-      }
-      this.player.voiceConnection.sockets.udp.send(packet)
-        .catch(e => {
-          this._setSpeaking(0);
-          this.emit('debug', `Failed to send a packet - ${e}`);
-        });
+    if (!this.player.voiceConnection.sockets.udp) {
+      this.emit('debug', 'Failed to send a packet - no UDP socket');
+      return;
     }
+    this.player.voiceConnection.sockets.udp.send(packet).catch(e => {
+      this._setSpeaking(0);
+      this.emit('debug', `Failed to send a packet - ${e}`);
+    });
   }
 
   _setSpeaking(value) {
@@ -310,13 +310,18 @@ class StreamDispatcher extends Writable {
     this.emit('speaking', value);
   }
 
-  get volumeEditable() { return Boolean(this.streams.volume); }
+  get volumeEditable() {
+    return Boolean(this.streams.volume);
+  }
 
   /**
    * Whether or not the Opus bitrate of this stream is editable
    * @type {boolean}
+   * @readonly
    */
-  get bitrateEditable() { return this.streams.opus && this.streams.opus.setBitrate; }
+  get bitrateEditable() {
+    return this.streams.opus && this.streams.opus.setBitrate;
+  }
 
   // Volume
   get volume() {
diff --git a/src/client/voice/networking/VoiceUDPClient.js b/src/client/voice/networking/VoiceUDPClient.js
index f8668be4..b86428ae 100644
--- a/src/client/voice/networking/VoiceUDPClient.js
+++ b/src/client/voice/networking/VoiceUDPClient.js
@@ -1,7 +1,9 @@
+'use strict';
+
 const udp = require('dgram');
-const { VoiceOPCodes } = require('../../../util/Constants');
 const EventEmitter = require('events');
 const { Error } = require('../../../errors');
+const { VoiceOPCodes } = require('../../../util/Constants');
 
 /**
  * Represents a UDP client for a Voice Connection.
@@ -46,6 +48,7 @@ class VoiceConnectionUDPClient extends EventEmitter {
   }
 
   shutdown() {
+    this.emit('debug', `[UDP] shutdown requested`);
     if (this.socket) {
       this.socket.removeAllListeners('message');
       try {
@@ -75,21 +78,35 @@ class VoiceConnectionUDPClient extends EventEmitter {
       if (!this.socket) throw new Error('UDP_SEND_FAIL');
       if (!this.discordAddress || !this.discordPort) throw new Error('UDP_ADDRESS_MALFORMED');
       this.socket.send(packet, 0, packet.length, this.discordPort, this.discordAddress, error => {
-        if (error) reject(error); else resolve(packet);
+        if (error) {
+          this.emit('debug', `[UDP] >> ERROR: ${error}`);
+          reject(error);
+        } else {
+          resolve(packet);
+        }
       });
     });
   }
 
-  createUDPSocket(address) {
+  async createUDPSocket(address) {
     this.discordAddress = address;
-    const socket = this.socket = udp.createSocket('udp4');
-
+    const socket = (this.socket = udp.createSocket('udp4'));
+    socket.on('error', e => {
+      this.emit('debug', `[UDP] Error: ${e}`);
+      this.emit('error', e);
+    });
+    socket.on('close', () => {
+      this.emit('debug', '[UDP] socket closed');
+    });
+    this.emit('debug', `[UDP] created socket`);
     socket.once('message', message => {
+      this.emit('debug', `[UDP] message: [${[...message]}] (${message})`);
       // Stop if the sockets have been deleted because the connection has been closed already
       if (!this.voiceConnection.sockets.ws) return;
 
       const packet = parseLocalPacket(message);
       if (packet.error) {
+        this.emit('debug', `[UDP] ERROR: ${packet.error}`);
         this.emit('error', packet.error);
         return;
       }
@@ -108,11 +125,17 @@ class VoiceConnectionUDPClient extends EventEmitter {
           },
         },
       });
+
+      this.emit('debug', `[UDP] << ${JSON.stringify(packet)}`);
+
+      socket.on('message', buffer => this.voiceConnection.receiver.packets.push(buffer));
     });
 
     const blankMessage = Buffer.alloc(70);
     blankMessage.writeUIntBE(this.voiceConnection.authentication.ssrc, 0, 4);
-    this.send(blankMessage);
+    this.emit('debug', `Sending IP discovery packet: [${[...blankMessage]}]`);
+    await this.send(blankMessage);
+    this.emit('debug', `Successfully sent IP discovery packet`);
   }
 }
 
diff --git a/src/client/voice/networking/VoiceWebSocket.js b/src/client/voice/networking/VoiceWebSocket.js
index bd03ea54..efc97aff 100644
--- a/src/client/voice/networking/VoiceWebSocket.js
+++ b/src/client/voice/networking/VoiceWebSocket.js
@@ -1,7 +1,9 @@
-const { OPCodes, VoiceOPCodes } = require('../../../util/Constants');
+'use strict';
+
 const EventEmitter = require('events');
-const { Error } = require('../../../errors');
 const WebSocket = require('../../../WebSocket');
+const { Error } = require('../../../errors');
+const { OPCodes, VoiceOPCodes } = require('../../../util/Constants');
 
 /**
  * Represents a Voice Connection's WebSocket.
@@ -23,7 +25,6 @@ class VoiceWebSocket extends EventEmitter {
      */
     this.attempts = 0;
 
-    this.connect();
     this.dead = false;
     this.connection.on('closing', this.shutdown.bind(this));
   }
@@ -31,12 +32,14 @@ class VoiceWebSocket extends EventEmitter {
   /**
    * The client of this voice WebSocket
    * @type {Client}
+   * @readonly
    */
   get client() {
-    return this.connection.voiceManager.client;
+    return this.connection.client;
   }
 
   shutdown() {
+    this.emit('debug', `[WS] shutdown requested`);
     this.dead = true;
     this.reset();
   }
@@ -45,6 +48,7 @@ class VoiceWebSocket extends EventEmitter {
    * Resets the current WebSocket.
    */
   reset() {
+    this.emit('debug', `[WS] reset requested`);
     if (this.ws) {
       if (this.ws.readyState !== WebSocket.CLOSED) this.ws.close();
       this.ws = null;
@@ -56,6 +60,7 @@ class VoiceWebSocket extends EventEmitter {
    * Starts connecting to the Voice WebSocket Server.
    */
   connect() {
+    this.emit('debug', `[WS] connect requested`);
     if (this.dead) return;
     if (this.ws) this.reset();
     if (this.attempts >= 5) {
@@ -70,6 +75,7 @@ class VoiceWebSocket extends EventEmitter {
      * @type {WebSocket}
      */
     this.ws = WebSocket.create(`wss://${this.connection.authentication.endpoint}/`, { v: 4 });
+    this.emit('debug', `[WS] connecting, ${this.attempts} attempts, ${this.ws.url}`);
     this.ws.onopen = this.onOpen.bind(this);
     this.ws.onmessage = this.onMessage.bind(this);
     this.ws.onclose = this.onClose.bind(this);
@@ -82,10 +88,12 @@ class VoiceWebSocket extends EventEmitter {
    * @returns {Promise<string>}
    */
   send(data) {
+    this.emit('debug', `[WS] >> ${data}`);
     return new Promise((resolve, reject) => {
       if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error('WS_NOT_OPEN', data);
       this.ws.send(data, null, error => {
-        if (error) reject(error); else resolve(data);
+        if (error) reject(error);
+        else resolve(data);
       });
     });
   }
@@ -108,6 +116,7 @@ class VoiceWebSocket extends EventEmitter {
    * Called whenever the WebSocket opens.
    */
   onOpen() {
+    this.emit('debug', `[WS] opened at gateway ${this.connection.authentication.endpoint}`);
     this.sendPacket({
       op: OPCodes.DISPATCH,
       d: {
@@ -128,7 +137,7 @@ class VoiceWebSocket extends EventEmitter {
    */
   onMessage(event) {
     try {
-      return this.onPacket(WebSocket.unpack(event.data));
+      return this.onPacket(WebSocket.unpack(event.data, 'json'));
     } catch (error) {
       return this.onError(error);
     }
@@ -138,6 +147,7 @@ class VoiceWebSocket extends EventEmitter {
    * Called whenever the connection to the WebSocket server is lost.
    */
   onClose() {
+    this.emit('debug', `[WS] closed`);
     if (!this.dead) this.client.setTimeout(this.connect.bind(this), this.attempts * 1000);
   }
 
@@ -146,6 +156,7 @@ class VoiceWebSocket extends EventEmitter {
    * @param {Error} error The error that occurred
    */
   onError(error) {
+    this.emit('debug', `[WS] Error: ${error}`);
     this.emit('error', error);
   }
 
@@ -154,6 +165,7 @@ class VoiceWebSocket extends EventEmitter {
    * @param {Object} packet The received packet
    */
   onPacket(packet) {
+    this.emit('debug', `[WS] << ${JSON.stringify(packet)}`);
     switch (packet.op) {
       case VoiceOPCodes.HELLO:
         this.setHeartbeat(packet.d.heartbeat_interval);
@@ -190,9 +202,9 @@ class VoiceWebSocket extends EventEmitter {
         /**
          * Emitted whenever a speaking packet is received.
          * @param {Object} data
-         * @event VoiceWebSocket#speaking
+         * @event VoiceWebSocket#startSpeaking
          */
-        this.emit('speaking', packet.d);
+        this.emit('startSpeaking', packet.d);
         break;
       default:
         /**
@@ -221,7 +233,7 @@ class VoiceWebSocket extends EventEmitter {
        * @event VoiceWebSocket#warn
        */
       this.emit('warn', 'A voice heartbeat interval is being overwritten');
-      clearInterval(this.heartbeatInterval);
+      this.client.clearInterval(this.heartbeatInterval);
     }
     this.heartbeatInterval = this.client.setInterval(this.sendHeartbeat.bind(this), interval);
   }
@@ -234,7 +246,7 @@ class VoiceWebSocket extends EventEmitter {
       this.emit('warn', 'Tried to clear a heartbeat interval that does not exist');
       return;
     }
-    clearInterval(this.heartbeatInterval);
+    this.client.clearInterval(this.heartbeatInterval);
     this.heartbeatInterval = null;
   }
 
diff --git a/src/client/voice/player/AudioPlayer.js b/src/client/voice/player/AudioPlayer.js
index e3381f5c..6f719a73 100644
--- a/src/client/voice/player/AudioPlayer.js
+++ b/src/client/voice/player/AudioPlayer.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const BasePlayer = require('./BasePlayer');
 
 /**
@@ -17,7 +19,7 @@ class AudioPlayer extends BasePlayer {
 
   playBroadcast(broadcast, options) {
     const dispatcher = this.createDispatcher(options, { broadcast });
-    broadcast.dispatchers.add(dispatcher);
+    broadcast.add(dispatcher);
     return dispatcher;
   }
 }
diff --git a/src/client/voice/player/BasePlayer.js b/src/client/voice/player/BasePlayer.js
index e19984df..b968f82f 100644
--- a/src/client/voice/player/BasePlayer.js
+++ b/src/client/voice/player/BasePlayer.js
@@ -1,15 +1,11 @@
-const EventEmitter = require('events').EventEmitter;
+'use strict';
+
+const EventEmitter = require('events');
 const { Readable: ReadableStream } = require('stream');
 const prism = require('prism-media');
 const StreamDispatcher = require('../dispatcher/StreamDispatcher');
 
-const FFMPEG_ARGUMENTS = [
-  '-analyzeduration', '0',
-  '-loglevel', '0',
-  '-f', 's16le',
-  '-ar', '48000',
-  '-ac', '2',
-];
+const FFMPEG_ARGUMENTS = ['-analyzeduration', '0', '-loglevel', '0', '-f', 's16le', '-ar', '48000', '-ac', '2'];
 
 /**
  * An Audio Player for a Voice Connection.
@@ -46,7 +42,7 @@ class BasePlayer extends EventEmitter {
     const isStream = input instanceof ReadableStream;
 
     const args = isStream ? FFMPEG_ARGUMENTS.slice() : ['-i', input, ...FFMPEG_ARGUMENTS];
-    if (options.seek) args.push('-ss', String(options.seek));
+    if (options.seek) args.unshift('-ss', String(options.seek));
 
     const ffmpeg = new prism.FFmpeg({ args });
     const streams = { ffmpeg };
@@ -59,13 +55,13 @@ class BasePlayer extends EventEmitter {
 
   playPCMStream(stream, options, streams = {}) {
     this.destroyDispatcher();
-    const opus = streams.opus = new prism.opus.Encoder({ channels: 2, rate: 48000, frameSize: 960 });
+    const opus = (streams.opus = new prism.opus.Encoder({ channels: 2, rate: 48000, frameSize: 960 }));
     if (options && options.volume === false) {
       stream.pipe(opus);
       return this.playOpusStream(opus, options, streams);
     }
-    const volume = streams.volume = new prism.VolumeTransformer16LE({ volume: options ? options.volume : 1 });
-    stream.pipe(volume).pipe(opus);
+    streams.volume = new prism.VolumeTransformer({ type: 's16le', volume: options ? options.volume : 1 });
+    stream.pipe(streams.volume).pipe(opus);
     return this.playOpusStream(opus, options, streams);
   }
 
@@ -75,10 +71,10 @@ class BasePlayer extends EventEmitter {
     if (options.volume !== false && !streams.input) {
       streams.input = stream;
       const decoder = new prism.opus.Decoder({ channels: 2, rate: 48000, frameSize: 960 });
-      const volume = streams.volume = new prism.VolumeTransformer16LE({ volume: options ? options.volume : 1 });
+      streams.volume = new prism.VolumeTransformer({ type: 's16le', volume: options ? options.volume : 1 });
       streams.opus = stream
         .pipe(decoder)
-        .pipe(volume)
+        .pipe(streams.volume)
         .pipe(new prism.opus.Encoder({ channels: 2, rate: 48000, frameSize: 960 }));
     }
     const dispatcher = this.createDispatcher(options, streams);
@@ -88,7 +84,7 @@ class BasePlayer extends EventEmitter {
 
   createDispatcher(options, streams, broadcast) {
     this.destroyDispatcher();
-    const dispatcher = this.dispatcher = new StreamDispatcher(this, options, streams, broadcast);
+    const dispatcher = (this.dispatcher = new StreamDispatcher(this, options, streams, broadcast));
     return dispatcher;
   }
 }
diff --git a/src/client/voice/player/BroadcastAudioPlayer.js b/src/client/voice/player/BroadcastAudioPlayer.js
index 052c9ea0..05197a4f 100644
--- a/src/client/voice/player/BroadcastAudioPlayer.js
+++ b/src/client/voice/player/BroadcastAudioPlayer.js
@@ -1,5 +1,7 @@
-const BroadcastDispatcher = require('../dispatcher/BroadcastDispatcher');
+'use strict';
+
 const BasePlayer = require('./BasePlayer');
+const BroadcastDispatcher = require('../dispatcher/BroadcastDispatcher');
 
 /**
  * An Audio Player for a Voice Connection.
@@ -18,7 +20,7 @@ class AudioPlayer extends BasePlayer {
 
   createDispatcher(options, streams) {
     this.destroyDispatcher();
-    const dispatcher = this.dispatcher = new BroadcastDispatcher(this, options, streams);
+    const dispatcher = (this.dispatcher = new BroadcastDispatcher(this, options, streams));
     return dispatcher;
   }
 }
diff --git a/src/client/voice/receiver/PacketHandler.js b/src/client/voice/receiver/PacketHandler.js
index 1ea702c1..c441c5e0 100644
--- a/src/client/voice/receiver/PacketHandler.js
+++ b/src/client/voice/receiver/PacketHandler.js
@@ -1,7 +1,15 @@
-const secretbox = require('../util/Secretbox');
-const EventEmitter = require('events');
+'use strict';
 
-class Readable extends require('stream').Readable { _read() {} } // eslint-disable-line no-empty-function
+const EventEmitter = require('events');
+const secretbox = require('../util/Secretbox');
+
+// The delay between packets when a user is considered to have stopped speaking
+// https://github.com/discordjs/discord.js/issues/3524#issuecomment-540373200
+const DISCORD_SPEAKING_DELAY = 250;
+
+class Readable extends require('stream').Readable {
+  _read() {} // eslint-disable-line no-empty-function
+}
 
 class PacketHandler extends EventEmitter {
   constructor(receiver) {
@@ -9,6 +17,7 @@ class PacketHandler extends EventEmitter {
     this.nonce = Buffer.alloc(24);
     this.receiver = receiver;
     this.streams = new Map();
+    this.speakingTimeouts = new Map();
   }
 
   get connection() {
@@ -52,7 +61,7 @@ class PacketHandler extends EventEmitter {
     packet = Buffer.from(packet);
 
     // Strip RTP Header Extensions (one-byte only)
-    if (packet[0] === 0xBE && packet[1] === 0xDE && packet.length > 4) {
+    if (packet[0] === 0xbe && packet[1] === 0xde && packet.length > 4) {
       const headerExtensionLength = packet.readUInt16BE(2);
       let offset = 4;
       for (let i = 0; i < headerExtensionLength; i++) {
@@ -61,20 +70,38 @@ class PacketHandler extends EventEmitter {
         if (byte === 0) continue;
         offset += 1 + (0b1111 & (byte >> 4));
       }
-      while (packet[offset] === 0) offset++;
+      // Skip over undocumented Discord byte
+      offset++;
+
       packet = packet.slice(offset);
     }
 
     return packet;
   }
 
-  userFromSSRC(ssrc) { return this.connection.client.users.get(this.connection.ssrcMap.get(ssrc)); }
-
   push(buffer) {
     const ssrc = buffer.readUInt32BE(8);
-    const user = this.userFromSSRC(ssrc);
-    if (!user) return;
-    let stream = this.streams.get(user.id);
+    const userStat = this.connection.ssrcMap.get(ssrc);
+    if (!userStat) return;
+
+    let speakingTimeout = this.speakingTimeouts.get(ssrc);
+    if (typeof speakingTimeout === 'undefined') {
+      this.connection.onSpeaking({ user_id: userStat.userID, ssrc: ssrc, speaking: userStat.speaking });
+      speakingTimeout = this.receiver.connection.client.setTimeout(() => {
+        try {
+          this.connection.onSpeaking({ user_id: userStat.userID, ssrc: ssrc, speaking: 0 });
+          this.receiver.connection.client.clearTimeout(speakingTimeout);
+          this.speakingTimeouts.delete(ssrc);
+        } catch {
+          // Connection already closed, ignore
+        }
+      }, DISCORD_SPEAKING_DELAY);
+      this.speakingTimeouts.set(ssrc, speakingTimeout);
+    } else {
+      speakingTimeout.refresh();
+    }
+
+    let stream = this.streams.get(userStat.userID);
     if (!stream) return;
     stream = stream.stream;
     const opusPacket = this.parseBuffer(buffer);
diff --git a/src/client/voice/receiver/Receiver.js b/src/client/voice/receiver/Receiver.js
index 8b626be7..605d9927 100644
--- a/src/client/voice/receiver/Receiver.js
+++ b/src/client/voice/receiver/Receiver.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const EventEmitter = require('events');
 const prism = require('prism-media');
 const PacketHandler = require('./PacketHandler');
@@ -21,7 +23,6 @@ class VoiceReceiver extends EventEmitter {
      * @param {Error|string} error The error or message to debug
      */
     this.packets.on('error', err => this.emit('debug', err));
-    this.connection.sockets.udp.socket.on('message', buffer => this.packets.push(buffer));
   }
 
   /**
diff --git a/src/client/voice/util/DispatcherSet.js b/src/client/voice/util/DispatcherSet.js
deleted file mode 100644
index a1ab7e94..00000000
--- a/src/client/voice/util/DispatcherSet.js
+++ /dev/null
@@ -1,40 +0,0 @@
-const { Events } = require('../../../util/Constants');
-
-/**
- * A "store" for handling broadcast dispatcher (un)subscription
- * @private
- */
-class DispatcherSet extends Set {
-  constructor(broadcast) {
-    super();
-    /**
-     * The broadcast that this set belongs to
-     * @type {VoiceBroadcast}
-     */
-    this.broadcast = broadcast;
-  }
-
-  add(dispatcher) {
-    super.add(dispatcher);
-    /**
-     * Emitted whenever a stream dispatcher subscribes to the broadcast.
-     * @event VoiceBroadcast#subscribe
-     * @param {StreamDispatcher} dispatcher The subscribed dispatcher
-     */
-    this.broadcast.emit(Events.VOICE_BROADCAST_SUBSCRIBE, dispatcher);
-    return this;
-  }
-
-  delete(dispatcher) {
-    const ret = super.delete(dispatcher);
-    /**
-     * Emitted whenever a stream dispatcher unsubscribes to the broadcast.
-     * @event VoiceBroadcast#unsubscribe
-     * @param {StreamDispatcher} dispatcher The unsubscribed dispatcher
-     */
-    if (ret) this.broadcast.emit(Events.VOICE_BROADCAST_UNSUBSCRIBE, dispatcher);
-    return ret;
-  }
-}
-
-module.exports = DispatcherSet;
diff --git a/src/client/voice/util/PlayInterface.js b/src/client/voice/util/PlayInterface.js
index 58d31141..0b08272d 100644
--- a/src/client/voice/util/PlayInterface.js
+++ b/src/client/voice/util/PlayInterface.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const { Readable } = require('stream');
 const prism = require('prism-media');
 const { Error } = require('../../../errors');
@@ -9,7 +11,6 @@ const { Error } = require('../../../errors');
  * @property {number} [seek=0] The time to seek to, will be ignored when playing `ogg/opus` or `webm/opus` streams
  * @property {number|boolean} [volume=1] The volume to play at. Set this to false to disable volume transforms for
  * this stream to improve performance.
- * @property {number} [passes=1] How many times to send the voice packet to reduce packet loss
  * @property {number} [plp] Expected packet loss percentage
  * @property {boolean} [fec] Enabled forward error correction
  * @property {number|string} [bitrate=96] The bitrate (quality) of the audio in kbps.
@@ -73,10 +74,10 @@ class PlayInterface {
         return this.player.playOpusStream(resource, options);
       } else if (type === 'ogg/opus') {
         if (!(resource instanceof Readable)) throw new Error('VOICE_PRISM_DEMUXERS_NEED_STREAM');
-        return this.player.playOpusStream(resource.pipe(new prism.OggOpusDemuxer()), options);
+        return this.player.playOpusStream(resource.pipe(new prism.opus.OggDemuxer()), options);
       } else if (type === 'webm/opus') {
         if (!(resource instanceof Readable)) throw new Error('VOICE_PRISM_DEMUXERS_NEED_STREAM');
-        return this.player.playOpusStream(resource.pipe(new prism.WebmOpusDemuxer()), options);
+        return this.player.playOpusStream(resource.pipe(new prism.opus.WebmDemuxer()), options);
       }
     }
     throw new Error('VOICE_PLAY_INTERFACE_BAD_TYPE');
@@ -84,12 +85,12 @@ class PlayInterface {
 
   static applyToClass(structure) {
     for (const prop of ['play']) {
-      Object.defineProperty(structure.prototype, prop,
-        Object.getOwnPropertyDescriptor(PlayInterface.prototype, prop));
+      Object.defineProperty(structure.prototype, prop, Object.getOwnPropertyDescriptor(PlayInterface.prototype, prop));
     }
   }
 }
 
 module.exports = PlayInterface;
 
+// eslint-disable-next-line import/order
 const Broadcast = require('../VoiceBroadcast');
diff --git a/src/client/voice/util/Secretbox.js b/src/client/voice/util/Secretbox.js
index fe1eebe8..c16a4353 100644
--- a/src/client/voice/util/Secretbox.js
+++ b/src/client/voice/util/Secretbox.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const libs = {
   sodium: sodium => ({
     open: sodium.api.crypto_secretbox_open_easy,
@@ -25,6 +27,6 @@ exports.methods = {};
       if (libName === 'libsodium-wrappers' && lib.ready) await lib.ready; // eslint-disable-line no-await-in-loop
       exports.methods = libs[libName](lib);
       break;
-    } catch (err) {} // eslint-disable-line no-empty
+    } catch {} // eslint-disable-line no-empty
   }
 })();
diff --git a/src/client/voice/util/Silence.js b/src/client/voice/util/Silence.js
index b9643da1..9bea3d00 100644
--- a/src/client/voice/util/Silence.js
+++ b/src/client/voice/util/Silence.js
@@ -1,6 +1,8 @@
+'use strict';
+
 const { Readable } = require('stream');
 
-const SILENCE_FRAME = Buffer.from([0xF8, 0xFF, 0xFE]);
+const SILENCE_FRAME = Buffer.from([0xf8, 0xff, 0xfe]);
 
 class Silence extends Readable {
   _read() {
diff --git a/src/client/voice/util/VolumeInterface.js b/src/client/voice/util/VolumeInterface.js
index 95645f91..0dca04f1 100644
--- a/src/client/voice/util/VolumeInterface.js
+++ b/src/client/voice/util/VolumeInterface.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const EventEmitter = require('events');
 
 /**
@@ -13,6 +15,7 @@ class VolumeInterface extends EventEmitter {
   /**
    * Whether or not the volume of this stream is editable
    * @type {boolean}
+   * @readonly
    */
   get volumeEditable() {
     return true;
@@ -20,8 +23,8 @@ class VolumeInterface extends EventEmitter {
 
   /**
    * The current volume of the stream
-   * @readonly
    * @type {number}
+   * @readonly
    */
   get volume() {
     return this._volume;
@@ -29,8 +32,8 @@ class VolumeInterface extends EventEmitter {
 
   /**
    * The current volume of the stream in decibels
-   * @readonly
    * @type {number}
+   * @readonly
    */
   get volumeDecibels() {
     return Math.log10(this.volume) * 20;
@@ -38,8 +41,8 @@ class VolumeInterface extends EventEmitter {
 
   /**
    * The current volume of the stream from a logarithmic scale
-   * @readonly
    * @type {number}
+   * @readonly
    */
   get volumeLogarithmic() {
     return Math.pow(this.volume, 1 / 1.660964);
@@ -91,19 +94,10 @@ class VolumeInterface extends EventEmitter {
   }
 }
 
-const props = [
-  'volumeDecibels',
-  'volumeLogarithmic',
-  'setVolumeDecibels',
-  'setVolumeLogarithmic',
-];
+const props = ['volumeDecibels', 'volumeLogarithmic', 'setVolumeDecibels', 'setVolumeLogarithmic'];
 
 exports.applyToClass = function applyToClass(structure) {
   for (const prop of props) {
-    Object.defineProperty(
-      structure.prototype,
-      prop,
-      Object.getOwnPropertyDescriptor(VolumeInterface.prototype, prop)
-    );
+    Object.defineProperty(structure.prototype, prop, Object.getOwnPropertyDescriptor(VolumeInterface.prototype, prop));
   }
 };
diff --git a/src/client/websocket/WebSocketConnection.js b/src/client/websocket/WebSocketConnection.js
deleted file mode 100644
index 12e90075..00000000
--- a/src/client/websocket/WebSocketConnection.js
+++ /dev/null
@@ -1,488 +0,0 @@
-const EventEmitter = require('events');
-const { Events, OPCodes, Status, WSCodes } = require('../../util/Constants');
-const PacketManager = require('./packets/WebSocketPacketManager');
-const WebSocket = require('../../WebSocket');
-try {
-  var zlib = require('zlib-sync');
-  if (!zlib.Inflate) zlib = require('pako');
-} catch (err) {
-  zlib = require('pako');
-}
-
-/**
- * Abstracts a WebSocket connection with decoding/encoding for the Discord gateway.
- * @private
- */
-class WebSocketConnection extends EventEmitter {
-  /**
-   * @param {WebSocketManager} manager The WebSocket manager
-   * @param {string} gateway The WebSocket gateway to connect to
-   */
-  constructor(manager, gateway) {
-    super();
-    /**
-     * The WebSocket Manager of this connection
-     * @type {WebSocketManager}
-     */
-    this.manager = manager;
-
-    /**
-     * The client this belongs to
-     * @type {Client}
-     */
-    this.client = manager.client;
-
-    /**
-     * The WebSocket connection itself
-     * @type {WebSocket}
-     */
-    this.ws = null;
-
-    /**
-     * The current sequence of the WebSocket
-     * @type {number}
-     */
-    this.sequence = -1;
-
-    /**
-     * The current sessionID of the WebSocket
-     * @type {string}
-     */
-    this.sessionID = null;
-
-    /**
-     * The current status of the client
-     * @type {number}
-     */
-    this.status = Status.IDLE;
-
-    /**
-     * The Packet Manager of the connection
-     * @type {WebSocketPacketManager}
-     */
-    this.packetManager = new PacketManager(this);
-
-    /**
-     * The last time a ping was sent (a timestamp)
-     * @type {number}
-     */
-    this.lastPingTimestamp = 0;
-
-    /**
-     * Contains the rate limit queue and metadata
-     * @type {Object}
-     */
-    this.ratelimit = {
-      queue: [],
-      remaining: 120,
-      total: 120,
-      time: 60e3,
-      resetTimer: null,
-    };
-
-    /**
-     * Events that are disabled (will not be processed)
-     * @type {Object}
-     */
-    this.disabledEvents = {};
-    for (const event of this.client.options.disabledEvents) this.disabledEvents[event] = true;
-
-    /**
-     * The sequence on WebSocket close
-     * @type {number}
-     */
-    this.closeSequence = 0;
-
-    /**
-     * Whether or not the WebSocket is expecting to be closed
-     * @type {boolean}
-     */
-    this.expectingClose = false;
-
-    this.inflate = null;
-    this.connect(gateway);
-  }
-
-  /**
-   * Causes the client to be marked as ready and emits the ready event.
-   * @returns {void}
-   */
-  triggerReady() {
-    if (this.status === Status.READY) {
-      this.debug('Tried to mark self as ready, but already ready');
-      return;
-    }
-    /**
-     * Emitted when the client becomes ready to start working.
-     * @event Client#ready
-     */
-    this.status = Status.READY;
-    this.client.emit(Events.READY);
-    this.packetManager.handleQueue();
-  }
-
-  /**
-   * Checks whether the client is ready to be marked as ready.
-   * @returns {void}
-   */
-  checkIfReady() {
-    if (this.status === Status.READY || this.status === Status.NEARLY) return false;
-    let unavailableGuilds = 0;
-    for (const guild of this.client.guilds.values()) {
-      if (!guild.available) unavailableGuilds++;
-    }
-    if (unavailableGuilds === 0) {
-      this.status = Status.NEARLY;
-      if (!this.client.options.fetchAllMembers) return this.triggerReady();
-      // Fetch all members before marking self as ready
-      const promises = this.client.guilds.map(g => g.members.fetch());
-      Promise.all(promises)
-        .then(() => this.triggerReady())
-        .catch(e => {
-          this.debug(`Failed to fetch all members before ready! ${e}`);
-          this.triggerReady();
-        });
-    }
-    return true;
-  }
-
-  // Util
-  /**
-   * Emits a debug message.
-   * @param {string} message Debug message
-   * @returns {void}
-   */
-  debug(message) {
-    if (message instanceof Error) message = message.stack;
-    return this.manager.debug(`[connection] ${message}`);
-  }
-
-  /**
-   * Processes the current WebSocket queue.
-   */
-  processQueue() {
-    if (this.ratelimit.remaining === 0) return;
-    if (this.ratelimit.queue.length === 0) return;
-    if (this.ratelimit.remaining === this.ratelimit.total) {
-      this.ratelimit.resetTimer = this.client.setTimeout(() => {
-        this.ratelimit.remaining = this.ratelimit.total;
-        this.processQueue();
-      }, this.ratelimit.time);
-    }
-    while (this.ratelimit.remaining > 0) {
-      const item = this.ratelimit.queue.shift();
-      if (!item) return;
-      this._send(item);
-      this.ratelimit.remaining--;
-    }
-  }
-
-  /**
-   * Sends data, bypassing the queue.
-   * @param {Object} data Packet to send
-   * @returns {void}
-   */
-  _send(data) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      this.debug(`Tried to send packet ${data} but no WebSocket is available!`);
-      return;
-    }
-    this.ws.send(WebSocket.pack(data));
-  }
-
-  /**
-   * Adds data to the queue to be sent.
-   * @param {Object} data Packet to send
-   * @returns {void}
-   */
-  send(data) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      this.debug(`Tried to send packet ${data} but no WebSocket is available!`);
-      return;
-    }
-    this.ratelimit.queue.push(data);
-    this.processQueue();
-  }
-
-  /**
-   * Creates a connection to a gateway.
-   * @param {string} gateway The gateway to connect to
-   * @param {number} [after=0] How long to wait before connecting
-   * @param {boolean} [force=false] Whether or not to force a new connection even if one already exists
-   * @returns {boolean}
-   */
-  connect(gateway = this.gateway, after = 0, force = false) {
-    if (after) return this.client.setTimeout(() => this.connect(gateway, 0, force), after); // eslint-disable-line
-    if (this.ws && !force) {
-      this.debug('WebSocket connection already exists');
-      return false;
-    } else if (typeof gateway !== 'string') {
-      this.debug(`Tried to connect to an invalid gateway: ${gateway}`);
-      return false;
-    }
-    this.inflate = new zlib.Inflate({
-      chunkSize: 65535,
-      flush: zlib.Z_SYNC_FLUSH,
-      to: WebSocket.encoding === 'json' ? 'string' : '',
-    });
-    this.expectingClose = false;
-    this.gateway = gateway;
-    this.debug(`Connecting to ${gateway}`);
-    const ws = this.ws = WebSocket.create(gateway, {
-      v: this.client.options.ws.version,
-      compress: 'zlib-stream',
-    });
-    ws.onmessage = this.onMessage.bind(this);
-    ws.onopen = this.onOpen.bind(this);
-    ws.onerror = this.onError.bind(this);
-    ws.onclose = this.onClose.bind(this);
-    this.status = Status.CONNECTING;
-    return true;
-  }
-
-  /**
-   * Destroys the connection.
-   * @returns {boolean}
-   */
-  destroy() {
-    const ws = this.ws;
-    if (!ws) {
-      this.debug('Attempted to destroy WebSocket but no connection exists!');
-      return false;
-    }
-    this.heartbeat(-1);
-    this.expectingClose = true;
-    ws.close(1000);
-    this.packetManager.handleQueue();
-    this.ws = null;
-    this.status = Status.DISCONNECTED;
-    this.ratelimit.remaining = this.ratelimit.total;
-    return true;
-  }
-
-  /**
-   * Called whenever a message is received.
-   * @param {Event} event Event received
-   */
-  onMessage({ data }) {
-    if (data instanceof ArrayBuffer) data = new Uint8Array(data);
-    const l = data.length;
-    const flush = l >= 4 &&
-      data[l - 4] === 0x00 &&
-      data[l - 3] === 0x00 &&
-      data[l - 2] === 0xFF &&
-      data[l - 1] === 0xFF;
-
-    this.inflate.push(data, flush && zlib.Z_SYNC_FLUSH);
-    if (!flush) return;
-    let packet;
-    try {
-      packet = WebSocket.unpack(this.inflate.result);
-    } catch (err) {
-      this.client.emit('debug', err);
-      return;
-    }
-    this.onPacket(packet);
-    if (this.client.listenerCount('raw')) this.client.emit('raw', packet);
-  }
-
-  /**
-   * Sets the current sequence of the connection.
-   * @param {number} s New sequence
-   */
-  setSequence(s) {
-    this.sequence = s > this.sequence ? s : this.sequence;
-  }
-
-  /**
-   * Called whenever a packet is received.
-   * @param {Object} packet Received packet
-   * @returns {boolean}
-   */
-  onPacket(packet) {
-    if (!packet) {
-      this.debug('Received null packet');
-      return false;
-    }
-    switch (packet.op) {
-      case OPCodes.HELLO:
-        return this.heartbeat(packet.d.heartbeat_interval);
-      case OPCodes.RECONNECT:
-        return this.reconnect();
-      case OPCodes.INVALID_SESSION:
-        if (!packet.d) this.sessionID = null;
-        this.sequence = -1;
-        this.debug('Session invalidated -- will identify with a new session');
-        return this.identify(packet.d ? 2500 : 0);
-      case OPCodes.HEARTBEAT_ACK:
-        return this.ackHeartbeat();
-      case OPCodes.HEARTBEAT:
-        return this.heartbeat();
-      default:
-        return this.packetManager.handle(packet);
-    }
-  }
-
-  /**
-   * Called whenever a connection is opened to the gateway.
-   * @param {Event} event Received open event
-   */
-  onOpen(event) {
-    if (event && event.target && event.target.url) this.gateway = event.target.url;
-    this.debug(`Connected to gateway ${this.gateway}`);
-    this.identify();
-  }
-
-  /**
-   * Causes a reconnection to the gateway.
-   */
-  reconnect() {
-    this.debug('Attempting to reconnect in 5500ms...');
-    /**
-     * Emitted whenever the client tries to reconnect to the WebSocket.
-     * @event Client#reconnecting
-     */
-    this.client.emit(Events.RECONNECTING);
-    this.connect(this.gateway, 5500, true);
-  }
-
-  /**
-   * Called whenever an error occurs with the WebSocket.
-   * @param {Error} error The error that occurred
-   */
-  onError(error) {
-    if (error && error.message === 'uWs client connection error') {
-      this.reconnect();
-      return;
-    }
-    /**
-     * Emitted whenever the client's WebSocket encounters a connection error.
-     * @event Client#error
-     * @param {Error} error The encountered error
-     */
-    this.client.emit(Events.ERROR, error);
-  }
-
-  /**
-   * @external CloseEvent
-   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent}
-   */
-
-  /**
-   * Called whenever a connection to the gateway is closed.
-   * @param {CloseEvent} event Close event that was received
-   */
-  onClose(event) {
-    this.debug(`${this.expectingClose ? 'Client' : 'Server'} closed the WebSocket connection: ${event.code}`);
-    this.closeSequence = this.sequence;
-    // Reset the state before trying to fix anything
-    this.emit('close', event);
-    this.heartbeat(-1);
-    // Should we reconnect?
-    if (event.code === 1000 ? this.expectingClose : WSCodes[event.code]) {
-      this.expectingClose = false;
-      /**
-       * Emitted when the client's WebSocket disconnects and will no longer attempt to reconnect.
-       * @event Client#disconnect
-       * @param {CloseEvent} event The WebSocket close event
-       */
-      this.client.emit(Events.DISCONNECT, event);
-      this.debug(WSCodes[event.code]);
-      this.destroy();
-      return;
-    }
-    this.expectingClose = false;
-    this.reconnect();
-  }
-
-  // Heartbeat
-  /**
-   * Acknowledges a heartbeat.
-   */
-  ackHeartbeat() {
-    this.debug(`Heartbeat acknowledged, latency of ${Date.now() - this.lastPingTimestamp}ms`);
-    this.client._pong(this.lastPingTimestamp);
-  }
-
-  /**
-   * Sends a heartbeat or sets an interval for sending heartbeats.
-   * @param {number} [time] If -1, clears the interval, any other number sets an interval
-   * If no value is given, a heartbeat will be sent instantly
-   */
-  heartbeat(time) {
-    if (!isNaN(time)) {
-      if (time === -1) {
-        this.debug('Clearing heartbeat interval');
-        this.client.clearInterval(this.heartbeatInterval);
-        this.heartbeatInterval = null;
-      } else {
-        this.debug(`Setting a heartbeat interval for ${time}ms`);
-        this.heartbeatInterval = this.client.setInterval(() => this.heartbeat(), time);
-      }
-      return;
-    }
-    this.debug('Sending a heartbeat');
-    this.lastPingTimestamp = Date.now();
-    this.send({
-      op: OPCodes.HEARTBEAT,
-      d: this.sequence,
-    });
-  }
-
-  // Identification
-  /**
-   * Identifies the client on a connection.
-   * @param {number} [after] How long to wait before identifying
-   * @returns {void}
-   */
-  identify(after) {
-    if (after) return this.client.setTimeout(this.identify.bind(this), after);
-    return this.sessionID ? this.identifyResume() : this.identifyNew();
-  }
-
-  /**
-   * Identifies as a new connection on the gateway.
-   * @returns {void}
-   */
-  identifyNew() {
-    if (!this.client.token) {
-      this.debug('No token available to identify a new session with');
-      return;
-    }
-    // Clone the generic payload and assign the token
-    const d = Object.assign({ token: this.client.token }, this.client.options.ws);
-
-    // Sharding stuff
-    const { shardId, shardCount } = this.client.options;
-    if (shardCount > 0) d.shard = [Number(shardId), Number(shardCount)];
-
-    // Send the payload
-    this.debug('Identifying as a new session');
-    this.send({ op: OPCodes.IDENTIFY, d });
-  }
-
-  /**
-   * Resumes a session on the gateway.
-   * @returns {void}
-   */
-  identifyResume() {
-    if (!this.sessionID) {
-      this.debug('Warning: wanted to resume but session ID not available; identifying as a new session instead');
-      return this.identifyNew();
-    }
-    this.debug(`Attempting to resume session ${this.sessionID}`);
-
-    const d = {
-      token: this.client.token,
-      session_id: this.sessionID,
-      seq: this.sequence,
-    };
-
-    return this.send({
-      op: OPCodes.RESUME,
-      d,
-    });
-  }
-}
-
-module.exports = WebSocketConnection;
diff --git a/src/client/websocket/WebSocketManager.js b/src/client/websocket/WebSocketManager.js
index 960bc0b7..905626b6 100644
--- a/src/client/websocket/WebSocketManager.js
+++ b/src/client/websocket/WebSocketManager.js
@@ -1,89 +1,438 @@
+'use strict';
+
 const EventEmitter = require('events');
-const { Events, Status } = require('../../util/Constants');
-const WebSocketConnection = require('./WebSocketConnection');
+const WebSocketShard = require('./WebSocketShard');
+const PacketHandlers = require('./handlers');
+const { Error: DJSError } = require('../../errors');
+const Collection = require('../../util/Collection');
+const { Events, ShardEvents, Status, WSCodes, WSEvents } = require('../../util/Constants');
+const Util = require('../../util/Util');
+
+const BeforeReadyWhitelist = [
+  WSEvents.READY,
+  WSEvents.RESUMED,
+  WSEvents.GUILD_CREATE,
+  WSEvents.GUILD_DELETE,
+  WSEvents.GUILD_MEMBERS_CHUNK,
+  WSEvents.GUILD_MEMBER_ADD,
+  WSEvents.GUILD_MEMBER_REMOVE,
+];
+
+const UNRECOVERABLE_CLOSE_CODES = Object.keys(WSCodes)
+  .slice(1)
+  .map(Number);
+const UNRESUMABLE_CLOSE_CODES = [1000, 4006, 4007];
 
 /**
- * WebSocket Manager of the client.
- * @private
+ * The WebSocket manager for this client.
+ * <info>This class forwards raw dispatch events,
+ * read more about it here {@link https://discordapp.com/developers/docs/topics/gateway}</info>
+ * @extends EventEmitter
  */
 class WebSocketManager extends EventEmitter {
   constructor(client) {
     super();
+
     /**
      * The client that instantiated this WebSocketManager
      * @type {Client}
+     * @readonly
+     * @name WebSocketManager#client
      */
-    this.client = client;
+    Object.defineProperty(this, 'client', { value: client });
 
     /**
-     * The WebSocket connection of this manager
-     * @type {?WebSocketConnection}
+     * The gateway this manager uses
+     * @type {?string}
      */
-    this.connection = null;
+    this.gateway = undefined;
+
+    /**
+     * The amount of shards this manager handles
+     * @private
+     * @type {number}
+     */
+    this.totalShards = this.client.options.shards.length;
+
+    /**
+     * A collection of all shards this manager handles
+     * @type {Collection<number, WebSocketShard>}
+     */
+    this.shards = new Collection();
+
+    /**
+     * An array of shards to be connected or that need to reconnect
+     * @type {Set<WebSocketShard>}
+     * @private
+     * @name WebSocketManager#shardQueue
+     */
+    Object.defineProperty(this, 'shardQueue', { value: new Set(), writable: true });
+
+    /**
+     * An array of queued events before this WebSocketManager became ready
+     * @type {object[]}
+     * @private
+     * @name WebSocketManager#packetQueue
+     */
+    Object.defineProperty(this, 'packetQueue', { value: [] });
+
+    /**
+     * The current status of this WebSocketManager
+     * @type {number}
+     */
+    this.status = Status.IDLE;
+
+    /**
+     * If this manager was destroyed. It will prevent shards from reconnecting
+     * @type {boolean}
+     * @private
+     */
+    this.destroyed = false;
+
+    /**
+     * If this manager is currently reconnecting one or multiple shards
+     * @type {boolean}
+     * @private
+     */
+    this.reconnecting = false;
+
+    /**
+     * The current session limit of the client
+     * @private
+     * @type {?Object}
+     * @prop {number} total Total number of identifies available
+     * @prop {number} remaining Number of identifies remaining
+     * @prop {number} reset_after Number of milliseconds after which the limit resets
+     */
+    this.sessionStartLimit = undefined;
   }
 
   /**
-   * Sends a heartbeat on the available connection.
-   * @returns {void}
+   * The average ping of all WebSocketShards
+   * @type {number}
+   * @readonly
    */
-  heartbeat() {
-    if (!this.connection) return this.debug('No connection to heartbeat');
-    return this.connection.heartbeat();
+  get ping() {
+    const sum = this.shards.reduce((a, b) => a + b.ping, 0);
+    return sum / this.shards.size;
   }
 
   /**
-   * Emits a debug event.
-   * @param {string} message Debug message
-   * @returns {void}
+   * Emits a debug message.
+   * @param {string} message The debug message
+   * @param {?WebSocketShard} [shard] The shard that emitted this message, if any
+   * @private
    */
-  debug(message) {
-    return this.client.emit(Events.DEBUG, `[ws] ${message}`);
+  debug(message, shard) {
+    this.client.emit(Events.DEBUG, `[WS => ${shard ? `Shard ${shard.id}` : 'Manager'}] ${message}`);
   }
 
   /**
-   * Destroy the client.
-   * @returns {void} Whether or not destruction was successful
+   * Connects this manager to the gateway.
+   * @private
+   */
+  async connect() {
+    const invalidToken = new DJSError(WSCodes[4004]);
+    const {
+      url: gatewayURL,
+      shards: recommendedShards,
+      session_start_limit: sessionStartLimit,
+    } = await this.client.api.gateway.bot.get().catch(error => {
+      throw error.httpStatus === 401 ? invalidToken : error;
+    });
+
+    this.sessionStartLimit = sessionStartLimit;
+
+    const { total, remaining, reset_after } = sessionStartLimit;
+
+    this.debug(`Fetched Gateway Information
+    URL: ${gatewayURL}
+    Recommended Shards: ${recommendedShards}`);
+
+    this.debug(`Session Limit Information
+    Total: ${total}
+    Remaining: ${remaining}`);
+
+    this.gateway = `${gatewayURL}/`;
+
+    let { shards } = this.client.options;
+
+    if (shards === 'auto') {
+      this.debug(`Using the recommended shard count provided by Discord: ${recommendedShards}`);
+      this.totalShards = this.client.options.shardCount = recommendedShards;
+      shards = this.client.options.shards = Array.from({ length: recommendedShards }, (_, i) => i);
+    }
+
+    this.totalShards = shards.length;
+    this.debug(`Spawning shards: ${shards.join(', ')}`);
+    this.shardQueue = new Set(shards.map(id => new WebSocketShard(this, id)));
+
+    await this._handleSessionLimit(remaining, reset_after);
+
+    return this.createShards();
+  }
+
+  /**
+   * Handles the creation of a shard.
+   * @returns {Promise<boolean>}
+   * @private
+   */
+  async createShards() {
+    // If we don't have any shards to handle, return
+    if (!this.shardQueue.size) return false;
+
+    const [shard] = this.shardQueue;
+
+    this.shardQueue.delete(shard);
+
+    if (!shard.eventsAttached) {
+      shard.on(ShardEvents.ALL_READY, unavailableGuilds => {
+        /**
+         * Emitted when a shard turns ready.
+         * @event Client#shardReady
+         * @param {number} id The shard ID that turned ready
+         * @param {?Set<string>} unavailableGuilds Set of unavailable guild IDs, if any
+         */
+        this.client.emit(Events.SHARD_READY, shard.id, unavailableGuilds);
+
+        if (!this.shardQueue.size) this.reconnecting = false;
+        this.checkShardsReady();
+      });
+
+      shard.on(ShardEvents.CLOSE, event => {
+        if (event.code === 1000 ? this.destroyed : UNRECOVERABLE_CLOSE_CODES.includes(event.code)) {
+          /**
+           * Emitted when a shard's WebSocket disconnects and will no longer reconnect.
+           * @event Client#shardDisconnect
+           * @param {CloseEvent} event The WebSocket close event
+           * @param {number} id The shard ID that disconnected
+           */
+          this.client.emit(Events.SHARD_DISCONNECT, event, shard.id);
+          this.debug(WSCodes[event.code], shard);
+          return;
+        }
+
+        if (UNRESUMABLE_CLOSE_CODES.includes(event.code)) {
+          // These event codes cannot be resumed
+          shard.sessionID = undefined;
+        }
+
+        /**
+         * Emitted when a shard is attempting to reconnect or re-identify.
+         * @event Client#shardReconnecting
+         * @param {number} id The shard ID that is attempting to reconnect
+         */
+        this.client.emit(Events.SHARD_RECONNECTING, shard.id);
+
+        this.shardQueue.add(shard);
+
+        if (shard.sessionID) {
+          this.debug(`Session ID is present, attempting an immediate reconnect...`, shard);
+          this.reconnect(true);
+        } else {
+          shard.destroy({ reset: true, emit: false, log: false });
+          this.reconnect();
+        }
+      });
+
+      shard.on(ShardEvents.INVALID_SESSION, () => {
+        this.client.emit(Events.SHARD_RECONNECTING, shard.id);
+      });
+
+      shard.on(ShardEvents.DESTROYED, () => {
+        this.debug('Shard was destroyed but no WebSocket connection was present! Reconnecting...', shard);
+
+        this.client.emit(Events.SHARD_RECONNECTING, shard.id);
+
+        this.shardQueue.add(shard);
+        this.reconnect();
+      });
+
+      shard.eventsAttached = true;
+    }
+
+    this.shards.set(shard.id, shard);
+
+    try {
+      await shard.connect();
+    } catch (error) {
+      if (error && error.code && UNRECOVERABLE_CLOSE_CODES.includes(error.code)) {
+        throw new DJSError(WSCodes[error.code]);
+        // Undefined if session is invalid, error event for regular closes
+      } else if (!error || error.code) {
+        this.debug('Failed to connect to the gateway, requeueing...', shard);
+        this.shardQueue.add(shard);
+      } else {
+        throw error;
+      }
+    }
+    // If we have more shards, add a 5s delay
+    if (this.shardQueue.size) {
+      this.debug(`Shard Queue Size: ${this.shardQueue.size}; continuing in 5 seconds...`);
+      await Util.delayFor(5000);
+      await this._handleSessionLimit();
+      return this.createShards();
+    }
+
+    return true;
+  }
+
+  /**
+   * Handles reconnects for this manager.
+   * @param {boolean} [skipLimit=false] IF this reconnect should skip checking the session limit
+   * @private
+   * @returns {Promise<boolean>}
+   */
+  async reconnect(skipLimit = false) {
+    if (this.reconnecting || this.status !== Status.READY) return false;
+    this.reconnecting = true;
+    try {
+      if (!skipLimit) await this._handleSessionLimit();
+      await this.createShards();
+    } catch (error) {
+      this.debug(`Couldn't reconnect or fetch information about the gateway. ${error}`);
+      if (error.httpStatus !== 401) {
+        this.debug(`Possible network error occurred. Retrying in 5s...`);
+        await Util.delayFor(5000);
+        this.reconnecting = false;
+        return this.reconnect();
+      }
+      // If we get an error at this point, it means we cannot reconnect anymore
+      if (this.client.listenerCount(Events.INVALIDATED)) {
+        /**
+         * Emitted when the client's session becomes invalidated.
+         * You are expected to handle closing the process gracefully and preventing a boot loop
+         * if you are listening to this event.
+         * @event Client#invalidated
+         */
+        this.client.emit(Events.INVALIDATED);
+        // Destroy just the shards. This means you have to handle the cleanup yourself
+        this.destroy();
+      } else {
+        this.client.destroy();
+      }
+    } finally {
+      this.reconnecting = false;
+    }
+    return true;
+  }
+
+  /**
+   * Broadcasts a packet to every shard this manager handles.
+   * @param {Object} packet The packet to send
+   * @private
+   */
+  broadcast(packet) {
+    for (const shard of this.shards.values()) shard.send(packet);
+  }
+
+  /**
+   * Destroys this manager and all its shards.
+   * @private
    */
   destroy() {
-    if (!this.connection) {
-      this.debug('Attempted to destroy WebSocket but no connection exists!');
-      return false;
-    }
-    return this.connection.destroy();
+    if (this.destroyed) return;
+    this.debug(`Manager was destroyed. Called by:\n${new Error('MANAGER_DESTROYED').stack}`);
+    this.destroyed = true;
+    this.shardQueue.clear();
+    for (const shard of this.shards.values()) shard.destroy({ closeCode: 1000, reset: true, emit: false, log: false });
   }
 
   /**
-   * Send a packet on the available WebSocket.
-   * @param {Object} packet Packet to send
-   * @returns {void}
+   * Handles the timeout required if we cannot identify anymore.
+   * @param {number} [remaining] The amount of remaining identify sessions that can be done today
+   * @param {number} [resetAfter] The amount of time in which the identify counter resets
+   * @private
    */
-  send(packet) {
-    if (!this.connection) {
-      this.debug('No connection to websocket');
+  async _handleSessionLimit(remaining, resetAfter) {
+    if (typeof remaining === 'undefined' && typeof resetAfter === 'undefined') {
+      const { session_start_limit } = await this.client.api.gateway.bot.get();
+      this.sessionStartLimit = session_start_limit;
+      remaining = session_start_limit.remaining;
+      resetAfter = session_start_limit.reset_after;
+      this.debug(`Session Limit Information
+    Total: ${session_start_limit.total}
+    Remaining: ${remaining}`);
+    }
+    if (!remaining) {
+      this.debug(`Exceeded identify threshold. Will attempt a connection in ${resetAfter}ms`);
+      await Util.delayFor(resetAfter);
+    }
+  }
+
+  /**
+   * Processes a packet and queues it if this WebSocketManager is not ready.
+   * @param {Object} [packet] The packet to be handled
+   * @param {WebSocketShard} [shard] The shard that will handle this packet
+   * @returns {boolean}
+   * @private
+   */
+  handlePacket(packet, shard) {
+    if (packet && this.status !== Status.READY) {
+      if (!BeforeReadyWhitelist.includes(packet.t)) {
+        this.packetQueue.push({ packet, shard });
+        return false;
+      }
+    }
+
+    if (this.packetQueue.length) {
+      const item = this.packetQueue.shift();
+      this.client.setImmediate(() => {
+        this.handlePacket(item.packet, item.shard);
+      });
+    }
+
+    if (packet && !this.client.options.disabledEvents.includes(packet.t) && PacketHandlers[packet.t]) {
+      PacketHandlers[packet.t](this.client, packet, shard);
+    }
+
+    return true;
+  }
+
+  /**
+   * Checks whether the client is ready to be marked as ready.
+   * @private
+   */
+  async checkShardsReady() {
+    if (this.status === Status.READY) return;
+    if (this.shards.size !== this.totalShards || this.shards.some(s => s.status !== Status.READY)) {
       return;
     }
-    this.connection.send(packet);
+
+    this.status = Status.NEARLY;
+
+    if (this.client.options.fetchAllMembers) {
+      try {
+        const promises = this.client.guilds.cache.map(guild => {
+          if (guild.available) return guild.members.fetch();
+          // Return empty promise if guild is unavailable
+          return Promise.resolve();
+        });
+        await Promise.all(promises);
+      } catch (err) {
+        this.debug(`Failed to fetch all members before ready! ${err}\n${err.stack}`);
+      }
+    }
+
+    this.triggerClientReady();
   }
 
   /**
-   * Connects the client to a gateway.
-   * @param {string} gateway The gateway to connect to
-   * @returns {boolean}
+   * Causes the client to be marked as ready and emits the ready event.
+   * @private
    */
-  connect(gateway) {
-    if (!this.connection) {
-      this.connection = new WebSocketConnection(this, gateway);
-      return true;
-    }
-    switch (this.connection.status) {
-      case Status.IDLE:
-      case Status.DISCONNECTED:
-        this.connection.connect(gateway, 5500);
-        return true;
-      default:
-        this.debug(`Couldn't connect to ${gateway} as the websocket is at state ${this.connection.status}`);
-        return false;
-    }
+  triggerClientReady() {
+    this.status = Status.READY;
+
+    this.client.readyAt = new Date();
+
+    /**
+     * Emitted when the client becomes ready to start working.
+     * @event Client#ready
+     */
+    this.client.emit(Events.CLIENT_READY);
+
+    this.handlePacket();
   }
 }
 
diff --git a/src/client/websocket/WebSocketShard.js b/src/client/websocket/WebSocketShard.js
new file mode 100644
index 00000000..eaf4fa1a
--- /dev/null
+++ b/src/client/websocket/WebSocketShard.js
@@ -0,0 +1,762 @@
+'use strict';
+
+const EventEmitter = require('events');
+const WebSocket = require('../../WebSocket');
+const { browser, Status, Events, ShardEvents, OPCodes, WSEvents } = require('../../util/Constants');
+
+const STATUS_KEYS = Object.keys(Status);
+const CONNECTION_STATE = Object.keys(WebSocket.WebSocket);
+
+let zlib;
+
+if (!browser) {
+  try {
+    zlib = require('zlib-sync');
+  } catch {} // eslint-disable-line no-empty
+}
+
+/**
+ * Represents a Shard's WebSocket connection
+ */
+class WebSocketShard extends EventEmitter {
+  constructor(manager, id) {
+    super();
+
+    /**
+     * The WebSocketManager of the shard
+     * @type {WebSocketManager}
+     */
+    this.manager = manager;
+
+    /**
+     * The ID of the shard
+     * @type {number}
+     */
+    this.id = id;
+
+    /**
+     * The current status of the shard
+     * @type {Status}
+     */
+    this.status = Status.IDLE;
+
+    /**
+     * The current sequence of the shard
+     * @type {number}
+     * @private
+     */
+    this.sequence = -1;
+
+    /**
+     * The sequence of the shard after close
+     * @type {number}
+     * @private
+     */
+    this.closeSequence = 0;
+
+    /**
+     * The current session ID of the shard
+     * @type {string}
+     * @private
+     */
+    this.sessionID = undefined;
+
+    /**
+     * The previous heartbeat ping of the shard
+     * @type {number}
+     */
+    this.ping = -1;
+
+    /**
+     * The last time a ping was sent (a timestamp)
+     * @type {number}
+     * @private
+     */
+    this.lastPingTimestamp = -1;
+
+    /**
+     * If we received a heartbeat ack back. Used to identify zombie connections
+     * @type {boolean}
+     * @private
+     */
+    this.lastHeartbeatAcked = true;
+
+    /**
+     * Contains the rate limit queue and metadata
+     * @type {Object}
+     * @private
+     */
+    Object.defineProperty(this, 'ratelimit', {
+      value: {
+        queue: [],
+        total: 120,
+        remaining: 120,
+        time: 60e3,
+        timer: null,
+      },
+    });
+
+    /**
+     * The WebSocket connection for the current shard
+     * @type {?WebSocket}
+     * @private
+     */
+    Object.defineProperty(this, 'connection', { value: null, writable: true });
+
+    /**
+     * @external Inflate
+     * @see {@link https://www.npmjs.com/package/zlib-sync}
+     */
+
+    /**
+     * The compression to use
+     * @type {?Inflate}
+     * @private
+     */
+    Object.defineProperty(this, 'inflate', { value: null, writable: true });
+
+    /**
+     * The HELLO timeout
+     * @type {?NodeJS.Timer}
+     * @private
+     */
+    Object.defineProperty(this, 'helloTimeout', { value: undefined, writable: true });
+
+    /**
+     * If the manager attached its event handlers on the shard
+     * @type {boolean}
+     * @private
+     */
+    Object.defineProperty(this, 'eventsAttached', { value: false, writable: true });
+
+    /**
+     * A set of guild IDs this shard expects to receive
+     * @type {?Set<string>}
+     * @private
+     */
+    Object.defineProperty(this, 'expectedGuilds', { value: undefined, writable: true });
+
+    /**
+     * The ready timeout
+     * @type {?NodeJS.Timer}
+     * @private
+     */
+    Object.defineProperty(this, 'readyTimeout', { value: undefined, writable: true });
+
+    /**
+     * Time when the WebSocket connection was opened
+     * @type {number}
+     * @private
+     */
+    Object.defineProperty(this, 'connectedAt', { value: 0, writable: true });
+  }
+
+  /**
+   * Emits a debug event.
+   * @param {string} message The debug message
+   * @private
+   */
+  debug(message) {
+    this.manager.debug(message, this);
+  }
+
+  /**
+   * Connects the shard to the gateway.
+   * @private
+   * @returns {Promise<void>} A promise that will resolve if the shard turns ready successfully,
+   * or reject if we couldn't connect
+   */
+  connect() {
+    const { gateway, client } = this.manager;
+
+    if (this.connection && this.connection.readyState === WebSocket.OPEN && this.status === Status.READY) {
+      return Promise.resolve();
+    }
+
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        this.removeListener(ShardEvents.CLOSE, onClose);
+        this.removeListener(ShardEvents.READY, onReady);
+        this.removeListener(ShardEvents.RESUMED, onResumed);
+        this.removeListener(ShardEvents.INVALID_SESSION, onInvalidOrDestroyed);
+        this.removeListener(ShardEvents.DESTROYED, onInvalidOrDestroyed);
+      };
+
+      const onReady = () => {
+        cleanup();
+        resolve();
+      };
+
+      const onResumed = () => {
+        cleanup();
+        resolve();
+      };
+
+      const onClose = event => {
+        cleanup();
+        reject(event);
+      };
+
+      const onInvalidOrDestroyed = () => {
+        cleanup();
+        // eslint-disable-next-line prefer-promise-reject-errors
+        reject();
+      };
+
+      this.once(ShardEvents.READY, onReady);
+      this.once(ShardEvents.RESUMED, onResumed);
+      this.once(ShardEvents.CLOSE, onClose);
+      this.once(ShardEvents.INVALID_SESSION, onInvalidOrDestroyed);
+      this.once(ShardEvents.DESTROYED, onInvalidOrDestroyed);
+
+      if (this.connection && this.connection.readyState === WebSocket.OPEN) {
+        this.debug('An open connection was found, attempting an immediate identify.');
+        this.identify();
+        return;
+      }
+
+      if (this.connection) {
+        this.debug(`A connection object was found. Cleaning up before continuing.
+    State: ${CONNECTION_STATE[this.connection.readyState]}`);
+        this.destroy({ emit: false });
+      }
+
+      const wsQuery = { v: client.options.ws.version };
+
+      if (zlib) {
+        this.inflate = new zlib.Inflate({
+          chunkSize: 65535,
+          flush: zlib.Z_SYNC_FLUSH,
+          to: WebSocket.encoding === 'json' ? 'string' : '',
+        });
+        wsQuery.compress = 'zlib-stream';
+      }
+
+      this.debug(
+        `[CONNECT]
+    Gateway    : ${gateway}
+    Version    : ${client.options.ws.version}
+    Encoding   : ${WebSocket.encoding}
+    Compression: ${zlib ? 'zlib-stream' : 'none'}`,
+      );
+
+      this.status = this.status === Status.DISCONNECTED ? Status.RECONNECTING : Status.CONNECTING;
+      this.setHelloTimeout();
+
+      this.connectedAt = Date.now();
+
+      const ws = (this.connection = WebSocket.create(gateway, wsQuery));
+      ws.onopen = this.onOpen.bind(this);
+      ws.onmessage = this.onMessage.bind(this);
+      ws.onerror = this.onError.bind(this);
+      ws.onclose = this.onClose.bind(this);
+    });
+  }
+
+  /**
+   * Called whenever a connection is opened to the gateway.
+   * @private
+   */
+  onOpen() {
+    this.debug(`[CONNECTED] ${this.connection.url} in ${Date.now() - this.connectedAt}ms`);
+    this.status = Status.NEARLY;
+  }
+
+  /**
+   * Called whenever a message is received.
+   * @param {MessageEvent} event Event received
+   * @private
+   */
+  onMessage({ data }) {
+    let raw;
+    if (data instanceof ArrayBuffer) data = new Uint8Array(data);
+    if (zlib) {
+      const l = data.length;
+      const flush =
+        l >= 4 && data[l - 4] === 0x00 && data[l - 3] === 0x00 && data[l - 2] === 0xff && data[l - 1] === 0xff;
+
+      this.inflate.push(data, flush && zlib.Z_SYNC_FLUSH);
+      if (!flush) return;
+      raw = this.inflate.result;
+    } else {
+      raw = data;
+    }
+    let packet;
+    try {
+      packet = WebSocket.unpack(raw);
+      this.manager.client.emit(Events.RAW, packet, this.id);
+      if (packet.op === OPCodes.DISPATCH) this.manager.emit(packet.t, packet.d, this.id);
+    } catch (err) {
+      this.manager.client.emit(Events.SHARD_ERROR, err, this.id);
+      return;
+    }
+    this.onPacket(packet);
+  }
+
+  /**
+   * Called whenever an error occurs with the WebSocket.
+   * @param {ErrorEvent} event The error that occurred
+   * @private
+   */
+  onError(event) {
+    const error = event && event.error ? event.error : event;
+    if (!error) return;
+
+    /**
+     * Emitted whenever a shard's WebSocket encounters a connection error.
+     * @event Client#shardError
+     * @param {Error} error The encountered error
+     * @param {number} shardID The shard that encountered this error
+     */
+    this.manager.client.emit(Events.SHARD_ERROR, error, this.id);
+  }
+
+  /**
+   * @external CloseEvent
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent}
+   */
+
+  /**
+   * @external ErrorEvent
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent}
+   */
+
+  /**
+   * @external MessageEvent
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent}
+   */
+
+  /**
+   * Called whenever a connection to the gateway is closed.
+   * @param {CloseEvent} event Close event that was received
+   * @private
+   */
+  onClose(event) {
+    if (this.sequence !== -1) this.closeSequence = this.sequence;
+    this.sequence = -1;
+
+    this.debug(`[CLOSE]
+    Event Code: ${event.code}
+    Clean     : ${event.wasClean}
+    Reason    : ${event.reason || 'No reason received'}`);
+
+    this.setHeartbeatTimer(-1);
+    this.setHelloTimeout(-1);
+    // If we still have a connection object, clean up its listeners
+    if (this.connection) this._cleanupConnection();
+
+    this.status = Status.DISCONNECTED;
+
+    /**
+     * Emitted when a shard's WebSocket closes.
+     * @private
+     * @event WebSocketShard#close
+     * @param {CloseEvent} event The received event
+     */
+    this.emit(ShardEvents.CLOSE, event);
+  }
+
+  /**
+   * Called whenever a packet is received.
+   * @param {Object} packet The received packet
+   * @private
+   */
+  onPacket(packet) {
+    if (!packet) {
+      this.debug(`Received broken packet: '${packet}'.`);
+      return;
+    }
+
+    switch (packet.t) {
+      case WSEvents.READY:
+        /**
+         * Emitted when the shard receives the READY payload and is now waiting for guilds
+         * @event WebSocketShard#ready
+         */
+        this.emit(ShardEvents.READY);
+
+        this.sessionID = packet.d.session_id;
+        this.expectedGuilds = new Set(packet.d.guilds.map(d => d.id));
+        this.status = Status.WAITING_FOR_GUILDS;
+        this.debug(`[READY] Session ${this.sessionID}.`);
+        this.lastHeartbeatAcked = true;
+        this.sendHeartbeat('ReadyHeartbeat');
+        break;
+      case WSEvents.RESUMED: {
+        /**
+         * Emitted when the shard resumes successfully
+         * @event WebSocketShard#resumed
+         */
+        this.emit(ShardEvents.RESUMED);
+
+        this.status = Status.READY;
+        const replayed = packet.s - this.closeSequence;
+        this.debug(`[RESUMED] Session ${this.sessionID} | Replayed ${replayed} events.`);
+        this.lastHeartbeatAcked = true;
+        this.sendHeartbeat('ResumeHeartbeat');
+        break;
+      }
+    }
+
+    if (packet.s > this.sequence) this.sequence = packet.s;
+
+    switch (packet.op) {
+      case OPCodes.HELLO:
+        this.setHelloTimeout(-1);
+        this.setHeartbeatTimer(packet.d.heartbeat_interval);
+        this.identify();
+        break;
+      case OPCodes.RECONNECT:
+        this.destroy({ closeCode: 4000 });
+        break;
+      case OPCodes.INVALID_SESSION:
+        this.debug(`[INVALID SESSION] Resumable: ${packet.d}.`);
+        // If we can resume the session, do so immediately
+        if (packet.d) {
+          this.identifyResume();
+          return;
+        }
+        // Reset the sequence
+        this.sequence = -1;
+        // Reset the session ID as it's invalid
+        this.sessionID = undefined;
+        // Set the status to reconnecting
+        this.status = Status.RECONNECTING;
+        // Finally, emit the INVALID_SESSION event
+        this.emit(ShardEvents.INVALID_SESSION);
+        break;
+      case OPCodes.HEARTBEAT_ACK:
+        this.ackHeartbeat();
+        break;
+      case OPCodes.HEARTBEAT:
+        this.sendHeartbeat('HeartbeatRequest');
+        break;
+      default:
+        this.manager.handlePacket(packet, this);
+        if (this.status === Status.WAITING_FOR_GUILDS && packet.t === WSEvents.GUILD_CREATE) {
+          this.expectedGuilds.delete(packet.d.id);
+          this.checkReady();
+        }
+    }
+  }
+
+  /**
+   * Checks if the shard can be marked as ready
+   * @private
+   */
+  checkReady() {
+    // Step 0. Clear the ready timeout, if it exists
+    if (this.readyTimeout) {
+      this.manager.client.clearTimeout(this.readyTimeout);
+      this.readyTimeout = undefined;
+    }
+    // Step 1. If we don't have any other guilds pending, we are ready
+    if (!this.expectedGuilds.size) {
+      this.debug('Shard received all its guilds. Marking as fully ready.');
+      this.status = Status.READY;
+
+      /**
+       * Emitted when the shard is fully ready.
+       * This event is emitted if:
+       * * all guilds were received by this shard
+       * * the ready timeout expired, and some guilds are unavailable
+       * @event WebSocketShard#allReady
+       * @param {?Set<string>} unavailableGuilds Set of unavailable guilds, if any
+       */
+      this.emit(ShardEvents.ALL_READY);
+      return;
+    }
+    // Step 2. Create a 15s timeout that will mark the shard as ready if there are still unavailable guilds
+    this.readyTimeout = this.manager.client.setTimeout(() => {
+      this.debug(`Shard did not receive any more guild packets in 15 seconds.
+  Unavailable guild count: ${this.expectedGuilds.size}`);
+
+      this.readyTimeout = undefined;
+
+      this.status = Status.READY;
+
+      this.emit(ShardEvents.ALL_READY, this.expectedGuilds);
+    }, 15000);
+  }
+
+  /**
+   * Sets the HELLO packet timeout.
+   * @param {number} [time] If set to -1, it will clear the hello timeout timeout
+   * @private
+   */
+  setHelloTimeout(time) {
+    if (time === -1) {
+      if (this.helloTimeout) {
+        this.debug('Clearing the HELLO timeout.');
+        this.manager.client.clearTimeout(this.helloTimeout);
+        this.helloTimeout = undefined;
+      }
+      return;
+    }
+    this.debug('Setting a HELLO timeout for 20s.');
+    this.helloTimeout = this.manager.client.setTimeout(() => {
+      this.debug('Did not receive HELLO in time. Destroying and connecting again.');
+      this.destroy({ reset: true, closeCode: 4009 });
+    }, 20000);
+  }
+
+  /**
+   * Sets the heartbeat timer for this shard.
+   * @param {number} time If -1, clears the interval, any other number sets an interval
+   * @private
+   */
+  setHeartbeatTimer(time) {
+    if (time === -1) {
+      if (this.heartbeatInterval) {
+        this.debug('Clearing the heartbeat interval.');
+        this.manager.client.clearInterval(this.heartbeatInterval);
+        this.heartbeatInterval = undefined;
+      }
+      return;
+    }
+    this.debug(`Setting a heartbeat interval for ${time}ms.`);
+    // Sanity checks
+    if (this.heartbeatInterval) this.manager.client.clearInterval(this.heartbeatInterval);
+    this.heartbeatInterval = this.manager.client.setInterval(() => this.sendHeartbeat(), time);
+  }
+
+  /**
+   * Sends a heartbeat to the WebSocket.
+   * If this shard didn't receive a heartbeat last time, it will destroy it and reconnect
+   * @param {string} [tag='HeartbeatTimer'] What caused this heartbeat to be sent
+   * @param {boolean} [ignoreHeartbeatAck] If we should send the heartbeat forcefully.
+   * @private
+   */
+  sendHeartbeat(
+    tag = 'HeartbeatTimer',
+    ignoreHeartbeatAck = [Status.WAITING_FOR_GUILDS, Status.IDENTIFYING, Status.RESUMING].includes(this.status),
+  ) {
+    if (ignoreHeartbeatAck && !this.lastHeartbeatAcked) {
+      this.debug(`[${tag}] Didn't process heartbeat ack yet but we are still connected. Sending one now.`);
+    } else if (!this.lastHeartbeatAcked) {
+      this.debug(
+        `[${tag}] Didn't receive a heartbeat ack last time, assuming zombie connection. Destroying and reconnecting.
+    Status          : ${STATUS_KEYS[this.status]}
+    Sequence        : ${this.sequence}
+    Connection State: ${this.connection ? CONNECTION_STATE[this.connection.readyState] : 'No Connection??'}`,
+      );
+
+      this.destroy({ closeCode: 4009, reset: true });
+      return;
+    }
+
+    this.debug(`[${tag}] Sending a heartbeat.`);
+    this.lastHeartbeatAcked = false;
+    this.lastPingTimestamp = Date.now();
+    this.send({ op: OPCodes.HEARTBEAT, d: this.sequence }, true);
+  }
+
+  /**
+   * Acknowledges a heartbeat.
+   * @private
+   */
+  ackHeartbeat() {
+    this.lastHeartbeatAcked = true;
+    const latency = Date.now() - this.lastPingTimestamp;
+    this.debug(`Heartbeat acknowledged, latency of ${latency}ms.`);
+    this.ping = latency;
+  }
+
+  /**
+   * Identifies the client on the connection.
+   * @private
+   * @returns {void}
+   */
+  identify() {
+    return this.sessionID ? this.identifyResume() : this.identifyNew();
+  }
+
+  /**
+   * Identifies as a new connection on the gateway.
+   * @private
+   */
+  identifyNew() {
+    const { client } = this.manager;
+    if (!client.token) {
+      this.debug('[IDENTIFY] No token available to identify a new session.');
+      return;
+    }
+
+    this.status = Status.IDENTIFYING;
+
+    // Clone the identify payload and assign the token and shard info
+    const d = {
+      ...client.options.ws,
+      token: client.token,
+      shard: [this.id, Number(client.options.shardCount)],
+    };
+
+    this.debug(`[IDENTIFY] Shard ${this.id}/${client.options.shardCount}`);
+    this.send({ op: OPCodes.IDENTIFY, d }, true);
+  }
+
+  /**
+   * Resumes a session on the gateway.
+   * @private
+   */
+  identifyResume() {
+    if (!this.sessionID) {
+      this.debug('[RESUME] No session ID was present; identifying as a new session.');
+      this.identifyNew();
+      return;
+    }
+
+    this.status = Status.RESUMING;
+
+    this.debug(`[RESUME] Session ${this.sessionID}, sequence ${this.closeSequence}`);
+
+    const d = {
+      token: this.manager.client.token,
+      session_id: this.sessionID,
+      seq: this.closeSequence,
+    };
+
+    this.send({ op: OPCodes.RESUME, d }, true);
+  }
+
+  /**
+   * Adds a packet to the queue to be sent to the gateway.
+   * <warn>If you use this method, make sure you understand that you need to provide
+   * a full [Payload](https://discordapp.com/developers/docs/topics/gateway#commands-and-events-gateway-commands).
+   * Do not use this method if you don't know what you're doing.</warn>
+   * @param {Object} data The full packet to send
+   * @param {boolean} [important=false] If this packet should be added first in queue
+   */
+  send(data, important = false) {
+    this.ratelimit.queue[important ? 'unshift' : 'push'](data);
+    this.processQueue();
+  }
+
+  /**
+   * Sends data, bypassing the queue.
+   * @param {Object} data Packet to send
+   * @returns {void}
+   * @private
+   */
+  _send(data) {
+    if (!this.connection || this.connection.readyState !== WebSocket.OPEN) {
+      this.debug(`Tried to send packet '${JSON.stringify(data)}' but no WebSocket is available!`);
+      this.destroy({ close: 4000 });
+      return;
+    }
+
+    this.connection.send(WebSocket.pack(data), err => {
+      if (err) this.manager.client.emit(Events.SHARD_ERROR, err, this.id);
+    });
+  }
+
+  /**
+   * Processes the current WebSocket queue.
+   * @returns {void}
+   * @private
+   */
+  processQueue() {
+    if (this.ratelimit.remaining === 0) return;
+    if (this.ratelimit.queue.length === 0) return;
+    if (this.ratelimit.remaining === this.ratelimit.total) {
+      this.ratelimit.timer = this.manager.client.setTimeout(() => {
+        this.ratelimit.remaining = this.ratelimit.total;
+        this.processQueue();
+      }, this.ratelimit.time);
+    }
+    while (this.ratelimit.remaining > 0) {
+      const item = this.ratelimit.queue.shift();
+      if (!item) return;
+      this._send(item);
+      this.ratelimit.remaining--;
+    }
+  }
+
+  /**
+   * Destroys this shard and closes its WebSocket connection.
+   * @param {Object} [options={ closeCode: 1000, reset: false, emit: true, log: true }] Options for destroying the shard
+   * @private
+   */
+  destroy({ closeCode = 1000, reset = false, emit = true, log = true } = {}) {
+    if (log) {
+      this.debug(`[DESTROY]
+    Close Code    : ${closeCode}
+    Reset         : ${reset}
+    Emit DESTROYED: ${emit}`);
+    }
+
+    // Step 0: Remove all timers
+    this.setHeartbeatTimer(-1);
+    this.setHelloTimeout(-1);
+
+    // Step 1: Close the WebSocket connection, if any, otherwise, emit DESTROYED
+    if (this.connection) {
+      // If the connection is currently opened, we will (hopefully) receive close
+      if (this.connection.readyState === WebSocket.OPEN) {
+        this.connection.close(closeCode);
+      } else {
+        // Connection is not OPEN
+        this.debug(`WS State: ${CONNECTION_STATE[this.connection.readyState]}`);
+        // Remove listeners from the connection
+        this._cleanupConnection();
+        // Attempt to close the connection just in case
+        try {
+          this.connection.close(closeCode);
+        } catch {
+          // No-op
+        }
+        // Emit the destroyed event if needed
+        if (emit) this._emitDestroyed();
+      }
+    } else if (emit) {
+      // We requested a destroy, but we had no connection. Emit destroyed
+      this._emitDestroyed();
+    }
+
+    // Step 2: Null the connection object
+    this.connection = null;
+
+    // Step 3: Set the shard status to DISCONNECTED
+    this.status = Status.DISCONNECTED;
+
+    // Step 4: Cache the old sequence (use to attempt a resume)
+    if (this.sequence !== -1) this.closeSequence = this.sequence;
+
+    // Step 5: Reset the sequence and session ID if requested
+    if (reset) {
+      this.sequence = -1;
+      this.sessionID = undefined;
+    }
+
+    // Step 6: reset the ratelimit data
+    this.ratelimit.remaining = this.ratelimit.total;
+    this.ratelimit.queue.length = 0;
+    if (this.ratelimit.timer) {
+      this.manager.client.clearTimeout(this.ratelimit.timer);
+      this.ratelimit.timer = null;
+    }
+  }
+
+  /**
+   * Cleans up the WebSocket connection listeners.
+   * @private
+   */
+  _cleanupConnection() {
+    this.connection.onopen = this.connection.onclose = this.connection.onerror = this.connection.onmessage = null;
+  }
+
+  /**
+   * Emits the DESTROYED event on the shard
+   * @private
+   */
+  _emitDestroyed() {
+    /**
+     * Emitted when a shard is destroyed, but no WebSocket connection was present.
+     * @private
+     * @event WebSocketShard#destroyed
+     */
+    this.emit(ShardEvents.DESTROYED);
+  }
+}
+
+module.exports = WebSocketShard;
diff --git a/src/client/websocket/handlers/CHANNEL_CREATE.js b/src/client/websocket/handlers/CHANNEL_CREATE.js
new file mode 100644
index 00000000..d6d560d8
--- /dev/null
+++ b/src/client/websocket/handlers/CHANNEL_CREATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ChannelCreate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/CHANNEL_DELETE.js b/src/client/websocket/handlers/CHANNEL_DELETE.js
new file mode 100644
index 00000000..cb9f3d8c
--- /dev/null
+++ b/src/client/websocket/handlers/CHANNEL_DELETE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.ChannelDelete.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/CHANNEL_PINS_UPDATE.js b/src/client/websocket/handlers/CHANNEL_PINS_UPDATE.js
new file mode 100644
index 00000000..13e6f0fa
--- /dev/null
+++ b/src/client/websocket/handlers/CHANNEL_PINS_UPDATE.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const channel = client.channels.cache.get(data.channel_id);
+  const time = new Date(data.last_pin_timestamp);
+
+  if (channel && !Number.isNaN(time.getTime())) {
+    // Discord sends null for last_pin_timestamp if the last pinned message was removed
+    channel.lastPinTimestamp = time.getTime() || null;
+
+    /**
+     * Emitted whenever the pins of a channel are updated. Due to the nature of the WebSocket event,
+     * not much information can be provided easily here - you need to manually check the pins yourself.
+     * @event Client#channelPinsUpdate
+     * @param {DMChannel|TextChannel} channel The channel that the pins update occurred in
+     * @param {Date} time The time of the pins update
+     */
+    client.emit(Events.CHANNEL_PINS_UPDATE, channel, time);
+  }
+};
diff --git a/src/client/websocket/handlers/CHANNEL_UPDATE.js b/src/client/websocket/handlers/CHANNEL_UPDATE.js
new file mode 100644
index 00000000..d441478a
--- /dev/null
+++ b/src/client/websocket/handlers/CHANNEL_UPDATE.js
@@ -0,0 +1,16 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, packet) => {
+  const { old, updated } = client.actions.ChannelUpdate.handle(packet.d);
+  if (old && updated) {
+    /**
+     * Emitted whenever a channel is updated - e.g. name change, topic change, channel type change.
+     * @event Client#channelUpdate
+     * @param {DMChannel|GuildChannel} oldChannel The channel before the update
+     * @param {DMChannel|GuildChannel} newChannel The channel after the update
+     */
+    client.emit(Events.CHANNEL_UPDATE, old, updated);
+  }
+};
diff --git a/src/client/websocket/handlers/GUILD_BAN_ADD.js b/src/client/websocket/handlers/GUILD_BAN_ADD.js
new file mode 100644
index 00000000..5d4a0965
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_BAN_ADD.js
@@ -0,0 +1,16 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  const user = client.users.add(data.user);
+
+  /**
+   * Emitted whenever a member is banned from a guild.
+   * @event Client#guildBanAdd
+   * @param {Guild} guild The guild that the ban occurred in
+   * @param {User} user The user that was banned
+   */
+  if (guild && user) client.emit(Events.GUILD_BAN_ADD, guild, user);
+};
diff --git a/src/client/websocket/handlers/GUILD_BAN_REMOVE.js b/src/client/websocket/handlers/GUILD_BAN_REMOVE.js
new file mode 100644
index 00000000..8389e46e
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_BAN_REMOVE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildBanRemove.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/GUILD_CREATE.js b/src/client/websocket/handlers/GUILD_CREATE.js
new file mode 100644
index 00000000..67432049
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_CREATE.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const { Events, Status } = require('../../../util/Constants');
+
+module.exports = async (client, { d: data }, shard) => {
+  let guild = client.guilds.cache.get(data.id);
+  if (guild) {
+    if (!guild.available && !data.unavailable) {
+      // A newly available guild
+      guild._patch(data);
+      // If the client was ready before and we had unavailable guilds, fetch them
+      if (client.ws.status === Status.READY && client.options.fetchAllMembers) {
+        await guild.members
+          .fetch()
+          .catch(err => client.emit(Events.DEBUG, `Failed to fetch all members: ${err}\n${err.stack}`));
+      }
+    }
+  } else {
+    // A new guild
+    data.shardID = shard.id;
+    guild = client.guilds.add(data);
+    if (client.ws.status === Status.READY) {
+      /**
+       * Emitted whenever the client joins a guild.
+       * @event Client#guildCreate
+       * @param {Guild} guild The created guild
+       */
+      if (client.options.fetchAllMembers) {
+        await guild.members
+          .fetch()
+          .catch(err => client.emit(Events.DEBUG, `Failed to fetch all members: ${err}\n${err.stack}`));
+      }
+      client.emit(Events.GUILD_CREATE, guild);
+    }
+  }
+};
diff --git a/src/client/websocket/handlers/GUILD_DELETE.js b/src/client/websocket/handlers/GUILD_DELETE.js
new file mode 100644
index 00000000..27a32562
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_DELETE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildDelete.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/GUILD_EMOJIS_UPDATE.js b/src/client/websocket/handlers/GUILD_EMOJIS_UPDATE.js
new file mode 100644
index 00000000..e23b6713
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_EMOJIS_UPDATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildEmojisUpdate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/GUILD_INTEGRATIONS_UPDATE.js b/src/client/websocket/handlers/GUILD_INTEGRATIONS_UPDATE.js
new file mode 100644
index 00000000..e90a72c2
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_INTEGRATIONS_UPDATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildIntegrationsUpdate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/GUILD_MEMBERS_CHUNK.js b/src/client/websocket/handlers/GUILD_MEMBERS_CHUNK.js
new file mode 100644
index 00000000..3ceb6225
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_MEMBERS_CHUNK.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const Collection = require('../../../util/Collection');
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (!guild) return;
+  const members = new Collection();
+
+  for (const member of data.members) members.set(member.user.id, guild.members.add(member));
+  if (data.presences) {
+    for (const presence of data.presences) guild.presences.cache.add(Object.assign(presence, { guild }));
+  }
+  /**
+   * Emitted whenever a chunk of guild members is received (all members come from the same guild).
+   * @event Client#guildMembersChunk
+   * @param {Collection<Snowflake, GuildMember>} members The members in the chunk
+   * @param {Guild} guild The guild related to the member chunk
+   */
+  client.emit(Events.GUILD_MEMBERS_CHUNK, members, guild);
+};
diff --git a/src/client/websocket/handlers/GUILD_MEMBER_ADD.js b/src/client/websocket/handlers/GUILD_MEMBER_ADD.js
new file mode 100644
index 00000000..51287562
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_MEMBER_ADD.js
@@ -0,0 +1,19 @@
+'use strict';
+
+const { Events, Status } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }, shard) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (guild) {
+    guild.memberCount++;
+    const member = guild.members.add(data);
+    if (shard.status === Status.READY) {
+      /**
+       * Emitted whenever a user joins a guild.
+       * @event Client#guildMemberAdd
+       * @param {GuildMember} member The member that has joined a guild
+       */
+      client.emit(Events.GUILD_MEMBER_ADD, member);
+    }
+  }
+};
diff --git a/src/client/websocket/handlers/GUILD_MEMBER_REMOVE.js b/src/client/websocket/handlers/GUILD_MEMBER_REMOVE.js
new file mode 100644
index 00000000..72432af1
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_MEMBER_REMOVE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet, shard) => {
+  client.actions.GuildMemberRemove.handle(packet.d, shard);
+};
diff --git a/src/client/websocket/handlers/GUILD_MEMBER_UPDATE.js b/src/client/websocket/handlers/GUILD_MEMBER_UPDATE.js
new file mode 100644
index 00000000..92c9da6c
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_MEMBER_UPDATE.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const { Status, Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }, shard) => {
+  const guild = client.guilds.cache.get(data.guild_id);
+  if (guild) {
+    const member = guild.members.cache.get(data.user.id);
+    if (member) {
+      const old = member._update(data);
+      if (shard.status === Status.READY) {
+        /**
+         * Emitted whenever a guild member changes - i.e. new role, removed role, nickname.
+         * @event Client#guildMemberUpdate
+         * @param {GuildMember} oldMember The member before the update
+         * @param {GuildMember} newMember The member after the update
+         */
+        client.emit(Events.GUILD_MEMBER_UPDATE, old, member);
+      }
+    }
+  }
+};
diff --git a/src/client/websocket/handlers/GUILD_ROLE_CREATE.js b/src/client/websocket/handlers/GUILD_ROLE_CREATE.js
new file mode 100644
index 00000000..da9e7bc4
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_ROLE_CREATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildRoleCreate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/GUILD_ROLE_DELETE.js b/src/client/websocket/handlers/GUILD_ROLE_DELETE.js
new file mode 100644
index 00000000..cdc63531
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_ROLE_DELETE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildRoleDelete.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/GUILD_ROLE_UPDATE.js b/src/client/websocket/handlers/GUILD_ROLE_UPDATE.js
new file mode 100644
index 00000000..3a9b62e8
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_ROLE_UPDATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildRoleUpdate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/GUILD_UPDATE.js b/src/client/websocket/handlers/GUILD_UPDATE.js
new file mode 100644
index 00000000..fd0012ad
--- /dev/null
+++ b/src/client/websocket/handlers/GUILD_UPDATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.GuildUpdate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/INVITE_CREATE.js b/src/client/websocket/handlers/INVITE_CREATE.js
new file mode 100644
index 00000000..50a2e72d
--- /dev/null
+++ b/src/client/websocket/handlers/INVITE_CREATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.InviteCreate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/INVITE_DELETE.js b/src/client/websocket/handlers/INVITE_DELETE.js
new file mode 100644
index 00000000..59718523
--- /dev/null
+++ b/src/client/websocket/handlers/INVITE_DELETE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.InviteDelete.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/MESSAGE_CREATE.js b/src/client/websocket/handlers/MESSAGE_CREATE.js
new file mode 100644
index 00000000..c9b79a8f
--- /dev/null
+++ b/src/client/websocket/handlers/MESSAGE_CREATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.MessageCreate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/MESSAGE_DELETE.js b/src/client/websocket/handlers/MESSAGE_DELETE.js
new file mode 100644
index 00000000..85ae2bc7
--- /dev/null
+++ b/src/client/websocket/handlers/MESSAGE_DELETE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.MessageDelete.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/MESSAGE_DELETE_BULK.js b/src/client/websocket/handlers/MESSAGE_DELETE_BULK.js
new file mode 100644
index 00000000..fbcf80fd
--- /dev/null
+++ b/src/client/websocket/handlers/MESSAGE_DELETE_BULK.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.MessageDeleteBulk.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/MESSAGE_REACTION_ADD.js b/src/client/websocket/handlers/MESSAGE_REACTION_ADD.js
new file mode 100644
index 00000000..e219b4a5
--- /dev/null
+++ b/src/client/websocket/handlers/MESSAGE_REACTION_ADD.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.MessageReactionAdd.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE.js b/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE.js
new file mode 100644
index 00000000..2980e695
--- /dev/null
+++ b/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.MessageReactionRemove.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE_ALL.js b/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE_ALL.js
new file mode 100644
index 00000000..ead80f75
--- /dev/null
+++ b/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE_ALL.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.MessageReactionRemoveAll.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE_EMOJI.js b/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE_EMOJI.js
new file mode 100644
index 00000000..579444c9
--- /dev/null
+++ b/src/client/websocket/handlers/MESSAGE_REACTION_REMOVE_EMOJI.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.MessageReactionRemoveEmoji.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/MESSAGE_UPDATE.js b/src/client/websocket/handlers/MESSAGE_UPDATE.js
new file mode 100644
index 00000000..7428e90c
--- /dev/null
+++ b/src/client/websocket/handlers/MESSAGE_UPDATE.js
@@ -0,0 +1,16 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, packet) => {
+  const { old, updated } = client.actions.MessageUpdate.handle(packet.d);
+  if (old && updated) {
+    /**
+     * Emitted whenever a message is updated - e.g. embed or content change.
+     * @event Client#messageUpdate
+     * @param {Message} oldMessage The message before the update
+     * @param {Message} newMessage The message after the update
+     */
+    client.emit(Events.MESSAGE_UPDATE, old, updated);
+  }
+};
diff --git a/src/client/websocket/handlers/PRESENCE_UPDATE.js b/src/client/websocket/handlers/PRESENCE_UPDATE.js
new file mode 100644
index 00000000..bde36297
--- /dev/null
+++ b/src/client/websocket/handlers/PRESENCE_UPDATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.PresenceUpdate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/READY.js b/src/client/websocket/handlers/READY.js
new file mode 100644
index 00000000..c38b681c
--- /dev/null
+++ b/src/client/websocket/handlers/READY.js
@@ -0,0 +1,21 @@
+'use strict';
+
+let ClientUser;
+
+module.exports = (client, { d: data }, shard) => {
+  if (client.user) {
+    client.user._patch(data.user);
+  } else {
+    if (!ClientUser) ClientUser = require('../../../structures/ClientUser');
+    const clientUser = new ClientUser(client, data.user);
+    client.user = clientUser;
+    client.users.cache.set(clientUser.id, clientUser);
+  }
+
+  for (const guild of data.guilds) {
+    guild.shardID = shard.id;
+    client.guilds.add(guild);
+  }
+
+  shard.checkReady();
+};
diff --git a/src/client/websocket/handlers/RESUMED.js b/src/client/websocket/handlers/RESUMED.js
new file mode 100644
index 00000000..5e5f403a
--- /dev/null
+++ b/src/client/websocket/handlers/RESUMED.js
@@ -0,0 +1,14 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, packet, shard) => {
+  const replayed = shard.sequence - shard.closeSequence;
+  /**
+   * Emitted when a shard resumes successfully.
+   * @event Client#shardResume
+   * @param {number} id The shard ID that resumed
+   * @param {number} replayedEvents The amount of replayed events
+   */
+  client.emit(Events.SHARD_RESUME, shard.id, replayed);
+};
diff --git a/src/client/websocket/handlers/TYPING_START.js b/src/client/websocket/handlers/TYPING_START.js
new file mode 100644
index 00000000..426c96f1
--- /dev/null
+++ b/src/client/websocket/handlers/TYPING_START.js
@@ -0,0 +1,18 @@
+'use strict';
+
+const { Events } = require('../../../util/Constants');
+
+module.exports = (client, { d: data }) => {
+  const channel = client.channels.cache.get(data.channel_id);
+  const user = client.users.cache.get(data.user_id);
+
+  if (channel && user) {
+    /**
+     * Emitted whenever a user starts typing in a channel.
+     * @event Client#typingStart
+     * @param {Channel} channel The channel the user started typing in
+     * @param {User} user The user that started typing
+     */
+    client.emit(Events.TYPING_START, channel, user);
+  }
+};
diff --git a/src/client/websocket/handlers/USER_UPDATE.js b/src/client/websocket/handlers/USER_UPDATE.js
new file mode 100644
index 00000000..a02bf588
--- /dev/null
+++ b/src/client/websocket/handlers/USER_UPDATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.UserUpdate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/VOICE_SERVER_UPDATE.js b/src/client/websocket/handlers/VOICE_SERVER_UPDATE.js
new file mode 100644
index 00000000..f9cf5343
--- /dev/null
+++ b/src/client/websocket/handlers/VOICE_SERVER_UPDATE.js
@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.emit('debug', `[VOICE] received voice server: ${JSON.stringify(packet)}`);
+  client.voice.onVoiceServer(packet.d);
+};
diff --git a/src/client/websocket/handlers/VOICE_STATE_UPDATE.js b/src/client/websocket/handlers/VOICE_STATE_UPDATE.js
new file mode 100644
index 00000000..dbff6ea2
--- /dev/null
+++ b/src/client/websocket/handlers/VOICE_STATE_UPDATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.VoiceStateUpdate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/WEBHOOKS_UPDATE.js b/src/client/websocket/handlers/WEBHOOKS_UPDATE.js
new file mode 100644
index 00000000..46cacee0
--- /dev/null
+++ b/src/client/websocket/handlers/WEBHOOKS_UPDATE.js
@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.WebhooksUpdate.handle(packet.d);
+};
diff --git a/src/client/websocket/handlers/index.js b/src/client/websocket/handlers/index.js
new file mode 100644
index 00000000..d69c105f
--- /dev/null
+++ b/src/client/websocket/handlers/index.js
@@ -0,0 +1,13 @@
+'use strict';
+
+const { WSEvents } = require('../../../util/Constants');
+
+const handlers = {};
+
+for (const name of Object.keys(WSEvents)) {
+  try {
+    handlers[name] = require(`./${name}.js`);
+  } catch {} // eslint-disable-line no-empty
+}
+
+module.exports = handlers;
diff --git a/src/client/websocket/packets/WebSocketPacketManager.js b/src/client/websocket/packets/WebSocketPacketManager.js
deleted file mode 100644
index a5887138..00000000
--- a/src/client/websocket/packets/WebSocketPacketManager.js
+++ /dev/null
@@ -1,104 +0,0 @@
-const { OPCodes, Status, WSEvents } = require('../../../util/Constants');
-
-const BeforeReadyWhitelist = [
-  WSEvents.READY,
-  WSEvents.RESUMED,
-  WSEvents.GUILD_CREATE,
-  WSEvents.GUILD_DELETE,
-  WSEvents.GUILD_MEMBERS_CHUNK,
-  WSEvents.GUILD_MEMBER_ADD,
-  WSEvents.GUILD_MEMBER_REMOVE,
-];
-
-class WebSocketPacketManager {
-  constructor(connection) {
-    this.ws = connection;
-    this.handlers = {};
-    this.queue = [];
-
-    this.register(WSEvents.READY, require('./handlers/Ready'));
-    this.register(WSEvents.RESUMED, require('./handlers/Resumed'));
-    this.register(WSEvents.GUILD_CREATE, require('./handlers/GuildCreate'));
-    this.register(WSEvents.GUILD_DELETE, require('./handlers/GuildDelete'));
-    this.register(WSEvents.GUILD_UPDATE, require('./handlers/GuildUpdate'));
-    this.register(WSEvents.GUILD_BAN_ADD, require('./handlers/GuildBanAdd'));
-    this.register(WSEvents.GUILD_BAN_REMOVE, require('./handlers/GuildBanRemove'));
-    this.register(WSEvents.GUILD_MEMBER_ADD, require('./handlers/GuildMemberAdd'));
-    this.register(WSEvents.GUILD_MEMBER_REMOVE, require('./handlers/GuildMemberRemove'));
-    this.register(WSEvents.GUILD_MEMBER_UPDATE, require('./handlers/GuildMemberUpdate'));
-    this.register(WSEvents.GUILD_ROLE_CREATE, require('./handlers/GuildRoleCreate'));
-    this.register(WSEvents.GUILD_ROLE_DELETE, require('./handlers/GuildRoleDelete'));
-    this.register(WSEvents.GUILD_ROLE_UPDATE, require('./handlers/GuildRoleUpdate'));
-    this.register(WSEvents.GUILD_EMOJIS_UPDATE, require('./handlers/GuildEmojisUpdate'));
-    this.register(WSEvents.GUILD_MEMBERS_CHUNK, require('./handlers/GuildMembersChunk'));
-    this.register(WSEvents.GUILD_INTEGRATIONS_UPDATE, require('./handlers/GuildIntegrationsUpdate'));
-    this.register(WSEvents.CHANNEL_CREATE, require('./handlers/ChannelCreate'));
-    this.register(WSEvents.CHANNEL_DELETE, require('./handlers/ChannelDelete'));
-    this.register(WSEvents.CHANNEL_UPDATE, require('./handlers/ChannelUpdate'));
-    this.register(WSEvents.CHANNEL_PINS_UPDATE, require('./handlers/ChannelPinsUpdate'));
-    this.register(WSEvents.PRESENCE_UPDATE, require('./handlers/PresenceUpdate'));
-    this.register(WSEvents.USER_UPDATE, require('./handlers/UserUpdate'));
-    this.register(WSEvents.VOICE_STATE_UPDATE, require('./handlers/VoiceStateUpdate'));
-    this.register(WSEvents.TYPING_START, require('./handlers/TypingStart'));
-    this.register(WSEvents.MESSAGE_CREATE, require('./handlers/MessageCreate'));
-    this.register(WSEvents.MESSAGE_DELETE, require('./handlers/MessageDelete'));
-    this.register(WSEvents.MESSAGE_UPDATE, require('./handlers/MessageUpdate'));
-    this.register(WSEvents.MESSAGE_DELETE_BULK, require('./handlers/MessageDeleteBulk'));
-    this.register(WSEvents.VOICE_SERVER_UPDATE, require('./handlers/VoiceServerUpdate'));
-    this.register(WSEvents.MESSAGE_REACTION_ADD, require('./handlers/MessageReactionAdd'));
-    this.register(WSEvents.MESSAGE_REACTION_REMOVE, require('./handlers/MessageReactionRemove'));
-    this.register(WSEvents.MESSAGE_REACTION_REMOVE_ALL, require('./handlers/MessageReactionRemoveAll'));
-    this.register(WSEvents.WEBHOOKS_UPDATE, require('./handlers/WebhooksUpdate'));
-  }
-
-  get client() {
-    return this.ws.client;
-  }
-
-  register(event, Handler) {
-    this.handlers[event] = new Handler(this);
-  }
-
-  handleQueue() {
-    this.queue.forEach((element, index) => {
-      this.handle(this.queue[index], true);
-      this.queue.splice(index, 1);
-    });
-  }
-
-  handle(packet, queue = false) {
-    if (packet.op === OPCodes.HEARTBEAT_ACK) {
-      this.ws.client._pong(this.ws.client._pingTimestamp);
-      this.ws.lastHeartbeatAck = true;
-      this.ws.client.emit('debug', 'Heartbeat acknowledged');
-    } else if (packet.op === OPCodes.HEARTBEAT) {
-      this.client.ws.send({
-        op: OPCodes.HEARTBEAT,
-        d: this.client.ws.sequence,
-      });
-      this.ws.client.emit('debug', 'Received gateway heartbeat');
-    }
-
-    if (this.ws.status === Status.RECONNECTING) {
-      this.ws.reconnecting = false;
-      this.ws.checkIfReady();
-    }
-
-    this.ws.setSequence(packet.s);
-
-    if (this.ws.disabledEvents[packet.t] !== undefined) return false;
-
-    if (this.ws.status !== Status.READY) {
-      if (BeforeReadyWhitelist.indexOf(packet.t) === -1) {
-        this.queue.push(packet);
-        return false;
-      }
-    }
-
-    if (!queue && this.queue.length > 0) this.handleQueue();
-    if (this.handlers[packet.t]) return this.handlers[packet.t].handle(packet);
-    return false;
-  }
-}
-
-module.exports = WebSocketPacketManager;
diff --git a/src/client/websocket/packets/handlers/AbstractHandler.js b/src/client/websocket/packets/handlers/AbstractHandler.js
deleted file mode 100644
index c1c2a5a2..00000000
--- a/src/client/websocket/packets/handlers/AbstractHandler.js
+++ /dev/null
@@ -1,11 +0,0 @@
-class AbstractHandler {
-  constructor(packetManager) {
-    this.packetManager = packetManager;
-  }
-
-  handle(packet) {
-    return packet;
-  }
-}
-
-module.exports = AbstractHandler;
diff --git a/src/client/websocket/packets/handlers/ChannelCreate.js b/src/client/websocket/packets/handlers/ChannelCreate.js
deleted file mode 100644
index 5ccc0570..00000000
--- a/src/client/websocket/packets/handlers/ChannelCreate.js
+++ /dev/null
@@ -1,15 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class ChannelCreateHandler extends AbstractHandler {
-  handle(packet) {
-    this.packetManager.client.actions.ChannelCreate.handle(packet.d);
-  }
-}
-
-module.exports = ChannelCreateHandler;
-
-/**
- * Emitted whenever a channel is created.
- * @event Client#channelCreate
- * @param {DMChannel|GroupDMChannel|GuildChannel} channel The channel that was created
- */
diff --git a/src/client/websocket/packets/handlers/ChannelDelete.js b/src/client/websocket/packets/handlers/ChannelDelete.js
deleted file mode 100644
index 68eb9a90..00000000
--- a/src/client/websocket/packets/handlers/ChannelDelete.js
+++ /dev/null
@@ -1,9 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class ChannelDeleteHandler extends AbstractHandler {
-  handle(packet) {
-    this.packetManager.client.actions.ChannelDelete.handle(packet.d);
-  }
-}
-
-module.exports = ChannelDeleteHandler;
diff --git a/src/client/websocket/packets/handlers/ChannelPinsUpdate.js b/src/client/websocket/packets/handlers/ChannelPinsUpdate.js
deleted file mode 100644
index b8cb6401..00000000
--- a/src/client/websocket/packets/handlers/ChannelPinsUpdate.js
+++ /dev/null
@@ -1,37 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-
-/*
-{ t: 'CHANNEL_PINS_UPDATE',
-  s: 666,
-  op: 0,
-  d:
-   { last_pin_timestamp: '2016-08-28T17:37:13.171774+00:00',
-     channel_id: '314866471639044027' } }
-*/
-
-class ChannelPinsUpdate extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    const channel = client.channels.get(data.channel_id);
-    const time = new Date(data.last_pin_timestamp);
-    if (channel && time) {
-      // Discord sends null for last_pin_timestamp if the last pinned message was removed
-      channel.lastPinTimestamp = time.getTime() || null;
-
-      client.emit(Events.CHANNEL_PINS_UPDATE, channel, time);
-    }
-  }
-}
-
-module.exports = ChannelPinsUpdate;
-
-/**
- * Emitted whenever the pins of a channel are updated. Due to the nature of the WebSocket event, not much information
- * can be provided easily here - you need to manually check the pins yourself.
- * <warn>The `time` parameter will be a Unix Epoch Date object when there are no pins left.</warn>
- * @event Client#channelPinsUpdate
- * @param {DMChannel|GroupDMChannel|TextChannel} channel The channel that the pins update occurred in
- * @param {Date} time The time when the last pinned message was pinned
- */
diff --git a/src/client/websocket/packets/handlers/ChannelUpdate.js b/src/client/websocket/packets/handlers/ChannelUpdate.js
deleted file mode 100644
index f0d1873a..00000000
--- a/src/client/websocket/packets/handlers/ChannelUpdate.js
+++ /dev/null
@@ -1,20 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-
-class ChannelUpdateHandler extends AbstractHandler {
-  handle(packet) {
-    const { old, updated } = this.packetManager.client.actions.ChannelUpdate.handle(packet.d);
-    if (old && updated) {
-      this.packetManager.client.emit(Events.CHANNEL_UPDATE, old, updated);
-    }
-  }
-}
-
-module.exports = ChannelUpdateHandler;
-
-/**
- * Emitted whenever a channel is updated - e.g. name change, topic change.
- * @event Client#channelUpdate
- * @param {DMChannel|GroupDMChannel|GuildChannel} oldChannel The channel before the update
- * @param {DMChannel|GroupDMChannel|GuildChannel} newChannel The channel after the update
- */
diff --git a/src/client/websocket/packets/handlers/GuildBanAdd.js b/src/client/websocket/packets/handlers/GuildBanAdd.js
deleted file mode 100644
index 89f57b78..00000000
--- a/src/client/websocket/packets/handlers/GuildBanAdd.js
+++ /dev/null
@@ -1,23 +0,0 @@
-// ##untested handler##
-
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-
-class GuildBanAddHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    const guild = client.guilds.get(data.guild_id);
-    const user = client.users.add(data.user);
-    if (guild && user) client.emit(Events.GUILD_BAN_ADD, guild, user);
-  }
-}
-
-/**
- * Emitted whenever a member is banned from a guild.
- * @event Client#guildBanAdd
- * @param {Guild} guild The guild that the ban occurred in
- * @param {User} user The user that was banned
- */
-
-module.exports = GuildBanAddHandler;
diff --git a/src/client/websocket/packets/handlers/GuildBanRemove.js b/src/client/websocket/packets/handlers/GuildBanRemove.js
deleted file mode 100644
index c4edbdeb..00000000
--- a/src/client/websocket/packets/handlers/GuildBanRemove.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// ##untested handler##
-
-const AbstractHandler = require('./AbstractHandler');
-
-class GuildBanRemoveHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.actions.GuildBanRemove.handle(data);
-  }
-}
-
-/**
- * Emitted whenever a member is unbanned from a guild.
- * @event Client#guildBanRemove
- * @param {Guild} guild The guild that the unban occurred in
- * @param {User} user The user that was unbanned
- */
-
-module.exports = GuildBanRemoveHandler;
diff --git a/src/client/websocket/packets/handlers/GuildCreate.js b/src/client/websocket/packets/handlers/GuildCreate.js
deleted file mode 100644
index 96c5ae98..00000000
--- a/src/client/websocket/packets/handlers/GuildCreate.js
+++ /dev/null
@@ -1,33 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events, Status } = require('../../../../util/Constants');
-
-class GuildCreateHandler extends AbstractHandler {
-  async handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-
-    let guild = client.guilds.get(data.id);
-    if (guild) {
-      if (!guild.available && !data.unavailable) {
-        // A newly available guild
-        guild._patch(data);
-        this.packetManager.ws.checkIfReady();
-      }
-    } else {
-      // A new guild
-      guild = client.guilds.add(data);
-      const emitEvent = client.ws.connection.status === Status.READY;
-      if (emitEvent) {
-        /**
-         * Emitted whenever the client joins a guild.
-         * @event Client#guildCreate
-         * @param {Guild} guild The created guild
-         */
-        if (client.options.fetchAllMembers) await guild.members.fetch();
-        client.emit(Events.GUILD_CREATE, guild);
-      }
-    }
-  }
-}
-
-module.exports = GuildCreateHandler;
diff --git a/src/client/websocket/packets/handlers/GuildDelete.js b/src/client/websocket/packets/handlers/GuildDelete.js
deleted file mode 100644
index 58d60bc1..00000000
--- a/src/client/websocket/packets/handlers/GuildDelete.js
+++ /dev/null
@@ -1,16 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class GuildDeleteHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    client.actions.GuildDelete.handle(packet.d);
-  }
-}
-
-/**
- * Emitted whenever a guild kicks the client or the guild is deleted/left.
- * @event Client#guildDelete
- * @param {Guild} guild The guild that was deleted
- */
-
-module.exports = GuildDeleteHandler;
diff --git a/src/client/websocket/packets/handlers/GuildEmojisUpdate.js b/src/client/websocket/packets/handlers/GuildEmojisUpdate.js
deleted file mode 100644
index 2906e74f..00000000
--- a/src/client/websocket/packets/handlers/GuildEmojisUpdate.js
+++ /dev/null
@@ -1,11 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class GuildEmojisUpdate extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.actions.GuildEmojisUpdate.handle(data);
-  }
-}
-
-module.exports = GuildEmojisUpdate;
diff --git a/src/client/websocket/packets/handlers/GuildIntegrationsUpdate.js b/src/client/websocket/packets/handlers/GuildIntegrationsUpdate.js
deleted file mode 100644
index 5adfb5b0..00000000
--- a/src/client/websocket/packets/handlers/GuildIntegrationsUpdate.js
+++ /dev/null
@@ -1,19 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-
-class GuildIntegrationsHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    const guild = client.guilds.get(data.guild_id);
-    if (guild) client.emit(Events.GUILD_INTEGRATIONS_UPDATE, guild);
-  }
-}
-
-module.exports = GuildIntegrationsHandler;
-
-/**
- * Emitted whenever a guild integration is updated
- * @event Client#guildIntegrationsUpdate
- * @param {Guild} guild The guild whose integrations were updated
- */
diff --git a/src/client/websocket/packets/handlers/GuildMemberAdd.js b/src/client/websocket/packets/handlers/GuildMemberAdd.js
deleted file mode 100644
index 15201b82..00000000
--- a/src/client/websocket/packets/handlers/GuildMemberAdd.js
+++ /dev/null
@@ -1,27 +0,0 @@
-// ##untested handler##
-
-const AbstractHandler = require('./AbstractHandler');
-const { Events, Status } = require('../../../../util/Constants');
-
-class GuildMemberAddHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    const guild = client.guilds.get(data.guild_id);
-    if (guild) {
-      guild.memberCount++;
-      const member = guild.members.add(data);
-      if (client.ws.connection.status === Status.READY) {
-        client.emit(Events.GUILD_MEMBER_ADD, member);
-      }
-    }
-  }
-}
-
-module.exports = GuildMemberAddHandler;
-
-/**
- * Emitted whenever a user joins a guild.
- * @event Client#guildMemberAdd
- * @param {GuildMember} member The member that has joined a guild
- */
diff --git a/src/client/websocket/packets/handlers/GuildMemberRemove.js b/src/client/websocket/packets/handlers/GuildMemberRemove.js
deleted file mode 100644
index 6ec1bfe6..00000000
--- a/src/client/websocket/packets/handlers/GuildMemberRemove.js
+++ /dev/null
@@ -1,13 +0,0 @@
-// ##untested handler##
-
-const AbstractHandler = require('./AbstractHandler');
-
-class GuildMemberRemoveHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.actions.GuildMemberRemove.handle(data);
-  }
-}
-
-module.exports = GuildMemberRemoveHandler;
diff --git a/src/client/websocket/packets/handlers/GuildMemberUpdate.js b/src/client/websocket/packets/handlers/GuildMemberUpdate.js
deleted file mode 100644
index 90189369..00000000
--- a/src/client/websocket/packets/handlers/GuildMemberUpdate.js
+++ /dev/null
@@ -1,29 +0,0 @@
-// ##untested handler##
-
-const AbstractHandler = require('./AbstractHandler');
-const { Events, Status } = require('../../../../util/Constants');
-
-class GuildMemberUpdateHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    const guild = client.guilds.get(data.guild_id);
-    if (guild) {
-      const member = guild.members.get(data.user.id);
-      if (member) {
-        const old = member._update(data);
-        if (client.ws.connection.status === Status.READY) {
-          /**
-           * Emitted whenever a guild member's details (e.g. role, nickname) are changed
-           * @event Client#guildMemberUpdate
-           * @param {GuildMember} oldMember The member before the update
-           * @param {GuildMember} newMember The member after the update
-           */
-          client.emit(Events.GUILD_MEMBER_UPDATE, old, member);
-        }
-      }
-    }
-  }
-}
-
-module.exports = GuildMemberUpdateHandler;
diff --git a/src/client/websocket/packets/handlers/GuildMembersChunk.js b/src/client/websocket/packets/handlers/GuildMembersChunk.js
deleted file mode 100644
index 4e821f5c..00000000
--- a/src/client/websocket/packets/handlers/GuildMembersChunk.js
+++ /dev/null
@@ -1,28 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-const Collection = require('../../../../util/Collection');
-
-class GuildMembersChunkHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    const guild = client.guilds.get(data.guild_id);
-    if (!guild) return;
-    const members = new Collection();
-
-    for (const member of data.members) members.set(member.user.id, guild.members.add(member));
-
-    client.emit(Events.GUILD_MEMBERS_CHUNK, members, guild);
-
-    client.ws.lastHeartbeatAck = true;
-  }
-}
-
-/**
- * Emitted whenever a chunk of guild members is received (all members come from the same guild).
- * @event Client#guildMembersChunk
- * @param {Collection<Snowflake, GuildMember>} members The members in the chunk
- * @param {Guild} guild The guild related to the member chunk
- */
-
-module.exports = GuildMembersChunkHandler;
diff --git a/src/client/websocket/packets/handlers/GuildRoleCreate.js b/src/client/websocket/packets/handlers/GuildRoleCreate.js
deleted file mode 100644
index 8581d53f..00000000
--- a/src/client/websocket/packets/handlers/GuildRoleCreate.js
+++ /dev/null
@@ -1,11 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class GuildRoleCreateHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.actions.GuildRoleCreate.handle(data);
-  }
-}
-
-module.exports = GuildRoleCreateHandler;
diff --git a/src/client/websocket/packets/handlers/GuildRoleDelete.js b/src/client/websocket/packets/handlers/GuildRoleDelete.js
deleted file mode 100644
index 63439b0f..00000000
--- a/src/client/websocket/packets/handlers/GuildRoleDelete.js
+++ /dev/null
@@ -1,11 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class GuildRoleDeleteHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.actions.GuildRoleDelete.handle(data);
-  }
-}
-
-module.exports = GuildRoleDeleteHandler;
diff --git a/src/client/websocket/packets/handlers/GuildRoleUpdate.js b/src/client/websocket/packets/handlers/GuildRoleUpdate.js
deleted file mode 100644
index 6fbdc109..00000000
--- a/src/client/websocket/packets/handlers/GuildRoleUpdate.js
+++ /dev/null
@@ -1,11 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class GuildRoleUpdateHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.actions.GuildRoleUpdate.handle(data);
-  }
-}
-
-module.exports = GuildRoleUpdateHandler;
diff --git a/src/client/websocket/packets/handlers/GuildUpdate.js b/src/client/websocket/packets/handlers/GuildUpdate.js
deleted file mode 100644
index 70eff52c..00000000
--- a/src/client/websocket/packets/handlers/GuildUpdate.js
+++ /dev/null
@@ -1,11 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class GuildUpdateHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.actions.GuildUpdate.handle(data);
-  }
-}
-
-module.exports = GuildUpdateHandler;
diff --git a/src/client/websocket/packets/handlers/MessageCreate.js b/src/client/websocket/packets/handlers/MessageCreate.js
deleted file mode 100644
index 31f5f280..00000000
--- a/src/client/websocket/packets/handlers/MessageCreate.js
+++ /dev/null
@@ -1,9 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class MessageCreateHandler extends AbstractHandler {
-  handle(packet) {
-    this.packetManager.client.actions.MessageCreate.handle(packet.d);
-  }
-}
-
-module.exports = MessageCreateHandler;
diff --git a/src/client/websocket/packets/handlers/MessageDelete.js b/src/client/websocket/packets/handlers/MessageDelete.js
deleted file mode 100644
index 831a0ae0..00000000
--- a/src/client/websocket/packets/handlers/MessageDelete.js
+++ /dev/null
@@ -1,9 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class MessageDeleteHandler extends AbstractHandler {
-  handle(packet) {
-    this.packetManager.client.actions.MessageDelete.handle(packet.d);
-  }
-}
-
-module.exports = MessageDeleteHandler;
diff --git a/src/client/websocket/packets/handlers/MessageDeleteBulk.js b/src/client/websocket/packets/handlers/MessageDeleteBulk.js
deleted file mode 100644
index 0077dbf8..00000000
--- a/src/client/websocket/packets/handlers/MessageDeleteBulk.js
+++ /dev/null
@@ -1,9 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class MessageDeleteBulkHandler extends AbstractHandler {
-  handle(packet) {
-    this.packetManager.client.actions.MessageDeleteBulk.handle(packet.d);
-  }
-}
-
-module.exports = MessageDeleteBulkHandler;
diff --git a/src/client/websocket/packets/handlers/MessageReactionAdd.js b/src/client/websocket/packets/handlers/MessageReactionAdd.js
deleted file mode 100644
index 34e5c613..00000000
--- a/src/client/websocket/packets/handlers/MessageReactionAdd.js
+++ /dev/null
@@ -1,13 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-
-class MessageReactionAddHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    const { user, reaction } = client.actions.MessageReactionAdd.handle(data);
-    if (reaction) client.emit(Events.MESSAGE_REACTION_ADD, reaction, user);
-  }
-}
-
-module.exports = MessageReactionAddHandler;
diff --git a/src/client/websocket/packets/handlers/MessageReactionRemove.js b/src/client/websocket/packets/handlers/MessageReactionRemove.js
deleted file mode 100644
index cddde703..00000000
--- a/src/client/websocket/packets/handlers/MessageReactionRemove.js
+++ /dev/null
@@ -1,11 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class MessageReactionRemove extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.actions.MessageReactionRemove.handle(data);
-  }
-}
-
-module.exports = MessageReactionRemove;
diff --git a/src/client/websocket/packets/handlers/MessageReactionRemoveAll.js b/src/client/websocket/packets/handlers/MessageReactionRemoveAll.js
deleted file mode 100644
index 303da9ca..00000000
--- a/src/client/websocket/packets/handlers/MessageReactionRemoveAll.js
+++ /dev/null
@@ -1,11 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class MessageReactionRemoveAll extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.actions.MessageReactionRemoveAll.handle(data);
-  }
-}
-
-module.exports = MessageReactionRemoveAll;
diff --git a/src/client/websocket/packets/handlers/MessageUpdate.js b/src/client/websocket/packets/handlers/MessageUpdate.js
deleted file mode 100644
index 33e45b19..00000000
--- a/src/client/websocket/packets/handlers/MessageUpdate.js
+++ /dev/null
@@ -1,20 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-
-class MessageUpdateHandler extends AbstractHandler {
-  handle(packet) {
-    const { old, updated } = this.packetManager.client.actions.MessageUpdate.handle(packet.d);
-    if (old && updated) {
-      this.packetManager.client.emit(Events.MESSAGE_UPDATE, old, updated);
-    }
-  }
-}
-
-module.exports = MessageUpdateHandler;
-
-/**
- * Emitted whenever a message is updated - e.g. embed or content change.
- * @event Client#messageUpdate
- * @param {Message} oldMessage The message before the update
- * @param {Message} newMessage The message after the update
- */
diff --git a/src/client/websocket/packets/handlers/PresenceUpdate.js b/src/client/websocket/packets/handlers/PresenceUpdate.js
deleted file mode 100644
index 2892d44c..00000000
--- a/src/client/websocket/packets/handlers/PresenceUpdate.js
+++ /dev/null
@@ -1,68 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-
-class PresenceUpdateHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    let user = client.users.get(data.user.id);
-    const guild = client.guilds.get(data.guild_id);
-
-    // Step 1
-    if (!user) {
-      if (data.user.username) {
-        user = client.users.add(data.user);
-      } else {
-        return;
-      }
-    }
-
-    const oldUser = user._update(data.user);
-    if (!user.equals(oldUser)) {
-      client.emit(Events.USER_UPDATE, oldUser, user);
-    }
-
-    if (guild) {
-      let oldPresence = guild.presences.get(user.id);
-      if (oldPresence) oldPresence = oldPresence._clone();
-      let member = guild.members.get(user.id);
-      if (!member && data.status !== 'offline') {
-        member = guild.members.add({
-          user,
-          roles: data.roles,
-          deaf: false,
-          mute: false,
-        });
-        client.emit(Events.GUILD_MEMBER_AVAILABLE, member);
-      }
-      guild.presences.add(Object.assign(data, { guild }));
-      if (member && client.listenerCount(Events.PRESENCE_UPDATE)) {
-        client.emit(Events.PRESENCE_UPDATE, oldPresence, member.presence);
-      }
-    }
-  }
-}
-
-/**
- * Emitted whenever a guild member's presence (e.g. status, activity) is changed.
- * @event Client#presenceUpdate
- * @param {?Presence} oldPresence The presence before the update, if one at all
- * @param {Presence} newPresence The presence after the update
- */
-
-/**
- * Emitted whenever a user's details (e.g. username, avatar) are changed.
- * <info>Disabling {@link Client#presenceUpdate} will cause this event to only fire
- * on {@link ClientUser} update.</info>
- * @event Client#userUpdate
- * @param {User} oldUser The user before the update
- * @param {User} newUser The user after the update
- */
-
-/**
- * Emitted whenever a member becomes available in a large guild.
- * @event Client#guildMemberAvailable
- * @param {GuildMember} member The member that became available
- */
-
-module.exports = PresenceUpdateHandler;
diff --git a/src/client/websocket/packets/handlers/Ready.js b/src/client/websocket/packets/handlers/Ready.js
deleted file mode 100644
index 5b14c833..00000000
--- a/src/client/websocket/packets/handlers/Ready.js
+++ /dev/null
@@ -1,41 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-let ClientUser;
-
-class ReadyHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-
-    client.ws.heartbeat();
-
-    client.presence.userID = data.user.id;
-    if (!ClientUser) ClientUser = require('../../../../structures/ClientUser');
-    const clientUser = new ClientUser(client, data.user);
-    client.user = clientUser;
-    client.readyAt = new Date();
-    client.users.set(clientUser.id, clientUser);
-
-    for (const guild of data.guilds) client.guilds.add(guild);
-
-    const t = client.setTimeout(() => {
-      client.ws.connection.triggerReady();
-    }, 1200 * data.guilds.length);
-
-    client.setMaxListeners(data.guilds.length + 10);
-
-    client.once('ready', () => {
-      client.setMaxListeners(10);
-      client.clearTimeout(t);
-    });
-
-    const ws = this.packetManager.ws;
-
-    ws.sessionID = data.session_id;
-    ws._trace = data._trace;
-    client.emit(Events.DEBUG, `READY ${ws._trace.join(' -> ')} ${ws.sessionID}`);
-    ws.checkIfReady();
-  }
-}
-
-module.exports = ReadyHandler;
diff --git a/src/client/websocket/packets/handlers/Resumed.js b/src/client/websocket/packets/handlers/Resumed.js
deleted file mode 100644
index cd7cab77..00000000
--- a/src/client/websocket/packets/handlers/Resumed.js
+++ /dev/null
@@ -1,28 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events, Status } = require('../../../../util/Constants');
-
-class ResumedHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const ws = client.ws.connection;
-
-    ws._trace = packet.d._trace;
-
-    ws.status = Status.READY;
-    this.packetManager.handleQueue();
-
-    const replayed = ws.sequence - ws.closeSequence;
-
-    ws.debug(`RESUMED ${ws._trace.join(' -> ')} | replayed ${replayed} events.`);
-    client.emit(Events.RESUMED, replayed);
-    ws.heartbeat();
-  }
-}
-
-/**
- * Emitted whenever a WebSocket resumes.
- * @event Client#resumed
- * @param {number} replayed The number of events that were replayed
- */
-
-module.exports = ResumedHandler;
diff --git a/src/client/websocket/packets/handlers/TypingStart.js b/src/client/websocket/packets/handlers/TypingStart.js
deleted file mode 100644
index 52a0f6ba..00000000
--- a/src/client/websocket/packets/handlers/TypingStart.js
+++ /dev/null
@@ -1,68 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-
-class TypingStartHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    const channel = client.channels.get(data.channel_id);
-    const user = client.users.get(data.user_id);
-    const timestamp = new Date(data.timestamp * 1000);
-
-    if (channel && user) {
-      if (channel.type === 'voice') {
-        client.emit(Events.WARN, `Discord sent a typing packet to voice channel ${channel.id}`);
-        return;
-      }
-      if (channel._typing.has(user.id)) {
-        const typing = channel._typing.get(user.id);
-        typing.lastTimestamp = timestamp;
-        typing.resetTimeout(tooLate(channel, user));
-      } else {
-        channel._typing.set(user.id, new TypingData(client, timestamp, timestamp, tooLate(channel, user)));
-        client.emit(Events.TYPING_START, channel, user);
-      }
-    }
-  }
-}
-
-class TypingData {
-  constructor(client, since, lastTimestamp, _timeout) {
-    this.client = client;
-    this.since = since;
-    this.lastTimestamp = lastTimestamp;
-    this._timeout = _timeout;
-  }
-
-  resetTimeout(_timeout) {
-    this.client.clearTimeout(this._timeout);
-    this._timeout = _timeout;
-  }
-
-  get elapsedTime() {
-    return Date.now() - this.since;
-  }
-}
-
-function tooLate(channel, user) {
-  return channel.client.setTimeout(() => {
-    channel.client.emit(Events.TYPING_STOP, channel, user, channel._typing.get(user.id));
-    channel._typing.delete(user.id);
-  }, 6000);
-}
-
-/**
- * Emitted whenever a user starts typing in a channel.
- * @event Client#typingStart
- * @param {Channel} channel The channel the user started typing in
- * @param {User} user The user that started typing
- */
-
-/**
- * Emitted whenever a user stops typing in a channel.
- * @event Client#typingStop
- * @param {Channel} channel The channel the user stopped typing in
- * @param {User} user The user that stopped typing
- */
-
-module.exports = TypingStartHandler;
diff --git a/src/client/websocket/packets/handlers/UserUpdate.js b/src/client/websocket/packets/handlers/UserUpdate.js
deleted file mode 100644
index bc34f347..00000000
--- a/src/client/websocket/packets/handlers/UserUpdate.js
+++ /dev/null
@@ -1,11 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-class UserUpdateHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.actions.UserUpdate.handle(data);
-  }
-}
-
-module.exports = UserUpdateHandler;
diff --git a/src/client/websocket/packets/handlers/VoiceServerUpdate.js b/src/client/websocket/packets/handlers/VoiceServerUpdate.js
deleted file mode 100644
index 97885d6c..00000000
--- a/src/client/websocket/packets/handlers/VoiceServerUpdate.js
+++ /dev/null
@@ -1,19 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-/*
-{
-    "token": "my_token",
-    "guild_id": "41771983423143937",
-    "endpoint": "smart.loyal.discord.gg"
-}
-*/
-
-class VoiceServerUpdate extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    client.emit('self.voiceServer', data);
-  }
-}
-
-module.exports = VoiceServerUpdate;
diff --git a/src/client/websocket/packets/handlers/VoiceStateUpdate.js b/src/client/websocket/packets/handlers/VoiceStateUpdate.js
deleted file mode 100644
index e423d0d0..00000000
--- a/src/client/websocket/packets/handlers/VoiceStateUpdate.js
+++ /dev/null
@@ -1,45 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-
-const { Events } = require('../../../../util/Constants');
-const VoiceState = require('../../../../structures/VoiceState');
-
-class VoiceStateUpdateHandler extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-
-    const guild = client.guilds.get(data.guild_id);
-    if (guild) {
-      // Update the state
-      const oldState = guild.voiceStates.has(data.user_id) ?
-        guild.voiceStates.get(data.user_id)._clone() :
-        new VoiceState(guild, { user_id: data.user_id });
-
-      const newState = guild.voiceStates.add(data);
-
-      // Get the member
-      let member = guild.members.get(data.user_id);
-      if (member && data.member) {
-        member._patch(data.member);
-      } else if (data.member && data.member.user && data.member.joined_at) {
-        member = guild.members.add(data.member);
-      }
-
-      // Emit event
-      if (member && member.user.id === client.user.id && data.channel_id) {
-        client.emit('self.voiceStateUpdate', data);
-      }
-
-      client.emit(Events.VOICE_STATE_UPDATE, oldState, newState);
-    }
-  }
-}
-
-/**
- * Emitted whenever a member changes voice state - e.g. joins/leaves a channel, mutes/unmutes.
- * @event Client#voiceStateUpdate
- * @param {?VoiceState} oldState The voice state before the update
- * @param {VoiceState} newState The voice state after the update
- */
-
-module.exports = VoiceStateUpdateHandler;
diff --git a/src/client/websocket/packets/handlers/WebhooksUpdate.js b/src/client/websocket/packets/handlers/WebhooksUpdate.js
deleted file mode 100644
index 7ed2721e..00000000
--- a/src/client/websocket/packets/handlers/WebhooksUpdate.js
+++ /dev/null
@@ -1,19 +0,0 @@
-const AbstractHandler = require('./AbstractHandler');
-const { Events } = require('../../../../util/Constants');
-
-class WebhooksUpdate extends AbstractHandler {
-  handle(packet) {
-    const client = this.packetManager.client;
-    const data = packet.d;
-    const channel = client.channels.get(data.channel_id);
-    if (channel) client.emit(Events.WEBHOOKS_UPDATE, channel);
-  }
-}
-
-/**
- * Emitted whenever a guild text channel has its webhooks changed.
- * @event Client#webhookUpdate
- * @param {TextChannel} channel The channel that had a webhook update
- */
-
-module.exports = WebhooksUpdate;
diff --git a/src/errors/DJSError.js b/src/errors/DJSError.js
index 1d5aea12..157ca660 100644
--- a/src/errors/DJSError.js
+++ b/src/errors/DJSError.js
@@ -1,3 +1,5 @@
+'use strict';
+
 // Heavily inspired by node's `internal/errors` module
 
 const kCode = Symbol('code');
diff --git a/src/errors/Messages.js b/src/errors/Messages.js
index 2d1bc3c2..c3e37960 100644
--- a/src/errors/Messages.js
+++ b/src/errors/Messages.js
@@ -1,23 +1,22 @@
+'use strict';
+
 const { register } = require('./DJSError');
 
 const Messages = {
   CLIENT_INVALID_OPTION: (prop, must) => `The ${prop} option must be ${must}`,
+  CLIENT_INVALID_PROVIDED_SHARDS: 'None of the provided shards were valid.',
 
   TOKEN_INVALID: 'An invalid token was provided.',
   TOKEN_MISSING: 'Request to use token, but token was unavailable to the client.',
 
-  WS_CONNECTION_TIMEOUT: 'The connection to the gateway timed out.',
+  WS_CLOSE_REQUESTED: 'WebSocket closed due to user request.',
   WS_CONNECTION_EXISTS: 'There is already an existing WebSocket connection.',
   WS_NOT_OPEN: (data = 'data') => `Websocket not open to send ${data}`,
 
   BITFIELD_INVALID: 'Invalid bitfield flag or number.',
 
-  RATELIMIT_INVALID_METHOD: 'Unknown rate limiting method.',
-
   SHARDING_INVALID: 'Invalid shard settings were provided.',
   SHARDING_REQUIRED: 'This session would have handled too many guilds - Sharding is required.',
-  SHARDING_CHILD_CONNECTION: 'Failed to send message to shard\'s process.',
-  SHARDING_PARENT_CONNECTION: 'Failed to send message to master process.',
   SHARDING_NO_SHARDS: 'No shards have been spawned.',
   SHARDING_IN_PROCESS: 'Shards are still being spawned.',
   SHARDING_ALREADY_SPAWNED: count => `Already spawned ${count} shards.`,
@@ -37,8 +36,7 @@ const Messages = {
   USER_NO_DMCHANNEL: 'No DM Channel exists!',
 
   VOICE_INVALID_HEARTBEAT: 'Tried to set voice heartbeat but no valid interval was specified.',
-  VOICE_USER_MISSING: 'Couldn\'t resolve the user to create stream.',
-  VOICE_STREAM_EXISTS: 'There is already an existing stream for that user.',
+  VOICE_USER_MISSING: "Couldn't resolve the user to create stream.",
   VOICE_JOIN_CHANNEL: (full = false) =>
     `You do not have permission to join this voice channel${full ? '; it is full.' : '.'}`,
   VOICE_CONNECTION_TIMEOUT: 'Connection not established within 15 seconds.',
@@ -53,40 +51,36 @@ const Messages = {
   VOICE_PRISM_DEMUXERS_NEED_STREAM: 'To play a webm/ogg stream, you need to pass a ReadableStream.',
 
   VOICE_STATE_UNCACHED_MEMBER: 'The member of this voice state is uncached.',
-
-  OPUS_ENGINE_MISSING: 'Couldn\'t find an Opus engine.',
+  VOICE_STATE_NOT_OWN: 'You cannot self-deafen/mute on VoiceStates that do not belong to the ClientUser.',
+  VOICE_STATE_INVALID_TYPE: name => `${name} must be a boolean.`,
 
   UDP_SEND_FAIL: 'Tried to send a UDP packet, but there is no socket available.',
   UDP_ADDRESS_MALFORMED: 'Malformed UDP address or port.',
   UDP_CONNECTION_EXISTS: 'There is already an existing UDP connection.',
 
-  REQ_BODY_TYPE: 'The response body isn\'t a Buffer.',
   REQ_RESOURCE_TYPE: 'The resource must be a string, Buffer or a valid file stream.',
 
   IMAGE_FORMAT: format => `Invalid image format: ${format}`,
   IMAGE_SIZE: size => `Invalid image size: ${size}`,
 
-  MESSAGE_MISSING: 'Message not found',
   MESSAGE_BULK_DELETE_TYPE: 'The messages must be an Array, Collection, or number.',
   MESSAGE_NONCE_TYPE: 'Message nonce must fit in an unsigned 64-bit integer.',
 
   TYPING_COUNT: 'Count must be at least 1',
 
-  SPLIT_MAX_LEN: 'Message exceeds the max length and contains no split characters.',
+  SPLIT_MAX_LEN: 'Chunk exceeds the max length and contains no split characters.',
 
   BAN_RESOLVE_ID: (ban = false) => `Couldn't resolve the user ID to ${ban ? 'ban' : 'unban'}.`,
+  FETCH_BAN_RESOLVE_ID: "Couldn't resolve the user ID to fetch the ban.",
 
   PRUNE_DAYS_TYPE: 'Days must be a number',
 
-  SEARCH_CHANNEL_TYPE: 'Target must be a TextChannel, DMChannel, GroupDMChannel, or Guild.',
-
-  MESSAGE_SPLIT_MISSING: 'Message exceeds the max length and contains no split characters.',
-
   GUILD_CHANNEL_RESOLVE: 'Could not resolve channel to a guild channel.',
+  GUILD_VOICE_CHANNEL_RESOLVE: 'Could not resolve channel to a guild voice channel.',
   GUILD_CHANNEL_ORPHAN: 'Could not find a parent to this guild channel.',
   GUILD_OWNED: 'Guild is owned by the client.',
-  GUILD_RESTRICTED: (state = false) => `Guild is ${state ? 'already' : 'not'} restricted.`,
-  GUILD_MEMBERS_TIMEOUT: 'Members didn\'t arrive in time.',
+  GUILD_MEMBERS_TIMEOUT: "Members didn't arrive in time.",
+  GUILD_UNCACHED_ME: 'The client user as a member of this guild is uncached.',
 
   INVALID_TYPE: (name, expected, an = false) => `Supplied ${name} is not a${an ? 'n' : ''} ${expected}.`,
 
@@ -94,12 +88,15 @@ const Messages = {
 
   EMOJI_TYPE: 'Emoji must be a string or GuildEmoji/ReactionEmoji',
   EMOJI_MANAGED: 'Emoji is managed and has no Author.',
-  MISSING_MANAGE_EMOJIS_PERMISSION:
-    guild => `Client must have Manage Emoji permission in guild ${guild} to see emoji authors.`,
+  MISSING_MANAGE_EMOJIS_PERMISSION: guild =>
+    `Client must have Manage Emoji permission in guild ${guild} to see emoji authors.`,
 
-  REACTION_RESOLVE_USER: 'Couldn\'t resolve the user ID to remove from the reaction.',
+  REACTION_RESOLVE_USER: "Couldn't resolve the user ID to remove from the reaction.",
 
   VANITY_URL: 'This guild does not have the VANITY_URL feature enabled.',
+
+  DELETE_GROUP_DM_CHANNEL: "Bots don't have access to Group DM Channels and cannot delete them",
+  FETCH_GROUP_DM_CHANNEL: "Bots don't have access to Group DM Channels and cannot fetch them",
 };
 
 for (const [name, message] of Object.entries(Messages)) register(name, message);
diff --git a/src/errors/index.js b/src/errors/index.js
index 39b7582d..c94ddc78 100644
--- a/src/errors/index.js
+++ b/src/errors/index.js
@@ -1,2 +1,4 @@
+'use strict';
+
 module.exports = require('./DJSError');
 module.exports.Messages = require('./Messages');
diff --git a/src/index.js b/src/index.js
index a124108f..155d2f53 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Util = require('./util/Util');
 
 module.exports = {
@@ -15,30 +17,33 @@ module.exports = {
   Collection: require('./util/Collection'),
   Constants: require('./util/Constants'),
   DataResolver: require('./util/DataResolver'),
-  DataStore: require('./stores/DataStore'),
+  LimitedCollection: require('./util/LimitedCollection'),
+  BaseManager: require('./managers/BaseManager'),
   DiscordAPIError: require('./rest/DiscordAPIError'),
+  HTTPError: require('./rest/HTTPError'),
+  MessageFlags: require('./util/MessageFlags'),
   Permissions: require('./util/Permissions'),
   Speaking: require('./util/Speaking'),
   Snowflake: require('./util/Snowflake'),
   SnowflakeUtil: require('./util/Snowflake'),
   Structures: require('./util/Structures'),
+  SystemChannelFlags: require('./util/SystemChannelFlags'),
   Util: Util,
-  util: Util,
   version: require('../package.json').version,
 
-  // Stores
-  ChannelStore: require('./stores/ChannelStore'),
-  GuildChannelStore: require('./stores/GuildChannelStore'),
-  GuildEmojiStore: require('./stores/GuildEmojiStore'),
-  GuildEmojiRoleStore: require('./stores/GuildEmojiRoleStore'),
-  GuildMemberStore: require('./stores/GuildMemberStore'),
-  GuildMemberRoleStore: require('./stores/GuildMemberRoleStore'),
-  GuildStore: require('./stores/GuildStore'),
-  ReactionUserStore: require('./stores/ReactionUserStore'),
-  MessageStore: require('./stores/MessageStore'),
-  PresenceStore: require('./stores/PresenceStore'),
-  RoleStore: require('./stores/RoleStore'),
-  UserStore: require('./stores/UserStore'),
+  // Managers
+  ChannelManager: require('./managers/ChannelManager'),
+  GuildChannelManager: require('./managers/GuildChannelManager'),
+  GuildEmojiManager: require('./managers/GuildEmojiManager'),
+  GuildEmojiRoleManager: require('./managers/GuildEmojiRoleManager'),
+  GuildMemberManager: require('./managers/GuildMemberManager'),
+  GuildMemberRoleManager: require('./managers/GuildMemberRoleManager'),
+  GuildManager: require('./managers/GuildManager'),
+  ReactionUserManager: require('./managers/ReactionUserManager'),
+  MessageManager: require('./managers/MessageManager'),
+  PresenceManager: require('./managers/PresenceManager'),
+  RoleManager: require('./managers/RoleManager'),
+  UserManager: require('./managers/UserManager'),
 
   // Shortcuts to Util methods
   discordSort: Util.discordSort,
@@ -62,7 +67,6 @@ module.exports = {
   Collector: require('./structures/interfaces/Collector'),
   DMChannel: require('./structures/DMChannel'),
   Emoji: require('./structures/Emoji'),
-  GroupDMChannel: require('./structures/GroupDMChannel'),
   Guild: require('./structures/Guild'),
   GuildAuditLogs: require('./structures/GuildAuditLogs'),
   GuildChannel: require('./structures/GuildChannel'),
@@ -76,6 +80,7 @@ module.exports = {
   MessageEmbed: require('./structures/MessageEmbed'),
   MessageMentions: require('./structures/MessageMentions'),
   MessageReaction: require('./structures/MessageReaction'),
+  NewsChannel: require('./structures/NewsChannel'),
   PermissionOverwrites: require('./structures/PermissionOverwrites'),
   Presence: require('./structures/Presence').Presence,
   ClientPresence: require('./structures/ClientPresence'),
@@ -83,6 +88,9 @@ module.exports = {
   ReactionEmoji: require('./structures/ReactionEmoji'),
   RichPresenceAssets: require('./structures/Presence').RichPresenceAssets,
   Role: require('./structures/Role'),
+  StoreChannel: require('./structures/StoreChannel'),
+  Team: require('./structures/Team'),
+  TeamMember: require('./structures/TeamMember'),
   TextChannel: require('./structures/TextChannel'),
   User: require('./structures/User'),
   VoiceChannel: require('./structures/VoiceChannel'),
diff --git a/src/managers/BaseManager.js b/src/managers/BaseManager.js
new file mode 100644
index 00000000..c11d1910
--- /dev/null
+++ b/src/managers/BaseManager.js
@@ -0,0 +1,81 @@
+'use strict';
+
+const Collection = require('../util/Collection');
+let Structures;
+
+/**
+ * Manages the API methods of a data model and holds its cache.
+ * @abstract
+ */
+class BaseManager {
+  constructor(client, iterable, holds, cacheType = Collection, ...cacheOptions) {
+    if (!Structures) Structures = require('../util/Structures');
+    /**
+     * The data structure belonging to this manager
+     * @name BaseManager#holds
+     * @type {Function}
+     * @private
+     * @readonly
+     */
+    Object.defineProperty(this, 'holds', { value: Structures.get(holds.name) || holds });
+
+    /**
+     * The client that instantiated this Manager
+     * @name BaseManager#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * The type of Collection of the Manager
+     * @type {Collection}
+     */
+    this.cacheType = cacheType;
+
+    /**
+     * Holds the cache for the data model
+     * @type {Collection}
+     */
+    this.cache = new cacheType(...cacheOptions);
+    if (iterable) for (const i of iterable) this.add(i);
+  }
+
+  add(data, cache = true, { id, extras = [] } = {}) {
+    const existing = this.cache.get(id || data.id);
+    if (existing && existing._patch && cache) existing._patch(data);
+    if (existing) return existing;
+
+    const entry = this.holds ? new this.holds(this.client, data, ...extras) : data;
+    if (cache) this.cache.set(id || entry.id, entry);
+    return entry;
+  }
+
+  /**
+   * Resolves a data entry to a data Object.
+   * @param {string|Object} idOrInstance The id or instance of something in this Manager
+   * @returns {?Object} An instance from this Manager
+   */
+  resolve(idOrInstance) {
+    if (idOrInstance instanceof this.holds) return idOrInstance;
+    if (typeof idOrInstance === 'string') return this.cache.get(idOrInstance) || null;
+    return null;
+  }
+
+  /**
+   * Resolves a data entry to a instance ID.
+   * @param {string|Object} idOrInstance The id or instance of something in this Manager
+   * @returns {?Snowflake}
+   */
+  resolveID(idOrInstance) {
+    if (idOrInstance instanceof this.holds) return idOrInstance.id;
+    if (typeof idOrInstance === 'string') return idOrInstance;
+    return null;
+  }
+
+  valueOf() {
+    return this.cache;
+  }
+}
+
+module.exports = BaseManager;
diff --git a/src/managers/ChannelManager.js b/src/managers/ChannelManager.js
new file mode 100644
index 00000000..99fde10f
--- /dev/null
+++ b/src/managers/ChannelManager.js
@@ -0,0 +1,93 @@
+'use strict';
+
+const BaseManager = require('./BaseManager');
+const Channel = require('../structures/Channel');
+const { Events } = require('../util/Constants');
+
+/**
+ * A manager of channels belonging to a client
+ * @extends {BaseManager}
+ */
+class ChannelManager extends BaseManager {
+  constructor(client, iterable) {
+    super(client, iterable, Channel);
+  }
+
+  /**
+   * The cache of Channels
+   * @type {Collection<Snowflake, Channel>}
+   * @name ChannelManager#cache
+   */
+
+  add(data, guild, cache = true) {
+    const existing = this.cache.get(data.id);
+    if (existing) {
+      if (existing._patch && cache) existing._patch(data);
+      if (guild) guild.channels.add(existing);
+      return existing;
+    }
+
+    const channel = Channel.create(this.client, data, guild);
+
+    if (!channel) {
+      this.client.emit(Events.DEBUG, `Failed to find guild, or unknown type for channel ${data.id} ${data.type}`);
+      return null;
+    }
+
+    if (cache) this.cache.set(channel.id, channel);
+
+    return channel;
+  }
+
+  remove(id) {
+    const channel = this.cache.get(id);
+    if (channel.guild) channel.guild.channels.cache.delete(id);
+    this.cache.delete(id);
+  }
+
+  /**
+   * Data that can be resolved to give a Channel object. This can be:
+   * * A Channel object
+   * * A Snowflake
+   * @typedef {Channel|Snowflake} ChannelResolvable
+   */
+
+  /**
+   * Resolves a ChannelResolvable to a Channel object.
+   * @method resolve
+   * @memberof ChannelManager
+   * @instance
+   * @param {ChannelResolvable} channel The channel resolvable to resolve
+   * @returns {?Channel}
+   */
+
+  /**
+   * Resolves a ChannelResolvable to a channel ID string.
+   * @method resolveID
+   * @memberof ChannelManager
+   * @instance
+   * @param {ChannelResolvable} channel The channel resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Obtains a channel from Discord, or the channel cache if it's already available.
+   * @param {Snowflake} id ID of the channel
+   * @param {boolean} [cache=true] Whether to cache the new channel object if it isn't already
+   * @returns {Promise<Channel>}
+   * @example
+   * // Fetch a channel by its id
+   * client.channels.fetch('222109930545610754')
+   *   .then(channel => console.log(channel.name))
+   *   .catch(console.error);
+   */
+  async fetch(id, cache = true) {
+    const existing = this.cache.get(id);
+    if (existing && !existing.partial) return existing;
+
+    const data = await this.client.api.channels(id).get();
+    return this.add(data, null, cache);
+  }
+}
+
+module.exports = ChannelManager;
diff --git a/src/stores/GuildChannelStore.js b/src/managers/GuildChannelManager.js
similarity index 75%
rename from src/stores/GuildChannelStore.js
rename to src/managers/GuildChannelManager.js
index e67bcc1c..bc72e9a4 100644
--- a/src/stores/GuildChannelStore.js
+++ b/src/managers/GuildChannelManager.js
@@ -1,26 +1,63 @@
-const Channel = require('../structures/Channel');
-const { ChannelTypes } = require('../util/Constants');
-const DataStore = require('./DataStore');
+'use strict';
+
+const BaseManager = require('./BaseManager');
 const GuildChannel = require('../structures/GuildChannel');
 const PermissionOverwrites = require('../structures/PermissionOverwrites');
+const { ChannelTypes } = require('../util/Constants');
 
 /**
- * Stores guild channels.
- * @extends {DataStore}
+ * Manages API methods for GuildChannels and stores their cache.
+ * @extends {BaseManager}
  */
-class GuildChannelStore extends DataStore {
+class GuildChannelManager extends BaseManager {
   constructor(guild, iterable) {
     super(guild.client, iterable, GuildChannel);
+
+    /**
+     * The guild this Manager belongs to
+     * @type {Guild}
+     */
     this.guild = guild;
   }
 
-  add(data) {
-    const existing = this.get(data.id);
-    if (existing) return existing;
+  /**
+   * The cache of this Manager
+   * @type {Collection<Snowflake, GuildChannel>}
+   * @name GuildChannelManager#cache
+   */
 
-    return Channel.create(this.client, data, this.guild);
+  add(channel) {
+    const existing = this.cache.get(channel.id);
+    if (existing) return existing;
+    this.cache.set(channel.id, channel);
+    return channel;
   }
 
+  /**
+   * Data that can be resolved to give a Guild Channel object. This can be:
+   * * A GuildChannel object
+   * * A Snowflake
+   * @typedef {GuildChannel|Snowflake} GuildChannelResolvable
+   */
+
+  /**
+   * Resolves a GuildChannelResolvable to a Channel object.
+   * @method resolve
+   * @memberof GuildChannelManager
+   * @instance
+   * @param {GuildChannelResolvable} channel The GuildChannel resolvable to resolve
+   * @returns {?Channel}
+   */
+
+  /**
+   * Resolves a GuildChannelResolvable to a channel ID string.
+   * @method resolveID
+   * @memberof GuildChannelManager
+   * @instance
+   * @param {GuildChannelResolvable} channel The GuildChannel resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
   /**
    * Creates a new channel in the guild.
    * @param {string} name The name of the new channel
@@ -33,6 +70,7 @@ class GuildChannelStore extends DataStore {
    * @param {ChannelResolvable} [options.parent] Parent of the new channel
    * @param {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} [options.permissionOverwrites]
    * Permission overwrites of the new channel
+   * @param {number} [options.position] Position of the new channel
    * @param {number} [options.rateLimitPerUser] The ratelimit per user for the channel
    * @param {string} [options.reason] Reason for creating the channel
    * @returns {Promise<GuildChannel>}
@@ -54,7 +92,18 @@ class GuildChannelStore extends DataStore {
    * })
    */
   async create(name, options = {}) {
-    let { type, topic, nsfw, bitrate, userLimit, parent, permissionOverwrites, rateLimitPerUser, reason } = options;
+    let {
+      type,
+      topic,
+      nsfw,
+      bitrate,
+      userLimit,
+      parent,
+      permissionOverwrites,
+      position,
+      rateLimitPerUser,
+      reason,
+    } = options;
     if (parent) parent = this.client.channels.resolveID(parent);
     if (permissionOverwrites) {
       permissionOverwrites = permissionOverwrites.map(o => PermissionOverwrites.resolve(o, this.guild));
@@ -64,11 +113,12 @@ class GuildChannelStore extends DataStore {
       data: {
         name,
         topic,
-        type: type ? ChannelTypes[type.toUpperCase()] : 'text',
+        type: type ? ChannelTypes[type.toUpperCase()] : ChannelTypes.TEXT,
         nsfw,
         bitrate,
         user_limit: userLimit,
         parent_id: parent,
+        position,
         permission_overwrites: permissionOverwrites,
         rate_limit_per_user: rateLimitPerUser,
       },
@@ -76,31 +126,6 @@ class GuildChannelStore extends DataStore {
     });
     return this.client.actions.ChannelCreate.handle(data).channel;
   }
-
-  /**
-   * Data that can be resolved to give a Guild Channel object. This can be:
-   * * A GuildChannel object
-   * * A Snowflake
-   * @typedef {GuildChannel|Snowflake} GuildChannelResolvable
-   */
-
-  /**
-   * Resolves a GuildChannelResolvable to a Channel object.
-   * @method resolve
-   * @memberof GuildChannelStore
-   * @instance
-   * @param {GuildChannelResolvable} channel The GuildChannel resolvable to resolve
-   * @returns {?Channel}
-   */
-
-  /**
-   * Resolves a GuildChannelResolvable to a channel ID string.
-   * @method resolveID
-   * @memberof GuildChannelStore
-   * @instance
-   * @param {GuildChannelResolvable} channel The GuildChannel resolvable to resolve
-   * @returns {?Snowflake}
-   */
 }
 
-module.exports = GuildChannelStore;
+module.exports = GuildChannelManager;
diff --git a/src/stores/GuildEmojiStore.js b/src/managers/GuildEmojiManager.js
similarity index 83%
rename from src/stores/GuildEmojiStore.js
rename to src/managers/GuildEmojiManager.js
index 925f79ab..74807238 100644
--- a/src/stores/GuildEmojiStore.js
+++ b/src/managers/GuildEmojiManager.js
@@ -1,20 +1,32 @@
-const Collection = require('../util/Collection');
-const DataStore = require('./DataStore');
+'use strict';
+
+const BaseManager = require('./BaseManager');
+const { TypeError } = require('../errors');
 const GuildEmoji = require('../structures/GuildEmoji');
 const ReactionEmoji = require('../structures/ReactionEmoji');
+const Collection = require('../util/Collection');
 const DataResolver = require('../util/DataResolver');
-const { TypeError } = require('../errors');
 
 /**
- * Stores guild emojis.
- * @extends {DataStore}
+ * Manages API methods for GuildEmojis and stores their cache.
+ * @extends {BaseManager}
  */
-class GuildEmojiStore extends DataStore {
+class GuildEmojiManager extends BaseManager {
   constructor(guild, iterable) {
     super(guild.client, iterable, GuildEmoji);
+    /**
+     * The guild this manager belongs to
+     * @type {Guild}
+     */
     this.guild = guild;
   }
 
+  /**
+   * The cache of GuildEmojis
+   * @type {Collection<Snowflake, GuildEmoji>}
+   * @name GuildEmojiManager#cache
+   */
+
   add(data, cache) {
     return super.add(data, cache, { extras: [this.guild] });
   }
@@ -46,14 +58,17 @@ class GuildEmojiStore extends DataStore {
         for (let role of roles instanceof Collection ? roles.values() : roles) {
           role = this.guild.roles.resolve(role);
           if (!role) {
-            return Promise.reject(new TypeError('INVALID_TYPE', 'options.roles',
-              'Array or Collection of Roles or Snowflakes', true));
+            return Promise.reject(
+              new TypeError('INVALID_TYPE', 'options.roles', 'Array or Collection of Roles or Snowflakes', true),
+            );
           }
           data.roles.push(role.id);
         }
       }
 
-      return this.client.api.guilds(this.guild.id).emojis.post({ data, reason })
+      return this.client.api
+        .guilds(this.guild.id)
+        .emojis.post({ data, reason })
         .then(emoji => this.client.actions.GuildEmojiCreate.handle(this.guild, emoji).emoji);
     }
 
@@ -112,4 +127,4 @@ class GuildEmojiStore extends DataStore {
   }
 }
 
-module.exports = GuildEmojiStore;
+module.exports = GuildEmojiManager;
diff --git a/src/stores/GuildEmojiRoleStore.js b/src/managers/GuildEmojiRoleManager.js
similarity index 65%
rename from src/stores/GuildEmojiRoleStore.js
rename to src/managers/GuildEmojiRoleManager.js
index e2fe5ecd..038571fc 100644
--- a/src/stores/GuildEmojiRoleStore.js
+++ b/src/managers/GuildEmojiRoleManager.js
@@ -1,16 +1,28 @@
-const Collection = require('../util/Collection');
-const Util = require('../util/Util');
+'use strict';
+
 const { TypeError } = require('../errors');
+const Collection = require('../util/Collection');
 
 /**
- * Stores emoji roles
- * @extends {Collection}
+ * Manages API methods for roles belonging to emojis and stores their cache.
  */
-class GuildEmojiRoleStore extends Collection {
+class GuildEmojiRoleManager {
   constructor(emoji) {
-    super();
+    /**
+     * The emoji belonging to this manager
+     * @type {GuildEmoji}
+     */
     this.emoji = emoji;
+    /**
+     * The guild belonging to this manager
+     * @type {Guild}
+     */
     this.guild = emoji.guild;
+    /**
+     * The client belonging to this manager
+     * @type {Client}
+     * @readonly
+     */
     Object.defineProperty(this, 'client', { value: emoji.client });
   }
 
@@ -18,9 +30,19 @@ class GuildEmojiRoleStore extends Collection {
    * The filtered collection of roles of the guild emoji
    * @type {Collection<Snowflake, Role>}
    * @private
+   * @readonly
    */
-  get _filtered() {
-    return this.guild.roles.filter(role => this.emoji._roles.includes(role.id));
+  get _roles() {
+    return this.guild.roles.cache.filter(role => this.emoji._roles.includes(role.id));
+  }
+
+  /**
+   * The cache of roles belonging to this emoji
+   * @type {Collection<Snowflake, Role>}
+   * @readonly
+   */
+  get cache() {
+    return this._roles;
   }
 
   /**
@@ -30,15 +52,14 @@ class GuildEmojiRoleStore extends Collection {
    */
   add(roleOrRoles) {
     if (roleOrRoles instanceof Collection) return this.add(roleOrRoles.keyArray());
-    if (!(roleOrRoles instanceof Array)) return this.add([roleOrRoles]);
+    if (!Array.isArray(roleOrRoles)) return this.add([roleOrRoles]);
     roleOrRoles = roleOrRoles.map(r => this.guild.roles.resolve(r));
 
     if (roleOrRoles.includes(null)) {
-      return Promise.reject(new TypeError('INVALID_TYPE', 'roles',
-        'Array or Collection of Roles or Snowflakes', true));
+      return Promise.reject(new TypeError('INVALID_TYPE', 'roles', 'Array or Collection of Roles or Snowflakes', true));
     }
 
-    const newRoles = [...new Set(roleOrRoles.concat(...this.values()))];
+    const newRoles = [...new Set(roleOrRoles.concat(...this._roles.values()))];
     return this.set(newRoles);
   }
 
@@ -49,15 +70,14 @@ class GuildEmojiRoleStore extends Collection {
    */
   remove(roleOrRoles) {
     if (roleOrRoles instanceof Collection) return this.remove(roleOrRoles.keyArray());
-    if (!(roleOrRoles instanceof Array)) return this.remove([roleOrRoles]);
+    if (!Array.isArray(roleOrRoles)) return this.remove([roleOrRoles]);
     roleOrRoles = roleOrRoles.map(r => this.guild.roles.resolveID(r));
 
     if (roleOrRoles.includes(null)) {
-      return Promise.reject(new TypeError('INVALID_TYPE', 'roles',
-        'Array or Collection of Roles or Snowflakes', true));
+      return Promise.reject(new TypeError('INVALID_TYPE', 'roles', 'Array or Collection of Roles or Snowflakes', true));
     }
 
-    const newRoles = this.keyArray().filter(role => !roleOrRoles.includes(role));
+    const newRoles = this._roles.keyArray().filter(role => !roleOrRoles.includes(role));
     return this.set(newRoles);
   }
 
@@ -82,28 +102,18 @@ class GuildEmojiRoleStore extends Collection {
 
   clone() {
     const clone = new this.constructor(this.emoji);
-    clone._patch(this.keyArray().slice());
+    clone._patch(this._roles.keyArray().slice());
     return clone;
   }
 
   /**
-   * Patches the roles for this store
+   * Patches the roles for this manager's cache
    * @param {Snowflake[]} roles The new roles
    * @private
    */
   _patch(roles) {
     this.emoji._roles = roles;
   }
-
-  *[Symbol.iterator]() {
-    yield* this._filtered.entries();
-  }
-
-  valueOf() {
-    return this._filtered;
-  }
 }
 
-Util.mixin(GuildEmojiRoleStore, ['set']);
-
-module.exports = GuildEmojiRoleStore;
+module.exports = GuildEmojiRoleManager;
diff --git a/src/managers/GuildManager.js b/src/managers/GuildManager.js
new file mode 100644
index 00000000..b485c723
--- /dev/null
+++ b/src/managers/GuildManager.js
@@ -0,0 +1,216 @@
+'use strict';
+
+const BaseManager = require('./BaseManager');
+const Guild = require('../structures/Guild');
+const GuildChannel = require('../structures/GuildChannel');
+const GuildEmoji = require('../structures/GuildEmoji');
+const GuildMember = require('../structures/GuildMember');
+const Invite = require('../structures/Invite');
+const Role = require('../structures/Role');
+const {
+  Events,
+  VerificationLevels,
+  DefaultMessageNotifications,
+  ExplicitContentFilterLevels,
+} = require('../util/Constants');
+const DataResolver = require('../util/DataResolver');
+const Permissions = require('../util/Permissions');
+const { resolveColor } = require('../util/Util');
+
+/**
+ * Manages API methods for Guilds and stores their cache.
+ * @extends {BaseManager}
+ */
+class GuildManager extends BaseManager {
+  constructor(client, iterable) {
+    super(client, iterable, Guild);
+  }
+
+  /**
+   * The cache of this Manager
+   * @type {Collection<Snowflake, Guild>}
+   * @name GuildManager#cache
+   */
+
+  /**
+   * Data that resolves to give a Guild object. This can be:
+   * * A Guild object
+   * * A GuildChannel object
+   * * A GuildEmoji object
+   * * A Role object
+   * * A Snowflake
+   * * An Invite object
+   * @typedef {Guild|GuildChannel|GuildMember|GuildEmoji|Role|Snowflake|Invite} GuildResolvable
+   */
+
+  /**
+   * Partial data for a Role.
+   * @typedef {Object} PartialRoleData
+   * @property {number} id The ID for this role, used to set channel overrides,
+   * this is a placeholder and will be replaced by the API after consumption
+   * @property {string} [name] The name of the role
+   * @property {ColorResolvable} [color] The color of the role, either a hex string or a base 10 number
+   * @property {boolean} [hoist] Whether or not the role should be hoisted
+   * @property {number} [position] The position of the role
+   * @property {PermissionResolvable|number} [permissions] The permissions of the role
+   * @property {boolean} [mentionable] Whether or not the role should be mentionable
+   */
+
+  /**
+   * Partial overwrite data.
+   * @typedef {Object} PartialOverwriteData
+   * @property {number|Snowflake} id The Role or User ID for this overwrite
+   * @property {string} [type] The type of this overwrite
+   * @property {PermissionResolvable} [allow] The permissions to allow
+   * @property {PermissionResolvable} [deny] The permissions to deny
+   */
+
+  /**
+   * Partial data for a Channel.
+   * @typedef {Object} PartialChannelData
+   * @property {number} [id] The ID for this channel, used to set its parent,
+   * this is a placeholder and will be replaced by the API after consumption
+   * @property {number} [parentID] The parent ID for this channel
+   * @property {string} [type] The type of the channel
+   * @property {string} name The name of the channel
+   * @property {string} [topic] The topic of the text channel
+   * @property {boolean} [nsfw] Whether the channel is NSFW
+   * @property {number} [bitrate] The bitrate of the voice channel
+   * @property {number} [userLimit] The user limit of the channel
+   * @property {PartialOverwriteData} [permissionOverwrites]
+   * Overwrites of the channel
+   * @property {number} [rateLimitPerUser] The rate limit per user of the channel in seconds
+   */
+
+  /**
+   * Resolves a GuildResolvable to a Guild object.
+   * @method resolve
+   * @memberof GuildManager
+   * @instance
+   * @param {GuildResolvable} guild The guild resolvable to identify
+   * @returns {?Guild}
+   */
+  resolve(guild) {
+    if (
+      guild instanceof GuildChannel ||
+      guild instanceof GuildMember ||
+      guild instanceof GuildEmoji ||
+      guild instanceof Role ||
+      (guild instanceof Invite && guild.guild)
+    ) {
+      return super.resolve(guild.guild);
+    }
+    return super.resolve(guild);
+  }
+
+  /**
+   * Resolves a GuildResolvable to a Guild ID string.
+   * @method resolveID
+   * @memberof GuildManager
+   * @instance
+   * @param {GuildResolvable} guild The guild resolvable to identify
+   * @returns {?Snowflake}
+   */
+  resolveID(guild) {
+    if (
+      guild instanceof GuildChannel ||
+      guild instanceof GuildMember ||
+      guild instanceof GuildEmoji ||
+      guild instanceof Role ||
+      (guild instanceof Invite && guild.guild)
+    ) {
+      return super.resolveID(guild.guild.id);
+    }
+    return super.resolveID(guild);
+  }
+
+  /**
+   * Creates a guild.
+   * <warn>This is only available to bots in fewer than 10 guilds.</warn>
+   * @param {string} name The name of the guild
+   * @param {Object} [options] Options for the creating
+   * @param {PartialChannelData[]} [options.channels] The channels for this guild
+   * @param {DefaultMessageNotifications} [options.defaultMessageNotifications] The default message notifications
+   * for the guild
+   * @param {ExplicitContentFilterLevel} [options.explicitContentFilter] The explicit content filter level for the guild
+   * @param {BufferResolvable|Base64Resolvable} [options.icon=null] The icon for the guild
+   * @param {string} [options.region] The region for the server, defaults to the closest one available
+   * @param {PartialRoleData[]} [options.roles] The roles for this guild,
+   * the first element of this array is used to change properties of the guild's everyone role.
+   * @param {VerificationLevel} [options.verificationLevel] The verification level for the guild
+   * @returns {Promise<Guild>} The guild that was created
+   */
+  async create(
+    name,
+    {
+      channels = [],
+      defaultMessageNotifications,
+      explicitContentFilter,
+      icon = null,
+      region,
+      roles = [],
+      verificationLevel,
+    } = {},
+  ) {
+    icon = await DataResolver.resolveImage(icon);
+    if (typeof verificationLevel !== 'undefined' && typeof verificationLevel !== 'number') {
+      verificationLevel = VerificationLevels.indexOf(verificationLevel);
+    }
+    if (typeof defaultMessageNotifications !== 'undefined' && typeof defaultMessageNotifications !== 'number') {
+      defaultMessageNotifications = DefaultMessageNotifications.indexOf(defaultMessageNotifications);
+    }
+    if (typeof explicitContentFilter !== 'undefined' && typeof explicitContentFilter !== 'number') {
+      explicitContentFilter = ExplicitContentFilterLevels.indexOf(explicitContentFilter);
+    }
+    for (const channel of channels) {
+      channel.parent_id = channel.parentID;
+      delete channel.parentID;
+      if (!channel.permissionOverwrites) continue;
+      for (const overwrite of channel.permissionOverwrites) {
+        if (overwrite.allow) overwrite.allow = Permissions.resolve(overwrite.allow);
+        if (overwrite.deny) overwrite.deny = Permissions.resolve(overwrite.deny);
+      }
+      channel.permission_overwrites = channel.permissionOverwrites;
+      delete channel.permissionOverwrites;
+    }
+    for (const role of roles) {
+      if (role.color) role.color = resolveColor(role.color);
+      if (role.permissions) role.permissions = Permissions.resolve(role.permissions);
+    }
+    return new Promise((resolve, reject) =>
+      this.client.api.guilds
+        .post({
+          data: {
+            name,
+            region,
+            icon,
+            verification_level: verificationLevel,
+            default_message_notifications: defaultMessageNotifications,
+            explicit_content_filter: explicitContentFilter,
+            channels,
+            roles,
+          },
+        })
+        .then(data => {
+          if (this.client.guilds.cache.has(data.id)) return resolve(this.client.guilds.cache.get(data.id));
+
+          const handleGuild = guild => {
+            if (guild.id === data.id) {
+              this.client.removeListener(Events.GUILD_CREATE, handleGuild);
+              this.client.clearTimeout(timeout);
+              resolve(guild);
+            }
+          };
+          this.client.on(Events.GUILD_CREATE, handleGuild);
+
+          const timeout = this.client.setTimeout(() => {
+            this.client.removeListener(Events.GUILD_CREATE, handleGuild);
+            resolve(this.client.guilds.add(data));
+          }, 10000);
+          return undefined;
+        }, reject),
+    );
+  }
+}
+
+module.exports = GuildManager;
diff --git a/src/stores/GuildMemberStore.js b/src/managers/GuildMemberManager.js
similarity index 67%
rename from src/stores/GuildMemberStore.js
rename to src/managers/GuildMemberManager.js
index 44494be4..2859d87a 100644
--- a/src/stores/GuildMemberStore.js
+++ b/src/managers/GuildMemberManager.js
@@ -1,19 +1,31 @@
-const DataStore = require('./DataStore');
-const GuildMember = require('../structures/GuildMember');
-const { Events, OPCodes } = require('../util/Constants');
-const Collection = require('../util/Collection');
+'use strict';
+
+const BaseManager = require('./BaseManager');
 const { Error, TypeError } = require('../errors');
+const GuildMember = require('../structures/GuildMember');
+const Collection = require('../util/Collection');
+const { Events, OPCodes } = require('../util/Constants');
 
 /**
- * Stores guild members.
- * @extends {DataStore}
+ * Manages API methods for GuildMembers and stores their cache.
+ * @extends {BaseManager}
  */
-class GuildMemberStore extends DataStore {
+class GuildMemberManager extends BaseManager {
   constructor(guild, iterable) {
     super(guild.client, iterable, GuildMember);
+    /**
+     * The guild this manager belongs to
+     * @type {Guild}
+     */
     this.guild = guild;
   }
 
+  /**
+   * The cache of this Manager
+   * @type {Collection<Snowflake, GuildMember>}
+   * @name GuildMemberManager#cache
+   */
+
   add(data, cache = true) {
     return super.add(data, cache, { id: data.user.id, extras: [this.guild] });
   }
@@ -47,7 +59,7 @@ class GuildMemberStore extends DataStore {
     const memberResolvable = super.resolveID(member);
     if (memberResolvable) return memberResolvable;
     const userResolvable = this.client.users.resolveID(member);
-    return this.has(userResolvable) ? userResolvable : null;
+    return this.cache.has(userResolvable) ? userResolvable : null;
   }
 
   /**
@@ -60,8 +72,10 @@ class GuildMemberStore extends DataStore {
   /**
    * Options used to fetch multiple members from a guild.
    * @typedef {Object} FetchMembersOptions
-   * @property {string} [query=''] Limit fetch to members with similar usernames
+   * @property {UserResolvable|UserResolvable[]} user The user(s) to fetch
+   * @property {?string} query Limit fetch to members with similar usernames
    * @property {number} [limit=0] Maximum number of members to request
+   * @property {boolean} [withPresences=false] Whether or not to include the presences
    */
 
   /**
@@ -86,6 +100,11 @@ class GuildMemberStore extends DataStore {
    *   .then(console.log)
    *   .catch(console.error);
    * @example
+   * // Fetch by an array of users including their presences
+   * guild.members.fetch({ user: ['66564597481480192', '191615925336670208'], withPresences: true })
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
    * // Fetch by query
    * guild.members.fetch({ query: 'hydra', limit: 1 })
    *   .then(console.log)
@@ -96,19 +115,26 @@ class GuildMemberStore extends DataStore {
     const user = this.client.users.resolveID(options);
     if (user) return this._fetchSingle({ user, cache: true });
     if (options.user) {
-      options.user = this.client.users.resolveID(options.user);
-      if (options.user) return this._fetchSingle(options);
+      if (Array.isArray(options.user)) {
+        options.user = options.user.map(u => this.client.users.resolveID(u));
+        return this._fetchMany(options);
+      } else {
+        options.user = this.client.users.resolveID(options.user);
+      }
+      if (!options.limit && !options.withPresences) return this._fetchSingle(options);
     }
     return this._fetchMany(options);
   }
 
   /**
    * Prunes members from the guild based on how long they have been inactive.
+   * <info>It's recommended to set options.count to `false` for large guilds.</info>
    * @param {Object} [options] Prune options
    * @param {number} [options.days=7] Number of days of inactivity required to kick
    * @param {boolean} [options.dry=false] Get number of users that will be kicked, without actually kicking them
+   * @param {boolean} [options.count=true] Whether or not to return the number of users that have been kicked.
    * @param {string} [options.reason] Reason for this prune
-   * @returns {Promise<number>} The number of members that were/will be kicked
+   * @returns {Promise<number|null>} The number of members that were/will be kicked
    * @example
    * // See how many members will be pruned
    * guild.members.prune({ dry: true })
@@ -120,9 +146,17 @@ class GuildMemberStore extends DataStore {
    *   .then(pruned => console.log(`I just pruned ${pruned} people!`))
    *   .catch(console.error);
    */
-  prune({ days = 7, dry = false, reason } = {}) {
+  prune({ days = 7, dry = false, count = true, reason } = {}) {
     if (typeof days !== 'number') throw new TypeError('PRUNE_DAYS_TYPE');
-    return this.client.api.guilds(this.guild.id).prune[dry ? 'get' : 'post']({ query: { days }, reason })
+    return this.client.api
+      .guilds(this.guild.id)
+      .prune[dry ? 'get' : 'post']({
+        query: {
+          days,
+          compute_prune_count: count,
+        },
+        reason,
+      })
       .then(data => data.pruned);
   }
 
@@ -145,7 +179,9 @@ class GuildMemberStore extends DataStore {
     if (options.days) options['delete-message-days'] = options.days;
     const id = this.client.users.resolveID(user);
     if (!id) return Promise.reject(new Error('BAN_RESOLVE_ID', true));
-    return this.client.api.guilds(this.guild.id).bans[id].put({ query: options })
+    return this.client.api
+      .guilds(this.guild.id)
+      .bans[id].put({ query: options })
       .then(() => {
         if (user instanceof GuildMember) return user;
         const _user = this.client.users.resolve(id);
@@ -170,53 +206,66 @@ class GuildMemberStore extends DataStore {
    */
   unban(user, reason) {
     const id = this.client.users.resolveID(user);
-    if (!id) throw new Error('BAN_RESOLVE_ID');
-    return this.client.api.guilds(this.guild.id).bans[id].delete({ reason })
+    if (!id) return Promise.reject(new Error('BAN_RESOLVE_ID'));
+    return this.client.api
+      .guilds(this.guild.id)
+      .bans[id].delete({ reason })
       .then(() => this.client.users.resolve(user));
   }
 
-
   _fetchSingle({ user, cache }) {
-    const existing = this.get(user);
-    if (existing && existing.joinedTimestamp) return Promise.resolve(existing);
-    return this.client.api.guilds(this.guild.id).members(user).get()
+    const existing = this.cache.get(user);
+    if (existing && !existing.partial) return Promise.resolve(existing);
+    return this.client.api
+      .guilds(this.guild.id)
+      .members(user)
+      .get()
       .then(data => this.add(data, cache));
   }
 
-  _fetchMany({ query = '', limit = 0 } = {}) {
+  _fetchMany({ limit = 0, withPresences: presences = false, user: user_ids, query } = {}) {
     return new Promise((resolve, reject) => {
-      if (this.guild.memberCount === this.size) {
-        resolve(query || limit ? new Collection() : this);
+      if (this.guild.memberCount === this.cache.size && !query && !limit && !presences && !user_ids) {
+        resolve(this.cache);
         return;
       }
-      this.guild.client.ws.send({
+      if (!query && !user_ids) query = '';
+      this.guild.shard.send({
         op: OPCodes.REQUEST_GUILD_MEMBERS,
         d: {
           guild_id: this.guild.id,
+          presences,
+          user_ids,
           query,
           limit,
         },
       });
       const fetchedMembers = new Collection();
+      const option = query || limit || presences || user_ids;
       const handler = (members, guild) => {
         if (guild.id !== this.guild.id) return;
+        timeout.refresh();
         for (const member of members.values()) {
-          if (query || limit) fetchedMembers.set(member.id, member);
+          if (option) fetchedMembers.set(member.id, member);
         }
-        if (this.guild.memberCount <= this.size ||
-          ((query || limit) && members.size < 1000) ||
-          (limit && fetchedMembers.size >= limit)) {
+        if (
+          this.guild.memberCount <= this.cache.size ||
+          (option && members.size < 1000) ||
+          (limit && fetchedMembers.size >= limit)
+        ) {
           this.guild.client.removeListener(Events.GUILD_MEMBERS_CHUNK, handler);
-          resolve(query || limit ? fetchedMembers : this);
+          let fetched = option ? fetchedMembers : this.cache;
+          if (user_ids && !Array.isArray(user_ids) && fetched.size) fetched = fetched.first();
+          resolve(fetched);
         }
       };
-      this.guild.client.on(Events.GUILD_MEMBERS_CHUNK, handler);
-      this.guild.client.setTimeout(() => {
+      const timeout = this.guild.client.setTimeout(() => {
         this.guild.client.removeListener(Events.GUILD_MEMBERS_CHUNK, handler);
         reject(new Error('GUILD_MEMBERS_TIMEOUT'));
       }, 120e3);
+      this.guild.client.on(Events.GUILD_MEMBERS_CHUNK, handler);
     });
   }
 }
 
-module.exports = GuildMemberStore;
+module.exports = GuildMemberManager;
diff --git a/src/stores/GuildMemberRoleStore.js b/src/managers/GuildMemberRoleManager.js
similarity index 60%
rename from src/stores/GuildMemberRoleStore.js
rename to src/managers/GuildMemberRoleManager.js
index 205de123..84711056 100644
--- a/src/stores/GuildMemberRoleStore.js
+++ b/src/managers/GuildMemberRoleManager.js
@@ -1,15 +1,22 @@
-const Collection = require('../util/Collection');
-const Util = require('../util/Util');
+'use strict';
+
 const { TypeError } = require('../errors');
+const Collection = require('../util/Collection');
 
 /**
- * Stores member roles
- * @extends {Collection}
+ * Manages API methods for roles of a GuildMember and stores their cache.
  */
-class GuildMemberRoleStore extends Collection {
+class GuildMemberRoleManager {
   constructor(member) {
-    super();
+    /**
+     * The GuildMember this manager belongs to
+     * @type {GuildMember}
+     */
     this.member = member;
+    /**
+     * The Guild this manager belongs to
+     * @type {Guild}
+     */
     this.guild = member.guild;
     Object.defineProperty(this, 'client', { value: member.client });
   }
@@ -18,10 +25,20 @@ class GuildMemberRoleStore extends Collection {
    * The filtered collection of roles of the member
    * @type {Collection<Snowflake, Role>}
    * @private
+   * @readonly
    */
-  get _filtered() {
-    const everyone = this.guild.defaultRole;
-    return this.guild.roles.filter(role => this.member._roles.includes(role.id)).set(everyone.id, everyone);
+  get _roles() {
+    const everyone = this.guild.roles.everyone;
+    return this.guild.roles.cache.filter(role => this.member._roles.includes(role.id)).set(everyone.id, everyone);
+  }
+
+  /**
+   * The roles of this member
+   * @type {Collection<Snowflake, Role>}
+   * @readonly
+   */
+  get cache() {
+    return this._roles;
   }
 
   /**
@@ -30,9 +47,9 @@ class GuildMemberRoleStore extends Collection {
    * @readonly
    */
   get hoist() {
-    const hoistedRoles = this._filtered.filter(role => role.hoist);
+    const hoistedRoles = this._roles.filter(role => role.hoist);
     if (!hoistedRoles.size) return null;
-    return hoistedRoles.reduce((prev, role) => !prev || role.comparePositionTo(prev) > 0 ? role : prev);
+    return hoistedRoles.reduce((prev, role) => (!prev || role.comparePositionTo(prev) > 0 ? role : prev));
   }
 
   /**
@@ -41,9 +58,9 @@ class GuildMemberRoleStore extends Collection {
    * @readonly
    */
   get color() {
-    const coloredRoles = this._filtered.filter(role => role.color);
+    const coloredRoles = this._roles.filter(role => role.color);
     if (!coloredRoles.size) return null;
-    return coloredRoles.reduce((prev, role) => !prev || role.comparePositionTo(prev) > 0 ? role : prev);
+    return coloredRoles.reduce((prev, role) => (!prev || role.comparePositionTo(prev) > 0 ? role : prev));
   }
 
   /**
@@ -52,7 +69,7 @@ class GuildMemberRoleStore extends Collection {
    * @readonly
    */
   get highest() {
-    return this._filtered.reduce((prev, role) => role.comparePositionTo(prev) > 0 ? role : prev, this.first());
+    return this._roles.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev), this._roles.first());
   }
 
   /**
@@ -62,26 +79,24 @@ class GuildMemberRoleStore extends Collection {
    * @returns {Promise<GuildMember>}
    */
   async add(roleOrRoles, reason) {
-    if (roleOrRoles instanceof Collection || roleOrRoles instanceof Array) {
+    if (roleOrRoles instanceof Collection || Array.isArray(roleOrRoles)) {
       roleOrRoles = roleOrRoles.map(r => this.guild.roles.resolve(r));
       if (roleOrRoles.includes(null)) {
-        return Promise.reject(new TypeError('INVALID_TYPE', 'roles',
-          'Array or Collection of Roles or Snowflakes', true));
+        throw new TypeError('INVALID_TYPE', 'roles', 'Array or Collection of Roles or Snowflakes', true);
       }
 
-      const newRoles = [...new Set(roleOrRoles.concat(...this.values()))];
+      const newRoles = [...new Set(roleOrRoles.concat(...this._roles.values()))];
       return this.set(newRoles, reason);
     } else {
       roleOrRoles = this.guild.roles.resolve(roleOrRoles);
       if (roleOrRoles === null) {
-        return Promise.reject(new TypeError('INVALID_TYPE', 'roles',
-          'Array or Collection of Roles or Snowflakes', true));
+        throw new TypeError('INVALID_TYPE', 'roles', 'Array or Collection of Roles or Snowflakes', true);
       }
 
       await this.client.api.guilds[this.guild.id].members[this.member.id].roles[roleOrRoles.id].put({ reason });
 
       const clone = this.member._clone();
-      clone.roles._patch([...this.keys(), roleOrRoles.id]);
+      clone._roles = [...this._roles.keys(), roleOrRoles.id];
       return clone;
     }
   }
@@ -93,27 +108,25 @@ class GuildMemberRoleStore extends Collection {
    * @returns {Promise<GuildMember>}
    */
   async remove(roleOrRoles, reason) {
-    if (roleOrRoles instanceof Collection || roleOrRoles instanceof Array) {
+    if (roleOrRoles instanceof Collection || Array.isArray(roleOrRoles)) {
       roleOrRoles = roleOrRoles.map(r => this.guild.roles.resolve(r));
       if (roleOrRoles.includes(null)) {
-        return Promise.reject(new TypeError('INVALID_TYPE', 'roles',
-          'Array or Collection of Roles or Snowflakes', true));
+        throw new TypeError('INVALID_TYPE', 'roles', 'Array or Collection of Roles or Snowflakes', true);
       }
 
-      const newRoles = this.filter(role => !roleOrRoles.includes(role));
+      const newRoles = this._roles.filter(role => !roleOrRoles.includes(role));
       return this.set(newRoles, reason);
     } else {
       roleOrRoles = this.guild.roles.resolve(roleOrRoles);
       if (roleOrRoles === null) {
-        return Promise.reject(new TypeError('INVALID_TYPE', 'roles',
-          'Array or Collection of Roles or Snowflakes', true));
+        throw new TypeError('INVALID_TYPE', 'roles', 'Array or Collection of Roles or Snowflakes', true);
       }
 
       await this.client.api.guilds[this.guild.id].members[this.member.id].roles[roleOrRoles.id].delete({ reason });
 
       const clone = this.member._clone();
-      const newRoles = this.filter(role => role.id !== roleOrRoles.id);
-      clone.roles._patch([...newRoles.keys()]);
+      const newRoles = this._roles.filter(role => role.id !== roleOrRoles.id);
+      clone._roles = [...newRoles.keys()];
       return clone;
     }
   }
@@ -131,32 +144,18 @@ class GuildMemberRoleStore extends Collection {
    * @example
    * // Remove all the roles from a member
    * guildMember.roles.set([])
-   *   .then(member => console.log(`Member roles is now of ${member.roles.size} size`))
+   *   .then(member => console.log(`Member roles is now of ${member.roles.cache.size} size`))
    *   .catch(console.error);
    */
   set(roles, reason) {
     return this.member.edit({ roles }, reason);
   }
 
-  _patch(roles) {
-    this.member._roles = roles;
-  }
-
   clone() {
     const clone = new this.constructor(this.member);
-    clone._patch(this.keyArray());
+    clone.member._roles = [...this._roles.keyArray()];
     return clone;
   }
-
-  *[Symbol.iterator]() {
-    yield* this._filtered.entries();
-  }
-
-  valueOf() {
-    return this._filtered;
-  }
 }
 
-Util.mixin(GuildMemberRoleStore, ['set']);
-
-module.exports = GuildMemberRoleStore;
+module.exports = GuildMemberRoleManager;
diff --git a/src/stores/MessageStore.js b/src/managers/MessageManager.js
similarity index 59%
rename from src/stores/MessageStore.js
rename to src/managers/MessageManager.js
index 2d704979..321dc455 100644
--- a/src/stores/MessageStore.js
+++ b/src/managers/MessageManager.js
@@ -1,28 +1,34 @@
-const DataStore = require('./DataStore');
-const Collection = require('../util/Collection');
+'use strict';
+
+const BaseManager = require('./BaseManager');
 const Message = require('../structures/Message');
+const Collection = require('../util/Collection');
+const LimitedCollection = require('../util/LimitedCollection');
 
 /**
- * Stores messages for text-based channels.
- * @extends {DataStore}
+ * Manages API methods for Messages and holds their cache.
+ * @extends {BaseManager}
  */
-class MessageStore extends DataStore {
+class MessageManager extends BaseManager {
   constructor(channel, iterable) {
-    super(channel.client, iterable, Message);
+    super(channel.client, iterable, Message, LimitedCollection, channel.client.options.messageCacheMaxSize);
+    /**
+     * The channel that the messages belong to
+     * @type {TextBasedChannel}
+     */
     this.channel = channel;
   }
 
+  /**
+   * The cache of Messages
+   * @type {LimitedCollection<Snowflake, Message>}
+   * @name MessageManager#cache
+   */
+
   add(data, cache) {
     return super.add(data, cache, { extras: [this.channel] });
   }
 
-  set(key, value) {
-    const maxSize = this.client.options.messageCacheMaxSize;
-    if (maxSize === 0) return;
-    if (this.size >= maxSize && maxSize > 0) this.delete(this.firstKey());
-    super.set(key, value);
-  }
-
   /**
    * The parameters to pass in when requesting previous messages from a channel. `around`, `before` and
    * `after` are mutually exclusive. All the parameters are optional.
@@ -38,6 +44,7 @@ class MessageStore extends DataStore {
    * <info>The returned Collection does not contain reaction users of the messages if they were not cached.
    * Those need to be fetched separately in such a case.</info>
    * @param {Snowflake|ChannelLogsQueryOptions} [message] The ID of the message to fetch, or query parameters.
+   * @param {boolean} [cache=true] Whether to cache the message(s)
    * @returns {Promise<Message>|Promise<Collection<Snowflake, Message>>}
    * @example
    * // Get message
@@ -55,14 +62,15 @@ class MessageStore extends DataStore {
    *   .then(messages => console.log(`${messages.filter(m => m.author.id === '84484653687267328').size} messages`))
    *   .catch(console.error);
    */
-  fetch(message) {
-    return typeof message === 'string' ? this._fetchId(message) : this._fetchMany(message);
+  fetch(message, cache = true) {
+    return typeof message === 'string' ? this._fetchId(message, cache) : this._fetchMany(message, cache);
   }
 
   /**
    * Fetches the pinned messages of this channel and returns a collection of them.
    * <info>The returned Collection does not contain any reaction data of the messages.
    * Those need to be fetched separately.</info>
+   * @param {boolean} [cache=true] Whether to cache the message(s)
    * @returns {Promise<Collection<Snowflake, Message>>}
    * @example
    * // Get pinned messages
@@ -70,27 +78,14 @@ class MessageStore extends DataStore {
    *   .then(messages => console.log(`Received ${messages.size} messages`))
    *   .catch(console.error);
    */
-  fetchPinned() {
+  fetchPinned(cache = true) {
     return this.client.api.channels[this.channel.id].pins.get().then(data => {
       const messages = new Collection();
-      for (const message of data) messages.set(message.id, this.add(message));
+      for (const message of data) messages.set(message.id, this.add(message, cache));
       return messages;
     });
   }
 
-  async _fetchId(messageID) {
-    const data = await this.client.api.channels[this.channel.id].messages[messageID].get();
-    return this.add(data);
-  }
-
-  async _fetchMany(options = {}) {
-    const data = await this.client.api.channels[this.channel.id].messages.get({ query: options });
-    const messages = new Collection();
-    for (const message of data) messages.set(message.id, this.add(message));
-    return messages;
-  }
-
-
   /**
    * Data that can be resolved to a Message object. This can be:
    * * A Message
@@ -99,22 +94,51 @@ class MessageStore extends DataStore {
    */
 
   /**
-    * Resolves a MessageResolvable to a Message object.
-    * @method resolve
-    * @memberof MessageStore
-    * @instance
-    * @param {MessageResolvable} message The message resolvable to resolve
-    * @returns {?Message}
-    */
+   * Resolves a MessageResolvable to a Message object.
+   * @method resolve
+   * @memberof MessageManager
+   * @instance
+   * @param {MessageResolvable} message The message resolvable to resolve
+   * @returns {?Message}
+   */
 
   /**
-    * Resolves a MessageResolvable to a Message ID string.
-    * @method resolveID
-    * @memberof MessageStore
-    * @instance
-    * @param {MessageResolvable} message The message resolvable to resolve
-    * @returns {?Snowflake}
-    */
+   * Resolves a MessageResolvable to a Message ID string.
+   * @method resolveID
+   * @memberof MessageManager
+   * @instance
+   * @param {MessageResolvable} message The message resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Deletes a message, even if it's not cached.
+   * @param {MessageResolvable} message The message to delete
+   * @param {string} [reason] Reason for deleting this message, if it does not belong to the client user
+   */
+  async delete(message, reason) {
+    message = this.resolveID(message);
+    if (message) {
+      await this.client.api
+        .channels(this.channel.id)
+        .messages(message)
+        .delete({ reason });
+    }
+  }
+
+  async _fetchId(messageID, cache) {
+    const existing = this.cache.get(messageID);
+    if (existing && !existing.partial) return existing;
+    const data = await this.client.api.channels[this.channel.id].messages[messageID].get();
+    return this.add(data, cache);
+  }
+
+  async _fetchMany(options = {}, cache) {
+    const data = await this.client.api.channels[this.channel.id].messages.get({ query: options });
+    const messages = new Collection();
+    for (const message of data) messages.set(message.id, this.add(message, cache));
+    return messages;
+  }
 }
 
-module.exports = MessageStore;
+module.exports = MessageManager;
diff --git a/src/stores/PresenceStore.js b/src/managers/PresenceManager.js
similarity index 54%
rename from src/stores/PresenceStore.js
rename to src/managers/PresenceManager.js
index 15fc9f12..c02fe044 100644
--- a/src/stores/PresenceStore.js
+++ b/src/managers/PresenceManager.js
@@ -1,17 +1,25 @@
-const DataStore = require('./DataStore');
+'use strict';
+
+const BaseManager = require('./BaseManager');
 const { Presence } = require('../structures/Presence');
 
 /**
- * Stores presences.
- * @extends {DataStore}
+ * Manages API methods for Presences and holds their cache.
+ * @extends {BaseManager}
  */
-class PresenceStore extends DataStore {
+class PresenceManager extends BaseManager {
   constructor(client, iterable) {
     super(client, iterable, Presence);
   }
 
+  /**
+   * The cache of Presences
+   * @type {Collection<Snowflake, Presence>}
+   * @name PresenceManager#cache
+   */
+
   add(data, cache) {
-    const existing = this.get(data.user.id);
+    const existing = this.cache.get(data.user.id);
     return existing ? existing.patch(data) : super.add(data, cache, { id: data.user.id });
   }
 
@@ -24,10 +32,10 @@ class PresenceStore extends DataStore {
    */
 
   /**
-    * Resolves a PresenceResolvable to a Presence object.
-    * @param {PresenceResolvable} presence The presence resolvable to resolve
-    * @returns {?Presence}
-    */
+   * Resolves a PresenceResolvable to a Presence object.
+   * @param {PresenceResolvable} presence The presence resolvable to resolve
+   * @returns {?Presence}
+   */
   resolve(presence) {
     const presenceResolvable = super.resolve(presence);
     if (presenceResolvable) return presenceResolvable;
@@ -36,16 +44,16 @@ class PresenceStore extends DataStore {
   }
 
   /**
-    * Resolves a PresenceResolvable to a Presence ID string.
-    * @param {PresenceResolvable} presence The presence resolvable to resolve
-    * @returns {?Snowflake}
-    */
+   * Resolves a PresenceResolvable to a Presence ID string.
+   * @param {PresenceResolvable} presence The presence resolvable to resolve
+   * @returns {?Snowflake}
+   */
   resolveID(presence) {
     const presenceResolvable = super.resolveID(presence);
     if (presenceResolvable) return presenceResolvable;
     const userResolvable = this.client.users.resolveID(presence);
-    return this.has(userResolvable) ? userResolvable : null;
+    return this.cache.has(userResolvable) ? userResolvable : null;
   }
 }
 
-module.exports = PresenceStore;
+module.exports = PresenceManager;
diff --git a/src/managers/ReactionManager.js b/src/managers/ReactionManager.js
new file mode 100644
index 00000000..b8217689
--- /dev/null
+++ b/src/managers/ReactionManager.js
@@ -0,0 +1,95 @@
+'use strict';
+
+const BaseManager = require('./BaseManager');
+const MessageReaction = require('../structures/MessageReaction');
+
+/**
+ * Manages API methods for reactions and holds their cache.
+ * @extends {BaseManager}
+ */
+class ReactionManager extends BaseManager {
+  constructor(message, iterable) {
+    super(message.client, iterable, MessageReaction);
+
+    /**
+     * The message that this manager belongs to
+     * @type {Message}
+     */
+    this.message = message;
+  }
+
+  add(data, cache) {
+    return super.add(data, cache, { id: data.emoji.id || data.emoji.name, extras: [this.message] });
+  }
+
+  /**
+   * The reaction cache of this manager
+   * @type {Collection<Snowflake, MessageReaction>}
+   * @name ReactionManager#cache
+   */
+
+  /**
+   * Data that can be resolved to a MessageReaction object. This can be:
+   * * A MessageReaction
+   * * A Snowflake
+   * @typedef {MessageReaction|Snowflake} MessageReactionResolvable
+   */
+
+  /**
+   * Resolves a MessageReactionResolvable to a MessageReaction object.
+   * @method resolve
+   * @memberof ReactionManager
+   * @instance
+   * @param {MessageReactionResolvable} reaction The MessageReaction to resolve
+   * @returns {?MessageReaction}
+   */
+
+  /**
+   * Resolves a MessageReactionResolvable to a MessageReaction ID string.
+   * @method resolveID
+   * @memberof ReactionManager
+   * @instance
+   * @param {MessageReactionResolvable} reaction The MessageReaction to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Removes all reactions from a message.
+   * @returns {Promise<Message>}
+   */
+  removeAll() {
+    return this.client.api
+      .channels(this.message.channel.id)
+      .messages(this.message.id)
+      .reactions.delete()
+      .then(() => this.message);
+  }
+
+  _partial(emoji) {
+    const id = emoji.id || emoji.name;
+    const existing = this.cache.get(id);
+    return !existing || existing.partial;
+  }
+
+  async _fetchReaction(reactionEmoji, cache) {
+    const id = reactionEmoji.id || reactionEmoji.name;
+    const existing = this.cache.get(id);
+    if (!this._partial(reactionEmoji)) return existing;
+    const data = await this.client.api
+      .channels(this.message.channel.id)
+      .messages(this.message.id)
+      .get();
+    if (this.message.partial) this.message._patch(data);
+    if (!data.reactions || !data.reactions.some(r => (r.emoji.id || r.emoji.name) === id)) {
+      reactionEmoji.reaction._patch({ count: 0 });
+      this.message.reactions.cache.delete(id);
+      return existing;
+    }
+    for (const reaction of data.reactions) {
+      if (this._partial(reaction.emoji)) this.add(reaction, cache);
+    }
+    return existing;
+  }
+}
+
+module.exports = ReactionManager;
diff --git a/src/stores/ReactionUserStore.js b/src/managers/ReactionUserManager.js
similarity index 65%
rename from src/stores/ReactionUserStore.js
rename to src/managers/ReactionUserManager.js
index 1b027579..1a6ce147 100644
--- a/src/stores/ReactionUserStore.js
+++ b/src/managers/ReactionUserManager.js
@@ -1,17 +1,29 @@
-const Collection = require('../util/Collection');
-const DataStore = require('./DataStore');
+'use strict';
+
+const BaseManager = require('./BaseManager');
 const { Error } = require('../errors');
+const Collection = require('../util/Collection');
 
 /**
- * A data store to store User models who reacted to a MessageReaction.
- * @extends {DataStore}
+ * Manages API methods for users who reacted to a reaction and stores their cache.
+ * @extends {BaseManager}
  */
-class ReactionUserStore extends DataStore {
+class ReactionUserManager extends BaseManager {
   constructor(client, iterable, reaction) {
-    super(client, iterable, require('../structures/User'));
+    super(client, iterable, { name: 'User' });
+    /**
+     * The reaction that this manager belongs to
+     * @type {MessageReaction}
+     */
     this.reaction = reaction;
   }
 
+  /**
+   * The cache of this manager
+   * @type {Collection<Snowflake, User>}
+   * @name ReactionUserManager#cache
+   */
+
   /**
    * Fetches all the users that gave this reaction. Resolves with a collection of users, mapped by their IDs.
    * @param {Object} [options] Options for fetching the users
@@ -22,13 +34,13 @@ class ReactionUserStore extends DataStore {
    */
   async fetch({ limit = 100, after, before } = {}) {
     const message = this.reaction.message;
-    const data = await this.client.api.channels[message.channel.id].messages[message.id]
-      .reactions[this.reaction.emoji.identifier]
-      .get({ query: { limit, before, after } });
+    const data = await this.client.api.channels[message.channel.id].messages[message.id].reactions[
+      this.reaction.emoji.identifier
+    ].get({ query: { limit, before, after } });
     const users = new Collection();
     for (const rawUser of data) {
       const user = this.client.users.add(rawUser);
-      this.set(user.id, user);
+      this.cache.set(user.id, user);
       users.set(user.id, user);
     }
     return users;
@@ -43,18 +55,12 @@ class ReactionUserStore extends DataStore {
     const message = this.reaction.message;
     const userID = message.client.users.resolveID(user);
     if (!userID) return Promise.reject(new Error('REACTION_RESOLVE_USER'));
-    return message.client.api.channels[message.channel.id].messages[message.id]
-      .reactions[this.reaction.emoji.identifier][userID === message.client.user.id ? '@me' : userID]
+    return message.client.api.channels[message.channel.id].messages[message.id].reactions[
+      this.reaction.emoji.identifier
+    ][userID === message.client.user.id ? '@me' : userID]
       .delete()
-      .then(() =>
-        message.client.actions.MessageReactionRemove.handle({
-          user_id: userID,
-          message_id: message.id,
-          emoji: this.reaction.emoji,
-          channel_id: message.channel.id,
-        }).reaction
-      );
+      .then(() => this.reaction);
   }
 }
 
-module.exports = ReactionUserStore;
+module.exports = ReactionUserManager;
diff --git a/src/managers/RoleManager.js b/src/managers/RoleManager.js
new file mode 100644
index 00000000..4b7ebe38
--- /dev/null
+++ b/src/managers/RoleManager.js
@@ -0,0 +1,145 @@
+'use strict';
+
+const BaseManager = require('./BaseManager');
+const Role = require('../structures/Role');
+const Permissions = require('../util/Permissions');
+const { resolveColor } = require('../util/Util');
+
+/**
+ * Manages API methods for roles and stores their cache.
+ * @extends {BaseManager}
+ */
+class RoleManager extends BaseManager {
+  constructor(guild, iterable) {
+    super(guild.client, iterable, Role);
+    /**
+     * The guild belonging to this manager
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The role cache of this manager
+   * @type {Collection<Snowflake, Role>}
+   * @name RoleManager#cache
+   */
+
+  add(data, cache) {
+    return super.add(data, cache, { extras: [this.guild] });
+  }
+
+  /**
+   * Obtains one or more roles from Discord, or the role cache if they're already available.
+   * @param {Snowflake} [id] ID or IDs of the role(s)
+   * @param {boolean} [cache=true] Whether to cache the new roles objects if it weren't already
+   * @returns {Promise<Role|RoleManager>}
+   * @example
+   * // Fetch all roles from the guild
+   * message.guild.roles.fetch()
+   *   .then(roles => console.log(`There are ${roles.cache.size} roles.`))
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single role
+   * message.guild.roles.fetch('222078108977594368')
+   *   .then(role => console.log(`The role color is: ${role.color}`))
+   *   .catch(console.error);
+   */
+  async fetch(id, cache = true) {
+    if (id) {
+      const existing = this.cache.get(id);
+      if (existing) return existing;
+    }
+
+    // We cannot fetch a single role, as of this commit's date, Discord API throws with 405
+    const roles = await this.client.api.guilds(this.guild.id).roles.get();
+    for (const role of roles) this.add(role, cache);
+    return id ? this.cache.get(id) || null : this;
+  }
+
+  /**
+   * Data that can be resolved to a Role object. This can be:
+   * * A Role
+   * * A Snowflake
+   * @typedef {Role|Snowflake} RoleResolvable
+   */
+
+  /**
+   * Resolves a RoleResolvable to a Role object.
+   * @method resolve
+   * @memberof RoleManager
+   * @instance
+   * @param {RoleResolvable} role The role resolvable to resolve
+   * @returns {?Role}
+   */
+
+  /**
+   * Resolves a RoleResolvable to a role ID string.
+   * @method resolveID
+   * @memberof RoleManager
+   * @instance
+   * @param {RoleResolvable} role The role resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Creates a new role in the guild with given information.
+   * <warn>The position will silently reset to 1 if an invalid one is provided, or none.</warn>
+   * @param {Object} [options] Options
+   * @param {RoleData} [options.data] The data to create the role with
+   * @param {string} [options.reason] Reason for creating this role
+   * @returns {Promise<Role>}
+   * @example
+   * // Create a new role
+   * guild.roles.create()
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Create a new role with data and a reason
+   * guild.roles.create({
+   *   data: {
+   *     name: 'Super Cool People',
+   *     color: 'BLUE',
+   *   },
+   *   reason: 'we needed a role for Super Cool People',
+   * })
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  create({ data = {}, reason } = {}) {
+    if (data.color) data.color = resolveColor(data.color);
+    if (data.permissions) data.permissions = Permissions.resolve(data.permissions);
+
+    return this.guild.client.api
+      .guilds(this.guild.id)
+      .roles.post({ data, reason })
+      .then(r => {
+        const { role } = this.client.actions.GuildRoleCreate.handle({
+          guild_id: this.guild.id,
+          role: r,
+        });
+        if (data.position) return role.setPosition(data.position, reason);
+        return role;
+      });
+  }
+
+  /**
+   * The `@everyone` role of the guild
+   * @type {?Role}
+   * @readonly
+   */
+  get everyone() {
+    return this.cache.get(this.guild.id) || null;
+  }
+
+  /**
+   * The role with the highest position in the cache
+   * @type {Role}
+   * @readonly
+   */
+  get highest() {
+    return this.cache.reduce((prev, role) => (role.comparePositionTo(prev) > 0 ? role : prev), this.cache.first());
+  }
+}
+
+module.exports = RoleManager;
diff --git a/src/stores/UserStore.js b/src/managers/UserManager.js
similarity index 71%
rename from src/stores/UserStore.js
rename to src/managers/UserManager.js
index d700877c..ebd7fdf3 100644
--- a/src/stores/UserStore.js
+++ b/src/managers/UserManager.js
@@ -1,17 +1,25 @@
-const DataStore = require('./DataStore');
-const User = require('../structures/User');
+'use strict';
+
+const BaseManager = require('./BaseManager');
 const GuildMember = require('../structures/GuildMember');
 const Message = require('../structures/Message');
+const User = require('../structures/User');
 
 /**
- * A data store to store User models.
- * @extends {DataStore}
+ * Manages API methods for users and stores their cache.
+ * @extends {BaseManager}
  */
-class UserStore extends DataStore {
+class UserManager extends BaseManager {
   constructor(client, iterable) {
     super(client, iterable, User);
   }
 
+  /**
+   * The cache of this manager
+   * @type {Collection<Snowflake, User>}
+   * @name UserManager#cache
+   */
+
   /**
    * Data that resolves to give a User object. This can be:
    * * A User object
@@ -49,12 +57,12 @@ class UserStore extends DataStore {
    * @param {boolean} [cache=true] Whether to cache the new user object if it isn't already
    * @returns {Promise<User>}
    */
-  fetch(id, cache = true) {
-    const existing = this.get(id);
-    if (existing) return Promise.resolve(existing);
-
-    return this.client.api.users(id).get().then(data => this.add(data, cache));
+  async fetch(id, cache = true) {
+    const existing = this.cache.get(id);
+    if (existing && !existing.partial) return existing;
+    const data = await this.client.api.users(id).get();
+    return this.add(data, cache);
   }
 }
 
-module.exports = UserStore;
+module.exports = UserManager;
diff --git a/src/managers/VoiceStateManager.js b/src/managers/VoiceStateManager.js
new file mode 100644
index 00000000..4a26b304
--- /dev/null
+++ b/src/managers/VoiceStateManager.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const BaseManager = require('./BaseManager');
+const VoiceState = require('../structures/VoiceState');
+
+/**
+ * Manages API methods for VoiceStates and stores their cache.
+ * @extends {BaseManager}
+ */
+class VoiceStateManager extends BaseManager {
+  constructor(guild, iterable) {
+    super(guild.client, iterable, VoiceState);
+    /**
+     * The guild this manager belongs to
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of this manager
+   * @type {Collection<Snowflake, VoiceState>}
+   * @name VoiceStateManager#cache
+   */
+
+  add(data, cache = true) {
+    const existing = this.cache.get(data.user_id);
+    if (existing) return existing._patch(data);
+
+    const entry = new VoiceState(this.guild, data);
+    if (cache) this.cache.set(data.user_id, entry);
+    return entry;
+  }
+}
+
+module.exports = VoiceStateManager;
diff --git a/src/rest/APIRequest.js b/src/rest/APIRequest.js
index ec8375dd..d94f0e65 100644
--- a/src/rest/APIRequest.js
+++ b/src/rest/APIRequest.js
@@ -1,8 +1,10 @@
-const querystring = require('querystring');
-const FormData = require('form-data');
+'use strict';
+
 const https = require('https');
-const { browser, UserAgent } = require('../util/Constants');
+const AbortController = require('abort-controller');
+const FormData = require('form-data');
 const fetch = require('node-fetch');
+const { browser, UserAgent } = require('../util/Constants');
 
 if (https.Agent) var agent = new https.Agent({ keepAlive: true });
 
@@ -14,13 +16,20 @@ class APIRequest {
     this.route = options.route;
     this.options = options;
 
-    const queryString = (querystring.stringify(options.query).match(/[^=&?]+=[^=&?]+/g) || []).join('&');
-    this.path = `${path}${queryString ? `?${queryString}` : ''}`;
+    let queryString = '';
+    if (options.query) {
+      // Filter out undefined query options
+      const query = Object.entries(options.query).filter(([, value]) => value !== null && typeof value !== 'undefined');
+      queryString = new URLSearchParams(query).toString();
+    }
+    this.path = `${path}${queryString && `?${queryString}`}`;
   }
 
   make() {
-    const API = this.options.versioned === false ? this.client.options.http.api :
-      `${this.client.options.http.api}/v${this.client.options.http.version}`;
+    const API =
+      this.options.versioned === false
+        ? this.client.options.http.api
+        : `${this.client.options.http.api}/v${this.client.options.http.version}`;
     const url = API + this.path;
     let headers = {};
 
@@ -35,17 +44,21 @@ class APIRequest {
       for (const file of this.options.files) if (file && file.file) body.append(file.name, file.file, file.name);
       if (typeof this.options.data !== 'undefined') body.append('payload_json', JSON.stringify(this.options.data));
       if (!browser) headers = Object.assign(headers, body.getHeaders());
-    } else if (this.options.data != null) { // eslint-disable-line eqeqeq
+      // eslint-disable-next-line eqeqeq
+    } else if (this.options.data != null) {
       body = JSON.stringify(this.options.data);
       headers['Content-Type'] = 'application/json';
     }
 
+    const controller = new AbortController();
+    const timeout = this.client.setTimeout(() => controller.abort(), this.client.options.restRequestTimeout);
     return fetch(url, {
       method: this.method,
       headers,
       agent,
       body,
-    });
+      signal: controller.signal,
+    }).finally(() => this.client.clearTimeout(timeout));
   }
 }
 
diff --git a/src/rest/APIRouter.js b/src/rest/APIRouter.js
index 06ebeb3f..e85c739f 100644
--- a/src/rest/APIRouter.js
+++ b/src/rest/APIRouter.js
@@ -1,8 +1,14 @@
+'use strict';
+
 const noop = () => {}; // eslint-disable-line no-empty-function
 const methods = ['get', 'post', 'delete', 'patch', 'put'];
 const reflectors = [
-  'toString', 'valueOf', 'inspect', 'constructor',
-  Symbol.toPrimitive, Symbol.for('util.inspect.custom'),
+  'toString',
+  'valueOf',
+  'inspect',
+  'constructor',
+  Symbol.toPrimitive,
+  Symbol.for('nodejs.util.inspect.custom'),
 ];
 
 function buildRoute(manager) {
@@ -11,14 +17,27 @@ function buildRoute(manager) {
     get(target, name) {
       if (reflectors.includes(name)) return () => route.join('/');
       if (methods.includes(name)) {
-        return options => manager.request(name, route.join('/'), Object.assign({
-          versioned: manager.versioned,
-          route: route.map((r, i) => {
-            if (/\d{16,19}/g.test(r)) return /channels|guilds/.test(route[i - 1]) ? r : ':id';
-            if (route[i - 1] === 'reactions') return ':reaction';
-            return r;
-          }).join('/'),
-        }, options));
+        const routeBucket = [];
+        for (let i = 0; i < route.length; i++) {
+          // Reactions routes and sub-routes all share the same bucket
+          if (route[i - 1] === 'reactions') break;
+          // Literal IDs should only be taken account if they are the Major ID (the Channel/Guild ID)
+          if (/\d{16,19}/g.test(route[i]) && !/channels|guilds/.test(route[i - 1])) routeBucket.push(':id');
+          // All other parts of the route should be considered as part of the bucket identifier
+          else routeBucket.push(route[i]);
+        }
+        return options =>
+          manager.request(
+            name,
+            route.join('/'),
+            Object.assign(
+              {
+                versioned: manager.versioned,
+                route: routeBucket.join('/'),
+              },
+              options,
+            ),
+          );
       }
       route.push(name);
       return new Proxy(noop, handler);
diff --git a/src/rest/DiscordAPIError.js b/src/rest/DiscordAPIError.js
index c90ee4f5..aebe513d 100644
--- a/src/rest/DiscordAPIError.js
+++ b/src/rest/DiscordAPIError.js
@@ -1,9 +1,11 @@
+'use strict';
+
 /**
  * Represents an error from the Discord API.
  * @extends Error
  */
 class DiscordAPIError extends Error {
-  constructor(path, error, method) {
+  constructor(path, error, method, status) {
     super();
     const flattened = this.constructor.flattenErrors(error.errors || error).join('\n');
     this.name = 'DiscordAPIError';
@@ -26,6 +28,12 @@ class DiscordAPIError extends Error {
      * @type {number}
      */
     this.code = error.code;
+
+    /**
+     * The HTTP status code
+     * @type {number}
+     */
+    this.httpStatus = status;
   }
 
   /**
@@ -40,7 +48,7 @@ class DiscordAPIError extends Error {
 
     for (const [k, v] of Object.entries(obj)) {
       if (k === 'message') continue;
-      const newKey = key ? isNaN(k) ? `${key}.${k}` : `${key}[${k}]` : k;
+      const newKey = key ? (isNaN(k) ? `${key}.${k}` : `${key}[${k}]`) : k;
 
       if (v._errors) {
         messages.push(`${newKey}: ${v._errors.map(e => e.message).join(' ')}`);
diff --git a/src/rest/HTTPError.js b/src/rest/HTTPError.js
index 32b3e6bd..2911467f 100644
--- a/src/rest/HTTPError.js
+++ b/src/rest/HTTPError.js
@@ -1,3 +1,5 @@
+'use strict';
+
 /**
  * Represents a HTTP error from a request.
  * @extends Error
diff --git a/src/rest/RESTManager.js b/src/rest/RESTManager.js
index 53a8047f..b02ae812 100644
--- a/src/rest/RESTManager.js
+++ b/src/rest/RESTManager.js
@@ -1,9 +1,11 @@
-const RequestHandler = require('./RequestHandler');
+'use strict';
+
 const APIRequest = require('./APIRequest');
 const routeBuilder = require('./APIRouter');
+const RequestHandler = require('./RequestHandler');
 const { Error } = require('../errors');
-const { Endpoints } = require('../util/Constants');
 const Collection = require('../util/Collection');
+const { Endpoints } = require('../util/Constants');
 
 class RESTManager {
   constructor(client, tokenPrefix = 'Bot') {
@@ -25,9 +27,7 @@ class RESTManager {
 
   getAuth() {
     const token = this.client.token || this.client.accessToken;
-    const prefixed = !!this.client.application || this.client.user;
-    if (token && prefixed) return `${this.tokenPrefix} ${token}`;
-    else if (token) return token;
+    if (token) return `${this.tokenPrefix} ${token}`;
     throw new Error('TOKEN_MISSING');
   }
 
@@ -37,12 +37,14 @@ class RESTManager {
 
   push(handler, apiRequest) {
     return new Promise((resolve, reject) => {
-      handler.push({
-        request: apiRequest,
-        resolve,
-        reject,
-        retries: 0,
-      }).catch(reject);
+      handler
+        .push({
+          request: apiRequest,
+          resolve,
+          reject,
+          retries: 0,
+        })
+        .catch(reject);
     });
   }
 
diff --git a/src/rest/RequestHandler.js b/src/rest/RequestHandler.js
index 3f66fd43..76ca0dd1 100644
--- a/src/rest/RequestHandler.js
+++ b/src/rest/RequestHandler.js
@@ -1,7 +1,12 @@
+'use strict';
+
 const DiscordAPIError = require('./DiscordAPIError');
 const HTTPError = require('./HTTPError');
+const {
+  Events: { RATE_LIMIT },
+  browser,
+} = require('../util/Constants');
 const Util = require('../util/Util');
-const { Events: { RATE_LIMIT }, browser } = require('../util/Constants');
 
 function parseResponse(res) {
   if (res.headers.get('content-type').startsWith('application/json')) return res.json();
@@ -50,7 +55,6 @@ class RequestHandler {
     return this.queue.length === 0 && !this.limited && this.busy !== true;
   }
 
-  /* eslint-disable-next-line complexity */
   async execute(item) {
     // Insert item back to the beginning if currently busy
     if (this.busy) {
@@ -100,9 +104,7 @@ class RequestHandler {
     } catch (error) {
       // NodeFetch error expected for all "operational" errors, such as 500 status code
       this.busy = false;
-      return reject(
-        new HTTPError(error.message, error.constructor.name, error.status, request.method, request.route)
-      );
+      return reject(new HTTPError(error.message, error.constructor.name, error.status, request.method, request.path));
     }
 
     if (res && res.headers) {
@@ -153,7 +155,7 @@ class RequestHandler {
       // Retry the specified number of times for possible serverside issues
       if (item.retries === this.manager.client.options.retryLimit) {
         return reject(
-          new HTTPError(res.statusText, res.constructor.name, res.status, item.request.method, request.path)
+          new HTTPError(res.statusText, res.constructor.name, res.status, item.request.method, request.path),
         );
       } else {
         item.retries++;
@@ -161,17 +163,15 @@ class RequestHandler {
         return this.run();
       }
     } else {
-      // Handle possible malformed requessts
+      // Handle possible malformed requests
       try {
         const data = await parseResponse(res);
         if (res.status >= 400 && res.status < 500) {
-          return reject(new DiscordAPIError(request.path, data, request.method));
+          return reject(new DiscordAPIError(request.path, data, request.method, res.status));
         }
         return null;
       } catch (err) {
-        return reject(
-          new HTTPError(err.message, err.constructor.name, err.status, request.method, request.path)
-        );
+        return reject(new HTTPError(err.message, err.constructor.name, err.status, request.method, request.path));
       }
     }
   }
diff --git a/src/sharding/Shard.js b/src/sharding/Shard.js
index 1fb47975..555cef61 100644
--- a/src/sharding/Shard.js
+++ b/src/sharding/Shard.js
@@ -1,13 +1,16 @@
-const childProcess = require('child_process');
+'use strict';
+
 const EventEmitter = require('events');
 const path = require('path');
-const Util = require('../util/Util');
 const { Error } = require('../errors');
+const Util = require('../util/Util');
+let childProcess = null;
+let Worker = null;
 
 /**
  * A self-contained shard created by the {@link ShardingManager}. Each one has a {@link ChildProcess} that contains
- * an instance of the bot and its {@link Client}. When its child process exits for any reason, the shard will spawn a
- * new one to replace it as necessary.
+ * an instance of the bot and its {@link Client}. When its child process/worker exits for any reason, the shard will
+ * spawn a new one to replace it as necessary.
  * @extends EventEmitter
  */
 class Shard extends EventEmitter {
@@ -18,6 +21,9 @@ class Shard extends EventEmitter {
   constructor(manager, id) {
     super();
 
+    if (manager.mode === 'process') childProcess = require('child_process');
+    else if (manager.mode === 'worker') Worker = require('worker_threads').Worker;
+
     /**
      * Manager that created the shard
      * @type {ShardingManager}
@@ -25,30 +31,30 @@ class Shard extends EventEmitter {
     this.manager = manager;
 
     /**
-     * ID of the shard
+     * ID of the shard in the manager
      * @type {number}
      */
     this.id = id;
 
     /**
-     * Arguments for the shard's process
+     * Arguments for the shard's process (only when {@link ShardingManager#mode} is `process`)
      * @type {string[]}
      */
     this.args = manager.shardArgs || [];
 
     /**
-     * Arguments for the shard's process executable
+     * Arguments for the shard's process executable (only when {@link ShardingManager#mode} is `process`)
      * @type {?string[]}
      */
     this.execArgv = manager.execArgv;
 
     /**
-     * Environment variables for the shard's process
+     * Environment variables for the shard's process, or workerData for the shard's worker
      * @type {Object}
      */
     this.env = Object.assign({}, process.env, {
       SHARDING_MANAGER: true,
-      SHARD_ID: this.id,
+      SHARDS: this.id,
       SHARD_COUNT: this.manager.totalShards,
       DISCORD_TOKEN: this.manager.token,
     });
@@ -60,11 +66,17 @@ class Shard extends EventEmitter {
     this.ready = false;
 
     /**
-     * Process of the shard
+     * Process of the shard (if {@link ShardingManager#mode} is `process`)
      * @type {?ChildProcess}
      */
     this.process = null;
 
+    /**
+     * Worker of the shard (if {@link ShardingManager#mode} is `worker`)
+     * @type {?Worker}
+     */
+    this.worker = null;
+
     /**
      * Ongoing promises for calls to {@link Shard#eval}, mapped by the `script` they were called with
      * @type {Map<string, Promise>}
@@ -88,68 +100,118 @@ class Shard extends EventEmitter {
   }
 
   /**
-   * Forks a child process for the shard.
+   * Forks a child process or creates a worker thread for the shard.
    * <warn>You should not need to call this manually.</warn>
-   * @param {boolean} [waitForReady=true] Whether to wait until the {@link Client} has become ready before resolving
+   * @param {number} [spawnTimeout=30000] The amount in milliseconds to wait until the {@link Client} has become ready
+   * before resolving. (-1 or Infinity for no wait)
    * @returns {Promise<ChildProcess>}
    */
-  async spawn(waitForReady = true) {
+  async spawn(spawnTimeout = 30000) {
     if (this.process) throw new Error('SHARDING_PROCESS_EXISTS', this.id);
+    if (this.worker) throw new Error('SHARDING_WORKER_EXISTS', this.id);
 
-    this.process = childProcess.fork(path.resolve(this.manager.file), this.args, {
-      env: this.env, execArgv: this.execArgv,
-    })
-      .on('message', this._handleMessage.bind(this))
-      .on('exit', this._exitListener);
+    if (this.manager.mode === 'process') {
+      this.process = childProcess
+        .fork(path.resolve(this.manager.file), this.args, {
+          env: this.env,
+          execArgv: this.execArgv,
+        })
+        .on('message', this._handleMessage.bind(this))
+        .on('exit', this._exitListener);
+    } else if (this.manager.mode === 'worker') {
+      this.worker = new Worker(path.resolve(this.manager.file), { workerData: this.env })
+        .on('message', this._handleMessage.bind(this))
+        .on('exit', this._exitListener);
+    }
 
     /**
-     * Emitted upon the creation of the shard's child process.
+     * Emitted upon the creation of the shard's child process/worker.
      * @event Shard#spawn
-     * @param {ChildProcess} process Child process that was created
+     * @param {ChildProcess|Worker} process Child process/worker that was created
      */
-    this.emit('spawn', this.process);
+    this.emit('spawn', this.process || this.worker);
 
-    if (!waitForReady) return this.process;
+    if (spawnTimeout === -1 || spawnTimeout === Infinity) return this.process || this.worker;
     await new Promise((resolve, reject) => {
-      this.once('ready', resolve);
-      this.once('disconnect', () => reject(new Error('SHARDING_READY_DISCONNECTED', this.id)));
-      this.once('death', () => reject(new Error('SHARDING_READY_DIED', this.id)));
-      setTimeout(() => reject(new Error('SHARDING_READY_TIMEOUT', this.id)), 30000);
+      const cleanup = () => {
+        clearTimeout(spawnTimeoutTimer);
+        this.off('ready', onReady);
+        this.off('disconnect', onDisconnect);
+        this.off('death', onDeath);
+      };
+
+      const onReady = () => {
+        cleanup();
+        resolve();
+      };
+
+      const onDisconnect = () => {
+        cleanup();
+        reject(new Error('SHARDING_READY_DISCONNECTED', this.id));
+      };
+
+      const onDeath = () => {
+        cleanup();
+        reject(new Error('SHARDING_READY_DIED', this.id));
+      };
+
+      const onTimeout = () => {
+        cleanup();
+        reject(new Error('SHARDING_READY_TIMEOUT', this.id));
+      };
+
+      const spawnTimeoutTimer = setTimeout(onTimeout, spawnTimeout);
+      this.once('ready', onReady);
+      this.once('disconnect', onDisconnect);
+      this.once('death', onDeath);
     });
-    return this.process;
+    return this.process || this.worker;
   }
 
   /**
-   * Immediately kills the shard's process and does not restart it.
+   * Immediately kills the shard's process/worker and does not restart it.
    */
   kill() {
-    this.process.removeListener('exit', this._exitListener);
-    this.process.kill();
+    if (this.process) {
+      this.process.removeListener('exit', this._exitListener);
+      this.process.kill();
+    } else {
+      this.worker.removeListener('exit', this._exitListener);
+      this.worker.terminate();
+    }
+
     this._handleExit(false);
   }
 
   /**
-   * Kills and restarts the shard's process.
-   * @param {number} [delay=500] How long to wait between killing the process and restarting it (in milliseconds)
-   * @param {boolean} [waitForReady=true] Whether to wait until the {@link Client} has become ready before resolving
+   * Kills and restarts the shard's process/worker.
+   * @param {number} [delay=500] How long to wait between killing the process/worker and restarting it (in milliseconds)
+   * @param {number} [spawnTimeout=30000] The amount in milliseconds to wait until the {@link Client} has become ready
+   * before resolving. (-1 or Infinity for no wait)
    * @returns {Promise<ChildProcess>}
    */
-  async respawn(delay = 500, waitForReady = true) {
+  async respawn(delay = 500, spawnTimeout) {
     this.kill();
     if (delay > 0) await Util.delayFor(delay);
-    return this.spawn(waitForReady);
+    return this.spawn(spawnTimeout);
   }
 
   /**
-   * Sends a message to the shard's process.
+   * Sends a message to the shard's process/worker.
    * @param {*} message Message to send to the shard
    * @returns {Promise<Shard>}
    */
   send(message) {
     return new Promise((resolve, reject) => {
-      this.process.send(message, err => {
-        if (err) reject(err); else resolve(this);
-      });
+      if (this.process) {
+        this.process.send(message, err => {
+          if (err) reject(err);
+          else resolve(this);
+        });
+      } else {
+        this.worker.postMessage(message);
+        resolve(this);
+      }
     });
   }
 
@@ -166,16 +228,18 @@ class Shard extends EventEmitter {
     if (this._fetches.has(prop)) return this._fetches.get(prop);
 
     const promise = new Promise((resolve, reject) => {
+      const child = this.process || this.worker;
+
       const listener = message => {
         if (!message || message._fetchProp !== prop) return;
-        this.process.removeListener('message', listener);
+        child.removeListener('message', listener);
         this._fetches.delete(prop);
         resolve(message._result);
       };
-      this.process.on('message', listener);
+      child.on('message', listener);
 
       this.send({ _fetchProp: prop }).catch(err => {
-        this.process.removeListener('message', listener);
+        child.removeListener('message', listener);
         this._fetches.delete(prop);
         reject(err);
       });
@@ -194,17 +258,20 @@ class Shard extends EventEmitter {
     if (this._evals.has(script)) return this._evals.get(script);
 
     const promise = new Promise((resolve, reject) => {
+      const child = this.process || this.worker;
+
       const listener = message => {
         if (!message || message._eval !== script) return;
-        this.process.removeListener('message', listener);
+        child.removeListener('message', listener);
         this._evals.delete(script);
-        if (!message._error) resolve(message._result); else reject(Util.makeError(message._error));
+        if (!message._error) resolve(message._result);
+        else reject(Util.makeError(message._error));
       };
-      this.process.on('message', listener);
+      child.on('message', listener);
 
       const _eval = typeof script === 'function' ? `(${script})(this)` : script;
       this.send({ _eval }).catch(err => {
-        this.process.removeListener('message', listener);
+        child.removeListener('message', listener);
         this._evals.delete(script);
         reject(err);
       });
@@ -215,7 +282,7 @@ class Shard extends EventEmitter {
   }
 
   /**
-   * Handles an IPC message.
+   * Handles a message received from the child process/worker.
    * @param {*} message Message received
    * @private
    */
@@ -258,7 +325,7 @@ class Shard extends EventEmitter {
       if (message._sFetchProp) {
         this.manager.fetchClientValues(message._sFetchProp).then(
           results => this.send({ _sFetchProp: message._sFetchProp, _result: results }),
-          err => this.send({ _sFetchProp: message._sFetchProp, _error: Util.makePlainError(err) })
+          err => this.send({ _sFetchProp: message._sFetchProp, _error: Util.makePlainError(err) }),
         );
         return;
       }
@@ -267,15 +334,15 @@ class Shard extends EventEmitter {
       if (message._sEval) {
         this.manager.broadcastEval(message._sEval).then(
           results => this.send({ _sEval: message._sEval, _result: results }),
-          err => this.send({ _sEval: message._sEval, _error: Util.makePlainError(err) })
+          err => this.send({ _sEval: message._sEval, _error: Util.makePlainError(err) }),
         );
         return;
       }
 
       // Shard is requesting a respawn of all shards
       if (message._sRespawnAll) {
-        const { shardDelay, respawnDelay, waitForReady } = message._sRespawnAll;
-        this.manager.respawnAll(shardDelay, respawnDelay, waitForReady).catch(() => {
+        const { shardDelay, respawnDelay, spawnTimeout } = message._sRespawnAll;
+        this.manager.respawnAll(shardDelay, respawnDelay, spawnTimeout).catch(() => {
           // Do nothing
         });
         return;
@@ -283,7 +350,7 @@ class Shard extends EventEmitter {
     }
 
     /**
-     * Emitted upon recieving a message from the child process.
+     * Emitted upon receiving a message from the child process/worker.
      * @event Shard#message
      * @param {*} message Message that was received
      */
@@ -291,20 +358,21 @@ class Shard extends EventEmitter {
   }
 
   /**
-   * Handles the shard's process exiting.
+   * Handles the shard's process/worker exiting.
    * @param {boolean} [respawn=this.manager.respawn] Whether to spawn the shard again
    * @private
    */
   _handleExit(respawn = this.manager.respawn) {
     /**
-     * Emitted upon the shard's child process exiting.
+     * Emitted upon the shard's child process/worker exiting.
      * @event Shard#death
-     * @param {ChildProcess} process Child process that exited
+     * @param {ChildProcess|Worker} process Child process/worker that exited
      */
-    this.emit('death', this.process);
+    this.emit('death', this.process || this.worker);
 
     this.ready = false;
     this.process = null;
+    this.worker = null;
     this._evals.clear();
     this._fetches.clear();
 
diff --git a/src/sharding/ShardClientUtil.js b/src/sharding/ShardClientUtil.js
index 07c282eb..52d5e009 100644
--- a/src/sharding/ShardClientUtil.js
+++ b/src/sharding/ShardClientUtil.js
@@ -1,29 +1,69 @@
-const Util = require('../util/Util');
+'use strict';
+
 const { Events } = require('../util/Constants');
+const Util = require('../util/Util');
 
 /**
- * Helper class for sharded clients spawned as a child process, such as from a {@link ShardingManager}.
+ * Helper class for sharded clients spawned as a child process/worker, such as from a {@link ShardingManager}.
  * Utilises IPC to send and receive data to/from the master process and other shards.
  */
 class ShardClientUtil {
   /**
    * @param {Client} client Client of the current shard
+   * @param {ShardingManagerMode} mode Mode the shard was spawned with
    */
-  constructor(client) {
+  constructor(client, mode) {
+    /**
+     * Client for the shard
+     * @type {Client}
+     */
     this.client = client;
-    process.on('message', this._handleMessage.bind(this));
-    client.on('ready', () => { process.send({ _ready: true }); });
-    client.on('disconnect', () => { process.send({ _disconnect: true }); });
-    client.on('reconnecting', () => { process.send({ _reconnecting: true }); });
+
+    /**
+     * Mode the shard was spawned with
+     * @type {ShardingManagerMode}
+     */
+    this.mode = mode;
+
+    /**
+     * Message port for the master process (only when {@link ShardClientUtil#mode} is `worker`)
+     * @type {?MessagePort}
+     */
+    this.parentPort = null;
+
+    if (mode === 'process') {
+      process.on('message', this._handleMessage.bind(this));
+      client.on('ready', () => {
+        process.send({ _ready: true });
+      });
+      client.on('disconnect', () => {
+        process.send({ _disconnect: true });
+      });
+      client.on('reconnecting', () => {
+        process.send({ _reconnecting: true });
+      });
+    } else if (mode === 'worker') {
+      this.parentPort = require('worker_threads').parentPort;
+      this.parentPort.on('message', this._handleMessage.bind(this));
+      client.on('ready', () => {
+        this.parentPort.postMessage({ _ready: true });
+      });
+      client.on('disconnect', () => {
+        this.parentPort.postMessage({ _disconnect: true });
+      });
+      client.on('reconnecting', () => {
+        this.parentPort.postMessage({ _reconnecting: true });
+      });
+    }
   }
 
   /**
-   * ID of this shard
-   * @type {number}
+   * Array of shard IDs of this client
+   * @type {number[]}
    * @readonly
    */
-  get id() {
-    return this.client.options.shardId;
+  get ids() {
+    return this.client.options.shards;
   }
 
   /**
@@ -42,9 +82,15 @@ class ShardClientUtil {
    */
   send(message) {
     return new Promise((resolve, reject) => {
-      process.send(message, err => {
-        if (err) reject(err); else resolve();
-      });
+      if (this.mode === 'process') {
+        process.send(message, err => {
+          if (err) reject(err);
+          else resolve();
+        });
+      } else if (this.mode === 'worker') {
+        this.parentPort.postMessage(message);
+        resolve();
+      }
     });
   }
 
@@ -53,22 +99,25 @@ class ShardClientUtil {
    * @param {string} prop Name of the client property to get, using periods for nesting
    * @returns {Promise<Array<*>>}
    * @example
-   * client.shard.fetchClientValues('guilds.size')
+   * client.shard.fetchClientValues('guilds.cache.size')
    *   .then(results => console.log(`${results.reduce((prev, val) => prev + val, 0)} total guilds`))
    *   .catch(console.error);
    * @see {@link ShardingManager#fetchClientValues}
    */
   fetchClientValues(prop) {
     return new Promise((resolve, reject) => {
+      const parent = this.parentPort || process;
+
       const listener = message => {
         if (!message || message._sFetchProp !== prop) return;
-        process.removeListener('message', listener);
-        if (!message._error) resolve(message._result); else reject(Util.makeError(message._error));
+        parent.removeListener('message', listener);
+        if (!message._error) resolve(message._result);
+        else reject(Util.makeError(message._error));
       };
-      process.on('message', listener);
+      parent.on('message', listener);
 
       this.send({ _sFetchProp: prop }).catch(err => {
-        process.removeListener('message', listener);
+        parent.removeListener('message', listener);
         reject(err);
       });
     });
@@ -79,23 +128,26 @@ class ShardClientUtil {
    * @param {string|Function} script JavaScript to run on each shard
    * @returns {Promise<Array<*>>} Results of the script execution
    * @example
-   * client.shard.broadcastEval('this.guilds.size')
+   * client.shard.broadcastEval('this.guilds.cache.size')
    *   .then(results => console.log(`${results.reduce((prev, val) => prev + val, 0)} total guilds`))
    *   .catch(console.error);
    * @see {@link ShardingManager#broadcastEval}
    */
   broadcastEval(script) {
     return new Promise((resolve, reject) => {
+      const parent = this.parentPort || process;
       script = typeof script === 'function' ? `(${script})(this)` : script;
+
       const listener = message => {
         if (!message || message._sEval !== script) return;
-        process.removeListener('message', listener);
-        if (!message._error) resolve(message._result); else reject(Util.makeError(message._error));
+        parent.removeListener('message', listener);
+        if (!message._error) resolve(message._result);
+        else reject(Util.makeError(message._error));
       };
-      process.on('message', listener);
+      parent.on('message', listener);
 
       this.send({ _sEval: script }).catch(err => {
-        process.removeListener('message', listener);
+        parent.removeListener('message', listener);
         reject(err);
       });
     });
@@ -104,14 +156,15 @@ class ShardClientUtil {
   /**
    * Requests a respawn of all shards.
    * @param {number} [shardDelay=5000] How long to wait between shards (in milliseconds)
-   * @param {number} [respawnDelay=500] How long to wait between killing a shard's process and restarting it
+   * @param {number} [respawnDelay=500] How long to wait between killing a shard's process/worker and restarting it
    * (in milliseconds)
-   * @param {boolean} [waitForReady=true] Whether to wait for a shard to become ready before continuing to another
+   * @param {number} [spawnTimeout=30000] The amount in milliseconds to wait for a shard to become ready before
+   * continuing to another. (-1 or Infinity for no wait)
    * @returns {Promise<void>} Resolves upon the message being sent
    * @see {@link ShardingManager#respawnAll}
    */
-  respawnAll(shardDelay = 5000, respawnDelay = 500, waitForReady = true) {
-    return this.send({ _sRespawnAll: { shardDelay, respawnDelay, waitForReady } });
+  respawnAll(shardDelay = 5000, respawnDelay = 500, spawnTimeout = 30000) {
+    return this.send({ _sRespawnAll: { shardDelay, respawnDelay, spawnTimeout } });
   }
 
   /**
@@ -144,6 +197,11 @@ class ShardClientUtil {
   _respond(type, message) {
     this.send(message).catch(err => {
       err.message = `Error when sending ${type} response to master process: ${err.message}`;
+      /**
+       * Emitted when the client encounters an error.
+       * @event Client#error
+       * @param {Error} error The error encountered
+       */
       this.client.emit(Events.ERROR, err);
     });
   }
@@ -151,14 +209,17 @@ class ShardClientUtil {
   /**
    * Creates/gets the singleton of this class.
    * @param {Client} client The client to use
+   * @param {ShardingManagerMode} mode Mode the shard was spawned with
    * @returns {ShardClientUtil}
    */
-  static singleton(client) {
+  static singleton(client, mode) {
     if (!this._singleton) {
-      this._singleton = new this(client);
+      this._singleton = new this(client, mode);
     } else {
-      client.emit(Events.WARN,
-        'Multiple clients created in child process; only the first will handle sharding helpers.');
+      client.emit(
+        Events.WARN,
+        'Multiple clients created in child process/worker; only the first will handle sharding helpers.',
+      );
     }
     return this._singleton;
   }
diff --git a/src/sharding/ShardingManager.js b/src/sharding/ShardingManager.js
index bbec15b6..c931d35b 100644
--- a/src/sharding/ShardingManager.js
+++ b/src/sharding/ShardingManager.js
@@ -1,38 +1,57 @@
-const path = require('path');
-const fs = require('fs');
+'use strict';
+
 const EventEmitter = require('events');
+const fs = require('fs');
+const path = require('path');
 const Shard = require('./Shard');
+const { Error, TypeError, RangeError } = require('../errors');
 const Collection = require('../util/Collection');
 const Util = require('../util/Util');
-const { Error, TypeError, RangeError } = require('../errors');
 
 /**
  * This is a utility class that makes multi-process sharding of a bot an easy and painless experience.
- * It works by spawning a self-contained {@link ChildProcess} for each individual shard, each containing its own
- * instance of your bot's {@link Client}. They all have a line of communication with the master process, and there are
- * several useful methods that utilise it in order to simplify tasks that are normally difficult with sharding. It can
- * spawn a specific number of shards or the amount that Discord suggests for the bot, and takes a path to your main bot
- * script to launch for each one.
+ * It works by spawning a self-contained {@link ChildProcess} or {@link Worker} for each individual shard, each
+ * containing its own instance of your bot's {@link Client}. They all have a line of communication with the master
+ * process, and there are several useful methods that utilise it in order to simplify tasks that are normally difficult
+ * with sharding. It can spawn a specific number of shards or the amount that Discord suggests for the bot, and takes a
+ * path to your main bot script to launch for each one.
  * @extends {EventEmitter}
  */
 class ShardingManager extends EventEmitter {
+  /**
+   * The mode to spawn shards with for a {@link ShardingManager}: either "process" to use child processes, or
+   * "worker" to use workers. The "worker" mode relies on the experimental
+   * [Worker threads](https://nodejs.org/api/worker_threads.html) functionality that is present in Node v10.5.0 or
+   * newer. Node must be started with the `--experimental-worker` flag to expose it.
+   * @typedef {Object} ShardingManagerMode
+   */
+
   /**
    * @param {string} file Path to your shard script file
    * @param {Object} [options] Options for the sharding manager
-   * @param {number|string} [options.totalShards='auto'] Number of shards to spawn, or "auto"
+   * @param {string|number} [options.totalShards='auto'] Number of total shards of all shard managers or "auto"
+   * @param {string|number[]} [options.shardList='auto'] List of shards to spawn or "auto"
+   * @param {ShardingManagerMode} [options.mode='process'] Which mode to use for shards
    * @param {boolean} [options.respawn=true] Whether shards should automatically respawn upon exiting
    * @param {string[]} [options.shardArgs=[]] Arguments to pass to the shard script when spawning
+   * (only available when using the `process` mode)
    * @param {string[]} [options.execArgv=[]] Arguments to pass to the shard script executable when spawning
+   * (only available when using the `process` mode)
    * @param {string} [options.token] Token to use for automatic shard count and passing to shards
    */
   constructor(file, options = {}) {
     super();
-    options = Util.mergeDefault({
-      totalShards: 'auto',
-      respawn: true,
-      shardArgs: [],
-      token: process.env.DISCORD_TOKEN,
-    }, options);
+    options = Util.mergeDefault(
+      {
+        totalShards: 'auto',
+        mode: 'process',
+        respawn: true,
+        shardArgs: [],
+        execArgv: [],
+        token: process.env.DISCORD_TOKEN,
+      },
+      options,
+    );
 
     /**
      * Path to the shard script file
@@ -45,20 +64,49 @@ class ShardingManager extends EventEmitter {
     if (!stats.isFile()) throw new Error('CLIENT_INVALID_OPTION', 'File', 'a file');
 
     /**
-     * Amount of shards that this manager is going to spawn
-     * @type {number|string}
+     * List of shards this sharding manager spawns
+     * @type {string|number[]}
      */
-    this.totalShards = options.totalShards;
+    this.shardList = options.shardList || 'auto';
+    if (this.shardList !== 'auto') {
+      if (!Array.isArray(this.shardList)) {
+        throw new TypeError('CLIENT_INVALID_OPTION', 'shardList', 'an array.');
+      }
+      this.shardList = [...new Set(this.shardList)];
+      if (this.shardList.length < 1) throw new RangeError('CLIENT_INVALID_OPTION', 'shardList', 'at least 1 ID.');
+      if (
+        this.shardList.some(
+          shardID => typeof shardID !== 'number' || isNaN(shardID) || !Number.isInteger(shardID) || shardID < 0,
+        )
+      ) {
+        throw new TypeError('CLIENT_INVALID_OPTION', 'shardList', 'an array of positive integers.');
+      }
+    }
+
+    /**
+     * Amount of shards that all sharding managers spawn in total
+     * @type {number}
+     */
+    this.totalShards = options.totalShards || 'auto';
     if (this.totalShards !== 'auto') {
       if (typeof this.totalShards !== 'number' || isNaN(this.totalShards)) {
         throw new TypeError('CLIENT_INVALID_OPTION', 'Amount of shards', 'a number.');
       }
       if (this.totalShards < 1) throw new RangeError('CLIENT_INVALID_OPTION', 'Amount of shards', 'at least 1.');
-      if (this.totalShards !== Math.floor(this.totalShards)) {
+      if (!Number.isInteger(this.totalShards)) {
         throw new RangeError('CLIENT_INVALID_OPTION', 'Amount of shards', 'an integer.');
       }
     }
 
+    /**
+     * Mode for shards to spawn with
+     * @type {ShardingManagerMode}
+     */
+    this.mode = options.mode;
+    if (this.mode !== 'process' && this.mode !== 'worker') {
+      throw new RangeError('CLIENT_INVALID_OPTION', 'Sharding mode', '"process" or "worker"');
+    }
+
     /**
      * Whether shards should automatically respawn upon exiting
      * @type {boolean}
@@ -66,13 +114,13 @@ class ShardingManager extends EventEmitter {
     this.respawn = options.respawn;
 
     /**
-     * An array of arguments to pass to shards
+     * An array of arguments to pass to shards (only when {@link ShardingManager#mode} is `process`)
      * @type {string[]}
      */
     this.shardArgs = options.shardArgs;
 
     /**
-     * An array of arguments to pass to the executable
+     * An array of arguments to pass to the executable (only when {@link ShardingManager#mode} is `process`)
      * @type {string[]}
      */
     this.execArgv = options.execArgv;
@@ -88,6 +136,10 @@ class ShardingManager extends EventEmitter {
      * @type {Collection<number, Shard>}
      */
     this.shards = new Collection();
+
+    process.env.SHARDING_MANAGER = true;
+    process.env.SHARDING_MANAGER_MODE = this.mode;
+    process.env.DISCORD_TOKEN = this.token;
   }
 
   /**
@@ -110,12 +162,13 @@ class ShardingManager extends EventEmitter {
 
   /**
    * Spawns multiple shards.
-   * @param {number} [amount=this.totalShards] Number of shards to spawn
+   * @param {number|string} [amount=this.totalShards] Number of shards to spawn
    * @param {number} [delay=5500] How long to wait in between spawning each shard (in milliseconds)
-   * @param {boolean} [waitForReady=true] Whether to wait for a shard to become ready before continuing to another
+   * @param {number} [spawnTimeout=30000] The amount in milliseconds to wait until the {@link Client} has become ready
+   * before resolving. (-1 or Infinity for no wait)
    * @returns {Promise<Collection<number, Shard>>}
    */
-  async spawn(amount = this.totalShards, delay = 5500, waitForReady = true) {
+  async spawn(amount = this.totalShards, delay = 5500, spawnTimeout) {
     // Obtain/verify the number of shards to spawn
     if (amount === 'auto') {
       amount = await Util.fetchRecommendedShards(this.token);
@@ -124,21 +177,34 @@ class ShardingManager extends EventEmitter {
         throw new TypeError('CLIENT_INVALID_OPTION', 'Amount of shards', 'a number.');
       }
       if (amount < 1) throw new RangeError('CLIENT_INVALID_OPTION', 'Amount of shards', 'at least 1.');
-      if (amount !== Math.floor(amount)) {
+      if (!Number.isInteger(amount)) {
         throw new TypeError('CLIENT_INVALID_OPTION', 'Amount of shards', 'an integer.');
       }
     }
 
     // Make sure this many shards haven't already been spawned
     if (this.shards.size >= amount) throw new Error('SHARDING_ALREADY_SPAWNED', this.shards.size);
-    this.totalShards = amount;
+    if (this.shardList === 'auto' || this.totalShards === 'auto' || this.totalShards !== amount) {
+      this.shardList = [...Array(amount).keys()];
+    }
+    if (this.totalShards === 'auto' || this.totalShards !== amount) {
+      this.totalShards = amount;
+    }
+
+    if (this.shardList.some(shardID => shardID >= amount)) {
+      throw new RangeError(
+        'CLIENT_INVALID_OPTION',
+        'Amount of shards',
+        'bigger than the highest shardID in the shardList option.',
+      );
+    }
 
     // Spawn the shards
-    for (let s = 1; s <= amount; s++) {
+    for (const shardID of this.shardList) {
       const promises = [];
-      const shard = this.createShard();
-      promises.push(shard.spawn(waitForReady));
-      if (delay > 0 && s !== amount) promises.push(Util.delayFor(delay));
+      const shard = this.createShard(shardID);
+      promises.push(shard.spawn(spawnTimeout));
+      if (delay > 0 && this.shards.size !== this.shardList.length) promises.push(Util.delayFor(delay));
       await Promise.all(promises); // eslint-disable-line no-await-in-loop
     }
 
@@ -172,13 +238,13 @@ class ShardingManager extends EventEmitter {
    * @param {string} prop Name of the client property to get, using periods for nesting
    * @returns {Promise<Array<*>>}
    * @example
-   * manager.fetchClientValues('guilds.size')
+   * manager.fetchClientValues('guilds.cache.size')
    *   .then(results => console.log(`${results.reduce((prev, val) => prev + val, 0)} total guilds`))
    *   .catch(console.error);
    */
   fetchClientValues(prop) {
     if (this.shards.size === 0) return Promise.reject(new Error('SHARDING_NO_SHARDS'));
-    if (this.shards.size !== this.totalShards) return Promise.reject(new Error('SHARDING_IN_PROCESS'));
+    if (this.shards.size !== this.shardList.length) return Promise.reject(new Error('SHARDING_IN_PROCESS'));
     const promises = [];
     for (const shard of this.shards.values()) promises.push(shard.fetchClientValue(prop));
     return Promise.all(promises);
@@ -189,13 +255,14 @@ class ShardingManager extends EventEmitter {
    * @param {number} [shardDelay=5000] How long to wait between shards (in milliseconds)
    * @param {number} [respawnDelay=500] How long to wait between killing a shard's process and restarting it
    * (in milliseconds)
-   * @param {boolean} [waitForReady=true] Whether to wait for a shard to become ready before continuing to another
+   * @param {number} [spawnTimeout=30000] The amount in milliseconds to wait for a shard to become ready before
+   * continuing to another. (-1 or Infinity for no wait)
    * @returns {Promise<Collection<string, Shard>>}
    */
-  async respawnAll(shardDelay = 5000, respawnDelay = 500, waitForReady = true) {
+  async respawnAll(shardDelay = 5000, respawnDelay = 500, spawnTimeout) {
     let s = 0;
     for (const shard of this.shards.values()) {
-      const promises = [shard.respawn(respawnDelay, waitForReady)];
+      const promises = [shard.respawn(respawnDelay, spawnTimeout)];
       if (++s < this.shards.size && shardDelay > 0) promises.push(Util.delayFor(shardDelay));
       await Promise.all(promises); // eslint-disable-line no-await-in-loop
     }
diff --git a/src/stores/ChannelStore.js b/src/stores/ChannelStore.js
deleted file mode 100644
index 6e2e4081..00000000
--- a/src/stores/ChannelStore.js
+++ /dev/null
@@ -1,101 +0,0 @@
-const DataStore = require('./DataStore');
-const Channel = require('../structures/Channel');
-const { Events } = require('../util/Constants');
-
-const kLru = Symbol('LRU');
-const lruable = ['group', 'dm'];
-
-/**
- * Stores channels.
- * @extends {DataStore}
- */
-class ChannelStore extends DataStore {
-  constructor(client, iterableOrOptions = {}, options) {
-    if (!options && typeof iterableOrOptions[Symbol.iterator] !== 'function') {
-      options = iterableOrOptions;
-      iterableOrOptions = undefined;
-    }
-    super(client, iterableOrOptions, Channel);
-
-    if (options.lru) {
-      const lru = this[kLru] = [];
-      lru.add = item => {
-        lru.remove(item);
-        lru.unshift(item);
-        while (lru.length > options.lru) this.remove(lru[lru.length - 1]);
-      };
-      lru.remove = item => {
-        const index = lru.indexOf(item);
-        if (index > -1) lru.splice(index, 1);
-      };
-    }
-  }
-
-  get(key, peek = false) {
-    const item = super.get(key);
-    if (!item || !lruable.includes(item.type)) return item;
-    if (!peek && this[kLru]) this[kLru].add(key);
-    return item;
-  }
-
-  set(key, val) {
-    if (this[kLru] && lruable.includes(val.type)) this[kLru].add(key);
-    return super.set(key, val);
-  }
-
-  delete(key) {
-    const item = this.get(key, true);
-    if (!item) return false;
-    if (this[kLru] && lruable.includes(item.type)) this[kLru].remove(key);
-    return super.delete(key);
-  }
-
-  add(data, guild, cache = true) {
-    const existing = this.get(data.id);
-    if (existing) return existing;
-
-    const channel = Channel.create(this.client, data, guild);
-
-    if (!channel) {
-      this.client.emit(Events.DEBUG, `Failed to find guild for channel ${data.id} ${data.type}`);
-      return null;
-    }
-
-    if (cache) this.set(channel.id, channel);
-
-    return channel;
-  }
-
-  remove(id) {
-    const channel = this.get(id);
-    if (channel.guild) channel.guild.channels.remove(id);
-    super.remove(id);
-  }
-
-  /**
-   * Data that can be resolved to give a Channel object. This can be:
-   * * A Channel object
-   * * A Snowflake
-   * @typedef {Channel|Snowflake} ChannelResolvable
-   */
-
-  /**
-   * Resolves a ChannelResolvable to a Channel object.
-   * @method resolve
-   * @memberof ChannelStore
-   * @instance
-   * @param {ChannelResolvable} channel The channel resolvable to resolve
-   * @returns {?Channel}
-   */
-
-  /**
-   * Resolves a ChannelResolvable to a channel ID string.
-   * @method resolveID
-   * @memberof ChannelStore
-   * @instance
-   * @param {ChannelResolvable} channel The channel resolvable to resolve
-   * @returns {?Snowflake}
-   */
-}
-
-module.exports = ChannelStore;
diff --git a/src/stores/DataStore.js b/src/stores/DataStore.js
deleted file mode 100644
index 3708893c..00000000
--- a/src/stores/DataStore.js
+++ /dev/null
@@ -1,55 +0,0 @@
-const Collection = require('../util/Collection');
-let Structures;
-
-/**
- * Manages the creation, retrieval and deletion of a specific data model.
- * @extends {Collection}
- */
-class DataStore extends Collection {
-  constructor(client, iterable, holds) {
-    super();
-    if (!Structures) Structures = require('../util/Structures');
-    Object.defineProperty(this, 'client', { value: client });
-    Object.defineProperty(this, 'holds', { value: Structures.get(holds.name) || holds });
-    if (iterable) for (const item of iterable) this.add(item);
-  }
-
-  add(data, cache = true, { id, extras = [] } = {}) {
-    const existing = this.get(id || data.id);
-    if (existing) return existing;
-
-    const entry = this.holds ? new this.holds(this.client, data, ...extras) : data;
-    if (cache) this.set(id || entry.id, entry);
-    return entry;
-  }
-
-  remove(key) { return this.delete(key); }
-
-  /**
-   * Resolves a data entry to a data Object.
-   * @param {string|Object} idOrInstance The id or instance of something in this DataStore
-   * @returns {?Object} An instance from this DataStore
-   */
-  resolve(idOrInstance) {
-    if (idOrInstance instanceof this.holds) return idOrInstance;
-    if (typeof idOrInstance === 'string') return this.get(idOrInstance) || null;
-    return null;
-  }
-
-  /**
-   * Resolves a data entry to a instance ID.
-   * @param {string|Instance} idOrInstance The id or instance of something in this DataStore
-   * @returns {?Snowflake}
-   */
-  resolveID(idOrInstance) {
-    if (idOrInstance instanceof this.holds) return idOrInstance.id;
-    if (typeof idOrInstance === 'string') return idOrInstance;
-    return null;
-  }
-
-  static get [Symbol.species]() {
-    return Collection;
-  }
-}
-
-module.exports = DataStore;
diff --git a/src/stores/GuildStore.js b/src/stores/GuildStore.js
deleted file mode 100644
index 0cf9a115..00000000
--- a/src/stores/GuildStore.js
+++ /dev/null
@@ -1,79 +0,0 @@
-const DataStore = require('./DataStore');
-const DataResolver = require('../util/DataResolver');
-const { Events } = require('../util/Constants');
-const Guild = require('../structures/Guild');
-
-/**
- * Stores guilds.
- * @extends {DataStore}
- */
-class GuildStore extends DataStore {
-  constructor(client, iterable) {
-    super(client, iterable, Guild);
-  }
-
-  /**
-   * Data that resolves to give a Guild object. This can be:
-   * * A Guild object
-   * * A Snowflake
-   * @typedef {Guild|Snowflake} GuildResolvable
-   */
-
-  /**
-   * Resolves a GuildResolvable to a Guild object.
-   * @method resolve
-   * @memberof GuildStore
-   * @instance
-   * @param {GuildResolvable} guild The guild resolvable to identify
-   * @returns {?Guild}
-   */
-
-  /**
-   * Resolves a GuildResolvable to a Guild ID string.
-   * @method resolveID
-   * @memberof GuildStore
-   * @instance
-   * @param {GuildResolvable} guild The guild resolvable to identify
-   * @returns {?Snowflake}
-   */
-
-  /**
-   * Creates a guild.
-   * <warn>This is only available to bots in fewer than 10 guilds.</warn>
-   * @param {string} name The name of the guild
-   * @param {Object} [options] Options for the creating
-   * @param {string} [options.region] The region for the server, defaults to the closest one available
-   * @param {BufferResolvable|Base64Resolvable} [options.icon=null] The icon for the guild
-   * @returns {Promise<Guild>} The guild that was created
-   */
-  create(name, { region, icon = null } = {}) {
-    if (!icon || (typeof icon === 'string' && icon.startsWith('data:'))) {
-      return new Promise((resolve, reject) =>
-        this.client.api.guilds.post({ data: { name, region, icon } })
-          .then(data => {
-            if (this.client.guilds.has(data.id)) return resolve(this.client.guilds.get(data.id));
-
-            const handleGuild = guild => {
-              if (guild.id === data.id) {
-                this.client.removeListener(Events.GUILD_CREATE, handleGuild);
-                this.client.clearTimeout(timeout);
-                resolve(guild);
-              }
-            };
-            this.client.on(Events.GUILD_CREATE, handleGuild);
-
-            const timeout = this.client.setTimeout(() => {
-              this.client.removeListener(Events.GUILD_CREATE, handleGuild);
-              resolve(this.client.guilds.add(data));
-            }, 10000);
-            return undefined;
-          }, reject)
-      );
-    }
-
-    return DataResolver.resolveImage(icon)
-      .then(data => this.create(name, { region, icon: data || null }));
-  }
-}
-
-module.exports = GuildStore;
diff --git a/src/stores/ReactionStore.js b/src/stores/ReactionStore.js
deleted file mode 100644
index 38c467b7..00000000
--- a/src/stores/ReactionStore.js
+++ /dev/null
@@ -1,53 +0,0 @@
-const DataStore = require('./DataStore');
-const MessageReaction = require('../structures/MessageReaction');
-
-/**
- * Stores reactions.
- * @extends {DataStore}
- */
-class ReactionStore extends DataStore {
-  constructor(message, iterable) {
-    super(message.client, iterable, MessageReaction);
-    this.message = message;
-  }
-
-  add(data, cache) {
-    return super.add(data, cache, { id: data.emoji.id || data.emoji.name, extras: [this.message] });
-  }
-
-  /**
-   * Data that can be resolved to a MessageReaction object. This can be:
-   * * A MessageReaction
-   * * A Snowflake
-   * @typedef {MessageReaction|Snowflake} MessageReactionResolvable
-   */
-
-  /**
-    * Resolves a MessageReactionResolvable to a MessageReaction object.
-    * @method resolve
-    * @memberof ReactionStore
-    * @instance
-    * @param {MessageReactionResolvable} reaction The MessageReaction to resolve
-    * @returns {?MessageReaction}
-    */
-
-  /**
-    * Resolves a MessageReactionResolvable to a MessageReaction ID string.
-    * @method resolveID
-    * @memberof ReactionStore
-    * @instance
-    * @param {MessageReactionResolvable} role The role resolvable to resolve
-    * @returns {?Snowflake}
-    */
-
-  /**
-   * Removes all reactions from a message.
-   * @returns {Promise<Message>}
-   */
-  removeAll() {
-    return this.client.api.channels(this.message.channel.id).messages(this.message.id).reactions.delete()
-      .then(() => this.message);
-  }
-}
-
-module.exports = ReactionStore;
diff --git a/src/stores/RoleStore.js b/src/stores/RoleStore.js
deleted file mode 100644
index 3c3a5b35..00000000
--- a/src/stores/RoleStore.js
+++ /dev/null
@@ -1,93 +0,0 @@
-const DataStore = require('./DataStore');
-const Role = require('../structures/Role');
-const { resolveColor } = require('../util/Util');
-const Permissions = require('../util/Permissions');
-
-/**
- * Stores roles.
- * @extends {DataStore}
- */
-class RoleStore extends DataStore {
-  constructor(guild, iterable) {
-    super(guild.client, iterable, Role);
-    this.guild = guild;
-  }
-
-  add(data, cache) {
-    return super.add(data, cache, { extras: [this.guild] });
-  }
-
-  /**
-   * Data that can be resolved to a Role object. This can be:
-   * * A Role
-   * * A Snowflake
-   * @typedef {Role|Snowflake} RoleResolvable
-   */
-
-  /**
-   * Resolves a RoleResolvable to a Role object.
-   * @method resolve
-   * @memberof RoleStore
-   * @instance
-   * @param {RoleResolvable} role The role resolvable to resolve
-   * @returns {?Role}
-   */
-
-  /**
-   * Resolves a RoleResolvable to a role ID string.
-   * @method resolveID
-   * @memberof RoleStore
-   * @instance
-   * @param {RoleResolvable} role The role resolvable to resolve
-   * @returns {?Snowflake}
-   */
-
-  /**
-   * Creates a new role in the guild with given information.
-   * <warn>The position will silently reset to 1 if an invalid one is provided, or none.</warn>
-   * @param {Object} [options] Options
-   * @param {RoleData} [options.data] The data to update the role with
-   * @param {string} [options.reason] Reason for creating this role
-   * @returns {Promise<Role>}
-   * @example
-   * // Create a new role
-   * guild.roles.create()
-   *   .then(console.log)
-   *   .catch(console.error);
-   * @example
-   * // Create a new role with data and a reason
-   * guild.roles.create({
-   *   data: {
-   *     name: 'Super Cool People',
-   *     color: 'BLUE',
-   *   },
-   *   reason: 'we needed a role for Super Cool People',
-   * })
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
-  create({ data = {}, reason } = {}) {
-    if (data.color) data.color = resolveColor(data.color);
-    if (data.permissions) data.permissions = Permissions.resolve(data.permissions);
-
-    return this.guild.client.api.guilds(this.guild.id).roles.post({ data, reason }).then(r => {
-      const { role } = this.client.actions.GuildRoleCreate.handle({
-        guild_id: this.guild.id,
-        role: r,
-      });
-      if (data.position) return role.setPosition(data.position, reason);
-      return role;
-    });
-  }
-
-  /**
-   * The role with the highest position in the store
-   * @type {Role}
-   * @readonly
-   */
-  get highest() {
-    return this.reduce((prev, role) => role.comparePositionTo(prev) > 0 ? role : prev, this.first());
-  }
-}
-
-module.exports = RoleStore;
diff --git a/src/stores/VoiceStateStore.js b/src/stores/VoiceStateStore.js
deleted file mode 100644
index 2de49249..00000000
--- a/src/stores/VoiceStateStore.js
+++ /dev/null
@@ -1,20 +0,0 @@
-const DataStore = require('./DataStore');
-const VoiceState = require('../structures/VoiceState');
-
-class VoiceStateStore extends DataStore {
-  constructor(guild, iterable) {
-    super(guild.client, iterable, VoiceState);
-    this.guild = guild;
-  }
-
-  add(data, cache = true) {
-    const existing = this.get(data.user_id);
-    if (existing) return existing._patch(data);
-
-    const entry = new VoiceState(this.guild, data);
-    if (cache) this.set(data.user_id, entry);
-    return entry;
-  }
-}
-
-module.exports = VoiceStateStore;
diff --git a/src/structures/APIMessage.js b/src/structures/APIMessage.js
index b0a22365..f2ca68b2 100644
--- a/src/structures/APIMessage.js
+++ b/src/structures/APIMessage.js
@@ -1,9 +1,12 @@
-const DataResolver = require('../util/DataResolver');
-const MessageEmbed = require('./MessageEmbed');
+'use strict';
+
 const MessageAttachment = require('./MessageAttachment');
-const { browser } = require('../util/Constants');
-const Util = require('../util/Util');
+const MessageEmbed = require('./MessageEmbed');
 const { RangeError } = require('../errors');
+const { browser } = require('../util/Constants');
+const DataResolver = require('../util/DataResolver');
+const MessageFlags = require('../util/MessageFlags');
+const Util = require('../util/Util');
 
 /**
  * Represents a message to be sent to the API.
@@ -62,14 +65,45 @@ class APIMessage {
   }
 
   /**
-   * Makes the content of this message.
-   * @returns {string|string[]}
+   * Whether or not the target is a message
+   * @type {boolean}
+   * @readonly
    */
-  makeContent() { // eslint-disable-line complexity
+  get isMessage() {
+    const Message = require('./Message');
+    return this.target instanceof Message;
+  }
+
+  /**
+   * Makes the content of this message.
+   * @returns {?(string|string[])}
+   */
+  makeContent() {
     const GuildMember = require('./GuildMember');
 
-    // eslint-disable-next-line eqeqeq
-    let content = Util.resolveString(this.options.content == null ? '' : this.options.content);
+    let content;
+    if (this.options.content === null) {
+      content = '';
+    } else if (typeof this.options.content !== 'undefined') {
+      content = Util.resolveString(this.options.content);
+    }
+
+    const disableMentions =
+      typeof this.options.disableMentions === 'undefined'
+        ? this.target.client.options.disableMentions
+        : this.options.disableMentions;
+    if (disableMentions === 'all') {
+      content = Util.removeMentions(content || '');
+    } else if (disableMentions === 'everyone') {
+      content = (content || '').replace(/@([^<>@ ]*)/gmsu, (match, target) => {
+        if (target.match(/^[&!]?\d+$/)) {
+          return `@${target}`;
+        } else {
+          return `@\u200b${target}`;
+        }
+      });
+    }
+
     const isSplit = typeof this.options.split !== 'undefined' && this.options.split !== false;
     const isCode = typeof this.options.code !== 'undefined' && this.options.code !== false;
     const splitOptions = isSplit ? { ...this.options.split } : undefined;
@@ -86,24 +120,17 @@ class APIMessage {
     if (content || replyPrefix) {
       if (isCode) {
         const codeName = typeof this.options.code === 'string' ? this.options.code : '';
-        content = `${replyPrefix}\`\`\`${codeName}\n${Util.escapeMarkdown(content, true)}\n\`\`\``;
+        content = `${replyPrefix}\`\`\`${codeName}\n${Util.cleanCodeBlockContent(content || '')}\n\`\`\``;
         if (isSplit) {
           splitOptions.prepend = `${splitOptions.prepend || ''}\`\`\`${codeName}\n`;
           splitOptions.append = `\n\`\`\`${splitOptions.append || ''}`;
         }
       } else if (replyPrefix) {
-        content = `${replyPrefix}${content}`;
-      }
-
-      const disableEveryone = typeof this.options.disableEveryone === 'undefined' ?
-        this.target.client.options.disableEveryone :
-        this.options.disableEveryone;
-      if (disableEveryone) {
-        content = content.replace(/@(everyone|here)/g, '@\u200b$1');
+        content = `${replyPrefix}${content || ''}`;
       }
 
       if (isSplit) {
-        content = Util.splitMessage(content, splitOptions);
+        content = Util.splitMessage(content || '', splitOptions);
       }
     }
 
@@ -119,6 +146,7 @@ class APIMessage {
 
     const content = this.makeContent();
     const tts = Boolean(this.options.tts);
+
     let nonce;
     if (typeof this.options.nonce !== 'undefined') {
       nonce = parseInt(this.options.nonce);
@@ -133,7 +161,7 @@ class APIMessage {
     } else if (this.options.embed) {
       embedLikes.push(this.options.embed);
     }
-    const embeds = embedLikes.map(e => new MessageEmbed(e)._apiTransform());
+    const embeds = embedLikes.map(e => new MessageEmbed(e).toJSON());
 
     let username;
     let avatarURL;
@@ -142,6 +170,12 @@ class APIMessage {
       if (this.options.avatarURL) avatarURL = this.options.avatarURL;
     }
 
+    let flags;
+    if (this.isMessage) {
+      // eslint-disable-next-line eqeqeq
+      flags = this.options.flags != null ? new MessageFlags(this.options.flags).bitfield : this.target.flags.bitfield;
+    }
+
     this.data = {
       content,
       tts,
@@ -150,6 +184,7 @@ class APIMessage {
       embeds,
       username,
       avatar_url: avatarURL,
+      flags,
     };
     return this;
   }
@@ -191,7 +226,7 @@ class APIMessage {
   split() {
     if (!this.data) this.resolveData();
 
-    if (!(this.data.content instanceof Array)) return [this];
+    if (!Array.isArray(this.data.content)) return [this];
 
     const apiMessages = [];
 
@@ -236,7 +271,8 @@ class APIMessage {
       return 'file.jpg';
     };
 
-    const ownAttachment = typeof fileLike === 'string' ||
+    const ownAttachment =
+      typeof fileLike === 'string' ||
       fileLike instanceof (browser ? ArrayBuffer : Buffer) ||
       typeof fileLike.pipe === 'function';
     if (ownAttachment) {
@@ -273,16 +309,16 @@ class APIMessage {
   /**
    * Transforms the user-level arguments into a final options object. Passing a transformed options object alone into
    * this method will keep it the same, allowing for the reuse of the final options object.
-   * @param {StringResolvable} [content=''] Content to send
+   * @param {StringResolvable} [content] Content to send
    * @param {MessageOptions|WebhookMessageOptions|MessageAdditions} [options={}] Options to use
    * @param {MessageOptions|WebhookMessageOptions} [extra={}] Extra options to add onto transformed options
    * @param {boolean} [isWebhook=false] Whether or not to use WebhookMessageOptions as the result
    * @returns {MessageOptions|WebhookMessageOptions}
    */
   static transformOptions(content, options, extra = {}, isWebhook = false) {
-    if (!options && typeof content === 'object' && !(content instanceof Array)) {
+    if (!options && typeof content === 'object' && !Array.isArray(content)) {
       options = content;
-      content = '';
+      content = undefined;
     }
 
     if (!options) {
@@ -293,10 +329,10 @@ class APIMessage {
       return { content, files: [options], ...extra };
     }
 
-    if (options instanceof Array) {
+    if (Array.isArray(options)) {
       const [embeds, files] = this.partitionMessageAdditions(options);
       return isWebhook ? { content, embeds, files, ...extra } : { content, embed: embeds[0], files, ...extra };
-    } else if (content instanceof Array) {
+    } else if (Array.isArray(content)) {
       const [embeds, files] = this.partitionMessageAdditions(content);
       if (embeds.length || files.length) {
         return isWebhook ? { embeds, files, ...extra } : { embed: embeds[0], files, ...extra };
@@ -309,7 +345,7 @@ class APIMessage {
   /**
    * Creates an `APIMessage` from user-level arguments.
    * @param {MessageTarget} target Target to send to
-   * @param {StringResolvable} [content=''] Content to send
+   * @param {StringResolvable} [content] Content to send
    * @param {MessageOptions|WebhookMessageOptions|MessageAdditions} [options={}] Options to use
    * @param {MessageOptions|WebhookMessageOptions} [extra={}] - Extra options to add onto transformed options
    * @returns {MessageOptions|WebhookMessageOptions}
@@ -328,7 +364,7 @@ module.exports = APIMessage;
 
 /**
  * A target for a message.
- * @typedef {TextChannel|DMChannel|GroupDMChannel|User|GuildMember|Webhook|WebhookClient} MessageTarget
+ * @typedef {TextChannel|DMChannel|User|GuildMember|Webhook|WebhookClient} MessageTarget
  */
 
 /**
diff --git a/src/structures/Base.js b/src/structures/Base.js
index 37633757..65c1fa5e 100644
--- a/src/structures/Base.js
+++ b/src/structures/Base.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Util = require('../util/Util');
 
 /**
@@ -18,7 +20,9 @@ class Base {
     return Object.assign(Object.create(this), this);
   }
 
-  _patch(data) { return data; }
+  _patch(data) {
+    return data;
+  }
 
   _update(data) {
     const clone = this._clone();
diff --git a/src/structures/CategoryChannel.js b/src/structures/CategoryChannel.js
index 5766a4a7..4ac9fbbb 100644
--- a/src/structures/CategoryChannel.js
+++ b/src/structures/CategoryChannel.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const GuildChannel = require('./GuildChannel');
 
 /**
@@ -11,7 +13,7 @@ class CategoryChannel extends GuildChannel {
    * @readonly
    */
   get children() {
-    return this.guild.channels.filter(c => c.parentID === this.id);
+    return this.guild.channels.cache.filter(c => c.parentID === this.id);
   }
 
   /**
diff --git a/src/structures/Channel.js b/src/structures/Channel.js
index 8466d19a..6fbf03cb 100644
--- a/src/structures/Channel.js
+++ b/src/structures/Channel.js
@@ -1,6 +1,8 @@
-const Snowflake = require('../util/Snowflake');
+'use strict';
+
 const Base = require('./Base');
 const { ChannelTypes } = require('../util/Constants');
+const Snowflake = require('../util/Snowflake');
 
 /**
  * Represents any channel on Discord.
@@ -14,10 +16,11 @@ class Channel extends Base {
     /**
      * The type of the channel, either:
      * * `dm` - a DM channel
-     * * `group` - a Group DM channel
      * * `text` - a guild text channel
      * * `voice` - a guild voice channel
      * * `category` - a guild category channel
+     * * `news` - a guild news channel
+     * * `store` - a guild store channel
      * * `unknown` - a generic channel of unknown type, could be Channel or GuildChannel
      * @type {string}
      */
@@ -79,20 +82,38 @@ class Channel extends Base {
    *   .catch(console.error);
    */
   delete() {
-    return this.client.api.channels(this.id).delete().then(() => this);
+    return this.client.api
+      .channels(this.id)
+      .delete()
+      .then(() => this);
+  }
+
+  /**
+   * Fetches this channel.
+   * @returns {Promise<Channel>}
+   */
+  fetch() {
+    return this.client.channels.fetch(this.id, true);
   }
 
   static create(client, data, guild) {
     const Structures = require('../util/Structures');
     let channel;
-    if (data.type === ChannelTypes.DM) {
-      const DMChannel = Structures.get('DMChannel');
-      channel = new DMChannel(client, data);
-    } else if (data.type === ChannelTypes.GROUP) {
-      const GroupDMChannel = Structures.get('GroupDMChannel');
-      channel = new GroupDMChannel(client, data);
+    if (!data.guild_id && !guild) {
+      switch (data.type) {
+        case ChannelTypes.DM: {
+          const DMChannel = Structures.get('DMChannel');
+          channel = new DMChannel(client, data);
+          break;
+        }
+        case ChannelTypes.GROUP: {
+          const PartialGroupDMChannel = require('./PartialGroupDMChannel');
+          channel = new PartialGroupDMChannel(client, data);
+          break;
+        }
+      }
     } else {
-      guild = guild || client.guilds.get(data.guild_id);
+      guild = guild || client.guilds.cache.get(data.guild_id);
       if (guild) {
         switch (data.type) {
           case ChannelTypes.TEXT: {
@@ -110,12 +131,18 @@ class Channel extends Base {
             channel = new CategoryChannel(guild, data);
             break;
           }
-          default: {
-            const GuildChannel = Structures.get('GuildChannel');
-            channel = new GuildChannel(guild, data);
+          case ChannelTypes.NEWS: {
+            const NewsChannel = Structures.get('NewsChannel');
+            channel = new NewsChannel(guild, data);
+            break;
+          }
+          case ChannelTypes.STORE: {
+            const StoreChannel = Structures.get('StoreChannel');
+            channel = new StoreChannel(guild, data);
+            break;
           }
         }
-        guild.channels.set(channel.id, channel);
+        if (channel) guild.channels.cache.set(channel.id, channel);
       }
     }
     return channel;
diff --git a/src/structures/ClientApplication.js b/src/structures/ClientApplication.js
index 7ea36020..753d90da 100644
--- a/src/structures/ClientApplication.js
+++ b/src/structures/ClientApplication.js
@@ -1,6 +1,9 @@
-const Snowflake = require('../util/Snowflake');
-const { ClientApplicationAssetTypes, Endpoints } = require('../util/Constants');
+'use strict';
+
 const Base = require('./Base');
+const Team = require('./Team');
+const { ClientApplicationAssetTypes, Endpoints } = require('../util/Constants');
+const Snowflake = require('../util/Snowflake');
 
 const AssetTypes = Object.keys(ClientApplicationAssetTypes);
 
@@ -65,9 +68,9 @@ class ClientApplication extends Base {
 
     /**
      * The owner of this OAuth application
-     * @type {?User}
+     * @type {?User|Team}
      */
-    this.owner = data.owner ? this.client.users.add(data.owner) : null;
+    this.owner = data.team ? new Team(this.client, data.team) : data.owner ? this.client.users.add(data.owner) : null;
   }
 
   /**
@@ -105,9 +108,7 @@ class ClientApplication extends Base {
    */
   coverImage({ format, size } = {}) {
     if (!this.cover) return null;
-    return Endpoints
-      .CDN(this.client.options.http.cdn)
-      .AppIcon(this.id, this.cover, { format, size });
+    return Endpoints.CDN(this.client.options.http.cdn).AppIcon(this.id, this.cover, { format, size });
   }
 
   /**
@@ -123,12 +124,16 @@ class ClientApplication extends Base {
    * @returns {Promise<Array<ClientAsset>>}
    */
   fetchAssets() {
-    return this.client.api.oauth2.applications(this.id).assets.get()
-      .then(assets => assets.map(a => ({
-        id: a.id,
-        name: a.name,
-        type: AssetTypes[a.type - 1],
-      })));
+    return this.client.api.oauth2
+      .applications(this.id)
+      .assets.get()
+      .then(assets =>
+        assets.map(a => ({
+          id: a.id,
+          name: a.name,
+          type: AssetTypes[a.type - 1],
+        })),
+      );
   }
 
   /**
diff --git a/src/structures/ClientPresence.js b/src/structures/ClientPresence.js
index 90d1cb4a..a39ba006 100644
--- a/src/structures/ClientPresence.js
+++ b/src/structures/ClientPresence.js
@@ -1,9 +1,15 @@
+'use strict';
+
 const { Presence } = require('./Presence');
+const { TypeError } = require('../errors');
 const Collection = require('../util/Collection');
 const { ActivityTypes, OPCodes } = require('../util/Constants');
-const { TypeError } = require('../errors');
 
 class ClientPresence extends Presence {
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Object} [data={}] The data for the client presence
+   */
   constructor(client, data = {}) {
     super(client, Object.assign(data, { status: 'online', user: { id: null } }));
   }
@@ -11,11 +17,19 @@ class ClientPresence extends Presence {
   async set(presence) {
     const packet = await this._parse(presence);
     this.patch(packet);
-    this.client.ws.send({ op: OPCodes.STATUS_UPDATE, d: packet });
+    if (typeof presence.shardID === 'undefined') {
+      this.client.ws.broadcast({ op: OPCodes.STATUS_UPDATE, d: packet });
+    } else if (Array.isArray(presence.shardID)) {
+      for (const shardID of presence.shardID) {
+        this.client.ws.shards.get(shardID).send({ op: OPCodes.STATUS_UPDATE, d: packet });
+      }
+    } else {
+      this.client.ws.shards.get(presence.shardID).send({ op: OPCodes.STATUS_UPDATE, d: packet });
+    }
     return this;
   }
 
-  async _parse({ status, since, afk, activity }) { // eslint-disable-line complexity
+  async _parse({ status, since, afk, activity }) {
     const applicationID = activity && (activity.application ? activity.application.id || activity.application : null);
     let assets = new Collection();
     if (activity) {
@@ -25,7 +39,7 @@ class ClientPresence extends Presence {
         try {
           const a = await this.client.api.oauth2.applications(applicationID).assets.get();
           for (const asset of a) assets.set(asset.name, asset.id);
-        } catch (err) { } // eslint-disable-line no-empty
+        } catch {} // eslint-disable-line no-empty
       }
     }
 
@@ -33,33 +47,37 @@ class ClientPresence extends Presence {
       afk: afk != null ? afk : false, // eslint-disable-line eqeqeq
       since: since != null ? since : null, // eslint-disable-line eqeqeq
       status: status || this.status,
-      game: activity ? {
-        type: activity.type,
-        name: activity.name,
-        url: activity.url,
-        details: activity.details || undefined,
-        state: activity.state || undefined,
-        assets: activity.assets ? {
-          large_text: activity.assets.largeText || undefined,
-          small_text: activity.assets.smallText || undefined,
-          large_image: assets.get(activity.assets.largeImage) || activity.assets.largeImage,
-          small_image: assets.get(activity.assets.smallImage) || activity.assets.smallImage,
-        } : undefined,
-        timestamps: activity.timestamps || undefined,
-        party: activity.party || undefined,
-        application_id: applicationID || undefined,
-        secrets: activity.secrets || undefined,
-        instance: activity.instance || undefined,
-      } : null,
+      game: activity
+        ? {
+            type: activity.type,
+            name: activity.name,
+            url: activity.url,
+            details: activity.details || undefined,
+            state: activity.state || undefined,
+            assets: activity.assets
+              ? {
+                  large_text: activity.assets.largeText || undefined,
+                  small_text: activity.assets.smallText || undefined,
+                  large_image: assets.get(activity.assets.largeImage) || activity.assets.largeImage,
+                  small_image: assets.get(activity.assets.smallImage) || activity.assets.smallImage,
+                }
+              : undefined,
+            timestamps: activity.timestamps || undefined,
+            party: activity.party || undefined,
+            application_id: applicationID || undefined,
+            secrets: activity.secrets || undefined,
+            instance: activity.instance || undefined,
+          }
+        : null,
     };
 
     if ((status || afk || since) && !activity) {
-      packet.game = this.activity;
+      packet.game = this.activities[0] || null;
     }
 
     if (packet.game) {
-      packet.game.type = typeof packet.game.type === 'number' ?
-        packet.game.type : ActivityTypes.indexOf(packet.game.type);
+      packet.game.type =
+        typeof packet.game.type === 'number' ? packet.game.type : ActivityTypes.indexOf(packet.game.type);
     }
 
     return packet;
diff --git a/src/structures/ClientUser.js b/src/structures/ClientUser.js
index 9827e16d..84ada54d 100644
--- a/src/structures/ClientUser.js
+++ b/src/structures/ClientUser.js
@@ -1,45 +1,60 @@
-const Structures = require('../util/Structures');
+'use strict';
+
 const DataResolver = require('../util/DataResolver');
+const Structures = require('../util/Structures');
 
 /**
  * Represents the logged in client's Discord user.
  * @extends {User}
  */
 class ClientUser extends Structures.get('User') {
+  constructor(client, data) {
+    super(client, data);
+    this._typing = new Map();
+  }
+
   _patch(data) {
     super._patch(data);
 
-    /**
-     * Whether or not this account has been verified
-     * @type {boolean}
-     */
-    this.verified = data.verified;
+    if ('verified' in data) {
+      /**
+       * Whether or not this account has been verified
+       * @type {boolean}
+       */
+      this.verified = data.verified;
+    }
 
-    this._typing = new Map();
-
-    /**
-     * If the bot's {@link ClientApplication#owner Owner} has MFA enabled on their account
-     * @type {?boolean}
-     */
-    this.mfaEnabled = typeof data.mfa_enabled === 'boolean' ? data.mfa_enabled : null;
+    if ('mfa_enabled' in data) {
+      /**
+       * If the bot's {@link ClientApplication#owner Owner} has MFA enabled on their account
+       * @type {?boolean}
+       */
+      this.mfaEnabled = typeof data.mfa_enabled === 'boolean' ? data.mfa_enabled : null;
+    } else if (typeof this.mfaEnabled === 'undefined') {
+      this.mfaEnabled = null;
+    }
 
     if (data.token) this.client.token = data.token;
   }
 
   /**
    * ClientUser's presence
-   * @readonly
    * @type {Presence}
+   * @readonly
    */
   get presence() {
     return this.client.presence;
   }
 
   edit(data) {
-    return this.client.api.users('@me').patch({ data })
+    return this.client.api
+      .users('@me')
+      .patch({ data })
       .then(newData => {
         this.client.token = newData.token;
-        return this.client.actions.UserUpdate.handle(newData).updated;
+        const { updated } = this.client.actions.UserUpdate.handle(newData);
+        if (updated) return updated;
+        return this;
       });
   }
 
@@ -76,7 +91,7 @@ class ClientUser extends Structures.get('User') {
   /**
    * Data resembling a raw Discord presence.
    * @typedef {Object} PresenceData
-   * @property {PresenceStatus} [status] Status of the user
+   * @property {PresenceStatusData} [status] Status of the user
    * @property {boolean} [afk] Whether the user is AFK
    * @property {Object} [activity] Activity the user is playing
    * @property {Object|string} [activity.application] An application object or application id
@@ -84,6 +99,7 @@ class ClientUser extends Structures.get('User') {
    * @property {string} [activity.name] Name of the activity
    * @property {ActivityType|number} [activity.type] Type of the activity
    * @property {string} [activity.url] Stream url
+   * @property {?number|number[]} [shardID] Shard Id(s) to have the activity set on
    */
 
   /**
@@ -106,12 +122,13 @@ class ClientUser extends Structures.get('User') {
    * * `idle`
    * * `invisible`
    * * `dnd` (do not disturb)
-   * @typedef {string} PresenceStatus
+   * @typedef {string} PresenceStatusData
    */
 
   /**
    * Sets the status of the client user.
-   * @param {PresenceStatus} status Status to change to
+   * @param {PresenceStatusData} status Status to change to
+   * @param {?number|number[]} [shardID] Shard ID(s) to have the activity set on
    * @returns {Promise<Presence>}
    * @example
    * // Set the client user's status
@@ -119,8 +136,8 @@ class ClientUser extends Structures.get('User') {
    *   .then(console.log)
    *   .catch(console.error);
    */
-  setStatus(status) {
-    return this.setPresence({ status });
+  setStatus(status, shardID) {
+    return this.setPresence({ status, shardID });
   }
 
   /**
@@ -129,6 +146,7 @@ class ClientUser extends Structures.get('User') {
    * @type {Object}
    * @property {string} [url] Twitch stream URL
    * @property {ActivityType|number} [type] Type of the activity
+   * @property {?number|number[]} [shardID] Shard Id(s) to have the activity set on
    */
 
   /**
@@ -139,14 +157,14 @@ class ClientUser extends Structures.get('User') {
    * @example
    * // Set the client user's activity
    * client.user.setActivity('discord.js', { type: 'WATCHING' })
-   *   .then(presence => console.log(`Activity set to ${presence.activity.name}`))
+   *   .then(presence => console.log(`Activity set to ${presence.activities[0].name}`))
    *   .catch(console.error);
    */
   setActivity(name, options = {}) {
-    if (!name) return this.setPresence({ activity: null });
+    if (!name) return this.setPresence({ activity: null, shardID: options.shardID });
 
     const activity = Object.assign({}, options, typeof name === 'object' ? name : { name });
-    return this.setPresence({ activity });
+    return this.setPresence({ activity, shardID: activity.shardID });
   }
 
   /**
@@ -157,42 +175,6 @@ class ClientUser extends Structures.get('User') {
   setAFK(afk) {
     return this.setPresence({ afk });
   }
-
-  /**
-   * An object containing either a user or access token, and an optional nickname.
-   * @typedef {Object} GroupDMRecipientOptions
-   * @property {UserResolvable} [user] User to add to the Group DM
-   * @property {string} [accessToken] Access token to use to add a user to the Group DM
-   * (only available if a bot is creating the DM)
-   * @property {string} [nick] Permanent nickname (only available if a bot is creating the DM)
-   * @property {string} [id] If no user resolvable is provided and you want to assign nicknames
-   * you must provide user ids instead
-   */
-
-  /**
-   * Creates a Group DM.
-   * @param {GroupDMRecipientOptions[]} recipients The recipients
-   * @returns {Promise<GroupDMChannel>}
-   * @example
-   * // Create a Group DM with a token provided from OAuth
-   * client.user.createGroupDM([{
-   *   user: '66564597481480192',
-   *   accessToken: token
-   * }])
-   *   .then(console.log)
-   *   .catch(console.error);
-   */
-  createGroupDM(recipients) {
-    const data = this.bot ? {
-      access_tokens: recipients.map(u => u.accessToken),
-      nicks: recipients.reduce((o, r) => {
-        if (r.nick) o[r.user ? r.user.id : r.id] = r.nick;
-        return o;
-      }, {}),
-    } : { recipients: recipients.map(u => this.client.users.resolveID(u.user || u.id)) };
-    return this.client.api.users('@me').channels.post({ data })
-      .then(res => this.client.channels.add(res));
-  }
 }
 
 module.exports = ClientUser;
diff --git a/src/structures/DMChannel.js b/src/structures/DMChannel.js
index 1f45f490..e661bc44 100644
--- a/src/structures/DMChannel.js
+++ b/src/structures/DMChannel.js
@@ -1,6 +1,8 @@
+'use strict';
+
 const Channel = require('./Channel');
 const TextBasedChannel = require('./interfaces/TextBasedChannel');
-const MessageStore = require('../stores/MessageStore');
+const MessageManager = require('../managers/MessageManager');
 
 /**
  * Represents a direct message channel between two users.
@@ -8,24 +10,32 @@ const MessageStore = require('../stores/MessageStore');
  * @implements {TextBasedChannel}
  */
 class DMChannel extends Channel {
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Object} data The data for the DM channel
+   */
   constructor(client, data) {
     super(client, data);
+    // Override the channel type so partials have a known type
+    this.type = 'dm';
     /**
-     * A collection containing the messages sent to this channel
-     * @type {MessageStore<Snowflake, Message>}
+     * A manager of the messages belonging to this channel
+     * @type {MessageManager}
      */
-    this.messages = new MessageStore(this);
+    this.messages = new MessageManager(this);
     this._typing = new Map();
   }
 
   _patch(data) {
     super._patch(data);
 
-    /**
-     * The recipient on the other end of the DM
-     * @type {User}
-     */
-    this.recipient = this.client.users.add(data.recipients[0]);
+    if (data.recipients) {
+      /**
+       * The recipient on the other end of the DM
+       * @type {User}
+       */
+      this.recipient = this.client.users.add(data.recipients[0]);
+    }
 
     /**
      * The ID of the last message in the channel, if one was sent
@@ -40,6 +50,23 @@ class DMChannel extends Channel {
     this.lastPinTimestamp = data.last_pin_timestamp ? new Date(data.last_pin_timestamp).getTime() : null;
   }
 
+  /**
+   * Whether this DMChannel is a partial
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return typeof this.lastMessageID === 'undefined';
+  }
+
+  /**
+   * Fetch this DMChannel.
+   * @returns {Promise<DMChannel>}
+   */
+  fetch() {
+    return this.recipient.createDM();
+  }
+
   /**
    * When concatenated with a string, this automatically returns the recipient's mention instead of the
    * DMChannel object.
@@ -57,7 +84,6 @@ class DMChannel extends Channel {
   get lastMessage() {}
   get lastPinAt() {}
   send() {}
-  search() {}
   startTyping() {}
   stopTyping() {}
   get typing() {}
@@ -65,8 +91,6 @@ class DMChannel extends Channel {
   createMessageCollector() {}
   awaitMessages() {}
   // Doesn't work on DM channels; bulkDelete() {}
-  acknowledge() {}
-  _cacheMessage() {}
 }
 
 TextBasedChannel.applyToClass(DMChannel, true, ['bulkDelete']);
diff --git a/src/structures/Emoji.js b/src/structures/Emoji.js
index ed844f18..0214ea80 100644
--- a/src/structures/Emoji.js
+++ b/src/structures/Emoji.js
@@ -1,6 +1,7 @@
-const Snowflake = require('../util/Snowflake');
-const Base = require('./Base');
+'use strict';
 
+const Base = require('./Base');
+const Snowflake = require('../util/Snowflake');
 
 /**
  * Represents an emoji, see {@link GuildEmoji} and {@link ReactionEmoji}.
@@ -80,7 +81,7 @@ class Emoji extends Base {
    * @returns {string}
    * @example
    * // Send a custom emoji from a guild:
-   * const emoji = guild.emojis.first();
+   * const emoji = guild.emojis.cache.first();
    * msg.reply(`Hello! ${emoji}`);
    * @example
    * // Send the emoji used in a reaction to the channel the reaction is part of
diff --git a/src/structures/GroupDMChannel.js b/src/structures/GroupDMChannel.js
deleted file mode 100644
index b2fe7200..00000000
--- a/src/structures/GroupDMChannel.js
+++ /dev/null
@@ -1,244 +0,0 @@
-const Channel = require('./Channel');
-const TextBasedChannel = require('./interfaces/TextBasedChannel');
-const Collection = require('../util/Collection');
-const DataResolver = require('../util/DataResolver');
-const MessageStore = require('../stores/MessageStore');
-
-/*
-{ type: 3,
-  recipients:
-   [ { username: 'Charlie',
-       id: '123',
-       discriminator: '6631',
-       avatar: '123' },
-     { username: 'Ben',
-       id: '123',
-       discriminator: '2055',
-       avatar: '123' },
-     { username: 'Adam',
-       id: '123',
-       discriminator: '2406',
-       avatar: '123' } ],
-  owner_id: '123',
-  name: null,
-  last_message_id: '123',
-  id: '123',
-  icon: null }
-*/
-
-/**
- * Represents a Group DM on Discord.
- * @extends {Channel}
- * @implements {TextBasedChannel}
- */
-class GroupDMChannel extends Channel {
-  constructor(client, data) {
-    super(client, data);
-    /**
-     * A collection containing the messages sent to this channel
-     * @type {MessageStore<Snowflake, Message>}
-     */
-    this.messages = new MessageStore(this);
-    this._typing = new Map();
-  }
-
-  _patch(data) {
-    super._patch(data);
-
-    /**
-     * The name of this Group DM, can be null if one isn't set
-     * @type {string}
-     */
-    this.name = data.name;
-
-    /**
-     * A hash of this Group DM icon
-     * @type {?string}
-     */
-    this.icon = data.icon;
-
-    /**
-     * The user ID of this Group DM's owner
-     * @type {Snowflake}
-     */
-    this.ownerID = data.owner_id;
-
-    /**
-     * If the DM is managed by an application
-     * @type {boolean}
-     */
-    this.managed = data.managed;
-
-    /**
-     * Application ID of the application that made this Group DM, if applicable
-     * @type {?Snowflake}
-     */
-    this.applicationID = data.application_id;
-
-    if (data.nicks) {
-      /**
-       * Nicknames for group members
-       * @type {?Collection<Snowflake, string>}
-       */
-      this.nicks = new Collection(data.nicks.map(n => [n.id, n.nick]));
-    }
-
-    if (!this.recipients) {
-      /**
-       * A collection of the recipients of this DM, mapped by their ID
-       * @type {Collection<Snowflake, User>}
-       */
-      this.recipients = new Collection();
-    }
-
-    if (data.recipients) {
-      for (const recipient of data.recipients) {
-        const user = this.client.users.add(recipient);
-        this.recipients.set(user.id, user);
-      }
-    }
-
-    /**
-     * The ID of the last message in the channel, if one was sent
-     * @type {?Snowflake}
-     */
-    this.lastMessageID = data.last_message_id;
-
-    /**
-     * The timestamp when the last pinned message was pinned, if there was one
-     * @type {?number}
-     */
-    this.lastPinTimestamp = data.last_pin_timestamp ? new Date(data.last_pin_timestamp).getTime() : null;
-  }
-
-  /**
-   * The owner of this Group DM
-   * @type {?User}
-   * @readonly
-   */
-  get owner() {
-    return this.client.users.get(this.ownerID) || null;
-  }
-
-  /**
-   * Gets the URL to this Group DM's icon.
-   * @param {ImageURLOptions} [options={}] Options for the Image URL
-   * @returns {?string}
-   */
-  iconURL({ format, size } = {}) {
-    if (!this.icon) return null;
-    return this.client.rest.cdn.GDMIcon(this.id, this.icon, format, size);
-  }
-
-  /**
-   * Whether this channel equals another channel. It compares all properties, so for most operations
-   * it is advisable to just compare `channel.id === channel2.id` as it is much faster and is often
-   * what most users need.
-   * @param {GroupDMChannel} channel Channel to compare with
-   * @returns {boolean}
-   */
-  equals(channel) {
-    const equal = channel &&
-      this.id === channel.id &&
-      this.name === channel.name &&
-      this.icon === channel.icon &&
-      this.ownerID === channel.ownerID;
-
-    if (equal) {
-      return this.recipients.equals(channel.recipients);
-    }
-
-    return equal;
-  }
-
-  /**
-   * Edits this Group DM.
-   * @param {Object} data New data for this Group DM
-   * @param {string} [reason] Reason for editing this Group DM
-   * @returns {Promise<GroupDMChannel>}
-   */
-  edit(data, reason) {
-    return this.client.api.channels[this.id].patch({
-      data: {
-        icon: data.icon,
-        name: data.name === null ? null : data.name || this.name,
-      },
-      reason,
-    }).then(() => this);
-  }
-
-  /**
-   * Sets a new icon for this Group DM.
-   * @param {Base64Resolvable|BufferResolvable} icon The new icon of this Group DM
-   * @returns {Promise<GroupDMChannel>}
-   */
-  async setIcon(icon) {
-    return this.edit({ icon: await DataResolver.resolveImage(icon) });
-  }
-
-  /**
-   * Sets a new name for this Group DM.
-   * @param {string} name New name for this Group DM
-   * @returns {Promise<GroupDMChannel>}
-   */
-  setName(name) {
-    return this.edit({ name });
-  }
-
-  /**
-   * Adds a user to this Group DM.
-   * @param {Object} options Options for this method
-   * @param {UserResolvable} options.user User to add to this Group DM
-   * @param {string} [options.accessToken] Access token to use to add the user to this Group DM
-   * @param {string} [options.nick] Permanent nickname to give the user
-   * @returns {Promise<GroupDMChannel>}
-   */
-  addUser({ user, accessToken, nick }) {
-    const id = this.client.users.resolveID(user);
-    return this.client.api.channels[this.id].recipients[id].put({ nick, access_token: accessToken })
-      .then(() => this);
-  }
-
-  /**
-   * Removes a user from this Group DM.
-   * @param {UserResolvable} user User to remove
-   * @returns {Promise<GroupDMChannel>}
-   */
-  removeUser(user) {
-    const id = this.client.users.resolveID(user);
-    return this.client.api.channels[this.id].recipients[id].delete()
-      .then(() => this);
-  }
-
-  /**
-   * When concatenated with a string, this automatically returns the channel's name instead of the
-   * GroupDMChannel object.
-   * @returns {string}
-   * @example
-   * // Logs: Hello from My Group DM!
-   * console.log(`Hello from ${channel}!`);
-   */
-  toString() {
-    return this.name;
-  }
-
-  // These are here only for documentation purposes - they are implemented by TextBasedChannel
-  /* eslint-disable no-empty-function */
-  get lastMessage() {}
-  get lastPinAt() {}
-  send() {}
-  search() {}
-  startTyping() {}
-  stopTyping() {}
-  get typing() {}
-  get typingCount() {}
-  createMessageCollector() {}
-  awaitMessages() {}
-  // Doesn't work on Group DMs; bulkDelete() {}
-  acknowledge() {}
-  _cacheMessage() {}
-}
-
-TextBasedChannel.applyToClass(GroupDMChannel, true, ['bulkDelete']);
-
-module.exports = GroupDMChannel;
diff --git a/src/structures/Guild.js b/src/structures/Guild.js
index 493c0df8..ece8a530 100644
--- a/src/structures/Guild.js
+++ b/src/structures/Guild.js
@@ -1,21 +1,29 @@
-const Invite = require('./Invite');
-const Integration = require('./Integration');
+'use strict';
+
+const Base = require('./Base');
 const GuildAuditLogs = require('./GuildAuditLogs');
-const Webhook = require('./Webhook');
+const Integration = require('./Integration');
+const Invite = require('./Invite');
 const VoiceRegion = require('./VoiceRegion');
-const { ChannelTypes, DefaultMessageNotifications, browser } = require('../util/Constants');
+const Webhook = require('./Webhook');
+const GuildChannelManager = require('../managers/GuildChannelManager');
+const GuildEmojiManager = require('../managers/GuildEmojiManager');
+const GuildMemberManager = require('../managers/GuildMemberManager');
+const PresenceManager = require('../managers/PresenceManager');
+const RoleManager = require('../managers/RoleManager');
+const VoiceStateManager = require('../managers/VoiceStateManager');
 const Collection = require('../util/Collection');
-const Util = require('../util/Util');
+const {
+  ChannelTypes,
+  DefaultMessageNotifications,
+  PartialTypes,
+  VerificationLevels,
+  ExplicitContentFilterLevels,
+} = require('../util/Constants');
 const DataResolver = require('../util/DataResolver');
 const Snowflake = require('../util/Snowflake');
-const GuildMemberStore = require('../stores/GuildMemberStore');
-const RoleStore = require('../stores/RoleStore');
-const GuildEmojiStore = require('../stores/GuildEmojiStore');
-const GuildChannelStore = require('../stores/GuildChannelStore');
-const PresenceStore = require('../stores/PresenceStore');
-const VoiceStateStore = require('../stores/VoiceStateStore');
-const Base = require('./Base');
-const { Error, TypeError } = require('../errors');
+const SystemChannelFlags = require('../util/SystemChannelFlags');
+const Util = require('../util/Util');
 
 /**
  * Represents a guild (or a server) on Discord.
@@ -24,32 +32,42 @@ const { Error, TypeError } = require('../errors');
  * @extends {Base}
  */
 class Guild extends Base {
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Object} data The data for the guild
+   */
   constructor(client, data) {
     super(client);
 
     /**
-     * A collection of members that are in this guild. The key is the member's ID, the value is the member
-     * @type {GuildMemberStore<Snowflake, GuildMember>}
+     * A manager of the members belonging to this guild
+     * @type {GuildMemberManager}
      */
-    this.members = new GuildMemberStore(this);
+    this.members = new GuildMemberManager(this);
 
     /**
-     * A collection of channels that are in this guild. The key is the channel's ID, the value is the channel
-     * @type {GuildChannelStore<Snowflake, GuildChannel>}
+     * A manager of the channels belonging to this guild
+     * @type {GuildChannelManager}
      */
-    this.channels = new GuildChannelStore(this);
+    this.channels = new GuildChannelManager(this);
 
     /**
-     * A collection of roles that are in this guild. The key is the role's ID, the value is the role
-     * @type {RoleStore<Snowflake, Role>}
+     * A manager of the roles belonging to this guild
+     * @type {RoleManager}
      */
-    this.roles = new RoleStore(this);
+    this.roles = new RoleManager(this);
 
     /**
-     * A collection of presences in this guild
-     * @type {PresenceStore<Snowflake, Presence>}
+     * A manager of the presences belonging to this guild
+     * @type {PresenceManager}
      */
-    this.presences = new PresenceStore(this.client);
+    this.presences = new PresenceManager(this.client);
+
+    /**
+     * A manager of the voice states of this guild
+     * @type {VoiceStateManager}
+     */
+    this.voiceStates = new VoiceStateManager(this);
 
     /**
      * Whether the bot has been removed from the guild
@@ -74,9 +92,23 @@ class Guild extends Base {
       this._patch(data);
       if (!data.channels) this.available = false;
     }
+
+    /**
+     * The id of the shard this Guild belongs to.
+     * @type {number}
+     */
+    this.shardID = data.shardID;
+  }
+
+  /**
+   * The Shard this Guild belongs to.
+   * @type {WebSocketShard}
+   * @readonly
+   */
+  get shard() {
+    return this.client.ws.shards.get(this.shardID);
   }
 
-  /* eslint-disable complexity */
   /**
    * Sets up the guild.
    * @param {*} data The raw data of the guild
@@ -121,11 +153,18 @@ class Guild extends Base {
 
     /**
      * An array of enabled guild features, here are the possible values:
+     * * ANIMATED_ICON
+     * * BANNER
+     * * COMMERCE
+     * * DISCOVERABLE
+     * * FEATURABLE
      * * INVITE_SPLASH
-     * * MORE_EMOJI
+     * * PUBLIC
+     * * NEWS
+     * * PARTNERED
+     * * VANITY_URL
      * * VERIFIED
      * * VIP_REGIONS
-     * * VANITY_URL
      * @typedef {string} Features
      */
 
@@ -166,16 +205,61 @@ class Guild extends Base {
     this.embedEnabled = data.embed_enabled;
 
     /**
-     * The verification level of the guild
-     * @type {number}
+     * The type of premium tier:
+     * * 0: NONE
+     * * 1: TIER_1
+     * * 2: TIER_2
+     * * 3: TIER_3
+     * @typedef {number} PremiumTier
      */
-    this.verificationLevel = data.verification_level;
+
+    /**
+     * The premium tier on this guild
+     * @type {PremiumTier}
+     */
+    this.premiumTier = data.premium_tier;
+
+    /**
+     * The total number of users currently boosting this server
+     * @type {?number}
+     * @name Guild#premiumSubscriptionCount
+     */
+    if (typeof data.premium_subscription_count !== 'undefined') {
+      this.premiumSubscriptionCount = data.premium_subscription_count;
+    }
+
+    /**
+     * Whether widget images are enabled on this guild
+     * @type {?boolean}
+     * @name Guild#widgetEnabled
+     */
+    if (typeof data.widget_enabled !== 'undefined') this.widgetEnabled = data.widget_enabled;
+
+    /**
+     * The widget channel ID, if enabled
+     * @type {?string}
+     * @name Guild#widgetChannelID
+     */
+    if (typeof data.widget_channel_id !== 'undefined') this.widgetChannelID = data.widget_channel_id;
+
+    /**
+     * The embed channel ID, if enabled
+     * @type {?string}
+     * @name Guild#embedChannelID
+     */
+    if (typeof data.embed_channel_id !== 'undefined') this.embedChannelID = data.embed_channel_id;
+
+    /**
+     * The verification level of the guild
+     * @type {VerificationLevel}
+     */
+    this.verificationLevel = VerificationLevels[data.verification_level];
 
     /**
      * The explicit content filter level of the guild
-     * @type {number}
+     * @type {ExplicitContentFilterLevel}
      */
-    this.explicitContentFilter = data.explicit_content_filter;
+    this.explicitContentFilter = ExplicitContentFilterLevels[data.explicit_content_filter];
 
     /**
      * The required MFA level for the guild
@@ -190,30 +274,84 @@ class Guild extends Base {
     this.joinedTimestamp = data.joined_at ? new Date(data.joined_at).getTime() : this.joinedTimestamp;
 
     /**
-     * The value set for a guild's default message notifications
+     * The value set for the guild's default message notifications
      * @type {DefaultMessageNotifications|number}
      */
-    this.defaultMessageNotifications = DefaultMessageNotifications[data.default_message_notifications] ||
-      data.default_message_notifications;
+    this.defaultMessageNotifications =
+      DefaultMessageNotifications[data.default_message_notifications] || data.default_message_notifications;
+
+    /**
+     * The value set for the guild's system channel flags
+     * @type {Readonly<SystemChannelFlags>}
+     */
+    this.systemChannelFlags = new SystemChannelFlags(data.system_channel_flags).freeze();
+
+    /**
+     * The maximum amount of members the guild can have
+     * <info>You will need to fetch the guild using {@link Guild#fetch} if you want to receive this parameter</info>
+     * @type {?number}
+     * @name Guild#maximumMembers
+     */
+    if (typeof data.max_members !== 'undefined') this.maximumMembers = data.max_members || 250000;
+
+    /**
+     * The maximum amount of presences the guild can have
+     * <info>You will need to fetch the guild using {@link Guild#fetch} if you want to receive this parameter</info>
+     * @type {?number}
+     * @name Guild#maximumPresences
+     */
+    if (typeof data.max_presences !== 'undefined') this.maximumPresences = data.max_presences || 5000;
+
+    /**
+     * The vanity URL code of the guild, if any
+     * @type {?string}
+     */
+    this.vanityURLCode = data.vanity_url_code;
+
+    /**
+     * The description of the guild, if any
+     * @type {?string}
+     */
+    this.description = data.description;
+
+    /**
+     * The hash of the guild banner
+     * @type {?string}
+     */
+    this.banner = data.banner;
 
     this.id = data.id;
     this.available = !data.unavailable;
     this.features = data.features || this.features || [];
 
+    /**
+     * The ID of the rules channel for the guild
+     * <info>This is only available on guilds with the `PUBLIC` feature</info>
+     * @type {?Snowflake}
+     */
+    this.rulesChannelID = data.rules_channel_id;
+
+    /**
+     * The ID of the public updates channel for the guild
+     * <info>This is only available on guilds with the `PUBLIC` feature</info>
+     * @type {?Snowflake}
+     */
+    this.publicUpdatesChannelID = data.public_updates_channel_id;
+
     if (data.channels) {
-      this.channels.clear();
+      this.channels.cache.clear();
       for (const rawChannel of data.channels) {
         this.client.channels.add(rawChannel, this);
       }
     }
 
     if (data.roles) {
-      this.roles.clear();
+      this.roles.cache.clear();
       for (const role of data.roles) this.roles.add(role);
     }
 
     if (data.members) {
-      this.members.clear();
+      this.members.cache.clear();
       for (const guildUser of data.members) this.members.add(guildUser);
     }
 
@@ -231,8 +369,8 @@ class Guild extends Base {
       }
     }
 
-    if (!this.voiceStates) this.voiceStates = new VoiceStateStore(this);
     if (data.voice_states) {
+      this.voiceStates.cache.clear();
       for (const voiceState of data.voice_states) {
         this.voiceStates.add(voiceState);
       }
@@ -240,12 +378,12 @@ class Guild extends Base {
 
     if (!this.emojis) {
       /**
-       * A collection of emojis that are in this guild. The key is the emoji's ID, the value is the emoji.
-       * @type {GuildEmojiStore<Snowflake, GuildEmoji>}
+       * A manager of the emojis belonging to this guild
+       * @type {GuildEmojiManager}
        */
-      this.emojis = new GuildEmojiStore(this);
+      this.emojis = new GuildEmojiManager(this);
       if (data.emojis) for (const emoji of data.emojis) this.emojis.add(emoji);
-    } else {
+    } else if (data.emojis) {
       this.client.actions.GuildEmojisUpdate.handle({
         guild_id: this.id,
         emojis: data.emojis,
@@ -253,6 +391,16 @@ class Guild extends Base {
     }
   }
 
+  /**
+   * The URL to this guild's banner.
+   * @param {ImageURLOptions} [options={}] Options for the Image URL
+   * @returns {?string}
+   */
+  bannerURL({ format, size } = {}) {
+    if (!this.banner) return null;
+    return this.client.rest.cdn.Banner(this.id, this.banner, format, size);
+  }
+
   /**
    * The timestamp the guild was created at
    * @type {number}
@@ -280,6 +428,15 @@ class Guild extends Base {
     return new Date(this.joinedTimestamp);
   }
 
+  /**
+   * If this guild is partnered
+   * @type {boolean}
+   * @readonly
+   */
+  get partnered() {
+    return this.features.includes('PARTNERED');
+  }
+
   /**
    * If this guild is verified
    * @type {boolean}
@@ -294,9 +451,9 @@ class Guild extends Base {
    * @param {ImageURLOptions} [options={}] Options for the Image URL
    * @returns {?string}
    */
-  iconURL({ format, size } = {}) {
+  iconURL({ format, size, dynamic } = {}) {
     if (!this.icon) return null;
-    return this.client.rest.cdn.Icon(this.id, this.icon, format, size);
+    return this.client.rest.cdn.Icon(this.id, this.icon, format, size, dynamic);
   }
 
   /**
@@ -324,7 +481,12 @@ class Guild extends Base {
    * @readonly
    */
   get owner() {
-    return this.members.get(this.ownerID) || null;
+    return (
+      this.members.cache.get(this.ownerID) ||
+      (this.client.options.partials.includes(PartialTypes.GUILD_MEMBER)
+        ? this.members.add({ user: { id: this.ownerID } }, true)
+        : null)
+    );
   }
 
   /**
@@ -333,7 +495,7 @@ class Guild extends Base {
    * @readonly
    */
   get afkChannel() {
-    return this.client.channels.get(this.afkChannelID) || null;
+    return this.client.channels.cache.get(this.afkChannelID) || null;
   }
 
   /**
@@ -342,26 +504,45 @@ class Guild extends Base {
    * @readonly
    */
   get systemChannel() {
-    return this.client.channels.get(this.systemChannelID) || null;
+    return this.client.channels.cache.get(this.systemChannelID) || null;
   }
 
   /**
-   * If the client is connected to any voice channel in this guild, this will be the relevant VoiceConnection
-   * @type {?VoiceConnection}
+   * Widget channel for this guild
+   * @type {?TextChannel}
    * @readonly
    */
-  get voiceConnection() {
-    if (browser) return null;
-    return this.client.voice.connections.get(this.id) || null;
+  get widgetChannel() {
+    return this.client.channels.cache.get(this.widgetChannelID) || null;
   }
 
   /**
-   * The `@everyone` role of the guild
-   * @type {?Role}
+   * Embed channel for this guild
+   * @type {?TextChannel}
    * @readonly
    */
-  get defaultRole() {
-    return this.roles.get(this.id) || null;
+  get embedChannel() {
+    return this.client.channels.cache.get(this.embedChannelID) || null;
+  }
+
+  /**
+   * Rules channel for this guild
+   * <info>This is only available on guilds with the `PUBLIC` feature</info>
+   * @type {?TextChannel}
+   * @readonly
+   */
+  get rulesChannel() {
+    return this.client.channels.cache.get(this.rulesChannelID) || null;
+  }
+
+  /**
+   * Public updates channel for this guild
+   * <info>This is only available on guilds with the `PUBLIC` feature</info>
+   * @type {?TextChannel}
+   * @readonly
+   */
+  get publicUpdatesChannel() {
+    return this.client.channels.cache.get(this.publicUpdatesChannelID) || null;
   }
 
   /**
@@ -370,7 +551,21 @@ class Guild extends Base {
    * @readonly
    */
   get me() {
-    return this.members.get(this.client.user.id) || null;
+    return (
+      this.members.cache.get(this.client.user.id) ||
+      (this.client.options.partials.includes(PartialTypes.GUILD_MEMBER)
+        ? this.members.add({ user: { id: this.client.user.id } }, true)
+        : null)
+    );
+  }
+
+  /**
+   * The voice state for the client user of this guild, if any
+   * @type {?VoiceState}
+   * @readonly
+   */
+  get voice() {
+    return this.voiceStates.cache.get(this.client.user.id);
   }
 
   /**
@@ -385,6 +580,20 @@ class Guild extends Base {
     return this.members.resolve(user);
   }
 
+  /**
+   * Fetches this guild.
+   * @returns {Promise<Guild>}
+   */
+  fetch() {
+    return this.client.api
+      .guilds(this.id)
+      .get()
+      .then(data => {
+        this._patch(data);
+        return this;
+      });
+  }
+
   /**
    * An object containing information about a guild member's ban.
    * @typedef {Object} BanInfo
@@ -392,20 +601,41 @@ class Guild extends Base {
    * @property {?string} reason Reason the user was banned
    */
 
+  /**
+   * Fetches information on a banned user from this guild.
+   * @param {UserResolvable} user The User to fetch the ban info of
+   * @returns {Promise<BanInfo>}
+   */
+  fetchBan(user) {
+    const id = this.client.users.resolveID(user);
+    if (!id) throw new Error('FETCH_BAN_RESOLVE_ID');
+    return this.client.api
+      .guilds(this.id)
+      .bans(id)
+      .get()
+      .then(ban => ({
+        reason: ban.reason,
+        user: this.client.users.add(ban.user),
+      }));
+  }
+
   /**
    * Fetches a collection of banned users in this guild.
    * @returns {Promise<Collection<Snowflake, BanInfo>>}
    */
   fetchBans() {
-    return this.client.api.guilds(this.id).bans.get().then(bans =>
-      bans.reduce((collection, ban) => {
-        collection.set(ban.user.id, {
-          reason: ban.reason,
-          user: this.client.users.add(ban.user),
-        });
-        return collection;
-      }, new Collection())
-    );
+    return this.client.api
+      .guilds(this.id)
+      .bans.get()
+      .then(bans =>
+        bans.reduce((collection, ban) => {
+          collection.set(ban.user.id, {
+            reason: ban.reason,
+            user: this.client.users.add(ban.user),
+          });
+          return collection;
+        }, new Collection()),
+      );
   }
 
   /**
@@ -419,11 +649,15 @@ class Guild extends Base {
    *   .catch(console.error);
    */
   fetchIntegrations() {
-    return this.client.api.guilds(this.id).integrations.get().then(data =>
-      data.reduce((collection, integration) =>
-        collection.set(integration.id, new Integration(this.client, integration, this)),
-      new Collection())
-    );
+    return this.client.api
+      .guilds(this.id)
+      .integrations.get()
+      .then(data =>
+        data.reduce(
+          (collection, integration) => collection.set(integration.id, new Integration(this.client, integration, this)),
+          new Collection(),
+        ),
+      );
   }
 
   /**
@@ -440,7 +674,9 @@ class Guild extends Base {
    * @returns {Promise<Guild>}
    */
   createIntegration(data, reason) {
-    return this.client.api.guilds(this.id).integrations.post({ data, reason })
+    return this.client.api
+      .guilds(this.id)
+      .integrations.post({ data, reason })
       .then(() => this);
   }
 
@@ -460,7 +696,9 @@ class Guild extends Base {
    *  .catch(console.error);
    */
   fetchInvites() {
-    return this.client.api.guilds(this.id).invites.get()
+    return this.client.api
+      .guilds(this.id)
+      .invites.get()
       .then(inviteItems => {
         const invites = new Collection();
         for (const inviteItem of inviteItems) {
@@ -487,7 +725,9 @@ class Guild extends Base {
     if (!this.features.includes('VANITY_URL')) {
       return Promise.reject(new Error('VANITY_URL'));
     }
-    return this.client.api.guilds(this.id, 'vanity-url').get()
+    return this.client.api
+      .guilds(this.id, 'vanity-url')
+      .get()
       .then(res => res.code);
   }
 
@@ -501,11 +741,14 @@ class Guild extends Base {
    *   .catch(console.error);
    */
   fetchWebhooks() {
-    return this.client.api.guilds(this.id).webhooks.get().then(data => {
-      const hooks = new Collection();
-      for (const hook of data) hooks.set(hook.id, new Webhook(this.client, hook));
-      return hooks;
-    });
+    return this.client.api
+      .guilds(this.id)
+      .webhooks.get()
+      .then(data => {
+        const hooks = new Collection();
+        for (const hook of data) hooks.set(hook.id, new Webhook(this.client, hook));
+        return hooks;
+      });
   }
 
   /**
@@ -513,11 +756,14 @@ class Guild extends Base {
    * @returns {Promise<Collection<string, VoiceRegion>>}
    */
   fetchVoiceRegions() {
-    return this.client.api.guilds(this.id).regions.get().then(res => {
-      const regions = new Collection();
-      for (const region of res) regions.set(region.id, new VoiceRegion(region));
-      return regions;
-    });
+    return this.client.api
+      .guilds(this.id)
+      .regions.get()
+      .then(res => {
+        const regions = new Collection();
+        for (const region of res) regions.set(region.id, new VoiceRegion(region));
+        return regions;
+      });
   }
 
   /**
@@ -537,17 +783,19 @@ class Guild extends Base {
    *   .catch(console.error);
    */
   fetchEmbed() {
-    return this.client.api.guilds(this.id).embed.get().then(data => ({
-      enabled: data.enabled,
-      channel: data.channel_id ? this.channels.get(data.channel_id) : null,
-    }));
+    return this.client.api
+      .guilds(this.id)
+      .embed.get()
+      .then(data => ({
+        enabled: data.enabled,
+        channel: data.channel_id ? this.channels.cache.get(data.channel_id) : null,
+      }));
   }
 
   /**
    * Fetches audit logs for this guild.
    * @param {Object} [options={}] Options for fetching audit logs
    * @param {Snowflake|GuildAuditLogsEntry} [options.before] Limit to entries from before specified entry
-   * @param {Snowflake|GuildAuditLogsEntry} [options.after] Limit to entries from after specified entry
    * @param {number} [options.limit] Limit number of entries
    * @param {UserResolvable} [options.user] Only show entries involving this user
    * @param {AuditLogAction|number} [options.type] Only show entries involving this action type
@@ -560,16 +808,18 @@ class Guild extends Base {
    */
   fetchAuditLogs(options = {}) {
     if (options.before && options.before instanceof GuildAuditLogs.Entry) options.before = options.before.id;
-    if (options.after && options.after instanceof GuildAuditLogs.Entry) options.after = options.after.id;
     if (typeof options.type === 'string') options.type = GuildAuditLogs.Actions[options.type];
 
-    return this.client.api.guilds(this.id)['audit-logs'].get({ query: {
-      before: options.before,
-      after: options.after,
-      limit: options.limit,
-      user_id: this.client.users.resolveID(options.user),
-      action_type: options.type,
-    } })
+    return this.client.api
+      .guilds(this.id)
+      ['audit-logs'].get({
+        query: {
+          before: options.before,
+          limit: options.limit,
+          user_id: this.client.users.resolveID(options.user),
+          action_type: options.type,
+        },
+      })
       .then(data => GuildAuditLogs.build(this, data));
   }
 
@@ -589,20 +839,25 @@ class Guild extends Base {
   addMember(user, options) {
     user = this.client.users.resolveID(user);
     if (!user) return Promise.reject(new TypeError('INVALID_TYPE', 'user', 'UserResolvable'));
-    if (this.members.has(user)) return Promise.resolve(this.members.get(user));
+    if (this.members.cache.has(user)) return Promise.resolve(this.members.cache.get(user));
     options.access_token = options.accessToken;
     if (options.roles) {
       const roles = [];
       for (let role of options.roles instanceof Collection ? options.roles.values() : options.roles) {
         role = this.roles.resolve(role);
         if (!role) {
-          return Promise.reject(new TypeError('INVALID_TYPE', 'options.roles',
-            'Array or Collection of Roles or Snowflakes', true));
+          return Promise.reject(
+            new TypeError('INVALID_TYPE', 'options.roles', 'Array or Collection of Roles or Snowflakes', true),
+          );
         }
         roles.push(role.id);
       }
+      options.roles = roles;
     }
-    return this.client.api.guilds(this.id).members(user).put({ data: options })
+    return this.client.api
+      .guilds(this.id)
+      .members(user)
+      .put({ data: options })
       .then(data => this.members.add(data));
   }
 
@@ -611,15 +866,17 @@ class Guild extends Base {
    * @typedef {Object} GuildEditData
    * @property {string} [name] The name of the guild
    * @property {string} [region] The region of the guild
-   * @property {number} [verificationLevel] The verification level of the guild
-   * @property {number} [explicitContentFilter] The level of the explicit content filter
+   * @property {VerificationLevel|number} [verificationLevel] The verification level of the guild
+   * @property {ExplicitContentFilterLevel|number} [explicitContentFilter] The level of the explicit content filter
    * @property {ChannelResolvable} [afkChannel] The AFK channel of the guild
    * @property {ChannelResolvable} [systemChannel] The system channel of the guild
    * @property {number} [afkTimeout] The AFK timeout of the guild
    * @property {Base64Resolvable} [icon] The icon of the guild
    * @property {GuildMemberResolvable} [owner] The owner of the guild
    * @property {Base64Resolvable} [splash] The splash screen of the guild
+   * @property {Base64Resolvable} [banner] The banner of the guild
    * @property {DefaultMessageNotifications|number} [defaultMessageNotifications] The default message notifications
+   * @property {SystemChannelFlagsResolvable} [systemChannelFlags] The system channel flags of the guild
    */
 
   /**
@@ -640,7 +897,12 @@ class Guild extends Base {
     const _data = {};
     if (data.name) _data.name = data.name;
     if (data.region) _data.region = data.region;
-    if (typeof data.verificationLevel !== 'undefined') _data.verification_level = Number(data.verificationLevel);
+    if (typeof data.verificationLevel !== 'undefined') {
+      _data.verification_level =
+        typeof data.verificationLevel === 'number'
+          ? Number(data.verificationLevel)
+          : ExplicitContentFilterLevels.indexOf(data.verificationLevel);
+    }
     if (typeof data.afkChannel !== 'undefined') {
       _data.afk_channel_id = this.client.channels.resolveID(data.afkChannel);
     }
@@ -649,23 +911,33 @@ class Guild extends Base {
     }
     if (data.afkTimeout) _data.afk_timeout = Number(data.afkTimeout);
     if (typeof data.icon !== 'undefined') _data.icon = data.icon;
-    if (data.owner) _data.owner_id = this.client.users.resolve(data.owner).id;
+    if (data.owner) _data.owner_id = this.client.users.resolveID(data.owner);
     if (data.splash) _data.splash = data.splash;
+    if (data.banner) _data.banner = data.banner;
     if (typeof data.explicitContentFilter !== 'undefined') {
-      _data.explicit_content_filter = Number(data.explicitContentFilter);
+      _data.explicit_content_filter =
+        typeof data.explicitContentFilter === 'number'
+          ? data.explicitContentFilter
+          : ExplicitContentFilterLevels.indexOf(data.explicitContentFilter);
     }
     if (typeof data.defaultMessageNotifications !== 'undefined') {
-      _data.default_message_notifications = typeof data.defaultMessageNotifications === 'string' ?
-        DefaultMessageNotifications.indexOf(data.defaultMessageNotifications) :
-        Number(data.defaultMessageNotifications);
+      _data.default_message_notifications =
+        typeof data.defaultMessageNotifications === 'string'
+          ? DefaultMessageNotifications.indexOf(data.defaultMessageNotifications)
+          : data.defaultMessageNotifications;
     }
-    return this.client.api.guilds(this.id).patch({ data: _data, reason })
+    if (typeof data.systemChannelFlags !== 'undefined') {
+      _data.system_channel_flags = SystemChannelFlags.resolve(data.systemChannelFlags);
+    }
+    return this.client.api
+      .guilds(this.id)
+      .patch({ data: _data, reason })
       .then(newData => this.client.actions.GuildUpdate.handle(newData).updated);
   }
 
   /**
    * Edits the level of the explicit content filter.
-   * @param {number} explicitContentFilter The new level of the explicit content filter
+   * @param {ExplicitContentFilterLevel|number} explicitContentFilter The new level of the explicit content filter
    * @param {string} [reason] Reason for changing the level of the guild's explicit content filter
    * @returns {Promise<Guild>}
    */
@@ -685,6 +957,16 @@ class Guild extends Base {
   }
   /* eslint-enable max-len */
 
+  /**
+   * Edits the flags of the default message notifications of the guild.
+   * @param {SystemChannelFlagsResolvable} systemChannelFlags The new flags for the default message notifications
+   * @param {string} [reason] Reason for changing the flags of the default message notifications
+   * @returns {Promise<Guild>}
+   */
+  setSystemChannelFlags(systemChannelFlags, reason) {
+    return this.edit({ systemChannelFlags }, reason);
+  }
+
   /**
    * Edits the name of the guild.
    * @param {string} name The new name of the guild
@@ -708,7 +990,7 @@ class Guild extends Base {
    * @example
    * // Edit the guild region
    * guild.setRegion('london')
-   *  .then(updated => console.log(`Updated guild region to ${guild.region}`))
+   *  .then(updated => console.log(`Updated guild region to ${updated.region}`))
    *  .catch(console.error);
    */
   setRegion(region, reason) {
@@ -717,7 +999,7 @@ class Guild extends Base {
 
   /**
    * Edits the verification level of the guild.
-   * @param {number} verificationLevel The new verification level of the guild
+   * @param {VerificationLevel|number} verificationLevel The new verification level of the guild
    * @param {string} [reason] Reason for changing the guild's verification level
    * @returns {Promise<Guild>}
    * @example
@@ -797,7 +1079,7 @@ class Guild extends Base {
    * @returns {Promise<Guild>}
    * @example
    * // Edit the guild owner
-   * guild.setOwner(guild.members.first())
+   * guild.setOwner(guild.members.cache.first())
    *  .then(updated => console.log(`Updated the guild owner to ${updated.owner.displayName}`))
    *  .catch(console.error);
    */
@@ -820,6 +1102,20 @@ class Guild extends Base {
     return this.edit({ splash: await DataResolver.resolveImage(splash), reason });
   }
 
+  /**
+   * Sets a new guild banner.
+   * @param {Base64Resolvable|BufferResolvable} banner The new banner of the guild
+   * @param {string} [reason] Reason for changing the guild's banner
+   * @returns {Promise<Guild>}
+   * @example
+   * guild.setBanner('./banner.png')
+   *  .then(updated => console.log('Updated the guild banner'))
+   *  .catch(console.error);
+   */
+  async setBanner(banner, reason) {
+    return this.edit({ banner: await DataResolver.resolveImage(banner), reason });
+  }
+
   /**
    * The data needed for updating a channel's position.
    * @typedef {Object} ChannelPosition
@@ -842,12 +1138,54 @@ class Guild extends Base {
       position: r.position,
     }));
 
-    return this.client.api.guilds(this.id).channels.patch({ data: updatedChannels }).then(() =>
-      this.client.actions.GuildChannelsPositionUpdate.handle({
-        guild_id: this.id,
-        channels: updatedChannels,
-      }).guild
-    );
+    return this.client.api
+      .guilds(this.id)
+      .channels.patch({ data: updatedChannels })
+      .then(
+        () =>
+          this.client.actions.GuildChannelsPositionUpdate.handle({
+            guild_id: this.id,
+            channels: updatedChannels,
+          }).guild,
+      );
+  }
+
+  /**
+   * The data needed for updating a guild role's position
+   * @typedef {Object} GuildRolePosition
+   * @property {RoleResolveable} role The ID of the role
+   * @property {number} position The position to update
+   */
+
+  /**
+   * Batch-updates the guild's role positions
+   * @param {GuildRolePosition[]} rolePositions Role positions to update
+   * @returns {Promise<Guild>}
+   * @example
+   * guild.setRolePositions([{ role: roleID, position: updatedRoleIndex }])
+   *  .then(guild => console.log(`Role permissions updated for ${guild}`))
+   *  .catch(console.error);
+   */
+  setRolePositions(rolePositions) {
+    // Make sure rolePositions are prepared for API
+    rolePositions = rolePositions.map(o => ({
+      id: o.role,
+      position: o.position,
+    }));
+
+    // Call the API to update role positions
+    return this.client.api
+      .guilds(this.id)
+      .roles.patch({
+        data: rolePositions,
+      })
+      .then(
+        () =>
+          this.client.actions.GuildRolePositionUpdate.handle({
+            guild_id: this.id,
+            roles: rolePositions,
+          }).guild,
+      );
   }
 
   /**
@@ -857,13 +1195,16 @@ class Guild extends Base {
    * @returns {Promise<Guild>}
    */
   setEmbed(embed, reason) {
-    return this.client.api.guilds(this.id).embed.patch({
-      data: {
-        enabled: embed.enabled,
-        channel_id: this.channels.resolveID(embed.channel),
-      },
-      reason,
-    }).then(() => this);
+    return this.client.api
+      .guilds(this.id)
+      .embed.patch({
+        data: {
+          enabled: embed.enabled,
+          channel_id: this.channels.resolveID(embed.channel),
+        },
+        reason,
+      })
+      .then(() => this);
   }
 
   /**
@@ -877,7 +1218,10 @@ class Guild extends Base {
    */
   leave() {
     if (this.ownerID === this.client.user.id) return Promise.reject(new Error('GUILD_OWNED'));
-    return this.client.api.users('@me').guilds(this.id).delete()
+    return this.client.api
+      .users('@me')
+      .guilds(this.id)
+      .delete()
       .then(() => this.client.actions.GuildDelete.handle({ id: this.id }).guild);
   }
 
@@ -891,7 +1235,9 @@ class Guild extends Base {
    *   .catch(console.error);
    */
   delete() {
-    return this.client.api.guilds(this.id).delete()
+    return this.client.api
+      .guilds(this.id)
+      .delete()
       .then(() => this.client.actions.GuildDelete.handle({ id: this.id }).guild);
   }
 
@@ -917,10 +1263,9 @@ class Guild extends Base {
       this.ownerID === guild.ownerID &&
       this.verificationLevel === guild.verificationLevel &&
       this.embedEnabled === guild.embedEnabled &&
-      (this.features === guild.features || (
-        this.features.length === guild.features.length &&
-        this.features.every((feat, i) => feat === guild.features[i]))
-      );
+      (this.features === guild.features ||
+        (this.features.length === guild.features.length &&
+          this.features.every((feat, i) => feat === guild.features[i])));
 
     if (equal) {
       if (this.embedChannel) {
@@ -954,6 +1299,7 @@ class Guild extends Base {
     });
     json.iconURL = this.iconURL();
     json.splashURL = this.splashURL();
+    json.bannerURL = this.bannerURL();
     return json;
   }
 
@@ -963,7 +1309,7 @@ class Guild extends Base {
    * @private
    */
   _sortedRoles() {
-    return Util.discordSort(this.roles);
+    return Util.discordSort(this.roles.cache);
   }
 
   /**
@@ -974,9 +1320,9 @@ class Guild extends Base {
    */
   _sortedChannels(channel) {
     const category = channel.type === ChannelTypes.CATEGORY;
-    return Util.discordSort(this.channels.filter(c =>
-      c.type === channel.type && (category || c.parent === channel.parent)
-    ));
+    return Util.discordSort(
+      this.channels.cache.filter(c => c.type === channel.type && (category || c.parent === channel.parent)),
+    );
   }
 }
 
diff --git a/src/structures/GuildAuditLogs.js b/src/structures/GuildAuditLogs.js
index a5212d5b..b3522b05 100644
--- a/src/structures/GuildAuditLogs.js
+++ b/src/structures/GuildAuditLogs.js
@@ -1,6 +1,10 @@
-const Collection = require('../util/Collection');
-const Snowflake = require('../util/Snowflake');
+'use strict';
+
+const Integration = require('./Integration');
 const Webhook = require('./Webhook');
+const Collection = require('../util/Collection');
+const { PartialTypes } = require('../util/Constants');
+const Snowflake = require('../util/Snowflake');
 const Util = require('../util/Util');
 
 /**
@@ -13,6 +17,7 @@ const Util = require('../util/Util');
  * * WEBHOOK
  * * EMOJI
  * * MESSAGE
+ * * INTEGRATION
  * @typedef {string} AuditLogTargetType
  */
 
@@ -31,6 +36,7 @@ const Targets = {
   WEBHOOK: 'WEBHOOK',
   EMOJI: 'EMOJI',
   MESSAGE: 'MESSAGE',
+  INTEGRATION: 'INTEGRATION',
   UNKNOWN: 'UNKNOWN',
 };
 
@@ -50,6 +56,9 @@ const Targets = {
  * * MEMBER_BAN_REMOVE: 23
  * * MEMBER_UPDATE: 24
  * * MEMBER_ROLE_UPDATE: 25
+ * * MEMBER_MOVE: 26
+ * * MEMBER_DISCONNECT: 27
+ * * BOT_ADD: 28,
  * * ROLE_CREATE: 30
  * * ROLE_UPDATE: 31
  * * ROLE_DELETE: 32
@@ -63,6 +72,12 @@ const Targets = {
  * * EMOJI_UPDATE: 61
  * * EMOJI_DELETE: 62
  * * MESSAGE_DELETE: 72
+ * * MESSAGE_BULK_DELETE: 73
+ * * MESSAGE_PIN: 74
+ * * MESSAGE_UNPIN: 75
+ * * INTEGRATION_CREATE: 80
+ * * INTEGRATION_UPDATE: 81
+ * * INTEGRATION_DELETE: 82
  * @typedef {?number|string} AuditLogAction
  */
 
@@ -86,6 +101,9 @@ const Actions = {
   MEMBER_BAN_REMOVE: 23,
   MEMBER_UPDATE: 24,
   MEMBER_ROLE_UPDATE: 25,
+  MEMBER_MOVE: 26,
+  MEMBER_DISCONNECT: 27,
+  BOT_ADD: 28,
   ROLE_CREATE: 30,
   ROLE_UPDATE: 31,
   ROLE_DELETE: 32,
@@ -99,9 +117,14 @@ const Actions = {
   EMOJI_UPDATE: 61,
   EMOJI_DELETE: 62,
   MESSAGE_DELETE: 72,
+  MESSAGE_BULK_DELETE: 73,
+  MESSAGE_PIN: 74,
+  MESSAGE_UNPIN: 75,
+  INTEGRATION_CREATE: 80,
+  INTEGRATION_UPDATE: 81,
+  INTEGRATION_DELETE: 82,
 };
 
-
 /**
  * Audit logs entries are held in this class.
  */
@@ -120,6 +143,18 @@ class GuildAuditLogs {
       }
     }
 
+    /**
+     * Cached integrations
+     * @type {Collection<Snowflake, Integration>}
+     * @private
+     */
+    this.integrations = new Collection();
+    if (data.integrations) {
+      for (const integration of data.integrations) {
+        this.integrations.set(integration.id, new Integration(guild.client, integration, guild));
+      }
+    }
+
     /**
      * The entries for this guild's audit logs
      * @type {Collection<Snowflake, GuildAuditLogsEntry>}
@@ -148,9 +183,10 @@ class GuildAuditLogs {
    * * An emoji
    * * An invite
    * * A webhook
+   * * An integration
    * * An object with an id key if target was deleted
    * * An object where the keys represent either the new value or the old value
-   * @typedef {?Object|Guild|User|Role|GuildEmoji|Invite|Webhook} AuditLogEntryTarget
+   * @typedef {?Object|Guild|User|Role|GuildEmoji|Invite|Webhook|Integration} AuditLogEntryTarget
    */
 
   /**
@@ -167,6 +203,7 @@ class GuildAuditLogs {
     if (target < 60) return Targets.WEBHOOK;
     if (target < 70) return Targets.EMOJI;
     if (target < 80) return Targets.MESSAGE;
+    if (target < 90) return Targets.INTEGRATION;
     return Targets.UNKNOWN;
   }
 
@@ -185,40 +222,61 @@ class GuildAuditLogs {
    * @returns {AuditLogActionType}
    */
   static actionType(action) {
-    if ([
-      Actions.CHANNEL_CREATE,
-      Actions.CHANNEL_OVERWRITE_CREATE,
-      Actions.MEMBER_BAN_REMOVE,
-      Actions.ROLE_CREATE,
-      Actions.INVITE_CREATE,
-      Actions.WEBHOOK_CREATE,
-      Actions.EMOJI_CREATE,
-    ].includes(action)) return 'CREATE';
+    if (
+      [
+        Actions.CHANNEL_CREATE,
+        Actions.CHANNEL_OVERWRITE_CREATE,
+        Actions.MEMBER_BAN_REMOVE,
+        Actions.BOT_ADD,
+        Actions.ROLE_CREATE,
+        Actions.INVITE_CREATE,
+        Actions.WEBHOOK_CREATE,
+        Actions.EMOJI_CREATE,
+        Actions.MESSAGE_PIN,
+        Actions.INTEGRATION_CREATE,
+      ].includes(action)
+    ) {
+      return 'CREATE';
+    }
 
-    if ([
-      Actions.CHANNEL_DELETE,
-      Actions.CHANNEL_OVERWRITE_DELETE,
-      Actions.MEMBER_KICK,
-      Actions.MEMBER_PRUNE,
-      Actions.MEMBER_BAN_ADD,
-      Actions.ROLE_DELETE,
-      Actions.INVITE_DELETE,
-      Actions.WEBHOOK_DELETE,
-      Actions.EMOJI_DELETE,
-      Actions.MESSAGE_DELETE,
-    ].includes(action)) return 'DELETE';
+    if (
+      [
+        Actions.CHANNEL_DELETE,
+        Actions.CHANNEL_OVERWRITE_DELETE,
+        Actions.MEMBER_KICK,
+        Actions.MEMBER_PRUNE,
+        Actions.MEMBER_BAN_ADD,
+        Actions.MEMBER_DISCONNECT,
+        Actions.ROLE_DELETE,
+        Actions.INVITE_DELETE,
+        Actions.WEBHOOK_DELETE,
+        Actions.EMOJI_DELETE,
+        Actions.MESSAGE_DELETE,
+        Actions.MESSAGE_BULK_DELETE,
+        Actions.MESSAGE_UNPIN,
+        Actions.INTEGRATION_DELETE,
+      ].includes(action)
+    ) {
+      return 'DELETE';
+    }
 
-    if ([
-      Actions.GUILD_UPDATE,
-      Actions.CHANNEL_UPDATE,
-      Actions.CHANNEL_OVERWRITE_UPDATE,
-      Actions.MEMBER_UPDATE,
-      Actions.MEMBER_ROLE_UPDATE,
-      Actions.ROLE_UPDATE,
-      Actions.INVITE_UPDATE,
-      Actions.WEBHOOK_UPDATE,
-      Actions.EMOJI_UPDATE,
-    ].includes(action)) return 'UPDATE';
+    if (
+      [
+        Actions.GUILD_UPDATE,
+        Actions.CHANNEL_UPDATE,
+        Actions.CHANNEL_OVERWRITE_UPDATE,
+        Actions.MEMBER_UPDATE,
+        Actions.MEMBER_ROLE_UPDATE,
+        Actions.MEMBER_MOVE,
+        Actions.ROLE_UPDATE,
+        Actions.INVITE_UPDATE,
+        Actions.WEBHOOK_UPDATE,
+        Actions.EMOJI_UPDATE,
+        Actions.INTEGRATION_UPDATE,
+      ].includes(action)
+    ) {
+      return 'UPDATE';
+    }
 
     return 'ALL';
   }
@@ -262,7 +320,9 @@ class GuildAuditLogsEntry {
      * The user that executed this entry
      * @type {User}
      */
-    this.executor = guild.client.users.get(data.user_id);
+    this.executor = guild.client.options.partials.includes(PartialTypes.USER)
+      ? guild.client.users.add({ id: data.user_id })
+      : guild.client.users.cache.get(data.user_id);
 
     /**
      * An entry in the audit log representing a specific change.
@@ -289,74 +349,133 @@ class GuildAuditLogsEntry {
      * @type {?Object|Role|GuildMember}
      */
     this.extra = null;
-    if (data.options) {
-      if (data.action_type === Actions.MEMBER_PRUNE) {
+    switch (data.action_type) {
+      case Actions.MEMBER_PRUNE:
         this.extra = {
-          removed: data.options.members_removed,
-          days: data.options.delete_member_days,
+          removed: Number(data.options.members_removed),
+          days: Number(data.options.delete_member_days),
         };
-      } else if (data.action_type === Actions.MESSAGE_DELETE) {
+        break;
+
+      case Actions.MEMBER_MOVE:
+      case Actions.MESSAGE_DELETE:
+      case Actions.MESSAGE_BULK_DELETE:
         this.extra = {
-          count: data.options.count,
-          channel: guild.channels.get(data.options.channel_id),
+          channel: guild.channels.cache.get(data.options.channel_id) || { id: data.options.channel_id },
+          count: Number(data.options.count),
         };
-      } else {
+        break;
+
+      case Actions.MESSAGE_PIN:
+      case Actions.MESSAGE_UNPIN:
+        this.extra = {
+          channel: guild.client.channels.cache.get(data.options.channel_id) || { id: data.options.channel_id },
+          messageID: data.options.message_id,
+        };
+        break;
+
+      case Actions.MEMBER_DISCONNECT:
+        this.extra = {
+          count: Number(data.options.count),
+        };
+        break;
+
+      case Actions.CHANNEL_OVERWRITE_CREATE:
+      case Actions.CHANNEL_OVERWRITE_UPDATE:
+      case Actions.CHANNEL_OVERWRITE_DELETE:
         switch (data.options.type) {
           case 'member':
-            this.extra = guild.members.get(data.options.id);
-            if (!this.extra) this.extra = { id: data.options.id };
+            this.extra = guild.members.cache.get(data.options.id) || { id: data.options.id, type: 'member' };
             break;
+
           case 'role':
-            this.extra = guild.roles.get(data.options.id);
-            if (!this.extra) this.extra = { id: data.options.id, name: data.options.role_name };
+            this.extra = guild.roles.cache.get(data.options.id) || {
+              id: data.options.id,
+              name: data.options.role_name,
+              type: 'role',
+            };
             break;
+
           default:
             break;
         }
-      }
+        break;
+
+      default:
+        break;
     }
 
-
+    /**
+     * The target of this entry
+     * @type {?AuditLogEntryTarget}
+     */
+    this.target = null;
     if (targetType === Targets.UNKNOWN) {
-      /**
-       * The target of this entry
-       * @type {AuditLogEntryTarget}
-       */
       this.target = this.changes.reduce((o, c) => {
         o[c.key] = c.new || c.old;
         return o;
       }, {});
       this.target.id = data.target_id;
-    } else if ([Targets.USER, Targets.GUILD].includes(targetType)) {
-      this.target = guild.client[`${targetType.toLowerCase()}s`].get(data.target_id);
+      // MEMBER_DISCONNECT and similar types do not provide a target_id.
+    } else if (targetType === Targets.USER && data.target_id) {
+      this.target = guild.client.options.partials.includes(PartialTypes.USER)
+        ? guild.client.users.add({ id: data.target_id })
+        : guild.client.users.cache.get(data.target_id);
+    } else if (targetType === Targets.GUILD) {
+      this.target = guild.client.guilds.cache.get(data.target_id);
     } else if (targetType === Targets.WEBHOOK) {
-      this.target = logs.webhooks.get(data.target_id) ||
-        new Webhook(guild.client,
-          this.changes.reduce((o, c) => {
+      this.target =
+        logs.webhooks.get(data.target_id) ||
+        new Webhook(
+          guild.client,
+          this.changes.reduce(
+            (o, c) => {
+              o[c.key] = c.new || c.old;
+              return o;
+            },
+            {
+              id: data.target_id,
+              guild_id: guild.id,
+            },
+          ),
+        );
+    } else if (targetType === Targets.INVITE) {
+      this.target = guild.members.fetch(guild.client.user.id).then(me => {
+        if (me.permissions.has('MANAGE_GUILD')) {
+          const change = this.changes.find(c => c.key === 'code');
+          return guild.fetchInvites().then(invites => {
+            this.target = invites.find(i => i.code === (change.new || change.old));
+          });
+        } else {
+          this.target = this.changes.reduce((o, c) => {
             o[c.key] = c.new || c.old;
             return o;
-          }, {
-            id: data.target_id,
-            guild_id: guild.id,
-          }));
-    } else if (targetType === Targets.INVITE) {
-      if (guild.me.permissions.has('MANAGE_GUILD')) {
-        const change = this.changes.find(c => c.key === 'code');
-        this.target = guild.fetchInvites()
-          .then(invites => {
-            this.target = invites.find(i => i.code === (change.new || change.old));
-            return this.target;
-          });
-      } else {
-        this.target = this.changes.reduce((o, c) => {
-          o[c.key] = c.new || c.old;
-          return o;
-        }, {});
-      }
+          }, {});
+          return this.target;
+        }
+      });
     } else if (targetType === Targets.MESSAGE) {
-      this.target = guild.client.users.get(data.target_id);
-    } else {
-      this.target = guild[`${targetType.toLowerCase()}s`].get(data.target_id) || { id: data.target_id };
+      // Discord sends a channel id for the MESSAGE_BULK_DELETE action type.
+      this.target =
+        data.action_type === Actions.MESSAGE_BULK_DELETE
+          ? guild.channels.cache.get(data.target_id) || { id: data.target_id }
+          : guild.client.users.cache.get(data.target_id);
+    } else if (targetType === Targets.INTEGRATION) {
+      this.target =
+        logs.integrations.get(data.target_id) ||
+        new Integration(
+          guild.client,
+          this.changes.reduce(
+            (o, c) => {
+              o[c.key] = c.new || c.old;
+              return o;
+            },
+            { id: data.target_id },
+          ),
+          guild,
+        );
+    } else if (data.target_id) {
+      this.target = guild[`${targetType.toLowerCase()}s`].cache.get(data.target_id) || { id: data.target_id };
     }
   }
 
diff --git a/src/structures/GuildChannel.js b/src/structures/GuildChannel.js
index 3567ea4f..27a646be 100644
--- a/src/structures/GuildChannel.js
+++ b/src/structures/GuildChannel.js
@@ -1,17 +1,28 @@
+'use strict';
+
 const Channel = require('./Channel');
-const Role = require('./Role');
 const Invite = require('./Invite');
 const PermissionOverwrites = require('./PermissionOverwrites');
-const Util = require('../util/Util');
-const Permissions = require('../util/Permissions');
-const Collection = require('../util/Collection');
+const Role = require('./Role');
 const { Error, TypeError } = require('../errors');
+const Collection = require('../util/Collection');
+const Permissions = require('../util/Permissions');
+const Util = require('../util/Util');
 
 /**
- * Represents a guild channel (i.g. a {@link TextChannel}, {@link VoiceChannel} or {@link CategoryChannel}).
+ * Represents a guild channel from any of the following:
+ * - {@link TextChannel}
+ * - {@link VoiceChannel}
+ * - {@link CategoryChannel}
+ * - {@link NewsChannel}
+ * - {@link StoreChannel}
  * @extends {Channel}
  */
 class GuildChannel extends Channel {
+  /**
+   * @param {Guild} guild The guild the guild channel is part of
+   * @param {Object} data The data for the guild channel
+   */
   constructor(guild, data) {
     super(guild.client, data);
 
@@ -61,7 +72,7 @@ class GuildChannel extends Channel {
    * @readonly
    */
   get parent() {
-    return this.guild.channels.get(this.parentID) || null;
+    return this.guild.channels.cache.get(this.parentID) || null;
   }
 
   /**
@@ -74,9 +85,11 @@ class GuildChannel extends Channel {
     if (this.permissionOverwrites.size !== this.parent.permissionOverwrites.size) return false;
     return this.permissionOverwrites.every((value, key) => {
       const testVal = this.parent.permissionOverwrites.get(key);
-      return testVal !== undefined &&
+      return (
+        testVal !== undefined &&
         testVal.deny.bitfield === value.deny.bitfield &&
-        testVal.allow.bitfield === value.allow.bitfield;
+        testVal.allow.bitfield === value.allow.bitfield
+      );
     });
   }
 
@@ -107,7 +120,7 @@ class GuildChannel extends Channel {
     if (!verified) member = this.guild.members.resolve(member);
     if (!member) return [];
 
-    roles = roles || member.roles;
+    roles = roles || member.roles.cache;
     const roleOverwrites = [];
     let memberOverwrites;
     let everyoneOverwrites;
@@ -138,7 +151,7 @@ class GuildChannel extends Channel {
   memberPermissions(member) {
     if (member.id === this.guild.ownerID) return new Permissions(Permissions.ALL).freeze();
 
-    const roles = member.roles;
+    const roles = member.roles.cache;
     const permissions = new Permissions(roles.map(role => role.permissions));
 
     if (permissions.has(Permissions.FLAGS.ADMINISTRATOR)) return new Permissions(Permissions.ALL).freeze();
@@ -177,30 +190,31 @@ class GuildChannel extends Channel {
 
   /**
    * Replaces the permission overwrites in this channel.
-   * @param {Object} [options] Options
-   * @param {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} [options.permissionOverwrites]
+   * @param {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} overwrites
    * Permission overwrites the channel gets updated with
-   * @param {string} [options.reason] Reason for updating the channel overwrites
+   * @param {string} [reason] Reason for updating the channel overwrites
    * @returns {Promise<GuildChannel>}
    * @example
-   * channel.overwritePermissions({
-   * permissionOverwrites: [
+   * channel.overwritePermissions([
    *   {
    *      id: message.author.id,
    *      deny: ['VIEW_CHANNEL'],
    *   },
-   * ],
-   *   reason: 'Needed to change permissions'
-   * });
+   * ], 'Needed to change permissions');
    */
-  overwritePermissions(options = {}) {
-    return this.edit(options).then(() => this);
+  overwritePermissions(overwrites, reason) {
+    if (!Array.isArray(overwrites) && !(overwrites instanceof Collection)) {
+      return Promise.reject(
+        new TypeError('INVALID_TYPE', 'overwrites', 'Array or Collection of Permission Overwrites', true),
+      );
+    }
+    return this.edit({ permissionOverwrites: overwrites, reason }).then(() => this);
   }
 
   /**
    * Updates Overwrites for a user or role in this channel. (creates if non-existent)
    * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
-   * @param {PermissionOverwriteOption} options The options for the update
+   * @param {PermissionOverwriteOptions} options The options for the update
    * @param {string} [reason] Reason for creating/editing this overwrite
    * @returns {Promise<GuildChannel>}
    * @example
@@ -223,7 +237,7 @@ class GuildChannel extends Channel {
   /**
    * Overwrites the permissions for a user or role in this channel. (replaces if existent)
    * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
-   * @param {PermissionOverwriteOption} options The options for the update
+   * @param {PermissionOverwriteOptions} options The options for the update
    * @param {string} [reason] Reason for creating/editing this overwrite
    * @returns {Promise<GuildChannel>}
    * @example
@@ -241,8 +255,12 @@ class GuildChannel extends Channel {
     const type = userOrRole instanceof Role ? 'role' : 'member';
     const { allow, deny } = PermissionOverwrites.resolveOverwriteOptions(options);
 
-    return this.client.api.channels(this.id).permissions[userOrRole.id]
-      .put({ data: { id: userOrRole.id, type, allow: allow.bitfield, deny: deny.bitfield }, reason })
+    return this.client.api
+      .channels(this.id)
+      .permissions[userOrRole.id].put({
+        data: { id: userOrRole.id, type, allow: allow.bitfield, deny: deny.bitfield },
+        reason,
+      })
       .then(() => this);
   }
 
@@ -263,7 +281,7 @@ class GuildChannel extends Channel {
    */
   get members() {
     const members = new Collection();
-    for (const member of this.guild.members.values()) {
+    for (const member of this.guild.members.cache.values()) {
       if (this.permissionsFor(member).has('VIEW_CHANNEL', false)) {
         members.set(member.id, member);
       }
@@ -285,7 +303,7 @@ class GuildChannel extends Channel {
    * Lock the permissions of the channel to what the parent's permissions are
    * @property {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} [permissionOverwrites]
    * Permission overwrites for the channel
-   * @property {number} [rateLimitPerUser] The ratelimit per user for the channel
+   * @property {number} [rateLimitPerUser] The ratelimit per user for the channel in seconds
    */
 
   /**
@@ -301,18 +319,23 @@ class GuildChannel extends Channel {
    */
   async edit(data, reason) {
     if (typeof data.position !== 'undefined') {
-      await Util.setPosition(this, data.position, false,
-        this.guild._sortedChannels(this), this.client.api.guilds(this.guild.id).channels, reason)
-        .then(updatedChannels => {
-          this.client.actions.GuildChannelsPositionUpdate.handle({
-            guild_id: this.guild.id,
-            channels: updatedChannels,
-          });
+      await Util.setPosition(
+        this,
+        data.position,
+        false,
+        this.guild._sortedChannels(this),
+        this.client.api.guilds(this.guild.id).channels,
+        reason,
+      ).then(updatedChannels => {
+        this.client.actions.GuildChannelsPositionUpdate.handle({
+          guild_id: this.guild.id,
+          channels: updatedChannels,
         });
+      });
     }
 
-    const permission_overwrites = data.permissionOverwrites &&
-      data.permissionOverwrites.map(o => PermissionOverwrites.resolve(o, this.guild));
+    const permission_overwrites =
+      data.permissionOverwrites && data.permissionOverwrites.map(o => PermissionOverwrites.resolve(o, this.guild));
 
     const newData = await this.client.api.channels(this.id).patch({
       data: {
@@ -363,10 +386,14 @@ class GuildChannel extends Channel {
    *   .catch(console.error);
    */
   setParent(channel, { lockPermissions = true, reason } = {}) {
-    return this.edit({
-      parentID: channel !== null ? channel.hasOwnProperty('id') ? channel.id : channel : null,
-      lockPermissions,
-    }, reason);
+    return this.edit(
+      {
+        // eslint-disable-next-line no-prototype-builtins
+        parentID: channel !== null ? (channel.hasOwnProperty('id') ? channel.id : channel) : null,
+        lockPermissions,
+      },
+      reason,
+    );
   }
 
   /**
@@ -389,7 +416,7 @@ class GuildChannel extends Channel {
    * @param {number} position The new position for the guild channel
    * @param {Object} [options] Options for setting position
    * @param {boolean} [options.relative=false] Change the position relative to its current value
-   * @param {boolean} [options.reason] Reason for changing the position
+   * @param {string} [options.reason] Reason for changing the position
    * @returns {Promise<GuildChannel>}
    * @example
    * // Set a new channel position
@@ -398,15 +425,20 @@ class GuildChannel extends Channel {
    *   .catch(console.error);
    */
   setPosition(position, { relative, reason } = {}) {
-    return Util.setPosition(this, position, relative,
-      this.guild._sortedChannels(this), this.client.api.guilds(this.guild.id).channels, reason)
-      .then(updatedChannels => {
-        this.client.actions.GuildChannelsPositionUpdate.handle({
-          guild_id: this.guild.id,
-          channels: updatedChannels,
-        });
-        return this;
+    return Util.setPosition(
+      this,
+      position,
+      relative,
+      this.guild._sortedChannels(this),
+      this.client.api.guilds(this.guild.id).channels,
+      reason,
+    ).then(updatedChannels => {
+      this.client.actions.GuildChannelsPositionUpdate.handle({
+        guild_id: this.guild.id,
+        channels: updatedChannels,
       });
+      return this;
+    });
   }
 
   /**
@@ -426,9 +458,17 @@ class GuildChannel extends Channel {
    *   .catch(console.error);
    */
   createInvite({ temporary = false, maxAge = 86400, maxUses = 0, unique, reason } = {}) {
-    return this.client.api.channels(this.id).invites.post({ data: {
-      temporary, max_age: maxAge, max_uses: maxUses, unique,
-    }, reason })
+    return this.client.api
+      .channels(this.id)
+      .invites.post({
+        data: {
+          temporary,
+          max_age: maxAge,
+          max_uses: maxUses,
+          unique,
+        },
+        reason,
+      })
       .then(invite => new Invite(this.client, invite));
   }
 
@@ -447,37 +487,42 @@ class GuildChannel extends Channel {
     return invites;
   }
 
+  /* eslint-disable max-len */
   /**
    * Clones this channel.
    * @param {Object} [options] The options
-   * @param {string} [options.name=this.name] Optional name for the new channel, otherwise it has the name
-   * of this channel
-   * @param {boolean} [options.withPermissions=true] Whether to clone the channel with this channel's
-   * permission overwrites
-   * @param {boolean} [options.withTopic=true] Whether to clone the channel with this channel's topic
+   * @param {string} [options.name=this.name] Name of the new channel
+   * @param {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} [options.permissionOverwrites=this.permissionOverwrites]
+   * Permission overwrites of the new channel
+   * @param {string} [options.type=this.type] Type of the new channel
+   * @param {string} [options.topic=this.topic] Topic of the new channel (only text)
    * @param {boolean} [options.nsfw=this.nsfw] Whether the new channel is nsfw (only text)
    * @param {number} [options.bitrate=this.bitrate] Bitrate of the new channel in bits (only voice)
    * @param {number} [options.userLimit=this.userLimit] Maximum amount of users allowed in the new channel (only voice)
-   * @param {ChannelResolvable} [options.parent=this.parent] The parent of the new channel
+   * @param {number} [options.rateLimitPerUser=ThisType.rateLimitPerUser] Ratelimit per user for the new channel (only text)
+   * @param {ChannelResolvable} [options.parent=this.parent] Parent of the new channel
    * @param {string} [options.reason] Reason for cloning this channel
    * @returns {Promise<GuildChannel>}
    */
   clone(options = {}) {
-    if (typeof options.withPermissions === 'undefined') options.withPermissions = true;
-    if (typeof options.withTopic === 'undefined') options.withTopic = true;
-    Util.mergeDefault({
-      name: this.name,
-      permissionOverwrites: options.withPermissions ? this.permissionOverwrites : [],
-      topic: options.withTopic ? this.topic : undefined,
-      nsfw: this.nsfw,
-      parent: this.parent,
-      bitrate: this.bitrate,
-      userLimit: this.userLimit,
-      reason: null,
-    }, options);
-    options.type = this.type;
+    Util.mergeDefault(
+      {
+        name: this.name,
+        permissionOverwrites: this.permissionOverwrites,
+        topic: this.topic,
+        type: this.type,
+        nsfw: this.nsfw,
+        parent: this.parent,
+        bitrate: this.bitrate,
+        userLimit: this.userLimit,
+        rateLimitPerUser: this.rateLimitPerUser,
+        reason: null,
+      },
+      options,
+    );
     return this.guild.channels.create(options.name, options);
   }
+  /* eslint-enable max-len */
 
   /**
    * Checks if this channel has the same type, topic, position, name, overwrites and ID as another channel.
@@ -486,7 +531,8 @@ class GuildChannel extends Channel {
    * @returns {boolean}
    */
   equals(channel) {
-    let equal = channel &&
+    let equal =
+      channel &&
       this.id === channel.id &&
       this.type === channel.type &&
       this.topic === channel.topic &&
@@ -519,10 +565,21 @@ class GuildChannel extends Channel {
    * @readonly
    */
   get manageable() {
+    if (this.client.user.id === this.guild.ownerID) return true;
+    if (!this.viewable) return false;
+    return this.permissionsFor(this.client.user).has(Permissions.FLAGS.MANAGE_CHANNELS, false);
+  }
+
+  /**
+   * Whether the channel is viewable by the client user
+   * @type {boolean}
+   * @readonly
+   */
+  get viewable() {
     if (this.client.user.id === this.guild.ownerID) return true;
     const permissions = this.permissionsFor(this.client.user);
     if (!permissions) return false;
-    return permissions.has([Permissions.FLAGS.MANAGE_CHANNELS, Permissions.FLAGS.VIEW_CHANNEL], false);
+    return permissions.has(Permissions.FLAGS.VIEW_CHANNEL, false);
   }
 
   /**
@@ -536,7 +593,10 @@ class GuildChannel extends Channel {
    *   .catch(console.error);
    */
   delete(reason) {
-    return this.client.api.channels(this.id).delete({ reason }).then(() => this);
+    return this.client.api
+      .channels(this.id)
+      .delete({ reason })
+      .then(() => this);
   }
 }
 
diff --git a/src/structures/GuildEmoji.js b/src/structures/GuildEmoji.js
index 93e8d275..ea4de455 100644
--- a/src/structures/GuildEmoji.js
+++ b/src/structures/GuildEmoji.js
@@ -1,13 +1,20 @@
-const GuildEmojiRoleStore = require('../stores/GuildEmojiRoleStore');
-const Permissions = require('../util/Permissions');
-const { Error } = require('../errors');
+'use strict';
+
 const Emoji = require('./Emoji');
+const { Error } = require('../errors');
+const GuildEmojiRoleManager = require('../managers/GuildEmojiRoleManager');
+const Permissions = require('../util/Permissions');
 
 /**
  * Represents a custom emoji.
  * @extends {Emoji}
  */
 class GuildEmoji extends Emoji {
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Object} data The data for the guild emoji
+   * @param {Guild} guild The guild the guild emoji is part of
+   */
   constructor(client, data, guild) {
     super(client, data);
 
@@ -17,6 +24,12 @@ class GuildEmoji extends Emoji {
      */
     this.guild = guild;
 
+    /**
+     * The ID of this emoji
+     * @type {Snowflake}
+     * @name GuildEmoji#id
+     */
+
     this._roles = [];
     this._patch(data);
   }
@@ -27,15 +40,24 @@ class GuildEmoji extends Emoji {
     /**
      * Whether or not this emoji requires colons surrounding it
      * @type {boolean}
+     * @name GuildEmoji#requiresColons
      */
     if (typeof data.require_colons !== 'undefined') this.requiresColons = data.require_colons;
 
     /**
      * Whether this emoji is managed by an external service
      * @type {boolean}
+     * @name GuildEmoji#managed
      */
     if (typeof data.managed !== 'undefined') this.managed = data.managed;
 
+    /**
+     * Whether this emoji is available
+     * @type {boolean}
+     * @name GuildEmoji#available
+     */
+    if (typeof data.available !== 'undefined') this.available = data.available;
+
     if (data.roles) this._roles = data.roles;
   }
 
@@ -51,17 +73,17 @@ class GuildEmoji extends Emoji {
    * @readonly
    */
   get deletable() {
-    return !this.managed &&
-      this.guild.me.hasPermission(Permissions.FLAGS.MANAGE_EMOJIS);
+    if (!this.guild.me) throw new Error('GUILD_UNCACHED_ME');
+    return !this.managed && this.guild.me.hasPermission(Permissions.FLAGS.MANAGE_EMOJIS);
   }
 
   /**
-   * A collection of roles this emoji is active for (empty if all), mapped by role ID
-   * @type {GuildEmojiRoleStore<Snowflake, Role>}
+   * A manager for roles this emoji is active for.
+   * @type {GuildEmojiRoleManager}
    * @readonly
    */
   get roles() {
-    return new GuildEmojiRoleStore(this);
+    return new GuildEmojiRoleManager(this);
   }
 
   /**
@@ -71,10 +93,16 @@ class GuildEmoji extends Emoji {
   fetchAuthor() {
     if (this.managed) {
       return Promise.reject(new Error('EMOJI_MANAGED'));
-    } else if (!this.guild.me.permissions.has(Permissions.FLAGS.MANAGE_EMOJIS)) {
-      return Promise.reject(new Error('MISSING_MANAGE_EMOJIS_PERMISSION', this.guild));
+    } else {
+      if (!this.guild.me) return Promise.reject(new Error('GUILD_UNCACHED_ME'));
+      if (!this.guild.me.permissions.has(Permissions.FLAGS.MANAGE_EMOJIS)) {
+        return Promise.reject(new Error('MISSING_MANAGE_EMOJIS_PERMISSION', this.guild));
+      }
     }
-    return this.client.api.guilds(this.guild.id).emojis(this.id).get()
+    return this.client.api
+      .guilds(this.guild.id)
+      .emojis(this.id)
+      .get()
       .then(emoji => this.client.users.add(emoji.user));
   }
 
@@ -98,11 +126,16 @@ class GuildEmoji extends Emoji {
    */
   edit(data, reason) {
     const roles = data.roles ? data.roles.map(r => r.id || r) : undefined;
-    return this.client.api.guilds(this.guild.id).emojis(this.id)
-      .patch({ data: {
-        name: data.name,
-        roles,
-      }, reason })
+    return this.client.api
+      .guilds(this.guild.id)
+      .emojis(this.id)
+      .patch({
+        data: {
+          name: data.name,
+          roles,
+        },
+        reason,
+      })
       .then(newData => {
         const clone = this._clone();
         clone._patch(newData);
@@ -126,7 +159,10 @@ class GuildEmoji extends Emoji {
    * @returns {Promise<GuildEmoji>}
    */
   delete(reason) {
-    return this.client.api.guilds(this.guild.id).emojis(this.id).delete({ reason })
+    return this.client.api
+      .guilds(this.guild.id)
+      .emojis(this.id)
+      .delete({ reason })
       .then(() => this);
   }
 
@@ -142,15 +178,15 @@ class GuildEmoji extends Emoji {
         other.name === this.name &&
         other.managed === this.managed &&
         other.requiresColons === this.requiresColons &&
-        other.roles.size === this.roles.size &&
-        other.roles.every(role => this.roles.has(role.id))
+        other.roles.cache.size === this.roles.cache.size &&
+        other.roles.cache.every(role => this.roles.cache.has(role.id))
       );
     } else {
       return (
         other.id === this.id &&
         other.name === this.name &&
-        other.roles.length === this.roles.size &&
-        other.roles.every(role => this.roles.has(role))
+        other.roles.length === this.roles.cache.size &&
+        other.roles.every(role => this.roles.cache.has(role))
       );
     }
   }
diff --git a/src/structures/GuildMember.js b/src/structures/GuildMember.js
index d910117d..6a8891b2 100644
--- a/src/structures/GuildMember.js
+++ b/src/structures/GuildMember.js
@@ -1,11 +1,13 @@
-const TextBasedChannel = require('./interfaces/TextBasedChannel');
-const Role = require('./Role');
-const Permissions = require('../util/Permissions');
-const GuildMemberRoleStore = require('../stores/GuildMemberRoleStore');
+'use strict';
+
 const Base = require('./Base');
-const VoiceState = require('./VoiceState');
 const { Presence } = require('./Presence');
+const Role = require('./Role');
+const VoiceState = require('./VoiceState');
+const TextBasedChannel = require('./interfaces/TextBasedChannel');
 const { Error } = require('../errors');
+const GuildMemberRoleManager = require('../managers/GuildMemberRoleManager');
+const Permissions = require('../util/Permissions');
 
 /**
  * Represents a member of a guild on Discord.
@@ -13,6 +15,11 @@ const { Error } = require('../errors');
  * @extends {Base}
  */
 class GuildMember extends Base {
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Object} data The data for the guild member
+   * @param {Guild} guild The guild the member is part of
+   */
   constructor(client, data, guild) {
     super(client);
 
@@ -25,13 +32,13 @@ class GuildMember extends Base {
     /**
      * The user that this guild member instance represents
      * @type {User}
+     * @name GuildMember#user
      */
-    this.user = {};
+    if (data.user) this.user = client.users.add(data.user, true);
 
     /**
      * The timestamp the member joined the guild at
      * @type {?number}
-     * @name GuildMember#joinedTimestamp
      */
     this.joinedTimestamp = null;
 
@@ -47,6 +54,12 @@ class GuildMember extends Base {
      */
     this.lastMessageChannelID = null;
 
+    /**
+     * The timestamp of when the member used their Nitro boost on the guild, if it was used
+     * @type {?number}
+     */
+    this.premiumSinceTimestamp = null;
+
     /**
      * Whether the member has been removed from the guild
      * @type {boolean}
@@ -66,9 +79,10 @@ class GuildMember extends Base {
     if (typeof data.nick !== 'undefined') this.nickname = data.nick;
 
     if (data.joined_at) this.joinedTimestamp = new Date(data.joined_at).getTime();
+    if (data.premium_since) this.premiumSinceTimestamp = new Date(data.premium_since).getTime();
 
     if (data.user) this.user = this.guild.client.users.add(data.user);
-    if (data.roles) this.roles._patch(data.roles);
+    if (data.roles) this._roles = data.roles;
   }
 
   _clone() {
@@ -78,12 +92,21 @@ class GuildMember extends Base {
   }
 
   /**
-   * A collection of roles that are applied to this member, mapped by the role ID
-   * @type {GuildMemberRoleStore<Snowflake, Role>}
+   * Whether this GuildMember is a partial
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return !this.joinedTimestamp;
+  }
+
+  /**
+   * A manager for the roles belonging to this member
+   * @type {GuildMemberRoleManager}
    * @readonly
    */
   get roles() {
-    return new GuildMemberRoleStore(this);
+    return new GuildMemberRoleManager(this);
   }
 
   /**
@@ -92,8 +115,8 @@ class GuildMember extends Base {
    * @readonly
    */
   get lastMessage() {
-    const channel = this.guild.channels.get(this.lastMessageChannelID);
-    return (channel && channel.messages.get(this.lastMessageID)) || null;
+    const channel = this.guild.channels.cache.get(this.lastMessageChannelID);
+    return (channel && channel.messages.cache.get(this.lastMessageID)) || null;
   }
 
   /**
@@ -102,7 +125,7 @@ class GuildMember extends Base {
    * @readonly
    */
   get voice() {
-    return this.guild.voiceStates.get(this.id) || new VoiceState(this.guild, { user_id: this.id });
+    return this.guild.voiceStates.cache.get(this.id) || new VoiceState(this.guild, { user_id: this.id });
   }
 
   /**
@@ -114,18 +137,30 @@ class GuildMember extends Base {
     return this.joinedTimestamp ? new Date(this.joinedTimestamp) : null;
   }
 
+  /**
+   * The time of when the member used their Nitro boost on the guild, if it was used
+   * @type {?Date}
+   * @readonly
+   */
+  get premiumSince() {
+    return this.premiumSinceTimestamp ? new Date(this.premiumSinceTimestamp) : null;
+  }
+
   /**
    * The presence of this guild member
    * @type {Presence}
    * @readonly
    */
   get presence() {
-    return this.guild.presences.get(this.id) || new Presence(this.client, {
-      user: {
-        id: this.id,
-      },
-      guild: this.guild,
-    });
+    return (
+      this.guild.presences.cache.get(this.id) ||
+      new Presence(this.client, {
+        user: {
+          id: this.id,
+        },
+        guild: this.guild,
+      })
+    );
   }
 
   /**
@@ -173,7 +208,7 @@ class GuildMember extends Base {
    */
   get permissions() {
     if (this.user.id === this.guild.ownerID) return new Permissions(Permissions.ALL).freeze();
-    return new Permissions(this.roles.map(role => role.permissions)).freeze();
+    return new Permissions(this.roles.cache.map(role => role.permissions)).freeze();
   }
 
   /**
@@ -184,6 +219,8 @@ class GuildMember extends Base {
   get manageable() {
     if (this.user.id === this.guild.ownerID) return false;
     if (this.user.id === this.client.user.id) return false;
+    if (this.client.user.id === this.guild.ownerID) return true;
+    if (!this.guild.me) throw new Error('GUILD_UNCACHED_ME');
     return this.guild.me.roles.highest.comparePositionTo(this.roles.highest) > 0;
   }
 
@@ -227,7 +264,7 @@ class GuildMember extends Base {
    */
   hasPermission(permission, { checkAdmin = true, checkOwner = true } = {}) {
     if (checkOwner && this.user.id === this.guild.ownerID) return true;
-    return this.roles.some(r => r.permissions.has(permission, checkAdmin));
+    return this.roles.cache.some(r => r.permissions.has(permission, checkAdmin));
   }
 
   /**
@@ -237,7 +274,8 @@ class GuildMember extends Base {
    * @property {Collection<Snowflake, Role>|RoleResolvable[]} [roles] The roles or role IDs to apply
    * @property {boolean} [mute] Whether or not the member should be muted
    * @property {boolean} [deaf] Whether or not the member should be deafened
-   * @property {ChannelResolvable} [channel] Channel to move member to (if they are connected to voice)
+   * @property {ChannelResolvable|null} [channel] Channel to move member to (if they are connected to voice), or `null`
+   * if you want to kick them from voice
    */
 
   /**
@@ -246,12 +284,19 @@ class GuildMember extends Base {
    * @param {string} [reason] Reason for editing this user
    * @returns {Promise<GuildMember>}
    */
-  edit(data, reason) {
+  async edit(data, reason) {
     if (data.channel) {
-      data.channel_id = this.client.channels.resolve(data.channel).id;
-      data.channel = null;
+      data.channel = this.guild.channels.resolve(data.channel);
+      if (!data.channel || data.channel.type !== 'voice') {
+        throw new Error('GUILD_VOICE_CHANNEL_RESOLVE');
+      }
+      data.channel_id = data.channel.id;
+      data.channel = undefined;
+    } else if (data.channel === null) {
+      data.channel_id = null;
+      data.channel = undefined;
     }
-    if (data.roles) data.roles = data.roles.map(role => role instanceof Role ? role.id : role);
+    if (data.roles) data.roles = data.roles.map(role => (role instanceof Role ? role.id : role));
     let endpoint = this.client.api.guilds(this.guild.id);
     if (this.user.id === this.client.user.id) {
       const keys = Object.keys(data);
@@ -260,41 +305,12 @@ class GuildMember extends Base {
     } else {
       endpoint = endpoint.members(this.id);
     }
-    return endpoint.patch({ data, reason }).then(() => {
-      const clone = this._clone();
-      data.user = this.user;
-      clone._patch(data);
-      return clone;
-    });
-  }
+    await endpoint.patch({ data, reason });
 
-  /**
-   * Mutes/unmutes this member.
-   * @param {boolean} mute Whether or not the member should be muted
-   * @param {string} [reason] Reason for muting or unmuting
-   * @returns {Promise<GuildMember>}
-   */
-  setMute(mute, reason) {
-    return this.edit({ mute }, reason);
-  }
-
-  /**
-   * Deafens/undeafens this member.
-   * @param {boolean} deaf Whether or not the member should be deafened
-   * @param {string} [reason] Reason for deafening or undeafening
-   * @returns {Promise<GuildMember>}
-   */
-  setDeaf(deaf, reason) {
-    return this.edit({ deaf }, reason);
-  }
-
-  /**
-   * Moves this member to the given channel.
-   * @param {ChannelResolvable} channel The channel to move the member to
-   * @returns {Promise<GuildMember>}
-   */
-  setVoiceChannel(channel) {
-    return this.edit({ channel });
+    const clone = this._clone();
+    data.user = this.user;
+    clone._patch(data);
+    return clone;
   }
 
   /**
@@ -329,7 +345,10 @@ class GuildMember extends Base {
    * @returns {Promise<GuildMember>}
    */
   kick(reason) {
-    return this.client.api.guilds(this.guild.id).members(this.user.id).delete({ reason })
+    return this.client.api
+      .guilds(this.guild.id)
+      .members(this.user.id)
+      .delete({ reason })
       .then(() => this);
   }
 
@@ -349,6 +368,14 @@ class GuildMember extends Base {
     return this.guild.members.ban(this, options);
   }
 
+  /**
+   * Fetches this GuildMember.
+   * @returns {Promise<GuildMember>}
+   */
+  fetch() {
+    return this.guild.members.fetch(this.id, true);
+  }
+
   /**
    * When concatenated with a string, this automatically returns the user's mention instead of the GuildMember object.
    * @returns {string}
diff --git a/src/structures/Integration.js b/src/structures/Integration.js
index 2782008b..49a0227a 100644
--- a/src/structures/Integration.js
+++ b/src/structures/Integration.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Base = require('./Base');
 
 /**
@@ -54,7 +56,7 @@ class Integration extends Base {
      * The role that this integration uses for subscribers
      * @type {Role}
      */
-    this.role = this.guild.roles.get(data.role_id);
+    this.role = this.guild.roles.cache.get(data.role_id);
 
     /**
      * The user for this integration
@@ -96,7 +98,10 @@ class Integration extends Base {
    */
   sync() {
     this.syncing = true;
-    return this.client.api.guilds(this.guild.id).integrations(this.id).post()
+    return this.client.api
+      .guilds(this.guild.id)
+      .integrations(this.id)
+      .post()
       .then(() => {
         this.syncing = false;
         this.syncedAt = Date.now();
@@ -127,7 +132,10 @@ class Integration extends Base {
       data.expireGracePeriod = null;
     }
     // The option enable_emoticons is only available for Twitch at this moment
-    return this.client.api.guilds(this.guild.id).integrations(this.id).patch({ data, reason })
+    return this.client.api
+      .guilds(this.guild.id)
+      .integrations(this.id)
+      .patch({ data, reason })
       .then(() => {
         this._patch(data);
         return this;
@@ -140,7 +148,10 @@ class Integration extends Base {
    * @param {string} [reason] Reason for deleting this integration
    */
   delete(reason) {
-    return this.client.api.guilds(this.guild.id).integrations(this.id).delete({ reason })
+    return this.client.api
+      .guilds(this.guild.id)
+      .integrations(this.id)
+      .delete({ reason })
       .then(() => this);
   }
 
diff --git a/src/structures/Invite.js b/src/structures/Invite.js
index b142d696..68332668 100644
--- a/src/structures/Invite.js
+++ b/src/structures/Invite.js
@@ -1,5 +1,8 @@
-const { Endpoints } = require('../util/Constants');
+'use strict';
+
 const Base = require('./Base');
+const { Endpoints } = require('../util/Constants');
+const Permissions = require('../util/Permissions');
 
 /**
  * Represents an invitation to a guild channel.
@@ -67,6 +70,24 @@ class Invite extends Base {
      */
     this.inviter = data.inviter ? this.client.users.add(data.inviter) : null;
 
+    /**
+     * The target user for this invite
+     * @type {?User}
+     */
+    this.targetUser = data.target_user ? this.client.users.add(data.target_user) : null;
+
+    /**
+     * The type of the target user:
+     * * 1: STREAM
+     * @typedef {number} TargetUser
+     */
+
+    /**
+     * The target user type
+     * @type {?TargetUser}
+     */
+    this.targetUserType = typeof data.target_user_type === 'number' ? data.target_user_type : null;
+
     /**
      * The channel the invite is for
      * @type {Channel}
@@ -89,13 +110,28 @@ class Invite extends Base {
     return this.createdTimestamp ? new Date(this.createdTimestamp) : null;
   }
 
+  /**
+   * Whether the invite is deletable by the client user
+   * @type {boolean}
+   * @readonly
+   */
+  get deletable() {
+    const guild = this.guild;
+    if (!guild || !this.client.guilds.cache.has(guild.id)) return false;
+    if (!guild.me) throw new Error('GUILD_UNCACHED_ME');
+    return (
+      this.channel.permissionsFor(this.client.user).has(Permissions.FLAGS.MANAGE_CHANNELS, false) ||
+      guild.me.permissions.has(Permissions.FLAGS.MANAGE_GUILD)
+    );
+  }
+
   /**
    * The timestamp the invite will expire at
    * @type {?number}
    * @readonly
    */
   get expiresTimestamp() {
-    return this.createdTimestamp && this.maxAge ? this.createdTimestamp + (this.maxAge * 1000) : null;
+    return this.createdTimestamp && this.maxAge ? this.createdTimestamp + this.maxAge * 1000 : null;
   }
 
   /**
@@ -149,6 +185,10 @@ class Invite extends Base {
       guild: 'guildID',
     });
   }
+
+  valueOf() {
+    return this.code;
+  }
 }
 
 module.exports = Invite;
diff --git a/src/structures/Message.js b/src/structures/Message.js
index 88a1707a..630d21e7 100644
--- a/src/structures/Message.js
+++ b/src/structures/Message.js
@@ -1,28 +1,36 @@
-const Mentions = require('./MessageMentions');
+'use strict';
+
+const APIMessage = require('./APIMessage');
+const Base = require('./Base');
+const ClientApplication = require('./ClientApplication');
 const MessageAttachment = require('./MessageAttachment');
 const Embed = require('./MessageEmbed');
+const Mentions = require('./MessageMentions');
 const ReactionCollector = require('./ReactionCollector');
-const ClientApplication = require('./ClientApplication');
-const Util = require('../util/Util');
-const Collection = require('../util/Collection');
-const ReactionStore = require('../stores/ReactionStore');
-const { MessageTypes } = require('../util/Constants');
-const Permissions = require('../util/Permissions');
-const Base = require('./Base');
 const { Error, TypeError } = require('../errors');
-const APIMessage = require('./APIMessage');
+const ReactionManager = require('../managers/ReactionManager');
+const Collection = require('../util/Collection');
+const { MessageTypes } = require('../util/Constants');
+const MessageFlags = require('../util/MessageFlags');
+const Permissions = require('../util/Permissions');
+const Util = require('../util/Util');
 
 /**
  * Represents a message on Discord.
  * @extends {Base}
  */
 class Message extends Base {
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Object} data The data for the message
+   * @param {TextChannel|DMChannel} channel The channel the message was sent in
+   */
   constructor(client, data, channel) {
     super(client);
 
     /**
      * The channel that the message was sent in
-     * @type {TextChannel|DMChannel|GroupDMChannel}
+     * @type {TextChannel|DMChannel}
      */
     this.channel = channel;
 
@@ -35,7 +43,7 @@ class Message extends Base {
     if (data) this._patch(data);
   }
 
-  _patch(data) { // eslint-disable-line complexity
+  _patch(data) {
     /**
      * The ID of the message
      * @type {Snowflake}
@@ -56,9 +64,9 @@ class Message extends Base {
 
     /**
      * The author of the message
-     * @type {User}
+     * @type {?User}
      */
-    this.author = this.client.users.add(data.author, !data.webhook_id);
+    this.author = data.author ? this.client.users.add(data.author, !data.webhook_id) : null;
 
     /**
      * Whether or not this message is pinned
@@ -74,7 +82,9 @@ class Message extends Base {
 
     /**
      * A random number or string used for checking message delivery
-     * @type {string}
+     * <warn>This is only received after the message was sent successfully, and
+     * lost if re-fetched</warn>
+     * @type {?string}
      */
     this.nonce = data.nonce;
 
@@ -82,23 +92,23 @@ class Message extends Base {
      * Whether or not this message was sent by Discord, not actually a user (e.g. pin notifications)
      * @type {boolean}
      */
-    this.system = data.type === 6;
+    this.system = data.type !== 0;
 
     /**
      * A list of embeds in the message - e.g. YouTube Player
      * @type {MessageEmbed[]}
      */
-    this.embeds = data.embeds.map(e => new Embed(e));
+    this.embeds = (data.embeds || []).map(e => new Embed(e));
 
     /**
      * A collection of attachments in the message - e.g. Pictures - mapped by their ID
      * @type {Collection<Snowflake, MessageAttachment>}
      */
     this.attachments = new Collection();
-    for (const attachment of data.attachments) {
-      this.attachments.set(attachment.id, new MessageAttachment(
-        attachment.url, attachment.filename, attachment
-      ));
+    if (data.attachments) {
+      for (const attachment of data.attachments) {
+        this.attachments.set(attachment.id, new MessageAttachment(attachment.url, attachment.filename, attachment));
+      }
     }
 
     /**
@@ -114,10 +124,10 @@ class Message extends Base {
     this.editedTimestamp = data.edited_timestamp ? new Date(data.edited_timestamp).getTime() : null;
 
     /**
-     * A collection of reactions to this message, mapped by the reaction ID
-     * @type {ReactionStore<Snowflake, MessageReaction>}
+     * A manager of the reactions belonging to this message
+     * @type {ReactionManager}
      */
-    this.reactions = new ReactionStore(this);
+    this.reactions = new ReactionManager(this);
     if (data.reactions && data.reactions.length > 0) {
       for (const reaction of data.reactions) {
         this.reactions.add(reaction);
@@ -128,7 +138,7 @@ class Message extends Base {
      * All valid mentions that the message contains
      * @type {MessageMentions}
      */
-    this.mentions = new Mentions(this, data.mentions, data.mention_roles, data.mention_everyone);
+    this.mentions = new Mentions(this, data.mentions, data.mention_roles, data.mention_everyone, data.mention_channels);
 
     /**
      * ID of the webhook that sent the message, if applicable
@@ -146,16 +156,12 @@ class Message extends Base {
      * Group activity
      * @type {?MessageActivity}
      */
-    this.activity = data.activity ? {
-      partyID: data.activity.party_id,
-      type: data.activity.type,
-    } : null;
-
-    /**
-     * Whether this message is a hit in a search
-     * @type {?boolean}
-     */
-    this.hit = typeof data.hit === 'boolean' ? data.hit : null;
+    this.activity = data.activity
+      ? {
+          partyID: data.activity.party_id,
+          type: data.activity.type,
+        }
+      : null;
 
     /**
      * The previous versions of the message, sorted with the most recent first
@@ -169,6 +175,41 @@ class Message extends Base {
     } else if (data.member && this.guild && this.author) {
       this.guild.members.add(Object.assign(data.member, { user: this.author }));
     }
+
+    /**
+     * Flags that are applied to the message
+     * @type {Readonly<MessageFlags>}
+     */
+    this.flags = new MessageFlags(data.flags).freeze();
+
+    /**
+     * Reference data sent in a crossposted message.
+     * @typedef {Object} MessageReference
+     * @property {string} channelID ID of the channel the message was crossposted from
+     * @property {?string} guildID ID of the guild the message was crossposted from
+     * @property {?string} messageID ID of the message that was crossposted
+     */
+
+    /**
+     * Message reference data
+     * @type {?MessageReference}
+     */
+    this.reference = data.message_reference
+      ? {
+          channelID: data.message_reference.channel_id,
+          guildID: data.message_reference.guild_id,
+          messageID: data.message_reference.message_id,
+        }
+      : null;
+  }
+
+  /**
+   * Whether or not this message is a partial
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return typeof this.content !== 'string' || !this.author;
   }
 
   /**
@@ -180,7 +221,7 @@ class Message extends Base {
     const clone = this._clone();
     this._edits.unshift(clone);
 
-    this.editedTimestamp = new Date(data.edited_timestamp).getTime();
+    if ('edited_timestamp' in data) this.editedTimestamp = new Date(data.edited_timestamp).getTime();
     if ('content' in data) this.content = data.content;
     if ('pinned' in data) this.pinned = data.pinned;
     if ('tts' in data) this.tts = data.tts;
@@ -190,9 +231,7 @@ class Message extends Base {
     if ('attachments' in data) {
       this.attachments = new Collection();
       for (const attachment of data.attachments) {
-        this.attachments.set(attachment.id, new MessageAttachment(
-          attachment.url, attachment.filename, attachment
-        ));
+        this.attachments.set(attachment.id, new MessageAttachment(attachment.url, attachment.filename, attachment));
       }
     } else {
       this.attachments = new Collection(this.attachments);
@@ -202,8 +241,11 @@ class Message extends Base {
       this,
       'mentions' in data ? data.mentions : this.mentions.users,
       'mentions_roles' in data ? data.mentions_roles : this.mentions.roles,
-      'mention_everyone' in data ? data.mention_everyone : this.mentions.everyone
+      'mention_everyone' in data ? data.mention_everyone : this.mentions.everyone,
+      'mention_channels' in data ? data.mention_channels : this.mentions.crosspostedChannels,
     );
+
+    this.flags = new MessageFlags('flags' in data ? data.flags : 0).freeze();
   }
 
   /**
@@ -259,7 +301,8 @@ class Message extends Base {
    * @readonly
    */
   get cleanContent() {
-    return Util.cleanContent(this.content, this);
+    // eslint-disable-next-line eqeqeq
+    return this.content != null ? Util.cleanContent(this.content, this) : null;
   }
 
   /**
@@ -334,9 +377,11 @@ class Message extends Base {
    * @readonly
    */
   get deletable() {
-    return !this.deleted && (this.author.id === this.client.user.id || (this.guild &&
-      this.channel.permissionsFor(this.client.user).has(Permissions.FLAGS.MANAGE_MESSAGES, false)
-    ));
+    return (
+      !this.deleted &&
+      (this.author.id === this.client.user.id ||
+        (this.guild && this.channel.permissionsFor(this.client.user).has(Permissions.FLAGS.MANAGE_MESSAGES, false)))
+    );
   }
 
   /**
@@ -345,8 +390,10 @@ class Message extends Base {
    * @readonly
    */
   get pinnable() {
-    return !this.guild ||
-      this.channel.permissionsFor(this.client.user).has(Permissions.FLAGS.MANAGE_MESSAGES, false);
+    return (
+      this.type === 'DEFAULT' &&
+      (!this.guild || this.channel.permissionsFor(this.client.user).has(Permissions.FLAGS.MANAGE_MESSAGES, false))
+    );
   }
 
   /**
@@ -359,7 +406,7 @@ class Message extends Base {
 
   /**
    * Edits the content of the message.
-   * @param {StringResolvable|APIMessage} [content=''] The new content for the message
+   * @param {StringResolvable|APIMessage} [content] The new content for the message
    * @param {MessageEditOptions|MessageEmbed} [options] The options to provide
    * @returns {Promise<Message>}
    * @example
@@ -369,16 +416,13 @@ class Message extends Base {
    *   .catch(console.error);
    */
   edit(content, options) {
-    const { data } = content instanceof APIMessage ?
-      content.resolveData() :
-      APIMessage.create(this, content, options).resolveData();
-    return this.client.api.channels[this.channel.id].messages[this.id]
-      .patch({ data })
-      .then(d => {
-        const clone = this._clone();
-        clone._patch(d);
-        return clone;
-      });
+    const { data } =
+      content instanceof APIMessage ? content.resolveData() : APIMessage.create(this, content, options).resolveData();
+    return this.client.api.channels[this.channel.id].messages[this.id].patch({ data }).then(d => {
+      const clone = this._clone();
+      clone._patch(d);
+      return clone;
+    });
   }
 
   /**
@@ -386,7 +430,10 @@ class Message extends Base {
    * @returns {Promise<Message>}
    */
   pin() {
-    return this.client.api.channels(this.channel.id).pins(this.id).put()
+    return this.client.api
+      .channels(this.channel.id)
+      .pins(this.id)
+      .put()
       .then(() => this);
   }
 
@@ -395,7 +442,10 @@ class Message extends Base {
    * @returns {Promise<Message>}
    */
   unpin() {
-    return this.client.api.channels(this.channel.id).pins(this.id).delete()
+    return this.client.api
+      .channels(this.channel.id)
+      .pins(this.id)
+      .delete()
       .then(() => this);
   }
 
@@ -410,7 +460,7 @@ class Message extends Base {
    *   .catch(console.error);
    * @example
    * // React to a message with a custom emoji
-   * message.react(message.guild.emojis.get('123456789012345678'))
+   * message.react(message.guild.emojis.cache.get('123456789012345678'))
    *   .then(console.log)
    *   .catch(console.error);
    */
@@ -418,14 +468,20 @@ class Message extends Base {
     emoji = this.client.emojis.resolveIdentifier(emoji);
     if (!emoji) throw new TypeError('EMOJI_TYPE');
 
-    return this.client.api.channels(this.channel.id).messages(this.id).reactions(emoji, '@me')
+    return this.client.api
+      .channels(this.channel.id)
+      .messages(this.id)
+      .reactions(emoji, '@me')
       .put()
-      .then(() => this.client.actions.MessageReactionAdd.handle({
-        user: this.client.user,
-        channel: this.channel,
-        message: this,
-        emoji: Util.parseEmoji(emoji),
-      }).reaction);
+      .then(
+        () =>
+          this.client.actions.MessageReactionAdd.handle({
+            user: this.client.user,
+            channel: this.channel,
+            message: this,
+            emoji: Util.parseEmoji(emoji),
+          }).reaction,
+      );
   }
 
   /**
@@ -440,15 +496,11 @@ class Message extends Base {
    *   .then(msg => console.log(`Deleted message from ${msg.author.username}`))
    *   .catch(console.error);
    */
-  delete({ timeout = 0, reason } = {}) {
+  delete(options = {}) {
+    if (typeof options !== 'object') throw new TypeError('INVALID_TYPE', 'options', 'object', true);
+    const { timeout = 0, reason } = options;
     if (timeout <= 0) {
-      return this.client.api.channels(this.channel.id).messages(this.id)
-        .delete({ reason })
-        .then(() =>
-          this.client.actions.MessageDelete.handle({
-            id: this.id,
-            channel_id: this.channel.id,
-          }).message);
+      return this.channel.messages.delete(this.id, reason).then(() => this);
     } else {
       return new Promise(resolve => {
         this.client.setTimeout(() => {
@@ -470,12 +522,21 @@ class Message extends Base {
    *   .catch(console.error);
    */
   reply(content, options) {
-    return this.channel.send(content instanceof APIMessage ?
-      content :
-      APIMessage.transformOptions(content, options, { reply: this.member || this.author })
+    return this.channel.send(
+      content instanceof APIMessage
+        ? content
+        : APIMessage.transformOptions(content, options, { reply: this.member || this.author }),
     );
   }
 
+  /**
+   * Fetch this message.
+   * @returns {Promise<Message>}
+   */
+  fetch() {
+    return this.channel.messages.fetch(this.id, true);
+  }
+
   /**
    * Fetches the webhook used to create this message.
    * @returns {Promise<?Webhook>}
@@ -485,6 +546,23 @@ class Message extends Base {
     return this.client.fetchWebhook(this.webhookID);
   }
 
+  /**
+   * Suppresses or unsuppresses embeds on a message
+   * @param {boolean} [suppress=true] If the embeds should be suppressed or not
+   * @returns {Promise<Message>}
+   */
+  suppressEmbeds(suppress = true) {
+    const flags = new MessageFlags(this.flags.bitfield);
+
+    if (suppress) {
+      flags.add(MessageFlags.FLAGS.SUPPRESS_EMBEDS);
+    } else {
+      flags.remove(MessageFlags.FLAGS.SUPPRESS_EMBEDS);
+    }
+
+    return this.edit({ flags });
+  }
+
   /**
    * Used mainly internally. Whether two messages are identical in properties. If you want to compare messages
    * without checking all the properties, use `message.id === message2.id`, which is much more efficient. This
@@ -498,16 +576,18 @@ class Message extends Base {
     const embedUpdate = !message.author && !message.attachments;
     if (embedUpdate) return this.id === message.id && this.embeds.length === message.embeds.length;
 
-    let equal = this.id === message.id &&
-        this.author.id === message.author.id &&
-        this.content === message.content &&
-        this.tts === message.tts &&
-        this.nonce === message.nonce &&
-        this.embeds.length === message.embeds.length &&
-        this.attachments.length === message.attachments.length;
+    let equal =
+      this.id === message.id &&
+      this.author.id === message.author.id &&
+      this.content === message.content &&
+      this.tts === message.tts &&
+      this.nonce === message.nonce &&
+      this.embeds.length === message.embeds.length &&
+      this.attachments.length === message.attachments.length;
 
     if (equal && rawData) {
-      equal = this.mentions.everyone === message.mentions.everyone &&
+      equal =
+        this.mentions.everyone === message.mentions.everyone &&
         this.createdTimestamp === new Date(rawData.timestamp).getTime() &&
         this.editedTimestamp === new Date(rawData.edited_timestamp).getTime();
     }
diff --git a/src/structures/MessageAttachment.js b/src/structures/MessageAttachment.js
index cce6e487..f5fb723b 100644
--- a/src/structures/MessageAttachment.js
+++ b/src/structures/MessageAttachment.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Util = require('../util/Util');
 
 /**
@@ -79,6 +81,15 @@ class MessageAttachment {
     this.width = typeof data.width !== 'undefined' ? data.width : null;
   }
 
+  /**
+   * Whether or not this attachment has been marked as a spoiler
+   * @type {boolean}
+   * @readonly
+   */
+  get spoiler() {
+    return Util.basename(this.url).startsWith('SPOILER_');
+  }
+
   toJSON() {
     return Util.flatten(this);
   }
diff --git a/src/structures/MessageCollector.js b/src/structures/MessageCollector.js
index 3d9fcf72..f8f3d5ab 100644
--- a/src/structures/MessageCollector.js
+++ b/src/structures/MessageCollector.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Collector = require('./interfaces/Collector');
 const { Events } = require('../util/Constants');
 
@@ -9,11 +11,12 @@ const { Events } = require('../util/Constants');
 
 /**
  * Collects messages on a channel.
+ * Will automatically stop if the channel (`'channelDelete'`) or guild (`'guildDelete'`) are deleted.
  * @extends {Collector}
  */
 class MessageCollector extends Collector {
   /**
-   * @param {TextChannel|DMChannel|GroupDMChannel} channel The channel
+   * @param {TextChannel|DMChannel} channel The channel
    * @param {CollectorFilter} filter The filter to be applied to this collector
    * @param {MessageCollectorOptions} options The options to be applied to this collector
    * @emits MessageCollector#message
@@ -33,20 +36,26 @@ class MessageCollector extends Collector {
      */
     this.received = 0;
 
-    const bulkDeleteListener = (messages => {
+    const bulkDeleteListener = messages => {
       for (const message of messages.values()) this.handleDispose(message);
-    }).bind(this);
+    };
+    this._handleChannelDeletion = this._handleChannelDeletion.bind(this);
+    this._handleGuildDeletion = this._handleGuildDeletion.bind(this);
 
-    this.client.setMaxListeners(this.client.getMaxListeners() + 1);
+    if (this.client.getMaxListeners() !== 0) this.client.setMaxListeners(this.client.getMaxListeners() + 1);
     this.client.on(Events.MESSAGE_CREATE, this.handleCollect);
     this.client.on(Events.MESSAGE_DELETE, this.handleDispose);
     this.client.on(Events.MESSAGE_BULK_DELETE, bulkDeleteListener);
+    this.client.on(Events.CHANNEL_DELETE, this._handleChannelDeletion);
+    this.client.on(Events.GUILD_DELETE, this._handleGuildDeletion);
 
     this.once('end', () => {
       this.client.removeListener(Events.MESSAGE_CREATE, this.handleCollect);
       this.client.removeListener(Events.MESSAGE_DELETE, this.handleDispose);
       this.client.removeListener(Events.MESSAGE_BULK_DELETE, bulkDeleteListener);
-      this.client.setMaxListeners(this.client.getMaxListeners() - 1);
+      this.client.removeListener(Events.CHANNEL_DELETE, this._handleChannelDeletion);
+      this.client.removeListener(Events.GUILD_DELETE, this._handleGuildDeletion);
+      if (this.client.getMaxListeners() !== 0) this.client.setMaxListeners(this.client.getMaxListeners() - 1);
     });
   }
 
@@ -91,6 +100,30 @@ class MessageCollector extends Collector {
     if (this.options.maxProcessed && this.received === this.options.maxProcessed) return 'processedLimit';
     return null;
   }
+
+  /**
+   * Handles checking if the channel has been deleted, and if so, stops the collector with the reason 'channelDelete'.
+   * @private
+   * @param {GuildChannel} channel The channel that was deleted
+   * @returns {void}
+   */
+  _handleChannelDeletion(channel) {
+    if (channel.id === this.channel.id) {
+      this.stop('channelDelete');
+    }
+  }
+
+  /**
+   * Handles checking if the guild has been deleted, and if so, stops the collector with the reason 'guildDelete'.
+   * @private
+   * @param {Guild} guild The guild that was deleted
+   * @returns {void}
+   */
+  _handleGuildDeletion(guild) {
+    if (this.channel.guild && guild.id === this.channel.guild.id) {
+      this.stop('guildDelete');
+    }
+  }
 }
 
 module.exports = MessageCollector;
diff --git a/src/structures/MessageEmbed.js b/src/structures/MessageEmbed.js
index 49ddf30a..eb67b952 100644
--- a/src/structures/MessageEmbed.js
+++ b/src/structures/MessageEmbed.js
@@ -1,5 +1,7 @@
-const Util = require('../util/Util');
+'use strict';
+
 const { RangeError } = require('../errors');
+const Util = require('../util/Util');
 
 /**
  * Represents an embed in a message (image/video preview, rich embed, etc.)
@@ -9,13 +11,15 @@ class MessageEmbed {
     this.setup(data);
   }
 
-  setup(data) { // eslint-disable-line complexity
+  setup(data) {
     /**
      * The type of this embed, either:
+     * * `rich` - a rich embed
      * * `image` - an image embed
      * * `video` - a video embed
+     * * `gifv` - a gifv embed
+     * * `article` - an article embed
      * * `link` - a link embed
-     * * `rich` - a rich embed
      * @type {string}
      */
     this.type = data.type;
@@ -42,7 +46,7 @@ class MessageEmbed {
      * The color of this embed
      * @type {?number}
      */
-    this.color = data.color;
+    this.color = Util.resolveColor(data.color);
 
     /**
      * The timestamp of this embed
@@ -61,92 +65,134 @@ class MessageEmbed {
      * The fields of this embed
      * @type {EmbedField[]}
      */
-    this.fields = data.fields ? data.fields.map(Util.cloneObject) : [];
+    this.fields = data.fields ? this.constructor.normalizeFields(data.fields) : [];
 
     /**
-     * The thumbnail of this embed (if there is one)
-     * @type {?Object}
+     * @typedef {Object} MessageEmbedThumbnail
      * @property {string} url URL for this thumbnail
      * @property {string} proxyURL ProxyURL for this thumbnail
      * @property {number} height Height of this thumbnail
      * @property {number} width Width of this thumbnail
      */
-    this.thumbnail = data.thumbnail ? {
-      url: data.thumbnail.url,
-      proxyURL: data.thumbnail.proxy_url,
-      height: data.thumbnail.height,
-      width: data.thumbnail.width,
-    } : null;
 
     /**
-     * The image of this embed, if there is one
-     * @type {?Object}
+     * The thumbnail of this embed (if there is one)
+     * @type {?MessageEmbedThumbnail}
+     */
+    this.thumbnail = data.thumbnail
+      ? {
+          url: data.thumbnail.url,
+          proxyURL: data.thumbnail.proxyURL || data.thumbnail.proxy_url,
+          height: data.thumbnail.height,
+          width: data.thumbnail.width,
+        }
+      : null;
+
+    /**
+     * @typedef {Object} MessageEmbedImage
      * @property {string} url URL for this image
      * @property {string} proxyURL ProxyURL for this image
      * @property {number} height Height of this image
      * @property {number} width Width of this image
      */
-    this.image = data.image ? {
-      url: data.image.url,
-      proxyURL: data.image.proxy_url,
-      height: data.image.height,
-      width: data.image.width,
-    } : null;
+
+    /**
+     * The image of this embed, if there is one
+     * @type {?MessageEmbedImage}
+     */
+    this.image = data.image
+      ? {
+          url: data.image.url,
+          proxyURL: data.image.proxyURL || data.image.proxy_url,
+          height: data.image.height,
+          width: data.image.width,
+        }
+      : null;
+
+    /**
+     * @typedef {Object} MessageEmbedVideo
+     * @property {string} url URL of this video
+     * @property {string} proxyURL ProxyURL for this video
+     * @property {number} height Height of this video
+     * @property {number} width Width of this video
+     */
 
     /**
      * The video of this embed (if there is one)
-     * @type {?Object}
-     * @property {string} url URL of this video
-     * @property {number} height Height of this video
-     * @property {number} width Width of this video
+     * @type {?MessageEmbedVideo}
      * @readonly
      */
-    this.video = data.video;
+    this.video = data.video
+      ? {
+          url: data.video.url,
+          proxyURL: data.video.proxyURL || data.video.proxy_url,
+          height: data.video.height,
+          width: data.video.width,
+        }
+      : null;
 
     /**
-     * The author of this embed (if there is one)
-     * @type {?Object}
+     * @typedef {Object} MessageEmbedAuthor
      * @property {string} name The name of this author
      * @property {string} url URL of this author
      * @property {string} iconURL URL of the icon for this author
      * @property {string} proxyIconURL Proxied URL of the icon for this author
      */
-    this.author = data.author ? {
-      name: data.author.name,
-      url: data.author.url,
-      iconURL: data.author.iconURL || data.author.icon_url,
-      proxyIconURL: data.author.proxyIconUrl || data.author.proxy_icon_url,
-    } : null;
 
     /**
-     * The provider of this embed (if there is one)
-     * @type {?Object}
+     * The author of this embed (if there is one)
+     * @type {?MessageEmbedAuthor}
+     */
+    this.author = data.author
+      ? {
+          name: data.author.name,
+          url: data.author.url,
+          iconURL: data.author.iconURL || data.author.icon_url,
+          proxyIconURL: data.author.proxyIconURL || data.author.proxy_icon_url,
+        }
+      : null;
+
+    /**
+     * @typedef {Object} MessageEmbedProvider
      * @property {string} name The name of this provider
      * @property {string} url URL of this provider
      */
-    this.provider = data.provider;
 
     /**
-     * The footer of this embed
-     * @type {?Object}
+     * The provider of this embed (if there is one)
+     * @type {?MessageEmbedProvider}
+     */
+    this.provider = data.provider
+      ? {
+          name: data.provider.name,
+          url: data.provider.name,
+        }
+      : null;
+
+    /**
+     * @typedef {Object} MessageEmbedFooter
      * @property {string} text The text of this footer
      * @property {string} iconURL URL of the icon for this footer
      * @property {string} proxyIconURL Proxied URL of the icon for this footer
      */
-    this.footer = data.footer ? {
-      text: data.footer.text,
-      iconURL: data.footer.iconURL || data.footer.icon_url,
-      proxyIconURL: data.footer.proxyIconURL || data.footer.proxy_icon_url,
-    } : null;
+
+    /**
+     * The footer of this embed
+     * @type {?MessageEmbedFooter}
+     */
+    this.footer = data.footer
+      ? {
+          text: data.footer.text,
+          iconURL: data.footer.iconURL || data.footer.icon_url,
+          proxyIconURL: data.footer.proxyIconURL || data.footer.proxy_icon_url,
+        }
+      : null;
 
     /**
      * The files of this embed
      * @type {Array<FileOptions|string|MessageAttachment>}
      */
-    this.files = [];
-    if (data.files) {
-      this.files = data.files;
-    }
+    this.files = data.files || [];
   }
 
   /**
@@ -168,41 +214,51 @@ class MessageEmbed {
   }
 
   /**
-   * Adds a field to the embed (max 25).
-   * @param {StringResolvable} name The name of the field
-   * @param {StringResolvable} value The value of the field
-   * @param {boolean} [inline=false] Set the field to display inline
-   * @returns {MessageEmbed}
+   * The accumulated length for the embed title, description, fields and footer text
+   * @type {number}
+   * @readonly
    */
-  addField(name, value, inline) {
-    this.fields.push(this.constructor.checkField(name, value, inline));
-    return this;
+  get length() {
+    return (
+      (this.title ? this.title.length : 0) +
+      (this.description ? this.description.length : 0) +
+      (this.fields.length >= 1
+        ? this.fields.reduce((prev, curr) => prev + curr.name.length + curr.value.length, 0)
+        : 0) +
+      (this.footer ? this.footer.text.length : 0)
+    );
   }
 
   /**
-   * Convenience function for `<MessageEmbed>.addField('\u200B', '\u200B', inline)`.
-   * @param {boolean} [inline=false] Set the field to display inline
+   * Adds a field to the embed (max 25).
+   * @param {StringResolvable} name The name of this field
+   * @param {StringResolvable} value The value of this field
+   * @param {boolean} [inline=false] If this field will be displayed inline
    * @returns {MessageEmbed}
    */
-  addBlankField(inline) {
-    return this.addField('\u200B', '\u200B', inline);
+  addField(name, value, inline) {
+    return this.addFields({ name, value, inline });
+  }
+
+  /**
+   * Adds fields to the embed (max 25).
+   * @param {...EmbedFieldData|EmbedFieldData[]} fields The fields to add
+   * @returns {MessageEmbed}
+   */
+  addFields(...fields) {
+    this.fields.push(...this.constructor.normalizeFields(fields));
+    return this;
   }
 
   /**
    * Removes, replaces, and inserts fields in the embed (max 25).
    * @param {number} index The index to start at
    * @param {number} deleteCount The number of fields to remove
-   * @param {StringResolvable} [name] The name of the field
-   * @param {StringResolvable} [value] The value of the field
-   * @param {boolean} [inline=false] Set the field to display inline
+   * @param {...EmbedFieldData|EmbedFieldData[]} [fields] The replacing field objects
    * @returns {MessageEmbed}
    */
-  spliceField(index, deleteCount, name, value, inline) {
-    if (name && value) {
-      this.fields.splice(index, deleteCount, this.constructor.checkField(name, value, inline));
-    } else {
-      this.fields.splice(index, deleteCount);
-    }
+  spliceFields(index, deleteCount, ...fields) {
+    this.fields.splice(index, deleteCount, ...this.constructor.normalizeFields(...fields));
     return this;
   }
 
@@ -314,16 +370,11 @@ class MessageEmbed {
     return this;
   }
 
-  toJSON() {
-    return Util.flatten(this, { hexColor: true });
-  }
-
   /**
-   * Transforms the embed object to be processed.
+   * Transforms the embed to a plain object.
    * @returns {Object} The raw data of this embed
-   * @private
    */
-  _apiTransform() {
+  toJSON() {
     return {
       title: this.title,
       type: 'rich',
@@ -334,32 +385,60 @@ class MessageEmbed {
       fields: this.fields,
       thumbnail: this.thumbnail,
       image: this.image,
-      author: this.author ? {
-        name: this.author.name,
-        url: this.author.url,
-        icon_url: this.author.iconURL,
-      } : null,
-      footer: this.footer ? {
-        text: this.footer.text,
-        icon_url: this.footer.iconURL,
-      } : null,
+      author: this.author
+        ? {
+            name: this.author.name,
+            url: this.author.url,
+            icon_url: this.author.iconURL,
+          }
+        : null,
+      footer: this.footer
+        ? {
+            text: this.footer.text,
+            icon_url: this.footer.iconURL,
+          }
+        : null,
     };
   }
 
   /**
-   * Checks for valid field input and resolves strings
+   * Normalizes field input and resolves strings.
    * @param {StringResolvable} name The name of the field
    * @param {StringResolvable} value The value of the field
    * @param {boolean} [inline=false] Set the field to display inline
    * @returns {EmbedField}
    */
-  static checkField(name, value, inline = false) {
+  static normalizeField(name, value, inline = false) {
     name = Util.resolveString(name);
     if (!name) throw new RangeError('EMBED_FIELD_NAME');
     value = Util.resolveString(value);
     if (!value) throw new RangeError('EMBED_FIELD_VALUE');
     return { name, value, inline };
   }
+
+  /**
+   * @typedef {Object} EmbedFieldData
+   * @property {StringResolvable} name The name of this field
+   * @property {StringResolvable} value The value of this field
+   * @property {boolean} [inline] If this field will be displayed inline
+   */
+
+  /**
+   * Normalizes field input and resolves strings.
+   * @param  {...EmbedFieldData|EmbedFieldData[]} fields Fields to normalize
+   * @returns {EmbedField[]}
+   */
+  static normalizeFields(...fields) {
+    return fields
+      .flat(2)
+      .map(field =>
+        this.normalizeField(
+          field && field.name,
+          field && field.value,
+          field && typeof field.inline === 'boolean' ? field.inline : false,
+        ),
+      );
+  }
 }
 
 module.exports = MessageEmbed;
diff --git a/src/structures/MessageMentions.js b/src/structures/MessageMentions.js
index bd99397d..6450f723 100644
--- a/src/structures/MessageMentions.js
+++ b/src/structures/MessageMentions.js
@@ -1,12 +1,15 @@
-const Collection = require('../util/Collection');
-const Util = require('../util/Util');
+'use strict';
+
 const GuildMember = require('./GuildMember');
+const Collection = require('../util/Collection');
+const { ChannelTypes } = require('../util/Constants');
+const Util = require('../util/Util');
 
 /**
  * Keeps track of mentions in a {@link Message}.
  */
 class MessageMentions {
-  constructor(message, users, roles, everyone) {
+  constructor(message, users, roles, everyone, crosspostedChannels) {
     /**
      * The client the message is from
      * @type {Client}
@@ -39,13 +42,17 @@ class MessageMentions {
       if (users instanceof Collection) {
         /**
          * Any users that were mentioned
+         * <info>Order as received from the API, not as they appear in the message content</info>
          * @type {Collection<Snowflake, User>}
          */
         this.users = new Collection(users);
       } else {
         this.users = new Collection();
         for (const mention of users) {
-          let user = message.client.users.add(mention);
+          if (mention.member && message.guild) {
+            message.guild.members.add(Object.assign(mention.member, { user: mention }));
+          }
+          const user = message.client.users.add(mention);
           this.users.set(user.id, user);
         }
       }
@@ -57,13 +64,14 @@ class MessageMentions {
       if (roles instanceof Collection) {
         /**
          * Any roles that were mentioned
+         * <info>Order as received from the API, not as they appear in the message content</info>
          * @type {Collection<Snowflake, Role>}
          */
         this.roles = new Collection(roles);
       } else {
         this.roles = new Collection();
         for (const mention of roles) {
-          const role = message.channel.guild.roles.get(mention);
+          const role = message.channel.guild.roles.cache.get(mention);
           if (role) this.roles.set(role.id, role);
         }
       }
@@ -84,10 +92,45 @@ class MessageMentions {
      * @private
      */
     this._channels = null;
+
+    /**
+     * Crossposted channel data.
+     * @typedef {Object} CrosspostedChannel
+     * @property {string} channelID ID of the mentioned channel
+     * @property {string} guildID ID of the guild that has the channel
+     * @property {string} type Type of the channel
+     * @property {string} name The name of the channel
+     */
+
+    if (crosspostedChannels) {
+      if (crosspostedChannels instanceof Collection) {
+        /**
+         * A collection of crossposted channels
+         * <info>Order as received from the API, not as they appear in the message content</info>
+         * @type {Collection<Snowflake, CrosspostedChannel>}
+         */
+        this.crosspostedChannels = new Collection(crosspostedChannels);
+      } else {
+        this.crosspostedChannels = new Collection();
+        const channelTypes = Object.keys(ChannelTypes);
+        for (const d of crosspostedChannels) {
+          const type = channelTypes[d.type];
+          this.crosspostedChannels.set(d.id, {
+            channelID: d.id,
+            guildID: d.guild_id,
+            type: type ? type.toLowerCase() : 'unknown',
+            name: d.name,
+          });
+        }
+      }
+    } else {
+      this.crosspostedChannels = new Collection();
+    }
   }
 
   /**
    * Any members that were mentioned (only in {@link TextChannel}s)
+   * <info>Order as received from the API, not as they appear in the message content</info>
    * @type {?Collection<Snowflake, GuildMember>}
    * @readonly
    */
@@ -104,6 +147,7 @@ class MessageMentions {
 
   /**
    * Any channels that were mentioned
+   * <info>Order as they appear first in the message content</info>
    * @type {Collection<Snowflake, GuildChannel>}
    * @readonly
    */
@@ -112,7 +156,7 @@ class MessageMentions {
     this._channels = new Collection();
     let matches;
     while ((matches = this.constructor.CHANNELS_PATTERN.exec(this._content)) !== null) {
-      const chan = this.client.channels.get(matches[1]);
+      const chan = this.client.channels.cache.get(matches[1]);
       if (chan) this._channels.set(chan.id, chan);
     }
     return this._channels;
@@ -131,7 +175,7 @@ class MessageMentions {
   has(data, { ignoreDirect = false, ignoreRoles = false, ignoreEveryone = false } = {}) {
     if (!ignoreEveryone && this.everyone) return true;
     if (!ignoreRoles && data instanceof GuildMember) {
-      for (const role of this.roles.values()) if (data.roles.has(role.id)) return true;
+      for (const role of this.roles.values()) if (data.roles.cache.has(role.id)) return true;
     }
 
     if (!ignoreDirect) {
diff --git a/src/structures/MessageReaction.js b/src/structures/MessageReaction.js
index faf3bfbf..fae23916 100644
--- a/src/structures/MessageReaction.js
+++ b/src/structures/MessageReaction.js
@@ -1,13 +1,27 @@
+'use strict';
+
 const GuildEmoji = require('./GuildEmoji');
-const Util = require('../util/Util');
 const ReactionEmoji = require('./ReactionEmoji');
-const ReactionUserStore = require('../stores/ReactionUserStore');
+const ReactionUserManager = require('../managers/ReactionUserManager');
+const Util = require('../util/Util');
 
 /**
  * Represents a reaction to a message.
  */
 class MessageReaction {
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Object} data The data for the message reaction
+   * @param {Message} message The message the reaction refers to
+   */
   constructor(client, data, message) {
+    /**
+     * The client that instantiated this message reaction
+     * @name MessageReaction#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
     /**
      * The message that this reaction refers to
      * @type {Message}
@@ -21,18 +35,36 @@ class MessageReaction {
     this.me = data.me;
 
     /**
-     * The number of people that have given the same reaction
-     * @type {number}
+     * A manager of the users that have given this reaction
+     * @type {ReactionUserManager}
      */
-    this.count = data.count || 0;
-
-    /**
-     * The users that have given this reaction, mapped by their ID
-     * @type {ReactionUserStore<Snowflake, User>}
-     */
-    this.users = new ReactionUserStore(client, undefined, this);
+    this.users = new ReactionUserManager(client, undefined, this);
 
     this._emoji = new ReactionEmoji(this, data.emoji);
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    /**
+     * The number of people that have given the same reaction
+     * @type {?number}
+     */
+    // eslint-disable-next-line eqeqeq
+    if (this.count == undefined) this.count = data.count;
+  }
+
+  /**
+   * Removes all users from this reaction.
+   * @returns {Promise<MessageReaction>}
+   */
+  async remove() {
+    await this.client.api
+      .channels(this.message.channel.id)
+      .messages(this.message.id)
+      .reactions(this._emoji.identifier)
+      .delete();
+    return this;
   }
 
   /**
@@ -46,7 +78,7 @@ class MessageReaction {
     if (this._emoji instanceof GuildEmoji) return this._emoji;
     // Check to see if the emoji has become known to the client
     if (this._emoji.id) {
-      const emojis = this.message.client.emojis;
+      const emojis = this.message.client.emojis.cache;
       if (emojis.has(this._emoji.id)) {
         const emoji = emojis.get(this._emoji.id);
         this._emoji = emoji;
@@ -56,23 +88,41 @@ class MessageReaction {
     return this._emoji;
   }
 
+  /**
+   * Whether or not this reaction is a partial
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return this.count === null;
+  }
+
+  /**
+   * Fetch this reaction.
+   * @returns {Promise<MessageReaction>}
+   */
+  fetch() {
+    return this.message.reactions._fetchReaction(this.emoji, true);
+  }
 
   toJSON() {
     return Util.flatten(this, { emoji: 'emojiID', message: 'messageID' });
   }
 
   _add(user) {
-    this.users.set(user.id, user);
+    if (this.partial) return;
+    this.users.cache.set(user.id, user);
     if (!this.me || user.id !== this.message.client.user.id || this.count === 0) this.count++;
     if (!this.me) this.me = user.id === this.message.client.user.id;
   }
 
   _remove(user) {
-    this.users.delete(user.id);
+    if (this.partial) return;
+    this.users.cache.delete(user.id);
     if (!this.me || user.id !== this.message.client.user.id) this.count--;
     if (user.id === this.message.client.user.id) this.me = false;
-    if (this.count <= 0 && this.users.size === 0) {
-      this.message.reactions.remove(this.emoji.id || this.emoji.name);
+    if (this.count <= 0 && this.users.cache.size === 0) {
+      this.message.reactions.cache.delete(this.emoji.id || this.emoji.name);
     }
   }
 }
diff --git a/src/structures/NewsChannel.js b/src/structures/NewsChannel.js
new file mode 100644
index 00000000..76727fcd
--- /dev/null
+++ b/src/structures/NewsChannel.js
@@ -0,0 +1,18 @@
+'use strict';
+
+const TextChannel = require('./TextChannel');
+
+/**
+ * Represents a guild news channel on Discord.
+ * @extends {TextChannel}
+ */
+class NewsChannel extends TextChannel {
+  _patch(data) {
+    super._patch(data);
+
+    // News channels don't have a rate limit per user, remove it
+    this.rateLimitPerUser = undefined;
+  }
+}
+
+module.exports = NewsChannel;
diff --git a/src/structures/PartialGroupDMChannel.js b/src/structures/PartialGroupDMChannel.js
new file mode 100644
index 00000000..e398f235
--- /dev/null
+++ b/src/structures/PartialGroupDMChannel.js
@@ -0,0 +1,46 @@
+'use strict';
+
+const Channel = require('./Channel');
+const { Error } = require('../errors');
+
+/**
+ * Represents a Partial Group DM Channel on Discord.
+ * @extends {Channel}
+ */
+class PartialGroupDMChannel extends Channel {
+  constructor(client, data) {
+    super(client, data);
+
+    /**
+     * The name of this Group DM Channel
+     * @type {string}
+     */
+    this.name = data.name;
+
+    /**
+     * The hash of the channel icon
+     * @type {?string}
+     */
+    this.icon = data.icon;
+  }
+
+  /**
+   * The URL to this channel's icon.
+   * @param {ImageURLOptions} [options={}] Options for the Image URL
+   * @returns {?string}
+   */
+  iconURL({ format, size } = {}) {
+    if (!this.icon) return null;
+    return this.client.rest.cdn.GDMIcon(this.id, this.icon, format, size);
+  }
+
+  delete() {
+    return Promise.reject(new Error('DELETE_GROUP_DM_CHANNEL'));
+  }
+
+  fetch() {
+    return Promise.reject(new Error('FETCH_GROUP_DM_CHANNEL'));
+  }
+}
+
+module.exports = PartialGroupDMChannel;
diff --git a/src/structures/PermissionOverwrites.js b/src/structures/PermissionOverwrites.js
index b2851786..1c706905 100644
--- a/src/structures/PermissionOverwrites.js
+++ b/src/structures/PermissionOverwrites.js
@@ -1,7 +1,9 @@
+'use strict';
+
 const Role = require('./Role');
+const { TypeError } = require('../errors');
 const Permissions = require('../util/Permissions');
 const Util = require('../util/Util');
-const { TypeError } = require('../errors');
 
 /**
  * Represents a permission overwrite for a role or member in a guild channel.
@@ -54,7 +56,7 @@ class PermissionOverwrites {
 
   /**
    * Updates this permissionOverwrites.
-   * @param {PermissionOverwriteOption} options The options for the update
+   * @param {PermissionOverwriteOptions} options The options for the update
    * @param {string} [reason] Reason for creating/editing this overwrite
    * @returns {Promise<PermissionOverwrites>}
    * @example
@@ -68,8 +70,12 @@ class PermissionOverwrites {
   update(options, reason) {
     const { allow, deny } = this.constructor.resolveOverwriteOptions(options, this);
 
-    return this.channel.client.api.channels(this.channel.id).permissions[this.id]
-      .put({ data: { id: this.id, type: this.type, allow: allow.bitfield, deny: deny.bitfield }, reason })
+    return this.channel.client.api
+      .channels(this.channel.id)
+      .permissions[this.id].put({
+        data: { id: this.id, type: this.type, allow: allow.bitfield, deny: deny.bitfield },
+        reason,
+      })
       .then(() => this);
   }
 
@@ -79,9 +85,7 @@ class PermissionOverwrites {
    * @returns {Promise<PermissionOverwrites>}
    */
   delete(reason) {
-    return this.channel.client.api.channels[this.channel.id].permissions[this.id]
-      .delete({ reason })
-      .then(() => this);
+    return this.channel.client.api.channels[this.channel.id].permissions[this.id].delete({ reason }).then(() => this);
   }
 
   toJSON() {
@@ -97,7 +101,7 @@ class PermissionOverwrites {
    *  'ATTACH_FILES': false,
    * }
    * ```
-   * @typedef {Object} PermissionOverwriteOption
+   * @typedef {Object} PermissionOverwriteOptions
    */
 
   /**
@@ -108,7 +112,7 @@ class PermissionOverwrites {
 
   /**
    * Deletes this Permission Overwrite.
-   * @param {PermissionOverwriteOption} options The options for the update
+   * @param {PermissionOverwriteOptions} options The options for the update
    * @param {Object} initialPermissions The initial permissions
    * @param {PermissionResolvable} initialPermissions.allow Initial allowed permissions
    * @param {PermissionResolvable} initialPermissions.deny Initial denied permissions
@@ -166,10 +170,7 @@ class PermissionOverwrites {
   static resolve(overwrite, guild) {
     if (overwrite instanceof this) return overwrite.toJSON();
     if (typeof overwrite.id === 'string' && ['role', 'member'].includes(overwrite.type)) {
-      return { ...overwrite,
-        allow: Permissions.resolve(overwrite.allow),
-        deny: Permissions.resolve(overwrite.deny),
-      };
+      return { ...overwrite, allow: Permissions.resolve(overwrite.allow), deny: Permissions.resolve(overwrite.deny) };
     }
 
     const userOrRole = guild.roles.resolve(overwrite.id) || guild.client.users.resolve(overwrite.id);
diff --git a/src/structures/Presence.js b/src/structures/Presence.js
index 33998134..ac07a543 100644
--- a/src/structures/Presence.js
+++ b/src/structures/Presence.js
@@ -1,6 +1,9 @@
-const Util = require('../util/Util');
+'use strict';
+
+const Emoji = require('./Emoji');
 const ActivityFlags = require('../util/ActivityFlags');
 const { ActivityTypes } = require('../util/Constants');
+const Util = require('../util/Util');
 
 /**
  * Activity sent in a message.
@@ -9,58 +12,106 @@ const { ActivityTypes } = require('../util/Constants');
  * @property {number} [type] Type of activity sent
  */
 
+/**
+ * The status of this presence:
+ * * **`online`** - user is online
+ * * **`idle`** - user is AFK
+ * * **`offline`** - user is offline or invisible
+ * * **`dnd`** - user is in Do Not Disturb
+ * @typedef {string} PresenceStatus
+ */
+
+/**
+ * The status of this presence:
+ * * **`online`** - user is online
+ * * **`idle`** - user is AFK
+ * * **`dnd`** - user is in Do Not Disturb
+ * @typedef {string} ClientPresenceStatus
+ */
+
 /**
  * Represents a user's presence.
  */
 class Presence {
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Object} [data={}] The data for the presence
+   */
   constructor(client, data = {}) {
+    /**
+     * The client that instantiated this
+     * @name Presence#client
+     * @type {Client}
+     * @readonly
+     */
     Object.defineProperty(this, 'client', { value: client });
+    /**
+     * The user ID of this presence
+     * @type {Snowflake}
+     */
     this.userID = data.user.id;
-    this.guild = data.guild;
+
+    /**
+     * The guild of this presence
+     * @type {?Guild}
+     */
+    this.guild = data.guild || null;
+
     this.patch(data);
   }
 
   /**
    * The user of this presence
    * @type {?User}
+   * @readonly
    */
   get user() {
-    return this.client.users.get(this.userID) || null;
+    return this.client.users.cache.get(this.userID) || null;
   }
 
   /**
    * The member of this presence
    * @type {?GuildMember}
+   * @readonly
    */
   get member() {
-    return this.guild.members.get(this.userID) || null;
+    return this.guild.members.cache.get(this.userID) || null;
   }
 
   patch(data) {
     /**
-     * The status of the presence:
-     *
-     * * **`online`** - user is online
-     * * **`offline`** - user is offline or invisible
-     * * **`idle`** - user is AFK
-     * * **`dnd`** - user is in Do Not Disturb
-     * @type {string}
+     * The status of this presence
+     * @type {PresenceStatus}
      */
     this.status = data.status || this.status || 'offline';
 
-    const activity = data.game || data.activity;
+    if (data.activities) {
+      /**
+       * The activities of this presence
+       * @type {Activity[]}
+       */
+      this.activities = data.activities.map(activity => new Activity(this, activity));
+    } else if (data.activity || data.game) {
+      this.activities = [new Activity(this, data.game || data.activity)];
+    } else {
+      this.activities = [];
+    }
+
     /**
-     * The activity of the presence
-     * @type {?Activity}
+     * The devices this presence is on
+     * @type {?Object}
+     * @property {?ClientPresenceStatus} web The current presence in the web application
+     * @property {?ClientPresenceStatus} mobile The current presence in the mobile application
+     * @property {?ClientPresenceStatus} desktop The current presence in the desktop application
      */
-    this.activity = activity ? new Activity(this, activity) : null;
+    this.clientStatus = data.client_status || null;
 
     return this;
   }
 
   _clone() {
     const clone = Object.assign(Object.create(this), this);
-    if (this.activity) clone.activity = this.activity._clone();
+    if (this.activities) clone.activities = this.activities.map(activity => activity._clone());
     return clone;
   }
 
@@ -70,10 +121,15 @@ class Presence {
    * @returns {boolean}
    */
   equals(presence) {
-    return this === presence || (
-      presence &&
-      this.status === presence.status &&
-      this.activity ? this.activity.equals(presence.activity) : !presence.activity
+    return (
+      this === presence ||
+      (presence &&
+        this.status === presence.status &&
+        this.activities.length === presence.activities.length &&
+        this.activities.every((activity, index) => activity.equals(presence.activities[index])) &&
+        this.clientStatus.web === presence.clientStatus.web &&
+        this.clientStatus.mobile === presence.clientStatus.mobile &&
+        this.clientStatus.desktop === presence.clientStatus.desktop)
     );
   }
 
@@ -131,10 +187,12 @@ class Activity {
      * @prop {?Date} start When the activity started
      * @prop {?Date} end When the activity will end
      */
-    this.timestamps = data.timestamps ? {
-      start: data.timestamps.start ? new Date(Number(data.timestamps.start)) : null,
-      end: data.timestamps.end ? new Date(Number(data.timestamps.end)) : null,
-    } : null;
+    this.timestamps = data.timestamps
+      ? {
+          start: data.timestamps.start ? new Date(Number(data.timestamps.start)) : null,
+          end: data.timestamps.end ? new Date(Number(data.timestamps.end)) : null,
+        }
+      : null;
 
     /**
      * Party of the activity
@@ -157,6 +215,18 @@ class Activity {
      * @type {Readonly<ActivityFlags>}
      */
     this.flags = new ActivityFlags(data.flags).freeze();
+
+    /**
+     * Emoji for a custom activity
+     * @type {?Emoji}
+     */
+    this.emoji = data.emoji ? new Emoji(presence.client, data.emoji) : null;
+
+    /**
+     * Creation date of the activity
+     * @type {number}
+     */
+    this.createdTimestamp = new Date(data.created_at).getTime();
   }
 
   /**
@@ -165,14 +235,21 @@ class Activity {
    * @returns {boolean}
    */
   equals(activity) {
-    return this === activity || (
-      activity &&
-      this.name === activity.name &&
-      this.type === activity.type &&
-      this.url === activity.url
+    return (
+      this === activity ||
+      (activity && this.name === activity.name && this.type === activity.type && this.url === activity.url)
     );
   }
 
+  /**
+   * The time the activity was created at
+   * @type {Date}
+   * @readonly
+   */
+  get createdAt() {
+    return new Date(this.createdTimestamp);
+  }
+
   /**
    * When concatenated with a string, this automatically returns the activities' name instead of the Activity object.
    * @returns {string}
@@ -227,8 +304,10 @@ class RichPresenceAssets {
    */
   smallImageURL({ format, size } = {}) {
     if (!this.smallImage) return null;
-    return this.activity.presence.client.rest.cdn
-      .AppAsset(this.activity.applicationID, this.smallImage, { format, size });
+    return this.activity.presence.client.rest.cdn.AppAsset(this.activity.applicationID, this.smallImage, {
+      format,
+      size,
+    });
   }
 
   /**
@@ -242,9 +321,13 @@ class RichPresenceAssets {
     if (!this.largeImage) return null;
     if (/^spotify:/.test(this.largeImage)) {
       return `https://i.scdn.co/image/${this.largeImage.slice(8)}`;
+    } else if (/^twitch:/.test(this.largeImage)) {
+      return `https://static-cdn.jtvnw.net/previews-ttv/live_user_${this.largeImage.slice(7)}.png`;
     }
-    return this.activity.presence.client.rest.cdn
-      .AppAsset(this.activity.applicationID, this.largeImage, { format, size });
+    return this.activity.presence.client.rest.cdn.AppAsset(this.activity.applicationID, this.largeImage, {
+      format,
+      size,
+    });
   }
 }
 
diff --git a/src/structures/ReactionCollector.js b/src/structures/ReactionCollector.js
index 5c4532e2..6da9d17d 100644
--- a/src/structures/ReactionCollector.js
+++ b/src/structures/ReactionCollector.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Collector = require('./interfaces/Collector');
 const Collection = require('../util/Collection');
 const { Events } = require('../util/Constants');
@@ -11,6 +13,8 @@ const { Events } = require('../util/Constants');
 
 /**
  * Collects reactions on messages.
+ * Will automatically stop if the message (`'messageDelete'`),
+ * channel (`'channelDelete'`), or guild (`'guildDelete'`) are deleted.
  * @extends {Collector}
  */
 class ReactionCollector extends Collector {
@@ -41,17 +45,26 @@ class ReactionCollector extends Collector {
     this.total = 0;
 
     this.empty = this.empty.bind(this);
+    this._handleChannelDeletion = this._handleChannelDeletion.bind(this);
+    this._handleGuildDeletion = this._handleGuildDeletion.bind(this);
+    this._handleMessageDeletion = this._handleMessageDeletion.bind(this);
 
-    this.client.setMaxListeners(this.client.getMaxListeners() + 1);
+    if (this.client.getMaxListeners() !== 0) this.client.setMaxListeners(this.client.getMaxListeners() + 1);
     this.client.on(Events.MESSAGE_REACTION_ADD, this.handleCollect);
     this.client.on(Events.MESSAGE_REACTION_REMOVE, this.handleDispose);
     this.client.on(Events.MESSAGE_REACTION_REMOVE_ALL, this.empty);
+    this.client.on(Events.MESSAGE_DELETE, this._handleMessageDeletion);
+    this.client.on(Events.CHANNEL_DELETE, this._handleChannelDeletion);
+    this.client.on(Events.GUILD_DELETE, this._handleGuildDeletion);
 
     this.once('end', () => {
       this.client.removeListener(Events.MESSAGE_REACTION_ADD, this.handleCollect);
       this.client.removeListener(Events.MESSAGE_REACTION_REMOVE, this.handleDispose);
       this.client.removeListener(Events.MESSAGE_REACTION_REMOVE_ALL, this.empty);
-      this.client.setMaxListeners(this.client.getMaxListeners() - 1);
+      this.client.removeListener(Events.MESSAGE_DELETE, this._handleMessageDeletion);
+      this.client.removeListener(Events.CHANNEL_DELETE, this._handleChannelDeletion);
+      this.client.removeListener(Events.GUILD_DELETE, this._handleGuildDeletion);
+      if (this.client.getMaxListeners() !== 0) this.client.setMaxListeners(this.client.getMaxListeners() - 1);
     });
 
     this.on('collect', (reaction, user) => {
@@ -61,7 +74,7 @@ class ReactionCollector extends Collector {
 
     this.on('remove', (reaction, user) => {
       this.total--;
-      if (!this.collected.some(r => r.users.has(user.id))) this.users.delete(user.id);
+      if (!this.collected.some(r => r.users.cache.has(user.id))) this.users.delete(user.id);
     });
   }
 
@@ -105,8 +118,7 @@ class ReactionCollector extends Collector {
      * @param {MessageReaction} reaction The reaction that was removed
      * @param {User} user The user that removed the reaction
      */
-    if (this.collected.has(ReactionCollector.key(reaction)) &&
-        this.users.has(user.id)) {
+    if (this.collected.has(ReactionCollector.key(reaction)) && this.users.has(user.id)) {
       this.emit('remove', reaction, user);
     }
     return reaction.count ? null : ReactionCollector.key(reaction);
@@ -129,6 +141,42 @@ class ReactionCollector extends Collector {
     return null;
   }
 
+  /**
+   * Handles checking if the message has been deleted, and if so, stops the collector with the reason 'messageDelete'.
+   * @private
+   * @param {Message} message The message that was deleted
+   * @returns {void}
+   */
+  _handleMessageDeletion(message) {
+    if (message.id === this.message.id) {
+      this.stop('messageDelete');
+    }
+  }
+
+  /**
+   * Handles checking if the channel has been deleted, and if so, stops the collector with the reason 'channelDelete'.
+   * @private
+   * @param {GuildChannel} channel The channel that was deleted
+   * @returns {void}
+   */
+  _handleChannelDeletion(channel) {
+    if (channel.id === this.message.channel.id) {
+      this.stop('channelDelete');
+    }
+  }
+
+  /**
+   * Handles checking if the guild has been deleted, and if so, stops the collector with the reason 'guildDelete'.
+   * @private
+   * @param {Guild} guild The guild that was deleted
+   * @returns {void}
+   */
+  _handleGuildDeletion(guild) {
+    if (this.message.guild && guild.id === this.message.guild.id) {
+      this.stop('guildDelete');
+    }
+  }
+
   /**
    * Gets the collector key for a reaction.
    * @param {MessageReaction} reaction The message reaction to get the key for
diff --git a/src/structures/ReactionEmoji.js b/src/structures/ReactionEmoji.js
index c6ea8d68..5c4bc134 100644
--- a/src/structures/ReactionEmoji.js
+++ b/src/structures/ReactionEmoji.js
@@ -1,5 +1,7 @@
-const Util = require('../util/Util');
+'use strict';
+
 const Emoji = require('./Emoji');
+const Util = require('../util/Util');
 
 /**
  * Represents a limited emoji set used for both custom and unicode emojis. Custom emojis
diff --git a/src/structures/Role.js b/src/structures/Role.js
index 18f68f2f..bba198ec 100644
--- a/src/structures/Role.js
+++ b/src/structures/Role.js
@@ -1,14 +1,21 @@
-const Snowflake = require('../util/Snowflake');
-const Permissions = require('../util/Permissions');
-const Util = require('../util/Util');
+'use strict';
+
 const Base = require('./Base');
 const { Error, TypeError } = require('../errors');
+const Permissions = require('../util/Permissions');
+const Snowflake = require('../util/Snowflake');
+const Util = require('../util/Util');
 
 /**
  * Represents a role on Discord.
  * @extends {Base}
  */
 class Role extends Base {
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Object} data The data for the role
+   * @param {Guild} guild The guild the role is part of
+   */
   constructor(client, data, guild) {
     super(client);
 
@@ -110,7 +117,7 @@ class Role extends Base {
    * @readonly
    */
   get members() {
-    return this.guild.members.filter(m => m.roles.has(this.id));
+    return this.guild.members.cache.filter(m => m.roles.cache.has(this.id));
   }
 
   /**
@@ -143,7 +150,7 @@ class Role extends Base {
    */
   comparePositionTo(role) {
     role = this.guild.roles.resolve(role);
-    if (!role) return Promise.reject(new TypeError('INVALID_TYPE', 'role', 'Role nor a Snowflake'));
+    if (!role) throw new TypeError('INVALID_TYPE', 'role', 'Role nor a Snowflake');
     return this.constructor.comparePositions(this, role);
   }
 
@@ -170,28 +177,34 @@ class Role extends Base {
    *   .catch(console.error);
    */
   async edit(data, reason) {
-    if (data.permissions) data.permissions = Permissions.resolve(data.permissions);
+    if (typeof data.permissions !== 'undefined') data.permissions = Permissions.resolve(data.permissions);
     else data.permissions = this.permissions.bitfield;
     if (typeof data.position !== 'undefined') {
-      await Util.setPosition(this, data.position, false, this.guild._sortedRoles(),
-        this.client.api.guilds(this.guild.id).roles, reason)
-        .then(updatedRoles => {
-          this.client.actions.GuildRolesPositionUpdate.handle({
-            guild_id: this.guild.id,
-            roles: updatedRoles,
-          });
+      await Util.setPosition(
+        this,
+        data.position,
+        false,
+        this.guild._sortedRoles(),
+        this.client.api.guilds(this.guild.id).roles,
+        reason,
+      ).then(updatedRoles => {
+        this.client.actions.GuildRolesPositionUpdate.handle({
+          guild_id: this.guild.id,
+          roles: updatedRoles,
         });
+      });
     }
-    return this.client.api.guilds[this.guild.id].roles[this.id].patch({
-      data: {
-        name: data.name || this.name,
-        color: data.color !== null ? Util.resolveColor(data.color || this.color) : null,
-        hoist: typeof data.hoist !== 'undefined' ? data.hoist : this.hoist,
-        permissions: data.permissions,
-        mentionable: typeof data.mentionable !== 'undefined' ? data.mentionable : this.mentionable,
-      },
-      reason,
-    })
+    return this.client.api.guilds[this.guild.id].roles[this.id]
+      .patch({
+        data: {
+          name: data.name || this.name,
+          color: data.color !== null ? Util.resolveColor(data.color || this.color) : null,
+          hoist: typeof data.hoist !== 'undefined' ? data.hoist : this.hoist,
+          permissions: data.permissions,
+          mentionable: typeof data.mentionable !== 'undefined' ? data.mentionable : this.mentionable,
+        },
+        reason,
+      })
       .then(role => {
         const clone = this._clone();
         clone._patch(role);
@@ -296,7 +309,7 @@ class Role extends Base {
    * @param {number} position The position of the role
    * @param {Object} [options] Options for setting position
    * @param {boolean} [options.relative=false] Change the position relative to its current value
-   * @param {boolean} [options.reason] Reason for changing the position
+   * @param {string} [options.reason] Reason for changing the position
    * @returns {Promise<Role>}
    * @example
    * // Set the position of the role
@@ -305,15 +318,20 @@ class Role extends Base {
    *   .catch(console.error);
    */
   setPosition(position, { relative, reason } = {}) {
-    return Util.setPosition(this, position, relative,
-      this.guild._sortedRoles(), this.client.api.guilds(this.guild.id).roles, reason)
-      .then(updatedRoles => {
-        this.client.actions.GuildRolesPositionUpdate.handle({
-          guild_id: this.guild.id,
-          roles: updatedRoles,
-        });
-        return this;
+    return Util.setPosition(
+      this,
+      position,
+      relative,
+      this.guild._sortedRoles(),
+      this.client.api.guilds(this.guild.id).roles,
+      reason,
+    ).then(updatedRoles => {
+      this.client.actions.GuildRolesPositionUpdate.handle({
+        guild_id: this.guild.id,
+        roles: updatedRoles,
       });
+      return this;
+    });
   }
 
   /**
@@ -327,11 +345,10 @@ class Role extends Base {
    *   .catch(console.error);
    */
   delete(reason) {
-    return this.client.api.guilds[this.guild.id].roles[this.id].delete({ reason })
-      .then(() => {
-        this.client.actions.GuildRoleDelete.handle({ guild_id: this.guild.id, role_id: this.id });
-        return this;
-      });
+    return this.client.api.guilds[this.guild.id].roles[this.id].delete({ reason }).then(() => {
+      this.client.actions.GuildRoleDelete.handle({ guild_id: this.guild.id, role_id: this.id });
+      return this;
+    });
   }
 
   /**
@@ -342,14 +359,16 @@ class Role extends Base {
    * @returns {boolean}
    */
   equals(role) {
-    return role &&
+    return (
+      role &&
       this.id === role.id &&
       this.name === role.name &&
       this.color === role.color &&
       this.hoist === role.hoist &&
       this.position === role.position &&
       this.permissions.bitfield === role.permissions.bitfield &&
-      this.managed === role.managed;
+      this.managed === role.managed
+    );
   }
 
   /**
diff --git a/src/structures/StoreChannel.js b/src/structures/StoreChannel.js
new file mode 100644
index 00000000..87cb0406
--- /dev/null
+++ b/src/structures/StoreChannel.js
@@ -0,0 +1,22 @@
+'use strict';
+
+const GuildChannel = require('./GuildChannel');
+
+/**
+ * Represents a guild store channel on Discord.
+ * @extends {GuildChannel}
+ */
+class StoreChannel extends GuildChannel {
+  _patch(data) {
+    super._patch(data);
+
+    /**
+     * If the guild considers this channel NSFW
+     * @type {boolean}
+     * @readonly
+     */
+    this.nsfw = data.nsfw;
+  }
+}
+
+module.exports = StoreChannel;
diff --git a/src/structures/Team.js b/src/structures/Team.js
new file mode 100644
index 00000000..a28c5a23
--- /dev/null
+++ b/src/structures/Team.js
@@ -0,0 +1,109 @@
+'use strict';
+
+const Base = require('./Base');
+const TeamMember = require('./TeamMember');
+const Collection = require('../util/Collection');
+const Snowflake = require('../util/Snowflake');
+
+/**
+ * Represents a Client OAuth2 Application Team.
+ * @extends {Base}
+ */
+class Team extends Base {
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+
+  _patch(data) {
+    /**
+     * The ID of the Team
+     * @type {Snowflake}
+     */
+    this.id = data.id;
+
+    /**
+     * The name of the Team
+     * @type {string}
+     */
+    this.name = data.name;
+
+    /**
+     * The Team's icon hash
+     * @type {?string}
+     */
+    this.icon = data.icon || null;
+
+    /**
+     * The Team's owner id
+     * @type {?string}
+     */
+    this.ownerID = data.owner_user_id || null;
+
+    /**
+     * The Team's members
+     * @type {Collection<Snowflake, TeamMember>}
+     */
+    this.members = new Collection();
+
+    for (const memberData of data.members) {
+      const member = new TeamMember(this, memberData);
+      this.members.set(member.id, member);
+    }
+  }
+
+  /**
+   * The owner of this team
+   * @type {?TeamMember}
+   * @readonly
+   */
+  get owner() {
+    return this.members.get(this.ownerID) || null;
+  }
+
+  /**
+   * The timestamp the team was created at
+   * @type {number}
+   * @readonly
+   */
+  get createdTimestamp() {
+    return Snowflake.deconstruct(this.id).timestamp;
+  }
+
+  /**
+   * The time the team was created at
+   * @type {Date}
+   * @readonly
+   */
+  get createdAt() {
+    return new Date(this.createdTimestamp);
+  }
+
+  /**
+   * A link to the teams's icon.
+   * @param {ImageURLOptions} [options={}] Options for the Image URL
+   * @returns {?string} URL to the icon
+   */
+  iconURL({ format, size } = {}) {
+    if (!this.icon) return null;
+    return this.client.rest.cdn.TeamIcon(this.id, this.icon, { format, size });
+  }
+
+  /**
+   * When concatenated with a string, this automatically returns the Team's name instead of the
+   * Team object.
+   * @returns {string}
+   * @example
+   * // Logs: Team name: My Team
+   * console.log(`Team name: ${team}`);
+   */
+  toString() {
+    return this.name;
+  }
+
+  toJSON() {
+    return super.toJSON({ createdTimestamp: true });
+  }
+}
+
+module.exports = Team;
diff --git a/src/structures/TeamMember.js b/src/structures/TeamMember.js
new file mode 100644
index 00000000..ba7ecd26
--- /dev/null
+++ b/src/structures/TeamMember.js
@@ -0,0 +1,65 @@
+'use strict';
+
+const Base = require('./Base');
+const { MembershipStates } = require('../util/Constants');
+
+/**
+ * Represents a Client OAuth2 Application Team Member.
+ * @extends {Base}
+ */
+class TeamMember extends Base {
+  constructor(team, data) {
+    super(team.client);
+
+    /**
+     * The Team this member is part of
+     * @type {Team}
+     */
+    this.team = team;
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    /**
+     * The permissions this Team Member has with regard to the team
+     * @type {string[]}
+     */
+    this.permissions = data.permissions;
+
+    /**
+     * The permissions this Team Member has with regard to the team
+     * @type {MembershipStates}
+     */
+    this.membershipState = MembershipStates[data.membership_state];
+
+    /**
+     * The user for this Team Member
+     * @type {User}
+     */
+    this.user = this.client.users.add(data.user);
+  }
+
+  /**
+   * The ID of the Team Member
+   * @type {Snowflake}
+   * @readonly
+   */
+  get id() {
+    return this.user.id;
+  }
+
+  /**
+   * When concatenated with a string, this automatically returns the team members's mention instead of the
+   * TeamMember object.
+   * @returns {string}
+   * @example
+   * // Logs: Team Member's mention: <@123456789012345678>
+   * console.log(`Team Member's mention: ${teamMember}`);
+   */
+  toString() {
+    return this.user.toString();
+  }
+}
+
+module.exports = TeamMember;
diff --git a/src/structures/TextChannel.js b/src/structures/TextChannel.js
index 6e053e5d..65ec13d0 100644
--- a/src/structures/TextChannel.js
+++ b/src/structures/TextChannel.js
@@ -1,9 +1,11 @@
+'use strict';
+
 const GuildChannel = require('./GuildChannel');
 const Webhook = require('./Webhook');
 const TextBasedChannel = require('./interfaces/TextBasedChannel');
+const MessageManager = require('../managers/MessageManager');
 const Collection = require('../util/Collection');
 const DataResolver = require('../util/DataResolver');
-const MessageStore = require('../stores/MessageStore');
 
 /**
  * Represents a guild text channel on Discord.
@@ -11,13 +13,17 @@ const MessageStore = require('../stores/MessageStore');
  * @implements {TextBasedChannel}
  */
 class TextChannel extends GuildChannel {
+  /**
+   * @param {Guild} guild The guild the text channel is part of
+   * @param {Object} data The data for the text channel
+   */
   constructor(guild, data) {
     super(guild, data);
     /**
-     * A collection containing the messages sent to this channel
-     * @type {MessageStore<Snowflake, Message>}
+     * A manager of the messages sent to this channel
+     * @type {MessageManager}
      */
-    this.messages = new MessageStore(this);
+    this.messages = new MessageManager(this);
     this._typing = new Map();
   }
 
@@ -35,7 +41,7 @@ class TextChannel extends GuildChannel {
      * @type {boolean}
      * @readonly
      */
-    this.nsfw = data.nsfw || /^nsfw(-|$)/.test(this.name);
+    this.nsfw = data.nsfw;
 
     /**
      * The ID of the last message sent in this channel, if one was sent
@@ -44,7 +50,7 @@ class TextChannel extends GuildChannel {
     this.lastMessageID = data.last_message_id;
 
     /**
-     * The ratelimit per user for this channel
+     * The ratelimit per user for this channel in seconds
      * @type {number}
      */
     this.rateLimitPerUser = data.rate_limit_per_user || 0;
@@ -60,7 +66,7 @@ class TextChannel extends GuildChannel {
 
   /**
    * Sets the rate limit per user for this channel.
-   * @param {number} rateLimitPerUser The new ratelimit
+   * @param {number} rateLimitPerUser The new ratelimit in seconds
    * @param {string} [reason] Reason for changing the channel's ratelimits
    * @returns {Promise<TextChannel>}
    */
@@ -115,9 +121,15 @@ class TextChannel extends GuildChannel {
     if (typeof avatar === 'string' && !avatar.startsWith('data:')) {
       avatar = await DataResolver.resolveImage(avatar);
     }
-    return this.client.api.channels[this.id].webhooks.post({ data: {
-      name, avatar,
-    }, reason }).then(data => new Webhook(this.client, data));
+    return this.client.api.channels[this.id].webhooks
+      .post({
+        data: {
+          name,
+          avatar,
+        },
+        reason,
+      })
+      .then(data => new Webhook(this.client, data));
   }
 
   // These are here only for documentation purposes - they are implemented by TextBasedChannel
@@ -125,7 +137,6 @@ class TextChannel extends GuildChannel {
   get lastMessage() {}
   get lastPinAt() {}
   send() {}
-  search() {}
   startTyping() {}
   stopTyping() {}
   get typing() {}
@@ -133,8 +144,6 @@ class TextChannel extends GuildChannel {
   createMessageCollector() {}
   awaitMessages() {}
   bulkDelete() {}
-  acknowledge() {}
-  _cacheMessage() {}
 }
 
 TextBasedChannel.applyToClass(TextChannel, true);
diff --git a/src/structures/User.js b/src/structures/User.js
index 67366323..294a12bc 100644
--- a/src/structures/User.js
+++ b/src/structures/User.js
@@ -1,8 +1,10 @@
-const TextBasedChannel = require('./interfaces/TextBasedChannel');
-const { Presence } = require('./Presence');
-const Snowflake = require('../util/Snowflake');
+'use strict';
+
 const Base = require('./Base');
+const { Presence } = require('./Presence');
+const TextBasedChannel = require('./interfaces/TextBasedChannel');
 const { Error } = require('../errors');
+const Snowflake = require('../util/Snowflake');
 
 /**
  * Represents a user on Discord.
@@ -10,6 +12,10 @@ const { Error } = require('../errors');
  * @extends {Base}
  */
 class User extends Base {
+  /**
+   * @param {Client} client The instantiating client
+   * @param {Object} data The data for the user
+   */
   constructor(client, data) {
     super(client);
 
@@ -51,6 +57,15 @@ class User extends Base {
      */
     if (typeof data.avatar !== 'undefined') this.avatar = data.avatar;
 
+    if (typeof data.bot !== 'undefined') this.bot = Boolean(data.bot);
+
+    /**
+     * Whether the user is an Official Discord System user (part of the urgent message system)
+     * @type {?boolean}
+     * @name User#system
+     */
+    if (typeof data.system !== 'undefined') this.system = Boolean(data.system);
+
     /**
      * The locale of the user's client (ISO 639-1)
      * @type {?string}
@@ -71,6 +86,15 @@ class User extends Base {
     this.lastMessageChannelID = null;
   }
 
+  /**
+   * Whether this User is a partial
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return typeof this.username !== 'string';
+  }
+
   /**
    * The timestamp the user was created at
    * @type {number}
@@ -95,8 +119,8 @@ class User extends Base {
    * @readonly
    */
   get lastMessage() {
-    const channel = this.client.channels.get(this.lastMessageChannelID);
-    return (channel && channel.messages.get(this.lastMessageID)) || null;
+    const channel = this.client.channels.cache.get(this.lastMessageChannelID);
+    return (channel && channel.messages.cache.get(this.lastMessageID)) || null;
   }
 
   /**
@@ -105,8 +129,8 @@ class User extends Base {
    * @readonly
    */
   get presence() {
-    for (const guild of this.client.guilds.values()) {
-      if (guild.presences.has(this.id)) return guild.presences.get(this.id);
+    for (const guild of this.client.guilds.cache.values()) {
+      if (guild.presences.cache.has(this.id)) return guild.presences.cache.get(this.id);
     }
     return new Presence(this.client, { user: { id: this.id } });
   }
@@ -116,9 +140,9 @@ class User extends Base {
    * @param {ImageURLOptions} [options={}] Options for the Image URL
    * @returns {?string}
    */
-  avatarURL({ format, size } = {}) {
+  avatarURL({ format, size, dynamic } = {}) {
     if (!this.avatar) return null;
-    return this.client.rest.cdn.Avatar(this.id, this.avatar, format, size);
+    return this.client.rest.cdn.Avatar(this.id, this.avatar, format, size, dynamic);
   }
 
   /**
@@ -185,29 +209,33 @@ class User extends Base {
    * @readonly
    */
   get dmChannel() {
-    return this.client.channels.find(c => c.type === 'dm' && c.recipient.id === this.id) || null;
+    return this.client.channels.cache.find(c => c.type === 'dm' && c.recipient.id === this.id) || null;
   }
 
   /**
    * Creates a DM channel between the client and the user.
    * @returns {Promise<DMChannel>}
    */
-  createDM() {
-    if (this.dmChannel) return Promise.resolve(this.dmChannel);
-    return this.client.api.users(this.client.user.id).channels.post({ data: {
-      recipient_id: this.id,
-    } })
-      .then(data => this.client.actions.ChannelCreate.handle(data).channel);
+  async createDM() {
+    const { dmChannel } = this;
+    if (dmChannel && !dmChannel.partial) return dmChannel;
+    const data = await this.client.api.users(this.client.user.id).channels.post({
+      data: {
+        recipient_id: this.id,
+      },
+    });
+    return this.client.actions.ChannelCreate.handle(data).channel;
   }
 
   /**
    * Deletes a DM channel (if one exists) between the client and the user. Resolves with the channel if successful.
    * @returns {Promise<DMChannel>}
    */
-  deleteDM() {
-    if (!this.dmChannel) return Promise.reject(new Error('USER_NO_DMCHANNEL'));
-    return this.client.api.channels(this.dmChannel.id).delete()
-      .then(data => this.client.actions.ChannelDelete.handle(data).channel);
+  async deleteDM() {
+    const { dmChannel } = this;
+    if (!dmChannel) throw new Error('USER_NO_DMCHANNEL');
+    const data = await this.client.api.channels(dmChannel.id).delete();
+    return this.client.actions.ChannelDelete.handle(data).channel;
   }
 
   /**
@@ -217,7 +245,8 @@ class User extends Base {
    * @returns {boolean}
    */
   equals(user) {
-    let equal = user &&
+    let equal =
+      user &&
       this.id === user.id &&
       this.username === user.username &&
       this.discriminator === user.discriminator &&
@@ -226,6 +255,14 @@ class User extends Base {
     return equal;
   }
 
+  /**
+   * Fetches this user.
+   * @returns {Promise<User>}
+   */
+  fetch() {
+    return this.client.users.fetch(this.id, true);
+  }
+
   /**
    * When concatenated with a string, this automatically returns the user's mention instead of the User object.
    * @returns {string}
@@ -238,13 +275,16 @@ class User extends Base {
   }
 
   toJSON(...props) {
-    const json = super.toJSON({
-      createdTimestamp: true,
-      defaultAvatarURL: true,
-      tag: true,
-      lastMessage: false,
-      lastMessageID: false,
-    }, ...props);
+    const json = super.toJSON(
+      {
+        createdTimestamp: true,
+        defaultAvatarURL: true,
+        tag: true,
+        lastMessage: false,
+        lastMessageID: false,
+      },
+      ...props,
+    );
     json.avatarURL = this.avatarURL();
     json.displayAvatarURL = this.displayAvatarURL();
     return json;
diff --git a/src/structures/VoiceChannel.js b/src/structures/VoiceChannel.js
index aee01b6f..6fb5ab78 100644
--- a/src/structures/VoiceChannel.js
+++ b/src/structures/VoiceChannel.js
@@ -1,8 +1,10 @@
+'use strict';
+
 const GuildChannel = require('./GuildChannel');
+const { Error } = require('../errors');
+const Collection = require('../util/Collection');
 const { browser } = require('../util/Constants');
 const Permissions = require('../util/Permissions');
-const Collection = require('../util/Collection');
-const { Error } = require('../errors');
 
 /**
  * Represents a guild voice channel on Discord.
@@ -28,10 +30,11 @@ class VoiceChannel extends GuildChannel {
    * The members in this voice channel
    * @type {Collection<Snowflake, GuildMember>}
    * @name VoiceChannel#members
+   * @readonly
    */
   get members() {
     const coll = new Collection();
-    for (const state of this.guild.voiceStates.values()) {
+    for (const state of this.guild.voiceStates.cache.values()) {
       if (state.channelID === this.id && state.member) {
         coll.set(state.id, state.member);
       }
@@ -39,17 +42,6 @@ class VoiceChannel extends GuildChannel {
     return coll;
   }
 
-  /**
-   * The voice connection for this voice channel, if the client is connected
-   * @type {?VoiceConnection}
-   * @readonly
-   */
-  get connection() {
-    const connection = this.guild.voiceConnection;
-    if (connection && connection.channel.id === this.id) return connection;
-    return null;
-  }
-
   /**
    * Checks if the voice channel is full
    * @type {boolean}
@@ -69,14 +61,24 @@ class VoiceChannel extends GuildChannel {
   }
 
   /**
-   * Checks if the client has permission join the voice channel
+   * Whether the channel is editable by the client user
+   * @type {boolean}
+   * @readonly
+   */
+  get editable() {
+    return this.manageable && this.permissionsFor(this.client.user).has(Permissions.FLAGS.CONNECT, false);
+  }
+
+  /**
+   * Whether the channel is joinable by the client user
    * @type {boolean}
    * @readonly
    */
   get joinable() {
     if (browser) return false;
-    if (!this.permissionsFor(this.client.user).has('CONNECT', false)) return false;
-    if (this.full && !this.permissionsFor(this.client.user).has('MOVE_MEMBERS', false)) return false;
+    if (!this.viewable) return false;
+    if (!this.permissionsFor(this.client.user).has(Permissions.FLAGS.CONNECT, false)) return false;
+    if (this.full && !this.permissionsFor(this.client.user).has(Permissions.FLAGS.MOVE_MEMBERS, false)) return false;
     return true;
   }
 
@@ -86,7 +88,7 @@ class VoiceChannel extends GuildChannel {
    * @readonly
    */
   get speakable() {
-    return this.permissionsFor(this.client.user).has('SPEAK', false);
+    return this.permissionsFor(this.client.user).has(Permissions.FLAGS.SPEAK, false);
   }
 
   /**
diff --git a/src/structures/VoiceRegion.js b/src/structures/VoiceRegion.js
index b4db2177..9626195d 100644
--- a/src/structures/VoiceRegion.js
+++ b/src/structures/VoiceRegion.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Util = require('../util/Util');
 
 /**
diff --git a/src/structures/VoiceState.js b/src/structures/VoiceState.js
index 88e0ed19..633d63e4 100644
--- a/src/structures/VoiceState.js
+++ b/src/structures/VoiceState.js
@@ -1,9 +1,17 @@
+'use strict';
+
 const Base = require('./Base');
+const { Error, TypeError } = require('../errors');
+const { browser } = require('../util/Constants');
 
 /**
  * Represents the voice state for a Guild Member.
  */
 class VoiceState extends Base {
+  /**
+   * @param {Guild} guild The guild the voice state is part of
+   * @param {Object} data The data for the voice state
+   */
   constructor(guild, data) {
     super(guild.client);
     /**
@@ -45,6 +53,11 @@ class VoiceState extends Base {
      * @type {?string}
      */
     this.sessionID = data.session_id;
+    /**
+     * Whether this member is streaming using "Go Live"
+     * @type {boolean}
+     */
+    this.streaming = data.self_stream || false;
     /**
      * The ID of the voice channel that this member is in
      * @type {?Snowflake}
@@ -56,22 +69,35 @@ class VoiceState extends Base {
   /**
    * The member that this voice state belongs to
    * @type {?GuildMember}
+   * @readonly
    */
   get member() {
-    return this.guild.members.get(this.id) || null;
+    return this.guild.members.cache.get(this.id) || null;
   }
 
   /**
    * The channel that the member is connected to
    * @type {?VoiceChannel}
+   * @readonly
    */
   get channel() {
-    return this.guild.channels.get(this.channelID) || null;
+    return this.guild.channels.cache.get(this.channelID) || null;
+  }
+
+  /**
+   * If this is a voice state of the client user, then this will refer to the active VoiceConnection for this guild
+   * @type {?VoiceConnection}
+   * @readonly
+   */
+  get connection() {
+    if (browser || this.id !== this.client.user.id) return null;
+    return this.client.voice.connections.get(this.guild.id) || null;
   }
 
   /**
    * Whether this member is either self-deafened or server-deafened
    * @type {?boolean}
+   * @readonly
    */
   get deaf() {
     return this.serverDeaf || this.selfDeaf;
@@ -80,6 +106,7 @@ class VoiceState extends Base {
   /**
    * Whether this member is either self-muted or server-muted
    * @type {?boolean}
+   * @readonly
    */
   get mute() {
     return this.serverMute || this.selfMute;
@@ -89,11 +116,10 @@ class VoiceState extends Base {
    * Whether this member is currently speaking. A boolean if the information is available (aka
    * the bot is connected to any voice channel in the guild), otherwise this is null
    * @type {?boolean}
+   * @readonly
    */
   get speaking() {
-    return this.channel && this.channel.connection ?
-      Boolean(this.channel.connection._speaking.get(this.id)) :
-      null;
+    return this.channel && this.channel.connection ? Boolean(this.channel.connection._speaking.get(this.id)) : null;
   }
 
   /**
@@ -116,6 +142,56 @@ class VoiceState extends Base {
     return this.member ? this.member.edit({ deaf }, reason) : Promise.reject(new Error('VOICE_STATE_UNCACHED_MEMBER'));
   }
 
+  /**
+   * Kicks the member from the voice channel.
+   * @param {string} [reason] Reason for kicking member from the channel
+   * @returns {Promise<GuildMember>}
+   */
+  kick(reason) {
+    return this.setChannel(null, reason);
+  }
+
+  /**
+   * Moves the member to a different channel, or kick them from the one they're in.
+   * @param {ChannelResolvable|null} [channel] Channel to move the member to, or `null` if you want to kick them from
+   * voice
+   * @param {string} [reason] Reason for moving member to another channel or kicking
+   * @returns {Promise<GuildMember>}
+   */
+  setChannel(channel, reason) {
+    return this.member
+      ? this.member.edit({ channel }, reason)
+      : Promise.reject(new Error('VOICE_STATE_UNCACHED_MEMBER'));
+  }
+
+  /**
+   * Self-mutes/unmutes the bot for this voice state.
+   * @param {boolean} mute Whether or not the bot should be self-muted
+   * @returns {Promise<boolean>} true if the voice state was successfully updated, otherwise false
+   */
+  async setSelfMute(mute) {
+    if (this.id !== this.client.user.id) throw new Error('VOICE_STATE_NOT_OWN');
+    if (typeof mute !== 'boolean') throw new TypeError('VOICE_STATE_INVALID_TYPE', 'mute');
+    if (!this.connection) return false;
+    this.selfMute = mute;
+    await this.connection.sendVoiceStateUpdate();
+    return true;
+  }
+
+  /**
+   * Self-deafens/undeafens the bot for this voice state.
+   * @param {boolean} deaf Whether or not the bot should be self-deafened
+   * @returns {Promise<boolean>} true if the voice state was successfully updated, otherwise false
+   */
+  async setSelfDeaf(deaf) {
+    if (this.id !== this.client.user.id) return new Error('VOICE_STATE_NOT_OWN');
+    if (typeof deaf !== 'boolean') return new TypeError('VOICE_STATE_INVALID_TYPE', 'deaf');
+    if (!this.connection) return false;
+    this.selfDeaf = deaf;
+    await this.connection.sendVoiceStateUpdate();
+    return true;
+  }
+
   toJSON() {
     return super.toJSON({
       id: true,
diff --git a/src/structures/Webhook.js b/src/structures/Webhook.js
index c12cc67f..d129d6b7 100644
--- a/src/structures/Webhook.js
+++ b/src/structures/Webhook.js
@@ -1,6 +1,10 @@
-const DataResolver = require('../util/DataResolver');
-const Channel = require('./Channel');
+'use strict';
+
 const APIMessage = require('./APIMessage');
+const Channel = require('./Channel');
+const { WebhookTypes } = require('../util/Constants');
+const DataResolver = require('../util/DataResolver');
+const Snowflake = require('../util/Snowflake');
 
 /**
  * Represents a webhook.
@@ -26,9 +30,10 @@ class Webhook {
 
     /**
      * The token for the webhook
-     * @type {string}
+     * @name Webhook#token
+     * @type {?string}
      */
-    Object.defineProperty(this, 'token', { value: data.token, writable: true, configurable: true });
+    Object.defineProperty(this, 'token', { value: data.token || null, writable: true, configurable: true });
 
     /**
      * The avatar for the webhook
@@ -42,6 +47,12 @@ class Webhook {
      */
     this.id = data.id;
 
+    /**
+     * The type of the webhook
+     * @type {WebhookTypes}
+     */
+    this.type = WebhookTypes[data.type];
+
     /**
      * The guild the webhook belongs to
      * @type {Snowflake}
@@ -59,7 +70,7 @@ class Webhook {
        * The owner of the webhook
        * @type {?User|Object}
        */
-      this.owner = this.client.users ? this.client.users.get(data.user.id) : data.user;
+      this.owner = this.client.users ? this.client.users.cache.get(data.user.id) : data.user;
     } else {
       this.owner = null;
     }
@@ -74,8 +85,8 @@ class Webhook {
    * @property {string} [nonce=''] The nonce for the message
    * @property {Object[]} [embeds] An array of embeds for the message
    * (see [here](https://discordapp.com/developers/docs/resources/channel#embed-object) for more details)
-   * @property {boolean} [disableEveryone=this.client.options.disableEveryone] Whether or not @everyone and @here
-   * should be replaced with plain-text
+   * @property {'none' | 'all' | 'everyone'} [disableMentions=this.client.options.disableMentions] Whether or not
+   * all mentions or everyone/here mentions should be sanitized to prevent unexpected mentions
    * @property {FileOptions[]|string[]} [files] Files to send with the message
    * @property {string|boolean} [code] Language for optional codeblock formatting to apply
    * @property {boolean|SplitOptions} [split=false] Whether or not the message should be split into multiple messages if
@@ -132,26 +143,31 @@ class Webhook {
       apiMessage = content.resolveData();
     } else {
       apiMessage = APIMessage.create(this, content, options).resolveData();
-      if (apiMessage.data.content instanceof Array) {
+      if (Array.isArray(apiMessage.data.content)) {
         return Promise.all(apiMessage.split().map(this.send.bind(this)));
       }
     }
 
     const { data, files } = await apiMessage.resolveFiles();
-    return this.client.api.webhooks(this.id, this.token).post({
-      data, files,
-      query: { wait: true },
-      auth: false,
-    }).then(d => {
-      if (!this.client.channels) return d;
-      return this.client.channels.get(d.channel_id).messages.add(d, false);
-    });
+    return this.client.api
+      .webhooks(this.id, this.token)
+      .post({
+        data,
+        files,
+        query: { wait: true },
+        auth: false,
+      })
+      .then(d => {
+        const channel = this.client.channels ? this.client.channels.cache.get(d.channel_id) : undefined;
+        if (!channel) return d;
+        return channel.messages.add(d, false);
+      });
   }
 
   /**
    * Sends a raw slack message with this webhook.
    * @param {Object} body The raw body to send
-   * @returns {Promise<Message|Object>}
+   * @returns {Promise<boolean>}
    * @example
    * // Send a slack message
    * webhook.sendSlackMessage({
@@ -166,14 +182,14 @@ class Webhook {
    * }).catch(console.error);
    */
   sendSlackMessage(body) {
-    return this.client.api.webhooks(this.id, this.token).slack.post({
-      query: { wait: true },
-      auth: false,
-      data: body,
-    }).then(data => {
-      if (!this.client.channels) return data;
-      return this.client.channels.get(data.channel_id).messages.add(data, false);
-    });
+    return this.client.api
+      .webhooks(this.id, this.token)
+      .slack.post({
+        query: { wait: true },
+        auth: false,
+        data: body,
+      })
+      .then(data => data.toString() === 'ok');
   }
 
   /**
@@ -185,20 +201,20 @@ class Webhook {
    * @param {string} [reason] Reason for editing this webhook
    * @returns {Promise<Webhook>}
    */
-  edit({ name = this.name, avatar, channel }, reason) {
-    if (avatar && (typeof avatar === 'string' && !avatar.startsWith('data:'))) {
-      return DataResolver.resolveImage(avatar).then(image => this.edit({ name, avatar: image }, reason));
+  async edit({ name = this.name, avatar, channel }, reason) {
+    if (avatar && typeof avatar === 'string' && !avatar.startsWith('data:')) {
+      avatar = await DataResolver.resolveImage(avatar);
     }
     if (channel) channel = channel instanceof Channel ? channel.id : channel;
-    return this.client.api.webhooks(this.id, channel ? undefined : this.token).patch({
+    const data = await this.client.api.webhooks(this.id, channel ? undefined : this.token).patch({
       data: { name, avatar, channel_id: channel },
       reason,
-    }).then(data => {
-      this.name = data.name;
-      this.avatar = data.avatar;
-      this.channelID = data.channel_id;
-      return this;
     });
+
+    this.name = data.name;
+    this.avatar = data.avatar;
+    this.channelID = data.channel_id;
+    return this;
   }
 
   /**
@@ -209,16 +225,46 @@ class Webhook {
   delete(reason) {
     return this.client.api.webhooks(this.id, this.token).delete({ reason });
   }
+  /**
+   * The timestamp the webhook was created at
+   * @type {number}
+   * @readonly
+   */
+  get createdTimestamp() {
+    return Snowflake.deconstruct(this.id).timestamp;
+  }
+
+  /**
+   * The time the webhook was created at
+   * @type {Date}
+   * @readonly
+   */
+  get createdAt() {
+    return new Date(this.createdTimestamp);
+  }
+
+  /**
+   * The url of this webhook
+   * @type {string}
+   * @readonly
+   */
+  get url() {
+    return this.client.options.http.api + this.client.api.webhooks(this.id, this.token);
+  }
+
+  /**
+   * A link to the webhook's avatar.
+   * @param {ImageURLOptions} [options={}] Options for the Image URL
+   * @returns {?string}
+   */
+  avatarURL({ format, size } = {}) {
+    if (!this.avatar) return null;
+    return this.client.rest.cdn.Avatar(this.id, this.avatar, format, size);
+  }
 
   static applyToClass(structure) {
-    for (const prop of [
-      'send',
-      'sendSlackMessage',
-      'edit',
-      'delete',
-    ]) {
-      Object.defineProperty(structure.prototype, prop,
-        Object.getOwnPropertyDescriptor(Webhook.prototype, prop));
+    for (const prop of ['send', 'sendSlackMessage', 'edit', 'delete', 'createdTimestamp', 'createdAt', 'url']) {
+      Object.defineProperty(structure.prototype, prop, Object.getOwnPropertyDescriptor(Webhook.prototype, prop));
     }
   }
 }
diff --git a/src/structures/interfaces/Collector.js b/src/structures/interfaces/Collector.js
index c490ebb3..21d01ca4 100644
--- a/src/structures/interfaces/Collector.js
+++ b/src/structures/interfaces/Collector.js
@@ -1,6 +1,8 @@
+'use strict';
+
+const EventEmitter = require('events');
 const Collection = require('../../util/Collection');
 const Util = require('../../util/Util');
-const EventEmitter = require('events');
 
 /**
  * Filter to be applied to the collector.
@@ -13,7 +15,8 @@ const EventEmitter = require('events');
 /**
  * Options to be applied to the collector.
  * @typedef {Object} CollectorOptions
- * @property {number} [time] How long to run the collector for
+ * @property {number} [time] How long to run the collector for in milliseconds
+ * @property {number} [idle] How long to stop the collector after inactivity in milliseconds
  * @property {boolean} [dispose=false] Whether to dispose data when it's deleted
  */
 
@@ -64,10 +67,18 @@ class Collector extends EventEmitter {
      */
     this._timeout = null;
 
+    /**
+     * Timeout for cleanup due to inactivity
+     * @type {?Timeout}
+     * @private
+     */
+    this._idletimeout = null;
+
     this.handleCollect = this.handleCollect.bind(this);
     this.handleDispose = this.handleDispose.bind(this);
 
     if (options.time) this._timeout = this.client.setTimeout(() => this.stop('time'), options.time);
+    if (options.idle) this._idletimeout = this.client.setTimeout(() => this.stop('idle'), options.idle);
   }
 
   /**
@@ -87,6 +98,11 @@ class Collector extends EventEmitter {
        * @param {...*} args The arguments emitted by the listener
        */
       this.emit('collect', ...args);
+
+      if (this._idletimeout) {
+        this.client.clearTimeout(this._idletimeout);
+        this._idletimeout = this.client.setTimeout(() => this.stop('idle'), this.options.idle);
+      }
     }
     this.checkEnd();
   }
@@ -153,7 +169,14 @@ class Collector extends EventEmitter {
   stop(reason = 'user') {
     if (this.ended) return;
 
-    if (this._timeout) this.client.clearTimeout(this._timeout);
+    if (this._timeout) {
+      this.client.clearTimeout(this._timeout);
+      this._timeout = null;
+    }
+    if (this._idletimeout) {
+      this.client.clearTimeout(this._idletimeout);
+      this._idletimeout = null;
+    }
     this.ended = true;
 
     /**
@@ -165,6 +188,23 @@ class Collector extends EventEmitter {
     this.emit('end', this.collected, reason);
   }
 
+  /**
+   * Resets the collectors timeout and idle timer.
+   * @param {Object} [options] Options
+   * @param {number} [options.time] How long to run the collector for in milliseconds
+   * @param {number} [options.idle] How long to stop the collector after inactivity in milliseconds
+   */
+  resetTimer({ time, idle } = {}) {
+    if (this._timeout) {
+      this.client.clearTimeout(this._timeout);
+      this._timeout = this.client.setTimeout(() => this.stop('time'), time || this.options.time);
+    }
+    if (this._idletimeout) {
+      this.client.clearTimeout(this._idletimeout);
+      this._idletimeout = this.client.setTimeout(() => this.stop('idle'), idle || this.options.idle);
+    }
+  }
+
   /**
    * Checks whether the collector should end, and if so, ends it.
    */
@@ -173,6 +213,37 @@ class Collector extends EventEmitter {
     if (reason) this.stop(reason);
   }
 
+  /**
+   * Allows collectors to be consumed with for-await-of loops
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of}
+   */
+  async *[Symbol.asyncIterator]() {
+    const queue = [];
+    const onCollect = item => queue.push(item);
+    this.on('collect', onCollect);
+
+    try {
+      while (queue.length || !this.ended) {
+        if (queue.length) {
+          yield queue.shift();
+        } else {
+          // eslint-disable-next-line no-await-in-loop
+          await new Promise(resolve => {
+            const tick = () => {
+              this.removeListener('collect', tick);
+              this.removeListener('end', tick);
+              return resolve();
+            };
+            this.on('collect', tick);
+            this.on('end', tick);
+          });
+        }
+      }
+    } finally {
+      this.removeListener('collect', onCollect);
+    }
+  }
+
   toJSON() {
     return Util.flatten(this);
   }
diff --git a/src/structures/interfaces/TextBasedChannel.js b/src/structures/interfaces/TextBasedChannel.js
index 524ae4cf..501f7c95 100644
--- a/src/structures/interfaces/TextBasedChannel.js
+++ b/src/structures/interfaces/TextBasedChannel.js
@@ -1,8 +1,11 @@
+'use strict';
+
+/* eslint-disable import/order */
 const MessageCollector = require('../MessageCollector');
+const APIMessage = require('../APIMessage');
 const Snowflake = require('../../util/Snowflake');
 const Collection = require('../../util/Collection');
 const { RangeError, TypeError } = require('../../errors');
-const APIMessage = require('../APIMessage');
 
 /**
  * Interface for classes that have text-channel-like features.
@@ -11,10 +14,10 @@ const APIMessage = require('../APIMessage');
 class TextBasedChannel {
   constructor() {
     /**
-     * A collection containing the messages sent to this channel
-     * @type {MessageStore<Snowflake, Message>}
+     * A manager of the messages sent to this channel
+     * @type {MessageManager}
      */
-    this.messages = new MessageStore(this);
+    this.messages = new MessageManager(this);
 
     /**
      * The ID of the last message in the channel, if one was sent
@@ -35,7 +38,7 @@ class TextBasedChannel {
    * @readonly
    */
   get lastMessage() {
-    return this.messages.get(this.lastMessageID) || null;
+    return this.messages.cache.get(this.lastMessageID) || null;
   }
 
   /**
@@ -55,8 +58,8 @@ class TextBasedChannel {
    * @property {string} [content=''] The content for the message
    * @property {MessageEmbed|Object} [embed] An embed for the message
    * (see [here](https://discordapp.com/developers/docs/resources/channel#embed-object) for more details)
-   * @property {boolean} [disableEveryone=this.client.options.disableEveryone] Whether or not @everyone and @here
-   * should be replaced with plain-text
+   * @property {'none' | 'all' | 'everyone'} [disableMentions=this.client.options.disableMentions] Whether or not
+   * all mentionsor everyone/here mentions should be sanitized to prevent unexpected mentions
    * @property {FileOptions[]|BufferResolvable[]} [files] Files to send with the message
    * @property {string|boolean} [code] Language for optional codeblock formatting to apply
    * @property {boolean|SplitOptions} [split=false] Whether or not the message should be split into multiple messages if
@@ -138,13 +141,14 @@ class TextBasedChannel {
       apiMessage = content.resolveData();
     } else {
       apiMessage = APIMessage.create(this, content, options).resolveData();
-      if (apiMessage.data.content instanceof Array) {
+      if (Array.isArray(apiMessage.data.content)) {
         return Promise.all(apiMessage.split().map(this.send.bind(this)));
       }
     }
 
     const { data, files } = await apiMessage.resolveFiles();
-    return this.client.api.channels[this.id].messages.post({ data, files })
+    return this.client.api.channels[this.id].messages
+      .post({ data, files })
       .then(d => this.client.actions.MessageCreate.handle(d).message);
   }
 
@@ -296,29 +300,39 @@ class TextBasedChannel {
    *   .catch(console.error);
    */
   async bulkDelete(messages, filterOld = false) {
-    if (messages instanceof Array || messages instanceof Collection) {
+    if (Array.isArray(messages) || messages instanceof Collection) {
       let messageIDs = messages instanceof Collection ? messages.keyArray() : messages.map(m => m.id || m);
       if (filterOld) {
-        messageIDs = messageIDs.filter(id =>
-          Date.now() - Snowflake.deconstruct(id).date.getTime() < 1209600000
-        );
+        messageIDs = messageIDs.filter(id => Date.now() - Snowflake.deconstruct(id).date.getTime() < 1209600000);
       }
       if (messageIDs.length === 0) return new Collection();
       if (messageIDs.length === 1) {
-        await this.client.api.channels(this.id).messages(messageIDs[0]).delete();
-        const message = this.client.actions.MessageDelete.handle({
-          channel_id: this.id,
-          id: messageIDs[0],
-        }).message;
-        if (message) return new Collection([[message.id, message]]);
-        return new Collection();
+        await this.client.api
+          .channels(this.id)
+          .messages(messageIDs[0])
+          .delete();
+        const message = this.client.actions.MessageDelete.getMessage(
+          {
+            message_id: messageIDs[0],
+          },
+          this,
+        );
+        return message ? new Collection([[message.id, message]]) : new Collection();
       }
-      await this.client.api.channels[this.id].messages['bulk-delete']
-        .post({ data: { messages: messageIDs } });
-      return this.client.actions.MessageDeleteBulk.handle({
-        channel_id: this.id,
-        ids: messageIDs,
-      }).messages;
+      await this.client.api.channels[this.id].messages['bulk-delete'].post({ data: { messages: messageIDs } });
+      return messageIDs.reduce(
+        (col, id) =>
+          col.set(
+            id,
+            this.client.actions.MessageDeleteBulk.getMessage(
+              {
+                message_id: id,
+              },
+              this,
+            ),
+          ),
+        new Collection(),
+      );
     }
     if (!isNaN(messages)) {
       const msgs = await this.messages.fetch({ limit: messages });
@@ -339,13 +353,16 @@ class TextBasedChannel {
         'typing',
         'typingCount',
         'createMessageCollector',
-        'awaitMessages'
+        'awaitMessages',
       );
     }
     for (const prop of props) {
       if (ignore.includes(prop)) continue;
-      Object.defineProperty(structure.prototype, prop,
-        Object.getOwnPropertyDescriptor(TextBasedChannel.prototype, prop));
+      Object.defineProperty(
+        structure.prototype,
+        prop,
+        Object.getOwnPropertyDescriptor(TextBasedChannel.prototype, prop),
+      );
     }
   }
 }
@@ -353,4 +370,4 @@ class TextBasedChannel {
 module.exports = TextBasedChannel;
 
 // Fixes Circular
-const MessageStore = require('../../stores/MessageStore');
+const MessageManager = require('../../managers/MessageManager');
diff --git a/src/util/ActivityFlags.js b/src/util/ActivityFlags.js
index 49fd7a67..f6f5aac9 100644
--- a/src/util/ActivityFlags.js
+++ b/src/util/ActivityFlags.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const BitField = require('./BitField');
 
 /**
diff --git a/src/util/BitField.js b/src/util/BitField.js
index fa506a2e..8de151d0 100644
--- a/src/util/BitField.js
+++ b/src/util/BitField.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const { RangeError } = require('../errors');
 
 /**
@@ -15,6 +17,15 @@ class BitField {
     this.bitfield = this.constructor.resolve(bits);
   }
 
+  /**
+   * Checks whether the bitfield has a bit, or any of multiple bits.
+   * @param {BitFieldResolvable} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  any(bit) {
+    return (this.bitfield & this.constructor.resolve(bit)) !== 0;
+  }
+
   /**
    * Checks if this bitfield equals another
    * @param {BitFieldResolvable} bit Bit(s) to check for
@@ -30,7 +41,7 @@ class BitField {
    * @returns {boolean}
    */
   has(bit) {
-    if (bit instanceof Array) return bit.every(p => this.has(p));
+    if (Array.isArray(bit)) return bit.every(p => this.has(p));
     bit = this.constructor.resolve(bit);
     return (this.bitfield & bit) === bit;
   }
@@ -42,7 +53,7 @@ class BitField {
    * @returns {string[]}
    */
   missing(bits, ...hasParams) {
-    if (!(bits instanceof Array)) bits = new this.constructor(bits).toArray(false);
+    if (!Array.isArray(bits)) bits = new this.constructor(bits).toArray(false);
     return bits.filter(p => !this.has(p, ...hasParams));
   }
 
@@ -92,7 +103,7 @@ class BitField {
    */
   serialize(...hasParams) {
     const serialized = {};
-    for (const perm in this.constructor.FLAGS) serialized[perm] = this.has(perm, ...hasParams);
+    for (const [flag, bit] of Object.entries(this.constructor.FLAGS)) serialized[flag] = this.has(bit, ...hasParams);
     return serialized;
   }
 
@@ -134,8 +145,8 @@ class BitField {
   static resolve(bit = 0) {
     if (typeof bit === 'number' && bit >= 0) return bit;
     if (bit instanceof BitField) return bit.bitfield;
-    if (bit instanceof Array) return bit.map(p => this.resolve(p)).reduce((prev, p) => prev | p, 0);
-    if (typeof bit === 'string') return this.FLAGS[bit];
+    if (Array.isArray(bit)) return bit.map(p => this.resolve(p)).reduce((prev, p) => prev | p, 0);
+    if (typeof bit === 'string' && typeof this.FLAGS[bit] !== 'undefined') return this.FLAGS[bit];
     throw new RangeError('BITFIELD_INVALID');
   }
 }
diff --git a/src/util/Collection.js b/src/util/Collection.js
index 7f0570d6..12b040ed 100644
--- a/src/util/Collection.js
+++ b/src/util/Collection.js
@@ -1,421 +1,22 @@
+'use strict';
+
+const BaseCollection = require('@discordjs/collection');
 const Util = require('./Util');
 
 /**
  * A Map with additional utility methods. This is used throughout discord.js rather than Arrays for anything that has
  * an ID, for significantly improved performance and ease-of-use.
- * @extends {Map}
+ * @extends {BaseCollection}
  */
-class Collection extends Map {
-  constructor(iterable) {
-    super(iterable);
-
-    /**
-     * Cached array for the `array()` method - will be reset to `null` whenever `set()` or `delete()` are called
-     * @name Collection#_array
-     * @type {?Array}
-     * @private
-     */
-    Object.defineProperty(this, '_array', { value: null, writable: true, configurable: true });
-
-    /**
-     * Cached array for the `keyArray()` method - will be reset to `null` whenever `set()` or `delete()` are called
-     * @name Collection#_keyArray
-     * @type {?Array}
-     * @private
-     */
-    Object.defineProperty(this, '_keyArray', { value: null, writable: true, configurable: true });
-  }
-
-  set(key, val) {
-    this._array = null;
-    this._keyArray = null;
-    return super.set(key, val);
-  }
-
-  delete(key) {
-    this._array = null;
-    this._keyArray = null;
-    return super.delete(key);
-  }
-
-  /**
-   * Creates an ordered array of the values of this collection, and caches it internally. The array will only be
-   * reconstructed if an item is added to or removed from the collection, or if you change the length of the array
-   * itself. If you don't want this caching behavior, use `[...collection.values()]` or
-   * `Array.from(collection.values())` instead.
-   * @returns {Array}
-   */
-  array() {
-    if (!this._array || this._array.length !== this.size) this._array = [...this.values()];
-    return this._array;
-  }
-
-  /**
-   * Creates an ordered array of the keys of this collection, and caches it internally. The array will only be
-   * reconstructed if an item is added to or removed from the collection, or if you change the length of the array
-   * itself. If you don't want this caching behavior, use `[...collection.keys()]` or
-   * `Array.from(collection.keys())` instead.
-   * @returns {Array}
-   */
-  keyArray() {
-    if (!this._keyArray || this._keyArray.length !== this.size) this._keyArray = [...this.keys()];
-    return this._keyArray;
-  }
-
-  /**
-   * Obtains the first value(s) in this collection.
-   * @param {number} [amount] Amount of values to obtain from the beginning
-   * @returns {*|Array<*>} A single value if no amount is provided or an array of values, starting from the end if
-   * amount is negative
-   */
-  first(amount) {
-    if (typeof amount === 'undefined') return this.values().next().value;
-    if (amount < 0) return this.last(amount * -1);
-    amount = Math.min(this.size, amount);
-    const arr = new Array(amount);
-    const iter = this.values();
-    for (let i = 0; i < amount; i++) arr[i] = iter.next().value;
-    return arr;
-  }
-
-  /**
-   * Obtains the first key(s) in this collection.
-   * @param {number} [amount] Amount of keys to obtain from the beginning
-   * @returns {*|Array<*>} A single key if no amount is provided or an array of keys, starting from the end if
-   * amount is negative
-   */
-  firstKey(amount) {
-    if (typeof amount === 'undefined') return this.keys().next().value;
-    if (amount < 0) return this.lastKey(amount * -1);
-    amount = Math.min(this.size, amount);
-    const arr = new Array(amount);
-    const iter = this.keys();
-    for (let i = 0; i < amount; i++) arr[i] = iter.next().value;
-    return arr;
-  }
-
-  /**
-   * Obtains the last value(s) in this collection. This relies on {@link Collection#array}, and thus the caching
-   * mechanism applies here as well.
-   * @param {number} [amount] Amount of values to obtain from the end
-   * @returns {*|Array<*>} A single value if no amount is provided or an array of values, starting from the start if
-   * amount is negative
-   */
-  last(amount) {
-    const arr = this.array();
-    if (typeof amount === 'undefined') return arr[arr.length - 1];
-    if (amount < 0) return this.first(amount * -1);
-    if (!amount) return [];
-    return arr.slice(-amount);
-  }
-
-  /**
-   * Obtains the last key(s) in this collection. This relies on {@link Collection#keyArray}, and thus the caching
-   * mechanism applies here as well.
-   * @param {number} [amount] Amount of keys to obtain from the end
-   * @returns {*|Array<*>} A single key if no amount is provided or an array of keys, starting from the start if
-   * amount is negative
-   */
-  lastKey(amount) {
-    const arr = this.keyArray();
-    if (typeof amount === 'undefined') return arr[arr.length - 1];
-    if (amount < 0) return this.firstKey(amount * -1);
-    if (!amount) return [];
-    return arr.slice(-amount);
-  }
-
-  /**
-   * Obtains unique random value(s) from this collection. This relies on {@link Collection#array}, and thus the caching
-   * mechanism applies here as well.
-   * @param {number} [amount] Amount of values to obtain randomly
-   * @returns {*|Array<*>} A single value if no amount is provided or an array of values
-   */
-  random(amount) {
-    let arr = this.array();
-    if (typeof amount === 'undefined') return arr[Math.floor(Math.random() * arr.length)];
-    if (arr.length === 0 || !amount) return [];
-    const rand = new Array(amount);
-    arr = arr.slice();
-    for (let i = 0; i < amount; i++) rand[i] = arr.splice(Math.floor(Math.random() * arr.length), 1)[0];
-    return rand;
-  }
-
-  /**
-   * Obtains unique random key(s) from this collection. This relies on {@link Collection#keyArray}, and thus the caching
-   * mechanism applies here as well.
-   * @param {number} [amount] Amount of keys to obtain randomly
-   * @returns {*|Array<*>} A single key if no amount is provided or an array
-   */
-  randomKey(amount) {
-    let arr = this.keyArray();
-    if (typeof amount === 'undefined') return arr[Math.floor(Math.random() * arr.length)];
-    if (arr.length === 0 || !amount) return [];
-    const rand = new Array(amount);
-    arr = arr.slice();
-    for (let i = 0; i < amount; i++) rand[i] = arr.splice(Math.floor(Math.random() * arr.length), 1)[0];
-    return rand;
-  }
-
-  /**
-   * Searches for a single item where the given function returns a truthy value. This behaves like
-   * [Array.find()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find).
-   * <warn>All collections used in Discord.js are mapped using their `id` property, and if you want to find by id you
-   * should use the `get` method. See
-   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get) for details.</warn>
-   * @param {Function} fn The function to test with (should return boolean)
-   * @param {*} [thisArg] Value to use as `this` when executing function
-   * @returns {*}
-   * @example collection.find(user => user.username === 'Bob');
-   */
-  find(fn, thisArg) {
-    if (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);
-    for (const [key, val] of this) {
-      if (fn(val, key, this)) return val;
-    }
-    return undefined;
-  }
-
-  /* eslint-disable max-len */
-  /**
-   * Searches for the key of a single item where the given function returns a truthy value. This behaves like
-   * [Array.findIndex()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex),
-   * but returns the key rather than the positional index.
-   * @param {Function} fn The function to test with (should return boolean)
-   * @param {*} [thisArg] Value to use as `this` when executing function
-   * @returns {*}
-   * @example collection.findKey(user => user.username === 'Bob');
-   */
-  findKey(fn, thisArg) {
-    /* eslint-enable max-len */
-    if (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);
-    for (const [key, val] of this) {
-      if (fn(val, key, this)) return key;
-    }
-    return undefined;
-  }
-
-  /**
-   * Removes entries that satisfy the provided filter function.
-   * @param {Function} fn Function used to test (should return a boolean)
-   * @param {Object} [thisArg] Value to use as `this` when executing function
-   * @returns {number} The number of removed entries
-   */
-  sweep(fn, thisArg) {
-    if (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);
-    const previousSize = this.size;
-    for (const [key, val] of this) {
-      if (fn(val, key, this)) this.delete(key);
-    }
-    return previousSize - this.size;
-  }
-
-  /**
-   * Identical to
-   * [Array.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter),
-   * but returns a Collection instead of an Array.
-   * @param {Function} fn The function to test with (should return boolean)
-   * @param {*} [thisArg] Value to use as `this` when executing function
-   * @returns {Collection}
-   * @example collection.filter(user => user.username === 'Bob');
-   */
-  filter(fn, thisArg) {
-    if (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);
-    const results = new this.constructor[Symbol.species]();
-    for (const [key, val] of this) {
-      if (fn(val, key, this)) results.set(key, val);
-    }
-    return results;
-  }
-
-  /**
-   * Partitions the collection into two collections where the first collection
-   * contains the items that passed and the second contains the items that failed.
-   * @param {Function} fn Function used to test (should return a boolean)
-   * @param {*} [thisArg] Value to use as `this` when executing function
-   * @returns {Collection[]}
-   * @example const [big, small] = collection.partition(guild => guild.memberCount > 250);
-   */
-  partition(fn, thisArg) {
-    if (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);
-    const results = [new this.constructor[Symbol.species](), new this.constructor[Symbol.species]()];
-    for (const [key, val] of this) {
-      if (fn(val, key, this)) {
-        results[0].set(key, val);
-      } else {
-        results[1].set(key, val);
-      }
-    }
-    return results;
-  }
-
-  /**
-   * Maps each item to another value. Identical in behavior to
-   * [Array.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).
-   * @param {Function} fn Function that produces an element of the new array, taking three arguments
-   * @param {*} [thisArg] Value to use as `this` when executing function
-   * @returns {Array}
-   * @example collection.map(user => user.tag);
-   */
-  map(fn, thisArg) {
-    if (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);
-    const arr = new Array(this.size);
-    let i = 0;
-    for (const [key, val] of this) arr[i++] = fn(val, key, this);
-    return arr;
-  }
-
-  /**
-   * Checks if there exists an item that passes a test. Identical in behavior to
-   * [Array.some()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some).
-   * @param {Function} fn Function used to test (should return a boolean)
-   * @param {*} [thisArg] Value to use as `this` when executing function
-   * @returns {boolean}
-   * @example collection.some(user => user.discriminator === '0000');
-   */
-  some(fn, thisArg) {
-    if (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);
-    for (const [key, val] of this) {
-      if (fn(val, key, this)) return true;
-    }
-    return false;
-  }
-
-  /**
-   * Checks if all items passes a test. Identical in behavior to
-   * [Array.every()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every).
-   * @param {Function} fn Function used to test (should return a boolean)
-   * @param {*} [thisArg] Value to use as `this` when executing function
-   * @returns {boolean}
-   * @example collection.every(user => !user.bot);
-   */
-  every(fn, thisArg) {
-    if (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);
-    for (const [key, val] of this) {
-      if (!fn(val, key, this)) return false;
-    }
-    return true;
-  }
-
-  /**
-   * Applies a function to produce a single value. Identical in behavior to
-   * [Array.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce).
-   * @param {Function} fn Function used to reduce, taking four arguments; `accumulator`, `currentValue`, `currentKey`,
-   * and `collection`
-   * @param {*} [initialValue] Starting value for the accumulator
-   * @returns {*}
-   * @example collection.reduce((acc, guild) => acc + guild.memberCount, 0);
-   */
-  reduce(fn, initialValue) {
-    let accumulator;
-    if (typeof initialValue !== 'undefined') {
-      accumulator = initialValue;
-      for (const [key, val] of this) accumulator = fn(accumulator, val, key, this);
-    } else {
-      let first = true;
-      for (const [key, val] of this) {
-        if (first) {
-          accumulator = val;
-          first = false;
-          continue;
-        }
-        accumulator = fn(accumulator, val, key, this);
-      }
-    }
-    return accumulator;
-  }
-
-  /**
-   * Identical to
-   * [Map.forEach()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach),
-   * but returns the collection instead of undefined.
-   * @param {Function} fn Function to execute for each element
-   * @param {*} [thisArg] Value to use as `this` when executing function
-   * @returns {Collection}
-   * @example
-   * collection
-   *  .each(user => console.log(user.username))
-   *  .filter(user => user.bot)
-   *  .each(user => console.log(user.username));
-   */
-  each(fn, thisArg) {
-    this.forEach(fn, thisArg);
-    return this;
-  }
-
-  /**
-   * Runs a function on the collection and returns the collection.
-   * @param {Function} fn Function to execute
-   * @param {*} [thisArg] Value to use as `this` when executing function
-   * @returns {Collection}
-   * @example
-   * collection
-   *  .tap(coll => console.log(`${coll.size} users, including bots`))
-   *  .filter(user => user.bot)
-   *  .tap(coll => console.log(`${coll.size} users, excluding bots`))
-   */
-  tap(fn, thisArg) {
-    if (typeof thisArg !== 'undefined') fn = fn.bind(thisArg);
-    fn(this);
-    return this;
-  }
-
-  /**
-   * Creates an identical shallow copy of this collection.
-   * @returns {Collection}
-   * @example const newColl = someColl.clone();
-   */
-  clone() {
-    return new this.constructor[Symbol.species](this);
-  }
-
-  /**
-   * Combines this collection with others into a new collection. None of the source collections are modified.
-   * @param {...Collection} collections Collections to merge
-   * @returns {Collection}
-   * @example const newColl = someColl.concat(someOtherColl, anotherColl, ohBoyAColl);
-   */
-  concat(...collections) {
-    const newColl = this.clone();
-    for (const coll of collections) {
-      for (const [key, val] of coll) newColl.set(key, val);
-    }
-    return newColl;
-  }
-
-  /**
-   * Checks if this collection shares identical key-value pairings with another.
-   * This is different to checking for equality using equal-signs, because
-   * the collections may be different objects, but contain the same data.
-   * @param {Collection} collection Collection to compare with
-   * @returns {boolean} Whether the collections have identical contents
-   */
-  equals(collection) {
-    if (!collection) return false;
-    if (this === collection) return true;
-    if (this.size !== collection.size) return false;
-    return !this.find((value, key) => {
-      const testVal = collection.get(key);
-      return testVal !== value || (testVal === undefined && !collection.has(key));
-    });
-  }
-
-  /**
-   * The sort() method sorts the elements of a collection and returns it.
-   * The sort is not necessarily stable. The default sort order is according to string Unicode code points.
-   * @param {Function} [compareFunction] Specifies a function that defines the sort order.
-   * If omitted, the collection is sorted according to each character's Unicode code point value,
-   * according to the string conversion of each element.
-   * @returns {Collection}
-   * @example collection.sort((userA, userB) => userA.createdTimestamp - userB.createdTimestamp);
-   */
-  sort(compareFunction = (x, y) => +(x > y) || +(x === y) - 1) {
-    return new this.constructor[Symbol.species]([...this.entries()]
-      .sort((a, b) => compareFunction(a[1], b[1], a[0], b[0])));
-  }
-
+class Collection extends BaseCollection {
   toJSON() {
-    return this.map(e => typeof e.toJSON === 'function' ? e.toJSON() : Util.flatten(e));
+    return this.map(e => (typeof e.toJSON === 'function' ? e.toJSON() : Util.flatten(e)));
   }
 }
 
 module.exports = Collection;
+
+/**
+ * @external BaseCollection
+ * @see {@link https://discord.js.org/#/docs/collection/}
+ */
diff --git a/src/util/Constants.js b/src/util/Constants.js
index 461db414..030fe8c4 100644
--- a/src/util/Constants.js
+++ b/src/util/Constants.js
@@ -1,12 +1,17 @@
-const Package = exports.Package = require('../../package.json');
+'use strict';
+
+const Package = (exports.Package = require('../../package.json'));
 const { Error, RangeError } = require('../errors');
-const browser = exports.browser = typeof window !== 'undefined';
+const browser = (exports.browser = typeof window !== 'undefined');
 
 /**
  * Options for a client.
  * @typedef {Object} ClientOptions
- * @property {number} [shardId=0] ID of the shard to run
- * @property {number} [shardCount=0] Total number of shards
+ * @property {number|number[]|string} [shards] ID of the shard to run, or an array of shard IDs. If not specified,
+ * the client will spawn {@link ClientOptions#shardCount} shards. If set to `auto`, it will fetch the
+ * recommended amount of shards from Discord and spawn that amount
+ * @property {number} [shardCount=1] The total amount of shards used by all processes of this bot
+ * (e.g. recommended shard count, shard count of the ShardingManager)
  * @property {number} [messageCacheMaxSize=200] Maximum number of messages to cache per channel
  * (-1 or Infinity for unlimited - don't do this without message sweeping, otherwise memory usage will climb
  * indefinitely)
@@ -16,13 +21,18 @@ const browser = exports.browser = typeof window !== 'undefined';
  * the message cache lifetime (in seconds, 0 for never)
  * @property {boolean} [fetchAllMembers=false] Whether to cache all guild members and users upon startup, as well as
  * upon joining a guild (should be avoided whenever possible)
- * @property {boolean} [disableEveryone=false] Default value for {@link MessageOptions#disableEveryone}
+ * @property {'none' | 'all' | 'everyone'} [disableMentions='none'] Default value
+ * for {@link MessageOptions#disableMentions}
+ * @property {PartialType[]} [partials] Structures allowed to be partial. This means events can be emitted even when
+ * they're missing all the data for a particular structure. See the "Partials" topic listed in the sidebar for some
+ * important usage information, as partials require you to put checks in place when handling data.
  * @property {ReplyPrefixer} [replyPrefixer] Function to override the default mention-based prefix for a message
  * reply
  * @property {number} [restWsBridgeTimeout=5000] Maximum time permitted between REST responses and their
  * corresponding websocket events
  * @property {number} [restTimeOffset=500] Extra time in millseconds to wait before continuing to make REST
  * requests (higher values will reduce rate-limiting errors on bad connections)
+ * @property {number} [restRequestTimeout=15000] Time to wait before cancelling a REST request, in milliseconds
  * @property {number} [restSweepInterval=60] How frequently to delete inactive request buckets, in seconds
  * (or 0 for never)
  * @property {number} [retryLimit=1] How many times to retry on 5XX errors (Infinity for indefinite amount of retries)
@@ -35,14 +45,13 @@ const browser = exports.browser = typeof window !== 'undefined';
  * @property {HTTPOptions} [http] HTTP options
  */
 exports.DefaultOptions = {
-  shardId: 0,
-  shardCount: 0,
-  internalSharding: false,
+  shardCount: 1,
   messageCacheMaxSize: 200,
   messageCacheLifetime: 0,
   messageSweepInterval: 0,
   fetchAllMembers: false,
-  disableEveryone: false,
+  disableMentions: 'none',
+  partials: [],
   /**
    * Function to override the default mention-based reply prefix behaviour
    * @callback ReplyPrefixer
@@ -52,6 +61,7 @@ exports.DefaultOptions = {
   replyPrefixer: null,
   restWsBridgeTimeout: 5000,
   disabledEvents: [],
+  restRequestTimeout: 15000,
   retryLimit: 1,
   restTimeOffset: 500,
   restSweepInterval: 60,
@@ -61,8 +71,6 @@ exports.DefaultOptions = {
    * WebSocket options (these are left as snake_case to match the API)
    * @typedef {Object} WebsocketOptions
    * @property {number} [large_threshold=250] Number of members in a guild to be considered large
-   * @property {boolean} [compress=false] Whether to compress data sent on the connection
-   * (defaults to `false` for browsers)
    */
   ws: {
     large_threshold: 250,
@@ -91,22 +99,18 @@ exports.DefaultOptions = {
   },
 };
 
-exports.UserAgent = browser ? null :
-  `DiscordBot (${Package.homepage.split('#')[0]}, ${Package.version}) Node.js/${process.version}`;
+exports.UserAgent = browser
+  ? null
+  : `DiscordBot (${Package.homepage.split('#')[0]}, ${Package.version}) Node.js/${process.version}`;
 
 exports.WSCodes = {
-  1000: 'Connection gracefully closed',
-  4004: 'Tried to identify with an invalid token',
-  4010: 'Sharding data provided was invalid',
-  4011: 'Shard would be on too many guilds if connected',
+  1000: 'WS_CLOSE_REQUESTED',
+  4004: 'TOKEN_INVALID',
+  4010: 'SHARDING_INVALID',
+  4011: 'SHARDING_REQUIRED',
 };
 
-const AllowedImageFormats = [
-  'webp',
-  'png',
-  'jpg',
-  'gif',
-];
+const AllowedImageFormats = ['webp', 'png', 'jpg', 'gif'];
 
 const AllowedImageSizes = Array.from({ length: 8 }, (e, i) => 2 ** (i + 4));
 
@@ -119,7 +123,9 @@ function makeImageUrl(root, { format = 'webp', size } = {}) {
  * Options for Image URLs.
  * @typedef {Object} ImageURLOptions
  * @property {string} [format] One of `webp`, `png`, `jpg`, `gif`. If no format is provided,
- * it will be `gif` for animated avatars or otherwise `webp`
+ * defaults to `webp`.
+ * @property {boolean} [dynamic] If true, the format will dynamically change to `gif` for
+ * animated avatars; the default is false.
  * @property {number} [size] One of `16`, `32`, `64`, `128`, `256`, `512`, `1024`, `2048`
  */
 
@@ -128,13 +134,17 @@ exports.Endpoints = {
     return {
       Emoji: (emojiID, format = 'png') => `${root}/emojis/${emojiID}.${format}`,
       Asset: name => `${root}/assets/${name}`,
-      DefaultAvatar: number => `${root}/embed/avatars/${number}.png`,
-      Avatar: (userID, hash, format = 'default', size) => {
-        if (format === 'default') format = hash.startsWith('a_') ? 'gif' : 'webp';
+      DefaultAvatar: discriminator => `${root}/embed/avatars/${discriminator}.png`,
+      Avatar: (userID, hash, format = 'webp', size, dynamic = false) => {
+        if (dynamic) format = hash.startsWith('a_') ? 'gif' : format;
         return makeImageUrl(`${root}/avatars/${userID}/${hash}`, { format, size });
       },
-      Icon: (guildID, hash, format = 'webp', size) =>
-        makeImageUrl(`${root}/icons/${guildID}/${hash}`, { format, size }),
+      Banner: (guildID, hash, format = 'webp', size) =>
+        makeImageUrl(`${root}/banners/${guildID}/${hash}`, { format, size }),
+      Icon: (guildID, hash, format = 'webp', size, dynamic = false) => {
+        if (dynamic) format = hash.startsWith('a_') ? 'gif' : format;
+        return makeImageUrl(`${root}/icons/${guildID}/${hash}`, { format, size });
+      },
       AppIcon: (clientID, hash, { format = 'webp', size } = {}) =>
         makeImageUrl(`${root}/app-icons/${clientID}/${hash}`, { size, format }),
       AppAsset: (clientID, hash, { format = 'webp', size } = {}) =>
@@ -143,6 +153,8 @@ exports.Endpoints = {
         makeImageUrl(`${root}/channel-icons/${channelID}/${hash}`, { size, format }),
       Splash: (guildID, hash, format = 'webp', size) =>
         makeImageUrl(`${root}/splashes/${guildID}/${hash}`, { size, format }),
+      TeamIcon: (teamID, hash, { format = 'webp', size } = {}) =>
+        makeImageUrl(`${root}/team-icons/${teamID}/${hash}`, { size, format }),
     };
   },
   invite: (root, code) => `${root}/${code}`,
@@ -157,6 +169,9 @@ exports.Endpoints = {
  * * IDLE: 3
  * * NEARLY: 4
  * * DISCONNECTED: 5
+ * * WAITING_FOR_GUILDS: 6
+ * * IDENTIFYING: 7
+ * * RESUMING: 8
  * @typedef {number} Status
  */
 exports.Status = {
@@ -166,6 +181,9 @@ exports.Status = {
   IDLE: 3,
   NEARLY: 4,
   DISCONNECTED: 5,
+  WAITING_FOR_GUILDS: 6,
+  IDENTIFYING: 7,
+  RESUMING: 8,
 };
 
 /**
@@ -214,8 +232,7 @@ exports.VoiceOPCodes = {
 
 exports.Events = {
   RATE_LIMIT: 'rateLimit',
-  READY: 'ready',
-  RESUMED: 'resumed',
+  CLIENT_READY: 'ready',
   GUILD_CREATE: 'guildCreate',
   GUILD_DELETE: 'guildDelete',
   GUILD_UPDATE: 'guildUpdate',
@@ -230,6 +247,8 @@ exports.Events = {
   GUILD_INTEGRATIONS_UPDATE: 'guildIntegrationsUpdate',
   GUILD_ROLE_CREATE: 'roleCreate',
   GUILD_ROLE_DELETE: 'roleDelete',
+  INVITE_CREATE: 'inviteCreate',
+  INVITE_DELETE: 'inviteDelete',
   GUILD_ROLE_UPDATE: 'roleUpdate',
   GUILD_EMOJI_CREATE: 'emojiCreate',
   GUILD_EMOJI_DELETE: 'emojiDelete',
@@ -247,23 +266,50 @@ exports.Events = {
   MESSAGE_REACTION_ADD: 'messageReactionAdd',
   MESSAGE_REACTION_REMOVE: 'messageReactionRemove',
   MESSAGE_REACTION_REMOVE_ALL: 'messageReactionRemoveAll',
+  MESSAGE_REACTION_REMOVE_EMOJI: 'messageReactionRemoveEmoji',
   USER_UPDATE: 'userUpdate',
-  USER_NOTE_UPDATE: 'userNoteUpdate',
-  USER_SETTINGS_UPDATE: 'clientUserSettingsUpdate',
   PRESENCE_UPDATE: 'presenceUpdate',
+  VOICE_SERVER_UPDATE: 'voiceServerUpdate',
   VOICE_STATE_UPDATE: 'voiceStateUpdate',
   VOICE_BROADCAST_SUBSCRIBE: 'subscribe',
   VOICE_BROADCAST_UNSUBSCRIBE: 'unsubscribe',
   TYPING_START: 'typingStart',
   TYPING_STOP: 'typingStop',
   WEBHOOKS_UPDATE: 'webhookUpdate',
-  DISCONNECT: 'disconnect',
-  RECONNECTING: 'reconnecting',
   ERROR: 'error',
   WARN: 'warn',
   DEBUG: 'debug',
+  SHARD_DISCONNECT: 'shardDisconnect',
+  SHARD_ERROR: 'shardError',
+  SHARD_RECONNECTING: 'shardReconnecting',
+  SHARD_READY: 'shardReady',
+  SHARD_RESUME: 'shardResume',
+  INVALIDATED: 'invalidated',
+  RAW: 'raw',
 };
 
+exports.ShardEvents = {
+  CLOSE: 'close',
+  DESTROYED: 'destroyed',
+  INVALID_SESSION: 'invalidSession',
+  READY: 'ready',
+  RESUMED: 'resumed',
+  ALL_READY: 'allReady',
+};
+
+/**
+ * The type of Structure allowed to be a partial:
+ * * USER
+ * * CHANNEL (only affects DMChannels)
+ * * GUILD_MEMBER
+ * * MESSAGE
+ * * REACTION
+ * <warn>Partials require you to put checks in place when handling data, read the Partials topic listed in the
+ * sidebar for more information.</warn>
+ * @typedef {string} PartialType
+ */
+exports.PartialTypes = keyMirror(['USER', 'CHANNEL', 'GUILD_MEMBER', 'MESSAGE', 'REACTION']);
+
 /**
  * The type of a websocket message event, e.g. `MESSAGE_CREATE`. Here are the available events:
  * * READY
@@ -271,6 +317,8 @@ exports.Events = {
  * * GUILD_CREATE
  * * GUILD_DELETE
  * * GUILD_UPDATE
+ * * INVITE_CREATE
+ * * INVITE_DELETE
  * * GUILD_MEMBER_ADD
  * * GUILD_MEMBER_REMOVE
  * * GUILD_MEMBER_UPDATE
@@ -281,6 +329,7 @@ exports.Events = {
  * * GUILD_ROLE_UPDATE
  * * GUILD_BAN_ADD
  * * GUILD_BAN_REMOVE
+ * * GUILD_EMOJIS_UPDATE
  * * CHANNEL_CREATE
  * * CHANNEL_DELETE
  * * CHANNEL_UPDATE
@@ -292,12 +341,11 @@ exports.Events = {
  * * MESSAGE_REACTION_ADD
  * * MESSAGE_REACTION_REMOVE
  * * MESSAGE_REACTION_REMOVE_ALL
+ * * MESSAGE_REACTION_REMOVE_EMOJI
  * * USER_UPDATE
- * * USER_NOTE_UPDATE
- * * USER_SETTINGS_UPDATE
  * * PRESENCE_UPDATE
- * * VOICE_STATE_UPDATE
  * * TYPING_START
+ * * VOICE_STATE_UPDATE
  * * VOICE_SERVER_UPDATE
  * * WEBHOOKS_UPDATE
  * @typedef {string} WSEventType
@@ -308,6 +356,8 @@ exports.WSEvents = keyMirror([
   'GUILD_CREATE',
   'GUILD_DELETE',
   'GUILD_UPDATE',
+  'INVITE_CREATE',
+  'INVITE_DELETE',
   'GUILD_MEMBER_ADD',
   'GUILD_MEMBER_REMOVE',
   'GUILD_MEMBER_UPDATE',
@@ -330,10 +380,11 @@ exports.WSEvents = keyMirror([
   'MESSAGE_REACTION_ADD',
   'MESSAGE_REACTION_REMOVE',
   'MESSAGE_REACTION_REMOVE_ALL',
+  'MESSAGE_REACTION_REMOVE_EMOJI',
   'USER_UPDATE',
   'PRESENCE_UPDATE',
-  'VOICE_STATE_UPDATE',
   'TYPING_START',
+  'VOICE_STATE_UPDATE',
   'VOICE_SERVER_UPDATE',
   'WEBHOOKS_UPDATE',
 ]);
@@ -348,6 +399,13 @@ exports.WSEvents = keyMirror([
  * * CHANNEL_ICON_CHANGE
  * * PINS_ADD
  * * GUILD_MEMBER_JOIN
+ * * USER_PREMIUM_GUILD_SUBSCRIPTION
+ * * USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_1
+ * * USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_2
+ * * USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_3
+ * * CHANNEL_FOLLOW_ADD
+ * * GUILD_DISCOVERY_DISQUALIFIED
+ * * GUILD_DISCOVERY_REQUALIFIED
  * @typedef {string} MessageType
  */
 exports.MessageTypes = [
@@ -359,22 +417,28 @@ exports.MessageTypes = [
   'CHANNEL_ICON_CHANGE',
   'PINS_ADD',
   'GUILD_MEMBER_JOIN',
+  'USER_PREMIUM_GUILD_SUBSCRIPTION',
+  'USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_1',
+  'USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_2',
+  'USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_3',
+  'CHANNEL_FOLLOW_ADD',
+  // 13 isn't yet documented
+  null,
+  'GUILD_DISCOVERY_DISQUALIFIED',
+  'GUILD_DISCOVERY_REQUALIFIED',
 ];
 
 /**
+ * <info>Bots cannot set a `CUSTOM_STATUS`, it is only for custom statuses received from users</info>
  * The type of an activity of a users presence, e.g. `PLAYING`. Here are the available types:
  * * PLAYING
  * * STREAMING
  * * LISTENING
  * * WATCHING
+ * * CUSTOM_STATUS
  * @typedef {string} ActivityType
  */
-exports.ActivityTypes = [
-  'PLAYING',
-  'STREAMING',
-  'LISTENING',
-  'WATCHING',
-];
+exports.ActivityTypes = ['PLAYING', 'STREAMING', 'LISTENING', 'WATCHING', 'CUSTOM_STATUS'];
 
 exports.ChannelTypes = {
   TEXT: 0,
@@ -382,6 +446,8 @@ exports.ChannelTypes = {
   VOICE: 2,
   GROUP: 3,
   CATEGORY: 4,
+  NEWS: 5,
+  STORE: 6,
 };
 
 exports.ClientApplicationAssetTypes = {
@@ -391,35 +457,56 @@ exports.ClientApplicationAssetTypes = {
 
 exports.Colors = {
   DEFAULT: 0x000000,
-  WHITE: 0xFFFFFF,
-  AQUA: 0x1ABC9C,
-  GREEN: 0x2ECC71,
-  BLUE: 0x3498DB,
-  PURPLE: 0x9B59B6,
-  LUMINOUS_VIVID_PINK: 0xE91E63,
-  GOLD: 0xF1C40F,
-  ORANGE: 0xE67E22,
-  RED: 0xE74C3C,
-  GREY: 0x95A5A6,
-  NAVY: 0x34495E,
-  DARK_AQUA: 0x11806A,
-  DARK_GREEN: 0x1F8B4C,
+  WHITE: 0xffffff,
+  AQUA: 0x1abc9c,
+  GREEN: 0x2ecc71,
+  BLUE: 0x3498db,
+  YELLOW: 0xffff00,
+  PURPLE: 0x9b59b6,
+  LUMINOUS_VIVID_PINK: 0xe91e63,
+  GOLD: 0xf1c40f,
+  ORANGE: 0xe67e22,
+  RED: 0xe74c3c,
+  GREY: 0x95a5a6,
+  NAVY: 0x34495e,
+  DARK_AQUA: 0x11806a,
+  DARK_GREEN: 0x1f8b4c,
   DARK_BLUE: 0x206694,
-  DARK_PURPLE: 0x71368A,
-  DARK_VIVID_PINK: 0xAD1457,
-  DARK_GOLD: 0xC27C0E,
-  DARK_ORANGE: 0xA84300,
-  DARK_RED: 0x992D22,
-  DARK_GREY: 0x979C9F,
-  DARKER_GREY: 0x7F8C8D,
-  LIGHT_GREY: 0xBCC0C0,
-  DARK_NAVY: 0x2C3E50,
-  BLURPLE: 0x7289DA,
-  GREYPLE: 0x99AAB5,
-  DARK_BUT_NOT_BLACK: 0x2C2F33,
-  NOT_QUITE_BLACK: 0x23272A,
+  DARK_PURPLE: 0x71368a,
+  DARK_VIVID_PINK: 0xad1457,
+  DARK_GOLD: 0xc27c0e,
+  DARK_ORANGE: 0xa84300,
+  DARK_RED: 0x992d22,
+  DARK_GREY: 0x979c9f,
+  DARKER_GREY: 0x7f8c8d,
+  LIGHT_GREY: 0xbcc0c0,
+  DARK_NAVY: 0x2c3e50,
+  BLURPLE: 0x7289da,
+  GREYPLE: 0x99aab5,
+  DARK_BUT_NOT_BLACK: 0x2c2f33,
+  NOT_QUITE_BLACK: 0x23272a,
 };
 
+/**
+ * The value set for the explicit content filter levels for a guild:
+ * * DISABLED
+ * * MEMBERS_WITHOUT_ROLES
+ * * ALL_MEMBERS
+ * @typedef {string} ExplicitContentFilterLevel
+ */
+exports.ExplicitContentFilterLevels = ['DISABLED', 'MEMBERS_WITHOUT_ROLES', 'ALL_MEMBERS'];
+
+/**
+ * The value set for the verification levels for a guild:
+ * * NONE
+ * * LOW
+ * * MEDIUM
+ * * HIGH
+ * * VERY_HIGH
+ * @typedef {string} VerificationLevel
+ */
+exports.VerificationLevels = ['NONE', 'LOW', 'MEDIUM', 'HIGH', 'VERY_HIGH'];
+
 /**
  * An error encountered while performing an API request. Here are the potential errors:
  * * UNKNOWN_ACCOUNT
@@ -444,7 +531,10 @@ exports.Colors = {
  * * MAXIMUM_PINS
  * * MAXIMUM_ROLES
  * * MAXIMUM_REACTIONS
+ * * MAXIMUM_CHANNELS
+ * * MAXIMUM_INVITES
  * * UNAUTHORIZED
+ * * USER_BANNED
  * * MISSING_ACCESS
  * * INVALID_ACCOUNT_TYPE
  * * CANNOT_EXECUTE_ON_DM
@@ -462,10 +552,15 @@ exports.Colors = {
  * * NOTE_TOO_LONG
  * * INVALID_BULK_DELETE_QUANTITY
  * * CANNOT_PIN_MESSAGE_IN_OTHER_CHANNEL
+ * * INVALID_OR_TAKEN_INVITE_CODE
  * * CANNOT_EXECUTE_ON_SYSTEM_MESSAGE
+ * * INVALID_OAUTH_TOKEN
  * * BULK_DELETE_MESSAGE_TOO_OLD
+ * * INVALID_FORM_BODY
  * * INVITE_ACCEPTED_TO_GUILD_NOT_CONTAINING_BOT
+ * * INVALID_API_VERSION
  * * REACTION_BLOCKED
+ * * RESOURCE_OVERLOADED
  * @typedef {string} APIError
  */
 exports.APIErrors = {
@@ -491,7 +586,10 @@ exports.APIErrors = {
   MAXIMUM_PINS: 30003,
   MAXIMUM_ROLES: 30005,
   MAXIMUM_REACTIONS: 30010,
+  MAXIMUM_CHANNELS: 30013,
+  MAXIMUM_INVITES: 30016,
   UNAUTHORIZED: 40001,
+  USER_BANNED: 40007,
   MISSING_ACCESS: 50001,
   INVALID_ACCOUNT_TYPE: 50002,
   CANNOT_EXECUTE_ON_DM: 50003,
@@ -509,10 +607,15 @@ exports.APIErrors = {
   NOTE_TOO_LONG: 50015,
   INVALID_BULK_DELETE_QUANTITY: 50016,
   CANNOT_PIN_MESSAGE_IN_OTHER_CHANNEL: 50019,
+  INVALID_OR_TAKEN_INVITE_CODE: 50020,
   CANNOT_EXECUTE_ON_SYSTEM_MESSAGE: 50021,
+  INVALID_OAUTH_TOKEN: 50025,
   BULK_DELETE_MESSAGE_TOO_OLD: 50034,
+  INVALID_FORM_BODY: 50035,
   INVITE_ACCEPTED_TO_GUILD_NOT_CONTAINING_BOT: 50036,
+  INVALID_API_VERSION: 50041,
   REACTION_BLOCKED: 90001,
+  RESOURCE_OVERLOADED: 130000,
 };
 
 /**
@@ -521,9 +624,32 @@ exports.APIErrors = {
  * * MENTIONS
  * @typedef {string} DefaultMessageNotifications
  */
-exports.DefaultMessageNotifications = [
-  'ALL',
-  'MENTIONS',
+exports.DefaultMessageNotifications = ['ALL', 'MENTIONS'];
+
+/**
+ * The value set for a team members's membership state:
+ * * INVITED
+ * * ACCEPTED
+ * @typedef {string} MembershipStates
+ */
+exports.MembershipStates = [
+  // They start at 1
+  null,
+  'INVITED',
+  'ACCEPTED',
+];
+
+/**
+ * The value set for a webhook's type:
+ * * Incoming
+ * * Channel Follower
+ * @typedef {string} WebhookTypes
+ */
+exports.WebhookTypes = [
+  // They start at 1
+  null,
+  'Incoming',
+  'Channel Follower',
 ];
 
 function keyMirror(arr) {
diff --git a/src/util/DataResolver.js b/src/util/DataResolver.js
index 5fcfd0d4..e5606f3f 100644
--- a/src/util/DataResolver.js
+++ b/src/util/DataResolver.js
@@ -1,9 +1,11 @@
-const path = require('path');
+'use strict';
+
 const fs = require('fs');
+const path = require('path');
 const fetch = require('node-fetch');
-const Util = require('../util/Util');
 const { Error: DiscordError, TypeError } = require('../errors');
 const { browser } = require('../util/Constants');
+const Util = require('../util/Util');
 
 /**
  * The DataResolver identifies different objects and tries to resolve a specific piece of information from them.
@@ -60,7 +62,7 @@ class DataResolver {
    * @returns {?string}
    */
   static resolveBase64(data) {
-    if (data instanceof Buffer) return `data:image/jpg;base64,${data.toString('base64')}`;
+    if (Buffer.isBuffer(data)) return `data:image/jpg;base64,${data.toString('base64')}`;
     return data;
   }
 
@@ -83,18 +85,18 @@ class DataResolver {
    * @returns {Promise<Buffer>}
    */
   static resolveFile(resource) {
-    if (!browser && resource instanceof Buffer) return Promise.resolve(resource);
+    if (!browser && Buffer.isBuffer(resource)) return Promise.resolve(resource);
     if (browser && resource instanceof ArrayBuffer) return Promise.resolve(Util.convertToBuffer(resource));
 
     if (typeof resource === 'string') {
       if (/^https?:\/\//.test(resource)) {
-        return fetch(resource).then(res => browser ? res.blob() : res.buffer());
+        return fetch(resource).then(res => (browser ? res.blob() : res.buffer()));
       } else if (!browser) {
         return new Promise((resolve, reject) => {
           const file = browser ? resource : path.resolve(resource);
           fs.stat(file, (err, stats) => {
             if (err) return reject(err);
-            if (!stats || !stats.isFile()) return reject(new DiscordError('FILE_NOT_FOUND', file));
+            if (!stats.isFile()) return reject(new DiscordError('FILE_NOT_FOUND', file));
             fs.readFile(file, (err2, data) => {
               if (err2) reject(err2);
               else resolve(data);
diff --git a/src/util/LimitedCollection.js b/src/util/LimitedCollection.js
new file mode 100644
index 00000000..5719a9fa
--- /dev/null
+++ b/src/util/LimitedCollection.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const Collection = require('./Collection.js');
+
+/**
+ * A Collection which holds a max amount of entries. The first key is deleted if the Collection has
+ * reached max size.
+ * @extends {Collection}
+ * @param {number} [maxSize=0] The maximum size of the Collection
+ * @param {Iterable} [iterable=null] Optional entries passed to the Map constructor.
+ */
+class LimitedCollection extends Collection {
+  constructor(maxSize = 0, iterable = null) {
+    super(iterable);
+    /**
+     * The max size of the Collection.
+     * @type {number}
+     */
+    this.maxSize = maxSize;
+  }
+
+  set(key, value) {
+    if (this.maxSize === 0) return this;
+    if (this.size >= this.maxSize && !this.has(key)) this.delete(this.firstKey());
+    return super.set(key, value);
+  }
+}
+
+module.exports = LimitedCollection;
diff --git a/src/util/MessageFlags.js b/src/util/MessageFlags.js
new file mode 100644
index 00000000..4863e671
--- /dev/null
+++ b/src/util/MessageFlags.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with an {@link Message#flags} bitfield.
+ * @extends {BitField}
+ */
+class MessageFlags extends BitField {}
+
+/**
+ * Numeric message flags. All available properties:
+ * * `CROSSPOSTED`
+ * * `IS_CROSSPOST`
+ * * `SUPPRESS_EMBEDS`
+ * * `SOURCE_MESSAGE_DELETED`
+ * * `URGENT`
+ * @type {Object}
+ * @see {@link https://discordapp.com/developers/docs/resources/channel#message-object-message-flags}
+ */
+MessageFlags.FLAGS = {
+  CROSSPOSTED: 1 << 0,
+  IS_CROSSPOST: 1 << 1,
+  SUPPRESS_EMBEDS: 1 << 2,
+  SOURCE_MESSAGE_DELETED: 1 << 3,
+  URGENT: 1 << 4,
+};
+
+module.exports = MessageFlags;
diff --git a/src/util/Permissions.js b/src/util/Permissions.js
index 295346b1..831f1738 100644
--- a/src/util/Permissions.js
+++ b/src/util/Permissions.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const BitField = require('./BitField');
 
 /**
@@ -16,6 +18,16 @@ class Permissions extends BitField {
    * @typedef {string|number|Permissions|PermissionResolvable[]} PermissionResolvable
    */
 
+  /**
+   * Checks whether the bitfield has a permission, or any of multiple permissions.
+   * @param {PermissionResolvable} permission Permission(s) to check for
+   * @param {boolean} [checkAdmin=true] Whether to allow the administrator permission to override
+   * @returns {boolean}
+   */
+  any(permission, checkAdmin = true) {
+    return (checkAdmin && super.has(this.constructor.FLAGS.ADMINISTRATOR)) || super.any(permission);
+  }
+
   /**
    * Checks whether the bitfield has a permission, or multiple permissions.
    * @param {PermissionResolvable} permission Permission(s) to check for
@@ -23,8 +35,7 @@ class Permissions extends BitField {
    * @returns {boolean}
    */
   has(permission, checkAdmin = true) {
-    if (checkAdmin && super.has(this.constructor.FLAGS.ADMINISTRATOR)) return true;
-    return super.has(permission);
+    return (checkAdmin && super.has(this.constructor.FLAGS.ADMINISTRATOR)) || super.has(permission);
   }
 }
 
@@ -39,6 +50,7 @@ class Permissions extends BitField {
  * * `ADD_REACTIONS` (add new reactions to messages)
  * * `VIEW_AUDIT_LOG`
  * * `PRIORITY_SPEAKER`
+ * * `STREAM`
  * * `VIEW_CHANNEL`
  * * `SEND_MESSAGES`
  * * `SEND_TTS_MESSAGES`
@@ -72,7 +84,7 @@ Permissions.FLAGS = {
   ADD_REACTIONS: 1 << 6,
   VIEW_AUDIT_LOG: 1 << 7,
   PRIORITY_SPEAKER: 1 << 8,
-
+  STREAM: 1 << 9,
   VIEW_CHANNEL: 1 << 10,
   SEND_MESSAGES: 1 << 11,
   SEND_TTS_MESSAGES: 1 << 12,
@@ -107,6 +119,6 @@ Permissions.ALL = Object.values(Permissions.FLAGS).reduce((all, p) => all | p, 0
  * Bitfield representing the default permissions for users
  * @type {number}
  */
-Permissions.DEFAULT = 104324097;
+Permissions.DEFAULT = 104324673;
 
 module.exports = Permissions;
diff --git a/src/util/Snowflake.js b/src/util/Snowflake.js
index 00f22d06..ec71033a 100644
--- a/src/util/Snowflake.js
+++ b/src/util/Snowflake.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const Util = require('../util/Util');
 
 // Discord epoch (2015-01-01T00:00:00.000Z)
@@ -34,12 +36,14 @@ class SnowflakeUtil {
     if (timestamp instanceof Date) timestamp = timestamp.getTime();
     if (typeof timestamp !== 'number' || isNaN(timestamp)) {
       throw new TypeError(
-        `"timestamp" argument must be a number (received ${isNaN(timestamp) ? 'NaN' : typeof timestamp})`
+        `"timestamp" argument must be a number (received ${isNaN(timestamp) ? 'NaN' : typeof timestamp})`,
       );
     }
     if (INCREMENT >= 4095) INCREMENT = 0;
     // eslint-disable-next-line max-len
-    const BINARY = `${(timestamp - EPOCH).toString(2).padStart(42, '0')}0000100000${(INCREMENT++).toString(2).padStart(12, '0')}`;
+    const BINARY = `${(timestamp - EPOCH).toString(2).padStart(42, '0')}0000100000${(INCREMENT++)
+      .toString(2)
+      .padStart(12, '0')}`;
     return Util.binaryToID(BINARY);
   }
 
@@ -60,7 +64,9 @@ class SnowflakeUtil {
    * @returns {DeconstructedSnowflake} Deconstructed snowflake
    */
   static deconstruct(snowflake) {
-    const BINARY = Util.idToBinary(snowflake).toString(2).padStart(64, '0');
+    const BINARY = Util.idToBinary(snowflake)
+      .toString(2)
+      .padStart(64, '0');
     const res = {
       timestamp: parseInt(BINARY.substring(0, 42), 2) + EPOCH,
       workerID: parseInt(BINARY.substring(42, 47), 2),
@@ -69,7 +75,9 @@ class SnowflakeUtil {
       binary: BINARY,
     };
     Object.defineProperty(res, 'date', {
-      get: function get() { return new Date(this.timestamp); },
+      get: function get() {
+        return new Date(this.timestamp);
+      },
       enumerable: true,
     });
     return res;
diff --git a/src/util/Speaking.js b/src/util/Speaking.js
index e0e557ea..18c1ae6a 100644
--- a/src/util/Speaking.js
+++ b/src/util/Speaking.js
@@ -1,3 +1,5 @@
+'use strict';
+
 const BitField = require('./BitField');
 
 /**
@@ -11,12 +13,14 @@ class Speaking extends BitField {}
  * Numeric speaking flags. All available properties:
  * * `SPEAKING`
  * * `SOUNDSHARE`
+ * * `PRIORITY_SPEAKING`
  * @type {Object}
  * @see {@link https://discordapp.com/developers/docs/topics/voice-connections#speaking}
  */
 Speaking.FLAGS = {
   SPEAKING: 1 << 0,
   SOUNDSHARE: 1 << 1,
+  PRIORITY_SPEAKING: 1 << 2,
 };
 
 module.exports = Speaking;
diff --git a/src/util/Structures.js b/src/util/Structures.js
index 8b1edd8b..e80158a8 100644
--- a/src/util/Structures.js
+++ b/src/util/Structures.js
@@ -1,5 +1,7 @@
+'use strict';
+
 /**
- * Allows for the extension of built-in Discord.js structures that are instantiated by {@link DataStore DataStores}.
+ * Allows for the extension of built-in Discord.js structures that are instantiated by {@link BaseManager Managers}.
  */
 class Structures {
   constructor() {
@@ -18,6 +20,8 @@ class Structures {
 
   /**
    * Extends a structure.
+   * <warn> Make sure to extend all structures before instantiating your client.
+   * Extending after doing so may not work as expected. </warn>
    * @param {string} structure Name of the structure class to extend
    * @param {Function} extender Function that takes the base class to extend as its only parameter and returns the
    * extended class/prototype
@@ -41,17 +45,22 @@ class Structures {
     if (typeof extender !== 'function') {
       const received = `(received ${typeof extender})`;
       throw new TypeError(
-        `"extender" argument must be a function that returns the extended structure class/prototype ${received}`
+        `"extender" argument must be a function that returns the extended structure class/prototype ${received}.`,
       );
     }
 
     const extended = extender(structures[structure]);
     if (typeof extended !== 'function') {
-      throw new TypeError('The extender function must return the extended structure class/prototype.');
+      const received = `(received ${typeof extended})`;
+      throw new TypeError(`The extender function must return the extended structure class/prototype ${received}.`);
     }
-    if (Object.getPrototypeOf(extended) !== structures[structure]) {
+
+    if (!(extended.prototype instanceof structures[structure])) {
+      const prototype = Object.getPrototypeOf(extended);
+      const received = `${extended.name || 'unnamed'}${prototype.name ? ` extends ${prototype.name}` : ''}`;
       throw new Error(
-        'The class/prototype returned from the extender function must extend the existing structure class/prototype.'
+        'The class/prototype returned from the extender function must extend the existing structure class/prototype' +
+          ` (received function ${received}; expected extension of ${structures[structure].name}).`,
       );
     }
 
@@ -63,11 +72,11 @@ class Structures {
 const structures = {
   GuildEmoji: require('../structures/GuildEmoji'),
   DMChannel: require('../structures/DMChannel'),
-  GroupDMChannel: require('../structures/GroupDMChannel'),
   TextChannel: require('../structures/TextChannel'),
   VoiceChannel: require('../structures/VoiceChannel'),
   CategoryChannel: require('../structures/CategoryChannel'),
-  GuildChannel: require('../structures/GuildChannel'),
+  NewsChannel: require('../structures/NewsChannel'),
+  StoreChannel: require('../structures/StoreChannel'),
   GuildMember: require('../structures/GuildMember'),
   Guild: require('../structures/Guild'),
   Message: require('../structures/Message'),
diff --git a/src/util/SystemChannelFlags.js b/src/util/SystemChannelFlags.js
new file mode 100644
index 00000000..be953f71
--- /dev/null
+++ b/src/util/SystemChannelFlags.js
@@ -0,0 +1,33 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with a {@link Guild#systemChannelFlags} bitfield.
+ * <info>Note that all event message types are enabled by default,
+ * and by setting their corresponding flags you are disabling them</info>
+ * @extends {BitField}
+ */
+class SystemChannelFlags extends BitField {}
+
+/**
+ * Data that can be resolved to give a sytem channel flag bitfield. This can be:
+ * * A string (see {@link SystemChannelFlags.FLAGS})
+ * * A sytem channel flag
+ * * An instance of SystemChannelFlags
+ * * An Array of SystemChannelFlagsResolvable
+ * @typedef {string|number|SystemChannelFlags|SystemChannelFlagsResolvable[]} SystemChannelFlagsResolvable
+ */
+
+/**
+ * Numeric system channel flags. All available properties:
+ * * `WELCOME_MESSAGE_DISABLED`
+ * * `BOOST_MESSAGE_DISABLED`
+ * @type {Object}
+ */
+SystemChannelFlags.FLAGS = {
+  WELCOME_MESSAGE_DISABLED: 1 << 0,
+  BOOST_MESSAGE_DISABLED: 1 << 1,
+};
+
+module.exports = SystemChannelFlags;
diff --git a/src/util/Util.js b/src/util/Util.js
index 119d0c7c..ebade751 100644
--- a/src/util/Util.js
+++ b/src/util/Util.js
@@ -1,9 +1,11 @@
-const { Colors, DefaultOptions, Endpoints } = require('./Constants');
+'use strict';
+
+const { parse } = require('path');
 const fetch = require('node-fetch');
+const { Colors, DefaultOptions, Endpoints } = require('./Constants');
 const { Error: DiscordError, RangeError, TypeError } = require('../errors');
 const has = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
 const isObject = d => typeof d === 'object' && d !== null;
-const { parse } = require('path');
 
 /**
  * Contains various general-purpose utility methods. These functions are also available on the base `Discord` object.
@@ -22,7 +24,12 @@ class Util {
   static flatten(obj, ...props) {
     if (!isObject(obj)) return obj;
 
-    props = Object.assign(...Object.keys(obj).filter(k => !k.startsWith('_')).map(k => ({ [k]: true })), ...props);
+    props = Object.assign(
+      ...Object.keys(obj)
+        .filter(k => !k.startsWith('_'))
+        .map(k => ({ [k]: true })),
+      ...props,
+    );
 
     const out = {};
 
@@ -34,8 +41,10 @@ class Util {
       const elemIsObj = isObject(element);
       const valueOf = elemIsObj && typeof element.valueOf === 'function' ? element.valueOf() : null;
 
-      // If it's a collection, make the array of keys
+      // If it's a Collection, make the array of keys
       if (element instanceof require('./Collection')) out[newProp] = Array.from(element.keys());
+      // If the valueOf is a Collection, use its array of keys
+      else if (valueOf instanceof require('./Collection')) out[newProp] = Array.from(valueOf.keys());
       // If it's an array, flatten each element
       else if (Array.isArray(element)) out[newProp] = element.map(e => Util.flatten(e));
       // If it's an object with a primitive `valueOf`, use that value
@@ -49,14 +58,15 @@ class Util {
 
   /**
    * Splits a string into multiple chunks at a designated character that do not exceed a specific length.
-   * @param {string} text Content to split
+   * @param {StringResolvable} text Content to split
    * @param {SplitOptions} [options] Options controlling the behavior of the split
-   * @returns {string|string[]}
+   * @returns {string[]}
    */
   static splitMessage(text, { maxLength = 2000, char = '\n', prepend = '', append = '' } = {}) {
-    if (text.length <= maxLength) return text;
+    text = Util.resolveString(text);
+    if (text.length <= maxLength) return [text];
     const splitText = text.split(char);
-    if (splitText.length === 1) throw new RangeError('SPLIT_MAX_LEN');
+    if (splitText.some(chunk => chunk.length > maxLength)) throw new RangeError('SPLIT_MAX_LEN');
     const messages = [];
     let msg = '';
     for (const chunk of splitText) {
@@ -72,14 +82,153 @@ class Util {
   /**
    * Escapes any Discord-flavour markdown in a string.
    * @param {string} text Content to escape
-   * @param {boolean} [onlyCodeBlock=false] Whether to only escape codeblocks (takes priority)
-   * @param {boolean} [onlyInlineCode=false] Whether to only escape inline code
+   * @param {Object} [options={}] What types of markdown to escape
+   * @param {boolean} [options.codeBlock=true] Whether to escape code blocks or not
+   * @param {boolean} [options.inlineCode=true] Whether to escape inline code or not
+   * @param {boolean} [options.bold=true] Whether to escape bolds or not
+   * @param {boolean} [options.italic=true] Whether to escape italics or not
+   * @param {boolean} [options.underline=true] Whether to escape underlines or not
+   * @param {boolean} [options.strikethrough=true] Whether to escape strikethroughs or not
+   * @param {boolean} [options.spoiler=true] Whether to escape spoilers or not
+   * @param {boolean} [options.codeBlockContent=true] Whether to escape text inside code blocks or not
+   * @param {boolean} [options.inlineCodeContent=true] Whether to escape text inside inline code or not
    * @returns {string}
    */
-  static escapeMarkdown(text, onlyCodeBlock = false, onlyInlineCode = false) {
-    if (onlyCodeBlock) return text.replace(/```/g, '`\u200b``');
-    if (onlyInlineCode) return text.replace(/\\(`|\\)/g, '$1').replace(/(`|\\)/g, '\\$1');
-    return text.replace(/\\(\*|_|`|~|\\)/g, '$1').replace(/(\*|_|`|~|\\)/g, '\\$1');
+  static escapeMarkdown(
+    text,
+    {
+      codeBlock = true,
+      inlineCode = true,
+      bold = true,
+      italic = true,
+      underline = true,
+      strikethrough = true,
+      spoiler = true,
+      codeBlockContent = true,
+      inlineCodeContent = true,
+    } = {},
+  ) {
+    if (!codeBlockContent) {
+      return text
+        .split('```')
+        .map((subString, index, array) => {
+          if (index % 2 && index !== array.length - 1) return subString;
+          return Util.escapeMarkdown(subString, {
+            inlineCode,
+            bold,
+            italic,
+            underline,
+            strikethrough,
+            spoiler,
+            inlineCodeContent,
+          });
+        })
+        .join(codeBlock ? '\\`\\`\\`' : '```');
+    }
+    if (!inlineCodeContent) {
+      return text
+        .split(/(?<=^|[^`])`(?=[^`]|$)/g)
+        .map((subString, index, array) => {
+          if (index % 2 && index !== array.length - 1) return subString;
+          return Util.escapeMarkdown(subString, {
+            codeBlock,
+            bold,
+            italic,
+            underline,
+            strikethrough,
+            spoiler,
+          });
+        })
+        .join(inlineCode ? '\\`' : '`');
+    }
+    if (inlineCode) text = Util.escapeInlineCode(text);
+    if (codeBlock) text = Util.escapeCodeBlock(text);
+    if (italic) text = Util.escapeItalic(text);
+    if (bold) text = Util.escapeBold(text);
+    if (underline) text = Util.escapeUnderline(text);
+    if (strikethrough) text = Util.escapeStrikethrough(text);
+    if (spoiler) text = Util.escapeSpoiler(text);
+    return text;
+  }
+
+  /**
+   * Escapes code block markdown in a string.
+   * @param {string} text Content to escape
+   * @returns {string}
+   */
+  static escapeCodeBlock(text) {
+    return text.replace(/```/g, '\\`\\`\\`');
+  }
+
+  /**
+   * Escapes inline code markdown in a string.
+   * @param {string} text Content to escape
+   * @returns {string}
+   */
+  static escapeInlineCode(text) {
+    return text.replace(/(?<=^|[^`])`(?=[^`]|$)/g, '\\`');
+  }
+
+  /**
+   * Escapes italic markdown in a string.
+   * @param {string} text Content to escape
+   * @returns {string}
+   */
+  static escapeItalic(text) {
+    let i = 0;
+    text = text.replace(/(?<=^|[^*])\*([^*]|\*\*|$)/g, (_, match) => {
+      if (match === '**') return ++i % 2 ? `\\*${match}` : `${match}\\*`;
+      return `\\*${match}`;
+    });
+    i = 0;
+    return text.replace(/(?<=^|[^_])_([^_]|__|$)/g, (_, match) => {
+      if (match === '__') return ++i % 2 ? `\\_${match}` : `${match}\\_`;
+      return `\\_${match}`;
+    });
+  }
+
+  /**
+   * Escapes bold markdown in a string.
+   * @param {string} text Content to escape
+   * @returns {string}
+   */
+  static escapeBold(text) {
+    let i = 0;
+    return text.replace(/\*\*(\*)?/g, (_, match) => {
+      if (match) return ++i % 2 ? `${match}\\*\\*` : `\\*\\*${match}`;
+      return '\\*\\*';
+    });
+  }
+
+  /**
+   * Escapes underline markdown in a string.
+   * @param {string} text Content to escape
+   * @returns {string}
+   */
+  static escapeUnderline(text) {
+    let i = 0;
+    return text.replace(/__(_)?/g, (_, match) => {
+      if (match) return ++i % 2 ? `${match}\\_\\_` : `\\_\\_${match}`;
+      return '\\_\\_';
+    });
+  }
+
+  /**
+   * Escapes strikethrough markdown in a string.
+   * @param {string} text Content to escape
+   * @returns {string}
+   */
+  static escapeStrikethrough(text) {
+    return text.replace(/~~/g, '\\~\\~');
+  }
+
+  /**
+   * Escapes spoiler markdown in a string.
+   * @param {string} text Content to escape
+   * @returns {string}
+   */
+  static escapeSpoiler(text) {
+    return text.replace(/\|\|/g, '\\|\\|');
   }
 
   /**
@@ -93,10 +242,12 @@ class Util {
     return fetch(`${DefaultOptions.http.api}/v${DefaultOptions.http.version}${Endpoints.botGateway}`, {
       method: 'GET',
       headers: { Authorization: `Bot ${token.replace(/^Bot\s*/i, '')}` },
-    }).then(res => {
-      if (res.ok) return res.json();
-      throw res;
-    }).then(data => data.shards * (1000 / guildsPerShard));
+    })
+      .then(res => {
+        if (res.ok) return res.json();
+        throw res;
+      })
+      .then(data => data.shards * (1000 / guildsPerShard));
   }
 
   /**
@@ -111,9 +262,9 @@ class Util {
   static parseEmoji(text) {
     if (text.includes('%')) text = decodeURIComponent(text);
     if (!text.includes(':')) return { animated: false, name: text, id: null };
-    const m = text.match(/<?(a)?:?(\w{2,32}):(\d{17,19})>?/);
+    const m = text.match(/<?(?:(a):)?(\w{2,32}):(\d{17,19})?>?/);
     if (!m) return null;
-    return { animated: Boolean(m[1]), name: m[2], id: m[3] };
+    return { animated: Boolean(m[1]), name: m[2], id: m[3] || null };
   }
 
   /**
@@ -234,7 +385,7 @@ class Util {
    */
   static resolveString(data) {
     if (typeof data === 'string') return data;
-    if (data instanceof Array) return data.join('\n');
+    if (Array.isArray(data)) return data.join('\n');
     return String(data);
   }
 
@@ -249,6 +400,7 @@ class Util {
    * - `AQUA`
    * - `GREEN`
    * - `BLUE`
+   * - `YELLOW`
    * - `PURPLE`
    * - `LUMINOUS_VIVID_PINK`
    * - `GOLD`
@@ -279,14 +431,14 @@ class Util {
    */
   static resolveColor(color) {
     if (typeof color === 'string') {
-      if (color === 'RANDOM') return Math.floor(Math.random() * (0xFFFFFF + 1));
+      if (color === 'RANDOM') return Math.floor(Math.random() * (0xffffff + 1));
       if (color === 'DEFAULT') return 0;
       color = Colors[color] || parseInt(color.replace('#', ''), 16);
-    } else if (color instanceof Array) {
+    } else if (Array.isArray(color)) {
       color = (color[0] << 16) + (color[1] << 8) + color[2];
     }
 
-    if (color < 0 || color > 0xFFFFFF) throw new RangeError('COLOR_RANGE');
+    if (color < 0 || color > 0xffffff) throw new RangeError('COLOR_RANGE');
     else if (color && isNaN(color)) throw new TypeError('COLOR_CONVERT');
 
     return color;
@@ -298,10 +450,11 @@ class Util {
    * @returns {Collection}
    */
   static discordSort(collection) {
-    return collection.sort((a, b) =>
-      a.rawPosition - b.rawPosition ||
-      parseInt(b.id.slice(0, -10)) - parseInt(a.id.slice(0, -10)) ||
-      parseInt(b.id.slice(10)) - parseInt(a.id.slice(10))
+    return collection.sorted(
+      (a, b) =>
+        a.rawPosition - b.rawPosition ||
+        parseInt(b.id.slice(0, -10)) - parseInt(a.id.slice(0, -10)) ||
+        parseInt(b.id.slice(10)) - parseInt(a.id.slice(10)),
     );
   }
 
@@ -370,7 +523,11 @@ class Util {
       const low = parseInt((high % 10).toString(2) + num.slice(-32), 2);
 
       dec = (low % 10).toString() + dec;
-      num = Math.floor(high / 10).toString(2) + Math.floor(low / 10).toString(2).padStart(32, '0');
+      num =
+        Math.floor(high / 10).toString(2) +
+        Math.floor(low / 10)
+          .toString(2)
+          .padStart(32, '0');
     }
 
     num = parseInt(num, 2);
@@ -382,6 +539,15 @@ class Util {
     return dec;
   }
 
+  /**
+   * Breaks user, role and everyone/here mentions by adding a zero width space after every @ character
+   * @param {string} str The string to sanitize
+   * @returns {string}
+   */
+  static removeMentions(str) {
+    return str.replace(/@/g, '@\u200b');
+  }
+
   /**
    * The content to have all mentions replaced by the equivalent text.
    * @param {string} str The string to be converted
@@ -389,32 +555,54 @@ class Util {
    * @returns {string}
    */
   static cleanContent(str, message) {
-    return str
-      .replace(/@(everyone|here)/g, '@\u200b$1')
+    if (message.client.options.disableMentions === 'everyone') {
+      str = str.replace(/@([^<>@ ]*)/gmsu, (match, target) => {
+        if (target.match(/^[&!]?\d+$/)) {
+          return `@${target}`;
+        } else {
+          return `@\u200b${target}`;
+        }
+      });
+    }
+    str = str
       .replace(/<@!?[0-9]+>/g, input => {
         const id = input.replace(/<|!|>|@/g, '');
-        if (message.channel.type === 'dm' || message.channel.type === 'group') {
-          const user = message.client.users.get(id);
+        if (message.channel.type === 'dm') {
+          const user = message.client.users.cache.get(id);
           return user ? `@${user.username}` : input;
         }
 
-        const member = message.channel.guild.members.get(id);
+        const member = message.channel.guild.members.cache.get(id);
         if (member) {
           return `@${member.displayName}`;
         } else {
-          const user = message.client.users.get(id);
+          const user = message.client.users.cache.get(id);
           return user ? `@${user.username}` : input;
         }
       })
       .replace(/<#[0-9]+>/g, input => {
-        const channel = message.client.channels.get(input.replace(/<|#|>/g, ''));
+        const channel = message.client.channels.cache.get(input.replace(/<|#|>/g, ''));
         return channel ? `#${channel.name}` : input;
       })
       .replace(/<@&[0-9]+>/g, input => {
-        if (message.channel.type === 'dm' || message.channel.type === 'group') return input;
-        const role = message.guild.roles.get(input.replace(/<|@|>|&/g, ''));
+        if (message.channel.type === 'dm') return input;
+        const role = message.guild.roles.cache.get(input.replace(/<|@|>|&/g, ''));
         return role ? `@${role.name}` : input;
       });
+    if (message.client.options.disableMentions === 'all') {
+      return Util.removeMentions(str);
+    } else {
+      return str;
+    }
+  }
+
+  /**
+   * The content to put in a codeblock with all codeblock fences replaced by the equivalent backticks.
+   * @param {string} text The string to be converted
+   * @returns {string}
+   */
+  static cleanCodeBlockContent(text) {
+    return text.replace(/```/g, '`\u200b``');
   }
 
   /**
@@ -428,34 +616,6 @@ class Util {
       setTimeout(resolve, ms);
     });
   }
-
-  /**
-   * Adds methods from collections and maps onto the provided store
-   * @param {DataStore} store The store to mixin
-   * @param {string[]} ignored The properties to ignore
-   * @private
-   */
-  /* eslint-disable func-names */
-  static mixin(store, ignored) {
-    const Collection = require('./Collection');
-    Object.getOwnPropertyNames(Collection.prototype)
-      .concat(Object.getOwnPropertyNames(Map.prototype)).forEach(prop => {
-        if (ignored.includes(prop)) return;
-        if (prop === 'size') {
-          Object.defineProperty(store.prototype, prop, {
-            get: function() {
-              return this._filtered[prop];
-            },
-          });
-          return;
-        }
-        const func = Collection.prototype[prop];
-        if (prop === 'constructor' || typeof func !== 'function') return;
-        store.prototype[prop] = function(...args) {
-          return func.apply(this._filtered, args);
-        };
-      });
-  }
 }
 
 module.exports = Util;
diff --git a/test/disableMentions.js b/test/disableMentions.js
new file mode 100644
index 00000000..428d605e
--- /dev/null
+++ b/test/disableMentions.js
@@ -0,0 +1,44 @@
+'use strict';
+
+const { token, prefix } = require('./auth');
+const Discord = require('../src');
+const { Util } = Discord;
+
+const client = new Discord.Client({
+    // To see a difference, comment out disableMentions and run the same tests using disableEveryone
+    // You will notice that all messages will mention @everyone
+    //disableEveryone: true
+    disableMentions: 'everyone'
+});
+
+const tests = [
+  // Test 1
+  // See https://github.com/discordapp/discord-api-docs/issues/1189
+  '@\u202eeveryone @\u202ehere',
+
+  // Test 2
+  // See https://github.com/discordapp/discord-api-docs/issues/1241
+  // TL;DR: Characters like \u0300 will only be stripped if more than 299 are present
+  `${'\u0300@'.repeat(150)}@\u0300everyone @\u0300here`,
+
+  // Test 3
+  // Normal @everyone/@here mention
+  '@everyone @here',
+];
+
+client.on('ready', () => console.log('Ready!'));
+
+client.on('message', message => {
+  // Check if message starts with prefix
+  if (!message.content.startsWith(prefix)) return;
+  const [command, ...args] = message.content.substr(prefix.length).split(' ');
+
+  // Clean content and log each character
+  console.log(Util.cleanContent(args.join(' '), message).split(''));
+
+  if (command === 'test1') message.reply(tests[0]);
+  else if (command === 'test2') message.reply(tests[1]);
+  else if (command === 'test3') message.reply(tests[2]);
+});
+
+client.login(token).catch(console.error);
diff --git a/test/escapeMarkdown.test.js b/test/escapeMarkdown.test.js
new file mode 100644
index 00000000..a8f7aede
--- /dev/null
+++ b/test/escapeMarkdown.test.js
@@ -0,0 +1,195 @@
+'use strict';
+
+/* eslint-disable max-len, no-undef */
+
+const Util = require('../src/util/Util');
+const testString = "`_Behold!_`\n||___~~***```js\n`use strict`;\nrequire('discord.js');```***~~___||";
+
+describe('escapeCodeblock', () => {
+  test('shared', () => {
+    expect(Util.escapeCodeBlock(testString)).toBe(
+      "`_Behold!_`\n||___~~***\\`\\`\\`js\n`use strict`;\nrequire('discord.js');\\`\\`\\`***~~___||",
+    );
+  });
+
+  test('basic', () => {
+    expect(Util.escapeCodeBlock('```test```')).toBe('\\`\\`\\`test\\`\\`\\`');
+  });
+});
+
+describe('escapeInlineCode', () => {
+  test('shared', () => {
+    expect(Util.escapeInlineCode(testString)).toBe(
+      "\\`_Behold!_\\`\n||___~~***```js\n\\`use strict\\`;\nrequire('discord.js');```***~~___||",
+    );
+  });
+
+  test('basic', () => {
+    expect(Util.escapeInlineCode('`test`')).toBe('\\`test\\`');
+  });
+});
+
+describe('escapeBold', () => {
+  test('shared', () => {
+    expect(Util.escapeBold(testString)).toBe(
+      "`_Behold!_`\n||___~~*\\*\\*```js\n`use strict`;\nrequire('discord.js');```\\*\\**~~___||",
+    );
+  });
+
+  test('basic', () => {
+    expect(Util.escapeBold('**test**')).toBe('\\*\\*test\\*\\*');
+  });
+});
+
+describe('escapeItalic', () => {
+  test('shared', () => {
+    expect(Util.escapeItalic(testString)).toBe(
+      "`\\_Behold!\\_`\n||\\___~~\\***```js\n`use strict`;\nrequire('discord.js');```**\\*~~__\\_||",
+    );
+  });
+
+  test('basic (_)', () => {
+    expect(Util.escapeItalic('_test_')).toBe('\\_test\\_');
+  });
+
+  test('basic (*)', () => {
+    expect(Util.escapeItalic('*test*')).toBe('\\*test\\*');
+  });
+});
+
+describe('escapeUnderline', () => {
+  test('shared', () => {
+    expect(Util.escapeUnderline(testString)).toBe(
+      "`_Behold!_`\n||_\\_\\_~~***```js\n`use strict`;\nrequire('discord.js');```***~~\\_\\__||",
+    );
+  });
+
+  test('basic', () => {
+    expect(Util.escapeUnderline('__test__')).toBe('\\_\\_test\\_\\_');
+  });
+});
+
+describe('escapeStrikethrough', () => {
+  test('shared', () => {
+    expect(Util.escapeStrikethrough(testString)).toBe(
+      "`_Behold!_`\n||___\\~\\~***```js\n`use strict`;\nrequire('discord.js');```***\\~\\~___||",
+    );
+  });
+
+  test('basic', () => {
+    expect(Util.escapeStrikethrough('~~test~~')).toBe('\\~\\~test\\~\\~');
+  });
+});
+
+describe('escapeSpoiler', () => {
+  test('shared', () => {
+    expect(Util.escapeSpoiler(testString)).toBe(
+      "`_Behold!_`\n\\|\\|___~~***```js\n`use strict`;\nrequire('discord.js');```***~~___\\|\\|",
+    );
+  });
+
+  test('basic', () => {
+    expect(Util.escapeSpoiler('||test||')).toBe('\\|\\|test\\|\\|');
+  });
+});
+
+describe('escapeMarkdown', () => {
+  test('shared', () => {
+    expect(Util.escapeMarkdown(testString)).toBe(
+      "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
+    );
+  });
+
+  test('no codeBlock', () => {
+    expect(Util.escapeMarkdown(testString, { codeBlock: false })).toBe(
+      "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*```js\n\\`use strict\\`;\nrequire('discord.js');```\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
+    );
+  });
+
+  test('no inlineCode', () => {
+    expect(Util.escapeMarkdown(testString, { inlineCode: false })).toBe(
+      "`\\_Behold!\\_`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n`use strict`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
+    );
+  });
+
+  test('no bold', () => {
+    expect(Util.escapeMarkdown(testString, { bold: false })).toBe(
+      "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_\\~\\~\\***\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`**\\*\\~\\~\\_\\_\\_\\|\\|",
+    );
+  });
+
+  test('no italic', () => {
+    expect(Util.escapeMarkdown(testString, { italic: false })).toBe(
+      "\\`_Behold!_\\`\n\\|\\|_\\_\\_\\~\\~*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\**\\~\\~\\_\\__\\|\\|",
+    );
+  });
+
+  test('no underline', () => {
+    expect(Util.escapeMarkdown(testString, { underline: false })).toBe(
+      "\\`\\_Behold!\\_\\`\n\\|\\|\\___\\~\\~\\*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~__\\_\\|\\|",
+    );
+  });
+
+  test('no strikethrough', () => {
+    expect(Util.escapeMarkdown(testString, { strikethrough: false })).toBe(
+      "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_~~\\*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*~~\\_\\_\\_\\|\\|",
+    );
+  });
+
+  test('no spoiler', () => {
+    expect(Util.escapeMarkdown(testString, { spoiler: false })).toBe(
+      "\\`\\_Behold!\\_\\`\n||\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_||",
+    );
+  });
+
+  describe('code content', () => {
+    test('no code block content', () => {
+      expect(Util.escapeMarkdown(testString, { codeBlockContent: false })).toBe(
+        "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n`use strict`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
+      );
+    });
+
+    test('no inline code content', () => {
+      expect(Util.escapeMarkdown(testString, { inlineCodeContent: false })).toBe(
+        "\\`_Behold!_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
+      );
+    });
+
+    test('neither inline code or code block content', () => {
+      expect(Util.escapeMarkdown(testString, { inlineCodeContent: false, codeBlockContent: false }))
+        // eslint-disable-next-line max-len
+        .toBe(
+          "\\`_Behold!_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n`use strict`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
+        );
+    });
+
+    test('neither code blocks or code block content', () => {
+      expect(Util.escapeMarkdown(testString, { codeBlock: false, codeBlockContent: false })).toBe(
+        "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*```js\n`use strict`;\nrequire('discord.js');```\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
+      );
+    });
+
+    test('neither inline code or inline code content', () => {
+      expect(Util.escapeMarkdown(testString, { inlineCode: false, inlineCodeContent: false })).toBe(
+        "`_Behold!_`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n`use strict`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
+      );
+    });
+
+    test('edge-case odd number of fenses with no code block content', () => {
+      expect(
+        Util.escapeMarkdown('**foo** ```**bar**``` **fizz** ``` **buzz**', {
+          codeBlock: false,
+          codeBlockContent: false,
+        }),
+      ).toBe('\\*\\*foo\\*\\* ```**bar**``` \\*\\*fizz\\*\\* ``` \\*\\*buzz\\*\\*');
+    });
+
+    test('edge-case odd number of backticks with no inline code content', () => {
+      expect(
+        Util.escapeMarkdown('**foo** `**bar**` **fizz** ` **buzz**', { inlineCode: false, inlineCodeContent: false }),
+      ).toBe('\\*\\*foo\\*\\* `**bar**` \\*\\*fizz\\*\\* ` \\*\\*buzz\\*\\*');
+    });
+  });
+});
+
+/* eslint-enable max-len, no-undef */
diff --git a/test/random.js b/test/random.js
index 8bbd2551..05ec5fb2 100644
--- a/test/random.js
+++ b/test/random.js
@@ -1,16 +1,20 @@
+/* eslint-disable */
+
 'use strict';
 
-const Discord = require('../');
 const request = require('superagent');
-const fs = require('fs');
+const ytdl = require('ytdl-core');
+const { token, song } = require('./auth.js');
+const Discord = require('../');
 
 console.time('magic');
 
 const client = new Discord.Client({ fetchAllMembers: true, apiRequestMethod: 'sequential' });
 
-const { email, password, token, usertoken, song } = require('./auth.js');
-
-client.login(token).then(atoken => console.log('logged in')).catch(console.error);
+client
+  .login(token)
+  .then(() => console.log('logged in'))
+  .catch(console.error);
 
 client.on('ready', () => {
   console.log(`ready with ${client.users.size} users`);
@@ -33,8 +37,9 @@ client.on('message', message => {
     if (message.content === 'imma queue pls') {
       let count = 0;
       let ecount = 0;
-      for(let x = 0; x < 4000; x++) {
-        message.channel.send(`this is message ${x} of 3999`)
+      for (let x = 0; x < 4000; x++) {
+        message.channel
+          .send(`this is message ${x} of 3999`)
           .then(m => {
             count++;
             console.log('reached', count, ecount);
@@ -48,8 +53,9 @@ client.on('message', message => {
     }
 
     if (message.content === 'myperms?') {
-      message.channel.send('Your permissions are:\n' +
-        JSON.stringify(message.channel.permissionsFor(message.author).serialize(), null, 4));
+      message.channel.send(
+        `Your permissions are:\n${JSON.stringify(message.channel.permissionsFor(message.author).serialize(), null, 4)}`,
+      );
     }
 
     if (message.content === 'delchann') {
@@ -65,22 +71,26 @@ client.on('message', message => {
     }
 
     if (message.content.startsWith('botavatar')) {
-      request
-        .get('url')
-        .end((err, res) => {
-          client.user.setAvatar(res.body).catch(console.error)
-            .then(user => message.channel.send('Done!'));
-        });
+      request.get('url').end((err, res) => {
+        client.user
+          .setAvatar(res.body)
+          .catch(console.error)
+          .then(user => message.channel.send('Done!'));
+      });
     }
 
     if (message.content.startsWith('gn')) {
-      message.guild.setName(message.content.substr(3))
+      message.guild
+        .setName(message.content.substr(3))
         .then(guild => console.log('guild updated to', guild.name))
         .catch(console.error);
     }
 
     if (message.content === 'leave') {
-      message.guild.leave().then(guild => console.log('left guild', guild.name)).catch(console.error);
+      message.guild
+        .leave()
+        .then(guild => console.log('left guild', guild.name))
+        .catch(console.error);
     }
 
     if (message.content === 'stats') {
@@ -90,22 +100,29 @@ client.on('message', message => {
       m += `I am aware of ${client.channels.size} channels overall\n`;
       m += `I am aware of ${client.guilds.size} guilds overall\n`;
       m += `I am aware of ${client.users.size} users overall\n`;
-      message.channel.send(m).then(msg => msg.edit('nah')).catch(console.error);
+      message.channel
+        .send(m)
+        .then(msg => msg.edit('nah'))
+        .catch(console.error);
     }
 
     if (message.content === 'messageme!') {
       message.author.send('oh, hi there!').catch(e => console.log(e.stack));
     }
 
-    if (message.content === 'don\'t dm me') {
+    if (message.content === "don't dm me") {
       message.author.deleteDM();
     }
 
     if (message.content.startsWith('kick')) {
-      message.guild.member(message.mentions[0]).kick().then(member => {
-        console.log(member);
-        message.channel.send('Kicked!' + member.user.username);
-      }).catch(console.error);
+      message.guild
+        .member(message.mentions[0])
+        .kick()
+        .then(member => {
+          console.log(member);
+          message.channel.send(`Kicked!${member.user.username}`);
+        })
+        .catch(console.error);
     }
 
     if (message.content === 'ratelimittest') {
@@ -122,55 +139,72 @@ client.on('message', message => {
     }
 
     if (message.content === 'makerole') {
-      message.guild.createRole().then(role => {
-        message.channel.send(`Made role ${role.name}`);
-      }).catch(console.error);
+      message.guild
+        .createRole()
+        .then(role => {
+          message.channel.send(`Made role ${role.name}`);
+        })
+        .catch(console.error);
     }
   }
 });
 
 function nameLoop(user) {
-  // user.setUsername(user.username + 'a').then(nameLoop).catch(console.error);
+  // User.setUsername(user.username + 'a').then(nameLoop).catch(console.error);
 }
 
 function chanLoop(channel) {
-  channel.setName(channel.name + 'a').then(chanLoop).catch(console.error);
+  channel
+    .setName(`${channel.name}a`)
+    .then(chanLoop)
+    .catch(console.error);
 }
 
 client.on('message', msg => {
   if (msg.content.startsWith('?raw')) {
-    msg.channel.send('```' + msg.content + '```');
+    msg.channel.send(`\`\`\`${msg.content}\`\`\``);
   }
 
   if (msg.content.startsWith('#eval') && msg.author.id === '66564597481480192') {
     try {
-      const com = eval(msg.content.split(" ").slice(1).join(" "));
-      msg.channel.send('```\n' + com + '```');
-    } catch(e) {
-      msg.channel.send('```\n' + e + '```');
+      const com = eval(
+        msg.content
+          .split(' ')
+          .slice(1)
+          .join(' '),
+      );
+      msg.channel.send(`\`\`\`\n${com}\`\`\``);
+    } catch (e) {
+      msg.channel.send(`\`\`\`\n${e}\`\`\``);
     }
   }
 });
 
-const ytdl = require('ytdl-core');
-
 let disp, con;
 
 client.on('message', msg => {
   if (msg.content.startsWith('/play')) {
     console.log('I am now going to play', msg.content);
-    const chan = msg.content.split(' ').slice(1).join(' ');
-        const s = ytdl(chan, {filter:'audioonly'}, { passes : 3 });
+    const chan = msg.content
+      .split(' ')
+      .slice(1)
+      .join(' ');
+    const s = ytdl(chan, { filter: 'audioonly' }, { passes: 3 });
     s.on('error', e => console.log(`e w stream 1 ${e}`));
     con.playStream(s);
   }
   if (msg.content.startsWith('/join')) {
-    const chan = msg.content.split(' ').slice(1).join(' ');
-    msg.channel.guild.channels.get(chan).join()
+    const chan = msg.content
+      .split(' ')
+      .slice(1)
+      .join(' ');
+    msg.channel.guild.channels
+      .get(chan)
+      .join()
       .then(conn => {
         con = conn;
         msg.reply('done');
-        const s = ytdl(song, {filter:'audioonly'}, { passes : 3 });
+        const s = ytdl(song, { filter: 'audioonly' }, { passes: 3 });
         s.on('error', e => console.log(`e w stream 2 ${e}`));
         disp = conn.playStream(s);
         conn.player.on('debug', console.log);
@@ -198,10 +232,13 @@ client.on('message', m => {
         reaction.fetchUsers().then(users => {
           m.channel.send(
             `The following gave that message ${reaction.emoji}:\n` +
-            `${users.map(u => u.username).map(t => `- ${t}`).join('\n')}`
+              `${users
+                .map(u => u.username)
+                .map(t => `- ${t}`)
+                .join('\n')}`,
           );
         });
       }
     });
   }
-});
\ No newline at end of file
+});
diff --git a/test/sendtest.js b/test/sendtest.js
index 14d48260..186e1c23 100644
--- a/test/sendtest.js
+++ b/test/sendtest.js
@@ -1,10 +1,11 @@
-const Discord = require('../src');
-const { owner, token } = require('./auth.js');
+'use strict';
 
-const fetch = require('node-fetch');
 const fs = require('fs');
 const path = require('path');
 const util = require('util');
+const fetch = require('node-fetch');
+const { owner, token } = require('./auth.js');
+const Discord = require('../src');
 
 const client = new Discord.Client();
 
@@ -37,10 +38,11 @@ const tests = [
   m => m.channel.send('x', { embed: { description: 'a' } }),
   m => m.channel.send({ embed: { description: 'a' } }),
   m => m.channel.send({ files: [{ attachment: linkA }] }),
-  m => m.channel.send({
-    embed: { description: 'a' },
-    files: [{ attachment: linkA, name: 'xyz.png' }],
-  }),
+  m =>
+    m.channel.send({
+      embed: { description: 'a' },
+      files: [{ attachment: linkA, name: 'xyz.png' }],
+    }),
 
   m => m.channel.send('x', embed().setDescription('a')),
   m => m.channel.send(embed().setDescription('a')),
@@ -71,45 +73,50 @@ const tests = [
   m => m.channel.send(['x', 'y'], [attach(linkA), attach(linkB)]),
 
   m => m.channel.send([embed().setDescription('a'), attach(linkB)]),
-  m => m.channel.send({
-    embed: embed().setImage('attachment://two.png'),
-    files: [attach(linkB, 'two.png')],
-  }),
-  m => m.channel.send({
-    embed: embed()
-      .setImage('attachment://two.png')
-      .attachFiles([attach(linkB, 'two.png')]),
-  }),
-  async m => m.channel.send(['x', 'y', 'z'], {
-    code: 'js',
-    embed: embed()
-      .setImage('attachment://two.png')
-      .attachFiles([attach(linkB, 'two.png')]),
-    files: [{ attachment: await buffer(linkA) }],
-  }),
+  m =>
+    m.channel.send({
+      embed: embed().setImage('attachment://two.png'),
+      files: [attach(linkB, 'two.png')],
+    }),
+  m =>
+    m.channel.send({
+      embed: embed()
+        .setImage('attachment://two.png')
+        .attachFiles([attach(linkB, 'two.png')]),
+    }),
+  async m =>
+    m.channel.send(['x', 'y', 'z'], {
+      code: 'js',
+      embed: embed()
+        .setImage('attachment://two.png')
+        .attachFiles([attach(linkB, 'two.png')]),
+      files: [{ attachment: await buffer(linkA) }],
+    }),
 
   m => m.channel.send('x', attach(fileA)),
   m => m.channel.send({ files: [fileA] }),
   m => m.channel.send(attach(fileA)),
   async m => m.channel.send({ files: [await read(fileA)] }),
-  async m => m.channel.send(fill('x'), {
-    reply: m.author,
-    code: 'js',
-    split: true,
-    embed: embed().setImage('attachment://zero.png'),
-    files: [attach(await buffer(linkA), 'zero.png')],
-  }),
+  async m =>
+    m.channel.send(fill('x'), {
+      reply: m.author,
+      code: 'js',
+      split: true,
+      embed: embed().setImage('attachment://zero.png'),
+      files: [attach(await buffer(linkA), 'zero.png')],
+    }),
 
   m => m.channel.send('x', attach(readStream(fileA))),
   m => m.channel.send({ files: [readStream(fileA)] }),
   m => m.channel.send({ files: [{ attachment: readStream(fileA) }] }),
-  async m => m.channel.send(fill('xyz '), {
-    reply: m.author,
-    code: 'js',
-    split: { char: ' ', prepend: 'hello! ', append: '!!!' },
-    embed: embed().setImage('attachment://zero.png'),
-    files: [linkB, attach(await buffer(linkA), 'zero.png'), readStream(fileA)],
-  }),
+  async m =>
+    m.channel.send(fill('xyz '), {
+      reply: m.author,
+      code: 'js',
+      split: { char: ' ', prepend: 'hello! ', append: '!!!' },
+      embed: embed().setImage('attachment://zero.png'),
+      files: [linkB, attach(await buffer(linkA), 'zero.png'), readStream(fileA)],
+    }),
 
   m => m.channel.send('Done!'),
 ];
diff --git a/test/shard.js b/test/shard.js
index 5f5f17c4..702f70df 100644
--- a/test/shard.js
+++ b/test/shard.js
@@ -1,15 +1,22 @@
-const Discord = require('../');
+'use strict';
+
 const { token } = require('./auth.json');
+const Discord = require('../');
 
 const client = new Discord.Client({
-  shardId: process.argv[2],
+  shardID: process.argv[2],
   shardCount: process.argv[3],
 });
 
 client.on('message', msg => {
   if (msg.content.startsWith('?eval') && msg.author.id === '66564597481480192') {
     try {
-      const com = eval(msg.content.split(' ').slice(1).join(' '));
+      const com = eval(
+        msg.content
+          .split(' ')
+          .slice(1)
+          .join(' '),
+      );
       msg.channel.send(com, { code: true });
     } catch (e) {
       msg.channel.send(e, { code: true });
@@ -20,12 +27,13 @@ client.on('message', msg => {
 process.send(123);
 
 client.on('ready', () => {
-  console.log('Ready', client.options.shardId);
-  if (client.options.shardId === 0)
+  console.log('Ready', client.options.shardID);
+  if (client.options.shardID === 0) {
     setTimeout(() => {
       console.log('kek dying');
       client.destroy();
     }, 5000);
+  }
 });
 
 client.login(token).catch(console.error);
diff --git a/test/tester1000.js b/test/tester1000.js
index 99209c71..471860b3 100644
--- a/test/tester1000.js
+++ b/test/tester1000.js
@@ -1,16 +1,21 @@
-const Discord = require('../src');
+'use strict';
+
 const { token, prefix, owner } = require('./auth.js');
+const Discord = require('../src');
 
 // eslint-disable-next-line no-console
 const log = (...args) => console.log(process.uptime().toFixed(3), ...args);
 
-const client = new Discord.Client();
+const client = new Discord.Client({
+  shardCount: 2,
+});
 
 client.on('debug', log);
 client.on('ready', () => {
   log('READY', client.user.tag, client.user.id);
 });
 client.on('rateLimit', log);
+client.on('error', console.error);
 
 const commands = {
   eval: message => {
@@ -32,7 +37,10 @@ const commands = {
 client.on('message', message => {
   if (!message.content.startsWith(prefix) || message.author.bot) return;
 
-  message.content = message.content.replace(prefix, '').trim().split(' ');
+  message.content = message.content
+    .replace(prefix, '')
+    .trim()
+    .split(' ');
   const command = message.content.shift();
   message.content = message.content.join(' ');
 
diff --git a/test/voice.js b/test/voice.js
index 70b5c30f..8ee9c722 100644
--- a/test/voice.js
+++ b/test/voice.js
@@ -1,32 +1,22 @@
 /* eslint no-console: 0 */
 'use strict';
 
-const Discord = require('../');
 const ytdl = require('ytdl-core');
-const prism = require('prism-media');
-const fs = require('fs');
-
-const client = new Discord.Client({ fetchAllMembers: false, apiRequestMethod: 'sequential' });
-
 const auth = require('./auth.js');
+const Discord = require('../');
 
-client.login(auth.token).then(() => console.log('logged')).catch(console.error);
+const client = new Discord.Client({ fetchAllMembers: false, partials: [], apiRequestMethod: 'sequential' });
+
+client
+  .login(auth.token)
+  .then(() => console.log('logged'))
+  .catch(console.error);
 
 const connections = new Map();
 
-var d, b;
-
 client.on('debug', console.log);
 client.on('error', console.log);
 
-async function wait(time = 1000) {
-  return new Promise(resolve => {
-    setTimeout(resolve, time);
-  });
-}
-
-var count = 0;
-
 process.on('unhandledRejection', console.log);
 
 client.on('presenceUpdate', (a, b) => {
@@ -34,6 +24,15 @@ client.on('presenceUpdate', (a, b) => {
   console.log(a ? a.status : null, b.status, b.user.username);
 });
 
+client.on('messageDelete', async m => {
+  if (m.channel.id !== '80426989059575808') return;
+  console.log(m.channel.recipient);
+  console.log(m.channel.partial);
+  await m.channel.fetch();
+  console.log('\n\n\n\n');
+  console.log(m.channel);
+});
+
 client.on('message', m => {
   if (!m.guild) return;
   if (m.author.id !== '66564597481480192') return;
@@ -45,15 +44,19 @@ client.on('message', m => {
         conn.player.on('error', (...e) => console.log('player', ...e));
         if (!connections.has(m.guild.id)) connections.set(m.guild.id, { conn, queue: [] });
         m.reply('ok!');
-        // conn.playOpusStream(fs.createReadStream('C:/users/amish/downloads/z.ogg').pipe(new prism.OggOpusDemuxer()));
-        d = conn.play(ytdl('https://www.youtube.com/watch?v=_XXOSf0s2nk', { filter: 'audioonly' }, { passes: 3 }));
+        conn.play(ytdl('https://www.youtube.com/watch?v=_XXOSf0s2nk', { filter: 'audioonly' }, { passes: 3 }));
       });
     } else {
       m.reply('Specify a voice channel!');
     }
   } else if (m.content.startsWith('#eval') && m.author.id === '66564597481480192') {
     try {
-      const com = eval(m.content.split(' ').slice(1).join(' '));
+      const com = eval(
+        m.content
+          .split(' ')
+          .slice(1)
+          .join(' '),
+      );
       m.channel.send(com, { code: true });
     } catch (e) {
       console.log(e);
diff --git a/test/webhooktest.js b/test/webhooktest.js
new file mode 100644
index 00000000..f73c693f
--- /dev/null
+++ b/test/webhooktest.js
@@ -0,0 +1,152 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const fetch = require('node-fetch');
+const { owner, token, webhookChannel, webhookToken } = require('./auth.js');
+const Discord = require('../src');
+
+const client = new Discord.Client();
+
+const fill = c => Array(4).fill(c.repeat(1000));
+const buffer = l => fetch(l).then(res => res.buffer());
+const read = util.promisify(fs.readFile);
+const readStream = fs.createReadStream;
+const wait = util.promisify(setTimeout);
+
+const linkA = 'https://lolisafe.moe/iiDMtAXA.png';
+const linkB = 'https://lolisafe.moe/9hSpedPh.png';
+const fileA = path.join(__dirname, 'blobReach.png');
+
+const embed = () => new Discord.MessageEmbed();
+const attach = (attachment, name) => new Discord.MessageAttachment(attachment, name);
+
+const tests = [
+  (m, hook) => hook.send('x'),
+  (m, hook) => hook.send(['x', 'y']),
+
+  (m, hook) => hook.send('x', { code: true }),
+  (m, hook) => hook.send('1', { code: 'js' }),
+  (m, hook) => hook.send('x', { code: '' }),
+
+  (m, hook) => hook.send(fill('x'), { split: true }),
+  (m, hook) => hook.send(fill('1'), { code: 'js', split: true }),
+  (m, hook) => hook.send(fill('x'), { reply: m.author, code: 'js', split: true }),
+  (m, hook) => hook.send(fill('xyz '), { split: { char: ' ' } }),
+
+  (m, hook) => hook.send({ embeds: [{ description: 'a' }] }),
+  (m, hook) => hook.send({ files: [{ attachment: linkA }] }),
+  (m, hook) =>
+    hook.send({
+      embeds: [{ description: 'a' }],
+      files: [{ attachment: linkA, name: 'xyz.png' }],
+    }),
+
+  (m, hook) => hook.send('x', embed().setDescription('a')),
+  (m, hook) => hook.send(embed().setDescription('a')),
+  (m, hook) => hook.send({ embeds: [embed().setDescription('a')] }),
+  (m, hook) => hook.send([embed().setDescription('a'), embed().setDescription('b')]),
+
+  (m, hook) => hook.send('x', attach(linkA)),
+  (m, hook) => hook.send(attach(linkA)),
+  (m, hook) => hook.send({ files: [linkA] }),
+  (m, hook) => hook.send({ files: [attach(linkA)] }),
+  async (m, hook) => hook.send(attach(await buffer(linkA))),
+  async (m, hook) => hook.send({ files: [await buffer(linkA)] }),
+  async (m, hook) => hook.send({ files: [{ attachment: await buffer(linkA) }] }),
+  (m, hook) => hook.send([attach(linkA), attach(linkB)]),
+
+  (m, hook) => hook.send(embed().setDescription('a')),
+
+  (m, hook) => hook.send({ embeds: [{ description: 'a' }] }),
+  (m, hook) => hook.send(embed().setDescription('a')),
+
+  (m, hook) => hook.send(['x', 'y'], [embed().setDescription('a'), attach(linkB)]),
+  (m, hook) => hook.send(['x', 'y'], [attach(linkA), attach(linkB)]),
+
+  (m, hook) => hook.send([embed().setDescription('a'), attach(linkB)]),
+  (m, hook) =>
+    hook.send({
+      embeds: [embed().setImage('attachment://two.png')],
+      files: [attach(linkB, 'two.png')],
+    }),
+  (m, hook) =>
+    hook.send({
+      embeds: [
+        embed()
+          .setImage('attachment://two.png')
+          .attachFiles([attach(linkB, 'two.png')]),
+      ],
+    }),
+  async (m, hook) =>
+    hook.send(['x', 'y', 'z'], {
+      code: 'js',
+      embeds: [
+        embed()
+          .setImage('attachment://two.png')
+          .attachFiles([attach(linkB, 'two.png')]),
+      ],
+      files: [{ attachment: await buffer(linkA) }],
+    }),
+
+  (m, hook) => hook.send('x', attach(fileA)),
+  (m, hook) => hook.send({ files: [fileA] }),
+  (m, hook) => hook.send(attach(fileA)),
+  async (m, hook) => hook.send({ files: [await read(fileA)] }),
+  async (m, hook) =>
+    hook.send(fill('x'), {
+      reply: m.author,
+      code: 'js',
+      split: true,
+      embeds: [embed().setImage('attachment://zero.png')],
+      files: [attach(await buffer(linkA), 'zero.png')],
+    }),
+
+  (m, hook) => hook.send('x', attach(readStream(fileA))),
+  (m, hook) => hook.send({ files: [readStream(fileA)] }),
+  (m, hook) => hook.send({ files: [{ attachment: readStream(fileA) }] }),
+  async (m, hook) =>
+    hook.send(fill('xyz '), {
+      reply: m.author,
+      code: 'js',
+      split: { char: ' ', prepend: 'hello! ', append: '!!!' },
+      embeds: [embed().setImage('attachment://zero.png')],
+      files: [linkB, attach(await buffer(linkA), 'zero.png'), readStream(fileA)],
+    }),
+
+  (m, hook) => hook.send('Done!'),
+];
+
+client.on('message', async message => {
+  if (message.author.id !== owner) return;
+  const match = message.content.match(/^do (.+)$/);
+  const hooks = [
+    { type: 'WebhookClient', hook: new Discord.WebhookClient(webhookChannel, webhookToken) },
+    { type: 'TextChannel#fetchWebhooks', hook: await message.channel.fetchWebhooks().then(x => x.first()) },
+    { type: 'Guild#fetchWebhooks', hook: await message.guild.fetchWebhooks().then(x => x.first()) },
+  ];
+  if (match && match[1] === 'it') {
+    /* eslint-disable no-await-in-loop */
+    for (const { type, hook } of hooks) {
+      for (const [i, test] of tests.entries()) {
+        await message.channel.send(`**#${i}-Hook: ${type}**\n\`\`\`js\n${test.toString()}\`\`\``);
+        await test(message, hook).catch(e => message.channel.send(`Error!\n\`\`\`\n${e}\`\`\``));
+        await wait(1000);
+      }
+    }
+    /* eslint-enable no-await-in-loop */
+  } else if (match) {
+    const n = parseInt(match[1]) || 0;
+    const test = tests.slice(n)[0];
+    const i = tests.indexOf(test);
+    /* eslint-disable no-await-in-loop */
+    for (const { type, hook } of hooks) {
+      await message.channel.send(`**#${i}-Hook: ${type}**\n\`\`\`js\n${test.toString()}\`\`\``);
+      await test(message, hook).catch(e => message.channel.send(`Error!\n\`\`\`\n${e}\`\`\``));
+    }
+    /* eslint-enable no-await-in-loop */
+  }
+});
+
+client.login(token);
diff --git a/test/webpack.html b/test/webpack.html
index 6de81a55..375fc7c1 100644
--- a/test/webpack.html
+++ b/test/webpack.html
@@ -1,32 +1,33 @@
 <!DOCTYPE html>
 <html>
-<head>
-  <title>discord.js Webpack test</title>
-  <meta charset="utf-8" />
-</head>
-<body>
-  <script type="text/javascript" src="../webpack/discord.js"></script>
-  <script type="text/javascript">
-    (() => {
-      const client = window.client = new Discord.Client();
+  <head>
+    <title>discord.js Webpack test</title>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <script type="text/javascript" src="../webpack/discord.js"></script>
+    <script type="text/javascript">
+      (() => {
+        const client = (window.client = new Discord.Client());
 
-      client.on('ready', () => {
-        console.log('[CLIENT] Ready!');
-      });
+        client.on('ready', () => {
+          console.log('[CLIENT] Ready!');
+        });
 
-      client.on('debug', console.log);
+        client.on('debug', console.log);
 
-      client.on('error', console.error);
+        client.on('error', console.error);
 
-      client.ws.on('close', (event) => console.log('[CLIENT] Disconnect!', event));
+        client.ws.on('close', event => console.log('[CLIENT] Disconnect!', event));
 
-      client.on('message', (message) => {
-        console.log(message.author.username, message.author.id, message.content);
-      });
+        client.on('message', message => {
+          console.log(message.author.username, message.author.id, message.content);
+        });
 
-      client.login(localStorage.token || window.token || prompt('token pls', 'abcdef123456'))
-      .then((token) => localStorage.token = token, console.log);
-    })();
-  </script>
-</body>
+        client
+          .login(localStorage.token || window.token || prompt('token pls', 'abcdef123456'))
+          .then(token => (localStorage.token = token), console.log);
+      })();
+    </script>
+  </body>
 </html>
diff --git a/travis/deploy-key.enc b/travis/deploy-key.enc
deleted file mode 100644
index e03fc36d..00000000
Binary files a/travis/deploy-key.enc and /dev/null differ
diff --git a/travis/deploy.sh b/travis/deploy.sh
deleted file mode 100644
index 39b57909..00000000
--- a/travis/deploy.sh
+++ /dev/null
@@ -1,83 +0,0 @@
-#!/bin/bash
-# Adapted from https://gist.github.com/domenic/ec8b0fc8ab45f39403dd.
-set -e
-
-# For revert branches, do nothing
-if [[ "$TRAVIS_BRANCH" == revert-* ]] || [[ "$TRAVIS_BRANCH" == dependabot/* ]]; then
-  echo -e "\e[36m\e[1mBuild triggered for reversion branch \"${TRAVIS_BRANCH}\" - doing nothing."
-  exit 0
-fi
-
-DONT_COMMIT=false
-
-if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
-  echo -e "\e[36m\e[1mBuild triggered for PR #${TRAVIS_PULL_REQUEST} to branch \"${TRAVIS_BRANCH}\" - not commiting"
-  SOURCE_TYPE="pr"
-  DONT_COMMIT=true
-elif [ -n "$TRAVIS_TAG" ]; then
-  echo -e "\e[36m\e[1mBuild triggered for tag \"${TRAVIS_TAG}\"."
-  SOURCE=$TRAVIS_TAG
-  SOURCE_TYPE="tag"
-else
-  echo -e "\e[36m\e[1mBuild triggered for branch \"${TRAVIS_BRANCH}\"."
-  SOURCE=$TRAVIS_BRANCH
-  SOURCE_TYPE="branch"
-fi
-
-# Run the build
-npm run docs
-NODE_ENV=production npm run build:browser
-
-if [ $DONT_COMMIT == true ]; then
-  echo -e "\e[36m\e[1mNot commiting - exiting early"
-  exit 0
-fi
-
-# Initialise some useful variables
-REPO=`git config remote.origin.url`
-SSH_REPO=${REPO/https:\/\/github.com\//git@github.com:}
-SHA=`git rev-parse --verify HEAD`
-
-# Decrypt and add the ssh key
-ENCRYPTED_KEY_VAR="encrypted_${ENCRYPTION_LABEL}_key"
-ENCRYPTED_IV_VAR="encrypted_${ENCRYPTION_LABEL}_iv"
-ENCRYPTED_KEY=${!ENCRYPTED_KEY_VAR}
-ENCRYPTED_IV=${!ENCRYPTED_IV_VAR}
-openssl aes-256-cbc -K $ENCRYPTED_KEY -iv $ENCRYPTED_IV -in travis/deploy-key.enc -out deploy-key -d
-chmod 600 deploy-key
-eval `ssh-agent -s`
-ssh-add deploy-key
-
-# Checkout the repo in the target branch so we can build docs and push to it
-TARGET_BRANCH="docs"
-git clone $REPO out -b $TARGET_BRANCH
-
-# Move the generated JSON file to the newly-checked-out repo, to be committed and pushed
-mv docs/docs.json out/$SOURCE.json
-
-# Commit and push
-cd out
-git add .
-git config user.name "Travis CI"
-git config user.email "$COMMIT_AUTHOR_EMAIL"
-git commit -m "Docs build for ${SOURCE_TYPE} ${SOURCE}: ${SHA}" || true
-git push $SSH_REPO $TARGET_BRANCH
-
-# Clean up...
-cd ..
-rm -rf out
-
-# ...then do the same once more for the webpack
-TARGET_BRANCH="webpack"
-git clone $REPO out -b $TARGET_BRANCH
-
-# Move the generated webpack over
-mv webpack/discord.min.js out/discord.$SOURCE.min.js
-
-# Commit and push
-cd out
-git add .
-git config user.name "Travis CI"
-git config user.email "$COMMIT_AUTHOR_EMAIL"
-git commit -m "Webpack build for ${SOURCE_TYPE} ${SOURCE}: ${SHA}" || true
-git push $SSH_REPO $TARGET_BRANCH
diff --git a/travis/test.sh b/travis/test.sh
deleted file mode 100644
index bef6134e..00000000
--- a/travis/test.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/bin/bash
-set -e
-
-# For revert branches, do nothing
-if [[ "$TRAVIS_BRANCH" == revert-* ]]; then
-  echo -e "\e[36m\e[1mTest triggered for reversion branch \"${TRAVIS_BRANCH}\" - doing nothing."
-  exit 0
-fi
-
-# For PRs
-if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
-  echo -e "\e[36m\e[1mTest triggered for PR #${TRAVIS_PULL_REQUEST}."
-fi
-
-# Figure out the source of the test
-if [ -n "$TRAVIS_TAG" ]; then
-  echo -e "\e[36m\e[1mTest triggered for tag \"${TRAVIS_TAG}\"."
-else
-  echo -e "\e[36m\e[1mTest triggered for branch \"${TRAVIS_BRANCH}\"."
-fi
-
-# Run the tests
-npm test
diff --git a/tsconfig.json b/tsconfig.json
index 37aa901e..02c9ecc2 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,13 +1,15 @@
 {
-    "compilerOptions": {
-        "module": "commonjs",
-        "target": "es6",
-        "noImplicitAny": true,
-        "strictNullChecks": true,
-        "noEmit": true,
-        "forceConsistentCasingInFileNames": true
-    },
-    "files": [
-        "typings/index.d.ts"
-    ]
+  "compilerOptions": {
+    "strict": true,
+    "moduleResolution": "node",
+    "declaration": false,
+    "removeComments": false,
+    "alwaysStrict": true,
+    "pretty": true,
+    "module": "commonjs",
+    "target": "es2019",
+    "lib": ["esnext", "esnext.array", "esnext.asynciterable", "esnext.intl", "esnext.symbol"],
+    "sourceMap": false,
+    "skipLibCheck": true
+  }
 }
diff --git a/tslint.json b/tslint.json
index 71f85026..61a76085 100644
--- a/tslint.json
+++ b/tslint.json
@@ -1,62 +1,28 @@
 {
-    "extends": [
-        "tslint-config-typings"
-    ],
-    "rules": {
-        "class-name": true,
-        "comment-format": [
-            true,
-            "check-space"
-        ],
-        "indent": [
-            true,
-            "tabs"
-        ],
-        "no-duplicate-variable": true,
-        "no-unused-variable": [false],
-        "no-eval": true,
-        "no-internal-module": true,
-        "no-trailing-whitespace": true,
-        "no-unsafe-finally": true,
-        "no-var-keyword": true,
-        "one-line": [
-            true,
-            "check-open-brace",
-            "check-whitespace"
-        ],
-        "quotemark": [
-            true,
-            "single"
-        ],
-        "semicolon": [
-            true,
-            "always"
-        ],
-        "triple-equals": [
-            true,
-            "allow-null-check"
-        ],
-        "typedef-whitespace": [
-            true,
-            {
-                "call-signature": "nospace",
-                "index-signature": "nospace",
-                "parameter": "nospace",
-                "property-declaration": "nospace",
-                "variable-declaration": "nospace"
-            }
-        ],
-        "variable-name": [
-            true,
-            "ban-keywords"
-        ],
-        "whitespace": [
-            true,
-            "check-branch",
-            "check-decl",
-            "check-operator",
-            "check-separator",
-            "check-type"
-        ]
-    }
+  "extends": ["dtslint/dtslint.json"],
+  "rules": {
+    "prefer-readonly": false,
+    "await-promise": false,
+    "no-for-in-array": false,
+    "no-null-undefined-union": false,
+    "no-promise-as-boolean": false,
+    "no-void-expression": false,
+    "strict-string-expressions": false,
+    "strict-comparisons": false,
+    "use-default-type-parameter": false,
+    "no-boolean-literal-compare": false,
+    "no-unnecessary-qualifier": false,
+    "no-unnecessary-type-assertion": false,
+    "expect": false,
+    "no-import-default-of-export-equals": false,
+    "no-relative-import-in-test": false,
+    "no-unnecessary-generics": false,
+    "strict-export-declare-modifiers": false,
+    "no-single-declare-module": false,
+    "member-access": true,
+    "no-unnecessary-class": false,
+    "array-type": [true, "array"],
+
+    "no-any-union": false
+  }
 }
diff --git a/typings/index.d.ts b/typings/index.d.ts
index 9a66fee1..b11becce 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -1,2120 +1,3025 @@
-// Type definitions for discord.js 12.0.0
-// Project: https://github.com/hydrabolt/discord.js
-// Definitions by:
-//   acdenisSK <acdenissk69@gmail.com> (https://github.com/acdenisSK)
-//   Zack Campbell <zajrik@gmail.com> (https://github.com/zajrik)
-//   iCrawl <icrawltogo@gmail.com> (https://github.com/iCrawl)
-// License: MIT
+declare enum ChannelType {
+  text,
+  dm,
+  voice,
+  group,
+  category,
+  news,
+  store,
+  unknown,
+}
 
 declare module 'discord.js' {
-	import { EventEmitter } from 'events';
-	import { Stream, Readable, Writable } from 'stream';
-	import { ChildProcess } from 'child_process';
-
-	export const version: string;
-
-//#region Classes
-
-	export class Activity {
-		constructor(presence: Presence, data?: object);
-		public applicationID: Snowflake;
-		public assets: RichPresenceAssets;
-		public details: string;
-		public name: string;
-		public party: {
-			id: string;
-			size: [number, number];
-		};
-		public state: string;
-		public timestamps: {
-			start: Date;
-			end: Date;
-		};
-		public type: ActivityType;
-		public url: string;
-		public equals(activity: Activity): boolean;
-	}
-
-	export class ActivityFlags extends BitField<ActivityFlagsString> {
-		public static FLAGS: Record<ActivityFlagsString, number>;
-		public static resolve(bit?: BitFieldResolvable<ActivityFlagsString>): number;
-	}
-
-	export class APIMessage {
-		constructor(target: MessageTarget, options: MessageOptions | WebhookMessageOptions);
-		public data?: object;
-		public readonly isUser: boolean;
-		public readonly isWebhook: boolean;
-		public files?: object[];
-		public options: MessageOptions | WebhookMessageOptions;
-		public target: MessageTarget;
-
-		public static create(
-			target: MessageTarget,
-			content?: StringResolvable,
-			options?: MessageOptions | WebhookMessageOptions | MessageAdditions,
-			extra?: MessageOptions | WebhookMessageOptions
-		): APIMessage;
-		public static partitionMessageAdditions(items: (MessageEmbed | MessageAttachment)[]): [MessageEmbed[], MessageAttachment[]];
-		public static resolveFile(fileLike: BufferResolvable | Stream | FileOptions | MessageAttachment): Promise<object>;
-		public static transformOptions(
-			content: StringResolvable,
-			options: MessageOptions | WebhookMessageOptions | MessageAdditions,
-			extra?: MessageOptions | WebhookMessageOptions,
-			isWebhook?: boolean
-		): MessageOptions | WebhookMessageOptions;
-
-		public makeContent(): string | string[];
-		public resolve(): Promise<this>;
-		public resolveData(): this;
-		public resolveFiles(): Promise<this>;
-		public split(): APIMessage[];
-	}
-
-	export class Base {
-		constructor (client: Client);
-		public readonly client: Client;
-		public toJSON(...props: { [key: string]: boolean | string }[]): object;
-		public valueOf(): string;
-	}
-
-	export class BaseClient extends EventEmitter {
-		constructor(options?: ClientOptions);
-		private _intervals: Set<NodeJS.Timer>;
-		private _timeouts: Set<NodeJS.Timer>;
-		private readonly api: object;
-		private rest: object;
-
-		public options: ClientOptions;
-		public clearInterval(interval: NodeJS.Timer): void;
-		public clearTimeout(timeout: NodeJS.Timer): void;
-		public destroy(): void;
-		public setInterval(fn: Function, delay: number, ...args: any[]): NodeJS.Timer;
-		public setTimeout(fn: Function, delay: number, ...args: any[]): NodeJS.Timer;
-		public toJSON(...props: { [key: string]: boolean | string }[]): object;
-	}
-
-	class BroadcastDispatcher extends VolumeMixin(StreamDispatcher) {
-		public broadcast: VoiceBroadcast;
-	}
-
-	export class BitField<S extends string> {
-		constructor(bits?: BitFieldResolvable<S>);
-		public bitfield: number;
-		public add(...bits: BitFieldResolvable<S>[]): BitField<S>;
-		public equals(bit: BitFieldResolvable<S>): boolean;
-		public freeze(): Readonly<BitField<S>>;
-		public has(bit: BitFieldResolvable<S>): boolean;
-		public missing(bits: BitFieldResolvable<S>, ...hasParams: any[]): S[];
-		public remove(...bits: BitFieldResolvable<S>[]): BitField<S>;
-		public serialize(...hasParams: BitFieldResolvable<S>[]): Record<S, boolean>;
-		public toArray(): S[];
-		public toJSON(): number;
-		public valueOf(): number;
-		public [Symbol.iterator](): Iterator<S>;
-		public static FLAGS: object;
-		public static resolve(bit?: BitFieldResolvable<any>): number;
-	}
-
-	export class CategoryChannel extends GuildChannel {
-		public readonly children: Collection<Snowflake, GuildChannel>;
-	}
-
-	export class Channel extends Base {
-		constructor(client: Client, data?: object);
-		public readonly createdAt: Date;
-		public readonly createdTimestamp: number;
-		public deleted: boolean;
-		public id: Snowflake;
-		public type: 'dm' | 'group' | 'text' | 'voice' | 'category' | 'unknown';
-		public delete(reason?: string): Promise<Channel>;
-		public toString(): string;
-	}
-
-	export class Client extends BaseClient {
-		constructor(options?: ClientOptions);
-		private readonly _pingTimestamp: number;
-		private actions: object;
-		private manager: ClientManager;
-		private voice: object;
-		private ws: object;
-		private _eval(script: string): any;
-		private _pong(startTime: number): void;
-		private _validateOptions(options?: ClientOptions): void;
-
-		public broadcasts: VoiceBroadcast[];
-		public channels: ChannelStore;
-		public readonly emojis: GuildEmojiStore;
-		public guilds: GuildStore;
-		public readonly ping: number;
-		public pings: number[];
-		public readyAt: Date;
-		public readonly readyTimestamp: number;
-		public shard: ShardClientUtil;
-		public readonly status: Status;
-		public token: string;
-		public readonly uptime: number;
-		public user: ClientUser;
-		public users: UserStore;
-		public readonly voiceConnections: Collection<Snowflake, VoiceConnection>;
-		public createVoiceBroadcast(): VoiceBroadcast;
-		public fetchApplication(): Promise<ClientApplication>;
-		public fetchInvite(invite: InviteResolvable): Promise<Invite>;
-		public fetchVoiceRegions(): Promise<Collection<string, VoiceRegion>>;
-		public fetchWebhook(id: Snowflake, token?: string): Promise<Webhook>;
-		public generateInvite(permissions?: PermissionResolvable): Promise<string>;
-		public login(token?: string): Promise<string>;
-		public sweepMessages(lifetime?: number): number;
-		public toJSON(): object;
-
-		public on(event: 'channelCreate' | 'channelDelete', listener: (channel: Channel) => void): this;
-		public on(event: 'channelPinsUpdate', listener: (channel: Channel, time: Date) => void): this;
-		public on(event: 'channelUpdate', listener: (oldChannel: Channel, newChannel: Channel) => void): this;
-		public on(event: 'debug' | 'warn', listener: (info: string) => void): this;
-		public on(event: 'disconnect', listener: (event: any) => void): this;
-		public on(event: 'emojiCreate' | 'emojiDelete', listener: (emoji: GuildEmoji) => void): this;
-		public on(event: 'emojiUpdate', listener: (oldEmoji: GuildEmoji, newEmoji: GuildEmoji) => void): this;
-		public on(event: 'error', listener: (error: Error) => void): this;
-		public on(event: 'guildBanAdd' | 'guildBanRemove', listener: (guild: Guild, user: User) => void): this;
-		public on(event: 'guildCreate' | 'guildDelete' | 'guildUnavailable', listener: (guild: Guild) => void): this;
-		public on(event: 'guildMemberAdd' | 'guildMemberAvailable' | 'guildMemberRemove', listener: (member: GuildMember) => void): this;
-		public on(event: 'guildMembersChunk', listener: (members: Collection<Snowflake, GuildMember>, guild: Guild) => void): this;
-		public on(event: 'guildMemberSpeaking', listener: (member: GuildMember, speaking: Readonly<Speaking>) => void): this;
-		public on(event: 'guildMemberUpdate', listener: (oldMember: GuildMember, newMember: GuildMember) => void): this;
-		public on(event: 'guildUpdate', listener: (oldGuild: Guild, newGuild: Guild) => void): this;
-		public on(event: 'guildIntegrationsUpdate', listener: (guild: Guild) => void): this;
-		public on(event: 'message' | 'messageDelete' | 'messageReactionRemoveAll', listener: (message: Message) => void): this;
-		public on(event: 'messageDeleteBulk', listener: (messages: Collection<Snowflake, Message>) => void): this;
-		public on(event: 'messageReactionAdd' | 'messageReactionRemove', listener: (messageReaction: MessageReaction, user: User) => void): this;
-		public on(event: 'messageUpdate', listener: (oldMessage: Message, newMessage: Message) => void): this;
-		public on(event: 'presenceUpdate', listener: (oldPresence: Presence | undefined, newPresence: Presence) => void): this;
-		public on(event: 'rateLimit', listener: (rateLimitData: RateLimitData) => void): this;
-		public on(event: 'ready' | 'reconnecting', listener: () => void): this;
-		public on(event: 'resumed', listener: (replayed: number) => void): this;
-		public on(event: 'roleCreate' | 'roleDelete', listener: (role: Role) => void): this;
-		public on(event: 'roleUpdate', listener: (oldRole: Role, newRole: Role) => void): this;
-		public on(event: 'typingStart' | 'typingStop', listener: (channel: Channel, user: User) => void): this;
-		public on(event: 'userUpdate', listener: (oldUser: User, newUser: User) => void): this;
-		public on(event: 'voiceStateUpdate', listener: (oldState: VoiceState | undefined, newState: VoiceState) => void): this;
-		public on(event: 'webhookUpdate', listener: (channel: TextChannel) => void): this;
-		public on(event: string, listener: Function): this;
-
-		public once(event: 'channelCreate' | 'channelDelete', listener: (channel: Channel) => void): this;
-		public once(event: 'channelPinsUpdate', listener: (channel: Channel, time: Date) => void): this;
-		public once(event: 'channelUpdate', listener: (oldChannel: Channel, newChannel: Channel) => void): this;
-		public once(event: 'debug' | 'warn', listener: (info: string) => void): this;
-		public once(event: 'disconnect', listener: (event: any) => void): this;
-		public once(event: 'emojiCreate' | 'emojiDelete', listener: (emoji: GuildEmoji) => void): this;
-		public once(event: 'emojiUpdate', listener: (oldEmoji: GuildEmoji, newEmoji: GuildEmoji) => void): this;
-		public once(event: 'error', listener: (error: Error) => void): this;
-		public once(event: 'guildBanAdd' | 'guildBanRemove', listener: (guild: Guild, user: User) => void): this;
-		public once(event: 'guildCreate' | 'guildDelete' | 'guildUnavailable', listener: (guild: Guild) => void): this;
-		public once(event: 'guildMemberAdd' | 'guildMemberAvailable' | 'guildMemberRemove', listener: (member: GuildMember) => void): this;
-		public once(event: 'guildMembersChunk', listener: (members: Collection<Snowflake, GuildMember>, guild: Guild) => void): this;
-		public once(event: 'guildMemberSpeaking', listener: (member: GuildMember, speaking: Readonly<Speaking>) => void): this;
-		public once(event: 'guildMemberUpdate', listener: (oldMember: GuildMember, newMember: GuildMember) => void): this;
-		public once(event: 'guildUpdate', listener: (oldGuild: Guild, newGuild: Guild) => void): this;
-		public once(event: 'guildIntegrationsUpdate', listener: (guild: Guild) => void): this;
-		public once(event: 'message' | 'messageDelete' | 'messageReactionRemoveAll', listener: (message: Message) => void): this;
-		public once(event: 'messageDeleteBulk', listener: (messages: Collection<Snowflake, Message>) => void): this;
-		public once(event: 'messageReactionAdd' | 'messageReactionRemove', listener: (messageReaction: MessageReaction, user: User) => void): this;
-		public once(event: 'messageUpdate', listener: (oldMessage: Message, newMessage: Message) => void): this;
-		public once(event: 'presenceUpdate', listener: (oldPresence: Presence | undefined, newPresence: Presence) => void): this;
-		public once(event: 'rateLimit', listener: (rateLimitData: RateLimitData) => void): this;
-		public once(event: 'ready' | 'reconnecting', listener: () => void): this;
-		public once(event: 'resumed', listener: (replayed: number) => void): this;
-		public once(event: 'roleCreate' | 'roleDelete', listener: (role: Role) => void): this;
-		public once(event: 'roleUpdate', listener: (oldRole: Role, newRole: Role) => void): this;
-		public once(event: 'typingStart' | 'typingStop', listener: (channel: Channel, user: User) => void): this;
-		public once(event: 'userUpdate', listener: (oldUser: User, newUser: User) => void): this;
-		public once(event: 'voiceStateUpdate', listener: (oldState: VoiceState | undefined, newState: VoiceState) => void): this;
-		public once(event: 'webhookUpdate', listener: (channel: TextChannel) => void): this;
-		public once(event: string, listener: Function): this;
-	}
-
-	export class ClientApplication extends Base {
-		constructor(client: Client, data: object);
-		public botPublic?: boolean;
-		public botRequireCodeGrant?: boolean;
-		public cover?: string;
-		public readonly createdAt: Date;
-		public readonly createdTimestamp: number;
-		public description: string;
-		public icon: string;
-		public id: Snowflake;
-		public name: string;
-		public owner?: User;
-		public rpcOrigins: string[];
-		public coverImage(options?: AvatarOptions): string;
-		public fetchAssets(): Promise<ClientApplicationAsset>;
-		public iconURL(options?: AvatarOptions): string;
-		public toJSON(): object;
-		public toString(): string;
-	}
-
-	class ClientManager {
-		constructor(client: Client);
-		public client: Client;
-		public heartbeatInterval: number;
-		public readonly status: number;
-		public connectToWebSocket(token: string, resolve: Function, reject: Function): void;
-	}
-
-	export interface ActivityOptions {
-		name?: string;
-		url?: string;
-		type?: ActivityType | number;
-	}
-
-	export class ClientUser extends User {
-		public mfaEnabled: boolean;
-		public verified: boolean;
-		public createGroupDM(recipients: GroupDMRecipientOptions[]): Promise<GroupDMChannel>;
-		public setActivity(options?: ActivityOptions): Promise<Presence>;
-		public setActivity(name: string, options?: ActivityOptions): Promise<Presence>;
-		public setAFK(afk: boolean): Promise<Presence>;
-		public setAvatar(avatar: BufferResolvable | Base64Resolvable): Promise<ClientUser>;
-		public setPresence(data: PresenceData): Promise<Presence>;
-		public setStatus(status: PresenceStatus): Promise<Presence>;
-		public setUsername(username: string): Promise<ClientUser>;
-	}
-
-	export class Collection<K, V> extends Map<K, V> {
-		private _array: V[];
-		private _keyArray: K[];
-
-		public array(): V[];
-		public clone(): Collection<K, V>;
-		public concat(...collections: Collection<K, V>[]): Collection<K, V>;
-		public each(fn: (value: V, key: K, collection: Collection<K, V>) => void, thisArg?: any): Collection<K, V>;
-		public equals(collection: Collection<any, any>): boolean;
-		public every(fn: (value: V, key: K, collection: Collection<K, V>) => boolean, thisArg?: any): boolean;
-		public filter(fn: (value: V, key: K, collection: Collection<K, V>) => boolean, thisArg?: any): Collection<K, V>;
-		public find(fn: (value: V, key: K, collection: Collection<K, V>) => boolean): V;
-		public findKey(fn: (value: V, key: K, collection: Collection<K, V>) => boolean): K;
-		public first(): V | undefined;
-		public first(count: number): V[];
-		public firstKey(): K | undefined;
-		public firstKey(count: number): K[];
-		public keyArray(): K[];
-		public last(): V | undefined;
-		public last(count: number): V[];
-		public lastKey(): K | undefined;
-		public lastKey(count: number): K[];
-		public map<T>(fn: (value: V, key: K, collection: Collection<K, V>) => T, thisArg?: any): T[];
-		public partition(fn: (value: V, key: K, collection: Collection<K, V>) => boolean): [Collection<K, V>, Collection<K, V>];
-		public random(): V | undefined;
-		public random(count: number): V[];
-		public randomKey(): K | undefined;
-		public randomKey(count: number): K[];
-		public reduce<T>(fn: (accumulator: any, value: V, key: K, collection: Collection<K, V>) => T, initialValue?: any): T;
-		public some(fn: (value: V, key: K, collection: Collection<K, V>) => boolean, thisArg?: any): boolean;
-		public sort(compareFunction?: (a: V, b: V, c?: K, d?: K) => number): Collection<K, V>;
-		public sweep(fn: (value: V, key: K, collection: Collection<K, V>) => boolean, thisArg?: any): number;
-		public tap(fn: (collection: Collection<K, V>) => void, thisArg?: any): Collection<K, V>;
-		public toJSON(): object;
-	}
-
-	export abstract class Collector<K, V> extends EventEmitter {
-		constructor(client: Client, filter: CollectorFilter, options?: CollectorOptions);
-		private _timeout: NodeJS.Timer;
-
-		public readonly client: Client;
-		public collected: Collection<K, V>;
-		public ended: boolean;
-		public filter: CollectorFilter;
-		public readonly next: Promise<V>;
-		public options: CollectorOptions;
-		public checkEnd(): void;
-		public handleCollect(...args: any[]): void;
-		public handleDispose(...args: any[]): void;
-		public stop(reason?: string): void;
-		public toJSON(): object;
-
-		protected listener: Function;
-		public abstract collect(...args: any[]): K;
-		public abstract dispose(...args: any[]): K;
-		public abstract endReason(): void;
-
-		public on(event: 'collect', listener: (...args: any[]) => void): this;
-		public on(event: 'dispose', listener: (...args: any[]) => void): this;
-		public on(event: 'end', listener: (collected: Collection<K, V>, reason: string) => void): this;
-
-		public once(event: 'collect', listener: (...args: any[]) => void): this;
-		public once(event: 'dispose', listener: (...args: any[]) => void): this;
-		public once(event: 'end', listener: (collected: Collection<K, V>, reason: string) => void): this;
-	}
-
-	export class DataResolver {
-		public static resolveBase64(data: Base64Resolvable): string;
-		public static resolveFile(resource: BufferResolvable | Stream): Promise<Buffer>;
-		public static resolveImage(resource: BufferResolvable | Base64Resolvable): Promise<string>;
-		public static resolveInviteCode(data: InviteResolvable): string;
-	}
-
-	export class DiscordAPIError extends Error {
-		constructor(path: string, error: object, method: string);
-		private static flattenErrors(obj: object, key: string): string[];
-
-		public code: number;
-		public method: string;
-		public path: string;
-	}
-
-	export class DMChannel extends TextBasedChannel(Channel) {
-		constructor(client: Client, data?: object);
-		public messages: MessageStore;
-		public recipient: User;
-	}
-
-	export class Emoji extends Base {
-		constructor(client: Client, emoji: object);
-		public animated: boolean;
-		public readonly createdAt: Date;
-		public readonly createdTimestamp: number;
-		public readonly deletable: boolean;
-		public id: Snowflake;
-		public name: string;
-		public readonly identifier: string;
-		public readonly url: string;
-		public toJSON(): object;
-		public toString(): string;
-	}
-
-	export class GroupDMChannel extends TextBasedChannel(Channel) {
-		constructor(client: Client, data?: object);
-		public applicationID: Snowflake;
-		public icon: string;
-		public managed: boolean;
-		public messages: MessageStore;
-		public name: string;
-		public nicks: Collection<Snowflake, string>;
-		public readonly owner: User;
-		public ownerID: Snowflake;
-		public recipients: Collection<Snowflake, User>;
-		public addUser(options: { user: UserResolvable, accessToken?: string, nick?: string }): Promise<GroupDMChannel>;
-		public edit (data: { icon?: string, name?: string }): Promise<GroupDMChannel>;
-		public equals(channel: GroupDMChannel): boolean;
-		public iconURL(options?: AvatarOptions): string;
-		public removeUser(user: UserResolvable): Promise<GroupDMChannel>;
-		public setIcon(icon: Base64Resolvable | BufferResolvable): Promise<GroupDMChannel>;
-		public setName(name: string): Promise<GroupDMChannel>;
-	}
-
-	export class Guild extends Base {
-		constructor(client: Client, data: object);
-		private _sortedRoles(): Collection<Snowflake, Role>;
-		private _sortedChannels(channel: Channel): Collection<Snowflake, GuildChannel>;
-		private _memberSpeakUpdate(user: Snowflake, speaking: boolean): void;
-
-		protected setup(data: any): void;
-
-		public readonly afkChannel: VoiceChannel;
-		public afkChannelID: Snowflake;
-		public afkTimeout: number;
-		public applicationID: Snowflake;
-		public available: boolean;
-		public channels: GuildChannelStore;
-		public readonly createdAt: Date;
-		public readonly createdTimestamp: number;
-		public defaultMessageNotifications: DefaultMessageNotifications | number;
-		public deleted: boolean;
-		public embedEnabled: boolean;
-		public emojis: GuildEmojiStore;
-		public explicitContentFilter: number;
-		public features: GuildFeatures[];
-		public icon: string;
-		public id: Snowflake;
-		public readonly joinedAt: Date;
-		public joinedTimestamp: number;
-		public large: boolean;
-		public readonly me: GuildMember;
-		public memberCount: number;
-		public members: GuildMemberStore;
-		public mfaLevel: number;
-		public name: string;
-		public readonly nameAcronym: string;
-		public readonly owner: GuildMember;
-		public ownerID: Snowflake;
-		public presences: PresenceStore;
-		public region: string;
-		public roles: RoleStore;
-		public splash: string;
-		public readonly systemChannel: TextChannel;
-		public systemChannelID: Snowflake;
-		public verificationLevel: number;
-		public readonly verified: boolean;
-		public readonly voiceConnection: VoiceConnection;
-		public addMember(user: UserResolvable, options: AddGuildMemberOptions): Promise<GuildMember>;
-		public createIntegration(data: IntegrationData, reason?: string): Promise<Guild>;
-		public delete(): Promise<Guild>;
-		public edit(data: GuildEditData, reason?: string): Promise<Guild>;
-		public equals(guild: Guild): boolean;
-		public fetchAuditLogs(options?: GuildAuditLogsFetchOptions): Promise<GuildAuditLogs>;
-		public fetchBans(): Promise<Collection<Snowflake, { user: User, reason: string }>>;
-		public fetchIntegrations(): Promise<Collection<string, Integration>>;
-		public fetchInvites(): Promise<Collection<string, Invite>>;
-		public fetchVanityCode(): Promise<string>;
-		public fetchVoiceRegions(): Promise<Collection<string, VoiceRegion>>;
-		public fetchWebhooks(): Promise<Collection<Snowflake, Webhook>>;
-		public fetchEmbed(): Promise<GuildEmbedData>;
-		public iconURL(options?: AvatarOptions): string;
-		public leave(): Promise<Guild>;
-		public member(user: UserResolvable): GuildMember;
-		public setAFKChannel(afkChannel: ChannelResolvable, reason?: string): Promise<Guild>;
-		public setAFKTimeout(afkTimeout: number, reason?: string): Promise<Guild>;
-		public setChannelPositions(channelPositions: ChannelPosition[]): Promise<Guild>;
-		public setDefaultMessageNotifications(defaultMessageNotifications: DefaultMessageNotifications | number, reason?: string): Promise<Guild>;
-		public setExplicitContentFilter(explicitContentFilter: number, reason?: string): Promise<Guild>;
-		public setIcon(icon: Base64Resolvable, reason?: string): Promise<Guild>;
-		public setName(name: string, reason?: string): Promise<Guild>;
-		public setOwner(owner: GuildMemberResolvable, reason?: string): Promise<Guild>;
-		public setRegion(region: string, reason?: string): Promise<Guild>;
-		public setSplash(splash: Base64Resolvable, reason?: string): Promise<Guild>;
-		public setSystemChannel(systemChannel: ChannelResolvable, reason?: string): Promise<Guild>;
-		public setVerificationLevel(verificationLevel: number, reason?: string): Promise<Guild>;
-		public setEmbed(embed: GuildEmbedData, reason?: string): Promise<Guild>;
-		public splashURL(options?: AvatarOptions): string;
-		public toJSON(): object;
-		public toString(): string;
-	}
-
-	export class GuildAuditLogs {
-		constructor(guild: Guild, data: object);
-		private webhooks: Collection<Snowflake, Webhook>;
-
-		public entries: Collection<Snowflake, GuildAuditLogsEntry>;
-
-		public static Actions: GuildAuditLogsActions;
-		public static Targets: GuildAuditLogsTargets;
-		public static Entry: typeof GuildAuditLogsEntry;
-		public static actionType(action: number): GuildAuditLogsActionType;
-		public static build(...args: any[]): Promise<GuildAuditLogs>;
-		public static targetType(target: number): GuildAuditLogsTarget;
-		public toJSON(): object;
-	}
-
-	class GuildAuditLogsEntry {
-		constructor(logs: GuildAuditLogs, guild: Guild, data: object);
-		public action: GuildAuditLogsAction;
-		public actionType: GuildAuditLogsActionType;
-		public changes: AuditLogChange[];
-		public readonly createdAt: Date;
-		public readonly createdTimestamp: number;
-		public executor: User;
-		public extra: object | Role | GuildMember;
-		public id: Snowflake;
-		public reason: string;
-		public target: Guild | User | Role | GuildEmoji | Invite | Webhook;
-		public targetType: GuildAuditLogsTarget;
-		public toJSON(): object;
-	}
-
-	export class GuildChannel extends Channel {
-		constructor(guild: Guild, data?: object);
-		private memberPermissions(member: GuildMember): Readonly<Permissions>;
-		private rolePermissions(role: Role): Readonly<Permissions>;
-
-		public readonly calculatedPosition: number;
-		public readonly deletable: boolean;
-		public guild: Guild;
-		public readonly manageable: boolean;
-		public name: string;
-		public readonly parent: CategoryChannel;
-		public parentID: Snowflake;
-		public permissionOverwrites: Collection<Snowflake, PermissionOverwrites>;
-		public readonly permissionsLocked: boolean;
-		public readonly position: number;
-		public rawPosition: number;
-		public clone(options?: GuildChannelCloneOptions): Promise<GuildChannel>;
-		public createInvite(options?: InviteOptions): Promise<Invite>;
-		public createOverwrite(userOrRole: RoleResolvable | UserResolvable, options: PermissionOverwriteOption, reason?: string): Promise<GuildChannel>;
-		public edit(data: ChannelData, reason?: string): Promise<GuildChannel>;
-		public equals(channel: GuildChannel): boolean;
-		public fetchInvites(): Promise<Collection<string, Invite>>;
-		public lockPermissions(): Promise<GuildChannel>;
-		public overwritePermissions(options?: { permissionOverwrites?: OverwriteResolvable[] | Collection<Snowflake, OverwriteResolvable>, reason?: string }): Promise<GuildChannel>;
-		public permissionsFor(memberOrRole: GuildMemberResolvable | RoleResolvable): Readonly<Permissions> | null;
-		public setName(name: string, reason?: string): Promise<GuildChannel>;
-		public setParent(channel: GuildChannel | Snowflake, options?: { lockPermissions?: boolean, reason?: string }): Promise<GuildChannel>;
-		public setPosition(position: number, options?: { relative?: boolean, reason?: string }): Promise<GuildChannel>;
-		public setTopic(topic: string, reason?: string): Promise<GuildChannel>;
-		public updateOverwrite(userOrRole: RoleResolvable | UserResolvable, options: PermissionOverwriteOption, reason?: string): Promise<GuildChannel>;
-	}
-
-	export class GuildEmoji extends Emoji {
-		constructor(client: Client, data: object, guild: Guild);
-		private _roles: string[];
-
-		public deleted: boolean;
-		public guild: Guild;
-		public managed: boolean;
-		public requiresColons: boolean;
-		public roles: GuildEmojiRoleStore;
-		public delete(reason?: string): Promise<GuildEmoji>;
-		public edit(data: GuildEmojiEditData, reason?: string): Promise<GuildEmoji>;
-		public equals(other: GuildEmoji | object): boolean;
-		public fetchAuthor(): Promise<User>;
-		public setName(name: string, reason?: string): Promise<GuildEmoji>;
-	}
-
-	export class GuildMember extends PartialTextBasedChannel(Base) {
-		constructor(client: Client, data: object, guild: Guild);
-		public readonly bannable: boolean;
-		public deleted: boolean;
-		public readonly displayColor: number;
-		public readonly displayHexColor: string;
-		public readonly displayName: string;
-		public guild: Guild;
-		public readonly id: Snowflake;
-		public readonly joinedAt: Date;
-		public joinedTimestamp: number;
-		public readonly kickable: boolean;
-		public readonly manageable: boolean;
-		public nickname: string;
-		public readonly permissions: Readonly<Permissions>;
-		public readonly presence: Presence;
-		public roles: GuildMemberRoleStore;
-		public user: User;
-		public readonly voice: VoiceState;
-		public ban(options?: BanOptions): Promise<GuildMember>;
-		public createDM(): Promise<DMChannel>;
-		public deleteDM(): Promise<DMChannel>;
-		public edit(data: GuildMemberEditData, reason?: string): Promise<GuildMember>;
-		public hasPermission(permission: PermissionResolvable, options?: { checkAdmin?: boolean; checkOwner?: boolean }): boolean;
-		public kick(reason?: string): Promise<GuildMember>;
-		public permissionsIn(channel: ChannelResolvable): Readonly<Permissions>;
-		public setDeaf(deaf: boolean, reason?: string): Promise<GuildMember>;
-		public setMute(mute: boolean, reason?: string): Promise<GuildMember>;
-		public setNickname(nickname: string, reason?: string): Promise<GuildMember>;
-		public setVoiceChannel(voiceChannel: ChannelResolvable): Promise<GuildMember>;
-		public toJSON(): object;
-		public toString(): string;
-	}
-
-	export class Integration extends Base {
-		constructor(client: Client, data: object, guild: Guild);
-		public account: IntegrationAccount;
-		public enabled: boolean;
-		public expireBehavior: number;
-		public expireGracePeriod: number;
-		public guild: Guild;
-		public id: Snowflake;
-		public name: string;
-		public role: Role;
-		public syncedAt: number;
-		public syncing: boolean;
-		public type: number;
-		public user: User;
-		public delete(reason?: string): Promise<Integration>;
-		public edit(data: IntegrationEditData, reason?: string): Promise<Integration>;
-		public sync(): Promise<Integration>;
-	}
-
-	export class HTTPError extends Error {
-		constructor(message: string, name: string, code: number, method: string, path: string);
-		public code: number;
-		public method: string;
-		public name: string;
-		public path: string;
-	}
-
-	export class Invite extends Base {
-		constructor(client: Client, data: object);
-		public channel: GuildChannel | GroupDMChannel;
-		public code: string;
-		public readonly createdAt: Date;
-		public createdTimestamp: number;
-		public readonly expiresAt: Date;
-		public readonly expiresTimestamp: number;
-		public guild: Guild;
-		public inviter: User;
-		public maxAge: number;
-		public maxUses: number;
-		public memberCount: number;
-		public presenceCount: number;
-		public temporary: boolean;
-		public readonly url: string;
-		public uses: number;
-		public delete(reason?: string): Promise<Invite>;
-		public toJSON(): object;
-		public toString(): string;
-	}
-
-	export class Message extends Base {
-		constructor(client: Client, data: object, channel: TextChannel | DMChannel | GroupDMChannel);
-		private _edits: Message[];
-		private patch(data: object): void;
-
-		public activity: GroupActivity;
-		public application: ClientApplication;
-		public attachments: Collection<Snowflake, MessageAttachment>;
-		public author: User;
-		public channel: TextChannel | DMChannel | GroupDMChannel;
-		public readonly cleanContent: string;
-		public content: string;
-		public readonly createdAt: Date;
-		public createdTimestamp: number;
-		public readonly deletable: boolean;
-		public deleted: boolean;
-		public readonly editable: boolean;
-		public readonly editedAt: Date;
-		public editedTimestamp: number;
-		public readonly edits: Message[];
-		public embeds: MessageEmbed[];
-		public readonly guild: Guild;
-		public hit: boolean;
-		public id: Snowflake;
-		public readonly member: GuildMember;
-		public mentions: MessageMentions;
-		public nonce: string;
-		public readonly pinnable: boolean;
-		public pinned: boolean;
-		public reactions: ReactionStore;
-		public system: boolean;
-		public tts: boolean;
-		public type: MessageType;
-		public readonly url: string;
-		public webhookID: Snowflake;
-		public awaitReactions(filter: CollectorFilter, options?: AwaitReactionsOptions): Promise<Collection<Snowflake, MessageReaction>>;
-		public createReactionCollector(filter: CollectorFilter, options?: ReactionCollectorOptions): ReactionCollector;
-		public delete(options?: { timeout?: number, reason?: string }): Promise<Message>;
-		public edit(content: StringResolvable, options?: MessageEditOptions | MessageEmbed): Promise<Message>;
-		public edit(options: MessageEditOptions | MessageEmbed | APIMessage): Promise<Message>;
-		public equals(message: Message, rawData: object): boolean;
-		public fetchWebhook(): Promise<Webhook>;
-		public pin(): Promise<Message>;
-		public react(emoji: EmojiIdentifierResolvable): Promise<MessageReaction>;
-		public reply(content?: StringResolvable, options?: MessageOptions | MessageAdditions): Promise<Message | Message[]>;
-		public reply(options?: MessageOptions | MessageAdditions | APIMessage): Promise<Message | Message[]>;
-		public toJSON(): object;
-		public toString(): string;
-		public unpin(): Promise<Message>;
-	}
-
-	export class MessageAttachment {
-		constructor(attachment: BufferResolvable | Stream, name?: string, data?: object);
-
-		public attachment: BufferResolvable | Stream;
-		public height: number;
-		public id: Snowflake;
-		public name?: string;
-		public proxyURL: string;
-		public size: number;
-		public url: string;
-		public width: number;
-		public setFile(attachment: BufferResolvable | Stream, name?: string): this;
-		public setName(name: string): this;
-		public toJSON(): object;
-	}
-
-	export class MessageCollector extends Collector<Snowflake, Message> {
-		constructor(channel: TextChannel | DMChannel | GroupDMChannel, filter: CollectorFilter, options?: MessageCollectorOptions);
-		public channel: Channel;
-		public options: MessageCollectorOptions;
-		public received: number;
-
-		public collect(message: Message): Snowflake;
-		public dispose(message: Message): Snowflake;
-		public endReason(): string;
-	}
-
-	export class MessageEmbed {
-		constructor(data?: MessageEmbed | MessageEmbedOptions);
-		private _apiTransform(): MessageEmbedOptions;
-
-		public author: { name?: string; url?: string; iconURL?: string; proxyIconURL?: string };
-		public color: number;
-		public readonly createdAt: Date;
-		public description: string;
-		public fields: EmbedField[];
-		public files: (MessageAttachment | string | FileOptions)[];
-		public footer: { text?: string; iconURL?: string; proxyIconURL?: string };
-		public readonly hexColor: string;
-		public image: { url: string; proxyURL?: string; height?: number; width?: number; };
-		public provider: { name: string; url: string; };
-		public thumbnail: { url: string; proxyURL?: string; height?: number; width?: number; };
-		public timestamp: number;
-		public title: string;
-		public type: string;
-		public url: string;
-		public readonly video: { url?: string; height?: number; width?: number };
-		public addBlankField(inline?: boolean): this;
-		public addField(name: StringResolvable, value: StringResolvable, inline?: boolean): this;
-		public attachFiles(file: (MessageAttachment | FileOptions | string)[]): this;
-		public setAuthor(name: StringResolvable, iconURL?: string, url?: string): this;
-		public setColor(color: ColorResolvable): this;
-		public setDescription(description: StringResolvable): this;
-		public setFooter(text: StringResolvable, iconURL?: string): this;
-		public setImage(url: string): this;
-		public setThumbnail(url: string): this;
-		public setTimestamp(timestamp?: Date | number): this;
-		public setTitle(title: StringResolvable): this;
-		public setURL(url: string): this;
-		public spliceField(index: number, deleteCount: number, name?: StringResolvable, value?: StringResolvable, inline?: boolean): this;
-		public toJSON(): object;
-
-		public static checkField(name: StringResolvable, value: StringResolvable, inline?: boolean): Required<EmbedField>;
-	}
-
-	export class MessageMentions {
-		constructor(message: Message, users: object[] | Collection<Snowflake, User>, roles: Snowflake[] | Collection<Snowflake, Role>, everyone: boolean);
-		private _channels: Collection<Snowflake, GuildChannel>;
-		private readonly _content: Message;
-		private _members: Collection<Snowflake, GuildMember>;
-
-		public readonly channels: Collection<Snowflake, TextChannel>;
-		public readonly client: Client;
-		public everyone: boolean;
-		public readonly guild: Guild;
-		public has(data: User | GuildMember | Role | GuildChannel, options?: {
-			ignoreDirect?: boolean;
-			ignoreRoles?: boolean;
-			ignoreEveryone?: boolean;
-		}): boolean;
-		public readonly members: Collection<Snowflake, GuildMember>;
-		public roles: Collection<Snowflake, Role>;
-		public users: Collection<Snowflake, User>;
-		public toJSON(): object;
-
-		public static CHANNELS_PATTERN: RegExp;
-		public static EVERYONE_PATTERN: RegExp;
-		public static ROLES_PATTERN: RegExp;
-		public static USERS_PATTERN: RegExp;
-	}
-
-	export class MessageReaction {
-		constructor(client: Client, data: object, message: Message);
-		private _emoji: GuildEmoji | ReactionEmoji;
-
-		public count: number;
-		public readonly emoji: GuildEmoji | ReactionEmoji;
-		public me: boolean;
-		public message: Message;
-		public users: ReactionUserStore;
-		public toJSON(): object;
-	}
-
-	export class PermissionOverwrites {
-		constructor(guildChannel: GuildChannel, data?: object);
-		public allow: Readonly<Permissions>;
-		public readonly channel: GuildChannel;
-		public deny: Readonly<Permissions>;
-		public id: Snowflake;
-		public type: OverwriteType;
-		public update(options: PermissionOverwriteOption, reason?: string): Promise<PermissionOverwrites>;
-		public delete(reason?: string): Promise<PermissionOverwrites>;
-		public toJSON(): object;
-		public static resolveOverwriteOptions(options: ResolvedOverwriteOptions, initialPermissions: { allow?: PermissionResolvable, deny?: PermissionResolvable }): ResolvedOverwriteOptions;
-		public static resolve(overwrite: OverwriteResolvable, guild: Guild): RawOverwriteData;
-	}
-
-	export class Permissions extends BitField<PermissionString> {
-		public has(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
-
-		public static ALL: number;
-		public static DEFAULT: number;
-		public static FLAGS: PermissionFlags;
-		public static resolve(permission?: PermissionResolvable): number;
-	}
-
-	export class Presence {
-		constructor(client: Client, data?: object);
-		public activity: Activity;
-		public flags: Readonly<ActivityFlags>;
-		public status: 'online' | 'offline' | 'idle' | 'dnd';
-		public readonly user: User;
-		public readonly member?: GuildMember;
-		public equals(presence: Presence): boolean;
-	}
-
-	export class ReactionCollector extends Collector<Snowflake, MessageReaction> {
-		constructor(message: Message, filter: CollectorFilter, options?: ReactionCollectorOptions);
-		public message: Message;
-		public options: ReactionCollectorOptions;
-		public total: number;
-		public users: Collection<Snowflake, User>;
-
-		public static key(reaction: MessageReaction): Snowflake | string;
-
-		public collect(reaction: MessageReaction): Snowflake | string;
-		public dispose(reaction: MessageReaction, user: User): Snowflake | string;
-		public empty(): void;
-		public endReason(): string;
-
-		public on(event: 'collect', listener: (reaction: MessageReaction, user: User) => void): this;
-		public on(event: 'dispose', listener: (reaction: MessageReaction, user: User) => void): this;
-		public on(event: 'end', listener: (collected: Collection<Snowflake, MessageReaction>, reason: string) => void): this;
-		public on(event: 'remove', listener: (reaction: MessageReaction, user: User) => void): this;
-		public on(event: string, listener: Function): this;
-
-		public once(event: 'collect', listener: (reaction: MessageReaction, user: User) => void): this;
-		public once(event: 'dispose', listener: (reaction: MessageReaction, user: User) => void): this;
-		public once(event: 'end', listener: (collected: Collection<Snowflake, MessageReaction>, reason: string) => void): this;
-		public once(event: 'remove', listener: (reaction: MessageReaction, user: User) => void): this;
-		public once(event: string, listener: Function): this;
-}
-
-	export class ReactionEmoji extends Emoji {
-		constructor(reaction: MessageReaction, emoji: object);
-		public reaction: MessageReaction;
-		public toJSON(): object;
-	}
-
-	export class RichPresenceAssets {
-		constructor(activity: Activity, assets: object);
-		public largeImage: Snowflake;
-		public largeText: string;
-		public smallImage: Snowflake;
-		public smallText: string;
-		public largeImageURL(options: AvatarOptions): string;
-		public smallImageURL(options: AvatarOptions): string;
-	}
-
-	export class Role extends Base {
-		constructor(client: Client, data: object, guild: Guild);
-		public color: number;
-		public readonly createdAt: Date;
-		public readonly createdTimestamp: number;
-		public deleted: boolean;
-		public readonly editable: boolean;
-		public guild: Guild;
-		public readonly hexColor: string;
-		public hoist: boolean;
-		public id: Snowflake;
-		public managed: boolean;
-		public readonly members: Collection<Snowflake, GuildMember>;
-		public mentionable: boolean;
-		public name: string;
-		public permissions: Readonly<Permissions>;
-		public readonly position: number;
-		public rawPosition: number;
-		public comparePositionTo(role: Role): number;
-		public delete(reason?: string): Promise<Role>;
-		public edit(data: RoleData, reason?: string): Promise<Role>;
-		public equals(role: Role): boolean;
-		public permissionsIn(channel: ChannelResolvable): Readonly<Permissions>;
-		public setColor(color: ColorResolvable, reason?: string): Promise<Role>;
-		public setHoist(hoist: boolean, reason?: string): Promise<Role>;
-		public setMentionable(mentionable: boolean, reason?: string): Promise<Role>;
-		public setName(name: string, reason?: string): Promise<Role>;
-		public setPermissions(permissions: PermissionResolvable, reason?: string): Promise<Role>;
-		public setPosition(position: number, options?: { relative?: boolean; reason?: string }): Promise<Role>;
-		public toJSON(): object;
-		public toString(): string;
-
-		public static comparePositions(role1: Role, role2: Role): number;
-	}
-
-	export class Shard extends EventEmitter {
-		constructor(manager: ShardingManager, id: number);
-		private _evals: Map<string, Promise<any>>;
-		private _exitListener: Function;
-		private _fetches: Map<string, Promise<any>>;
-		private _handleExit(respawn?: boolean): void;
-		private _handleMessage(message: any): void;
-
-		public args: string[];
-		public execArgv: string[];
-		public env: object;
-		public id: number;
-		public manager: ShardingManager;
-		public process: ChildProcess;
-		public ready: boolean;
-		public eval(script: string): Promise<any>;
-		public eval<T>(fn: (client: Client) => T): Promise<T[]>;
-		public fetchClientValue(prop: string): Promise<any>;
-		public kill(): void;
-		public respawn(delay?: number, waitForReady?: boolean): Promise<ChildProcess>;
-		public send(message: any): Promise<Shard>;
-		public spawn(waitForReady?: boolean): Promise<ChildProcess>;
-
-		public on(event: 'death', listener: (child: ChildProcess) => void): this;
-		public on(event: 'disconnect' | 'ready' | 'reconnecting', listener: () => void): this;
-		public on(event: 'error', listener: (error: Error) => void): this;
-		public on(event: 'message', listener: (message: any) => void): this;
-		public on(event: 'spawn', listener: (child: ChildProcess) => void): this;
-		public on(event: string, listener: Function): this;
-
-		public once(event: 'death', listener: (child: ChildProcess) => void): this;
-		public once(event: 'disconnect' | 'ready' | 'reconnecting', listener: () => void): this;
-		public once(event: 'error', listener: (error: Error) => void): this;
-		public once(event: 'message', listener: (message: any) => void): this;
-		public once(event: 'spawn', listener: (child: ChildProcess) => void): this;
-		public once(event: string, listener: Function): this;
-	}
-
-	export class ShardClientUtil {
-		constructor(client: Client);
-		private _handleMessage(message: any): void;
-		private _respond(type: string, message: any): void;
-
-		public readonly count: number;
-		public readonly id: number;
-		public broadcastEval(script: string): Promise<any[]>;
-		public broadcastEval<T>(fn: (client: Client) => T): Promise<T[]>;
-		public fetchClientValues(prop: string): Promise<any[]>;
-		public respawnAll(shardDelay?: number, respawnDelay?: number, waitForReady?: boolean): Promise<void>;
-		public send(message: any): Promise<void>;
-
-		public static singleton(client: Client): ShardClientUtil;
-	}
-
-	export class ShardingManager extends EventEmitter {
-		constructor(file: string, options?: {
-			totalShards?: number | 'auto';
-			respawn?: boolean;
-			shardArgs?: string[];
-			token?: string;
-			execArgv?: string[];
-		});
-
-		public file: string;
-		public respawn: boolean;
-		public shardArgs: string[];
-		public shards: Collection<number, Shard>;
-		public token: string;
-		public totalShards: number | 'auto';
-		public broadcast(message: any): Promise<Shard[]>;
-		public broadcastEval(script: string): Promise<any[]>;
-		public createShard(id: number): Shard;
-		public fetchClientValues(prop: string): Promise<any[]>;
-		public respawnAll(shardDelay?: number, respawnDelay?: number, waitForReady?: boolean): Promise<Collection<number, Shard>>;
-		public spawn(amount?: number | 'auto', delay?: number, waitForReady?: boolean): Promise<Collection<number, Shard>>;
-
-		public on(event: 'shardCreate', listener: (shard: Shard) => void): this;
-
-		public once(event: 'shardCreate', listener: (shard: Shard) => void): this;
-	}
-
-	export class SnowflakeUtil {
-		public static deconstruct(snowflake: Snowflake): DeconstructedSnowflake;
-		public static generate(): Snowflake;
-	}
-
-	const VolumeMixin: <T>(base: Constructable<T>) => Constructable<T & VolumeInterface>;
-
-	class StreamDispatcher extends VolumeMixin(Writable) {
-		constructor(player: object, options?: StreamOptions, streams?: object);
-		public player: object;
-		public pausedSince: number;
-		public broadcast: VoiceBroadcast;
-		public readonly paused: boolean;
-		public readonly pausedTime: boolean;
-		public readonly streamTime: number;
-		public readonly totalStreamTime: number;
-		public readonly bitrateEditable: boolean;
-
-		public setBitrate(value: number | 'auto'): boolean;
-		public setPLP(value: number): boolean;
-		public setFEC(enabled: boolean): boolean;
-		public pause(silence?: boolean): void;
-		public resume(): void;
-
-		public on(event: 'close', listener: () => void): this;
-		public on(event: 'debug', listener: (info: string) => void): this;
-		public on(event: 'drain', listener: () => void): this;
-		public on(event: 'end', listener: () => void): this;
-		public on(event: 'error', listener: (err: Error) => void): this;
-		public on(event: 'finish', listener: () => void): this;
-		public on(event: 'pipe', listener: (src: Readable) => void): this;
-		public on(event: 'start', listener: () => void): this;
-		public on(event: 'speaking', listener: (speaking: boolean) => void): this;
-		public on(event: 'unpipe', listener: (src: Readable) => void): this;
-		public on(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
-		public on(event: string, listener: Function): this;
-
-		public once(event: 'close', listener: () => void): this;
-		public once(event: 'debug', listener: (info: string) => void): this;
-		public once(event: 'drain', listener: () => void): this;
-		public once(event: 'end', listener: () => void): this;
-		public once(event: 'error', listener: (err: Error) => void): this;
-		public once(event: 'finish', listener: () => void): this;
-		public once(event: 'pipe', listener: (src: Readable) => void): this;
-		public once(event: 'start', listener: () => void): this;
-		public once(event: 'speaking', listener: (speaking: boolean) => void): this;
-		public once(event: 'unpipe', listener: (src: Readable) => void): this;
-		public on(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
-		public once(event: string, listener: Function): this;
-	}
-
-	export class Speaking extends BitField<SpeakingString> {
-		public static FLAGS: Record<SpeakingString, number>;
-		public static resolve(bit?: BitFieldResolvable<SpeakingString>): number;
-	}
-
-	export class Structures {
-		static get<K extends keyof Extendable>(structure: K): Extendable[K];
-		static get(structure: string): Function;
-		static extend<K extends keyof Extendable, T extends Extendable[K]>(structure: K, extender: (baseClass: Extendable[K]) => T): T;
-		static extend<T extends Function>(structure: string, extender: (baseClass: typeof Function) => T): T;
-	}
-
-	export class TextChannel extends TextBasedChannel(GuildChannel) {
-		constructor(guild: Guild, data?: object);
-		public readonly members: Collection<Snowflake, GuildMember>;
-		public messages: MessageStore;
-		public nsfw: boolean;
-		public rateLimitPerUser: number;
-		public topic: string;
-		public createWebhook(name: string, options?: { avatar?: BufferResolvable | Base64Resolvable, reason?: string }): Promise<Webhook>;
-		public setNSFW(nsfw: boolean, reason?: string): Promise<TextChannel>;
-		public setRateLimitPerUser(rateLimitPerUser: number, reason?: string): Promise<TextChannel>;
-		public fetchWebhooks(): Promise<Collection<Snowflake, Webhook>>;
-	}
-
-	export class User extends PartialTextBasedChannel(Base) {
-		constructor(client: Client, data: object);
-		public avatar: string;
-		public bot: boolean;
-		public readonly createdAt: Date;
-		public readonly createdTimestamp: number;
-		public discriminator: string;
-		public readonly defaultAvatarURL: string;
-		public readonly dmChannel: DMChannel;
-		public id: Snowflake;
-		public locale: string;
-		public readonly presence: Presence;
-		public readonly tag: string;
-		public username: string;
-		public avatarURL(options?: AvatarOptions): string;
-		public createDM(): Promise<DMChannel>;
-		public deleteDM(): Promise<DMChannel>;
-		public displayAvatarURL(options?: AvatarOptions): string;
-		public equals(user: User): boolean;
-		public toString(): string;
-		public typingDurationIn(channel: ChannelResolvable): number;
-		public typingIn(channel: ChannelResolvable): boolean;
-		public typingSinceIn(channel: ChannelResolvable): Date;
-	}
-
-	export class Util {
-		public static basename(path: string, ext?: string): string;
-		public static binaryToID(num: string): Snowflake;
-		public static cleanContent(str: string, message: Message): string;
-		public static cloneObject(obj: object): object;
-		public static convertToBuffer(ab: ArrayBuffer | string): Buffer;
-		public static delayFor(ms: number): Promise<void>;
-		public static discordSort<K, V extends { rawPosition: number; id: string; }>(collection: Collection<K, V>): Collection<K, V>;
-		public static escapeMarkdown(text: string, onlyCodeBlock?: boolean, onlyInlineCode?: boolean): string;
-		public static fetchRecommendedShards(token: string, guildsPerShard?: number): Promise<number>;
-		public static flatten(obj: object, ...props: { [key: string]: boolean | string }[]): object;
-		public static idToBinary(num: Snowflake): string;
-		public static makeError(obj: { name: string, message: string, stack: string }): Error;
-		public static makePlainError(err: Error): { name: string, message: string, stack: string };
-		public static mergeDefault(def: object, given: object): object;
-		public static moveElementInArray(array: any[], element: any, newIndex: number, offset?: boolean): number;
-		public static parseEmoji(text: string): { animated: boolean; name: string; id: string; };
-		public static resolveColor(color: ColorResolvable): number;
-		public static resolveString(data: StringResolvable): string;
-		public static setPosition<T extends (Channel | Role)>(
-			item: T,
-			position: number,
-			relative: boolean,
-			sorted: Collection<Snowflake, T>,
-			route: object,
-			reason?: string
-		): Promise<{ id: Snowflake; position: number }[]>;
-		public static splitMessage(text: string, options?: SplitOptions): string | string[];
-		public static str2ab(str: string): ArrayBuffer;
-	}
-
-	class VoiceBroadcast extends EventEmitter {
-		constructor(client: Client);
-		public client: Client;
-		public readonly dispatcher: BroadcastDispatcher;
-		public play(input: string | Readable, options?: StreamOptions): BroadcastDispatcher;
-
-		public on(event: 'end', listener: () => void): this;
-		public on(event: 'error', listener: (error: Error) => void): this;
-		public on(event: 'subscribe', listener: (dispatcher: StreamDispatcher) => void): this;
-		public on(event: 'unsubscribe', listener: (dispatcher: StreamDispatcher) => void): this;
-		public on(event: 'warn', listener: (warning: string | Error) => void): this;
-		public on(event: string, listener: Function): this;
-
-		public once(event: 'end', listener: () => void): this;
-		public once(event: 'error', listener: (error: Error) => void): this;
-		public once(event: 'subscribe', listener: (dispatcher: StreamDispatcher) => void): this;
-		public once(event: 'unsubscribe', listener: (dispatcher: StreamDispatcher) => void): this;
-		public once(event: 'warn', listener: (warning: string | Error) => void): this;
-		public once(event: string, listener: Function): this;
-	}
-
-	export class VoiceChannel extends GuildChannel {
-		constructor(guild: Guild, data?: object);
-		public bitrate: number;
-		public readonly connection: VoiceConnection;
-		public readonly full: boolean;
-		public readonly joinable: boolean;
-		public readonly members: Collection<Snowflake, GuildMember>;
-		public readonly speakable: boolean;
-		public userLimit: number;
-		public join(): Promise<VoiceConnection>;
-		public leave(): void;
-		public setBitrate(bitrate: number, reason?: string): Promise<VoiceChannel>;
-		public setUserLimit(userLimit: number, reason?: string): Promise<VoiceChannel>;
-	}
-
-	class VoiceConnection extends EventEmitter {
-		constructor(voiceManager: object, channel: VoiceChannel);
-		private authentication: object;
-		private sockets: object;
-		private ssrcMap: Map<number, boolean>;
-		private _disconnect(): void;
-		private authenticate(): void;
-		private authenticateFailed(reason: string): void;
-		private checkAuthenticated(): void;
-		private cleanup(): void;
-		private connect(): void;
-		private onReady(data: object): void;
-		private onSessionDescription(mode: string, secret: string): void;
-		private onSpeaking(data: object): void;
-		private reconnect(token: string, endpoint: string): void;
-		private sendVoiceStateUpdate(options: object): void;
-		private setSessionID(sessionID: string): void;
-		private setSpeaking(value: BitFieldResolvable<SpeakingString>): void;
-		private setTokenAndEndpoint(token: string, endpoint: string): void;
-		private updateChannel(channel: VoiceChannel): void;
-
-		public channel: VoiceChannel;
-		public readonly client: Client;
-		public readonly dispatcher: StreamDispatcher;
-		public player: object;
-		public receiver: VoiceReceiver;
-		public speaking: Readonly<Speaking>;
-		public status: VoiceStatus;
-		public voiceManager: object;
-		public disconnect(): void;
-		public play(input: VoiceBroadcast | Readable | string, options?: StreamOptions): StreamDispatcher;
-
-		public on(event: 'authenticated', listener: () => void): this;
-		public on(event: 'closing', listener: () => void): this;
-		public on(event: 'debug', listener: (message: string) => void): this;
-		public on(event: 'disconnect', listener: (error: Error) => void): this;
-		public on(event: 'error', listener: (error: Error) => void): this;
-		public on(event: 'failed', listener: (error: Error) => void): this;
-		public on(event: 'newSession', listener: () => void): this;
-		public on(event: 'ready', listener: () => void): this;
-		public on(event: 'reconnecting', listener: () => void): this;
-		public on(event: 'speaking', listener: (user: User, speaking: Readonly<Speaking>) => void): this;
-		public on(event: 'warn', listener: (warning: string | Error) => void): this;
-		public on(event: string, listener: Function): this;
-
-		public once(event: 'authenticated', listener: () => void): this;
-		public once(event: 'closing', listener: () => void): this;
-		public once(event: 'debug', listener: (message: string) => void): this;
-		public once(event: 'disconnect', listener: (error: Error) => void): this;
-		public once(event: 'error', listener: (error: Error) => void): this;
-		public once(event: 'failed', listener: (error: Error) => void): this;
-		public once(event: 'newSession', listener: () => void): this;
-		public once(event: 'ready', listener: () => void): this;
-		public once(event: 'reconnecting', listener: () => void): this;
-		public once(event: 'speaking', listener: (user: User, speaking: Readonly<Speaking>) => void): this;
-		public once(event: 'warn', listener: (warning: string | Error) => void): this;
-		public once(event: string, listener: Function): this;
-	}
-
-	class VoiceReceiver extends EventEmitter {
-		constructor(connection: VoiceConnection);
-		public createStream(user: UserResolvable, options?: { mode?: 'opus' | 'pcm', end?: 'silence' | 'manual' }): Readable;
-
-		public on(event: 'debug', listener: (error: Error | string) => void): this;
-		public on(event: string, listener: Function): this;
-
-		public once(event: 'debug', listener: (error: Error | string) => void): this;
-		public once(event: string, listener: Function): this;
-	}
-
-	export class VoiceRegion {
-		constructor(data: object);
-		public custom: boolean;
-		public deprecated: boolean;
-		public id: string;
-		public name: string;
-		public optimal: boolean;
-		public vip: boolean;
-		public toJSON(): object;
-	}
-
-	export class VoiceState extends Base {
-		constructor(guild: Guild, data: object);
-		public readonly channel?: VoiceChannel;
-		public channelID?: Snowflake;
-		public readonly deaf?: boolean;
-		public guild: Guild;
-		public id: Snowflake;
-		public readonly member: GuildMember;
-		public readonly mute?: boolean;
-		public selfDeaf?: boolean;
-		public selfMute?: boolean;
-		public serverDeaf?: boolean;
-		public serverMute?: boolean;
-		public sessionID?: string;
-		public readonly speaking?: boolean;
-
-		public setDeaf(mute: boolean, reason?: string): Promise<GuildMember>;
-		public setMute(mute: boolean, reason?: string): Promise<GuildMember>;
-	}
-
-	class VolumeInterface extends EventEmitter {
-		constructor(options?: { volume?: number })
-		public readonly volume: number;
-		public readonly volumeDecibels: number;
-		public readonly volumeEditable: boolean;
-		public readonly volumeLogarithmic: number;
-		public setVolume(volume: number): void;
-		public setVolumeDecibels(db: number): void;
-		public setVolumeLogarithmic(value: number): void;
-
-		public on(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
-
-		public once(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
-	}
-
-	export class Webhook extends WebhookMixin() {
-		constructor(client: Client, data?: object);
-		public avatar: string;
-		public channelID: Snowflake;
-		public guildID: Snowflake;
-		public name: string;
-		public owner: User | object;
-	}
-
-	export class WebhookClient extends WebhookMixin(BaseClient) {
-		constructor(id: string, token: string, options?: ClientOptions);
-	}
-
-//#endregion
-
-//#region Stores
-
-	export class ChannelStore extends DataStore<Snowflake, Channel, typeof Channel, ChannelResolvable> {
-		constructor(client: Client, iterable: Iterable<any>, options?: { lru: boolean });
-		constructor(client: Client, options?: { lru: boolean });
-	}
-
-	export class DataStore<K, V, VConstructor = Constructable<V>, R = any> extends Collection<K, V> {
-		constructor(client: Client, iterable: Iterable<any>, holds: VConstructor);
-		public static readonly [Symbol.species]: typeof Collection;
-		public client: Client;
-		public holds: VConstructor;
-		public add(data: any, cache?: boolean, { id, extras }?: { id: K, extras: any[] }): V;
-		public remove(key: K): void;
-		public resolve(resolvable: R): V;
-		public resolveID(resolvable: R): K;
-	}
-
-	export class GuildEmojiRoleStore extends OverridableDataStore<Snowflake, Role, typeof Role, RoleResolvable> {
-		constructor(emoji: GuildEmoji);
-		public add(roleOrRoles: RoleResolvable | RoleResolvable[] | Collection<Snowflake, Role>): Promise<GuildEmoji>;
-		public set(roles: RoleResolvable[] | Collection<Snowflake, Role>): Promise<GuildEmoji>;
-		public remove(roleOrRoles: RoleResolvable | RoleResolvable[] | Collection<Snowflake, Role>): Promise<GuildEmoji>;
-	}
-
-	export class GuildEmojiStore extends DataStore<Snowflake, GuildEmoji, typeof GuildEmoji, EmojiResolvable> {
-		constructor(guild: Guild, iterable?: Iterable<any>);
-		public create(attachment: BufferResolvable | Base64Resolvable, name: string, options?: GuildEmojiCreateOptions): Promise<GuildEmoji>;
-		public resolveIdentifier(emoji: EmojiIdentifierResolvable): string;
-	}
-
-	export class GuildChannelStore extends DataStore<Snowflake, GuildChannel, typeof GuildChannel, GuildChannelResolvable> {
-		constructor(guild: Guild, iterable?: Iterable<any>);
-		public create(name: string, options?: GuildCreateChannelOptions): Promise<TextChannel | VoiceChannel>;
-	}
-
-	// Hacky workaround because changing the signature of an overriden method errors
-	class OverridableDataStore<V, K, VConstructor = Constructable<V>, R = any> extends DataStore<V, K , VConstructor, R> {
-		public add(data: any, cache: any): any;
-		public set(key: any): any;
-	}
-
-	export class GuildMemberRoleStore extends OverridableDataStore<Snowflake, Role, typeof Role, RoleResolvable> {
-		constructor(member: GuildMember);
-		public readonly hoist: Role;
-		public readonly color: Role;
-		public readonly highest: Role;
-
-		public add(roleOrRoles: RoleResolvable | RoleResolvable[] | Collection<Snowflake, Role>, reason?: string): Promise<GuildMember>;
-		public set(roles: RoleResolvable[] | Collection<Snowflake, Role>, reason?: string): Promise<GuildMember>;
-		public remove(roleOrRoles: RoleResolvable | RoleResolvable[] | Collection<Snowflake, Role>, reason?: string): Promise<GuildMember>;
-	}
-
-	export class GuildMemberStore extends DataStore<Snowflake, GuildMember, typeof GuildMember, GuildMemberResolvable> {
-		constructor(guild: Guild, iterable?: Iterable<any>);
-		public ban(user: UserResolvable, options?: BanOptions): Promise<GuildMember | User | Snowflake>;
-		public fetch(options: UserResolvable | FetchMemberOptions): Promise<GuildMember>;
-		public fetch(): Promise<GuildMemberStore>;
-		public fetch(options: FetchMembersOptions): Promise<Collection<Snowflake, GuildMember>>;
-		public prune(options?: GuildPruneMembersOptions): Promise<number>;
-		public unban(user: UserResolvable, reason?: string): Promise<User>;
-	}
-
-	export class GuildStore extends DataStore<Snowflake, Guild, typeof Guild, GuildResolvable> {
-		constructor(client: Client, iterable?: Iterable<any>);
-		public create(name: string, options?: { region?: string, icon?: BufferResolvable | Base64Resolvable }): Promise<Guild>;
-	}
-
-	export class MessageStore extends DataStore<Snowflake, Message, typeof Message, MessageResolvable> {
-		constructor(channel: TextChannel | DMChannel | GroupDMChannel, iterable?: Iterable<any>);
-		public fetch(message: Snowflake): Promise<Message>;
-		public fetch(options?: ChannelLogsQueryOptions): Promise<Collection<Snowflake, Message>>;
-		public fetchPinned(): Promise<Collection<Snowflake, Message>>;
-	}
-
-	export class PresenceStore extends DataStore<Snowflake, Presence, typeof Presence, PresenceResolvable> {
-		constructor(client: Client, iterable?: Iterable<any>);
-	}
-
-	export class ReactionStore extends DataStore<Snowflake, MessageReaction, typeof MessageReaction, MessageReactionResolvable> {
-		constructor(message: Message, iterable?: Iterable<any>);
-		public removeAll(): Promise<Message>;
-	}
-
-	export class ReactionUserStore extends DataStore<Snowflake, User, typeof User, UserResolvable> {
-		constructor(client: Client, iterable: Iterable<any> | undefined, reaction: MessageReaction);
-		public fetch(options?: { limit?: number, after?: Snowflake, before?: Snowflake }): Promise<Collection<Snowflake, User>>;
-		public remove(user?: UserResolvable): Promise<MessageReaction>;
-	}
-
-	export class RoleStore extends DataStore<Snowflake, Role, typeof Role, RoleResolvable> {
-		constructor(guild: Guild, iterable?: Iterable<any>);
-		public readonly highest: Role;
-
-		public create(options?: { data?: RoleData, reason?: string }): Promise<Role>;
-	}
-
-	export class UserStore extends DataStore<Snowflake, User, typeof User, UserResolvable> {
-		constructor(client: Client, iterable?: Iterable<any>);
-		public fetch(id: Snowflake, cache?: boolean): Promise<User>;
-	}
-
-//#endregion
-
-//#region Mixins
-
-	// Model the TextBasedChannel mixin system, allowing application of these fields
-	// to the classes that use these methods without having to manually add them
-	// to each of those classes
-
-	type Constructable<T> = new (...args: any[]) => T;
-	const PartialTextBasedChannel: <T>(Base?: Constructable<T>) => Constructable<T & PartialTextBasedChannelFields>;
-	const TextBasedChannel: <T>(Base?: Constructable<T>) => Constructable<T & TextBasedChannelFields>;
-
-	type PartialTextBasedChannelFields = {
-		lastMessageID: Snowflake;
-		lastMessageChannelID: Snowflake;
-		readonly lastMessage: Message;
-		lastPinTimestamp: number;
-		readonly lastPinAt: Date;
-		send(content?: StringResolvable, options?: MessageOptions | MessageAdditions): Promise<Message | Message[]>;
-		send(options?: MessageOptions | MessageAdditions | APIMessage): Promise<Message | Message[]>;
-	};
-
-	type TextBasedChannelFields = {
-		typing: boolean;
-		typingCount: number;
-		awaitMessages(filter: CollectorFilter, options?: AwaitMessagesOptions): Promise<Collection<Snowflake, Message>>;
-		bulkDelete(messages: Collection<Snowflake, Message> | Message[] | number, filterOld?: boolean): Promise<Collection<Snowflake, Message>>;
-		createMessageCollector(filter: CollectorFilter, options?: MessageCollectorOptions): MessageCollector;
-		startTyping(count?: number): Promise<void>;
-		stopTyping(force?: boolean): void;
-	} & PartialTextBasedChannelFields;
-
-	const WebhookMixin: <T>(Base?: Constructable<T>) => Constructable<T & WebhookFields>;
-
-	type WebhookFields = {
-		readonly client: Client;
-		id: Snowflake;
-		token: string;
-		delete(reason?: string): Promise<void>;
-		edit(options: WebhookEditData): Promise<Webhook>;
-		send(content?: StringResolvable, options?: WebhookMessageOptions | MessageAdditions): Promise<Message | Message[]>;
-		send(options?: WebhookMessageOptions | MessageAdditions | APIMessage): Promise<Message | Message[]>;
-		sendSlackMessage(body: object): Promise<Message|object>;
-	};
-
-//#endregion
-
-//#region Typedefs
-
-	type ActivityFlagsString = 'INSTANCE' | 'JOIN' | 'SPECTATE' | 'JOIN_REQUEST' | 'SYNC' | 'PLAY';
-
-	type ActivityType = 'PLAYING'
-		| 'STREAMING'
-		| 'LISTENING'
-		| 'WATCHING';
-
-	type APIErrror = {
-		UNKNOWN_ACCOUNT: number;
-		UNKNOWN_APPLICATION: number;
-		UNKNOWN_CHANNEL: number;
-		UNKNOWN_GUILD: number;
-		UNKNOWN_INTEGRATION: number;
-		UNKNOWN_INVITE: number;
-		UNKNOWN_MEMBER: number;
-		UNKNOWN_MESSAGE: number;
-		UNKNOWN_OVERWRITE: number;
-		UNKNOWN_PROVIDER: number;
-		UNKNOWN_ROLE: number;
-		UNKNOWN_TOKEN: number;
-		UNKNOWN_USER: number;
-		UNKNOWN_EMOJI: number;
-		UNKNOWN_WEBHOOK: number;
-		BOT_PROHIBITED_ENDPOINT: number;
-		BOT_ONLY_ENDPOINT: number;
-		MAXIMUM_GUILDS: number;
-		MAXIMUM_FRIENDS: number;
-		MAXIMUM_PINS: number;
-		MAXIMUM_ROLES: number;
-		MAXIMUM_REACTIONS: number;
-		UNAUTHORIZED: number;
-		MISSING_ACCESS: number;
-		INVALID_ACCOUNT_TYPE: number;
-		CANNOT_EXECUTE_ON_DM: number;
-		EMBED_DISABLED: number;
-		CANNOT_EDIT_MESSAGE_BY_OTHER: number;
-		CANNOT_SEND_EMPTY_MESSAGE: number;
-		CANNOT_MESSAGE_USER: number;
-		CANNOT_SEND_MESSAGES_IN_VOICE_CHANNEL: number;
-		CHANNEL_VERIFICATION_LEVEL_TOO_HIGH: number;
-		OAUTH2_APPLICATION_BOT_ABSENT: number;
-		MAXIMUM_OAUTH2_APPLICATIONS: number;
-		INVALID_OAUTH_STATE: number;
-		MISSING_PERMISSIONS: number;
-		INVALID_AUTHENTICATION_TOKEN: number;
-		NOTE_TOO_LONG: number;
-		INVALID_BULK_DELETE_QUANTITY: number;
-		CANNOT_PIN_MESSAGE_IN_OTHER_CHANNEL: number;
-		CANNOT_EXECUTE_ON_SYSTEM_MESSAGE: number;
-		BULK_DELETE_MESSAGE_TOO_OLD: number;
-		INVITE_ACCEPTED_TO_GUILD_NOT_CONTAINING_BOT: number;
-		REACTION_BLOCKED: number;
-	};
-
-	type AddGuildMemberOptions = {
-		accessToken: String;
-		nick?: string;
-		roles?: Collection<Snowflake, Role> | RoleResolvable[];
-		mute?: boolean;
-		deaf?: boolean;
-	};
-
-	type AuditLogChange = {
-		key: string;
-		old?: any;
-		new?: any;
-	};
-
-	type AvatarOptions = {
-		format?: ImageExt;
-		size?: ImageSize;
-	};
-
-	type AwaitMessagesOptions = MessageCollectorOptions & { errors?: string[] };
-
-	type AwaitReactionsOptions = ReactionCollectorOptions & { errors?: string[] };
-
-	type BanOptions = {
-		days?: number;
-		reason?: string;
-	};
-
-	type Base64Resolvable = Buffer | Base64String;
-
-	type Base64String = string;
-
-	type BitFieldResolvable<T extends string> = RecursiveArray<T | number | Readonly<BitField<T>>> | T | number | Readonly<BitField<T>>;
-
-	type BufferResolvable = Buffer | string;
-
-	type ChannelCreationOverwrites = {
-		allow?: PermissionResolvable | number;
-		deny?: PermissionResolvable | number;
-		id: RoleResolvable | UserResolvable;
-	};
-
-	type ChannelData = {
-		name?: string;
-		position?: number;
-		topic?: string;
-		nsfw?: boolean;
-		bitrate?: number;
-		userLimit?: number;
-		parentID?: Snowflake;
-		rateLimitPerUser?: number;
-		lockPermissions?: boolean;
-		permissionOverwrites?: OverwriteResolvable[] | Collection<Snowflake, OverwriteResolvable>;
-	};
-
-	type ChannelLogsQueryOptions = {
-		limit?: number
-		before?: Snowflake
-		after?: Snowflake
-		around?: Snowflake
-	};
-
-	type ChannelPosition = {
-		channel: ChannelResolvable;
-		position: number;
-	};
-
-	type ChannelResolvable = Channel | Snowflake;
-
-	type ClientApplicationAsset = {
-		name: string;
-		id: Snowflake;
-		type: 'BIG' | 'SMALL';
-	};
-
-	type ClientOptions = {
-		presence?: PresenceData;
-		shardId?: number;
-		shardCount?: number;
-		messageCacheMaxSize?: number;
-		messageCacheLifetime?: number;
-		messageSweepInterval?: number;
-		fetchAllMembers?: boolean;
-		disableEveryone?: boolean;
-		replyPrefixer?: ReplyPrefixer;
-		restWsBridgeTimeout?: number;
-		restTimeOffset?: number;
-		retryLimit?: number,
-		disabledEvents?: WSEventType[];
-		ws?: WebSocketOptions;
-		http?: HTTPOptions;
-	};
-
-	type CollectorFilter = (...args: any[]) => boolean;
-	type CollectorOptions = {
-		time?: number;
-		dispose?: boolean;
-	};
-
-	type ColorResolvable = ('DEFAULT'
-		| 'AQUA'
-		| 'GREEN'
-		| 'BLUE'
-		| 'PURPLE'
-		| 'LUMINOUS_VIVID_PINK'
-		| 'GOLD'
-		| 'ORANGE'
-		| 'RED'
-		| 'GREY'
-		| 'DARKER_GREY'
-		| 'NAVY'
-		| 'DARK_AQUA'
-		| 'DARK_GREEN'
-		| 'DARK_BLUE'
-		| 'DARK_PURPLE'
-		| 'DARK_VIVID_PINK'
-		| 'DARK_GOLD'
-		| 'DARK_ORANGE'
-		| 'DARK_RED'
-		| 'DARK_GREY'
-		| 'LIGHT_GREY'
-		| 'DARK_NAVY'
-		| 'RANDOM')
-		| [number, number, number]
-		| number
-		| string;
-
-	type DeconstructedSnowflake = {
-		timestamp: number;
-		readonly date: Date;
-		workerID: number;
-		processID: number;
-		increment: number;
-		binary: string;
-	};
-
-	type DefaultMessageNotifications = 'ALL' | 'MENTIONS';
-
-	type GuildEmojiEditData = {
-		name?: string;
-		roles?: Collection<Snowflake, Role> | RoleResolvable[];
-	};
-
-	type EmbedField = { name: string, value: string, inline?: boolean };
-
-	type EmojiIdentifierResolvable = string | EmojiResolvable;
-
-	type EmojiResolvable = Snowflake | GuildEmoji | ReactionEmoji;
-
-	type Extendable = {
-		GuildEmoji: typeof GuildEmoji;
-		DMChannel: typeof DMChannel;
-		GroupDMChannel: typeof GroupDMChannel;
-		TextChannel: typeof TextChannel;
-		VoiceChannel: typeof VoiceChannel;
-		CategoryChannel: typeof CategoryChannel;
-		GuildChannel: typeof GuildChannel;
-		GuildMember: typeof GuildMember;
-		Guild: typeof Guild;
-		Message: typeof Message;
-		MessageReaction: typeof MessageReaction;
-		Presence: typeof Presence;
-		VoiceState: typeof VoiceState;
-		Role: typeof Role;
-		User: typeof User;
-	};
-
-	type FetchMemberOptions = {
-		user: UserResolvable;
-		cache?: boolean;
-	};
-
-	type FetchMembersOptions = {
-		query?: string;
-		limit?: number;
-	};
-
-	type FileOptions = {
-		attachment: BufferResolvable | Stream;
-		name?: string;
-	};
-
-	type GroupActivity = {
-		partyID: string;
-		type: number;
-	};
-
-	type GroupDMRecipientOptions = {
-		user?: UserResolvable | Snowflake;
-		accessToken?: string;
-		nick?: string;
-		id?: Snowflake;
-	};
-
-	type GuildAuditLogsAction = keyof GuildAuditLogsActions;
-
-	type GuildAuditLogsActions = {
-		ALL?: null,
-		GUILD_UPDATE?: number,
-		CHANNEL_CREATE?: number,
-		CHANNEL_UPDATE?: number,
-		CHANNEL_DELETE?: number,
-		CHANNEL_OVERWRITE_CREATE?: number,
-		CHANNEL_OVERWRITE_UPDATE?: number,
-		CHANNEL_OVERWRITE_DELETE?: number,
-		MEMBER_KICK?: number,
-		MEMBER_PRUNE?: number,
-		MEMBER_BAN_ADD?: number,
-		MEMBER_BAN_REMOVE?: number,
-		MEMBER_UPDATE?: number,
-		MEMBER_ROLE_UPDATE?: number,
-		ROLE_CREATE?: number,
-		ROLE_UPDATE?: number,
-		ROLE_DELETE?: number,
-		INVITE_CREATE?: number,
-		INVITE_UPDATE?: number,
-		INVITE_DELETE?: number,
-		WEBHOOK_CREATE?: number,
-		WEBHOOK_UPDATE?: number,
-		WEBHOOK_DELETE?: number,
-		EMOJI_CREATE?: number,
-		EMOJI_UPDATE?: number,
-		EMOJI_DELETE?: number,
-		MESSAGE_DELETE?: number
-	};
-
-	type GuildAuditLogsActionType = 'CREATE'
-		| 'DELETE'
-		| 'UPDATE'
-		| 'ALL';
-
-	type GuildAuditLogsFetchOptions = {
-		before?: Snowflake | GuildAuditLogsEntry;
-		after?: Snowflake | GuildAuditLogsEntry;
-		limit?: number;
-		user?: UserResolvable;
-		type?: string | number;
-	};
-
-	type GuildAuditLogsTarget = keyof GuildAuditLogsTargets;
-
-	type GuildAuditLogsTargets = {
-		ALL?: string;
-		GUILD?: string;
-		CHANNEL?: string;
-		USER?: string;
-		ROLE?: string;
-		INVITE?: string;
-		WEBHOOK?: string;
-		EMOJI?: string;
-		MESSAGE?: string;
-	};
-
-	type GuildChannelCloneOptions = {
-		bitrate?: number;
-		name?: string;
-		nsfw?: boolean;
-		parent?: ChannelResolvable;
-		reason?: string;
-		userLimit?: number;
-		withPermissions?: boolean;
-		withTopic?: boolean;
-	};
-
-	type GuildChannelResolvable = Snowflake | GuildChannel;
-
-	type GuildCreateChannelOptions = {
-		type?: 'text' | 'voice' | 'category'
-		nsfw?: boolean;
-		bitrate?: number;
-		userLimit?: number;
-		parent?: ChannelResolvable;
-		permissionOverwrites?: OverwriteResolvable[] | Collection<Snowflake, OverwriteResolvable>;
-		rateLimitPerUser?: number;
-		reason?: string
-	};
-
-	type GuildEmojiCreateOptions = {
-		roles?: Collection<Snowflake, Role> | RoleResolvable[];
-		reason?: string;
-	};
-
-	type GuildEditData = {
-		name?: string;
-		region?: string;
-		verificationLevel?: number;
-		explicitContentFilter?: number;
-		defaultMessageNotifications?: DefaultMessageNotifications | number;
-		afkChannel?: ChannelResolvable;
-		systemChannel?: ChannelResolvable;
-		afkTimeout?: number;
-		icon?: Base64Resolvable;
-		owner?: GuildMemberResolvable;
-		splash?: Base64Resolvable;
-	};
-
-	type GuildEmbedData = {
-		enabled: boolean;
-		channel?: GuildChannelResolvable;
-	};
-
-	type GuildFeatures = 'INVITE_SPLASH'
-		| 'MORE_EMOJI'
-		| 'VERIFIED'
-		| 'VIP_REGIONS'
-		| 'VANITY_URL';
-
-	type GuildMemberEditData = {
-		nick?: string;
-		roles?: Collection<Snowflake, Role> | RoleResolvable[];
-		mute?: boolean;
-		deaf?: boolean;
-		channel?: ChannelResolvable;
-	};
-
-	type GuildMemberResolvable = GuildMember | UserResolvable;
-
-	type GuildResolvable = Guild | Snowflake;
-
-	type GuildPruneMembersOptions = {
-		days?: number;
-		dry?: boolean;
-		reason?: string;
-	};
-
-	type HTTPOptions = {
-		version?: number;
-		host?: string;
-		cdn?: string;
-		invite?: string;
-	};
-
-	type ImageExt = 'webp'
-		| 'png'
-		| 'jpg'
-		| 'gif';
-
-	type ImageSize = 128
-		| 256
-		| 512
-		| 1024
-		| 2048;
-
-	type IntegrationData = {
-		id: string;
-		type: string;
-	};
-
-	type IntegrationEditData = {
-		expireBehavior?: number;
-		expireGracePeriod?: number;
-	};
-
-	type IntegrationAccount = {
-		id: string;
-		name: string;
-	};
-
-	type InviteOptions = {
-		temporary?: boolean;
-		maxAge?: number;
-		maxUses?: number;
-		unique?: boolean;
-		reason?: string;
-	};
-
-	type InviteResolvable = string;
-
-	type MessageCollectorOptions = CollectorOptions & {
-		max?: number;
-		maxProcessed?: number;
-	};
-
-	type MessageAdditions = MessageEmbed | MessageAttachment | (MessageEmbed | MessageAttachment)[];
-
-	type MessageEditOptions = {
-		content?: string;
-		embed?: MessageEmbedOptions | null;
-		code?: string | boolean;
-	};
-
-	type MessageEmbedOptions = {
-		title?: string;
-		description?: string;
-		url?: string;
-		timestamp?: Date | number;
-		color?: number | string;
-		fields?: { name: string; value: string; inline?: boolean; }[];
-		files?: (MessageAttachment | string | FileOptions)[];
-		author?: { name?: string; url?: string; icon_url?: string; iconURL?: string; };
-		thumbnail?: { url?: string; height?: number; width?: number; };
-		image?: { url?: string; proxy_url?: string; proxyURL?: string; height?: number; width?: number; };
-		video?: { url?: string; height?: number; width?: number; };
-		footer?: { text?: string; icon_url?: string; iconURL?: string; };
-	};
-
-	type MessageOptions = {
-		tts?: boolean;
-		nonce?: string;
-		content?: string;
-		embed?: MessageEmbed | MessageEmbedOptions,
-		disableEveryone?: boolean;
-		files?: (FileOptions | BufferResolvable | Stream | MessageAttachment)[];
-		code?: string | boolean;
-		split?: boolean | SplitOptions;
-		reply?: UserResolvable;
-		replyPrefixer?: ReplyPrefixer;
-	};
-
-	type MessageReactionResolvable = MessageReaction | Snowflake;
-
-	type MessageResolvable = Message | Snowflake;
-
-	type MessageTarget = TextChannel | DMChannel | GroupDMChannel | User | GuildMember | Webhook | WebhookClient;
-
-	type MessageType = 'DEFAULT'
-		| 'RECIPIENT_ADD'
-		| 'RECIPIENT_REMOVE'
-		| 'CALL'
-		| 'CHANNEL_NAME_CHANGE'
-		| 'CHANNEL_ICON_CHANGE'
-		| 'PINS_ADD'
-		| 'GUILD_MEMBER_JOIN';
-
-	type OverwriteData = {
-		allow?: PermissionResolvable;
-		deny?: PermissionResolvable;
-		id: GuildMemberResolvable | RoleResolvable;
-		type?: OverwriteType;
-	};
-
-	type OverwriteResolvable = PermissionOverwrites | OverwriteData;
-
-	type OverwriteType = 'member' | 'role';
-
-	type PermissionFlags = Record<PermissionString, number>;
-
-	type PermissionObject = Record<PermissionString, boolean>;
-
-	type PermissionOverwriteOption = { [k in PermissionString]?: boolean | null };
-
-	type PermissionString = 'CREATE_INSTANT_INVITE'
-		| 'KICK_MEMBERS'
-		| 'BAN_MEMBERS'
-		| 'ADMINISTRATOR'
-		| 'MANAGE_CHANNELS'
-		| 'MANAGE_GUILD'
-		| 'ADD_REACTIONS'
-		| 'VIEW_AUDIT_LOG'
-		| 'PRIORITY_SPEAKER'
-		| 'VIEW_CHANNEL'
-		| 'SEND_MESSAGES'
-		| 'SEND_TTS_MESSAGES'
-		| 'MANAGE_MESSAGES'
-		| 'EMBED_LINKS'
-		| 'ATTACH_FILES'
-		| 'READ_MESSAGE_HISTORY'
-		| 'MENTION_EVERYONE'
-		| 'USE_EXTERNAL_EMOJIS'
-		| 'CONNECT'
-		| 'SPEAK'
-		| 'MUTE_MEMBERS'
-		| 'DEAFEN_MEMBERS'
-		| 'MOVE_MEMBERS'
-		| 'USE_VAD'
-		| 'CHANGE_NICKNAME'
-		| 'MANAGE_NICKNAMES'
-		| 'MANAGE_ROLES'
-		| 'MANAGE_WEBHOOKS'
-		| 'MANAGE_EMOJIS';
-
-	interface RecursiveArray<T> extends Array<T | RecursiveArray<T>> { }
-
-	type PermissionResolvable = BitFieldResolvable<PermissionString>;
-
-	type PermissionOverwriteOptions = {
-		allow: PermissionResolvable;
-		deny: PermissionResolvable;
-		id: UserResolvable | RoleResolvable;
-	};
-
-	type PresenceData = {
-		status?: PresenceStatus;
-		afk?: boolean;
-		activity?: {
-			name?: string;
-			type?: ActivityType | number;
-			url?: string;
-		}
-	};
-
-	type PresenceResolvable = Presence | UserResolvable | Snowflake;
-
-	type PresenceStatus = 'online' | 'idle' | 'invisible' | 'dnd';
-
-	type RateLimitData = {
-		timeout: number;
-		limit: number;
-		timeDifference: number;
-		method: string;
-		path: string;
-		route: string;
-	};
-
-	type RawOverwriteData = {
-		id: Snowflake;
-		allow: number;
-		deny: number;
-		type: OverwriteType;
-	};
-
-	type ReactionCollectorOptions = CollectorOptions & {
-		max?: number;
-		maxEmojis?: number;
-		maxUsers?: number;
-	};
-
-	type ReplyPrefixer = (user: UserResolvable) => string;
-
-	type ResolvedOverwriteOptions = {
-		allow: Permissions;
-		deny: Permissions;
-	};
-
-	type RoleData = {
-		name?: string;
-		color?: ColorResolvable;
-		hoist?: boolean;
-		position?: number;
-		permissions?: PermissionResolvable;
-		mentionable?: boolean;
-	};
-
-	type RoleResolvable = Role | string;
-
-	type Snowflake = string;
-
-	type SplitOptions = {
-		maxLength?: number;
-		char?: string;
-		prepend?: string;
-		append?: string;
-	};
-
-	type Status = number;
-
-	type StreamOptions = {
-		type?: StreamType;
-		seek?: number;
-		volume?: number;
-		passes?: number;
-		plp?: number;
-		fec?: boolean;
-		bitrate?: number | 'auto'
-		highWaterMark?: number;
-	};
-
-	type SpeakingString = 'SPEAKING' | 'SOUNDSHARE';
-
-	type StreamType = 'unknown' | 'converted' | 'opus' | 'ogg/opus' | 'webm/opus';
-
-	type StringResolvable = string | string[] | any;
-
-	type UserResolvable = User | Snowflake | Message | GuildMember;
-
-	type VoiceStatus = number;
-
-	type WebhookEditData = {
-		name?: string;
-		avatar?: BufferResolvable;
-		channel?: ChannelResolvable;
-		reason?: string;
-	};
-
-	type WebhookMessageOptions = {
-		username?: string;
-		avatarURL?: string;
-		tts?: boolean;
-		nonce?: string;
-		embeds?: (MessageEmbed | object)[];
-		disableEveryone?: boolean;
-		files?: (FileOptions | BufferResolvable | Stream | MessageAttachment)[];
-		code?: string | boolean;
-		split?: boolean | SplitOptions;
-	};
-
-	type WebSocketOptions = {
-		large_threshold?: number;
-		compress?: boolean;
-	};
-
-	type WSEventType = 'READY'
-		| 'RESUMED'
-		| 'GUILD_CREATE'
-		| 'GUILD_DELETE'
-		| 'GUILD_UPDATE'
-		| 'GUILD_MEMBER_ADD'
-		| 'GUILD_MEMBER_REMOVE'
-		| 'GUILD_MEMBER_UPDATE'
-		| 'GUILD_MEMBERS_CHUNK'
-		| 'GUILD_ROLE_CREATE'
-		| 'GUILD_ROLE_DELETE'
-		| 'GUILD_ROLE_UPDATE'
-		| 'GUILD_BAN_ADD'
-		| 'GUILD_BAN_REMOVE'
-		| 'GUILD_EMOJIS_UPDATE'
-		| 'GUILD_INTEGRATIONS_UPDATE'
-		| 'CHANNEL_CREATE'
-		| 'CHANNEL_DELETE'
-		| 'CHANNEL_UPDATE'
-		| 'CHANNEL_PINS_UPDATE'
-		| 'MESSAGE_CREATE'
-		| 'MESSAGE_DELETE'
-		| 'MESSAGE_UPDATE'
-		| 'MESSAGE_DELETE_BULK'
-		| 'MESSAGE_REACTION_ADD'
-		| 'MESSAGE_REACTION_REMOVE'
-		| 'MESSAGE_REACTION_REMOVE_ALL'
-		| 'USER_UPDATE'
-		| 'PRESENCE_UPDATE'
-		| 'VOICE_STATE_UPDATE'
-		| 'TYPING_START'
-		| 'VOICE_SERVER_UPDATE'
-		| 'WEBHOOKS_UPDATE';
-
-//#endregion
+  import BaseCollection from '@discordjs/collection';
+  import { EventEmitter } from 'events';
+  import { Stream, Readable, Writable } from 'stream';
+  import { ChildProcess } from 'child_process';
+  import { PathLike } from 'fs';
+  import * as WebSocket from 'ws';
+
+  export const version: string;
+
+  //#region Classes
+
+  export class Activity {
+    constructor(presence: Presence, data?: object);
+    public applicationID: Snowflake | null;
+    public assets: RichPresenceAssets | null;
+    public readonly createdAt: Date;
+    public createdTimestamp: number;
+    public details: string | null;
+    public emoji: Emoji | null;
+    public name: string;
+    public party: {
+      id: string | null;
+      size: [number, number];
+    } | null;
+    public state: string | null;
+    public timestamps: {
+      start: Date | null;
+      end: Date | null;
+    } | null;
+    public type: ActivityType;
+    public url: string | null;
+    public equals(activity: Activity): boolean;
+  }
+
+  export class ActivityFlags extends BitField<ActivityFlagsString> {
+    public static FLAGS: Record<ActivityFlagsString, number>;
+    public static resolve(bit?: BitFieldResolvable<ActivityFlagsString>): number;
+  }
+
+  export class APIMessage {
+    constructor(target: MessageTarget, options: MessageOptions | WebhookMessageOptions);
+    public data: object | null;
+    public readonly isUser: boolean;
+    public readonly isWebhook: boolean;
+    public files: object[] | null;
+    public options: MessageOptions | WebhookMessageOptions;
+    public target: MessageTarget;
+
+    public static create(
+      target: MessageTarget,
+      content?: StringResolvable,
+      options?: MessageOptions | WebhookMessageOptions | MessageAdditions,
+      extra?: MessageOptions | WebhookMessageOptions,
+    ): APIMessage;
+    public static partitionMessageAdditions(
+      items: (MessageEmbed | MessageAttachment)[],
+    ): [MessageEmbed[], MessageAttachment[]];
+    public static resolveFile(fileLike: BufferResolvable | Stream | FileOptions | MessageAttachment): Promise<object>;
+    public static transformOptions(
+      content: StringResolvable,
+      options: MessageOptions | WebhookMessageOptions | MessageAdditions,
+      extra?: MessageOptions | WebhookMessageOptions,
+      isWebhook?: boolean,
+    ): MessageOptions | WebhookMessageOptions;
+
+    public makeContent(): string | string[] | undefined;
+    public resolve(): Promise<this>;
+    public resolveData(): this;
+    public resolveFiles(): Promise<this>;
+    public split(): APIMessage[];
+  }
+
+  export class Base {
+    constructor(client: Client);
+    public readonly client: Client;
+    public toJSON(...props: { [key: string]: boolean | string }[]): object;
+    public valueOf(): string;
+  }
+
+  export class BaseClient extends EventEmitter {
+    constructor(options?: ClientOptions);
+    private _timeouts: Set<NodeJS.Timer>;
+    private _intervals: Set<NodeJS.Timer>;
+    private _immediates: Set<NodeJS.Immediate>;
+    private readonly api: object;
+    private rest: object;
+
+    public options: ClientOptions;
+    public clearInterval(interval: NodeJS.Timer): void;
+    public clearTimeout(timeout: NodeJS.Timer): void;
+    public clearImmediate(timeout: NodeJS.Immediate): void;
+    public destroy(): void;
+    public setInterval(fn: (...args: any[]) => void, delay: number, ...args: any[]): NodeJS.Timer;
+    public setTimeout(fn: (...args: any[]) => void, delay: number, ...args: any[]): NodeJS.Timer;
+    public setImmediate(fn: (...args: any[]) => void, ...args: any[]): NodeJS.Immediate;
+    public toJSON(...props: { [key: string]: boolean | string }[]): object;
+  }
+
+  class BroadcastDispatcher extends VolumeMixin(StreamDispatcher) {
+    public broadcast: VoiceBroadcast;
+  }
+
+  export class BitField<S extends string> {
+    constructor(bits?: BitFieldResolvable<S>);
+    public bitfield: number;
+    public add(...bits: BitFieldResolvable<S>[]): BitField<S>;
+    public any(bit: BitFieldResolvable<S>): boolean;
+    public equals(bit: BitFieldResolvable<S>): boolean;
+    public freeze(): Readonly<BitField<S>>;
+    public has(bit: BitFieldResolvable<S>): boolean;
+    public missing(bits: BitFieldResolvable<S>, ...hasParam: readonly unknown[]): S[];
+    public remove(...bits: BitFieldResolvable<S>[]): BitField<S>;
+    public serialize(...hasParam: readonly unknown[]): Record<S, boolean>;
+    public toArray(...hasParam: readonly unknown[]): S[];
+    public toJSON(): number;
+    public valueOf(): number;
+    public [Symbol.iterator](): IterableIterator<S>;
+    public static FLAGS: object;
+    public static resolve(bit?: BitFieldResolvable<any>): number;
+  }
+
+  export class CategoryChannel extends GuildChannel {
+    public readonly children: Collection<Snowflake, GuildChannel>;
+  }
+
+  export class Channel extends Base {
+    constructor(client: Client, data?: object);
+    public readonly createdAt: Date;
+    public readonly createdTimestamp: number;
+    public deleted: boolean;
+    public id: Snowflake;
+    public type: keyof typeof ChannelType;
+    public delete(reason?: string): Promise<Channel>;
+    public fetch(): Promise<Channel>;
+    public toString(): string;
+  }
+
+  export class Client extends BaseClient {
+    constructor(options?: ClientOptions);
+    private actions: object;
+    private _eval(script: string): any;
+    private _validateOptions(options?: ClientOptions): void;
+
+    public channels: ChannelManager;
+    public readonly emojis: GuildEmojiManager;
+    public guilds: GuildManager;
+    public readyAt: Date | null;
+    public readonly readyTimestamp: number | null;
+    public shard: ShardClientUtil | null;
+    public token: string | null;
+    public readonly uptime: number | null;
+    public user: ClientUser | null;
+    public users: UserManager;
+    public voice: ClientVoiceManager | null;
+    public ws: WebSocketManager;
+    public destroy(): void;
+    public fetchApplication(): Promise<ClientApplication>;
+    public fetchInvite(invite: InviteResolvable): Promise<Invite>;
+    public fetchVoiceRegions(): Promise<Collection<string, VoiceRegion>>;
+    public fetchWebhook(id: Snowflake, token?: string): Promise<Webhook>;
+    public generateInvite(permissions?: PermissionResolvable): Promise<string>;
+    public login(token?: string): Promise<string>;
+    public sweepMessages(lifetime?: number): number;
+    public toJSON(): object;
+
+    public on(event: 'channelCreate' | 'channelDelete', listener: (channel: Channel | PartialChannel) => void): this;
+    public on(event: 'channelPinsUpdate', listener: (channel: Channel | PartialChannel, time: Date) => void): this;
+    public on(
+      event: 'channelUpdate',
+      listener: (oldChannel: Channel | PartialChannel, newChannel: Channel | PartialChannel) => void,
+    ): this;
+    public on(event: 'debug' | 'warn', listener: (info: string) => void): this;
+    public on(event: 'disconnect', listener: (event: any, shardID: number) => void): this;
+    public on(event: 'emojiCreate' | 'emojiDelete', listener: (emoji: GuildEmoji) => void): this;
+    public on(event: 'emojiUpdate', listener: (oldEmoji: GuildEmoji, newEmoji: GuildEmoji) => void): this;
+    public on(event: 'error', listener: (error: Error) => void): this;
+    public on(
+      event: 'guildBanAdd' | 'guildBanRemove',
+      listener: (guild: Guild, user: User | PartialUser) => void,
+    ): this;
+    public on(
+      event: 'guildCreate' | 'guildDelete' | 'guildUnavailable' | 'guildIntegrationsUpdate',
+      listener: (guild: Guild) => void,
+    ): this;
+    public on(
+      event: 'guildMemberAdd' | 'guildMemberAvailable' | 'guildMemberRemove',
+      listener: (member: GuildMember | PartialGuildMember) => void,
+    ): this;
+    public on(
+      event: 'guildMembersChunk',
+      listener: (members: Collection<Snowflake, GuildMember | PartialGuildMember>, guild: Guild) => void,
+    ): this;
+    public on(
+      event: 'guildMemberSpeaking',
+      listener: (member: GuildMember | PartialGuildMember, speaking: Readonly<Speaking>) => void,
+    ): this;
+    public on(
+      event: 'guildMemberUpdate',
+      listener: (oldMember: GuildMember | PartialGuildMember, newMember: GuildMember | PartialGuildMember) => void,
+    ): this;
+    public on(event: 'guildUpdate', listener: (oldGuild: Guild, newGuild: Guild) => void): this;
+    public on(event: 'inviteCreate' | 'inviteDelete', listener: (invite: Invite) => void): this;
+    public on(
+      event: 'message' | 'messageDelete' | 'messageReactionRemoveAll',
+      listener: (message: Message | PartialMessage) => void,
+    ): this;
+    public on(event: 'messageReactionRemoveEmoji', listener: (reaction: MessageReaction) => void): this;
+    public on(
+      event: 'messageDeleteBulk',
+      listener: (messages: Collection<Snowflake, Message | PartialMessage>) => void,
+    ): this;
+    public on(
+      event: 'messageReactionAdd' | 'messageReactionRemove',
+      listener: (messageReaction: MessageReaction, user: User | PartialUser) => void,
+    ): this;
+    public on(
+      event: 'messageUpdate',
+      listener: (oldMessage: Message | PartialMessage, newMessage: Message | PartialMessage) => void,
+    ): this;
+    public on(
+      event: 'presenceUpdate',
+      listener: (oldPresence: Presence | undefined, newPresence: Presence) => void,
+    ): this;
+    public on(event: 'rateLimit', listener: (rateLimitData: RateLimitData) => void): this;
+    public on(event: 'ready' | 'invalidated', listener: () => void): this;
+    public on(event: 'roleCreate' | 'roleDelete', listener: (role: Role) => void): this;
+    public on(event: 'roleUpdate', listener: (oldRole: Role, newRole: Role) => void): this;
+    public on(
+      event: 'typingStart' | 'typingStop',
+      listener: (channel: Channel | PartialChannel, user: User | PartialUser) => void,
+    ): this;
+    public on(event: 'userUpdate', listener: (oldUser: User | PartialUser, newUser: User | PartialUser) => void): this;
+    public on(event: 'voiceStateUpdate', listener: (oldState: VoiceState, newState: VoiceState) => void): this;
+    public on(event: 'webhookUpdate', listener: (channel: TextChannel) => void): this;
+    public on(event: 'shardDisconnect', listener: (event: CloseEvent, id: number) => void): this;
+    public on(event: 'shardError', listener: (error: Error, id: number) => void): this;
+    public on(event: 'shardReady' | 'shardReconnecting', listener: (id: number) => void): this;
+    public on(event: 'shardResume', listener: (id: number, replayed: number) => void): this;
+    public on(event: string, listener: (...args: any[]) => void): this;
+
+    public once(event: 'channelCreate' | 'channelDelete', listener: (channel: Channel | PartialChannel) => void): this;
+    public once(event: 'channelPinsUpdate', listener: (channel: Channel | PartialChannel, time: Date) => void): this;
+    public once(
+      event: 'channelUpdate',
+      listener: (oldChannel: Channel | PartialChannel, newChannel: Channel | PartialChannel) => void,
+    ): this;
+    public once(event: 'debug' | 'warn', listener: (info: string) => void): this;
+    public once(event: 'disconnect', listener: (event: any, shardID: number) => void): this;
+    public once(event: 'emojiCreate' | 'emojiDelete', listener: (emoji: GuildEmoji) => void): this;
+    public once(event: 'emojiUpdate', listener: (oldEmoji: GuildEmoji, newEmoji: GuildEmoji) => void): this;
+    public once(event: 'error', listener: (error: Error) => void): this;
+    public once(
+      event: 'guildBanAdd' | 'guildBanRemove',
+      listener: (guild: Guild, user: User | PartialUser) => void,
+    ): this;
+    public once(
+      event: 'guildCreate' | 'guildDelete' | 'guildUnavailable' | 'guildIntegrationsUpdate',
+      listener: (guild: Guild) => void,
+    ): this;
+    public once(
+      event: 'guildMemberAdd' | 'guildMemberAvailable' | 'guildMemberRemove',
+      listener: (member: GuildMember | PartialGuildMember) => void,
+    ): this;
+    public once(
+      event: 'guildMembersChunk',
+      listener: (members: Collection<Snowflake, GuildMember | PartialGuildMember>, guild: Guild) => void,
+    ): this;
+    public once(
+      event: 'guildMemberSpeaking',
+      listener: (member: GuildMember | PartialGuildMember, speaking: Readonly<Speaking>) => void,
+    ): this;
+    public once(
+      event: 'guildMemberUpdate',
+      listener: (oldMember: GuildMember | PartialGuildMember, newMember: GuildMember | PartialGuildMember) => void,
+    ): this;
+    public once(event: 'guildUpdate', listener: (oldGuild: Guild, newGuild: Guild) => void): this;
+    public once(
+      event: 'message' | 'messageDelete' | 'messageReactionRemoveAll',
+      listener: (message: Message | PartialMessage) => void,
+    ): this;
+    public once(
+      event: 'messageDeleteBulk',
+      listener: (messages: Collection<Snowflake, Message | PartialMessage>) => void,
+    ): this;
+    public once(
+      event: 'messageReactionAdd' | 'messageReactionRemove',
+      listener: (messageReaction: MessageReaction, user: User | PartialUser) => void,
+    ): this;
+    public once(
+      event: 'messageUpdate',
+      listener: (oldMessage: Message | PartialMessage, newMessage: Message | PartialMessage) => void,
+    ): this;
+    public once(
+      event: 'presenceUpdate',
+      listener: (oldPresence: Presence | undefined, newPresence: Presence) => void,
+    ): this;
+    public once(event: 'rateLimit', listener: (rateLimitData: RateLimitData) => void): this;
+    public once(event: 'ready' | 'invalidated', listener: () => void): this;
+    public once(event: 'roleCreate' | 'roleDelete', listener: (role: Role) => void): this;
+    public once(event: 'roleUpdate', listener: (oldRole: Role, newRole: Role) => void): this;
+    public once(
+      event: 'typingStart' | 'typingStop',
+      listener: (channel: Channel | PartialChannel, user: User | PartialUser) => void,
+    ): this;
+    public once(
+      event: 'userUpdate',
+      listener: (oldUser: User | PartialUser, newUser: User | PartialUser) => void,
+    ): this;
+    public once(event: 'voiceStateUpdate', listener: (oldState: VoiceState, newState: VoiceState) => void): this;
+    public once(event: 'webhookUpdate', listener: (channel: TextChannel) => void): this;
+    public once(event: 'shardDisconnect', listener: (event: CloseEvent, id: number) => void): this;
+    public once(event: 'shardError', listener: (error: Error, id: number) => void): this;
+    public once(event: 'shardReady' | 'shardReconnecting', listener: (id: number) => void): this;
+    public once(event: 'shardResume', listener: (id: number, replayed: number) => void): this;
+    public once(event: string, listener: (...args: any[]) => void): this;
+  }
+
+  export class ClientApplication extends Base {
+    constructor(client: Client, data: object);
+    public botPublic: boolean | null;
+    public botRequireCodeGrant: boolean | null;
+    public cover: string | null;
+    public readonly createdAt: Date;
+    public readonly createdTimestamp: number;
+    public description: string;
+    public icon: string;
+    public id: Snowflake;
+    public name: string;
+    public owner: User | Team | null;
+    public rpcOrigins: string[];
+    public coverImage(options?: ImageURLOptions): string;
+    public fetchAssets(): Promise<ClientApplicationAsset>;
+    public iconURL(options?: ImageURLOptions): string;
+    public toJSON(): object;
+    public toString(): string;
+  }
+
+  export class ClientUser extends User {
+    public mfaEnabled: boolean;
+    public verified: boolean;
+    public setActivity(options?: ActivityOptions): Promise<Presence>;
+    public setActivity(name: string, options?: ActivityOptions): Promise<Presence>;
+    public setAFK(afk: boolean): Promise<Presence>;
+    public setAvatar(avatar: BufferResolvable | Base64Resolvable): Promise<ClientUser>;
+    public setPresence(data: PresenceData): Promise<Presence>;
+    public setStatus(status: PresenceStatusData, shardID?: number | number[]): Promise<Presence>;
+    public setUsername(username: string): Promise<ClientUser>;
+  }
+
+  export class ClientVoiceManager {
+    constructor(client: Client);
+    public readonly client: Client;
+    public connections: Collection<Snowflake, VoiceConnection>;
+    public broadcasts: VoiceBroadcast[];
+
+    private joinChannel(channel: VoiceChannel): Promise<VoiceConnection>;
+
+    public createBroadcast(): VoiceBroadcast;
+  }
+
+  export abstract class Collector<K, V> extends EventEmitter {
+    constructor(client: Client, filter: CollectorFilter, options?: CollectorOptions);
+    private _timeout: NodeJS.Timer | null;
+    private _idletimeout: NodeJS.Timer | null;
+
+    public readonly client: Client;
+    public collected: Collection<K, V>;
+    public ended: boolean;
+    public filter: CollectorFilter;
+    public readonly next: Promise<V>;
+    public options: CollectorOptions;
+    public checkEnd(): void;
+    public handleCollect(...args: any[]): void;
+    public handleDispose(...args: any[]): void;
+    public stop(reason?: string): void;
+    public resetTimer(options?: { time?: number; idle?: number }): void;
+    public [Symbol.asyncIterator](): AsyncIterableIterator<V>;
+    public toJSON(): object;
+
+    protected listener: (...args: any[]) => void;
+    public abstract collect(...args: any[]): K;
+    public abstract dispose(...args: any[]): K;
+    public abstract endReason(): void;
+
+    public on(event: 'collect' | 'dispose', listener: (...args: any[]) => void): this;
+    public on(event: 'end', listener: (collected: Collection<K, V>, reason: string) => void): this;
+
+    public once(event: 'collect' | 'dispose', listener: (...args: any[]) => void): this;
+    public once(event: 'end', listener: (collected: Collection<K, V>, reason: string) => void): this;
+  }
+
+  type AllowedImageFormat = 'webp' | 'png' | 'jpg' | 'gif';
+
+  export const Constants: {
+    Package: {
+      name: string;
+      version: string;
+      description: string;
+      author: string;
+      license: string;
+      main: PathLike;
+      types: PathLike;
+      homepage: string;
+      keywords: string[];
+      bugs: { url: string };
+      repository: { type: string; url: string };
+      browser: { [key: string]: boolean };
+      scripts: { [key: string]: string };
+      engines: { [key: string]: string };
+      dependencies: { [key: string]: string };
+      peerDependencies: { [key: string]: string };
+      devDependencies: { [key: string]: string };
+      [key: string]: any;
+    };
+    browser: boolean;
+    DefaultOptions: ClientOptions;
+    UserAgent: string | null;
+    Endpoints: {
+      botGateway: string;
+      invite: (root: string, code: string) => string;
+      CDN: (
+        root: string,
+      ) => {
+        Asset: (name: string) => string;
+        DefaultAvatar: (id: string | number) => string;
+        Emoji: (emojiID: string, format: 'png' | 'gif') => string;
+        Avatar: (userID: string | number, hash: string, format: 'default' | AllowedImageFormat, size: number) => string;
+        Banner: (guildID: string | number, hash: string, format: AllowedImageFormat, size: number) => string;
+        Icon: (userID: string | number, hash: string, format: 'default' | AllowedImageFormat, size: number) => string;
+        AppIcon: (userID: string | number, hash: string, format: AllowedImageFormat, size: number) => string;
+        AppAsset: (userID: string | number, hash: string, format: AllowedImageFormat, size: number) => string;
+        GDMIcon: (userID: string | number, hash: string, format: AllowedImageFormat, size: number) => string;
+        Splash: (userID: string | number, hash: string, format: AllowedImageFormat, size: number) => string;
+        TeamIcon: (teamID: string | number, hash: string, format: AllowedImageFormat, size: number) => string;
+      };
+    };
+    WSCodes: {
+      1000: 'WS_CLOSE_REQUESTED';
+      4004: 'TOKEN_INVALID';
+      4010: 'SHARDING_INVALID';
+      4011: 'SHARDING_REQUIRED';
+    };
+    Events: {
+      RATE_LIMIT: 'rateLimit';
+      CLIENT_READY: 'ready';
+      RESUMED: 'resumed';
+      GUILD_CREATE: 'guildCreate';
+      GUILD_DELETE: 'guildDelete';
+      GUILD_UPDATE: 'guildUpdate';
+      INVITE_CREATE: 'inviteCreate';
+      INVITE_DELETE: 'inviteDelete';
+      GUILD_UNAVAILABLE: 'guildUnavailable';
+      GUILD_MEMBER_ADD: 'guildMemberAdd';
+      GUILD_MEMBER_REMOVE: 'guildMemberRemove';
+      GUILD_MEMBER_UPDATE: 'guildMemberUpdate';
+      GUILD_MEMBER_AVAILABLE: 'guildMemberAvailable';
+      GUILD_MEMBER_SPEAKING: 'guildMemberSpeaking';
+      GUILD_MEMBERS_CHUNK: 'guildMembersChunk';
+      GUILD_INTEGRATIONS_UPDATE: 'guildIntegrationsUpdate';
+      GUILD_ROLE_CREATE: 'roleCreate';
+      GUILD_ROLE_DELETE: 'roleDelete';
+      GUILD_ROLE_UPDATE: 'roleUpdate';
+      GUILD_EMOJI_CREATE: 'emojiCreate';
+      GUILD_EMOJI_DELETE: 'emojiDelete';
+      GUILD_EMOJI_UPDATE: 'emojiUpdate';
+      GUILD_BAN_ADD: 'guildBanAdd';
+      GUILD_BAN_REMOVE: 'guildBanRemove';
+      CHANNEL_CREATE: 'channelCreate';
+      CHANNEL_DELETE: 'channelDelete';
+      CHANNEL_UPDATE: 'channelUpdate';
+      CHANNEL_PINS_UPDATE: 'channelPinsUpdate';
+      MESSAGE_CREATE: 'message';
+      MESSAGE_DELETE: 'messageDelete';
+      MESSAGE_UPDATE: 'messageUpdate';
+      MESSAGE_BULK_DELETE: 'messageDeleteBulk';
+      MESSAGE_REACTION_ADD: 'messageReactionAdd';
+      MESSAGE_REACTION_REMOVE: 'messageReactionRemove';
+      MESSAGE_REACTION_REMOVE_ALL: 'messageReactionRemoveAll';
+      USER_UPDATE: 'userUpdate';
+      PRESENCE_UPDATE: 'presenceUpdate';
+      VOICE_STATE_UPDATE: 'voiceStateUpdate';
+      VOICE_BROADCAST_SUBSCRIBE: 'subscribe';
+      VOICE_BROADCAST_UNSUBSCRIBE: 'unsubscribe';
+      TYPING_START: 'typingStart';
+      WEBHOOKS_UPDATE: 'webhookUpdate';
+      DISCONNECT: 'disconnect';
+      RECONNECTING: 'reconnecting';
+      ERROR: 'error';
+      WARN: 'warn';
+      DEBUG: 'debug';
+      SHARD_DISCONNECT: 'shardDisconnect';
+      SHARD_ERROR: 'shardError';
+      SHARD_RECONNECTING: 'shardReconnecting';
+      SHARD_READY: 'shardReady';
+      SHARD_RESUME: 'shardResume';
+      INVALIDATED: 'invalidated';
+      RAW: 'raw';
+    };
+    ShardEvents: {
+      CLOSE: 'close';
+      DESTROYED: 'destroyed';
+      INVALID_SESSION: 'invalidSession';
+      READY: 'ready';
+      RESUMED: 'resumed';
+    };
+    PartialTypes: {
+      [K in PartialTypes]: K;
+    };
+    WSEvents: {
+      [K in WSEventType]: K;
+    };
+    Colors: {
+      DEFAULT: 0x000000;
+      WHITE: 0xffffff;
+      AQUA: 0x1abc9c;
+      GREEN: 0x2ecc71;
+      BLUE: 0x3498db;
+      YELLOW: 0xffff00;
+      PURPLE: 0x9b59b6;
+      LUMINOUS_VIVID_PINK: 0xe91e63;
+      GOLD: 0xf1c40f;
+      ORANGE: 0xe67e22;
+      RED: 0xe74c3c;
+      GREY: 0x95a5a6;
+      NAVY: 0x34495e;
+      DARK_AQUA: 0x11806a;
+      DARK_GREEN: 0x1f8b4c;
+      DARK_BLUE: 0x206694;
+      DARK_PURPLE: 0x71368a;
+      DARK_VIVID_PINK: 0xad1457;
+      DARK_GOLD: 0xc27c0e;
+      DARK_ORANGE: 0xa84300;
+      DARK_RED: 0x992d22;
+      DARK_GREY: 0x979c9f;
+      DARKER_GREY: 0x7f8c8d;
+      LIGHT_GREY: 0xbcc0c0;
+      DARK_NAVY: 0x2c3e50;
+      BLURPLE: 0x7289da;
+      GREYPLE: 0x99aab5;
+      DARK_BUT_NOT_BLACK: 0x2c2f33;
+      NOT_QUITE_BLACK: 0x23272a;
+    };
+    VerificationLevels: ['None', 'Low', 'Medium', '(╯°□°）╯︵ ┻━┻', '┻━┻ ﾐヽ(ಠ益ಠ)ノ彡┻━┻'];
+    Status: {
+      READY: 0;
+      CONNECTING: 1;
+      RECONNECTING: 2;
+      IDLE: 3;
+      NEARLY: 4;
+      DISCONNECTED: 5;
+    };
+    OPCodes: {
+      DISPATCH: 0;
+      HEARTBEAT: 1;
+      IDENTIFY: 2;
+      STATUS_UPDATE: 3;
+      VOICE_STATE_UPDATE: 4;
+      VOICE_GUILD_PING: 5;
+      RESUME: 6;
+      RECONNECT: 7;
+      REQUEST_GUILD_MEMBERS: 8;
+      INVALID_SESSION: 9;
+      HELLO: 10;
+      HEARTBEAT_ACK: 11;
+    };
+    APIErrors: {
+      UNKNOWN_ACCOUNT: 10001;
+      UNKNOWN_APPLICATION: 10002;
+      UNKNOWN_CHANNEL: 10003;
+      UNKNOWN_GUILD: 10004;
+      UNKNOWN_INTEGRATION: 10005;
+      UNKNOWN_INVITE: 10006;
+      UNKNOWN_MEMBER: 10007;
+      UNKNOWN_MESSAGE: 10008;
+      UNKNOWN_OVERWRITE: 10009;
+      UNKNOWN_PROVIDER: 10010;
+      UNKNOWN_ROLE: 10011;
+      UNKNOWN_TOKEN: 10012;
+      UNKNOWN_USER: 10013;
+      UNKNOWN_EMOJI: 10014;
+      UNKNOWN_WEBHOOK: 10015;
+      BOT_PROHIBITED_ENDPOINT: 20001;
+      BOT_ONLY_ENDPOINT: 20002;
+      MAXIMUM_GUILDS: 30001;
+      MAXIMUM_FRIENDS: 30002;
+      MAXIMUM_PINS: 30003;
+      MAXIMUM_ROLES: 30005;
+      MAXIMUM_REACTIONS: 30010;
+      MAXIMUM_CHANNELS: 30013;
+      MAXIMUM_INVITES: 30016;
+      UNAUTHORIZED: 40001;
+      USER_BANNED: 40007;
+      MISSING_ACCESS: 50001;
+      INVALID_ACCOUNT_TYPE: 50002;
+      CANNOT_EXECUTE_ON_DM: 50003;
+      EMBED_DISABLED: 50004;
+      CANNOT_EDIT_MESSAGE_BY_OTHER: 50005;
+      CANNOT_SEND_EMPTY_MESSAGE: 50006;
+      CANNOT_MESSAGE_USER: 50007;
+      CANNOT_SEND_MESSAGES_IN_VOICE_CHANNEL: 50008;
+      CHANNEL_VERIFICATION_LEVEL_TOO_HIGH: 50009;
+      OAUTH2_APPLICATION_BOT_ABSENT: 50010;
+      MAXIMUM_OAUTH2_APPLICATIONS: 50011;
+      INVALID_OAUTH_STATE: 50012;
+      MISSING_PERMISSIONS: 50013;
+      INVALID_AUTHENTICATION_TOKEN: 50014;
+      NOTE_TOO_LONG: 50015;
+      INVALID_BULK_DELETE_QUANTITY: 50016;
+      CANNOT_PIN_MESSAGE_IN_OTHER_CHANNEL: 50019;
+      CANNOT_EXECUTE_ON_SYSTEM_MESSAGE: 50021;
+      INVALID_OAUTH_TOKEN: 50025;
+      BULK_DELETE_MESSAGE_TOO_OLD: 50034;
+      INVALID_FORM_BODY: 50035;
+      INVITE_ACCEPTED_TO_GUILD_NOT_CONTAINING_BOT: 50036;
+      INVALID_API_VERSION: 50041;
+      REACTION_BLOCKED: 90001;
+      RESOURCE_OVERLOADED: 130000;
+    };
+    VoiceStatus: {
+      CONNECTED: 0;
+      CONNECTING: 1;
+      AUTHENTICATING: 2;
+      RECONNECTING: 3;
+      DISCONNECTED: 4;
+    };
+    VoiceOPCodes: {
+      IDENTIFY: 0;
+      SELECT_PROTOCOL: 1;
+      READY: 2;
+      HEARTBEAT: 3;
+      SESSION_DESCRIPTION: 4;
+      SPEAKING: 5;
+      HELLO: 8;
+      CLIENT_CONNECT: 12;
+      CLIENT_DISCONNECT: 13;
+    };
+    ChannelTypes: {
+      TEXT: 0;
+      DM: 1;
+      VOICE: 2;
+      GROUP: 3;
+      CATEGORY: 4;
+      NEWS: 5;
+      STORE: 6;
+    };
+    ClientApplicationAssetTypes: {
+      SMALL: 1;
+      BIG: 2;
+    };
+    MessageTypes: MessageType[];
+    ActivityTypes: ActivityType[];
+    ExplicitContentFilterLevels: ExplicitContentFilterLevel[];
+    DefaultMessageNotifications: DefaultMessageNotifications[];
+    VerificationLevels: VerificationLevel[];
+    MembershipStates: 'INVITED' | 'ACCEPTED';
+  };
+
+  export class DataResolver {
+    public static resolveBase64(data: Base64Resolvable): string;
+    public static resolveFile(resource: BufferResolvable | Stream): Promise<Buffer>;
+    public static resolveImage(resource: BufferResolvable | Base64Resolvable): Promise<string>;
+    public static resolveInviteCode(data: InviteResolvable): string;
+  }
+
+  export class DiscordAPIError extends Error {
+    constructor(path: string, error: object, method: string, httpStatus: number);
+    private static flattenErrors(obj: object, key: string): string[];
+
+    public code: number;
+    public method: string;
+    public path: string;
+    public httpStatus: number;
+  }
+
+  export class DMChannel extends TextBasedChannel(Channel) {
+    constructor(client: Client, data?: object);
+    public messages: MessageManager;
+    public recipient: User;
+    public readonly partial: false;
+    public fetch(): Promise<DMChannel>;
+  }
+
+  export class Emoji extends Base {
+    constructor(client: Client, emoji: object);
+    public animated: boolean;
+    public readonly createdAt: Date | null;
+    public readonly createdTimestamp: number | null;
+    public deleted: boolean;
+    public id: Snowflake | null;
+    public name: string;
+    public readonly identifier: string;
+    public readonly url: string | null;
+    public toJSON(): object;
+    public toString(): string;
+  }
+
+  export class Guild extends Base {
+    constructor(client: Client, data: object);
+    private _sortedRoles(): Collection<Snowflake, Role>;
+    private _sortedChannels(channel: Channel): Collection<Snowflake, GuildChannel>;
+    private _memberSpeakUpdate(user: Snowflake, speaking: boolean): void;
+
+    public readonly afkChannel: VoiceChannel | null;
+    public afkChannelID: Snowflake | null;
+    public afkTimeout: number;
+    public applicationID: Snowflake | null;
+    public available: boolean;
+    public banner: string | null;
+    public channels: GuildChannelManager;
+    public readonly createdAt: Date;
+    public readonly createdTimestamp: number;
+    public defaultMessageNotifications: DefaultMessageNotifications | number;
+    public deleted: boolean;
+    public description: string | null;
+    public embedChannel: GuildChannel | null;
+    public embedChannelID: Snowflake | null;
+    public embedEnabled: boolean;
+    public emojis: GuildEmojiManager;
+    public explicitContentFilter: ExplicitContentFilterLevel;
+    public features: GuildFeatures[];
+    public icon: string | null;
+    public id: Snowflake;
+    public readonly joinedAt: Date;
+    public joinedTimestamp: number;
+    public large: boolean;
+    public maximumMembers: number | null;
+    public maximumPresences: number | null;
+    public readonly me: GuildMember | null;
+    public memberCount: number;
+    public members: GuildMemberManager;
+    public mfaLevel: number;
+    public name: string;
+    public readonly nameAcronym: string;
+    public readonly owner: GuildMember | null;
+    public ownerID: Snowflake;
+    public readonly partnered: boolean;
+    public premiumSubscriptionCount: number | null;
+    public premiumTier: PremiumTier;
+    public presences: PresenceManager;
+    public readonly publicUpdatesChannel: TextChannel | null;
+    public publicUpdatesChannelID: Snowflake | null;
+    public region: string;
+    public roles: RoleManager;
+    public readonly rulesChannel: TextChannel | null;
+    public rulesChannelID: Snowflake | null;
+    public readonly shard: WebSocketShard;
+    public shardID: number;
+    public splash: string | null;
+    public readonly systemChannel: TextChannel | null;
+    public systemChannelFlags: Readonly<SystemChannelFlags>;
+    public systemChannelID: Snowflake | null;
+    public vanityURLCode: string | null;
+    public verificationLevel: VerificationLevel;
+    public readonly verified: boolean;
+    public readonly voice: VoiceState | null;
+    public readonly voiceStates: VoiceStateManager;
+    public readonly widgetChannel: TextChannel | null;
+    public widgetChannelID: Snowflake | null;
+    public widgetEnabled: boolean | null;
+    public addMember(user: UserResolvable, options: AddGuildMemberOptions): Promise<GuildMember>;
+    public bannerURL(options?: ImageURLOptions): string | null;
+    public createIntegration(data: IntegrationData, reason?: string): Promise<Guild>;
+    public delete(): Promise<Guild>;
+    public edit(data: GuildEditData, reason?: string): Promise<Guild>;
+    public equals(guild: Guild): boolean;
+    public fetch(): Promise<Guild>;
+    public fetchAuditLogs(options?: GuildAuditLogsFetchOptions): Promise<GuildAuditLogs>;
+    public fetchBan(user: UserResolvable): Promise<{ user: User; reason: string }>;
+    public fetchBans(): Promise<Collection<Snowflake, { user: User; reason: string }>>;
+    public fetchEmbed(): Promise<GuildEmbedData>;
+    public fetchIntegrations(): Promise<Collection<string, Integration>>;
+    public fetchInvites(): Promise<Collection<string, Invite>>;
+    public fetchVanityCode(): Promise<string>;
+    public fetchVoiceRegions(): Promise<Collection<string, VoiceRegion>>;
+    public fetchWebhooks(): Promise<Collection<Snowflake, Webhook>>;
+    public iconURL(options?: ImageURLOptions & { dynamic?: boolean }): string | null;
+    public leave(): Promise<Guild>;
+    public member(user: UserResolvable): GuildMember | null;
+    public setAFKChannel(afkChannel: ChannelResolvable | null, reason?: string): Promise<Guild>;
+    public setAFKTimeout(afkTimeout: number, reason?: string): Promise<Guild>;
+    public setBanner(banner: Base64Resolvable | null, reason?: string): Promise<Guild>;
+    public setChannelPositions(channelPositions: ChannelPosition[]): Promise<Guild>;
+    public setDefaultMessageNotifications(
+      defaultMessageNotifications: DefaultMessageNotifications | number,
+      reason?: string,
+    ): Promise<Guild>;
+    public setEmbed(embed: GuildEmbedData, reason?: string): Promise<Guild>;
+    public setExplicitContentFilter(explicitContentFilter: ExplicitContentFilterLevel, reason?: string): Promise<Guild>;
+    public setIcon(icon: Base64Resolvable | null, reason?: string): Promise<Guild>;
+    public setName(name: string, reason?: string): Promise<Guild>;
+    public setOwner(owner: GuildMemberResolvable, reason?: string): Promise<Guild>;
+    public setRegion(region: string, reason?: string): Promise<Guild>;
+    public setRolePositions(rolePositions: RolePosition[]): Promise<Guild>;
+    public setSplash(splash: Base64Resolvable | null, reason?: string): Promise<Guild>;
+    public setSystemChannel(systemChannel: ChannelResolvable | null, reason?: string): Promise<Guild>;
+    public setSystemChannelFlags(systemChannelFlags: SystemChannelFlagsResolvable, reason?: string): Promise<Guild>;
+    public setVerificationLevel(verificationLevel: VerificationLevel, reason?: string): Promise<Guild>;
+    public splashURL(options?: ImageURLOptions): string | null;
+    public toJSON(): object;
+    public toString(): string;
+  }
+
+  export class GuildAuditLogs {
+    constructor(guild: Guild, data: object);
+    private webhooks: Collection<Snowflake, Webhook>;
+    private integrations: Collection<Snowflake, Integration>;
+
+    public entries: Collection<Snowflake, GuildAuditLogsEntry>;
+
+    public static Actions: GuildAuditLogsActions;
+    public static Targets: GuildAuditLogsTargets;
+    public static Entry: typeof GuildAuditLogsEntry;
+    public static actionType(action: number): GuildAuditLogsActionType;
+    public static build(...args: any[]): Promise<GuildAuditLogs>;
+    public static targetType(target: number): GuildAuditLogsTarget;
+    public toJSON(): object;
+  }
+
+  class GuildAuditLogsEntry {
+    constructor(logs: GuildAuditLogs, guild: Guild, data: object);
+    public action: GuildAuditLogsAction;
+    public actionType: GuildAuditLogsActionType;
+    public changes: AuditLogChange[] | null;
+    public readonly createdAt: Date;
+    public readonly createdTimestamp: number;
+    public executor: User;
+    public extra: object | Role | GuildMember | null;
+    public id: Snowflake;
+    public reason: string | null;
+    public target: Guild | User | Role | GuildEmoji | Invite | Webhook | Integration | null;
+    public targetType: GuildAuditLogsTarget;
+    public toJSON(): object;
+  }
+
+  export class GuildChannel extends Channel {
+    constructor(guild: Guild, data?: object);
+    private memberPermissions(member: GuildMember): Readonly<Permissions>;
+    private rolePermissions(role: Role): Readonly<Permissions>;
+
+    public readonly calculatedPosition: number;
+    public readonly deletable: boolean;
+    public guild: Guild;
+    public readonly manageable: boolean;
+    public readonly members: Collection<Snowflake, GuildMember>;
+    public name: string;
+    public readonly parent: CategoryChannel | null;
+    public parentID: Snowflake | null;
+    public permissionOverwrites: Collection<Snowflake, PermissionOverwrites>;
+    public readonly permissionsLocked: boolean | null;
+    public readonly position: number;
+    public rawPosition: number;
+    public readonly viewable: boolean;
+    public clone(options?: GuildChannelCloneOptions): Promise<this>;
+    public createInvite(options?: InviteOptions): Promise<Invite>;
+    public createOverwrite(
+      userOrRole: RoleResolvable | UserResolvable,
+      options: PermissionOverwriteOption,
+      reason?: string,
+    ): Promise<this>;
+    public edit(data: ChannelData, reason?: string): Promise<this>;
+    public equals(channel: GuildChannel): boolean;
+    public fetchInvites(): Promise<Collection<string, Invite>>;
+    public lockPermissions(): Promise<this>;
+    public overwritePermissions(
+      overwrites: OverwriteResolvable[] | Collection<Snowflake, OverwriteResolvable>,
+      reason?: string,
+    ): Promise<this>;
+    public permissionsFor(memberOrRole: GuildMemberResolvable | RoleResolvable): Readonly<Permissions> | null;
+    public setName(name: string, reason?: string): Promise<this>;
+    public setParent(
+      channel: GuildChannel | Snowflake,
+      options?: { lockPermissions?: boolean; reason?: string },
+    ): Promise<this>;
+    public setPosition(position: number, options?: { relative?: boolean; reason?: string }): Promise<this>;
+    public setTopic(topic: string, reason?: string): Promise<this>;
+    public updateOverwrite(
+      userOrRole: RoleResolvable | UserResolvable,
+      options: PermissionOverwriteOption,
+      reason?: string,
+    ): Promise<this>;
+  }
+
+  export class GuildEmoji extends Emoji {
+    constructor(client: Client, data: object, guild: Guild);
+    private _roles: string[];
+
+    public available: boolean;
+    public readonly deletable: boolean;
+    public guild: Guild;
+    public id: Snowflake;
+    public managed: boolean;
+    public requiresColons: boolean;
+    public roles: GuildEmojiRoleManager;
+    public readonly url: string;
+    public delete(reason?: string): Promise<GuildEmoji>;
+    public edit(data: GuildEmojiEditData, reason?: string): Promise<GuildEmoji>;
+    public equals(other: GuildEmoji | object): boolean;
+    public fetchAuthor(): Promise<User>;
+    public setName(name: string, reason?: string): Promise<GuildEmoji>;
+  }
+
+  export class GuildMember extends PartialTextBasedChannel(Base) {
+    constructor(client: Client, data: object, guild: Guild);
+    public readonly bannable: boolean;
+    public deleted: boolean;
+    public readonly displayColor: number;
+    public readonly displayHexColor: string;
+    public readonly displayName: string;
+    public guild: Guild;
+    public readonly id: Snowflake;
+    public readonly joinedAt: Date | null;
+    public joinedTimestamp: number | null;
+    public readonly kickable: boolean;
+    public readonly manageable: boolean;
+    public nickname: string | null;
+    public readonly partial: false;
+    public readonly permissions: Readonly<Permissions>;
+    public readonly premiumSince: Date | null;
+    public premiumSinceTimestamp: number | null;
+    public readonly presence: Presence;
+    public roles: GuildMemberRoleManager;
+    public user: User;
+    public readonly voice: VoiceState;
+    public ban(options?: BanOptions): Promise<GuildMember>;
+    public fetch(): Promise<GuildMember>;
+    public createDM(): Promise<DMChannel>;
+    public deleteDM(): Promise<DMChannel>;
+    public edit(data: GuildMemberEditData, reason?: string): Promise<GuildMember>;
+    public hasPermission(
+      permission: PermissionResolvable,
+      options?: { checkAdmin?: boolean; checkOwner?: boolean },
+    ): boolean;
+    public kick(reason?: string): Promise<GuildMember>;
+    public permissionsIn(channel: ChannelResolvable): Readonly<Permissions>;
+    public setNickname(nickname: string, reason?: string): Promise<GuildMember>;
+    public toJSON(): object;
+    public toString(): string;
+    public valueOf(): string;
+  }
+
+  export class HTTPError extends Error {
+    constructor(message: string, name: string, code: number, method: string, path: string);
+    public code: number;
+    public method: string;
+    public name: string;
+    public path: string;
+  }
+
+  export class Integration extends Base {
+    constructor(client: Client, data: object, guild: Guild);
+    public account: IntegrationAccount;
+    public enabled: boolean;
+    public expireBehavior: number;
+    public expireGracePeriod: number;
+    public guild: Guild;
+    public id: Snowflake;
+    public name: string;
+    public role: Role;
+    public syncedAt: number;
+    public syncing: boolean;
+    public type: number;
+    public user: User;
+    public delete(reason?: string): Promise<Integration>;
+    public edit(data: IntegrationEditData, reason?: string): Promise<Integration>;
+    public sync(): Promise<Integration>;
+  }
+
+  export class Invite extends Base {
+    constructor(client: Client, data: object);
+    public channel: GuildChannel | PartialGroupDMChannel;
+    public code: string;
+    public readonly deletable: boolean;
+    public readonly createdAt: Date | null;
+    public createdTimestamp: number | null;
+    public readonly expiresAt: Date | null;
+    public readonly expiresTimestamp: number | null;
+    public guild: Guild | null;
+    public inviter: User | null;
+    public maxAge: number | null;
+    public maxUses: number | null;
+    public memberCount: number;
+    public presenceCount: number;
+    public targetUser: User | null;
+    public targetUserType: TargetUser | null;
+    public temporary: boolean | null;
+    public readonly url: string;
+    public uses: number | null;
+    public delete(reason?: string): Promise<Invite>;
+    public toJSON(): object;
+    public toString(): string;
+  }
+
+  export class Message extends Base {
+    constructor(client: Client, data: object, channel: TextChannel | DMChannel);
+    private _edits: Message[];
+    private patch(data: object): void;
+
+    public activity: MessageActivity | null;
+    public application: ClientApplication | null;
+    public attachments: Collection<Snowflake, MessageAttachment>;
+    public author: User;
+    public channel: TextChannel | DMChannel;
+    public readonly cleanContent: string;
+    public content: string;
+    public readonly createdAt: Date;
+    public createdTimestamp: number;
+    public readonly deletable: boolean;
+    public deleted: boolean;
+    public readonly editable: boolean;
+    public readonly editedAt: Date | null;
+    public editedTimestamp: number | null;
+    public readonly edits: Message[];
+    public embeds: MessageEmbed[];
+    public readonly guild: Guild | null;
+    public id: Snowflake;
+    public readonly member: GuildMember | null;
+    public mentions: MessageMentions;
+    public nonce: string | null;
+    public readonly partial: false;
+    public readonly pinnable: boolean;
+    public pinned: boolean;
+    public reactions: ReactionManager;
+    public system: boolean;
+    public tts: boolean;
+    public type: MessageType;
+    public readonly url: string;
+    public webhookID: Snowflake | null;
+    public flags: Readonly<MessageFlags>;
+    public reference: MessageReference | null;
+    public awaitReactions(
+      filter: CollectorFilter,
+      options?: AwaitReactionsOptions,
+    ): Promise<Collection<Snowflake, MessageReaction>>;
+    public createReactionCollector(filter: CollectorFilter, options?: ReactionCollectorOptions): ReactionCollector;
+    public delete(options?: { timeout?: number; reason?: string }): Promise<Message>;
+    public edit(content: StringResolvable, options?: MessageEditOptions | MessageEmbed): Promise<Message>;
+    public edit(options: MessageEditOptions | MessageEmbed | APIMessage): Promise<Message>;
+    public equals(message: Message, rawData: object): boolean;
+    public fetchWebhook(): Promise<Webhook>;
+    public fetch(): Promise<Message>;
+    public pin(): Promise<Message>;
+    public react(emoji: EmojiIdentifierResolvable): Promise<MessageReaction>;
+    public reply(
+      content?: StringResolvable,
+      options?: MessageOptions | MessageAdditions | (MessageOptions & { split?: false }) | MessageAdditions,
+    ): Promise<Message>;
+    public reply(
+      content?: StringResolvable,
+      options?: (MessageOptions & { split: true | SplitOptions }) | MessageAdditions,
+    ): Promise<Message[]>;
+    public reply(
+      options?:
+        | MessageOptions
+        | MessageAdditions
+        | APIMessage
+        | (MessageOptions & { split?: false })
+        | MessageAdditions
+        | APIMessage,
+    ): Promise<Message>;
+    public reply(
+      options?: (MessageOptions & { split: true | SplitOptions }) | MessageAdditions | APIMessage,
+    ): Promise<Message[]>;
+    public suppressEmbeds(suppress?: boolean): Promise<Message>;
+    public toJSON(): object;
+    public toString(): string;
+    public unpin(): Promise<Message>;
+  }
+
+  export class MessageAttachment {
+    constructor(attachment: BufferResolvable | Stream, name?: string, data?: object);
+
+    public attachment: BufferResolvable | Stream;
+    public height: number | null;
+    public id: Snowflake;
+    public name?: string;
+    public proxyURL: string;
+    public size: number;
+    public readonly spoiler: boolean;
+    public url: string;
+    public width: number | null;
+    public setFile(attachment: BufferResolvable | Stream, name?: string): this;
+    public setName(name: string): this;
+    public toJSON(): object;
+  }
+
+  export class MessageCollector extends Collector<Snowflake, Message> {
+    constructor(channel: TextChannel | DMChannel, filter: CollectorFilter, options?: MessageCollectorOptions);
+    private _handleChannelDeletion(channel: GuildChannel): void;
+    private _handleGuildDeletion(guild: Guild): void;
+
+    public channel: Channel;
+    public options: MessageCollectorOptions;
+    public received: number;
+
+    public collect(message: Message): Snowflake;
+    public dispose(message: Message): Snowflake;
+    public endReason(): string;
+  }
+
+  export class MessageEmbed {
+    constructor(data?: MessageEmbed | MessageEmbedOptions);
+    public author: MessageEmbedAuthor | null;
+    public color?: number;
+    public readonly createdAt: Date | null;
+    public description?: string;
+    public fields: EmbedField[];
+    public files: (MessageAttachment | string | FileOptions)[];
+    public footer: MessageEmbedFooter | null;
+    public readonly hexColor: string | null;
+    public image: MessageEmbedImage | null;
+    public readonly length: number;
+    public provider: MessageEmbedProvider | null;
+    public thumbnail: MessageEmbedThumbnail | null;
+    public timestamp: number | null;
+    public title?: string;
+    public type: string;
+    public url?: string;
+    public readonly video: MessageEmbedVideo | null;
+    public addField(name: StringResolvable, value: StringResolvable, inline?: boolean): this;
+    public addFields(...fields: EmbedFieldData[] | EmbedFieldData[][]): this;
+    public attachFiles(file: (MessageAttachment | FileOptions | string)[]): this;
+    public setAuthor(name: StringResolvable, iconURL?: string, url?: string): this;
+    public setColor(color: ColorResolvable): this;
+    public setDescription(description: StringResolvable): this;
+    public setFooter(text: StringResolvable, iconURL?: string): this;
+    public setImage(url: string): this;
+    public setThumbnail(url: string): this;
+    public setTimestamp(timestamp?: Date | number): this;
+    public setTitle(title: StringResolvable): this;
+    public setURL(url: string): this;
+    public spliceFields(index: number, deleteCount: number, ...fields: EmbedFieldData[] | EmbedFieldData[][]): this;
+    public toJSON(): object;
+
+    public static normalizeField(
+      name: StringResolvable,
+      value: StringResolvable,
+      inline?: boolean,
+    ): Required<EmbedFieldData>;
+    public static normalizeFields(...fields: EmbedFieldData[] | EmbedFieldData[][]): Required<EmbedFieldData>[];
+  }
+
+  export class MessageFlags extends BitField<MessageFlagsString> {
+    public static FLAGS: Record<MessageFlagsString, number>;
+    public static resolve(bit?: BitFieldResolvable<MessageFlagsString>): number;
+  }
+
+  export class MessageMentions {
+    constructor(
+      message: Message,
+      users: object[] | Collection<Snowflake, User>,
+      roles: Snowflake[] | Collection<Snowflake, Role>,
+      everyone: boolean,
+    );
+    private _channels: Collection<Snowflake, GuildChannel> | null;
+    private readonly _content: Message;
+    private _members: Collection<Snowflake, GuildMember> | null;
+
+    public readonly channels: Collection<Snowflake, TextChannel>;
+    public readonly client: Client;
+    public everyone: boolean;
+    public readonly guild: Guild;
+    public has(
+      data: User | GuildMember | Role | GuildChannel,
+      options?: {
+        ignoreDirect?: boolean;
+        ignoreRoles?: boolean;
+        ignoreEveryone?: boolean;
+      },
+    ): boolean;
+    public readonly members: Collection<Snowflake, GuildMember> | null;
+    public roles: Collection<Snowflake, Role>;
+    public users: Collection<Snowflake, User>;
+    public crosspostedChannels: Collection<Snowflake, CrosspostedChannel>;
+    public toJSON(): object;
+
+    public static CHANNELS_PATTERN: RegExp;
+    public static EVERYONE_PATTERN: RegExp;
+    public static ROLES_PATTERN: RegExp;
+    public static USERS_PATTERN: RegExp;
+  }
+
+  export class MessageReaction {
+    constructor(client: Client, data: object, message: Message);
+    private _emoji: GuildEmoji | ReactionEmoji;
+
+    public count: number | null;
+    public readonly emoji: GuildEmoji | ReactionEmoji;
+    public me: boolean;
+    public message: Message;
+    public readonly partial: boolean;
+    public users: ReactionUserManager;
+    public remove(): Promise<MessageReaction>;
+    public fetch(): Promise<MessageReaction>;
+    public toJSON(): object;
+  }
+
+  export class NewsChannel extends TextBasedChannel(GuildChannel) {
+    constructor(guild: Guild, data?: object);
+    public messages: MessageManager;
+    public nsfw: boolean;
+    public topic: string | null;
+    public createWebhook(
+      name: string,
+      options?: { avatar?: BufferResolvable | Base64Resolvable; reason?: string },
+    ): Promise<Webhook>;
+    public setNSFW(nsfw: boolean, reason?: string): Promise<NewsChannel>;
+    public fetchWebhooks(): Promise<Collection<Snowflake, Webhook>>;
+  }
+
+  export class PartialGroupDMChannel extends Channel {
+    constructor(client: Client, data: object);
+    public name: string;
+    public icon: string | null;
+    public iconURL(options?: ImageURLOptions): string | null;
+  }
+
+  export class PermissionOverwrites {
+    constructor(guildChannel: GuildChannel, data?: object);
+    public allow: Readonly<Permissions>;
+    public readonly channel: GuildChannel;
+    public deny: Readonly<Permissions>;
+    public id: Snowflake;
+    public type: OverwriteType;
+    public update(options: PermissionOverwriteOption, reason?: string): Promise<PermissionOverwrites>;
+    public delete(reason?: string): Promise<PermissionOverwrites>;
+    public toJSON(): object;
+    public static resolveOverwriteOptions(
+      options: ResolvedOverwriteOptions,
+      initialPermissions: { allow?: PermissionResolvable; deny?: PermissionResolvable },
+    ): ResolvedOverwriteOptions;
+    public static resolve(overwrite: OverwriteResolvable, guild: Guild): RawOverwriteData;
+  }
+
+  export class Permissions extends BitField<PermissionString> {
+    public any(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
+    public has(permission: PermissionResolvable, checkAdmin?: boolean): boolean;
+    public missing(bits: BitFieldResolvable<PermissionString>, checkAdmin?: boolean): PermissionString[];
+    public serialize(checkAdmin?: boolean): Record<PermissionString, boolean>;
+    public toArray(checkAdmin?: boolean): PermissionString[];
+
+    public static ALL: number;
+    public static DEFAULT: number;
+    public static FLAGS: PermissionFlags;
+    public static resolve(permission?: PermissionResolvable): number;
+  }
+
+  export class Presence {
+    constructor(client: Client, data?: object);
+    public activities: Activity[];
+    public clientStatus: ClientPresenceStatusData | null;
+    public flags: Readonly<ActivityFlags>;
+    public guild: Guild | null;
+    public readonly member: GuildMember | null;
+    public status: PresenceStatus;
+    public readonly user: User | null;
+    public equals(presence: Presence): boolean;
+  }
+
+  export class ReactionCollector extends Collector<Snowflake, MessageReaction> {
+    constructor(message: Message, filter: CollectorFilter, options?: ReactionCollectorOptions);
+    private _handleChannelDeletion(channel: GuildChannel): void;
+    private _handleGuildDeletion(guild: Guild): void;
+    private _handleMessageDeletion(message: Message): void;
+
+    public message: Message;
+    public options: ReactionCollectorOptions;
+    public total: number;
+    public users: Collection<Snowflake, User>;
+
+    public static key(reaction: MessageReaction): Snowflake | string;
+
+    public collect(reaction: MessageReaction): Snowflake | string;
+    public dispose(reaction: MessageReaction, user: User): Snowflake | string;
+    public empty(): void;
+    public endReason(): string | null;
+
+    public on(event: 'collect' | 'dispose' | 'remove', listener: (reaction: MessageReaction, user: User) => void): this;
+    public on(
+      event: 'end',
+      listener: (collected: Collection<Snowflake, MessageReaction>, reason: string) => void,
+    ): this;
+    public on(event: string, listener: (...args: any[]) => void): this;
+
+    public once(
+      event: 'collect' | 'dispose' | 'remove',
+      listener: (reaction: MessageReaction, user: User) => void,
+    ): this;
+    public once(
+      event: 'end',
+      listener: (collected: Collection<Snowflake, MessageReaction>, reason: string) => void,
+    ): this;
+    public once(event: string, listener: (...args: any[]) => void): this;
+  }
+
+  export class ReactionEmoji extends Emoji {
+    constructor(reaction: MessageReaction, emoji: object);
+    public reaction: MessageReaction;
+    public toJSON(): object;
+  }
+
+  export class RichPresenceAssets {
+    constructor(activity: Activity, assets: object);
+    public largeImage: Snowflake | null;
+    public largeText: string | null;
+    public smallImage: Snowflake | null;
+    public smallText: string | null;
+    public largeImageURL(options?: ImageURLOptions): string | null;
+    public smallImageURL(options?: ImageURLOptions): string | null;
+  }
+
+  export class Role extends Base {
+    constructor(client: Client, data: object, guild: Guild);
+    public color: number;
+    public readonly createdAt: Date;
+    public readonly createdTimestamp: number;
+    public deleted: boolean;
+    public readonly editable: boolean;
+    public guild: Guild;
+    public readonly hexColor: string;
+    public hoist: boolean;
+    public id: Snowflake;
+    public managed: boolean;
+    public readonly members: Collection<Snowflake, GuildMember>;
+    public mentionable: boolean;
+    public name: string;
+    public permissions: Readonly<Permissions>;
+    public readonly position: number;
+    public rawPosition: number;
+    public comparePositionTo(role: Role): number;
+    public delete(reason?: string): Promise<Role>;
+    public edit(data: RoleData, reason?: string): Promise<Role>;
+    public equals(role: Role): boolean;
+    public permissionsIn(channel: ChannelResolvable): Readonly<Permissions>;
+    public setColor(color: ColorResolvable, reason?: string): Promise<Role>;
+    public setHoist(hoist: boolean, reason?: string): Promise<Role>;
+    public setMentionable(mentionable: boolean, reason?: string): Promise<Role>;
+    public setName(name: string, reason?: string): Promise<Role>;
+    public setPermissions(permissions: PermissionResolvable, reason?: string): Promise<Role>;
+    public setPosition(position: number, options?: { relative?: boolean; reason?: string }): Promise<Role>;
+    public toJSON(): object;
+    public toString(): string;
+
+    public static comparePositions(role1: Role, role2: Role): number;
+  }
+
+  export class Shard extends EventEmitter {
+    constructor(manager: ShardingManager, id: number);
+    private _evals: Map<string, Promise<any>>;
+    private _exitListener: (...args: any[]) => void;
+    private _fetches: Map<string, Promise<any>>;
+    private _handleExit(respawn?: boolean): void;
+    private _handleMessage(message: any): void;
+
+    public args: string[];
+    public execArgv: string[];
+    public env: object;
+    public id: number;
+    public manager: ShardingManager;
+    public process: ChildProcess | null;
+    public ready: boolean;
+    public worker: any | null;
+    public eval(script: string): Promise<any>;
+    public eval<T>(fn: (client: Client) => T): Promise<T[]>;
+    public fetchClientValue(prop: string): Promise<any>;
+    public kill(): void;
+    public respawn(delay?: number, spawnTimeout?: number): Promise<ChildProcess>;
+    public send(message: any): Promise<Shard>;
+    public spawn(spawnTimeout?: number): Promise<ChildProcess>;
+
+    public on(event: 'spawn' | 'death', listener: (child: ChildProcess) => void): this;
+    public on(event: 'disconnect' | 'ready' | 'reconnecting', listener: () => void): this;
+    public on(event: 'error', listener: (error: Error) => void): this;
+    public on(event: 'message', listener: (message: any) => void): this;
+    public on(event: string, listener: (...args: any[]) => void): this;
+
+    public once(event: 'spawn' | 'death', listener: (child: ChildProcess) => void): this;
+    public once(event: 'disconnect' | 'ready' | 'reconnecting', listener: () => void): this;
+    public once(event: 'error', listener: (error: Error) => void): this;
+    public once(event: 'message', listener: (message: any) => void): this;
+    public once(event: string, listener: (...args: any[]) => void): this;
+  }
+
+  export class ShardClientUtil {
+    constructor(client: Client, mode: ShardingManagerMode);
+    private _handleMessage(message: any): void;
+    private _respond(type: string, message: any): void;
+
+    public client: Client;
+    public readonly count: number;
+    public readonly ids: number[];
+    public mode: ShardingManagerMode;
+    public parentPort: any | null;
+    public broadcastEval(script: string): Promise<any[]>;
+    public broadcastEval<T>(fn: (client: Client) => T): Promise<T[]>;
+    public fetchClientValues(prop: string): Promise<any[]>;
+    public respawnAll(shardDelay?: number, respawnDelay?: number, spawnTimeout?: number): Promise<void>;
+    public send(message: any): Promise<void>;
+
+    public static singleton(client: Client, mode: ShardingManagerMode): ShardClientUtil;
+  }
+
+  export class ShardingManager extends EventEmitter {
+    constructor(
+      file: string,
+      options?: {
+        totalShards?: number | 'auto';
+        shardList?: number[] | 'auto';
+        mode?: ShardingManagerMode;
+        respawn?: boolean;
+        shardArgs?: string[];
+        token?: string;
+        execArgv?: string[];
+      },
+    );
+
+    public file: string;
+    public respawn: boolean;
+    public shardArgs: string[];
+    public shards: Collection<number, Shard>;
+    public token: string | null;
+    public totalShards: number | 'auto';
+    public broadcast(message: any): Promise<Shard[]>;
+    public broadcastEval(script: string): Promise<any[]>;
+    public createShard(id: number): Shard;
+    public fetchClientValues(prop: string): Promise<any[]>;
+    public respawnAll(
+      shardDelay?: number,
+      respawnDelay?: number,
+      spawnTimeout?: number,
+    ): Promise<Collection<number, Shard>>;
+    public spawn(amount?: number | 'auto', delay?: number, spawnTimeout?: number): Promise<Collection<number, Shard>>;
+
+    public on(event: 'shardCreate', listener: (shard: Shard) => void): this;
+
+    public once(event: 'shardCreate', listener: (shard: Shard) => void): this;
+  }
+
+  export class SnowflakeUtil {
+    public static deconstruct(snowflake: Snowflake): DeconstructedSnowflake;
+    public static generate(timestamp?: number | Date): Snowflake;
+  }
+
+  export class Speaking extends BitField<SpeakingString> {
+    public static FLAGS: Record<SpeakingString, number>;
+    public static resolve(bit?: BitFieldResolvable<SpeakingString>): number;
+  }
+
+  export class StoreChannel extends GuildChannel {
+    constructor(guild: Guild, data?: object);
+    public nsfw: boolean;
+  }
+
+  class StreamDispatcher extends VolumeMixin(Writable) {
+    constructor(player: object, options?: StreamOptions, streams?: object);
+    public player: object;
+    public pausedSince: number;
+    public broadcast: VoiceBroadcast | null;
+    public readonly paused: boolean;
+    public readonly pausedTime: boolean | null;
+    public readonly streamTime: number;
+    public readonly totalStreamTime: number;
+    public readonly bitrateEditable: boolean;
+
+    public setBitrate(value: number | 'auto'): boolean;
+    public setPLP(value: number): boolean;
+    public setFEC(enabled: boolean): boolean;
+    public pause(silence?: boolean): void;
+    public resume(): void;
+
+    public on(event: 'close' | 'drain' | 'end' | 'finish' | 'start', listener: () => void): this;
+    public on(event: 'debug', listener: (info: string) => void): this;
+    public on(event: 'error', listener: (err: Error) => void): this;
+    public on(event: 'pipe' | 'unpipe', listener: (src: Readable) => void): this;
+    public on(event: 'speaking', listener: (speaking: boolean) => void): this;
+    public on(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
+    public on(event: string, listener: (...args: any[]) => void): this;
+
+    public once(event: 'close' | 'drain' | 'end' | 'finish' | 'start', listener: () => void): this;
+    public once(event: 'debug', listener: (info: string) => void): this;
+    public once(event: 'error', listener: (err: Error) => void): this;
+    public once(event: 'pipe' | 'unpipe', listener: (src: Readable) => void): this;
+    public once(event: 'speaking', listener: (speaking: boolean) => void): this;
+    public once(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
+    public once(event: string, listener: (...args: any[]) => void): this;
+  }
+
+  export class Structures {
+    public static get<K extends keyof Extendable>(structure: K): Extendable[K];
+    public static get(structure: string): (...args: any[]) => void;
+    public static extend<K extends keyof Extendable, T extends Extendable[K]>(
+      structure: K,
+      extender: (baseClass: Extendable[K]) => T,
+    ): T;
+    public static extend<T extends (...args: any[]) => void>(
+      structure: string,
+      extender: (baseClass: typeof Function) => T,
+    ): T;
+  }
+
+  export class SystemChannelFlags extends BitField<SystemChannelFlagsString> {
+    public static FLAGS: Record<SystemChannelFlagsString, number>;
+    public static resolve(bit?: BitFieldResolvable<SystemChannelFlagsString>): number;
+  }
+
+  export class Team extends Base {
+    constructor(client: Client, data: object);
+    public id: Snowflake;
+    public name: string;
+    public icon: string | null;
+    public ownerID: Snowflake | null;
+    public members: Collection<Snowflake, TeamMember>;
+
+    public readonly owner: TeamMember;
+    public readonly createdAt: Date;
+    public readonly createdTimestamp: number;
+
+    public iconURL(options?: ImageURLOptions): string;
+    public toJSON(): object;
+    public toString(): string;
+  }
+
+  export class TeamMember extends Base {
+    constructor(team: Team, data: object);
+    public team: Team;
+    public readonly id: Snowflake;
+    public permissions: string[];
+    public membershipState: MembershipStates;
+    public user: User;
+
+    public toString(): string;
+  }
+
+  export class TextChannel extends TextBasedChannel(GuildChannel) {
+    constructor(guild: Guild, data?: object);
+    public messages: MessageManager;
+    public nsfw: boolean;
+    public rateLimitPerUser: number;
+    public topic: string | null;
+    public createWebhook(
+      name: string,
+      options?: { avatar?: BufferResolvable | Base64Resolvable; reason?: string },
+    ): Promise<Webhook>;
+    public setNSFW(nsfw: boolean, reason?: string): Promise<TextChannel>;
+    public setRateLimitPerUser(rateLimitPerUser: number, reason?: string): Promise<TextChannel>;
+    public fetchWebhooks(): Promise<Collection<Snowflake, Webhook>>;
+  }
+
+  export class User extends PartialTextBasedChannel(Base) {
+    constructor(client: Client, data: object);
+    public avatar: string | null;
+    public bot: boolean;
+    public readonly createdAt: Date;
+    public readonly createdTimestamp: number;
+    public discriminator: string;
+    public readonly defaultAvatarURL: string;
+    public readonly dmChannel: DMChannel;
+    public id: Snowflake;
+    public locale: string;
+    public readonly partial: false;
+    public readonly presence: Presence;
+    public system?: boolean;
+    public readonly tag: string;
+    public username: string;
+    public avatarURL(options?: ImageURLOptions & { dynamic?: boolean }): string | null;
+    public createDM(): Promise<DMChannel>;
+    public deleteDM(): Promise<DMChannel>;
+    public displayAvatarURL(options?: ImageURLOptions & { dynamic?: boolean }): string;
+    public equals(user: User): boolean;
+    public fetch(): Promise<User>;
+    public toString(): string;
+    public typingDurationIn(channel: ChannelResolvable): number;
+    public typingIn(channel: ChannelResolvable): boolean;
+    public typingSinceIn(channel: ChannelResolvable): Date;
+  }
+
+  export class Util {
+    public static basename(path: string, ext?: string): string;
+    public static binaryToID(num: string): Snowflake;
+    public static cleanContent(str: string, message: Message): string;
+    public static removeMentions(str: string): string;
+    public static cloneObject(obj: object): object;
+    public static convertToBuffer(ab: ArrayBuffer | string): Buffer;
+    public static delayFor(ms: number): Promise<void>;
+    public static discordSort<K, V extends { rawPosition: number; id: string }>(
+      collection: Collection<K, V>,
+    ): Collection<K, V>;
+    public static escapeMarkdown(text: string, options?: EscapeMarkdownOptions): string;
+    public static escapeCodeBlock(text: string): string;
+    public static escapeInlineCode(text: string): string;
+    public static escapeBold(text: string): string;
+    public static escapeItalic(text: string): string;
+    public static escapeUnderline(text: string): string;
+    public static escapeStrikethrough(text: string): string;
+    public static escapeSpoiler(text: string): string;
+    public static cleanCodeBlockContent(text: string): string;
+    public static fetchRecommendedShards(token: string, guildsPerShard?: number): Promise<number>;
+    public static flatten(obj: object, ...props: { [key: string]: boolean | string }[]): object;
+    public static idToBinary(num: Snowflake): string;
+    public static makeError(obj: { name: string; message: string; stack: string }): Error;
+    public static makePlainError(err: Error): { name: string; message: string; stack: string };
+    public static mergeDefault(def: object, given: object): object;
+    public static moveElementInArray(array: any[], element: any, newIndex: number, offset?: boolean): number;
+    public static parseEmoji(text: string): { animated: boolean; name: string; id: string | null } | null;
+    public static resolveColor(color: ColorResolvable): number;
+    public static resolveString(data: StringResolvable): string;
+    public static setPosition<T extends Channel | Role>(
+      item: T,
+      position: number,
+      relative: boolean,
+      sorted: Collection<Snowflake, T>,
+      route: object,
+      reason?: string,
+    ): Promise<{ id: Snowflake; position: number }[]>;
+    public static splitMessage(text: StringResolvable, options?: SplitOptions): string[];
+    public static str2ab(str: string): ArrayBuffer;
+  }
+
+  class VoiceBroadcast extends EventEmitter {
+    constructor(client: Client);
+    public client: Client;
+    public subscribers: StreamDispatcher[];
+    public readonly dispatcher: BroadcastDispatcher;
+    public play(input: string | Readable, options?: StreamOptions): BroadcastDispatcher;
+
+    public on(event: 'end', listener: () => void): this;
+    public on(event: 'error', listener: (error: Error) => void): this;
+    public on(event: 'subscribe' | 'unsubscribe', listener: (dispatcher: StreamDispatcher) => void): this;
+    public on(event: 'warn', listener: (warning: string | Error) => void): this;
+    public on(event: string, listener: (...args: any[]) => void): this;
+
+    public once(event: 'end', listener: () => void): this;
+    public once(event: 'error', listener: (error: Error) => void): this;
+    public once(event: 'subscribe' | 'unsubscribe', listener: (dispatcher: StreamDispatcher) => void): this;
+    public once(event: 'warn', listener: (warning: string | Error) => void): this;
+    public once(event: string, listener: (...args: any[]) => void): this;
+  }
+
+  export class VoiceChannel extends GuildChannel {
+    constructor(guild: Guild, data?: object);
+    public bitrate: number;
+    public readonly editable: boolean;
+    public readonly full: boolean;
+    public readonly joinable: boolean;
+    public readonly speakable: boolean;
+    public userLimit: number;
+    public join(): Promise<VoiceConnection>;
+    public leave(): void;
+    public setBitrate(bitrate: number, reason?: string): Promise<VoiceChannel>;
+    public setUserLimit(userLimit: number, reason?: string): Promise<VoiceChannel>;
+  }
+
+  class VoiceConnection extends EventEmitter {
+    constructor(voiceManager: ClientVoiceManager, channel: VoiceChannel);
+    private authentication: object;
+    private sockets: object;
+    private ssrcMap: Map<number, boolean>;
+    private _speaking: Map<Snowflake, Readonly<Speaking>>;
+    private _disconnect(): void;
+    private authenticate(): void;
+    private authenticateFailed(reason: string): void;
+    private checkAuthenticated(): void;
+    private cleanup(): void;
+    private connect(): void;
+    private onReady(data: object): void;
+    private onSessionDescription(mode: string, secret: string): void;
+    private onSpeaking(data: object): void;
+    private reconnect(token: string, endpoint: string): void;
+    private sendVoiceStateUpdate(options: object): Promise<Shard>;
+    private setSessionID(sessionID: string): void;
+    private setSpeaking(value: BitFieldResolvable<SpeakingString>): void;
+    private setTokenAndEndpoint(token: string, endpoint: string): void;
+    private updateChannel(channel: VoiceChannel): void;
+
+    public channel: VoiceChannel;
+    public readonly client: Client;
+    public readonly dispatcher: StreamDispatcher;
+    public player: object;
+    public receiver: VoiceReceiver;
+    public speaking: Readonly<Speaking>;
+    public status: VoiceStatus;
+    public readonly voice: VoiceState;
+    public voiceManager: ClientVoiceManager;
+    public disconnect(): void;
+    public play(input: VoiceBroadcast | Readable | string, options?: StreamOptions): StreamDispatcher;
+
+    public on(event: 'authenticated' | 'closing' | 'newSession' | 'ready' | 'reconnecting', listener: () => void): this;
+    public on(event: 'debug', listener: (message: string) => void): this;
+    public on(event: 'error' | 'failed' | 'disconnect', listener: (error: Error) => void): this;
+    public on(event: 'speaking', listener: (user: User, speaking: Readonly<Speaking>) => void): this;
+    public on(event: 'warn', listener: (warning: string | Error) => void): this;
+    public on(event: string, listener: (...args: any[]) => void): this;
+
+    public once(
+      event: 'authenticated' | 'closing' | 'newSession' | 'ready' | 'reconnecting',
+      listener: () => void,
+    ): this;
+    public once(event: 'debug', listener: (message: string) => void): this;
+    public once(event: 'error' | 'failed' | 'disconnect', listener: (error: Error) => void): this;
+    public once(event: 'speaking', listener: (user: User, speaking: Readonly<Speaking>) => void): this;
+    public once(event: 'warn', listener: (warning: string | Error) => void): this;
+    public once(event: string, listener: (...args: any[]) => void): this;
+  }
+
+  class VoiceReceiver extends EventEmitter {
+    constructor(connection: VoiceConnection);
+    public createStream(
+      user: UserResolvable,
+      options?: { mode?: 'opus' | 'pcm'; end?: 'silence' | 'manual' },
+    ): Readable;
+
+    public on(event: 'debug', listener: (error: Error | string) => void): this;
+    public on(event: string, listener: (...args: any[]) => void): this;
+
+    public once(event: 'debug', listener: (error: Error | string) => void): this;
+    public once(event: string, listener: (...args: any[]) => void): this;
+  }
+
+  export class VoiceRegion {
+    constructor(data: object);
+    public custom: boolean;
+    public deprecated: boolean;
+    public id: string;
+    public name: string;
+    public optimal: boolean;
+    public vip: boolean;
+    public toJSON(): object;
+  }
+
+  export class VoiceState extends Base {
+    constructor(guild: Guild, data: object);
+    public readonly channel: VoiceChannel | null;
+    public channelID?: Snowflake;
+    public readonly connection: VoiceConnection | null;
+    public readonly deaf?: boolean;
+    public guild: Guild;
+    public id: Snowflake;
+    public readonly member: GuildMember | null;
+    public readonly mute?: boolean;
+    public selfDeaf?: boolean;
+    public selfMute?: boolean;
+    public serverDeaf?: boolean;
+    public serverMute?: boolean;
+    public sessionID?: string;
+    public streaming: boolean;
+    public readonly speaking: boolean | null;
+
+    public setDeaf(deaf: boolean, reason?: string): Promise<GuildMember>;
+    public setMute(mute: boolean, reason?: string): Promise<GuildMember>;
+    public kick(reason?: string): Promise<GuildMember>;
+    public setChannel(channel: ChannelResolvable | null, reason?: string): Promise<GuildMember>;
+    public setSelfDeaf(deaf: boolean): Promise<boolean>;
+    public setSelfMute(mute: boolean): Promise<boolean>;
+  }
+
+  class VolumeInterface extends EventEmitter {
+    constructor(options?: { volume?: number });
+    public readonly volume: number;
+    public readonly volumeDecibels: number;
+    public readonly volumeEditable: boolean;
+    public readonly volumeLogarithmic: number;
+    public setVolume(volume: number): void;
+    public setVolumeDecibels(db: number): void;
+    public setVolumeLogarithmic(value: number): void;
+
+    public on(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
+
+    public once(event: 'volumeChange', listener: (oldVolume: number, newVolume: number) => void): this;
+  }
+
+  export class Webhook extends WebhookMixin() {
+    constructor(client: Client, data?: object);
+    public avatar: string;
+    public avatarURL(options?: ImageURLOptions): string | null;
+    public channelID: Snowflake;
+    public client: Client;
+    public guildID: Snowflake;
+    public name: string;
+    public owner: User | object | null;
+    public token: string | null;
+    public type: WebhookTypes;
+  }
+
+  export class WebhookClient extends WebhookMixin(BaseClient) {
+    constructor(id: string, token: string, options?: ClientOptions);
+    public client: this;
+    public token: string;
+  }
+
+  export class WebSocketManager extends EventEmitter {
+    constructor(client: Client);
+    private totalShards: number | string;
+    private shardQueue: Set<WebSocketShard>;
+    private packetQueue: object[];
+    private destroyed: boolean;
+    private reconnecting: boolean;
+    private sessionStartLimit?: { total: number; remaining: number; reset_after: number };
+
+    public readonly client: Client;
+    public gateway?: string;
+    public shards: Collection<number, WebSocketShard>;
+    public status: Status;
+    public readonly ping: number;
+
+    public on(event: WSEventType, listener: (data: any, shardID: number) => void): this;
+    public once(event: WSEventType, listener: (data: any, shardID: number) => void): this;
+
+    private debug(message: string, shard?: WebSocketShard): void;
+    private connect(): Promise<void>;
+    private createShards(): Promise<void>;
+    private reconnect(): Promise<void>;
+    private broadcast(packet: object): void;
+    private destroy(): void;
+    private _handleSessionLimit(remaining?: number, resetAfter?: number): Promise<void>;
+    private handlePacket(packet?: object, shard?: WebSocketShard): boolean;
+    private checkShardsReady(): Promise<void>;
+    private triggerClientReady(): void;
+  }
+
+  export class WebSocketShard extends EventEmitter {
+    constructor(manager: WebSocketManager, id: number);
+    private sequence: number;
+    private closeSequence: number;
+    private sessionID?: string;
+    private lastPingTimestamp: number;
+    private lastHeartbeatAcked: boolean;
+    private ratelimit: { queue: object[]; total: number; remaining: number; time: 60e3; timer: NodeJS.Timeout | null };
+    private connection: WebSocket | null;
+    private helloTimeout: NodeJS.Timeout | undefined;
+    private eventsAttached: boolean;
+    private expectedGuilds: Set<Snowflake> | undefined;
+    private readyTimeout: NodeJS.Timeout | undefined;
+
+    public manager: WebSocketManager;
+    public id: number;
+    public status: Status;
+    public ping: number;
+
+    private debug(message: string): void;
+    private connect(): Promise<void>;
+    private onOpen(): void;
+    private onMessage(event: MessageEvent): void;
+    private onError(error: ErrorEvent | object): void;
+    private onClose(event: CloseEvent): void;
+    private onPacket(packet: object): void;
+    private checkReady(): void;
+    private setHelloTimeout(time?: number): void;
+    private setHeartbeatTimer(time: number): void;
+    private sendHeartbeat(): void;
+    private ackHeartbeat(): void;
+    private identify(): void;
+    private identifyNew(): void;
+    private identifyResume(): void;
+    private _send(data: object): void;
+    private processQueue(): void;
+    private destroy(destroyOptions?: { closeCode?: number; reset?: boolean; emit?: boolean; log?: boolean }): void;
+    private _cleanupConnection(): void;
+    private _emitDestroyed(): void;
+
+    public send(data: object): void;
+    public on(event: 'ready' | 'resumed' | 'invalidSession', listener: () => void): this;
+    public on(event: 'close', listener: (event: CloseEvent) => void): this;
+    public on(event: 'allReady', listener: (unavailableGuilds?: Set<Snowflake>) => void): this;
+    public on(event: string, listener: (...args: any[]) => void): this;
+
+    public once(event: 'ready' | 'resumed' | 'invalidSession', listener: () => void): this;
+    public once(event: 'close', listener: (event: CloseEvent) => void): this;
+    public once(event: 'allReady', listener: (unavailableGuilds?: Set<Snowflake>) => void): this;
+    public once(event: string, listener: (...args: any[]) => void): this;
+  }
+
+  //#endregion
+
+  //#region Collections
+
+  export class Collection<K, V> extends BaseCollection<K, V> {
+    public flatMap<T>(
+      fn: (value: V, key: K, collection: this) => Collection<K, T>,
+      thisArg?: unknown,
+    ): Collection<K, T>;
+    public flatMap<T, This>(
+      fn: (this: This, value: V, key: K, collection: this) => Collection<K, T>,
+      thisArg: This,
+    ): Collection<K, T>;
+    public mapValues<T>(fn: (value: V, key: K, collection: this) => T, thisArg?: unknown): Collection<K, T>;
+    public mapValues<This, T>(
+      fn: (this: This, value: V, key: K, collection: this) => T,
+      thisArg: This,
+    ): Collection<K, T>;
+    public toJSON(): object;
+  }
+
+  export class LimitedCollection<K, V> extends Collection<K, V> {
+    public constructor(maxSize: number, iterable: Iterable<any>);
+    public maxSize: number;
+  }
+
+  //#endregion
+
+  //#region Managers
+
+  export class ChannelManager extends BaseManager<Snowflake, Channel, ChannelResolvable> {
+    constructor(client: Client, iterable: Iterable<any>);
+    public fetch(id: Snowflake, cache?: boolean): Promise<Channel>;
+  }
+
+  export abstract class BaseManager<K, Holds, R> {
+    constructor(client: Client, iterable: Iterable<any>, holds: Constructable<Holds>, cacheType: Collection<K, Holds>);
+    public holds: Constructable<Holds>;
+    public cache: Collection<K, Holds>;
+    public cacheType: Collection<K, Holds>;
+    public readonly client: Client;
+    public add(data: any, cache?: boolean, { id, extras }?: { id: K; extras: any[] }): Holds;
+    public remove(key: K): void;
+    public resolve(resolvable: R): Holds | null;
+    public resolveID(resolvable: R): K | null;
+  }
+
+  export class GuildChannelManager extends BaseManager<Snowflake, GuildChannel, GuildChannelResolvable> {
+    constructor(guild: Guild, iterable?: Iterable<any>);
+    public guild: Guild;
+    public create(name: string, options: GuildCreateChannelOptions & { type: 'voice' }): Promise<VoiceChannel>;
+    public create(name: string, options: GuildCreateChannelOptions & { type: 'category' }): Promise<CategoryChannel>;
+    public create(name: string, options?: GuildCreateChannelOptions & { type?: 'text' }): Promise<TextChannel>;
+    public create(
+      name: string,
+      options: GuildCreateChannelOptions,
+    ): Promise<TextChannel | VoiceChannel | CategoryChannel>;
+  }
+
+  export class GuildEmojiManager extends BaseManager<Snowflake, GuildEmoji, EmojiResolvable> {
+    constructor(guild: Guild, iterable?: Iterable<any>);
+    public guild: Guild;
+    public create(
+      attachment: BufferResolvable | Base64Resolvable,
+      name: string,
+      options?: GuildEmojiCreateOptions,
+    ): Promise<GuildEmoji>;
+    public resolveIdentifier(emoji: EmojiIdentifierResolvable): string | null;
+  }
+
+  export class GuildEmojiRoleManager {
+    constructor(emoji: GuildEmoji);
+    public emoji: GuildEmoji;
+    public guild: Guild;
+    public cache: Collection<Snowflake, Role>;
+    public add(roleOrRoles: RoleResolvable | RoleResolvable[] | Collection<Snowflake, Role>): Promise<GuildEmoji>;
+    public set(roles: RoleResolvable[] | Collection<Snowflake, Role>): Promise<GuildEmoji>;
+    public remove(roleOrRoles: RoleResolvable | RoleResolvable[] | Collection<Snowflake, Role>): Promise<GuildEmoji>;
+  }
+
+  export class GuildManager extends BaseManager<Snowflake, Guild, GuildResolvable> {
+    constructor(client: Client, iterable?: Iterable<any>);
+    public create(
+      name: string,
+      options?: { region?: string; icon: BufferResolvable | Base64Resolvable | null },
+    ): Promise<Guild>;
+  }
+
+  export class GuildMemberManager extends BaseManager<Snowflake, GuildMember, GuildMemberResolvable> {
+    constructor(guild: Guild, iterable?: Iterable<any>);
+    public guild: Guild;
+    public ban(user: UserResolvable, options?: BanOptions): Promise<GuildMember | User | Snowflake>;
+    public fetch(
+      options: UserResolvable | FetchMemberOptions | (FetchMembersOptions & { user: UserResolvable }),
+    ): Promise<GuildMember>;
+    public fetch(options?: FetchMembersOptions): Promise<Collection<Snowflake, GuildMember>>;
+    public prune(options: GuildPruneMembersOptions & { dry?: false; count: false }): Promise<null>;
+    public prune(options?: GuildPruneMembersOptions): Promise<number>;
+    public unban(user: UserResolvable, reason?: string): Promise<User>;
+  }
+
+  export class GuildMemberRoleManager extends OverridableManager<Snowflake, Role, RoleResolvable> {
+    constructor(member: GuildMember);
+    public readonly hoist: Role | null;
+    public readonly color: Role | null;
+    public readonly highest: Role;
+    public member: GuildMember;
+    public guild: Guild;
+
+    public add(
+      roleOrRoles: RoleResolvable | RoleResolvable[] | Collection<Snowflake, Role>,
+      reason?: string,
+    ): Promise<GuildMember>;
+    public set(roles: RoleResolvable[] | Collection<Snowflake, Role>, reason?: string): Promise<GuildMember>;
+    public remove(
+      roleOrRoles: RoleResolvable | RoleResolvable[] | Collection<Snowflake, Role>,
+      reason?: string,
+    ): Promise<GuildMember>;
+  }
+
+  export class MessageManager extends BaseManager<Snowflake, Message, MessageResolvable> {
+    constructor(channel: TextChannel | DMChannel, iterable?: Iterable<any>);
+    public channel: TextBasedChannelFields;
+    public cache: LimitedCollection<Snowflake, Message>;
+    public fetch(message: Snowflake, cache?: boolean): Promise<Message>;
+    public fetch(options?: ChannelLogsQueryOptions, cache?: boolean): Promise<Collection<Snowflake, Message>>;
+    public fetchPinned(cache?: boolean): Promise<Collection<Snowflake, Message>>;
+    public delete(message: MessageResolvable, reason?: string): Promise<void>;
+  }
+
+  // Hacky workaround because changing the signature of an overridden method errors
+  class OverridableManager<V, K, R = any> extends BaseManager<V, K, R> {
+    public add(data: any, cache: any): any;
+    public set(key: any): any;
+  }
+
+  export class PresenceManager extends BaseManager<Snowflake, Presence, PresenceResolvable> {
+    constructor(client: Client, iterable?: Iterable<any>);
+  }
+
+  export class ReactionManager extends BaseManager<Snowflake, MessageReaction, MessageReactionResolvable> {
+    constructor(message: Message, iterable?: Iterable<any>);
+    public message: Message;
+    public removeAll(): Promise<Message>;
+  }
+
+  export class ReactionUserManager extends BaseManager<Snowflake, User, UserResolvable> {
+    constructor(client: Client, iterable: Iterable<any> | undefined, reaction: MessageReaction);
+    public reaction: MessageReaction;
+    public fetch(options?: {
+      limit?: number;
+      after?: Snowflake;
+      before?: Snowflake;
+    }): Promise<Collection<Snowflake, User>>;
+    public remove(user?: UserResolvable): Promise<MessageReaction>;
+  }
+
+  export class RoleManager extends BaseManager<Snowflake, Role, RoleResolvable> {
+    constructor(guild: Guild, iterable?: Iterable<any>);
+    public readonly everyone: Role | null;
+    public readonly highest: Role;
+    public guild: Guild;
+
+    public create(options?: { data?: RoleData; reason?: string }): Promise<Role>;
+    public fetch(id: Snowflake, cache?: boolean): Promise<Role | null>;
+    public fetch(id?: Snowflake, cache?: boolean): Promise<this>;
+  }
+
+  export class UserManager extends BaseManager<Snowflake, User, UserResolvable> {
+    constructor(client: Client, iterable?: Iterable<any>);
+    public fetch(id: Snowflake, cache?: boolean): Promise<User>;
+  }
+
+  export class VoiceStateManager extends BaseManager<Snowflake, VoiceState, typeof VoiceState> {
+    constructor(guild: Guild, iterable?: Iterable<any>);
+    public guild: Guild;
+  }
+
+  //#endregion
+
+  //#region Mixins
+
+  // Model the TextBasedChannel mixin system, allowing application of these fields
+  // to the classes that use these methods without having to manually add them
+  // to each of those classes
+
+  type Constructable<T> = new (...args: any[]) => T;
+  function PartialTextBasedChannel<T>(Base?: Constructable<T>): Constructable<T & PartialTextBasedChannelFields>;
+  function TextBasedChannel<T>(Base?: Constructable<T>): Constructable<T & TextBasedChannelFields>;
+
+  interface PartialTextBasedChannelFields {
+    lastMessageID: Snowflake | null;
+    lastMessageChannelID: Snowflake | null;
+    readonly lastMessage: Message | null;
+    lastPinTimestamp: number | null;
+    readonly lastPinAt: Date;
+    send(
+      content?: StringResolvable,
+      options?: MessageOptions | MessageAdditions | (MessageOptions & { split?: false }) | MessageAdditions,
+    ): Promise<Message>;
+    send(
+      content?: StringResolvable,
+      options?: (MessageOptions & { split: true | SplitOptions }) | MessageAdditions,
+    ): Promise<Message[]>;
+    send(
+      options?:
+        | MessageOptions
+        | MessageAdditions
+        | APIMessage
+        | (MessageOptions & { split?: false })
+        | MessageAdditions
+        | APIMessage,
+    ): Promise<Message>;
+    send(
+      options?: (MessageOptions & { split: true | SplitOptions }) | MessageAdditions | APIMessage,
+    ): Promise<Message[]>;
+  }
+
+  interface TextBasedChannelFields extends PartialTextBasedChannelFields {
+    typing: boolean;
+    typingCount: number;
+    awaitMessages(filter: CollectorFilter, options?: AwaitMessagesOptions): Promise<Collection<Snowflake, Message>>;
+    bulkDelete(
+      messages: Collection<Snowflake, Message> | Message[] | Snowflake[] | number,
+      filterOld?: boolean,
+    ): Promise<Collection<Snowflake, Message>>;
+    createMessageCollector(filter: CollectorFilter, options?: MessageCollectorOptions): MessageCollector;
+    startTyping(count?: number): Promise<void>;
+    stopTyping(force?: boolean): void;
+  }
+
+  function WebhookMixin<T>(Base?: Constructable<T>): Constructable<T & WebhookFields>;
+
+  function VolumeMixin<T>(base: Constructable<T>): Constructable<T & VolumeInterface>;
+
+  interface WebhookFields {
+    id: Snowflake;
+    readonly createdAt: Date;
+    readonly createdTimestamp: number;
+    readonly url: string;
+    delete(reason?: string): Promise<void>;
+    edit(options: WebhookEditData): Promise<Webhook>;
+    send(
+      content?: StringResolvable,
+      options?: (WebhookMessageOptions & { split?: false }) | MessageAdditions,
+    ): Promise<Message>;
+    send(
+      content?: StringResolvable,
+      options?: (WebhookMessageOptions & { split: true | SplitOptions }) | MessageAdditions,
+    ): Promise<Message[]>;
+    send(options?: (WebhookMessageOptions & { split?: false }) | MessageAdditions | APIMessage): Promise<Message>;
+    send(
+      options?: (WebhookMessageOptions & { split: true | SplitOptions }) | MessageAdditions | APIMessage,
+    ): Promise<Message[]>;
+    sendSlackMessage(body: object): Promise<boolean>;
+  }
+
+  //#endregion
+
+  //#region Typedefs
+
+  type ActivityFlagsString = 'INSTANCE' | 'JOIN' | 'SPECTATE' | 'JOIN_REQUEST' | 'SYNC' | 'PLAY';
+
+  interface ActivityOptions {
+    name?: string;
+    url?: string;
+    type?: ActivityType | number;
+    shardID?: number | number[];
+  }
+
+  type ActivityType = 'PLAYING' | 'STREAMING' | 'LISTENING' | 'WATCHING' | 'CUSTOM_STATUS';
+
+  interface AddGuildMemberOptions {
+    accessToken: string;
+    nick?: string;
+    roles?: Collection<Snowflake, Role> | RoleResolvable[];
+    mute?: boolean;
+    deaf?: boolean;
+  }
+
+  interface APIErrror {
+    UNKNOWN_ACCOUNT: number;
+    UNKNOWN_APPLICATION: number;
+    UNKNOWN_CHANNEL: number;
+    UNKNOWN_GUILD: number;
+    UNKNOWN_INTEGRATION: number;
+    UNKNOWN_INVITE: number;
+    UNKNOWN_MEMBER: number;
+    UNKNOWN_MESSAGE: number;
+    UNKNOWN_OVERWRITE: number;
+    UNKNOWN_PROVIDER: number;
+    UNKNOWN_ROLE: number;
+    UNKNOWN_TOKEN: number;
+    UNKNOWN_USER: number;
+    UNKNOWN_EMOJI: number;
+    UNKNOWN_WEBHOOK: number;
+    BOT_PROHIBITED_ENDPOINT: number;
+    BOT_ONLY_ENDPOINT: number;
+    MAXIMUM_GUILDS: number;
+    MAXIMUM_FRIENDS: number;
+    MAXIMUM_PINS: number;
+    MAXIMUM_ROLES: number;
+    MAXIMUM_REACTIONS: number;
+    UNAUTHORIZED: number;
+    MISSING_ACCESS: number;
+    INVALID_ACCOUNT_TYPE: number;
+    CANNOT_EXECUTE_ON_DM: number;
+    EMBED_DISABLED: number;
+    CANNOT_EDIT_MESSAGE_BY_OTHER: number;
+    CANNOT_SEND_EMPTY_MESSAGE: number;
+    CANNOT_MESSAGE_USER: number;
+    CANNOT_SEND_MESSAGES_IN_VOICE_CHANNEL: number;
+    CHANNEL_VERIFICATION_LEVEL_TOO_HIGH: number;
+    OAUTH2_APPLICATION_BOT_ABSENT: number;
+    MAXIMUM_OAUTH2_APPLICATIONS: number;
+    INVALID_OAUTH_STATE: number;
+    MISSING_PERMISSIONS: number;
+    INVALID_AUTHENTICATION_TOKEN: number;
+    NOTE_TOO_LONG: number;
+    INVALID_BULK_DELETE_QUANTITY: number;
+    CANNOT_PIN_MESSAGE_IN_OTHER_CHANNEL: number;
+    CANNOT_EXECUTE_ON_SYSTEM_MESSAGE: number;
+    BULK_DELETE_MESSAGE_TOO_OLD: number;
+    INVITE_ACCEPTED_TO_GUILD_NOT_CONTAINING_BOT: number;
+    REACTION_BLOCKED: number;
+  }
+
+  interface AuditLogChange {
+    key: string;
+    old?: any;
+    new?: any;
+  }
+
+  interface AwaitMessagesOptions extends MessageCollectorOptions {
+    errors?: string[];
+  }
+
+  interface AwaitReactionsOptions extends ReactionCollectorOptions {
+    errors?: string[];
+  }
+
+  interface BanOptions {
+    days?: number;
+    reason?: string;
+  }
+
+  type Base64Resolvable = Buffer | Base64String;
+
+  type Base64String = string;
+
+  type BitFieldResolvable<T extends string> =
+    | RecursiveArray<T | number | Readonly<BitField<T>>>
+    | T
+    | number
+    | Readonly<BitField<T>>;
+
+  type BufferResolvable = Buffer | string;
+
+  interface ChannelCreationOverwrites {
+    allow?: PermissionResolvable | number;
+    deny?: PermissionResolvable | number;
+    id: RoleResolvable | UserResolvable;
+  }
+
+  interface ChannelData {
+    name?: string;
+    position?: number;
+    topic?: string;
+    nsfw?: boolean;
+    bitrate?: number;
+    userLimit?: number;
+    parentID?: Snowflake;
+    rateLimitPerUser?: number;
+    lockPermissions?: boolean;
+    permissionOverwrites?: OverwriteResolvable[] | Collection<Snowflake, OverwriteResolvable>;
+  }
+
+  interface ChannelLogsQueryOptions {
+    limit?: number;
+    before?: Snowflake;
+    after?: Snowflake;
+    around?: Snowflake;
+  }
+
+  interface ChannelPosition {
+    channel: ChannelResolvable;
+    position: number;
+  }
+
+  type ChannelResolvable = Channel | Snowflake;
+
+  interface ClientApplicationAsset {
+    name: string;
+    id: Snowflake;
+    type: 'BIG' | 'SMALL';
+  }
+
+  interface ClientOptions {
+    shards?: number | number[] | 'auto';
+    shardCount?: number;
+    messageCacheMaxSize?: number;
+    messageCacheLifetime?: number;
+    messageSweepInterval?: number;
+    fetchAllMembers?: boolean;
+    disableMentions?: 'none' | 'all' | 'everyone';
+    partials?: PartialTypes[];
+    replyPrefixer?: ReplyPrefixer;
+    restWsBridgeTimeout?: number;
+    restTimeOffset?: number;
+    restRequestTimeout?: number;
+    restSweepInterval?: number;
+    retryLimit?: number;
+    presence?: PresenceData;
+    disabledEvents?: WSEventType[];
+    ws?: WebSocketOptions;
+    http?: HTTPOptions;
+  }
+
+  type ClientPresenceStatus = 'online' | 'idle' | 'dnd';
+
+  interface ClientPresenceStatusData {
+    web?: ClientPresenceStatus;
+    mobile?: ClientPresenceStatus;
+    desktop?: ClientPresenceStatus;
+  }
+
+  interface CloseEvent {
+    wasClean: boolean;
+    code: number;
+    reason: string;
+    target: WebSocket;
+  }
+
+  type CollectorFilter = (...args: any[]) => boolean;
+
+  interface CollectorOptions {
+    time?: number;
+    idle?: number;
+    dispose?: boolean;
+  }
+
+  type ColorResolvable =
+    | 'DEFAULT'
+    | 'WHITE'
+    | 'AQUA'
+    | 'GREEN'
+    | 'BLUE'
+    | 'YELLOW'
+    | 'PURPLE'
+    | 'LUMINOUS_VIVID_PINK'
+    | 'GOLD'
+    | 'ORANGE'
+    | 'RED'
+    | 'GREY'
+    | 'DARKER_GREY'
+    | 'NAVY'
+    | 'DARK_AQUA'
+    | 'DARK_GREEN'
+    | 'DARK_BLUE'
+    | 'DARK_PURPLE'
+    | 'DARK_VIVID_PINK'
+    | 'DARK_GOLD'
+    | 'DARK_ORANGE'
+    | 'DARK_RED'
+    | 'DARK_GREY'
+    | 'LIGHT_GREY'
+    | 'DARK_NAVY'
+    | 'RANDOM'
+    | [number, number, number]
+    | number
+    | string;
+
+  interface CrosspostedChannel {
+    channelID: Snowflake;
+    guildID: Snowflake;
+    type: keyof typeof ChannelType;
+    name: string;
+  }
+
+  interface DeconstructedSnowflake {
+    timestamp: number;
+    readonly date: Date;
+    workerID: number;
+    processID: number;
+    increment: number;
+    binary: string;
+  }
+
+  type DefaultMessageNotifications = 'ALL' | 'MENTIONS';
+
+  interface EmbedField {
+    name: string;
+    value: string;
+    inline: boolean;
+  }
+
+  interface EmbedFieldData {
+    name: StringResolvable;
+    value: StringResolvable;
+    inline?: boolean;
+  }
+
+  type EmojiIdentifierResolvable = string | EmojiResolvable;
+
+  type EmojiResolvable = Snowflake | GuildEmoji | ReactionEmoji;
+
+  interface ErrorEvent {
+    error: any;
+    message: string;
+    type: string;
+    target: WebSocket;
+  }
+
+  interface EscapeMarkdownOptions {
+    codeBlock?: boolean;
+    inlineCode?: boolean;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    spoiler?: boolean;
+    inlineCodeContent?: boolean;
+    codeBlockContent?: boolean;
+  }
+
+  type ExplicitContentFilterLevel = 'DISABLED' | 'MEMBERS_WITHOUT_ROLES' | 'ALL_MEMBERS';
+
+  interface Extendable {
+    GuildEmoji: typeof GuildEmoji;
+    DMChannel: typeof DMChannel;
+    TextChannel: typeof TextChannel;
+    VoiceChannel: typeof VoiceChannel;
+    CategoryChannel: typeof CategoryChannel;
+    NewsChannel: typeof NewsChannel;
+    StoreChannel: typeof StoreChannel;
+    GuildMember: typeof GuildMember;
+    Guild: typeof Guild;
+    Message: typeof Message;
+    MessageReaction: typeof MessageReaction;
+    Presence: typeof Presence;
+    VoiceState: typeof VoiceState;
+    Role: typeof Role;
+    User: typeof User;
+  }
+
+  interface FetchMemberOptions {
+    user: UserResolvable;
+    cache?: boolean;
+  }
+
+  interface FetchMembersOptions {
+    user?: UserResolvable | UserResolvable[];
+    query?: string;
+    limit?: number;
+    withPresences?: boolean;
+  }
+
+  interface FileOptions {
+    attachment: BufferResolvable | Stream;
+    name?: string;
+  }
+
+  type GuildAuditLogsAction = keyof GuildAuditLogsActions;
+
+  interface GuildAuditLogsActions {
+    ALL?: null;
+    GUILD_UPDATE?: number;
+    CHANNEL_CREATE?: number;
+    CHANNEL_UPDATE?: number;
+    CHANNEL_DELETE?: number;
+    CHANNEL_OVERWRITE_CREATE?: number;
+    CHANNEL_OVERWRITE_UPDATE?: number;
+    CHANNEL_OVERWRITE_DELETE?: number;
+    MEMBER_KICK?: number;
+    MEMBER_PRUNE?: number;
+    MEMBER_BAN_ADD?: number;
+    MEMBER_BAN_REMOVE?: number;
+    MEMBER_UPDATE?: number;
+    MEMBER_ROLE_UPDATE?: number;
+    MEMBER_MOVE?: number;
+    MEMBER_DISCONNECT?: number;
+    BOT_ADD?: number;
+    ROLE_CREATE?: number;
+    ROLE_UPDATE?: number;
+    ROLE_DELETE?: number;
+    INVITE_CREATE?: number;
+    INVITE_UPDATE?: number;
+    INVITE_DELETE?: number;
+    WEBHOOK_CREATE?: number;
+    WEBHOOK_UPDATE?: number;
+    WEBHOOK_DELETE?: number;
+    EMOJI_CREATE?: number;
+    EMOJI_UPDATE?: number;
+    EMOJI_DELETE?: number;
+    MESSAGE_DELETE?: number;
+    MESSAGE_BULK_DELETE?: number;
+    MESSAGE_PIN?: number;
+    MESSAGE_UNPIN?: number;
+    INTEGRATION_CREATE?: number;
+    INTEGRATION_UPDATE?: number;
+    INTEGRATION_DELETE?: number;
+  }
+
+  type GuildAuditLogsActionType = 'CREATE' | 'DELETE' | 'UPDATE' | 'ALL';
+
+  interface GuildAuditLogsFetchOptions {
+    before?: Snowflake | GuildAuditLogsEntry;
+    limit?: number;
+    user?: UserResolvable;
+    type?: GuildAuditLogsAction | number;
+  }
+
+  type GuildAuditLogsTarget = keyof GuildAuditLogsTargets;
+
+  interface GuildAuditLogsTargets {
+    ALL?: string;
+    GUILD?: string;
+    CHANNEL?: string;
+    USER?: string;
+    ROLE?: string;
+    INVITE?: string;
+    WEBHOOK?: string;
+    EMOJI?: string;
+    MESSAGE?: string;
+    INTEGRATION?: string;
+    UNKNOWN?: string;
+  }
+
+  type GuildChannelResolvable = Snowflake | GuildChannel;
+
+  interface GuildCreateChannelOptions {
+    permissionOverwrites?: OverwriteResolvable[] | Collection<Snowflake, OverwriteResolvable>;
+    topic?: string;
+    type?: Exclude<keyof typeof ChannelType, 'dm' | 'group' | 'unknown'>;
+    nsfw?: boolean;
+    parent?: ChannelResolvable;
+    bitrate?: number;
+    userLimit?: number;
+    rateLimitPerUser?: number;
+    position?: number;
+    reason?: string;
+  }
+
+  interface GuildChannelCloneOptions extends GuildCreateChannelOptions {
+    name?: string;
+  }
+
+  interface GuildEditData {
+    name?: string;
+    region?: string;
+    verificationLevel?: VerificationLevel;
+    explicitContentFilter?: ExplicitContentFilterLevel;
+    defaultMessageNotifications?: DefaultMessageNotifications | number;
+    afkChannel?: ChannelResolvable;
+    systemChannel?: ChannelResolvable;
+    systemChannelFlags?: SystemChannelFlagsResolvable;
+    afkTimeout?: number;
+    icon?: Base64Resolvable;
+    owner?: GuildMemberResolvable;
+    splash?: Base64Resolvable;
+    banner?: Base64Resolvable;
+  }
+
+  interface GuildEmbedData {
+    enabled: boolean;
+    channel: GuildChannelResolvable | null;
+  }
+
+  interface GuildEmojiCreateOptions {
+    roles?: Collection<Snowflake, Role> | RoleResolvable[];
+    reason?: string;
+  }
+
+  interface GuildEmojiEditData {
+    name?: string;
+    roles?: Collection<Snowflake, Role> | RoleResolvable[];
+  }
+
+  type GuildFeatures =
+    | 'ANIMATED_ICON'
+    | 'BANNER'
+    | 'COMMERCE'
+    | 'DISCOVERABLE'
+    | 'FEATURABLE'
+    | 'INVITE_SPLASH'
+    | 'PUBLIC'
+    | 'NEWS'
+    | 'PARTNERED'
+    | 'VANITY_URL'
+    | 'VERIFIED'
+    | 'VIP_REGIONS';
+
+  interface GuildMemberEditData {
+    nick?: string;
+    roles?: Collection<Snowflake, Role> | RoleResolvable[];
+    mute?: boolean;
+    deaf?: boolean;
+    channel?: ChannelResolvable | null;
+  }
+
+  type GuildMemberResolvable = GuildMember | UserResolvable;
+
+  type GuildResolvable = Guild | GuildChannel | GuildMember | GuildEmoji | Invite | Role | Snowflake;
+
+  interface GuildPruneMembersOptions {
+    count?: boolean;
+    days?: number;
+    dry?: boolean;
+    reason?: string;
+  }
+
+  interface HTTPOptions {
+    api?: string;
+    version?: number;
+    host?: string;
+    cdn?: string;
+    invite?: string;
+  }
+
+  type ImageExt = 'webp' | 'png' | 'jpg' | 'gif';
+
+  type ImageSize = 16 | 32 | 64 | 128 | 256 | 512 | 1024 | 2048;
+
+  interface ImageURLOptions {
+    format?: ImageExt;
+    size?: ImageSize;
+  }
+
+  interface IntegrationData {
+    id: string;
+    type: string;
+  }
+
+  interface IntegrationEditData {
+    expireBehavior?: number;
+    expireGracePeriod?: number;
+  }
+
+  interface IntegrationAccount {
+    id: string;
+    name: string;
+  }
+
+  interface InviteOptions {
+    temporary?: boolean;
+    maxAge?: number;
+    maxUses?: number;
+    unique?: boolean;
+    reason?: string;
+  }
+
+  type InviteResolvable = string;
+
+  type MembershipStates = 'INVITED' | 'ACCEPTED';
+
+  type MessageAdditions = MessageEmbed | MessageAttachment | (MessageEmbed | MessageAttachment)[];
+
+  interface MessageActivity {
+    partyID: string;
+    type: number;
+  }
+
+  interface MessageCollectorOptions extends CollectorOptions {
+    max?: number;
+    maxProcessed?: number;
+  }
+
+  interface MessageEditOptions {
+    content?: string;
+    embed?: MessageEmbedOptions | null;
+    code?: string | boolean;
+    flags?: BitFieldResolvable<MessageFlagsString>;
+  }
+
+  interface MessageEmbedAuthor {
+    name?: string;
+    url?: string;
+    iconURL?: string;
+    proxyIconURL?: string;
+  }
+
+  interface MessageEmbedFooter {
+    text?: string;
+    iconURL?: string;
+    proxyIconURL?: string;
+  }
+
+  interface MessageEmbedImage {
+    url: string;
+    proxyURL?: string;
+    height?: number;
+    width?: number;
+  }
+
+  interface MessageEmbedOptions {
+    title?: string;
+    description?: string;
+    url?: string;
+    timestamp?: Date | number;
+    color?: ColorResolvable;
+    fields?: EmbedFieldData[];
+    files?: (MessageAttachment | string | FileOptions)[];
+    author?: Partial<MessageEmbedAuthor> & { icon_url?: string; proxy_icon_url?: string };
+    thumbnail?: Partial<MessageEmbedThumbnail> & { proxy_url?: string };
+    image?: Partial<MessageEmbedImage> & { proxy_url?: string };
+    video?: Partial<MessageEmbedVideo> & { proxy_url?: string };
+    footer?: Partial<MessageEmbedFooter> & { icon_url?: string; proxy_icon_url?: string };
+  }
+
+  interface MessageEmbedProvider {
+    name: string;
+    url: string;
+  }
+
+  interface MessageEmbedThumbnail {
+    url: string;
+    proxyURL?: string;
+    height?: number;
+    width?: number;
+  }
+
+  interface MessageEmbedVideo {
+    url?: string;
+    proxyURL?: string;
+    height?: number;
+    width?: number;
+  }
+
+  interface MessageEvent {
+    data: WebSocket.Data;
+    type: string;
+    target: WebSocket;
+  }
+
+  type MessageFlagsString = 'CROSSPOSTED' | 'IS_CROSSPOST' | 'SUPPRESS_EMBEDS' | 'SOURCE_MESSAGE_DELETED' | 'URGENT';
+
+  interface MessageOptions {
+    tts?: boolean;
+    nonce?: string;
+    content?: string;
+    embed?: MessageEmbed | MessageEmbedOptions;
+    disableMentions?: 'none' | 'all' | 'everyone';
+    files?: (FileOptions | BufferResolvable | Stream | MessageAttachment)[];
+    code?: string | boolean;
+    split?: boolean | SplitOptions;
+    reply?: UserResolvable;
+    replyPrefixer?: ReplyPrefixer;
+  }
+
+  type MessageReactionResolvable = MessageReaction | Snowflake;
+
+  interface MessageReference {
+    channelID: string;
+    guildID: string;
+    messageID: string | null;
+  }
+
+  type MessageResolvable = Message | Snowflake;
+
+  type MessageTarget = TextChannel | DMChannel | User | GuildMember | Webhook | WebhookClient;
+
+  type MessageType =
+    | 'DEFAULT'
+    | 'RECIPIENT_ADD'
+    | 'RECIPIENT_REMOVE'
+    | 'CALL'
+    | 'CHANNEL_NAME_CHANGE'
+    | 'CHANNEL_ICON_CHANGE'
+    | 'PINS_ADD'
+    | 'GUILD_MEMBER_JOIN'
+    | 'USER_PREMIUM_GUILD_SUBSCRIPTION'
+    | 'USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_1'
+    | 'USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_2'
+    | 'USER_PREMIUM_GUILD_SUBSCRIPTION_TIER_3'
+    | 'CHANNEL_FOLLOW_ADD'
+    | 'GUILD_DISCOVERY_DISQUALIFIED'
+    | 'GUILD_DISCOVERY_REQUALIFIED';
+
+  interface OverwriteData {
+    allow?: PermissionResolvable;
+    deny?: PermissionResolvable;
+    id: GuildMemberResolvable | RoleResolvable;
+    type?: OverwriteType;
+  }
+
+  type OverwriteResolvable = PermissionOverwrites | OverwriteData;
+
+  type OverwriteType = 'member' | 'role';
+
+  interface PermissionFlags extends Record<PermissionString, number> {}
+
+  interface PermissionObject extends Record<PermissionString, boolean> {}
+
+  interface PermissionOverwriteOption extends Partial<Record<PermissionString, boolean | null>> {}
+
+  type PermissionResolvable = BitFieldResolvable<PermissionString>;
+
+  type PermissionString =
+    | 'CREATE_INSTANT_INVITE'
+    | 'KICK_MEMBERS'
+    | 'BAN_MEMBERS'
+    | 'ADMINISTRATOR'
+    | 'MANAGE_CHANNELS'
+    | 'MANAGE_GUILD'
+    | 'ADD_REACTIONS'
+    | 'VIEW_AUDIT_LOG'
+    | 'PRIORITY_SPEAKER'
+    | 'STREAM'
+    | 'VIEW_CHANNEL'
+    | 'SEND_MESSAGES'
+    | 'SEND_TTS_MESSAGES'
+    | 'MANAGE_MESSAGES'
+    | 'EMBED_LINKS'
+    | 'ATTACH_FILES'
+    | 'READ_MESSAGE_HISTORY'
+    | 'MENTION_EVERYONE'
+    | 'USE_EXTERNAL_EMOJIS'
+    | 'CONNECT'
+    | 'SPEAK'
+    | 'MUTE_MEMBERS'
+    | 'DEAFEN_MEMBERS'
+    | 'MOVE_MEMBERS'
+    | 'USE_VAD'
+    | 'CHANGE_NICKNAME'
+    | 'MANAGE_NICKNAMES'
+    | 'MANAGE_ROLES'
+    | 'MANAGE_WEBHOOKS'
+    | 'MANAGE_EMOJIS';
+
+  interface RecursiveArray<T> extends Array<T | RecursiveArray<T>> {}
+
+  interface PermissionOverwriteOptions {
+    allow: PermissionResolvable;
+    deny: PermissionResolvable;
+    id: UserResolvable | RoleResolvable;
+  }
+
+  type PremiumTier = number;
+
+  interface PresenceData {
+    status?: PresenceStatusData;
+    afk?: boolean;
+    activity?: {
+      name?: string;
+      type?: ActivityType | number;
+      url?: string;
+    };
+    shardID?: number | number[];
+  }
+
+  type PresenceResolvable = Presence | UserResolvable | Snowflake;
+
+  type Partialize<T> = {
+    id: string;
+    partial: true;
+    fetch(): Promise<T>;
+  } & {
+    [K in keyof Omit<T, 'id' | 'partial'>]: T[K] | null;
+  };
+
+  interface PartialChannel extends Partialize<Channel> {}
+
+  interface PartialChannelData {
+    id?: number;
+    name: string;
+    topic?: string;
+    type?: ChannelType;
+    parentID?: number;
+    permissionOverwrites?: {
+      id: number | Snowflake;
+      type?: OverwriteType;
+      allow?: PermissionResolvable;
+      deny?: PermissionResolvable;
+    }[];
+  }
+
+  interface PartialGuildMember extends Partialize<GuildMember> {}
+  interface PartialMessage extends Partialize<Message> {}
+
+  interface PartialRoleData extends RoleData {
+    id?: number;
+  }
+
+  type PartialTypes = 'USER' | 'CHANNEL' | 'GUILD_MEMBER' | 'MESSAGE' | 'REACTION';
+
+  interface PartialUser extends Partialize<User> {}
+
+  type PresenceStatus = ClientPresenceStatus | 'offline';
+
+  type PresenceStatusData = ClientPresenceStatus | 'invisible';
+
+  interface RateLimitData {
+    timeout: number;
+    limit: number;
+    timeDifference: number;
+    method: string;
+    path: string;
+    route: string;
+  }
+
+  interface RawOverwriteData {
+    id: Snowflake;
+    allow: number;
+    deny: number;
+    type: OverwriteType;
+  }
+
+  interface ReactionCollectorOptions extends CollectorOptions {
+    max?: number;
+    maxEmojis?: number;
+    maxUsers?: number;
+  }
+
+  type ReplyPrefixer = (user: UserResolvable) => string;
+
+  interface ResolvedOverwriteOptions {
+    allow: Permissions;
+    deny: Permissions;
+  }
+
+  interface RoleData {
+    name?: string;
+    color?: ColorResolvable;
+    hoist?: boolean;
+    position?: number;
+    permissions?: PermissionResolvable;
+    mentionable?: boolean;
+  }
+
+  interface RolePosition {
+    role: RoleResolvable;
+    position: number;
+  }
+
+  type RoleResolvable = Role | string;
+
+  type ShardingManagerMode = 'process' | 'worker';
+
+  type Snowflake = string;
+
+  interface SplitOptions {
+    maxLength?: number;
+    char?: string;
+    prepend?: string;
+    append?: string;
+  }
+
+  type Status = number;
+
+  interface StreamOptions {
+    type?: StreamType;
+    seek?: number;
+    volume?: number | boolean;
+    plp?: number;
+    fec?: boolean;
+    bitrate?: number | 'auto';
+    highWaterMark?: number;
+  }
+
+  type SpeakingString = 'SPEAKING' | 'SOUNDSHARE' | 'PRIORITY_SPEAKING';
+
+  type StreamType = 'unknown' | 'converted' | 'opus' | 'ogg/opus' | 'webm/opus';
+
+  type StringResolvable = string | string[] | any;
+
+  type SystemChannelFlagsString = 'WELCOME_MESSAGE_DISABLED' | 'BOOST_MESSAGE_DISABLED';
+
+  type SystemChannelFlagsResolvable = BitFieldResolvable<SystemChannelFlagsString>;
+
+  type TargetUser = number;
+
+  type UserResolvable = User | Snowflake | Message | GuildMember;
+
+  type VerificationLevel = 'NONE' | 'LOW' | 'MEDIUM' | 'HIGH' | 'VERY_HIGH';
+
+  type VoiceStatus = number;
+
+  interface WebhookEditData {
+    name?: string;
+    avatar?: BufferResolvable;
+    channel?: ChannelResolvable;
+    reason?: string;
+  }
+
+  interface WebhookMessageOptions {
+    username?: string;
+    avatarURL?: string;
+    tts?: boolean;
+    nonce?: string;
+    embeds?: (MessageEmbed | object)[];
+    disableMentions?: 'none' | 'all' | 'everyone';
+    files?: (FileOptions | BufferResolvable | Stream | MessageAttachment)[];
+    code?: string | boolean;
+    split?: boolean | SplitOptions;
+  }
+
+  type WebhookTypes = 'Incoming' | 'Channel Follower';
+
+  interface WebSocketOptions {
+    large_threshold?: number;
+    compress?: boolean;
+  }
+
+  type WSEventType =
+    | 'READY'
+    | 'RESUMED'
+    | 'GUILD_CREATE'
+    | 'GUILD_DELETE'
+    | 'GUILD_UPDATE'
+    | 'INVITE_CREATE'
+    | 'INVITE_DELETE'
+    | 'GUILD_MEMBER_ADD'
+    | 'GUILD_MEMBER_REMOVE'
+    | 'GUILD_MEMBER_UPDATE'
+    | 'GUILD_MEMBERS_CHUNK'
+    | 'GUILD_ROLE_CREATE'
+    | 'GUILD_ROLE_DELETE'
+    | 'GUILD_ROLE_UPDATE'
+    | 'GUILD_BAN_ADD'
+    | 'GUILD_BAN_REMOVE'
+    | 'GUILD_EMOJIS_UPDATE'
+    | 'GUILD_INTEGRATIONS_UPDATE'
+    | 'CHANNEL_CREATE'
+    | 'CHANNEL_DELETE'
+    | 'CHANNEL_UPDATE'
+    | 'CHANNEL_PINS_UPDATE'
+    | 'MESSAGE_CREATE'
+    | 'MESSAGE_DELETE'
+    | 'MESSAGE_UPDATE'
+    | 'MESSAGE_DELETE_BULK'
+    | 'MESSAGE_REACTION_ADD'
+    | 'MESSAGE_REACTION_REMOVE'
+    | 'MESSAGE_REACTION_REMOVE_ALL'
+    | 'MESSAGE_REACTION_REMOVE_EMOJI'
+    | 'USER_UPDATE'
+    | 'PRESENCE_UPDATE'
+    | 'TYPING_START'
+    | 'VOICE_STATE_UPDATE'
+    | 'VOICE_SERVER_UPDATE'
+    | 'WEBHOOKS_UPDATE';
+
+  //#endregion
 }
diff --git a/webpack.config.js b/webpack.config.js
index c7416852..2fb29975 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -1,6 +1,8 @@
+'use strict';
+
 const path = require('path');
-const webpack = require('webpack');
 const TerserJSPlugin = require('terser-webpack-plugin');
+const webpack = require('webpack');
 const version = require('./package.json').version;
 
 const prod = process.env.NODE_ENV === 'production';
@@ -47,16 +49,15 @@ module.exports = {
   optimization: {
     minimizer: [
       new TerserJSPlugin({
+        cache: false,
         terserOptions: {
           mangle: { keep_classnames: true },
           compress: { keep_classnames: true },
+          keep_classnames: true,
           output: { comments: false },
         },
-        parallel: true,
       }),
     ],
   },
-  plugins: [
-    new webpack.optimize.ModuleConcatenationPlugin(),
-  ],
+  plugins: [new webpack.optimize.ModuleConcatenationPlugin()],
 };