chore(Release): version upgrade

Co-authored-by: Noel <buechler.noel@outlook.com>

.eslintrc.json

@@ -1,44 +1,66 @@
 {
-  "extends": "eslint:recommended",
+  "extends": ["eslint:recommended", "plugin:prettier/recommended"],
+  "plugins": ["import"],
   "parserOptions": {
-    "ecmaVersion": 6
+    "ecmaVersion": 2020
   },
   "env": {
-    "es6": true,
+    "es2020": true,
     "node": 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",
+        "arrowParens": "avoid"
+      }
+    ],
+    "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"],
@@ -77,6 +99,7 @@
     "no-undef-init": "error",
 
     "callback-return": "error",
+    "getter-return": "off",
     "handle-callback-err": "error",
     "no-mixed-requires": "error",
     "no-new-require": "error",
@@ -95,7 +118,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",
@@ -107,7 +129,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",
@@ -117,14 +138,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", "never"],
+    "space-before-function-paren": [
+      "error",
+      {
+        "anonymous": "never",
+        "named": "never",
+        "asyncArrow": "always"
+      }
+    ],
     "space-in-parens": "error",
     "space-infix-ops": "error",
     "space-unary-ops": "error",

.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`
+2. Run `npm ci`
+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)
+6. [Submit a pull request](https://github.com/discordjs/discord.js/compare) (Make sure you follow the [conventional commit format](https://github.com/discordjs/discord.js-next/blob/master/.github/COMMIT_CONVENTION.md))

.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

.github/ISSUE_TEMPLATE.md

@@ -1,26 +0,0 @@
-<!--
-If you need help with discord.js installation or usage, please go to the discord.js Discord server instead:
-  https://discord.gg/bRCvFy9
-This issue tracker is only for bug reports and enhancement suggestions. 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
-
-```
-
-**Further details:**
-
-- discord.js version:
-- node.js version:
-- Operating system:
-- Priority this issue should have – please be realistic and elaborate if possible:
-
-<!--
-Ideally you would also test whether the issue occurs on the latest master branch commit.
-If you have, please check the following box and insert the hash of the commit you tested:
--->
-- [ ] I have also tested the issue on latest master, commit hash:

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,45 @@
+---
+
+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
+This issue tracker is only for bug reports and enhancement suggestions.
+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:
+
+**Relevant client options:**
+
+- partials: none
+- gateway intents: none
+- other: none
+
+<!--
+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 have also tested the issue on latest master, commit hash:

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Discord server
+    url: https://discord.gg/bRCvFy9
+    about: Have questions or need support? Please go to the Discord server, as issues that are just support-related will be closed and redirected there.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,26 @@
+---
+
+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
+This issue tracker is only for bug reports and enhancement suggestions.
+You likely won't receive any basic help here.
+-->
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Eg. I'm always frustrated when [...]
+
+**Describe the ideal solution**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,7 +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.

.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.

.github/tsc.json

@@ -0,0 +1,18 @@
+{
+  "problemMatcher": [
+      {
+          "owner": "tsc",
+          "pattern": [
+              {
+                  "regexp": "^(?:\\s+\\d+\\>)?([^\\s].*)\\((\\d+),(\\d+)\\)\\s*:\\s+(error|warning|info)\\s+(\\w{1,2}\\d+)\\s*:\\s*(.*)$",
+                  "file": 1,
+                  "line": 2,
+                  "column": 3,
+                  "severity": 4,
+                  "code": 5,
+                  "message": 6
+              }
+          ]
+      }
+  ]
+}

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,27 @@
+name: "CodeQL"
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 */12 * * 4'
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 2
+
+    - run: git checkout HEAD^2
+      if: ${{ github.event_name == 'pull_request' }}
+
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: javascript
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/deploy.yml

@@ -0,0 +1,49 @@
+name: Deployment
+on:
+  push:
+    branches:
+      - '*'
+      - '!webpack'
+      - '!docs'
+    tags:
+      - '*'
+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 ci
+
+      - 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 ci
+
+      - name: Build and deploy webpack
+        uses: discordjs/action-webpack@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test-cron.yml

@@ -0,0 +1,79 @@
+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 ci
+
+      - 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 ci
+
+      - name: Run TSLint
+        run: npm run lint:typings
+
+  typescript:
+    name: TypeScript
+    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 ci
+
+      - name: Register Problem Matcher
+        run: echo "##[add-matcher].github/tsc.json"
+
+      - name: Run TypeScript compiler
+        run: npm run test:typescript
+
+  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 ci
+
+      - name: Test documentation
+        run: npm run docs:test

.github/workflows/test.yml

@@ -0,0 +1,77 @@
+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 ci
+
+      - 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 ci
+
+      - name: Run TSLint
+        run: npm run lint:typings
+
+  typescript:
+    name: TypeScript
+    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 ci
+
+      - name: Register Problem Matcher
+        run: echo "##[add-matcher].github/tsc.json"
+
+      - name: Run TypeScript compiler
+        run: npm run test:typescript
+
+  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 ci
+
+      - name: Test documentation
+        run: npm run docs:test

.gitignore

@@ -17,5 +17,7 @@ deploy/deploy_key.pub
 # Miscellaneous
 .tmp/
 .vscode/
+.idea/
 docs/docs.json
+typings/index.js
 webpack/

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "typings"]
-	path = typings
-	url = https://github.com/discordjs/discord.js-typings

.npmignore

@@ -14,8 +14,6 @@ deploy/
 .vscode/
 docs/
 
-webpack/
-
 # NPM ignore
 .eslintrc.json
 .gitattributes
@@ -24,3 +22,5 @@ webpack/
 webpack.config.js
 .github/
 test/
+tsconfig.json
+tslint.json

.npmrc

@@ -1 +0,0 @@
-package-json=false

.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": {},
@@ -15,7 +11,7 @@
       "strong": true
     },
     "webpack": {
-      "configPath": "./webpack.config.js",
+      "configPath": "./webpack.config.js"
     }
   }
 }

.travis.yml

@@ -1,20 +0,0 @@
-language: node_js
-node_js:
-  - "6"
-  - "7"
-cache:
-  directories:
-    - node_modules
-install: npm install
-script: bash ./deploy/test.sh
-jobs:
-  include:
-    - stage: build
-      node_js: "6"
-      script: bash ./deploy/deploy.sh
-env:
-  global:
-    - ENCRYPTION_LABEL: "af862fa96d3e"
-    - COMMIT_AUTHOR_EMAIL: "amishshah.2k@gmail.com"
-dist: trusty
-sudo: false

LICENSE

@@ -175,7 +175,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2017 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.

README.md

@@ -5,20 +5,34 @@
   </p>
   <br />
   <p>
-    <a href="https://discord.gg/bRCvFy9"><img src="https://discordapp.com/api/guilds/222078108977594368/embed.png" alt="Discord server" /></a>
+    <a href="https://discord.gg/bRCvFy9"><img src="https://img.shields.io/discord/222078108977594368?color=7289da&logo=discord&logoColor=white" 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>
   <p>
-    <a href="https://nodei.co/npm/discord.js/"><img src="https://nodei.co/npm/discord.js.png?downloads=true&stars=true" alt="NPM info" /></a>
+    <a href="https://nodei.co/npm/discord.js/"><img src="https://nodei.co/npm/discord.js.png?downloads=true&stars=true" alt="npm installnfo" /></a>
   </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://discord.com/developers/docs/intro).
 
 - Object-oriented
 - Predictable abstractions
@@ -26,27 +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 6.0.0 or newer is required.**  
+
+**Node.js 12.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 ([@discordjs/opus](https://www.npmjs.com/package/@discordjs/opus)): `npm install discord.js @discordjs/opus`  
 With voice support ([opusscript](https://www.npmjs.com/package/opusscript)): `npm install 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
-- [bufferutil](https://www.npmjs.com/package/bufferutil) to greatly speed up the WebSocket when *not* using uws (`npm install bufferutil`)
-- [erlpack](https://github.com/hammerandchisel/erlpack) for significantly faster WebSocket data (de)serialisation (`npm install hammerandchisel/erlpack`)
+
+- [zlib-sync](https://www.npmjs.com/package/zlib-sync) for WebSocket data compression and inflation (`npm install zlib-sync`)
+- [erlpack](https://github.com/discord/erlpack) for significantly faster WebSocket data (de)serialisation (`npm install discord/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/uws) for a much faster WebSocket connection (`npm install uws`)
+  - [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();
@@ -65,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).

browser.js

@@ -1,9 +0,0 @@
-const browser = typeof window !== 'undefined';
-const webpack = !!process.env.__DISCORD_WEBPACK__;
-
-const Discord = require('./');
-
-module.exports = Discord;
-if (browser && webpack) window.Discord = Discord; // eslint-disable-line no-undef
-// eslint-disable-next-line no-console
-else if (!browser) console.warn('Warning: Attempting to use browser version of Discord.js in a non-browser environment!');

deploy/deploy.sh

@@ -1,90 +0,0 @@
-#!/bin/bash
-# Adapted from https://gist.github.com/domenic/ec8b0fc8ab45f39403dd.
-
-set -e
-
-function build {
-  npm run docs
-  VERSIONED=false npm run webpack
-}
-
-# For revert branches, do nothing
-if [[ "$TRAVIS_BRANCH" == revert-* ]]; then
-  echo -e "\e[36m\e[1mBuild triggered for reversion branch \"${TRAVIS_BRANCH}\" - doing nothing."
-  exit 0
-fi
-
-# For PRs, do nothing
-if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then
-  echo -e "\e[36m\e[1mBuild triggered for PR #${TRAVIS_PULL_REQUEST} to branch \"${TRAVIS_BRANCH}\" - doing nothing."
-  exit 0
-fi
-
-# Figure out the source of the build
-if [ -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
-
-# For Node != 6, do nothing
-if [ "$TRAVIS_NODE_VERSION" != "6" ]; then
-  echo -e "\e[36m\e[1mBuild triggered with Node v${TRAVIS_NODE_VERSION} - doing nothing."
-  exit 0
-fi
-
-build
-
-# 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 deploy/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.js out/discord.$SOURCE.js
-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

deploy/test.sh

@@ -1,34 +0,0 @@
-#!/bin/bash
-
-set -e
-
-function tests {
-  npm run lint
-  npm run docs:test
-  exit 0
-}
-
-# 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} to branch \"${TRAVIS_BRANCH}\" - only running tests."
-  tests
-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
-
-# For Node != 6
-if [ "$TRAVIS_NODE_VERSION" != "6" ]; then
-  echo -e "\e[36m\e[1mTest triggered with Node v${TRAVIS_NODE_VERSION} - only running tests."
-  tests
-fi

docs/examples/attachments.md

@@ -0,0 +1,163 @@
+# Sending Attachments
+
+In here you'll see a few examples showing how you can send an attachment using discord.js.
+
+## Sending an attachment using a URL
+
+There are a few ways you can do this, but we'll show you the easiest.
+
+The following examples use [MessageAttachment](/#/docs/main/master/class/MessageAttachment).
+
+```js
+// Extract the required classes from the discord.js module
+const { Client, MessageAttachment } = require('discord.js');
+
+// Create an instance of a Discord client
+const client = new Client();
+
+/**
+ * The ready event is vital, it means that only _after_ this will your bot start reacting to information
+ * received from Discord
+ */
+client.on('ready', () => {
+  console.log('I am 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);
+  }
+});
+
+// Log our bot in using the token from https://discord.com/developers/applications
+client.login('your token here');
+```
+
+And here is the result:
+
+![Image showing the result](/static/attachment-example1.png)
+
+But what if you want to send an attachment with a message content? Fear not, for it is easy to do that too! We'll recommend reading [the TextChannel's "send" function documentation](/#/docs/main/master/class/TextChannel?scrollTo=send) to see what other options are available.
+
+```js
+// Extract the required classes from the discord.js module
+const { Client, MessageAttachment } = require('discord.js');
+
+// Create an instance of a Discord client
+const client = new Client();
+
+/**
+ * The ready event is vital, it means that only _after_ this will your bot start reacting to information
+ * received from Discord
+ */
+client.on('ready', () => {
+  console.log('I am 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);
+  }
+});
+
+// Log our bot in using the token from https://discord.com/developers/applications
+client.login('your token here');
+```
+
+And here's the result of this one:
+
+![Image showing the result](/static/attachment-example2.png)
+
+## Sending a local file or buffer
+
+Sending a local file isn't hard either! We'll be using [MessageAttachment](/#/docs/main/master/class/MessageAttachment) for these examples too.
+
+```js
+// Extract the required classes from the discord.js module
+const { Client, MessageAttachment } = require('discord.js');
+
+// Create an instance of a Discord client
+const client = new Client();
+
+/**
+ * The ready event is vital, it means that only _after_ this will your bot start reacting to information
+ * received from Discord
+ */
+client.on('ready', () => {
+  console.log('I am 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);
+  }
+});
+
+// Log our bot in using the token from https://discord.com/developers/applications
+client.login('your token here');
+```
+
+The results are the same as the URL examples:
+
+![Image showing result](/static/attachment-example2.png)
+
+But what if you have a buffer from an image? Or a text document? Well, it's the same as sending a local file or a URL!
+
+In the following example, we'll be getting the buffer from a `memes.txt` file, and send it in the message channel.
+You can use any buffer you want, and send it. Just make sure to overwrite the filename if it isn't an image!
+
+```js
+// Extract the required classes from the discord.js module
+const { Client, MessageAttachment } = require('discord.js');
+
+// Import the native fs module
+const fs = require('fs');
+
+// Create an instance of a Discord client
+const client = new Client();
+
+/**
+ * The ready event is vital, it means that only _after_ this will your bot start reacting to information
+ * received from Discord
+ */
+client.on('ready', () => {
+  console.log('I am 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');
+
+    /**
+     * 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://discord.com/developers/applications
+client.login('your token here');
+```
+
+And of course, the results are:
+
+![Attachment File example 3](/static/attachment-example3.png)

docs/examples/avatars.js

@@ -1,6 +1,8 @@
-/*
-  Send a user a link to their avatar
-*/
+'use strict';
+
+/**
+ * Send a user a link to their avatar
+ */
 
 // Import the discord.js module
 const Discord = require('discord.js');
@@ -8,11 +10,10 @@ const Discord = require('discord.js');
 // Create an instance of a Discord client
 const client = new Discord.Client();
 
-// The token of your bot - https://discordapp.com/developers/applications/me
-const token = 'your bot token here';
-
-// The ready event is vital, it means that your bot will only start reacting to information
-// from Discord _after_ ready is emitted
+/**
+ * The ready event is vital, it means that only _after_ this will your bot start reacting to information
+ * received from Discord
+ */
 client.on('ready', () => {
   console.log('I am ready!');
 });
@@ -22,9 +23,9 @@ client.on('message', message => {
   // If the message is "what is my avatar"
   if (message.content === 'what is my avatar') {
     // Send the user's avatar URL
-    message.reply(message.author.avatarURL);
+    message.reply(message.author.displayAvatarURL());
   }
 });
 
-// Log our bot in
-client.login(token);
+// Log our bot in using the token from https://discord.com/developers/applications
+client.login('your token here');

docs/examples/embed.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/**
+ * An example of how you can send embeds
+ */
+
+// Extract the required classes from the discord.js module
+const { Client, MessageEmbed } = require('discord.js');
+
+// Create an instance of a Discord client
+const client = new Client();
+
+/**
+ * The ready event is vital, it means that only _after_ this will your bot start reacting to information
+ * received from Discord
+ */
+client.on('ready', () => {
+  console.log('I am ready!');
+});
+
+client.on('message', message => {
+  // If the message is "how to embed"
+  if (message.content === 'how to embed') {
+    // We can create embeds using the MessageEmbed constructor
+    // Read more about all that you can do with the constructor
+    // over at https://discord.js.org/#/docs/main/master/class/MessageEmbed
+    const embed = new MessageEmbed()
+      // Set the title of the field
+      .setTitle('A slick little embed')
+      // Set the color of the embed
+      .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
+    message.channel.send(embed);
+  }
+});
+
+// Log our bot in using the token from https://discord.com/developers/applications
+client.login('your token here');

docs/examples/greeting.js

@@ -1,6 +1,8 @@
-/*
-  A bot that welcomes new guild members when they join
-*/
+'use strict';
+
+/**
+ * A bot that welcomes new guild members when they join
+ */
 
 // Import the discord.js module
 const Discord = require('discord.js');
@@ -8,11 +10,10 @@ const Discord = require('discord.js');
 // Create an instance of a Discord client
 const client = new Discord.Client();
 
-// The token of your bot - https://discordapp.com/developers/applications/me
-const token = 'your bot token here';
-
-// The ready event is vital, it means that your bot will only start reacting to information
-// from Discord _after_ ready is emitted
+/**
+ * The ready event is vital, it means that only _after_ this will your bot start reacting to information
+ * received from Discord
+ */
 client.on('ready', () => {
   console.log('I am ready!');
 });
@@ -20,12 +21,12 @@ 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
   channel.send(`Welcome to the server, ${member}`);
 });
 
-// Log our bot in
-client.login(token);
+// Log our bot in using the token from https://discord.com/developers/applications
+client.login('your token here');

docs/examples/moderation.md

@@ -0,0 +1,151 @@
+# Moderation
+
+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.
+
+```js
+// Import the discord.js module
+const Discord = require('discord.js');
+
+// Create an instance of a Discord client
+const client = new Discord.Client();
+
+/**
+ * The ready event is vital, it means that only _after_ this will your bot start reacting to information
+ * received from Discord
+ */
+client.on('ready', () => {
+  console.log('I am ready!');
+});
+
+client.on('message', message => {
+  // Ignore messages that aren't from a guild
+  if (!message.guild) return;
+
+  // If the message content starts with "!kick"
+  if (message.content.startsWith('!kick')) {
+    // Assuming we mention someone in the message, this will return the user
+    // Read more about mentions over at https://discord.js.org/#/docs/main/master/class/MessageMentions
+    const user = message.mentions.users.first();
+    // If we have a user mentioned
+    if (user) {
+      // Now we get the member from the user
+      const member = message.guild.member(user);
+      // If the member is in the guild
+      if (member) {
+        /**
+         * Kick the member
+         * 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);
+          });
+      } else {
+        // The mentioned user isn't in this guild
+        message.reply("That user isn't in this guild!");
+      }
+      // Otherwise, if no user was mentioned
+    } else {
+      message.reply("You didn't mention the user to kick!");
+    }
+  }
+});
+
+// Log our bot in using the token from https://discord.com/developers/applications
+client.login('your token here');
+```
+
+And the result is:
+
+![Image showing the result](/static/kick-example.png)
+
+## Banning a member
+
+Banning works the same way as kicking, but it has slightly more options that can be changed.
+
+```js
+// Import the discord.js module
+const Discord = require('discord.js');
+
+// Create an instance of a Discord client
+const client = new Discord.Client();
+
+/**
+ * The ready event is vital, it means that only _after_ this will your bot start reacting to information
+ * received from Discord
+ */
+client.on('ready', () => {
+  console.log('I am ready!');
+});
+
+client.on('message', message => {
+  // Ignore messages that aren't from a guild
+  if (!message.guild) return;
+
+  // if the message content starts with "!ban"
+  if (message.content.startsWith('!ban')) {
+    // Assuming we mention someone in the message, this will return the user
+    // Read more about mentions over at https://discord.js.org/#/docs/main/master/class/MessageMentions
+    const user = message.mentions.users.first();
+    // If we have a user mentioned
+    if (user) {
+      // Now we get the member from the user
+      const member = message.guild.member(user);
+      // If the member is in the guild
+      if (member) {
+        /**
+         * Ban the member
+         * Make sure you run this on a member, not a user!
+         * There are big differences between a user and a member
+         * 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);
+          });
+      } else {
+        // The mentioned 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!");
+    }
+  }
+});
+
+// Log our bot in using the token from https://discord.com/developers/applications
+client.login('your token here');
+```
+
+And the result is:
+
+![Image showing the result](/static/ban-example.png)

docs/examples/ping.js

@@ -1,6 +1,8 @@
-/*
-  A ping pong bot, whenever you send "ping", it replies "pong".
-*/
+'use strict';
+
+/**
+ * A ping pong bot, whenever you send "ping", it replies "pong".
+ */
 
 // Import the discord.js module
 const Discord = require('discord.js');
@@ -8,11 +10,10 @@ const Discord = require('discord.js');
 // Create an instance of a Discord client
 const client = new Discord.Client();
 
-// The token of your bot - https://discordapp.com/developers/applications/me
-const token = 'your bot token here';
-
-// The ready event is vital, it means that your bot will only start reacting to information
-// from Discord _after_ ready is emitted
+/**
+ * The ready event is vital, it means that only _after_ this will your bot start reacting to information
+ * received from Discord
+ */
 client.on('ready', () => {
   console.log('I am ready!');
 });
@@ -26,5 +27,5 @@ client.on('message', message => {
   }
 });
 
-// Log our bot in
-client.login(token);
+// Log our bot in using the token from https://discord.com/developers/applications
+client.login('your token here');

docs/examples/webhook.js

@@ -1,11 +1,18 @@
-/*
-  Send a message using a webhook
-*/
+'use strict';
+
+/**
+ * Send a message using a webhook
+ */
 
 // Import the discord.js module
 const Discord = require('discord.js');
-
-// Create a new webhook
+/*
+ * Create a new webhook
+ * The Webhooks ID and token can be found in the URL, when you request that URL, or in the response body.
+ * https://discord.com/api/webhooks/12345678910/T0kEn0fw3Bh00K
+ *                                  ^^^^^^^^^^  ^^^^^^^^^^^^ 
+ *                                  Webhook ID  Webhook Token
+ */
 const hook = new Discord.WebhookClient('webhook id', 'webhook token');
 
 // Send a message using the webhook

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 6.0.0 or newer.
+
+Update to Node.js 12.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 --save ffmpeg-binaries`
+
+- **npm:** `npm install ffmpeg-static`
 - **Ubuntu 16.04:** `sudo apt install ffmpeg`
 - **Ubuntu 14.04:** `sudo apt-get install libav-tools`
-- **Windows:** See the [FFMPEG section of AoDude's guide](https://github.com/bdistin/OhGodMusicBot/blob/master/README.md#download-ffmpeg).
+- **Windows:** `npm install ffmpeg-static` 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).

docs/general/updating.md

@@ -1,80 +1,93 @@
-# Version 11.3.0
-v11.3.0 backports many new features and bug fixes from the in-development v12.
-See [the changelog](https://github.com/discordjs/discord.js/releases/tag/11.3.0) for a full list of changes, including information about deprecations.
+# Version 12.0.0
 
-# Version 11.2.0
-v11.2.0 fixes a lot of bugs we encountered along the 11.1.0 release, as well as support for new features such as Message Attachments and UserGuildSettings.
-See [the changelog](https://github.com/discordjs/discord.js/releases/tag/11.2.0) for a full list of changes, including information about deprecations.
+v12.0.0 contains many new and improved features, optimisations, and bug fixes.
+See [the changelog](https://github.com/discordjs/discord.js/releases/tag/12.0.0) for a full list of changes.
+You can also visit [the guide](https://discordjs.guide/additional-info/changes-in-v12.html) for help with updating your v11 code to v12.
 
 # 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
@@ -89,6 +102,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
@@ -98,41 +112,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`
+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
@@ -145,19 +164,22 @@ 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.
+
+Version 9 eschews callbacks in favour of Promises. This means all code relying on callbacks must be changed.  
 For example, the following code:
 
 ```js
@@ -167,7 +189,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`);
 });
 ```

docs/general/welcome.md

@@ -1,15 +1,16 @@
 <div align="center">
   <br />
   <p>
-    <a href="https://discord.js.org"><img src="https://discord.js.org/static/logo.svg" width="546" alt="discord.js" /></a>
+    <a href="https://discord.js.org"><img src="/static/logo.svg" width="546" alt="discord.js" id="djs-logo" /></a>
   </p>
   <br />
   <p>
-    <a href="https://discord.gg/bRCvFy9"><img src="https://discordapp.com/api/guilds/222078108977594368/embed.png" alt="Discord server" /></a>
+    <a href="https://discord.gg/bRCvFy9"><img src="https://img.shields.io/discord/222078108977594368?color=7289da&logo=discord&logoColor=white" 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://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>
   <p>
     <a href="https://nodei.co/npm/discord.js/"><img src="https://nodei.co/npm/discord.js.png?downloads=true&stars=true" alt="NPM info" /></a>
@@ -17,15 +18,13 @@
 </div>
 
 # Welcome!
-Welcome to the discord.js v11.3 documentation.
-The v11.3 release contains backports of many features and bug fixes from the in-development v12, such as categories and animated emoji support.
 
-v12 is still very much a work-in-progress, as we're aiming to make it the best it can possibly be before releasing.
-If you are fond of living life on the bleeding-edge, check out the master branch.
+Welcome to the discord.js v12 documentation.
 
 ## 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://discord.com/developers/docs/intro).
 
 - Object-oriented
 - Predictable abstractions
@@ -33,27 +32,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 6.0.0 or newer is required.**  
+
+**Node.js 12.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 ([@discordjs/opus](https://www.npmjs.com/package/@discordjs/opus)): `npm install discord.js @discordjs/opus`  
 With voice support ([opusscript](https://www.npmjs.com/package/opusscript)): `npm install 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
-- [bufferutil](https://www.npmjs.com/package/bufferutil) to greatly speed up the WebSocket when *not* using uws (`npm install bufferutil`)
-- [erlpack](https://github.com/hammerandchisel/erlpack) for significantly faster WebSocket data (de)serialisation (`npm install hammerandchisel/erlpack`)
+
+- [zlib-sync](https://www.npmjs.com/package/zlib-sync) for WebSocket data compression and inflation (`npm install zlib-sync`)
+- [erlpack](https://github.com/discord/erlpack) for significantly faster WebSocket data (de)serialisation (`npm install discord/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/uws) for a much faster WebSocket connection (`npm install uws`)
+  - [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();
@@ -72,23 +76,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).

docs/index.yml

@@ -12,13 +12,21 @@
       path: voice.md
     - name: Web builds
       path: web.md
+    - name: Partials
+      path: partials.md
 - name: Examples
   files:
     - name: Ping
       path: ping.js
     - name: Avatars
       path: avatars.js
+    - name: Attachments
+      path: attachments.md
     - name: Server greeting
       path: greeting.js
+    - name: Message Embed
+      path: embed.js
+    - name: Moderation
+      path: moderation.md
     - name: Webhook
       path: webhook.js

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.

docs/topics/voice.md

@@ -1,16 +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 opusscript`
-  * `npm install node-opus`
-* a good network connection
+
+- 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.
 
@@ -20,19 +27,15 @@ const client = new Discord.Client();
 
 client.login('token here');
 
-client.on('message', message => {
+client.on('message', async message => {
   // Voice only works in guilds, if the message does not come from a guild,
   // we ignore it
   if (!message.guild) return;
 
   if (message.content === '/join') {
     // Only try to join the sender's voice channel if they are in one themselves
-    if (message.member.voiceChannel) {
-      message.member.voiceChannel.join()
-        .then(connection => { // Connection is an instance of VoiceConnection
-          message.reply('I have successfully connected to the channel!');
-        })
-        .catch(console.log);
+    if (message.member.voice.channel) {
+      const connection = await message.member.voice.channel.join();
     } else {
       message.reply('You need to join a voice channel first!');
     }
@@ -41,69 +44,97 @@ client.on('message', 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. The following example shows how to stream an mp3
-file:
+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:
 
-**Playing a file:**
 ```js
-// To play a file, we need to give an absolute path to it
-const dispatcher = connection.playFile('C:/Users/Discord/Desktop/myfile.mp3');
+const dispatcher = connection.play('/home/discord/audio.mp3');
 ```
 
-Your file doesn't have to be just an mp3; ffmpeg can convert videos and audios of many formats.
-
-The `dispatcher` variable is an instance of a `StreamDispatcher`, which manages streaming a specific resource to a voice
-channel. We can do many things with the dispatcher, such as finding out when the stream ends or changing the volume:
+The `dispatcher` in this case is a `StreamDispatcher` - here you can control the volume and playback of the stream:
 
 ```js
-dispatcher.on('end', () => {
-  // The song has finished
+dispatcher.pause();
+dispatcher.resume();
+
+dispatcher.setVolume(0.5); // half the volume
+
+dispatcher.on('finish', () => {
+  console.log('Finished playing!');
 });
 
-dispatcher.on('error', e => {
-  // Catch any errors that may arise
-  console.log(e);
+dispatcher.destroy(); // end the stream
+```
+
+We can also pass in options when we first play the stream:
+
+```js
+const dispatcher = connection.play('/home/discord/audio.mp3', {
+  volume: 0.5,
+});
+```
+
+### What can I play?
+
+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' }));
+
+// Files on the internet
+connection.play('http://www.sample-videos.com/audio/mp3/wave.mp3');
+
+// Local files
+connection.play('/home/discord/audio.mp3');
+```
+
+New to v12 is the ability to play OggOpus and WebmOpus streams with much better performance by skipping out Ffmpeg. Note this comes at the cost of no longer having volume control over the stream:
+
+```js
+connection.play(fs.createReadStream('./media.webm'), {
+  type: 'webm/opus',
 });
 
-dispatcher.setVolume(0.5); // Set the volume to 50%
-dispatcher.setVolume(1); // Set the volume back to 100%
-
-console.log(dispatcher.time); // The time in milliseconds that the stream dispatcher has been playing for
-
-dispatcher.pause(); // Pause the stream
-dispatcher.resume(); // Carry on playing
-
-dispatcher.end(); // End the dispatcher, emits 'end' event
+connection.play(fs.createReadStream('./media.ogg'), {
+  type: 'ogg/opus',
+});
 ```
 
-If you have an existing [ReadableStream](https://nodejs.org/api/stream.html#stream_readable_streams),
-this can also be used:
+Make sure to consult the documentation for a full list of what you can play - there's too much to cover here!
 
-**Playing a ReadableStream:**
-```js
-connection.playStream(myReadableStream);
+## Voice Broadcasts
 
-// If you don't want to use absolute paths, you can use
-// fs.createReadStream to circumvent it
-
-const fs = require('fs');
-const stream = fs.createReadStream('./test.mp3');
-connection.playStream(stream);
-```
-
-It's important to note that creating a readable stream to a file is less efficient than simply using `connection.playFile()`.
-
-**Playing anything else:**
-
-For anything else, such as a URL to a file, you can use `connection.playArbitraryInput()`. You should consult the [ffmpeg protocol documentation](https://ffmpeg.org/ffmpeg-protocols.html) to see what you can use this for.
+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
-// Play an mp3 from a URL
-connection.playArbitraryInput('http://mysite.com/sound.mp3');
+const broadcast = client.voice.createBroadcast();
+
+broadcast.on('subscribe', dispatcher => {
+  console.log('New broadcast subscriber!');
+});
+
+broadcast.on('unsubscribe', dispatcher => {
+  console.log('Channel unsubscribed from broadcast :(');
+});
 ```
 
-Again, playing a file from a URL like this is more performant than creating a ReadableStream to the file.
+`broadcast` is an instance of `VoiceBroadcast`, which has the same `play` method you are used to with regular VoiceConnections:
 
-## Advanced Topics
-soon:tm:
+```js
+const dispatcher = broadcast.play('./audio.mp3');
+
+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™

docs/topics/web.md

@@ -1,13 +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.
 
-## Usage
+## 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>
 ```
@@ -15,15 +34,10 @@ Include the file on the page just as you would any other JS library, like so:
 Rather than importing discord.js with `require('discord.js')`, the entire `Discord` object is available as a global (on the `window`) object.
 The usage of the API isn't any different from using it in Node.js.
 
-## 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 optional packages are usable, since they're native libraries.
+#### Example
 
-## Example
 ```html
-<script type="text/javascript" src="discord.11.3.1.min.js"></script>
+<script type="text/javascript" src="discord.11.1.0.min.js"></script>
 <script type="text/javascript">
   const client = new Discord.Client();
 

esm/discord.mjs

@@ -0,0 +1,95 @@
+import Discord from '../src/index.js';
+
+export default Discord;
+
+export const {
+  BaseClient,
+  Client,
+  Shard,
+  ShardClientUtil,
+  ShardingManager,
+  WebhookClient,
+  ActivityFlags,
+  BitField,
+  Collection,
+  Constants,
+  DataResolver,
+  BaseManager,
+  DiscordAPIError,
+  HTTPError,
+  MessageFlags,
+  Intents,
+  Permissions,
+  Speaking,
+  Snowflake,
+  SnowflakeUtil,
+  Structures,
+  SystemChannelFlags,
+  UserFlags,
+  Util,
+  version,
+  ChannelManager,
+  GuildChannelManager,
+  GuildEmojiManager,
+  GuildEmojiRoleManager,
+  GuildMemberManager,
+  GuildMemberRoleManager,
+  GuildManager,
+  ReactionManager,
+  ReactionUserManager,
+  MessageManager,
+  PresenceManager,
+  RoleManager,
+  UserManager,
+  discordSort,
+  escapeMarkdown,
+  fetchRecommendedShards,
+  resolveColor,
+  resolveString,
+  splitMessage,
+  Application,
+  Base,
+  Activity,
+  APIMessage,
+  BaseGuildEmoji,
+  CategoryChannel,
+  Channel,
+  ClientApplication,
+  ClientUser,
+  Collector,
+  DMChannel,
+  Emoji,
+  Guild,
+  GuildAuditLogs,
+  GuildChannel,
+  GuildEmoji,
+  GuildMember,
+  GuildPreview,
+  GuildTemplate,
+  Integration,
+  Invite,
+  Message,
+  MessageAttachment,
+  MessageCollector,
+  MessageEmbed,
+  MessageMentions,
+  MessageReaction,
+  NewsChannel,
+  PermissionOverwrites,
+  Presence,
+  ClientPresence,
+  ReactionCollector,
+  ReactionEmoji,
+  RichPresenceAssets,
+  Role,
+  StoreChannel,
+  Team,
+  TeamMember,
+  TextChannel,
+  User,
+  VoiceChannel,
+  VoiceRegion,
+  VoiceState,
+  Webhook,
+  WebSocket
+} = Discord;

jsdoc.json

@@ -0,0 +1,3 @@
+{
+  "plugins": ["node_modules/jsdoc-strip-async-await"]
+}

package.json

@@ -1,16 +1,30 @@
 {
   "name": "discord.js",
-  "version": "11.3.2",
+  "version": "12.5.1",
   "description": "A powerful library for interacting with the Discord API",
   "main": "./src/index",
   "types": "./typings/index.d.ts",
+  "exports": {
+    ".": [
+      {
+        "require": "./src/index.js",
+        "import": "./esm/discord.mjs"
+      },
+      "./src/index.js"
+    ],
+    "./esm": "./esm/discord.mjs"
+  },
   "scripts": {
-    "test": "npm run lint && npm run docs:test",
+    "test": "npm run lint && npm run docs:test && npm run lint:typings",
+    "test:typescript": "tsc",
     "docs": "docgen --source src --custom docs/index.yml --output docs/docs.json",
     "docs:test": "docgen --source src --custom docs/index.yml",
     "lint": "eslint src",
-    "lint:fix": "eslint --fix src",
-    "webpack": "parallel-webpack"
+    "lint:fix": "eslint src --fix",
+    "lint:typings": "tslint typings/index.d.ts",
+    "prettier": "prettier --write src/**/*.js typings/**/*.ts",
+    "build:browser": "webpack",
+    "prepublishOnly": "npm run test && cross-env NODE_ENV=production npm run build:browser"
   },
   "repository": {
     "type": "git",
@@ -31,63 +45,119 @@
   },
   "homepage": "https://github.com/discordjs/discord.js#readme",
   "runkitExampleFilename": "./docs/examples/ping.js",
+  "unpkg": "./webpack/discord.min.js",
   "dependencies": {
-    "long": "^4.0.0",
-    "prism-media": "^0.0.2",
-    "snekfetch": "^3.6.4",
-    "tweetnacl": "^1.0.0",
-    "ws": "^4.0.0"
-  },
-  "peerDependencies": {
-    "bufferutil": "^3.0.3",
-    "erlpack": "discordapp/erlpack",
-    "node-opus": "^0.2.7",
-    "opusscript": "^0.0.6",
-    "sodium": "^2.0.3",
-    "libsodium-wrappers": "^0.7.3",
-    "uws": "^9.14.0"
+    "@discordjs/collection": "^0.1.6",
+    "@discordjs/form-data": "^3.0.1",
+    "abort-controller": "^3.0.0",
+    "node-fetch": "^2.6.1",
+    "prism-media": "^1.2.2",
+    "setimmediate": "^1.0.5",
+    "tweetnacl": "^1.0.3",
+    "ws": "^7.3.1"
   },
   "devDependencies": {
-    "@types/node": "^9.4.6",
-    "discord.js-docgen": "discordjs/docgen",
-    "eslint": "^4.18.0",
-    "parallel-webpack": "^2.2.0",
-    "uglifyjs-webpack-plugin": "^1.2.0",
-    "webpack": "^3.11.0"
+    "@commitlint/cli": "^11.0.0",
+    "@commitlint/config-angular": "^11.0.0",
+    "@types/node": "^12.12.6",
+    "@types/ws": "^7.2.7",
+    "cross-env": "^7.0.2",
+    "discord.js-docgen": "git+https://github.com/discordjs/docgen.git",
+    "dtslint": "^4.0.4",
+    "eslint": "^7.11.0",
+    "eslint-config-prettier": "^6.13.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-prettier": "^3.1.4",
+    "husky": "^4.3.0",
+    "jest": "^26.6.0",
+    "json-filter-loader": "^1.0.0",
+    "lint-staged": "^10.4.2",
+    "prettier": "^2.1.2",
+    "terser-webpack-plugin": "^4.2.3",
+    "tslint": "^6.1.3",
+    "typescript": "^4.0.3",
+    "webpack": "^4.44.2",
+    "webpack-cli": "^3.3.12"
   },
   "engines": {
-    "node": ">=6.0.0"
+    "node": ">=12.0.0"
   },
   "browser": {
+    "@discordjs/opus": false,
+    "https": false,
     "ws": false,
-    "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/dispatcher/StreamDispatcher.js": false,
-    "src/client/voice/opus/BaseOpusEngine.js": false,
-    "src/client/voice/opus/NodeOpusEngine.js": false,
-    "src/client/voice/opus/OpusEngineList.js": false,
-    "src/client/voice/opus/OpusScriptEngine.js": false,
-    "src/client/voice/pcm/ConverterEngine.js": false,
-    "src/client/voice/pcm/ConverterEngineList.js": false,
-    "src/client/voice/pcm/FfmpegConverterEngine.js": false,
-    "src/client/voice/player/AudioPlayer.js": false,
-    "src/client/voice/receiver/VoiceReadable.js": false,
-    "src/client/voice/receiver/VoiceReceiver.js": false,
-    "src/client/voice/util/Secretbox.js": false,
-    "src/client/voice/util/SecretKey.js": false,
-    "src/client/voice/util/VolumeInterface.js": false,
     "src/client/voice/ClientVoiceManager.js": false,
     "src/client/voice/VoiceBroadcast.js": false,
     "src/client/voice/VoiceConnection.js": false,
-    "src/client/voice/VoiceUDPClient.js": false,
-    "src/client/voice/VoiceWebSocket.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/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/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"
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-angular"
+    ],
+    "rules": {
+      "scope-case": [
+        2,
+        "always",
+        "pascal-case"
+      ],
+      "type-enum": [
+        2,
+        "always",
+        [
+          "chore",
+          "build",
+          "ci",
+          "docs",
+          "feat",
+          "fix",
+          "perf",
+          "refactor",
+          "revert",
+          "style",
+          "test"
+        ]
+      ]
+    }
+  },
+  "prettier": {
+    "singleQuote": true,
+    "printWidth": 120,
+    "trailingComma": "all",
+    "endOfLine": "lf",
+    "arrowParens": "avoid"
   }
 }

src/WebSocket.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const { browser } = require('./util/Constants');
+
+let erlpack;
+
+try {
+  erlpack = require('erlpack');
+  if (!erlpack.pack) erlpack = null;
+} 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 {
+  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, 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;
+  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;
+};
+
+for (const state of ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED']) exports[state] = exports.WebSocket[state];

src/client/BaseClient.js

@@ -0,0 +1,169 @@
+'use strict';
+
+require('setimmediate');
+const EventEmitter = require('events');
+const RESTManager = require('../rest/RESTManager');
+const { DefaultOptions } = require('../util/Constants');
+const Util = require('../util/Util');
+
+/**
+ * The base class for all clients.
+ * @extends {EventEmitter}
+ */
+class BaseClient extends EventEmitter {
+  constructor(options = {}) {
+    super();
+
+    /**
+     * Timeouts set by {@link BaseClient#setTimeout} that are still active
+     * @type {Set<Timeout>}
+     * @private
+     */
+    this._timeouts = new Set();
+
+    /**
+     * Intervals set by {@link BaseClient#setInterval} that are still active
+     * @type {Set<Timeout>}
+     * @private
+     */
+    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}
+     */
+    this.options = Util.mergeDefault(DefaultOptions, options);
+
+    /**
+     * The REST manager of the client
+     * @type {RESTManager}
+     * @private
+     */
+    this.rest = new RESTManager(this, options._tokenType);
+  }
+
+  /**
+   * API shortcut
+   * @type {Object}
+   * @readonly
+   * @private
+   */
+  get api() {
+    return this.rest.api;
+  }
+
+  /**
+   * Destroys all assets used by the base client.
+   */
+  destroy() {
+    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();
+  }
+
+  /**
+   * Sets a timeout that will be automatically cancelled if the client is destroyed.
+   * @param {Function} fn Function to execute
+   * @param {number} delay Time to wait before executing (in milliseconds)
+   * @param {...*} args Arguments for the function
+   * @returns {Timeout}
+   */
+  setTimeout(fn, delay, ...args) {
+    const timeout = setTimeout(() => {
+      fn(...args);
+      this._timeouts.delete(timeout);
+    }, delay);
+    this._timeouts.add(timeout);
+    return timeout;
+  }
+
+  /**
+   * Clears a timeout.
+   * @param {Timeout} timeout Timeout to cancel
+   */
+  clearTimeout(timeout) {
+    clearTimeout(timeout);
+    this._timeouts.delete(timeout);
+  }
+
+  /**
+   * Sets an interval that will be automatically cancelled if the client is destroyed.
+   * @param {Function} fn Function to execute
+   * @param {number} delay Time to wait between executions (in milliseconds)
+   * @param {...*} args Arguments for the function
+   * @returns {Timeout}
+   */
+  setInterval(fn, delay, ...args) {
+    const interval = setInterval(fn, delay, ...args);
+    this._intervals.add(interval);
+    return interval;
+  }
+
+  /**
+   * Clears an interval.
+   * @param {Timeout} interval Interval to cancel
+   */
+  clearInterval(interval) {
+    clearInterval(interval);
+    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);
+  }
+
+  /**
+   * Increments max listeners by one, if they are not zero.
+   * @private
+   */
+  incrementMaxListeners() {
+    const maxListeners = this.getMaxListeners();
+    if (maxListeners !== 0) {
+      this.setMaxListeners(maxListeners + 1);
+    }
+  }
+
+  /**
+   * Decrements max listeners by one, if they are not zero.
+   * @private
+   */
+  decrementMaxListeners() {
+    const maxListeners = this.getMaxListeners();
+    if (maxListeners !== 0) {
+      this.setMaxListeners(maxListeners - 1);
+    }
+  }
+
+  toJSON(...props) {
+    return Util.flatten(this, { domain: false }, ...props);
+  }
+}
+
+module.exports = BaseClient;

src/client/Client.js

@@ -1,76 +1,86 @@
-const EventEmitter = require('events');
-const Constants = require('../util/Constants');
-const Permissions = require('../util/Permissions');
-const Util = require('../util/Util');
-const RESTManager = require('./rest/RESTManager');
-const ClientDataManager = require('./ClientDataManager');
-const ClientManager = require('./ClientManager');
-const ClientDataResolver = require('./ClientDataResolver');
+'use strict';
+
+const BaseClient = require('./BaseClient');
+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 Presence = require('../structures/Presence').Presence;
+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 VoiceBroadcast = require('./voice/VoiceBroadcast');
+const ClientApplication = require('../structures/ClientApplication');
+const GuildPreview = require('../structures/GuildPreview');
+const GuildTemplate = require('../structures/GuildTemplate');
+const Invite = require('../structures/Invite');
+const VoiceRegion = require('../structures/VoiceRegion');
+const Webhook = require('../structures/Webhook');
+const Collection = require('../util/Collection');
+const { Events, browser, DefaultOptions } = require('../util/Constants');
+const DataResolver = require('../util/DataResolver');
+const Intents = require('../util/Intents');
+const Permissions = require('../util/Permissions');
+const Structures = require('../util/Structures');
 
 /**
  * The main hub for interacting with the Discord API, and the starting point for any bot.
- * @extends {EventEmitter}
+ * @extends {BaseClient}
  */
-class Client extends EventEmitter {
+class Client extends BaseClient {
   /**
    * @param {ClientOptions} [options] Options for the client
    */
   constructor(options = {}) {
-    super();
+    super(Object.assign({ _tokenType: 'Bot' }, options));
 
-    // Obtain shard details from environment
-    if (!options.shardId && 'SHARD_ID' in process.env) options.shardId = Number(process.env.SHARD_ID);
-    if (!options.shardCount && 'SHARD_COUNT' in process.env) options.shardCount = Number(process.env.SHARD_COUNT);
+    // 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 (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)),
+        ),
+      ];
+    }
 
-    /**
-     * The options the client was instantiated with
-     * @type {ClientOptions}
-     */
-    this.options = Util.mergeDefault(Constants.DefaultOptions, options);
     this._validateOptions();
 
-    /**
-     * The REST manager of the client
-     * @type {RESTManager}
-     * @private
-     */
-    this.rest = new RESTManager(this);
-
-    /**
-     * The data manager of the client
-     * @type {ClientDataManager}
-     * @private
-     */
-    this.dataManager = new ClientDataManager(this);
-
-    /**
-     * 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);
 
-    /**
-     * The data resolver of the client
-     * @type {ClientDataResolver}
-     * @private
-     */
-    this.resolver = new ClientDataResolver(this);
-
     /**
      * The action manager of the client
      * @type {ActionsManager}
@@ -81,52 +91,57 @@ class Client extends EventEmitter {
     /**
      * The voice manager of the client (`null` in browsers)
      * @type {?ClientVoiceManager}
-     * @private
      */
-    this.voice = !this.browser ? new ClientVoiceManager(this) : null;
+    this.voice = !browser ? new ClientVoiceManager(this) : null;
 
     /**
-     * The shard helpers for the client
-     * (only if the process was spawned as a child, such as from a {@link ShardingManager})
+     * Shard helpers for the client (only if the process was spawned from a {@link ShardingManager})
      * @type {?ShardClientUtil}
      */
-    this.shard = process.send ? 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 {Collection<Snowflake, User>}
+     * @type {UserManager}
      */
-    this.users = new Collection();
+    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 {Collection<Snowflake, Guild>}
+     * @type {GuildManager}
      */
-    this.guilds = new Collection();
+    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, and all DM channels
-     * @type {Collection<Snowflake, Channel>}
+     * as long as sharding isn't being used, this will be *every* channel in *every* guild the bot
+     * 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 Collection();
+    this.channels = new ChannelManager(this);
 
+    const ClientPresence = Structures.get('ClientPresence');
     /**
-     * Presences that have been received for the client user's friends, mapped by user IDs
-     * <warn>This is only filled when using a user account.</warn>
-     * @type {Collection<Snowflake, Presence>}
+     * The presence of the Client
+     * @private
+     * @type {ClientPresence}
      */
-    this.presences = new Collection();
+    this.presence = new ClientPresence(this);
 
     Object.defineProperty(this, 'token', { writable: true });
-    if (!this.token && 'CLIENT_TOKEN' in process.env) {
+    if (!browser && !this.token && 'DISCORD_TOKEN' in process.env) {
       /**
-       * Authorization token for the logged in user/bot
+       * Authorization token for the logged in bot.
+       * If present, this defaults to `process.env.DISCORD_TOKEN` when instantiating the client
        * <warn>This should be kept private at all times.</warn>
        * @type {?string}
        */
-      this.token = process.env.CLIENT_TOKEN;
+      this.token = process.env.DISCORD_TOKEN;
     } else {
       this.token = null;
     }
@@ -144,92 +159,20 @@ class Client extends EventEmitter {
      */
     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 = [];
-
-    /**
-     * Timeouts set by {@link Client#setTimeout} that are still active
-     * @type {Set<Timeout>}
-     * @private
-     */
-    this._timeouts = new Set();
-
-    /**
-     * Intervals set by {@link Client#setInterval} that are still active
-     * @type {Set<Timeout>}
-     * @private
-     */
-    this._intervals = new Set();
-
     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}
-   * @private
-   */
-  get _pingTimestamp() {
-    return this.ws.connection ? this.ws.connection.lastPingTimestamp : 0;
-  }
-
-  /**
-   * Current status of the client's connection to Discord
-   * @type {?number}
-   * @readonly
-   */
-  get status() {
-    return this.ws.connection.status;
-  }
-
-  /**
-   * 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 (this.browser) return new Collection();
-    return this.voice.connections;
-  }
-
   /**
    * All custom emojis that the client has access to, mapped by their IDs
-   * @type {Collection<Snowflake, Emoji>}
+   * @type {GuildEmojiManager}
    * @readonly
    */
   get emojis() {
-    const emojis = new Collection();
-    for (const guild of this.guilds.values()) {
-      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;
   }
@@ -244,85 +187,89 @@ class Client extends EventEmitter {
   }
 
   /**
-   * Whether the client is in a browser environment
-   * @type {boolean}
+   * How long it has been since the client last entered the `READY` state in milliseconds
+   * @type {?number}
    * @readonly
    */
-  get browser() {
-    return typeof window !== 'undefined';
-  }
-
-  /**
-   * Creates a voice broadcast.
-   * @returns {VoiceBroadcast}
-   */
-  createVoiceBroadcast() {
-    const broadcast = new VoiceBroadcast(this);
-    this.broadcasts.push(broadcast);
-    return broadcast;
+  get uptime() {
+    return this.readyAt ? Date.now() - this.readyAt : null;
   }
 
   /**
    * Logs the client in, establishing a websocket connection to Discord.
-   * <info>Both bot and regular user accounts are supported, but it is highly recommended to use a bot account whenever
-   * possible. User accounts are subject to harsher ratelimits and other restrictions that don't apply to bot accounts.
-   * Bot accounts also have access to many features that user accounts cannot utilise. User accounts that are found to
-   * be abusing/overusing the API will be banned, locking you out of Discord entirely.</info>
-   * @param {string} token Token of the account to log in with
+   * @param {string} [token=this.token] Token of the account to log in with
    * @returns {Promise<string>} Token of the account used
    * @example
    * client.login('my token');
    */
-  login(token) {
-    return this.rest.methods.login(token);
+  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();
+      throw error;
+    }
   }
 
   /**
    * Logs out, terminates the connection to Discord, and destroys the client.
-   * @returns {Promise}
+   * @returns {void}
    */
   destroy() {
-    for (const t of this._timeouts) clearTimeout(t);
-    for (const i of this._intervals) clearInterval(i);
-    this._timeouts.clear();
-    this._intervals.clear();
-    return this.manager.destroy();
-  }
-
-  /**
-   * Requests a sync of guild data with Discord.
-   * <info>This can be done automatically every 30 seconds by enabling {@link ClientOptions#sync}.</info>
-   * <warn>This is only available when using a user account.</warn>
-   * @param {Guild[]|Collection<Snowflake, Guild>} [guilds=this.guilds] An array or collection of guilds to sync
-   */
-  syncGuilds(guilds = this.guilds) {
-    if (this.user.bot) return;
-    this.ws.send({
-      op: 12,
-      d: guilds instanceof Collection ? guilds.keyArray() : guilds.map(g => g.id),
-    });
-  }
-
-  /**
-   * Obtains a user from Discord, or the user cache if it's already available.
-   * <warn>This is only available when using a bot account.</warn>
-   * @param {Snowflake} id ID of the user
-   * @param {boolean} [cache=true] Whether to cache the new user object if it isn't already
-   * @returns {Promise<User>}
-   */
-  fetchUser(id, cache = true) {
-    if (this.users.has(id)) return Promise.resolve(this.users.get(id));
-    return this.rest.methods.getUser(id, cache);
+    super.destroy();
+    this.ws.destroy();
+    this.token = null;
   }
 
   /**
    * Obtains an invite from Discord.
    * @param {InviteResolvable} invite Invite code or URL
    * @returns {Promise<Invite>}
+   * @example
+   * client.fetchInvite('https://discord.gg/bRCvFy9')
+   *   .then(invite => console.log(`Obtained invite with code: ${invite.code}`))
+   *   .catch(console.error);
    */
   fetchInvite(invite) {
-    const code = this.resolver.resolveInviteCode(invite);
-    return this.rest.methods.getInvite(code);
+    const code = DataResolver.resolveInviteCode(invite);
+    return this.api
+      .invites(code)
+      .get({ query: { with_counts: true } })
+      .then(data => new Invite(this, data));
+  }
+
+  /**
+   * Obtains a template from Discord.
+   * @param {GuildTemplateResolvable} template Template code or URL
+   * @returns {Promise<GuildTemplate>}
+   * @example
+   * client.fetchGuildTemplate('https://discord.new/FKvmczH2HyUf')
+   *   .then(template => console.log(`Obtained template with code: ${template.code}`))
+   *   .catch(console.error);
+   */
+  fetchGuildTemplate(template) {
+    const code = DataResolver.resolveGuildTemplateCode(template);
+    return this.api.guilds
+      .templates(code)
+      .get()
+      .then(data => new GuildTemplate(this, data));
   }
 
   /**
@@ -330,17 +277,32 @@ class Client extends EventEmitter {
    * @param {Snowflake} id ID of the webhook
    * @param {string} [token] Token for the webhook
    * @returns {Promise<Webhook>}
+   * @example
+   * client.fetchWebhook('id', 'token')
+   *   .then(webhook => console.log(`Obtained webhook with name: ${webhook.name}`))
+   *   .catch(console.error);
    */
   fetchWebhook(id, token) {
-    return this.rest.methods.getWebhook(id, token);
+    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(', ')}`))
+   *   .catch(console.error);
    */
   fetchVoiceRegions() {
-    return this.rest.methods.fetchVoiceRegions();
+    return this.api.voice.regions.get().then(res => {
+      const regions = new Collection();
+      for (const region of res) regions.set(region.id, new VoiceRegion(region));
+      return regions;
+    });
   }
 
   /**
@@ -350,11 +312,17 @@ class Client extends EventEmitter {
    * will be removed from the caches. The default is based on {@link ClientOptions#messageCacheLifetime}
    * @returns {number} Amount of messages that were removed from the caches,
    * or -1 if the message cache lifetime is unlimited
+   * @example
+   * // Remove all messages older than 1800 seconds from the messages cache
+   * const amount = client.sweepMessages(1800);
+   * console.log(`Successfully removed ${amount} messages from the cache.`);
    */
   sweepMessages(lifetime = this.options.messageCacheLifetime) {
-    if (typeof lifetime !== 'number' || isNaN(lifetime)) throw new TypeError('The lifetime must be a number.');
+    if (typeof lifetime !== 'number' || isNaN(lifetime)) {
+      throw new TypeError('INVALID_TYPE', 'lifetime', 'number');
+    }
     if (lifetime <= 0) {
-      this.emit('debug', 'Didn\'t sweep messages - lifetime is unlimited');
+      this.emit(Events.DEBUG, "Didn't sweep messages - lifetime is unlimited");
       return -1;
     }
 
@@ -363,123 +331,87 @@ class Client extends EventEmitter {
     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++;
 
-      for (const message of channel.messages.values()) {
-        if (now - (message.editedTimestamp || message.createdTimestamp) > lifetimeMs) {
-          channel.messages.delete(message.id);
-          messages++;
-        }
-      }
+      messages += channel.messages.cache.sweep(
+        message => now - (message.editedTimestamp || message.createdTimestamp) > lifetimeMs,
+      );
     }
 
-    this.emit('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;
   }
 
   /**
-   * Obtains the OAuth Application of the bot from Discord.
-   * @param {Snowflake} [id='@me'] ID of application to fetch
-   * @returns {Promise<OAuth2Application>}
+   * Obtains the OAuth Application of this bot from Discord.
+   * @returns {Promise<ClientApplication>}
    */
-  fetchApplication(id = '@me') {
-    return this.rest.methods.getApplication(id);
+  fetchApplication() {
+    return this.api.oauth2
+      .applications('@me')
+      .get()
+      .then(app => new ClientApplication(this, app));
+  }
+
+  /**
+   * Obtains a guild preview from Discord, available for all guilds the bot is in and all Discoverable guilds.
+   * @param {GuildResolvable} guild The guild to fetch the preview for
+   * @returns {Promise<GuildPreview>}
+   */
+  fetchGuildPreview(guild) {
+    const id = this.guilds.resolveID(guild);
+    if (!id) throw new TypeError('INVALID_TYPE', 'guild', 'GuildResolvable');
+    return this.api
+      .guilds(id)
+      .preview.get()
+      .then(data => new GuildPreview(this, data));
   }
 
   /**
    * Generates a link that can be used to invite the bot to a guild.
-   * <warn>This is only available when using a bot account.</warn>
-   * @param {PermissionResolvable[]|number} [permissions] Permissions to request
+   * @param {InviteGenerationOptions|PermissionResolvable} [options] Permissions to request
    * @returns {Promise<string>}
    * @example
-   * client.generateInvite(['SEND_MESSAGES', 'MANAGE_GUILD', 'MENTION_EVERYONE'])
-   *   .then(link => {
-   *     console.log(`Generated bot invite link: ${link}`);
-   *   });
+   * client.generateInvite({
+   *   permissions: ['SEND_MESSAGES', 'MANAGE_GUILD', 'MENTION_EVERYONE'],
+   * })
+   *   .then(link => console.log(`Generated bot invite link: ${link}`))
+   *   .catch(console.error);
    */
-  generateInvite(permissions) {
-    if (permissions) {
-      if (permissions instanceof Array) permissions = Permissions.resolve(permissions);
-    } else {
-      permissions = 0;
+  async generateInvite(options = {}) {
+    if (Array.isArray(options) || ['string', 'number'].includes(typeof options) || options instanceof Permissions) {
+      process.emitWarning(
+        'Client#generateInvite: Generate invite with an options object instead of a PermissionResolvable',
+        'DeprecationWarning',
+      );
+      options = { permissions: options };
     }
-    return this.fetchApplication().then(application =>
-      `https://discordapp.com/oauth2/authorize?client_id=${application.id}&permissions=${permissions}&scope=bot`
-    );
-  }
-
-  /**
-   * Sets a timeout that will be automatically cancelled if the client is destroyed.
-   * @param {Function} fn Function to execute
-   * @param {number} delay Time to wait before executing (in milliseconds)
-   * @param {...*} args Arguments for the function
-   * @returns {Timeout}
-   */
-  setTimeout(fn, delay, ...args) {
-    const timeout = setTimeout(() => {
-      fn(...args);
-      this._timeouts.delete(timeout);
-    }, delay);
-    this._timeouts.add(timeout);
-    return timeout;
-  }
-
-  /**
-   * Clears a timeout.
-   * @param {Timeout} timeout Timeout to cancel
-   */
-  clearTimeout(timeout) {
-    clearTimeout(timeout);
-    this._timeouts.delete(timeout);
-  }
-
-  /**
-   * Sets an interval that will be automatically cancelled if the client is destroyed.
-   * @param {Function} fn Function to execute
-   * @param {number} delay Time to wait before executing (in milliseconds)
-   * @param {...*} args Arguments for the function
-   * @returns {Timeout}
-   */
-  setInterval(fn, delay, ...args) {
-    const interval = setInterval(fn, delay, ...args);
-    this._intervals.add(interval);
-    return interval;
-  }
-
-  /**
-   * Clears an interval.
-   * @param {Timeout} interval Interval to cancel
-   */
-  clearInterval(interval) {
-    clearInterval(interval);
-    this._intervals.delete(interval);
-  }
-
-  /**
-   * 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;
-  }
-
-  /**
-   * Adds/updates a friend's presence in {@link Client#presences}.
-   * @param {Snowflake} id ID of the user
-   * @param {Object} presence Raw presence object from Discord
-   * @private
-   */
-  _setPresence(id, presence) {
-    if (this.presences.has(id)) {
-      this.presences.get(id).update(presence);
-      return;
+    const application = await this.fetchApplication();
+    const query = new URLSearchParams({
+      client_id: application.id,
+      permissions: Permissions.resolve(options.permissions),
+      scope: 'bot',
+    });
+    if (typeof options.disableGuildSelect === 'boolean') {
+      query.set('disable_guild_select', options.disableGuildSelect.toString());
     }
-    this.presences.set(id, new Presence(presence));
+    if (typeof options.guild !== 'undefined') {
+      const guildID = this.guilds.resolveID(options.guild);
+      if (!guildID) throw new TypeError('INVALID_TYPE', 'options.guild', 'GuildResolvable');
+      query.set('guild_id', guildID);
+    }
+    return `${this.options.http.api}${this.api.oauth2.authorize}?${query}`;
+  }
+
+  toJSON() {
+    return super.toJSON({
+      readyAt: false,
+    });
   }
 
   /**
@@ -499,41 +431,66 @@ class Client extends EventEmitter {
    * @private
    */
   _validateOptions(options = this.options) {
-    if (typeof options.shardCount !== 'number' || isNaN(options.shardCount)) {
-      throw new TypeError('The shardCount option must be a number.');
+    if (typeof options.ws.intents !== 'undefined') {
+      options.ws.intents = Intents.resolve(options.ws.intents);
     }
-    if (typeof options.shardId !== 'number' || isNaN(options.shardId)) {
-      throw new TypeError('The shardId option must be a number.');
+    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 (options.shardCount < 0) throw new RangeError('The shardCount option must be at least 0.');
-    if (options.shardId < 0) throw new RangeError('The shardId option must be at least 0.');
-    if (options.shardId !== 0 && options.shardId >= options.shardCount) {
-      throw new RangeError('The shardId option must be 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('The messageCacheMaxSize option must be a number.');
+      throw new TypeError('CLIENT_INVALID_OPTION', 'messageCacheMaxSize', 'a number');
     }
     if (typeof options.messageCacheLifetime !== 'number' || isNaN(options.messageCacheLifetime)) {
-      throw new TypeError('The messageCacheLifetime option must be a number.');
+      throw new TypeError('CLIENT_INVALID_OPTION', 'The messageCacheLifetime', 'a number');
     }
     if (typeof options.messageSweepInterval !== 'number' || isNaN(options.messageSweepInterval)) {
-      throw new TypeError('The messageSweepInterval option must be a number.');
+      throw new TypeError('CLIENT_INVALID_OPTION', 'messageSweepInterval', 'a number');
+    }
+    if (
+      typeof options.messageEditHistoryMaxSize !== 'number' ||
+      isNaN(options.messageEditHistoryMaxSize) ||
+      options.messageEditHistoryMaxSize < -1
+    ) {
+      throw new TypeError('CLIENT_INVALID_OPTION', 'messageEditHistoryMaxSize', 'a number greater than or equal to -1');
     }
     if (typeof options.fetchAllMembers !== 'boolean') {
-      throw new TypeError('The fetchAllMembers option must be a boolean.');
+      throw new TypeError('CLIENT_INVALID_OPTION', 'fetchAllMembers', 'a boolean');
     }
-    if (typeof options.disableEveryone !== 'boolean') {
-      throw new TypeError('The disableEveryone option must be 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('The restWsBridgeTimeout option must be a number.');
+      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.retryLimit !== 'number' || isNaN(options.retryLimit)) {
+      throw new TypeError('CLIENT_INVALID_OPTION', 'retryLimit', 'a number');
     }
-    if (!(options.disabledEvents instanceof Array)) throw new TypeError('The disabledEvents option must be an Array.');
   }
 }
 
 module.exports = Client;
 
+/**
+ * Options for {@link Client#generateInvite}.
+ * @typedef {Object} InviteGenerationOptions
+ * @property {PermissionResolvable} [permissions] Permissions to request
+ * @property {GuildResolvable} [guild] Guild to preselect
+ * @property {boolean} [disableGuildSelect] Whether to disable the guild selection
+ */
+
 /**
  * Emitted for general warnings.
  * @event Client#warn

src/client/ClientDataManager.js

@@ -1,136 +0,0 @@
-const Constants = require('../util/Constants');
-const Util = require('../util/Util');
-const Guild = require('../structures/Guild');
-const User = require('../structures/User');
-const CategoryChannel = require('../structures/CategoryChannel');
-const DMChannel = require('../structures/DMChannel');
-const Emoji = require('../structures/Emoji');
-const TextChannel = require('../structures/TextChannel');
-const VoiceChannel = require('../structures/VoiceChannel');
-const GuildChannel = require('../structures/GuildChannel');
-const GroupDMChannel = require('../structures/GroupDMChannel');
-
-class ClientDataManager {
-  constructor(client) {
-    this.client = client;
-  }
-
-  get pastReady() {
-    return this.client.ws.connection.status === Constants.Status.READY;
-  }
-
-  newGuild(data) {
-    const already = this.client.guilds.has(data.id);
-    const guild = new Guild(this.client, data);
-    this.client.guilds.set(guild.id, guild);
-    if (this.pastReady && !already) {
-      /**
-       * Emitted whenever the client joins a guild.
-       * @event Client#guildCreate
-       * @param {Guild} guild The created guild
-       */
-      if (this.client.options.fetchAllMembers) {
-        guild.fetchMembers().then(() => { this.client.emit(Constants.Events.GUILD_CREATE, guild); });
-      } else {
-        this.client.emit(Constants.Events.GUILD_CREATE, guild);
-      }
-    }
-
-    return guild;
-  }
-
-  newUser(data) {
-    if (this.client.users.has(data.id)) return this.client.users.get(data.id);
-    const user = new User(this.client, data);
-    this.client.users.set(user.id, user);
-    return user;
-  }
-
-  newChannel(data, guild) {
-    const already = this.client.channels.has(data.id);
-    let channel;
-    if (data.type === Constants.ChannelTypes.DM) {
-      channel = new DMChannel(this.client, data);
-    } else if (data.type === Constants.ChannelTypes.GROUP_DM) {
-      channel = new GroupDMChannel(this.client, data);
-    } else {
-      guild = guild || this.client.guilds.get(data.guild_id);
-      if (guild) {
-        if (data.type === Constants.ChannelTypes.TEXT) {
-          channel = new TextChannel(guild, data);
-          guild.channels.set(channel.id, channel);
-        } else if (data.type === Constants.ChannelTypes.VOICE) {
-          channel = new VoiceChannel(guild, data);
-          guild.channels.set(channel.id, channel);
-        } else if (data.type === Constants.ChannelTypes.CATEGORY) {
-          channel = new CategoryChannel(guild, data);
-          guild.channels.set(channel.id, channel);
-        }
-      }
-    }
-
-    if (channel && !already) {
-      if (this.pastReady) this.client.emit(Constants.Events.CHANNEL_CREATE, channel);
-      this.client.channels.set(channel.id, channel);
-      return channel;
-    } else if (already) {
-      return channel;
-    }
-
-    return null;
-  }
-
-  newEmoji(data, guild) {
-    const already = guild.emojis.has(data.id);
-    if (data && !already) {
-      let emoji = new Emoji(guild, data);
-      this.client.emit(Constants.Events.GUILD_EMOJI_CREATE, emoji);
-      guild.emojis.set(emoji.id, emoji);
-      return emoji;
-    } else if (already) {
-      return guild.emojis.get(data.id);
-    }
-
-    return null;
-  }
-
-  killEmoji(emoji) {
-    if (!(emoji instanceof Emoji && emoji.guild)) return;
-    this.client.emit(Constants.Events.GUILD_EMOJI_DELETE, emoji);
-    emoji.guild.emojis.delete(emoji.id);
-  }
-
-  killGuild(guild) {
-    const already = this.client.guilds.has(guild.id);
-    this.client.guilds.delete(guild.id);
-    if (already && this.pastReady) this.client.emit(Constants.Events.GUILD_DELETE, guild);
-  }
-
-  killUser(user) {
-    this.client.users.delete(user.id);
-  }
-
-  killChannel(channel) {
-    this.client.channels.delete(channel.id);
-    if (channel instanceof GuildChannel) channel.guild.channels.delete(channel.id);
-  }
-
-  updateGuild(currentGuild, newData) {
-    const oldGuild = Util.cloneObject(currentGuild);
-    currentGuild.setup(newData);
-    if (this.pastReady) this.client.emit(Constants.Events.GUILD_UPDATE, oldGuild, currentGuild);
-  }
-
-  updateChannel(currentChannel, newData) {
-    currentChannel.setup(newData);
-  }
-
-  updateEmoji(currentEmoji, newData) {
-    const oldEmoji = Util.cloneObject(currentEmoji);
-    currentEmoji.setup(newData);
-    this.client.emit(Constants.Events.GUILD_EMOJI_UPDATE, oldEmoji, currentEmoji);
-    return currentEmoji;
-  }
-}
-
-module.exports = ClientDataManager;

src/client/ClientDataResolver.js

@@ -1,378 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const snekfetch = require('snekfetch');
-
-const Constants = require('../util/Constants');
-const convertToBuffer = require('../util/Util').convertToBuffer;
-const User = require('../structures/User');
-const Message = require('../structures/Message');
-const Guild = require('../structures/Guild');
-const Channel = require('../structures/Channel');
-const GuildMember = require('../structures/GuildMember');
-const Emoji = require('../structures/Emoji');
-const ReactionEmoji = require('../structures/ReactionEmoji');
-const Role = require('../structures/Role');
-
-/**
- * The DataResolver identifies different objects and tries to resolve a specific piece of information from them, e.g.
- * extracting a User from a Message object.
- * @private
- */
-class ClientDataResolver {
-  /**
-   * @param {Client} client The client the resolver is for
-   */
-  constructor(client) {
-    this.client = client;
-  }
-
-  /**
-   * Data that resolves to give a User object. This can be:
-   * * A User object
-   * * A Snowflake
-   * * A Message object (resolves to the message author)
-   * * A Guild object (owner of the guild)
-   * * A GuildMember object
-   * @typedef {User|Snowflake|Message|Guild|GuildMember} UserResolvable
-   */
-
-  /**
-   * Resolves a UserResolvable to a User object.
-   * @param {UserResolvable} user The UserResolvable to identify
-   * @returns {?User}
-   */
-  resolveUser(user) {
-    if (user instanceof User) return user;
-    if (typeof user === 'string') return this.client.users.get(user) || null;
-    if (user instanceof GuildMember) return user.user;
-    if (user instanceof Message) return user.author;
-    if (user instanceof Guild) return user.owner;
-    return null;
-  }
-
-  /**
-   * Resolves a UserResolvable to a user ID string.
-   * @param {UserResolvable} user The UserResolvable to identify
-   * @returns {?Snowflake}
-   */
-  resolveUserID(user) {
-    if (user instanceof User || user instanceof GuildMember) return user.id;
-    if (typeof user === 'string') return user || null;
-    if (user instanceof Message) return user.author.id;
-    if (user instanceof Guild) return user.ownerID;
-    return null;
-  }
-
-  /**
-   * 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.
-   * @param {GuildResolvable} guild The GuildResolvable to identify
-   * @returns {?Guild}
-   */
-  resolveGuild(guild) {
-    if (guild instanceof Guild) return guild;
-    if (typeof guild === 'string') return this.client.guilds.get(guild) || null;
-    return null;
-  }
-
-  /**
-   * Data that resolves to give a GuildMember object. This can be:
-   * * A GuildMember object
-   * * A User object
-   * @typedef {GuildMember|User} GuildMemberResolvable
-   */
-
-  /**
-   * Resolves a GuildMemberResolvable to a GuildMember object.
-   * @param {GuildResolvable} guild The guild that the member is part of
-   * @param {UserResolvable} user The user that is part of the guild
-   * @returns {?GuildMember}
-   */
-  resolveGuildMember(guild, user) {
-    if (user instanceof GuildMember) return user;
-    guild = this.resolveGuild(guild);
-    user = this.resolveUser(user);
-    if (!guild || !user) return null;
-    return guild.members.get(user.id) || null;
-  }
-
-  /**
-   * 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.
-    * @param {GuildResolvable} guild The guild that this role is part of
-    * @param {RoleResolvable} role The role resolvable to resolve
-    * @returns {?Role}
-    */
-  resolveRole(guild, role) {
-    if (role instanceof Role) return role;
-    guild = this.resolveGuild(guild);
-    if (!guild) return null;
-    if (typeof role === 'string') return guild.roles.get(role);
-    return null;
-  }
-
-  /**
-   * Data that can be resolved to give a Channel object. This can be:
-   * * A Channel object
-   * * A Message object (the channel the message was sent in)
-   * * A Guild object (the #general channel)
-   * * A Snowflake
-   * @typedef {Channel|Guild|Message|Snowflake} ChannelResolvable
-   */
-
-  /**
-   * Resolves a ChannelResolvable to a Channel object.
-   * @param {ChannelResolvable} channel The channel resolvable to resolve
-   * @returns {?Channel}
-   */
-  resolveChannel(channel) {
-    if (channel instanceof Channel) return channel;
-    if (typeof channel === 'string') return this.client.channels.get(channel) || null;
-    if (channel instanceof Message) return channel.channel;
-    if (channel instanceof Guild) return channel.channels.get(channel.id) || null;
-    return null;
-  }
-
-  /**
-   * Resolves a ChannelResolvable to a channel ID.
-   * @param {ChannelResolvable} channel The channel resolvable to resolve
-   * @returns {?Snowflake}
-   */
-  resolveChannelID(channel) {
-    if (channel instanceof Channel) return channel.id;
-    if (typeof channel === 'string') return channel;
-    if (channel instanceof Message) return channel.channel.id;
-    if (channel instanceof Guild) return channel.defaultChannel.id;
-    return null;
-  }
-
-  /**
-   * Data that can be resolved to give an invite code. This can be:
-   * * An invite code
-   * * An invite URL
-   * @typedef {string} InviteResolvable
-   */
-
-  /**
-   * Resolves InviteResolvable to an invite code.
-   * @param {InviteResolvable} data The invite resolvable to resolve
-   * @returns {string}
-   */
-  resolveInviteCode(data) {
-    const inviteRegex = /discord(?:app\.com\/invite|\.gg)\/([\w-]{2,255})/i;
-    const match = inviteRegex.exec(data);
-    if (match && match[1]) return match[1];
-    return data;
-  }
-
-  /**
-   * Data that can be resolved to give a string. This can be:
-   * * A string
-   * * An array (joined with a new line delimiter to give a string)
-   * * Any value
-   * @typedef {string|Array|*} StringResolvable
-   */
-
-  /**
-   * Resolves a StringResolvable to a string.
-   * @param {StringResolvable} data The string resolvable to resolve
-   * @returns {string}
-   */
-  resolveString(data) {
-    if (typeof data === 'string') return data;
-    if (data instanceof Array) return data.join('\n');
-    return String(data);
-  }
-
-
-  /**
-   * Resolves a Base64Resolvable, a string, or a BufferResolvable to a Base 64 image.
-   * @param {BufferResolvable|Base64Resolvable} image The image to be resolved
-   * @returns {Promise<?string>}
-   */
-  resolveImage(image) {
-    if (!image) return Promise.resolve(null);
-    if (typeof image === 'string' && image.startsWith('data:')) {
-      return Promise.resolve(image);
-    }
-    return this.resolveFile(image).then(this.resolveBase64);
-  }
-
-  /**
-   * Data that resolves to give a Base64 string, typically for image uploading. This can be:
-   * * A Buffer
-   * * A base64 string
-   * @typedef {Buffer|string} Base64Resolvable
-   */
-
-  /**
-   * Resolves a Base64Resolvable to a Base 64 image.
-   * @param {Base64Resolvable} data The base 64 resolvable you want to resolve
-   * @returns {?string}
-   */
-  resolveBase64(data) {
-    if (data instanceof Buffer) return `data:image/jpg;base64,${data.toString('base64')}`;
-    return data;
-  }
-
-  /**
-    * Data that can be resolved to give a Buffer. This can be:
-    * * A Buffer
-    * * The path to a local file
-    * * A URL
-    * * A Stream
-    * @typedef {string|Buffer} BufferResolvable
-    */
-
-  /**
-    * @external Stream
-    * @see {@link https://nodejs.org/api/stream.html}
-    */
-
-  /**
-    * Resolves a BufferResolvable to a Buffer.
-    * @param {BufferResolvable|Stream} resource The buffer or stream resolvable to resolve
-    * @returns {Promise<Buffer>}
-    */
-  resolveFile(resource) {
-    if (resource instanceof Buffer) return Promise.resolve(resource);
-    if (this.client.browser && resource instanceof ArrayBuffer) return Promise.resolve(convertToBuffer(resource));
-
-    if (typeof resource === 'string') {
-      return new Promise((resolve, reject) => {
-        if (/^https?:\/\//.test(resource)) {
-          snekfetch.get(resource)
-            .end((err, res) => {
-              if (err) return reject(err);
-              if (!(res.body instanceof Buffer)) return reject(new TypeError('The response body isn\'t a Buffer.'));
-              return resolve(res.body);
-            });
-        } else {
-          const file = path.resolve(resource);
-          fs.stat(file, (err, stats) => {
-            if (err) return reject(err);
-            if (!stats || !stats.isFile()) return reject(new Error(`The file could not be found: ${file}`));
-            fs.readFile(file, (err2, data) => {
-              if (err2) reject(err2); else resolve(data);
-            });
-            return null;
-          });
-        }
-      });
-    } else if (resource.pipe && typeof resource.pipe === 'function') {
-      return new Promise((resolve, reject) => {
-        const buffers = [];
-        resource.once('error', reject);
-        resource.on('data', data => buffers.push(data));
-        resource.once('end', () => resolve(Buffer.concat(buffers)));
-      });
-    }
-
-    return Promise.reject(new TypeError('The resource must be a string or Buffer.'));
-  }
-
-  /**
-   * Data that can be resolved to give an emoji identifier. This can be:
-   * * The unicode representation of an emoji
-   * * A custom emoji ID
-   * * An Emoji object
-   * * A ReactionEmoji object
-   * @typedef {string|Emoji|ReactionEmoji} EmojiIdentifierResolvable
-   */
-
-  /**
-   * Resolves an EmojiResolvable to an emoji identifier.
-   * @param {EmojiIdentifierResolvable} emoji The emoji resolvable to resolve
-   * @returns {?string}
-   */
-  resolveEmojiIdentifier(emoji) {
-    if (emoji instanceof Emoji || emoji instanceof ReactionEmoji) return emoji.identifier;
-    if (typeof emoji === 'string') {
-      if (this.client.emojis.has(emoji)) return this.client.emojis.get(emoji).identifier;
-      else if (!emoji.includes('%')) return encodeURIComponent(emoji);
-      else return emoji;
-    }
-    return null;
-  }
-
-  /**
-   * Can be a Hex Literal, Hex String, Number, RGB Array, or one of the following
-   * ```
-   * [
-   *   'DEFAULT',
-   *   'AQUA',
-   *   'GREEN',
-   *   'BLUE',
-   *   'PURPLE',
-   *   'GOLD',
-   *   'ORANGE',
-   *   'RED',
-   *   'GREY',
-   *   'DARKER_GREY',
-   *   'NAVY',
-   *   'DARK_AQUA',
-   *   'DARK_GREEN',
-   *   'DARK_BLUE',
-   *   'DARK_PURPLE',
-   *   'DARK_GOLD',
-   *   'DARK_ORANGE',
-   *   'DARK_RED',
-   *   'DARK_GREY',
-   *   'LIGHT_GREY',
-   *   'DARK_NAVY',
-   *   'RANDOM',
-   * ]
-   * ```
-   * or something like
-   * ```
-   * [255, 0, 255]
-   * ```
-   * for purple
-   * @typedef {string|number|Array} ColorResolvable
-   */
-
-  /**
-   * Resolves a ColorResolvable into a color number.
-   * @param {ColorResolvable} color Color to resolve
-   * @returns {number} A color
-   */
-  static resolveColor(color) {
-    if (typeof color === 'string') {
-      if (color === 'RANDOM') return Math.floor(Math.random() * (0xFFFFFF + 1));
-      if (color === 'DEFAULT') return 0;
-      color = Constants.Colors[color] || parseInt(color.replace('#', ''), 16);
-    } else if (color instanceof Array) {
-      color = (color[0] << 16) + (color[1] << 8) + color[2];
-    }
-
-    if (color < 0 || color > 0xFFFFFF) {
-      throw new RangeError('Color must be within the range 0 - 16777215 (0xFFFFFF).');
-    } else if (color && isNaN(color)) {
-      throw new TypeError('Unable to convert color to a number.');
-    }
-
-    return color;
-  }
-
-  /**
-   * @param {ColorResolvable} color Color to resolve
-   * @returns {number} A color
-   */
-  resolveColor(color) {
-    return this.constructor.resolveColor(color);
-  }
-}
-
-module.exports = ClientDataResolver;

src/client/ClientManager.js

@@ -1,73 +0,0 @@
-const Constants = require('../util/Constants');
-const WebSocketConnection = require('./websocket/WebSocketConnection');
-
-/**
- * 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
-   * @type {number}
-   */
-  get status() {
-    return this.connection ? this.connection.status : Constants.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(Constants.Events.DEBUG, `Authenticated using token ${token}`);
-    this.client.token = token;
-    const timeout = this.client.setTimeout(() => reject(new Error(Constants.Errors.TOOK_TOO_LONG)), 1000 * 300);
-    this.client.rest.methods.getGateway().then(res => {
-      const protocolVersion = Constants.DefaultOptions.ws.version;
-      const gateway = `${res.url}/?v=${protocolVersion}&encoding=${WebSocketConnection.ENCODING}`;
-      this.client.emit(Constants.Events.DEBUG, `Using gateway ${gateway}`);
-      this.client.ws.connect(gateway);
-      this.client.ws.connection.once('close', event => {
-        if (event.code === 4004) reject(new Error(Constants.Errors.BAD_LOGIN));
-        if (event.code === 4010) reject(new Error(Constants.Errors.INVALID_SHARD));
-        if (event.code === 4011) reject(new Error(Constants.Errors.SHARDING_REQUIRED));
-      });
-      this.client.once(Constants.Events.READY, () => {
-        resolve(token);
-        this.client.clearTimeout(timeout);
-      });
-    }, reject);
-  }
-
-  destroy() {
-    this.client.ws.destroy();
-    this.client.rest.destroy();
-    if (!this.client.user) return Promise.resolve();
-    if (this.client.user.bot) {
-      this.client.token = null;
-      return Promise.resolve();
-    } else {
-      return this.client.rest.methods.logout().then(() => {
-        this.client.token = null;
-      });
-    }
-  }
-}
-
-module.exports = ClientManager;

src/client/WebhookClient.js

@@ -1,14 +1,14 @@
+'use strict';
+
+const BaseClient = require('./BaseClient');
 const Webhook = require('../structures/Webhook');
-const RESTManager = require('./rest/RESTManager');
-const ClientDataResolver = require('./ClientDataResolver');
-const Constants = require('../util/Constants');
-const Util = require('../util/Util');
 
 /**
  * The webhook client.
- * @extends {Webhook}
+ * @implements {Webhook}
+ * @extends {BaseClient}
  */
-class WebhookClient extends Webhook {
+class WebhookClient extends BaseClient {
   /**
    * @param {Snowflake} id ID of the webhook
    * @param {string} token Token of the webhook
@@ -16,103 +16,16 @@ class WebhookClient extends Webhook {
    * @example
    * // Create a new webhook and send a message
    * const hook = new Discord.WebhookClient('1234', 'abcdef');
-   * hook.sendMessage('This will send a message').catch(console.error);
+   * hook.send('This will send a message').catch(console.error);
    */
   constructor(id, token, options) {
-    super(null, id, token);
-
-    /**
-     * The options the client was instantiated with
-     * @type {ClientOptions}
-     */
-    this.options = Util.mergeDefault(Constants.DefaultOptions, options);
-
-    /**
-     * The REST manager of the client
-     * @type {RESTManager}
-     * @private
-     */
-    this.rest = new RESTManager(this);
-
-    /**
-     * The data resolver of the client
-     * @type {ClientDataResolver}
-     * @private
-     */
-    this.resolver = new ClientDataResolver(this);
-
-    /**
-     * Timeouts set by {@link WebhookClient#setTimeout} that are still active
-     * @type {Set<Timeout>}
-     * @private
-     */
-    this._timeouts = new Set();
-
-    /**
-     * Intervals set by {@link WebhookClient#setInterval} that are still active
-     * @type {Set<Timeout>}
-     * @private
-     */
-    this._intervals = new Set();
-  }
-
-  /**
-   * Sets a timeout that will be automatically cancelled if the client is destroyed.
-   * @param {Function} fn Function to execute
-   * @param {number} delay Time to wait before executing (in milliseconds)
-   * @param {...*} args Arguments for the function
-   * @returns {Timeout}
-   */
-  setTimeout(fn, delay, ...args) {
-    const timeout = setTimeout(() => {
-      fn(...args);
-      this._timeouts.delete(timeout);
-    }, delay);
-    this._timeouts.add(timeout);
-    return timeout;
-  }
-
-  /**
-   * Clears a timeout.
-   * @param {Timeout} timeout Timeout to cancel
-   */
-  clearTimeout(timeout) {
-    clearTimeout(timeout);
-    this._timeouts.delete(timeout);
-  }
-
-  /**
-   * Sets an interval that will be automatically cancelled if the client is destroyed.
-   * @param {Function} fn Function to execute
-   * @param {number} delay Time to wait before executing (in milliseconds)
-   * @param {...*} args Arguments for the function
-   * @returns {Timeout}
-   */
-  setInterval(fn, delay, ...args) {
-    const interval = setInterval(fn, delay, ...args);
-    this._intervals.add(interval);
-    return interval;
-  }
-
-  /**
-   * Clears an interval.
-   * @param {Timeout} interval Interval to cancel
-   */
-  clearInterval(interval) {
-    clearInterval(interval);
-    this._intervals.delete(interval);
-  }
-
-
-  /**
-   * Destroys the client.
-   */
-  destroy() {
-    for (const t of this._timeouts) clearTimeout(t);
-    for (const i of this._intervals) clearInterval(i);
-    this._timeouts.clear();
-    this._intervals.clear();
+    super(options);
+    Object.defineProperty(this, 'client', { value: this });
+    this.id = id;
+    Object.defineProperty(this, 'token', { value: token, writable: true, configurable: true });
   }
 }
 
+Webhook.applyToClass(WebhookClient);
+
 module.exports = WebhookClient;

src/client/actions/Action.js

@@ -1,3 +1,7 @@
+'use strict';
+
+const { PartialTypes } = require('../../util/Constants');
+
 /*
 
 ABOUT ACTIONS
@@ -18,6 +22,84 @@ 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) {
+    return this.getPayload(data, guild.members, data.user.id, PartialTypes.GUILD_MEMBER);
+  }
+
+  getUser(data) {
+    const id = data.user_id;
+    return data.user || this.getPayload({ id }, this.client.users, id, PartialTypes.USER);
+  }
+
+  getUserFromMember(data) {
+    if (data.guild_id && data.member && data.member.user) {
+      const guild = this.client.guilds.cache.get(data.guild_id);
+      if (guild) {
+        return guild.members.add(data.member).user;
+      } else {
+        return this.client.users.add(data.member.user);
+      }
+    }
+    return this.getUser(data);
+  }
 }
 
 module.exports = GenericAction;

src/client/actions/ActionsManager.js

@@ -1,3 +1,5 @@
+'use strict';
+
 class ActionsManager {
   constructor(client) {
     this.client = client;
@@ -9,27 +11,32 @@ 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('./GuildMemberGet'));
+    this.register(require('./InviteCreate'));
+    this.register(require('./InviteDelete'));
     this.register(require('./GuildMemberRemove'));
+    this.register(require('./GuildMemberUpdate'));
     this.register(require('./GuildBanRemove'));
     this.register(require('./GuildRoleCreate'));
     this.register(require('./GuildRoleDelete'));
     this.register(require('./GuildRoleUpdate'));
-    this.register(require('./UserGet'));
+    this.register(require('./PresenceUpdate'));
     this.register(require('./UserUpdate'));
-    this.register(require('./UserNoteUpdate'));
-    this.register(require('./GuildSync'));
+    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'));
+    this.register(require('./TypingStart'));
   }
 
   register(Action) {

src/client/actions/ChannelCreate.js

@@ -1,9 +1,21 @@
+'use strict';
+
 const Action = require('./Action');
+const { Events } = require('../../util/Constants');
 
 class ChannelCreateAction extends Action {
   handle(data) {
     const client = this.client;
-    const channel = client.dataManager.newChannel(data);
+    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 };
   }
 }

src/client/actions/ChannelDelete.js

@@ -1,4 +1,8 @@
+'use strict';
+
 const Action = require('./Action');
+const DMChannel = require('../../structures/DMChannel');
+const { Events } = require('../../util/Constants');
 
 class ChannelDeleteAction extends Action {
   constructor(client) {
@@ -8,22 +12,26 @@ class ChannelDeleteAction extends Action {
 
   handle(data) {
     const client = this.client;
+    let channel = client.channels.cache.get(data.id);
 
-    let channel = client.channels.get(data.id);
     if (channel) {
-      client.dataManager.killChannel(channel);
-      this.deleted.set(channel.id, channel);
-      this.scheduleForDeletion(channel.id);
-    } else {
-      channel = this.deleted.get(data.id) || null;
+      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);
     }
 
     return { channel };
   }
-
-  scheduleForDeletion(id) {
-    this.client.setTimeout(() => this.deleted.delete(id), this.client.options.restWsBridgeTimeout);
-  }
 }
 
 module.exports = ChannelDeleteAction;

src/client/actions/ChannelUpdate.js

@@ -1,34 +1,33 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
-const Util = require('../../util/Util');
+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 oldChannel = Util.cloneObject(channel);
-      channel.setup(data);
-      client.emit(Constants.Events.CHANNEL_UPDATE, oldChannel, 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: oldChannel,
+        old,
         updated: channel,
       };
     }
 
-    return {
-      old: null,
-      updated: null,
-    };
+    return {};
   }
 }
 
-/**
- * Emitted whenever a channel is updated - e.g. name change, topic change.
- * @event Client#channelUpdate
- * @param {Channel} oldChannel The channel before the update
- * @param {Channel} newChannel The channel after the update
- */
-
 module.exports = ChannelUpdateAction;

src/client/actions/GuildBanRemove.js

@@ -1,12 +1,20 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
+const { Events } = require('../../util/Constants');
 
 class GuildBanRemove extends Action {
   handle(data) {
     const client = this.client;
-    const guild = client.guilds.get(data.guild_id);
-    const user = client.dataManager.newUser(data.user);
-    if (guild && user) client.emit(Constants.Events.GUILD_BAN_REMOVE, guild, user);
+    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);
   }
 }
 

src/client/actions/GuildChannelsPositionUpdate.js

@@ -1,14 +1,16 @@
+'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);
-        if (channel) channel.position = partialChannel.position;
+        const channel = guild.channels.cache.get(partialChannel.id);
+        if (channel) channel.rawPosition = partialChannel.position;
       }
     }
 

src/client/actions/GuildDelete.js

@@ -1,5 +1,7 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
+const { Events } = require('../../util/Constants');
 
 class GuildDeleteAction extends Action {
   constructor(client) {
@@ -10,16 +12,22 @@ 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) {
+      if (data.unavailable) {
         // Guild is unavailable
         guild.available = false;
-        client.emit(Constants.Events.GUILD_UNAVAILABLE, guild);
+
+        /**
+         * 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,
         // handles emitting of event itself
@@ -28,11 +36,20 @@ class GuildDeleteAction extends Action {
         };
       }
 
-      for (const channel of guild.channels.values()) this.client.channels.delete(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.delete(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 {
@@ -47,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;

src/client/actions/GuildEmojiCreate.js

@@ -1,17 +1,20 @@
+'use strict';
+
 const Action = require('./Action');
+const { Events } = require('../../util/Constants');
 
 class GuildEmojiCreateAction extends Action {
   handle(guild, createdEmoji) {
-    const client = this.client;
-    const emoji = client.dataManager.newEmoji(createdEmoji, guild);
+    const already = guild.emojis.cache.has(createdEmoji.id);
+    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
+     */
+    if (!already) this.client.emit(Events.GUILD_EMOJI_CREATE, emoji);
     return { emoji };
   }
 }
 
-/**
- * Emitted whenever a custom emoji is created in a guild.
- * @event Client#emojiCreate
- * @param {Emoji} emoji The emoji that was created
- */
-
 module.exports = GuildEmojiCreateAction;

src/client/actions/GuildEmojiDelete.js

@@ -1,17 +1,20 @@
+'use strict';
+
 const Action = require('./Action');
+const { Events } = require('../../util/Constants');
 
 class GuildEmojiDeleteAction extends Action {
   handle(emoji) {
-    const client = this.client;
-    client.dataManager.killEmoji(emoji);
+    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 guild emoji is deleted.
- * @event Client#emojiDelete
- * @param {Emoji} emoji The emoji that was deleted
- */
-
 module.exports = GuildEmojiDeleteAction;

src/client/actions/GuildEmojiUpdate.js

@@ -1,17 +1,20 @@
+'use strict';
+
 const Action = require('./Action');
+const { Events } = require('../../util/Constants');
 
 class GuildEmojiUpdateAction extends Action {
-  handle(oldEmoji, newEmoji) {
-    const emoji = this.client.dataManager.updateEmoji(oldEmoji, newEmoji);
-    return { emoji };
+  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 guild emoji is updated.
- * @event Client#emojiUpdate
- * @param {Emoji} oldEmoji The old emoji
- * @param {Emoji} newEmoji The new emoji
- */
-
 module.exports = GuildEmojiUpdateAction;

src/client/actions/GuildEmojisUpdate.js

@@ -1,24 +1,20 @@
-const Action = require('./Action');
+'use strict';
 
-function mappify(iterable) {
-  const map = new Map();
-  for (const x of iterable) map.set(...x);
-  return map;
-}
+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 = mappify(guild.emojis.entries());
+    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, true)) {
+        if (!cachedEmoji.equals(emoji)) {
           // Emoji updated
           this.client.actions.GuildEmojiUpdate.handle(cachedEmoji, emoji);
         }

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;

src/client/actions/GuildMemberGet.js

@@ -1,10 +0,0 @@
-const Action = require('./Action');
-
-class GuildMemberGetAction extends Action {
-  handle(guild, data) {
-    const member = guild._addMember(data, false);
-    return { member };
-  }
-}
-
-module.exports = GuildMemberGetAction;

src/client/actions/GuildMemberRemove.js

@@ -1,40 +1,30 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
+const { Events, Status } = require('../../util/Constants');
 
 class GuildMemberRemoveAction extends Action {
-  constructor(client) {
-    super(client);
-    this.deleted = new Map();
-  }
-
-  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({ user: data.user }, guild);
+      guild.memberCount--;
       if (member) {
-        guild.memberCount--;
-        guild._removeMember(member);
-        this.deleted.set(guild.id + data.user.id, member);
-        if (client.status === Constants.Status.READY) client.emit(Constants.Events.GUILD_MEMBER_REMOVE, member);
-        this.scheduleForDeletion(guild.id, data.user.id);
-      } else {
-        member = this.deleted.get(guild.id + data.user.id) || null;
+        member.deleted = true;
+        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 };
   }
-
-  scheduleForDeletion(guildID, userID) {
-    this.client.setTimeout(() => this.deleted.delete(guildID + userID), this.client.options.restWsBridgeTimeout);
-  }
 }
 
-/**
- * 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;

src/client/actions/GuildMemberUpdate.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const Action = require('./Action');
+const { Status, Events } = require('../../util/Constants');
+
+class GuildMemberUpdateAction extends Action {
+  handle(data, shard) {
+    const { client } = this;
+    if (data.user.username) {
+      const user = client.users.cache.get(data.user.id);
+      if (!user) {
+        client.users.add(data.user);
+      } else if (!user.equals(data.user)) {
+        client.actions.UserUpdate.handle(data.user);
+      }
+    }
+
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      const member = this.getMember({ user: data.user }, guild);
+      if (member) {
+        const old = member._update(data);
+        /**
+         * Emitted whenever a guild member changes - i.e. new role, removed role, nickname.
+         * Also emitted when the user's details (e.g. username) change.
+         * @event Client#guildMemberUpdate
+         * @param {GuildMember} oldMember The member before the update
+         * @param {GuildMember} newMember The member after the update
+         */
+        if (shard.status === Status.READY) client.emit(Events.GUILD_MEMBER_UPDATE, old, member);
+      } else {
+        const newMember = guild.members.add(data);
+        /**
+         * Emitted whenever a member becomes available in a large guild.
+         * @event Client#guildMemberAvailable
+         * @param {GuildMember} member The member that became available
+         */
+        this.client.emit(Events.GUILD_MEMBER_AVAILABLE, newMember);
+      }
+    }
+  }
+}
+
+module.exports = GuildMemberUpdateAction;

src/client/actions/GuildRoleCreate.js

@@ -1,26 +1,25 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
-const Role = require('../../structures/Role');
+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);
-      role = new Role(guild, data.role);
-      guild.roles.set(role.id, role);
-      if (!already) client.emit(Constants.Events.GUILD_ROLE_CREATE, role);
+      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;

src/client/actions/GuildRoleDelete.js

@@ -1,41 +1,30 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
+const { Events } = require('../../util/Constants');
 
 class GuildRoleDeleteAction extends Action {
-  constructor(client) {
-    super(client);
-    this.deleted = new Map();
-  }
-
   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.delete(data.role_id);
-        this.deleted.set(guild.id + data.role_id, role);
-        this.scheduleForDeletion(guild.id, data.role_id);
-        client.emit(Constants.Events.GUILD_ROLE_DELETE, role);
-      } else {
-        role = this.deleted.get(guild.id + data.role_id) || null;
+        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);
       }
     }
 
     return { role };
   }
-
-  scheduleForDeletion(guildID, roleID) {
-    this.client.setTimeout(() => this.deleted.delete(guildID + roleID), this.client.options.restWsBridgeTimeout);
-  }
 }
 
-/**
- * Emitted whenever a guild role is deleted.
- * @event Client#roleDelete
- * @param {Role} role The role that was deleted
- */
-
 module.exports = GuildRoleDeleteAction;

src/client/actions/GuildRoleUpdate.js

@@ -1,25 +1,30 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
-const Util = require('../../util/Util');
+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) {
-      const roleData = data.role;
-      let oldRole = null;
+      let old = null;
 
-      const role = guild.roles.get(roleData.id);
+      const role = guild.roles.cache.get(data.role.id);
       if (role) {
-        oldRole = Util.cloneObject(role);
-        role.setup(data.role);
-        client.emit(Constants.Events.GUILD_ROLE_UPDATE, oldRole, 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);
       }
 
       return {
-        old: oldRole,
+        old,
         updated: role,
       };
     }
@@ -31,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;

src/client/actions/GuildRolesPositionUpdate.js

@@ -1,14 +1,16 @@
+'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);
-        if (role) role.position = partialRole.position;
+        const role = guild.roles.cache.get(partialRole.id);
+        if (role) role.rawPosition = partialRole.position;
       }
     }
 

src/client/actions/GuildSync.js

@@ -1,29 +0,0 @@
-const Action = require('./Action');
-
-class GuildSync extends Action {
-  handle(data) {
-    const client = this.client;
-
-    const guild = client.guilds.get(data.id);
-    if (guild) {
-      if (data.presences) {
-        for (const presence of data.presences) guild._setPresence(presence.user.id, presence);
-      }
-
-      if (data.members) {
-        for (const syncMember of data.members) {
-          const member = guild.members.get(syncMember.user.id);
-          if (member) {
-            guild._updateMember(member, syncMember);
-          } else {
-            guild._addMember(syncMember, false);
-          }
-        }
-      }
-
-      if ('large' in data) guild.large = data.large;
-    }
-  }
-}
-
-module.exports = GuildSync;

src/client/actions/GuildUpdate.js

@@ -1,18 +1,24 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
-const Util = require('../../util/Util');
+const { Events } = require('../../util/Constants');
 
 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 oldGuild = Util.cloneObject(guild);
-      guild.setup(data);
-      client.emit(Constants.Events.GUILD_UPDATE, oldGuild, 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: oldGuild,
+        old,
         updated: guild,
       };
     }
@@ -24,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;

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) 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;

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;

src/client/actions/MessageCreate.js

@@ -1,54 +1,38 @@
+'use strict';
+
 const Action = require('./Action');
-const Message = require('../../structures/Message');
+const { Events } = require('../../util/Constants');
 
 class MessageCreateAction extends Action {
   handle(data) {
     const client = this.client;
-
-    const channel = client.channels.get((data instanceof Array ? data[0] : data).channel_id);
-    const user = client.users.get((data instanceof Array ? data[0] : data).author.id);
+    const channel = client.channels.cache.get(data.channel_id);
     if (channel) {
-      const member = channel.guild ? channel.guild.member(user) : null;
-      if (data instanceof Array) {
-        const messages = new Array(data.length);
-        for (let i = 0; i < data.length; i++) {
-          messages[i] = channel._cacheMessage(new Message(channel, data[i], client));
-        }
-        const lastMessage = messages[messages.length - 1];
-        channel.lastMessageID = lastMessage.id;
-        channel.lastMessage = lastMessage;
-        if (user) {
-          user.lastMessageID = lastMessage.id;
-          user.lastMessage = lastMessage;
-        }
-        if (member) {
-          member.lastMessageID = lastMessage.id;
-          member.lastMessage = lastMessage;
-        }
-        return {
-          messages,
-        };
-      } else {
-        const message = channel._cacheMessage(new Message(channel, data, client));
-        channel.lastMessageID = data.id;
-        channel.lastMessage = message;
-        if (user) {
-          user.lastMessageID = data.id;
-          user.lastMessage = message;
-        }
-        if (member) {
-          member.lastMessageID = data.id;
-          member.lastMessage = message;
-        }
-        return {
-          message,
-        };
+      const existing = channel.messages.cache.get(data.id);
+      if (existing) return { message: existing };
+      const message = channel.messages.add(data);
+      const user = message.author;
+      let member = message.member;
+      channel.lastMessageID = data.id;
+      if (user) {
+        user.lastMessageID = data.id;
+        user.lastMessageChannelID = channel.id;
       }
+      if (member) {
+        member.lastMessageID = data.id;
+        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 };
     }
 
-    return {
-      message: null,
-    };
+    return {};
   }
 }
 

src/client/actions/MessageDelete.js

@@ -1,34 +1,29 @@
+'use strict';
+
 const Action = require('./Action');
+const { Events } = require('../../util/Constants');
 
 class MessageDeleteAction extends Action {
-  constructor(client) {
-    super(client);
-    this.deleted = new Map();
-  }
-
   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);
-        this.deleted.set(channel.id + message.id, message);
-        this.scheduleForDeletion(channel.id, message.id);
-      } else {
-        message = this.deleted.get(channel.id + data.id) || null;
+        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);
       }
     }
 
     return { message };
   }
-
-  scheduleForDeletion(channelID, messageID) {
-    this.client.setTimeout(() => this.deleted.delete(channelID + messageID),
-      this.client.options.restWsBridgeTimeout);
-  }
 }
 
 module.exports = MessageDeleteAction;

src/client/actions/MessageDeleteBulk.js

@@ -1,25 +1,42 @@
+'use strict';
+
 const Action = require('./Action');
 const Collection = require('../../util/Collection');
-const Constants = require('../../util/Constants');
+const { Events } = require('../../util/Constants');
 
 class MessageDeleteBulkAction extends Action {
   handle(data) {
-    const messages = new Collection();
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
 
-    if (!data.messages) {
-      const channel = this.client.channels.get(data.channel_id);
-      for (const id of data.ids) {
-        const message = channel.messages.get(id);
-        if (message) messages.set(message.id, message);
-      }
-    } else {
-      for (const msg of data.messages) {
-        messages.set(msg.id, msg);
+    if (channel) {
+      const ids = data.ids;
+      const messages = new Collection();
+      for (const id of ids) {
+        const message = this.getMessage(
+          {
+            id,
+            guild_id: data.guild_id,
+          },
+          channel,
+          false,
+        );
+        if (message) {
+          message.deleted = true;
+          messages.set(message.id, message);
+          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 };
     }
-
-    if (messages.size > 0) this.client.emit(Constants.Events.MESSAGE_BULK_DELETE, messages);
-    return { messages };
+    return {};
   }
 }
 

src/client/actions/MessageReactionAdd.js

@@ -1,37 +1,55 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
+const { Events } = require('../../util/Constants');
+const { PartialTypes } = require('../../util/Constants');
 
 /*
 { user_id: 'id',
      message_id: 'id',
      emoji: { name: '<27>', id: null },
-     channel_id: 'id' } }
+     channel_id: 'id',
+     // If originating from a guild
+     guild_id: 'id',
+     member: { ..., user: { ... } } }
 */
 
 class MessageReactionAdd 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.getUserFromMember(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 reaction = message._addReaction(data.emoji, user);
-    if (reaction) this.client.emit(Constants.Events.MESSAGE_REACTION_ADD, reaction, user);
+    if (message.partial && !this.client.options.partials.includes(PartialTypes.REACTION)) return false;
+    const existing = message.reactions.cache.get(data.emoji.id || data.emoji.name);
+    if (existing && existing.users.cache.has(user.id)) return { message, reaction: existing, user };
+    const reaction = message.reactions.add({
+      emoji: data.emoji,
+      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 message.
- * @event Client#messageReactionAdd
- * @param {MessageReaction} messageReaction The reaction object
- * @param {User} user The user that applied the emoji or reaction emoji
- */
-
 module.exports = MessageReactionAdd;

src/client/actions/MessageReactionRemove.js

@@ -1,37 +1,45 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
+const { Events } = require('../../util/Constants');
 
 /*
 { user_id: 'id',
      message_id: 'id',
      emoji: { name: '<27>', id: null },
-     channel_id: 'id' } }
+     channel_id: 'id',
+     guild_id: 'id' }
 */
 
 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 reaction = message._removeReaction(data.emoji, user);
-    if (reaction) this.client.emit(Constants.Events.MESSAGE_REACTION_REMOVE, reaction, user);
+    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 message.
- * @event Client#messageReactionRemove
- * @param {MessageReaction} messageReaction The reaction object
- * @param {User} user The user that removed the emoji or reaction emoji
- */
-
 module.exports = MessageReactionRemove;

src/client/actions/MessageReactionRemoveAll.js

@@ -1,23 +1,27 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
+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._clearReactions();
-    this.client.emit(Constants.Events.MESSAGE_REACTION_REMOVE_ALL, message);
+    message.reactions.cache.clear();
+    this.client.emit(Events.MESSAGE_REACTION_REMOVE_ALL, message);
 
     return { message };
   }
 }
 
 /**
- * Emitted whenever all reactions are removed from a message.
+ * Emitted whenever all reactions are removed from a cached message.
  * @event Client#messageReactionRemoveAll
  * @param {Message} message The message the reactions were removed from
  */

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;

src/client/actions/MessageUpdate.js

@@ -1,40 +1,24 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
 
 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);
-        client.emit(Constants.Events.MESSAGE_UPDATE, message._edits[0], message);
+        const old = message.patch(data);
         return {
-          old: message._edits[0],
+          old,
           updated: message,
         };
       }
-
-      return {
-        old: message,
-        updated: message,
-      };
     }
 
-    return {
-      old: null,
-      updated: null,
-    };
+    return {};
   }
 }
 
-/**
- * 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
- */
-
 module.exports = MessageUpdateAction;

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;

src/client/actions/TypingStart.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+const textBasedChannelTypes = ['dm', 'text', 'news'];
+
+class TypingStart extends Action {
+  handle(data) {
+    const channel = this.getChannel(data);
+    if (!channel) {
+      return;
+    }
+    if (!textBasedChannelTypes.includes(channel.type)) {
+      this.client.emit(Events.WARN, `Discord sent a typing packet to a ${channel.type} channel ${channel.id}`);
+      return;
+    }
+
+    const user = this.getUserFromMember(data);
+    const timestamp = new Date(data.timestamp * 1000);
+
+    if (channel && user) {
+      if (channel._typing.has(user.id)) {
+        const typing = channel._typing.get(user.id);
+
+        typing.lastTimestamp = timestamp;
+        typing.elapsedTime = Date.now() - typing.since;
+        this.client.clearTimeout(typing.timeout);
+        typing.timeout = this.tooLate(channel, user);
+      } else {
+        const since = new Date();
+        const lastTimestamp = new Date();
+        channel._typing.set(user.id, {
+          user,
+          since,
+          lastTimestamp,
+          elapsedTime: Date.now() - since,
+          timeout: this.tooLate(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
+         */
+        this.client.emit(Events.TYPING_START, channel, user);
+      }
+    }
+  }
+
+  tooLate(channel, user) {
+    return channel.client.setTimeout(() => {
+      channel._typing.delete(user.id);
+    }, 10000);
+  }
+}
+
+module.exports = TypingStart;

src/client/actions/UserGet.js

@@ -1,11 +0,0 @@
-const Action = require('./Action');
-
-class UserGetAction extends Action {
-  handle(data) {
-    const client = this.client;
-    const user = client.dataManager.newUser(data);
-    return { user };
-  }
-}
-
-module.exports = UserGetAction;

src/client/actions/UserNoteUpdate.js

@@ -1,30 +0,0 @@
-const Action = require('./Action');
-const Constants = require('../../util/Constants');
-
-class UserNoteUpdateAction extends Action {
-  handle(data) {
-    const client = this.client;
-
-    const oldNote = client.user.notes.get(data.id);
-    const note = data.note.length ? data.note : null;
-
-    client.user.notes.set(data.id, note);
-
-    client.emit(Constants.Events.USER_NOTE_UPDATE, data.id, oldNote, note);
-
-    return {
-      old: oldNote,
-      updated: note,
-    };
-  }
-}
-
-/**
- * Emitted whenever a note is updated.
- * @event Client#userNoteUpdate
- * @param {User} user The user the note belongs to
- * @param {string} oldNote The note content before the update
- * @param {string} newNote The note content after the update
- */
-
-module.exports = UserNoteUpdateAction;

src/client/actions/UserUpdate.js

@@ -1,25 +1,27 @@
+'use strict';
+
 const Action = require('./Action');
-const Constants = require('../../util/Constants');
-const Util = require('../../util/Util');
+const { Events } = require('../../util/Constants');
 
 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 = Util.cloneObject(client.user);
-      client.user.patch(data);
-      client.emit(Constants.Events.USER_UPDATE, oldUser, client.user);
+    if (!oldUser.equals(newUser)) {
+      /**
+       * Emitted whenever a user's details (e.g. username) are changed.
+       * Triggered by the Discord gateway events USER_UPDATE, GUILD_MEMBER_UPDATE, and PRESENCE_UPDATE.
+       * @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,
       };
     }
 

src/client/actions/VoiceStateUpdate.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+const Structures = require('../../util/Structures');
+
+class VoiceStateUpdate extends Action {
+  handle(data) {
+    const client = this.client;
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (guild) {
+      const VoiceState = Structures.get('VoiceState');
+      // 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;

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;

src/client/rest/APIRequest.js

@@ -1,52 +0,0 @@
-const snekfetch = require('snekfetch');
-const Constants = require('../../util/Constants');
-
-class APIRequest {
-  constructor(rest, method, path, auth, data, files, reason) {
-    this.rest = rest;
-    this.client = rest.client;
-    this.method = method;
-    this.path = path.toString();
-    this.auth = auth;
-    this.data = data;
-    this.files = files;
-    this.route = this.getRoute(this.path);
-    this.reason = reason;
-  }
-
-  getRoute(url) {
-    let route = url.split('?')[0];
-    if (route.includes('/channels/') || route.includes('/guilds/')) {
-      const startInd = route.includes('/channels/') ? route.indexOf('/channels/') : route.indexOf('/guilds/');
-      const majorID = route.substring(startInd).split('/')[2];
-      route = route.replace(/(\d{8,})/g, ':id').replace(':id', majorID);
-    }
-    return route;
-  }
-
-  getAuth() {
-    if (this.client.token && this.client.user && this.client.user.bot) {
-      return `Bot ${this.client.token}`;
-    } else if (this.client.token) {
-      return this.client.token;
-    }
-    throw new Error(Constants.Errors.NO_TOKEN);
-  }
-
-  gen() {
-    const API = `${this.client.options.http.host}/api/v${this.client.options.http.version}`;
-    const request = snekfetch[this.method](`${API}${this.path}`);
-    if (this.auth) request.set('Authorization', this.getAuth());
-    if (this.reason) request.set('X-Audit-Log-Reason', encodeURIComponent(this.reason));
-    if (!this.rest.client.browser) request.set('User-Agent', this.rest.userAgentManager.userAgent);
-    if (this.files) {
-      for (const file of this.files) if (file && file.file) request.attach(file.name, file.file, file.name);
-      if (typeof this.data !== 'undefined') request.attach('payload_json', JSON.stringify(this.data));
-    } else if (this.data) {
-      request.send(this.data);
-    }
-    return request;
-  }
-}
-
-module.exports = APIRequest;

src/client/rest/RESTManager.js

@@ -1,56 +0,0 @@
-const UserAgentManager = require('./UserAgentManager');
-const RESTMethods = require('./RESTMethods');
-const SequentialRequestHandler = require('./RequestHandlers/Sequential');
-const BurstRequestHandler = require('./RequestHandlers/Burst');
-const APIRequest = require('./APIRequest');
-const Constants = require('../../util/Constants');
-
-class RESTManager {
-  constructor(client) {
-    this.client = client;
-    this.handlers = {};
-    this.userAgentManager = new UserAgentManager(this);
-    this.methods = new RESTMethods(this);
-    this.rateLimitedEndpoints = {};
-    this.globallyRateLimited = false;
-  }
-
-  destroy() {
-    for (const handler of Object.values(this.handlers)) {
-      if (handler.destroy) handler.destroy();
-    }
-  }
-
-  push(handler, apiRequest) {
-    return new Promise((resolve, reject) => {
-      handler.push({
-        request: apiRequest,
-        resolve,
-        reject,
-      });
-    });
-  }
-
-  getRequestHandler() {
-    switch (this.client.options.apiRequestMethod) {
-      case 'sequential':
-        return SequentialRequestHandler;
-      case 'burst':
-        return BurstRequestHandler;
-      default:
-        throw new Error(Constants.Errors.INVALID_RATE_LIMIT_METHOD);
-    }
-  }
-
-  makeRequest(method, url, auth, data, file, reason) {
-    const apiRequest = new APIRequest(this, method, url, auth, data, file, reason);
-    if (!this.handlers[apiRequest.route]) {
-      const RequestHandlerType = this.getRequestHandler();
-      this.handlers[apiRequest.route] = new RequestHandlerType(this, apiRequest.route);
-    }
-
-    return this.push(this.handlers[apiRequest.route], apiRequest);
-  }
-}
-
-module.exports = RESTManager;

src/client/rest/RESTMethods.js

@@ -1,964 +0,0 @@
-const querystring = require('querystring');
-const long = require('long');
-const Permissions = require('../../util/Permissions');
-const Constants = require('../../util/Constants');
-const Endpoints = Constants.Endpoints;
-const Collection = require('../../util/Collection');
-const Util = require('../../util/Util');
-
-const User = require('../../structures/User');
-const GuildMember = require('../../structures/GuildMember');
-const Message = require('../../structures/Message');
-const Role = require('../../structures/Role');
-const Invite = require('../../structures/Invite');
-const Webhook = require('../../structures/Webhook');
-const UserProfile = require('../../structures/UserProfile');
-const OAuth2Application = require('../../structures/OAuth2Application');
-const Channel = require('../../structures/Channel');
-const GroupDMChannel = require('../../structures/GroupDMChannel');
-const Guild = require('../../structures/Guild');
-const VoiceRegion = require('../../structures/VoiceRegion');
-const GuildAuditLogs = require('../../structures/GuildAuditLogs');
-
-class RESTMethods {
-  constructor(restManager) {
-    this.rest = restManager;
-    this.client = restManager.client;
-    this._ackToken = null;
-  }
-
-  login(token = this.client.token) {
-    return new Promise((resolve, reject) => {
-      if (typeof token !== 'string') throw new Error(Constants.Errors.INVALID_TOKEN);
-      token = token.replace(/^Bot\s*/i, '');
-      this.client.manager.connectToWebSocket(token, resolve, reject);
-    });
-  }
-
-  logout() {
-    return this.rest.makeRequest('post', Endpoints.logout, true, {});
-  }
-
-  getGateway(bot = false) {
-    return this.rest.makeRequest('get', bot ? Endpoints.gateway.bot : Endpoints.gateway, true);
-  }
-
-  fetchVoiceRegions(guildID) {
-    let endpoint;
-    if (guildID) endpoint = Endpoints.Guild(guildID).voiceRegions;
-    else endpoint = Endpoints.voiceRegions;
-    return this.rest.makeRequest('get', endpoint, true).then(res => {
-      const regions = new Collection();
-      for (const region of res) regions.set(region.id, new VoiceRegion(region));
-      return regions;
-    });
-  }
-
-  sendMessage(channel, content, { tts, nonce, embed, disableEveryone, split, code, reply } = {}, files = null) {
-    return new Promise((resolve, reject) => { // eslint-disable-line complexity
-      if (typeof content !== 'undefined') content = this.client.resolver.resolveString(content);
-
-      // The nonce has to be a uint64 :<
-      if (typeof nonce !== 'undefined') {
-        nonce = parseInt(nonce);
-        if (isNaN(nonce) || nonce < 0) throw new RangeError('Message nonce must fit in an unsigned 64-bit integer.');
-      }
-
-      if (content) {
-        if (split && typeof split !== 'object') split = {};
-
-        // Wrap everything in a code block
-        if (typeof code !== 'undefined' && (typeof code !== 'boolean' || code === true)) {
-          content = Util.escapeMarkdown(this.client.resolver.resolveString(content), true);
-          content = `\`\`\`${typeof code !== 'boolean' ? code || '' : ''}\n${content}\n\`\`\``;
-          if (split) {
-            split.prepend = `\`\`\`${typeof code !== 'boolean' ? code || '' : ''}\n`;
-            split.append = '\n```';
-          }
-        }
-
-        // Add zero-width spaces to @everyone/@here
-        if (disableEveryone || (typeof disableEveryone === 'undefined' && this.client.options.disableEveryone)) {
-          content = content.replace(/@(everyone|here)/g, '@\u200b$1');
-        }
-
-        // Add the reply prefix
-        if (reply && !(channel instanceof User || channel instanceof GuildMember) && channel.type !== 'dm') {
-          const id = this.client.resolver.resolveUserID(reply);
-          const mention = `<@${reply instanceof GuildMember && reply.nickname ? '!' : ''}${id}>`;
-          content = `${mention}${content ? `, ${content}` : ''}`;
-          if (split) split.prepend = `${mention}, ${split.prepend || ''}`;
-        }
-
-        // Split the content
-        if (split) content = Util.splitMessage(content, split);
-      } else if (reply && !(channel instanceof User || channel instanceof GuildMember) && channel.type !== 'dm') {
-        const id = this.client.resolver.resolveUserID(reply);
-        content = `<@${reply instanceof GuildMember && reply.nickname ? '!' : ''}${id}>`;
-      }
-
-      const send = chan => {
-        if (content instanceof Array) {
-          const messages = [];
-          (function sendChunk(list, index) {
-            const options = index === list.length - 1 ? { tts, embed, files } : { tts };
-            chan.send(list[index], options).then(message => {
-              messages.push(message);
-              if (index >= list.length - 1) return resolve(messages);
-              return sendChunk(list, ++index);
-            }).catch(reject);
-          }(content, 0));
-        } else {
-          this.rest.makeRequest('post', Endpoints.Channel(chan).messages, true, {
-            content, tts, nonce, embed,
-          }, files).then(data => resolve(this.client.actions.MessageCreate.handle(data).message), reject);
-        }
-      };
-
-      if (channel instanceof User || channel instanceof GuildMember) this.createDM(channel).then(send, reject);
-      else send(channel);
-    });
-  }
-
-  updateMessage(message, content, { embed, code, reply } = {}) {
-    if (typeof content !== 'undefined') content = this.client.resolver.resolveString(content);
-
-    // Wrap everything in a code block
-    if (typeof code !== 'undefined' && (typeof code !== 'boolean' || code === true)) {
-      content = Util.escapeMarkdown(this.client.resolver.resolveString(content), true);
-      content = `\`\`\`${typeof code !== 'boolean' ? code || '' : ''}\n${content}\n\`\`\``;
-    }
-
-    // Add the reply prefix
-    if (reply && message.channel.type !== 'dm') {
-      const id = this.client.resolver.resolveUserID(reply);
-      const mention = `<@${reply instanceof GuildMember && reply.nickname ? '!' : ''}${id}>`;
-      content = `${mention}${content ? `, ${content}` : ''}`;
-    }
-
-    return this.rest.makeRequest('patch', Endpoints.Message(message), true, {
-      content, embed,
-    }).then(data => this.client.actions.MessageUpdate.handle(data).updated);
-  }
-
-  deleteMessage(message) {
-    return this.rest.makeRequest('delete', Endpoints.Message(message), true)
-      .then(() =>
-        this.client.actions.MessageDelete.handle({
-          id: message.id,
-          channel_id: message.channel.id,
-        }).message
-      );
-  }
-
-  ackMessage(message) {
-    return this.rest.makeRequest('post', Endpoints.Message(message).ack, true, { token: this._ackToken }).then(res => {
-      if (res.token) this._ackToken = res.token;
-      return message;
-    });
-  }
-
-  ackTextChannel(channel) {
-    return this.rest.makeRequest('post', Endpoints.Channel(channel).Message(channel.lastMessageID).ack, true, {
-      token: this._ackToken,
-    }).then(res => {
-      if (res.token) this._ackToken = res.token;
-      return channel;
-    });
-  }
-
-  ackGuild(guild) {
-    return this.rest.makeRequest('post', Endpoints.Guild(guild).ack, true).then(() => guild);
-  }
-
-  bulkDeleteMessages(channel, messages) {
-    return this.rest.makeRequest('post', Endpoints.Channel(channel).messages.bulkDelete, true, {
-      messages: messages.map(m => m.id),
-    }).then(() =>
-      this.client.actions.MessageDeleteBulk.handle({
-        channel_id: channel.id,
-        messages,
-      }).messages
-    );
-  }
-
-  search(target, options) {
-    if (typeof options === 'string') options = { content: options };
-    if (options.before) {
-      if (!(options.before instanceof Date)) options.before = new Date(options.before);
-      options.maxID = long.fromNumber(options.before.getTime() - 14200704e5).shiftLeft(22).toString();
-    }
-    if (options.after) {
-      if (!(options.after instanceof Date)) options.after = new Date(options.after);
-      options.minID = long.fromNumber(options.after.getTime() - 14200704e5).shiftLeft(22).toString();
-    }
-    if (options.during) {
-      if (!(options.during instanceof Date)) options.during = new Date(options.during);
-      const t = options.during.getTime() - 14200704e5;
-      options.minID = long.fromNumber(t).shiftLeft(22).toString();
-      options.maxID = long.fromNumber(t + 86400000).shiftLeft(22).toString();
-    }
-    if (options.channel) options.channel = this.client.resolver.resolveChannelID(options.channel);
-    if (options.author) options.author = this.client.resolver.resolveUserID(options.author);
-    if (options.mentions) options.mentions = this.client.resolver.resolveUserID(options.options.mentions);
-    options = {
-      content: options.content,
-      max_id: options.maxID,
-      min_id: options.minID,
-      has: options.has,
-      channel_id: options.channel,
-      author_id: options.author,
-      author_type: options.authorType,
-      context_size: options.contextSize,
-      sort_by: options.sortBy,
-      sort_order: options.sortOrder,
-      limit: options.limit,
-      offset: options.offset,
-      mentions: options.mentions,
-      mentions_everyone: options.mentionsEveryone,
-      link_hostname: options.linkHostname,
-      embed_provider: options.embedProvider,
-      embed_type: options.embedType,
-      attachment_filename: options.attachmentFilename,
-      attachment_extension: options.attachmentExtension,
-      include_nsfw: options.nsfw,
-    };
-
-    for (const key in options) if (options[key] === undefined) delete options[key];
-    const queryString = (querystring.stringify(options).match(/[^=&?]+=[^=&?]+/g) || []).join('&');
-
-    let endpoint;
-    if (target instanceof Channel) {
-      endpoint = Endpoints.Channel(target).search;
-    } else if (target instanceof Guild) {
-      endpoint = Endpoints.Guild(target).search;
-    } else {
-      throw new TypeError('Target must be a TextChannel, DMChannel, GroupDMChannel, or Guild.');
-    }
-    return this.rest.makeRequest('get', `${endpoint}?${queryString}`, true).then(body => {
-      const messages = body.messages.map(x =>
-        x.map(m => new Message(this.client.channels.get(m.channel_id), m, this.client))
-      );
-      return {
-        totalResults: body.total_results,
-        messages,
-      };
-    });
-  }
-
-  createChannel(guild, channelName, channelType, overwrites, reason) {
-    if (overwrites instanceof Collection || overwrites instanceof Array) {
-      overwrites = overwrites.map(overwrite => {
-        let allow = overwrite.allow || overwrite._allowed;
-        let deny = overwrite.deny || overwrite._denied;
-        if (allow instanceof Array) allow = Permissions.resolve(allow);
-        if (deny instanceof Array) deny = Permissions.resolve(deny);
-
-        const role = this.client.resolver.resolveRole(guild, overwrite.id);
-        if (role) {
-          overwrite.id = role.id;
-          overwrite.type = 'role';
-        } else {
-          overwrite.id = this.client.resolver.resolveUserID(overwrite.id);
-          overwrite.type = 'member';
-        }
-
-        return {
-          allow,
-          deny,
-          type: overwrite.type,
-          id: overwrite.id,
-        };
-      });
-    }
-    return this.rest.makeRequest('post', Endpoints.Guild(guild).channels, true, {
-      name: channelName,
-      type: channelType ? Constants.ChannelTypes[channelType.toUpperCase()] : 'text',
-      permission_overwrites: overwrites,
-    }, undefined, reason).then(data => this.client.actions.ChannelCreate.handle(data).channel);
-  }
-
-  createDM(recipient) {
-    const dmChannel = this.getExistingDM(recipient);
-    if (dmChannel) return Promise.resolve(dmChannel);
-    return this.rest.makeRequest('post', Endpoints.User(this.client.user).channels, true, {
-      recipient_id: recipient.id,
-    }).then(data => this.client.actions.ChannelCreate.handle(data).channel);
-  }
-
-  createGroupDM(options) {
-    const data = this.client.user.bot ?
-      { access_tokens: options.accessTokens, nicks: options.nicks } :
-      { recipients: options.recipients };
-    return this.rest.makeRequest('post', Endpoints.User('@me').channels, true, data)
-      .then(res => new GroupDMChannel(this.client, res));
-  }
-
-  addUserToGroupDM(channel, options) {
-    const data = this.client.user.bot ?
-      { nick: options.nick, access_token: options.accessToken } :
-      { recipient: options.id };
-    return this.rest.makeRequest('put', Endpoints.Channel(channel).Recipient(options.id), true, data)
-      .then(() => channel);
-  }
-
-  removeUserFromGroupDM(channel, userId) {
-    return this.rest.makeRequest('delete', Endpoints.Channel(channel).Recipient(userId), true)
-      .then(() => channel);
-  }
-
-  updateGroupDMChannel(channel, _data) {
-    const data = {};
-    data.name = _data.name;
-    data.icon = _data.icon;
-    return this.rest.makeRequest('patch', Endpoints.Channel(channel), true, data).then(() => channel);
-  }
-
-  getExistingDM(recipient) {
-    return this.client.channels.find(channel =>
-      channel.recipient && channel.recipient.id === recipient.id
-    );
-  }
-
-  deleteChannel(channel, reason) {
-    if (channel instanceof User || channel instanceof GuildMember) channel = this.getExistingDM(channel);
-    if (!channel) return Promise.reject(new Error('No channel to delete.'));
-    return this.rest.makeRequest('delete', Endpoints.Channel(channel), true, undefined, undefined, reason)
-      .then(data => {
-        data.id = channel.id;
-        return this.client.actions.ChannelDelete.handle(data).channel;
-      });
-  }
-
-  updateChannel(channel, _data, reason) {
-    const data = {};
-    data.name = (_data.name || channel.name).trim();
-    data.topic = _data.topic || channel.topic;
-    data.position = _data.position || channel.position;
-    data.bitrate = _data.bitrate || (channel.bitrate ? channel.bitrate * 1000 : undefined);
-    data.user_limit = typeof _data.userLimit !== 'undefined' ? _data.userLimit : channel.userLimit;
-    data.parent_id = _data.parent || (channel.parent ? channel.parent.id : undefined);
-    return this.rest.makeRequest('patch', Endpoints.Channel(channel), true, data, undefined, reason).then(newData =>
-      this.client.actions.ChannelUpdate.handle(newData).updated
-    );
-  }
-
-  leaveGuild(guild) {
-    if (guild.ownerID === this.client.user.id) return Promise.reject(new Error('Guild is owned by the client.'));
-    return this.rest.makeRequest('delete', Endpoints.User('@me').Guild(guild.id), true).then(() =>
-      this.client.actions.GuildDelete.handle({ id: guild.id }).guild
-    );
-  }
-
-  createGuild(options) {
-    options.icon = this.client.resolver.resolveBase64(options.icon) || null;
-    options.region = options.region || 'us-central';
-    return new Promise((resolve, reject) => {
-      this.rest.makeRequest('post', Endpoints.guilds, true, options).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(Constants.Events.GUILD_CREATE, handleGuild);
-            this.client.clearTimeout(timeout);
-            resolve(guild);
-          }
-        };
-        this.client.on(Constants.Events.GUILD_CREATE, handleGuild);
-
-        const timeout = this.client.setTimeout(() => {
-          this.client.removeListener(Constants.Events.GUILD_CREATE, handleGuild);
-          reject(new Error('Took too long to receive guild data.'));
-        }, 10000);
-        return undefined;
-      }, reject);
-    });
-  }
-
-  // Untested but probably will work
-  deleteGuild(guild) {
-    return this.rest.makeRequest('delete', Endpoints.Guild(guild), true).then(() =>
-      this.client.actions.GuildDelete.handle({ id: guild.id }).guild
-    );
-  }
-
-  getUser(userID, cache) {
-    return this.rest.makeRequest('get', Endpoints.User(userID), true).then(data => {
-      if (cache) return this.client.actions.UserGet.handle(data).user;
-      else return new User(this.client, data);
-    });
-  }
-
-  updateCurrentUser(_data, password) {
-    const user = this.client.user;
-    const data = {};
-    data.username = _data.username || user.username;
-    data.avatar = typeof _data.avatar === 'undefined' ? user.avatar : this.client.resolver.resolveBase64(_data.avatar);
-    if (!user.bot) {
-      data.email = _data.email || user.email;
-      data.password = password;
-      if (_data.new_password) data.new_password = _data.newPassword;
-    }
-    return this.rest.makeRequest('patch', Endpoints.User('@me'), true, data).then(newData =>
-      this.client.actions.UserUpdate.handle(newData).updated
-    );
-  }
-
-  updateGuild(guild, data, reason) {
-    return this.rest.makeRequest('patch', Endpoints.Guild(guild), true, data, undefined, reason).then(newData =>
-      this.client.actions.GuildUpdate.handle(newData).updated
-    );
-  }
-
-  kickGuildMember(guild, member, reason) {
-    return this.rest.makeRequest(
-      'delete', Endpoints.Guild(guild).Member(member), true,
-      undefined, undefined, reason)
-      .then(() =>
-        this.client.actions.GuildMemberRemove.handle({
-          guild_id: guild.id,
-          user: member.user,
-        }).member
-      );
-  }
-
-  createGuildRole(guild, data, reason) {
-    if (data.color) data.color = this.client.resolver.resolveColor(data.color);
-    if (data.permissions) data.permissions = Permissions.resolve(data.permissions);
-    return this.rest.makeRequest('post', Endpoints.Guild(guild).roles, true, data, undefined, reason).then(r => {
-      const { role } = this.client.actions.GuildRoleCreate.handle({
-        guild_id: guild.id,
-        role: r,
-      });
-      if (data.position) return role.setPosition(data.position, reason);
-      return role;
-    });
-  }
-
-  deleteGuildRole(role, reason) {
-    return this.rest.makeRequest(
-      'delete', Endpoints.Guild(role.guild).Role(role.id), true,
-      undefined, undefined, reason)
-      .then(() =>
-        this.client.actions.GuildRoleDelete.handle({
-          guild_id: role.guild.id,
-          role_id: role.id,
-        }).role
-      );
-  }
-
-  setChannelOverwrite(channel, payload) {
-    return this.rest.makeRequest('put', `${Endpoints.Channel(channel).permissions}/${payload.id}`, true, payload);
-  }
-
-  deletePermissionOverwrites(overwrite, reason) {
-    return this.rest.makeRequest(
-      'delete', `${Endpoints.Channel(overwrite.channel).permissions}/${overwrite.id}`,
-      true, undefined, undefined, reason
-    ).then(() => overwrite);
-  }
-
-  getChannelMessages(channel, payload = {}) {
-    const params = [];
-    if (payload.limit) params.push(`limit=${payload.limit}`);
-    if (payload.around) params.push(`around=${payload.around}`);
-    else if (payload.before) params.push(`before=${payload.before}`);
-    else if (payload.after) params.push(`after=${payload.after}`);
-
-    let endpoint = Endpoints.Channel(channel).messages;
-    if (params.length > 0) endpoint += `?${params.join('&')}`;
-    return this.rest.makeRequest('get', endpoint, true);
-  }
-
-  getChannelMessage(channel, messageID) {
-    const msg = channel.messages.get(messageID);
-    if (msg) return Promise.resolve(msg);
-    return this.rest.makeRequest('get', Endpoints.Channel(channel).Message(messageID), true);
-  }
-
-  putGuildMember(guild, user, options) {
-    options.access_token = options.accessToken;
-    if (options.roles) {
-      const roles = options.roles;
-      if (roles instanceof Collection || (roles instanceof Array && roles[0] instanceof Role)) {
-        options.roles = roles.map(role => role.id);
-      }
-    }
-    return this.rest.makeRequest('put', Endpoints.Guild(guild).Member(user.id), true, options)
-      .then(data => this.client.actions.GuildMemberGet.handle(guild, data).member);
-  }
-
-  getGuildMember(guild, user, cache) {
-    return this.rest.makeRequest('get', Endpoints.Guild(guild).Member(user.id), true).then(data => {
-      if (cache) return this.client.actions.GuildMemberGet.handle(guild, data).member;
-      else return new GuildMember(guild, data);
-    });
-  }
-
-  updateGuildMember(member, data, reason) {
-    if (data.channel) {
-      data.channel_id = this.client.resolver.resolveChannel(data.channel).id;
-      data.channel = null;
-    }
-    if (data.roles) data.roles = data.roles.map(role => role instanceof Role ? role.id : role);
-
-    let endpoint = Endpoints.Member(member);
-    // Fix your endpoints, discord ;-;
-    if (member.id === this.client.user.id) {
-      const keys = Object.keys(data);
-      if (keys.length === 1 && keys[0] === 'nick') {
-        endpoint = Endpoints.Member(member).nickname;
-      }
-    }
-
-    return this.rest.makeRequest('patch', endpoint, true, data, undefined, reason).then(newData =>
-      member.guild._updateMember(member, newData).mem
-    );
-  }
-
-  addMemberRole(member, role, reason) {
-    return new Promise((resolve, reject) => {
-      if (member._roles.includes(role.id)) return resolve(member);
-
-      const listener = (oldMember, newMember) => {
-        if (!oldMember._roles.includes(role.id) && newMember._roles.includes(role.id)) {
-          this.client.removeListener(Constants.Events.GUILD_MEMBER_UPDATE, listener);
-          resolve(newMember);
-        }
-      };
-
-      this.client.on(Constants.Events.GUILD_MEMBER_UPDATE, listener);
-      const timeout = this.client.setTimeout(() =>
-        this.client.removeListener(Constants.Events.GUILD_MEMBER_UPDATE, listener), 10e3);
-
-      return this.rest.makeRequest('put', Endpoints.Member(member).Role(role.id), true, undefined, undefined, reason)
-        .catch(err => {
-          this.client.removeListener(Constants.Events.GUILD_BAN_REMOVE, listener);
-          this.client.clearTimeout(timeout);
-          reject(err);
-        });
-    });
-  }
-
-  removeMemberRole(member, role, reason) {
-    return new Promise((resolve, reject) => {
-      if (!member._roles.includes(role.id)) return resolve(member);
-
-      const listener = (oldMember, newMember) => {
-        if (oldMember._roles.includes(role.id) && !newMember._roles.includes(role.id)) {
-          this.client.removeListener(Constants.Events.GUILD_MEMBER_UPDATE, listener);
-          resolve(newMember);
-        }
-      };
-
-      this.client.on(Constants.Events.GUILD_MEMBER_UPDATE, listener);
-      const timeout = this.client.setTimeout(() =>
-        this.client.removeListener(Constants.Events.GUILD_MEMBER_UPDATE, listener), 10e3);
-
-      return this.rest.makeRequest('delete', Endpoints.Member(member).Role(role.id), true, undefined, undefined, reason)
-        .catch(err => {
-          this.client.removeListener(Constants.Events.GUILD_BAN_REMOVE, listener);
-          this.client.clearTimeout(timeout);
-          reject(err);
-        });
-    });
-  }
-
-  sendTyping(channelID) {
-    return this.rest.makeRequest('post', Endpoints.Channel(channelID).typing, true);
-  }
-
-  banGuildMember(guild, member, options) {
-    const id = this.client.resolver.resolveUserID(member);
-    if (!id) return Promise.reject(new Error('Couldn\'t resolve the user ID to ban.'));
-
-    const url = `${Endpoints.Guild(guild).bans}/${id}?${querystring.stringify(options)}`;
-    return this.rest.makeRequest('put', url, true).then(() => {
-      if (member instanceof GuildMember) return member;
-      const user = this.client.resolver.resolveUser(id);
-      if (user) {
-        member = this.client.resolver.resolveGuildMember(guild, user);
-        return member || user;
-      }
-      return id;
-    });
-  }
-
-  unbanGuildMember(guild, member, reason) {
-    return new Promise((resolve, reject) => {
-      const id = this.client.resolver.resolveUserID(member);
-      if (!id) throw new Error('Couldn\'t resolve the user ID to unban.');
-
-      const listener = (eGuild, eUser) => {
-        if (eGuild.id === guild.id && eUser.id === id) {
-          this.client.removeListener(Constants.Events.GUILD_BAN_REMOVE, listener);
-          this.client.clearTimeout(timeout);
-          resolve(eUser);
-        }
-      };
-      this.client.on(Constants.Events.GUILD_BAN_REMOVE, listener);
-
-      const timeout = this.client.setTimeout(() => {
-        this.client.removeListener(Constants.Events.GUILD_BAN_REMOVE, listener);
-        reject(new Error('Took too long to receive the ban remove event.'));
-      }, 10000);
-
-      this.rest.makeRequest('delete', `${Endpoints.Guild(guild).bans}/${id}`, true, undefined, undefined, reason)
-        .catch(err => {
-          this.client.removeListener(Constants.Events.GUILD_BAN_REMOVE, listener);
-          this.client.clearTimeout(timeout);
-          reject(err);
-        });
-    });
-  }
-
-  getGuildBans(guild) {
-    return this.rest.makeRequest('get', Endpoints.Guild(guild).bans, true).then(bans =>
-      bans.reduce((collection, ban) => {
-        collection.set(ban.user.id, {
-          reason: ban.reason,
-          user: this.client.dataManager.newUser(ban.user),
-        });
-        return collection;
-      }, new Collection())
-    );
-  }
-
-  updateGuildRole(role, _data, reason) {
-    const data = {};
-    data.name = _data.name || role.name;
-    data.position = typeof _data.position !== 'undefined' ? _data.position : role.position;
-    data.color = this.client.resolver.resolveColor(_data.color || role.color);
-    data.hoist = typeof _data.hoist !== 'undefined' ? _data.hoist : role.hoist;
-    data.mentionable = typeof _data.mentionable !== 'undefined' ? _data.mentionable : role.mentionable;
-
-    if (_data.permissions) data.permissions = Permissions.resolve(_data.permissions);
-    else data.permissions = role.permissions;
-
-    return this.rest.makeRequest('patch', Endpoints.Guild(role.guild).Role(role.id), true, data, undefined, reason)
-      .then(_role =>
-        this.client.actions.GuildRoleUpdate.handle({
-          role: _role,
-          guild_id: role.guild.id,
-        }).updated
-      );
-  }
-
-  pinMessage(message) {
-    return this.rest.makeRequest('put', Endpoints.Channel(message.channel).Pin(message.id), true)
-      .then(() => message);
-  }
-
-  unpinMessage(message) {
-    return this.rest.makeRequest('delete', Endpoints.Channel(message.channel).Pin(message.id), true)
-      .then(() => message);
-  }
-
-  getChannelPinnedMessages(channel) {
-    return this.rest.makeRequest('get', Endpoints.Channel(channel).pins, true);
-  }
-
-  createChannelInvite(channel, options, reason) {
-    const payload = {};
-    payload.temporary = options.temporary;
-    payload.max_age = options.maxAge;
-    payload.max_uses = options.maxUses;
-    payload.unique = options.unique;
-    return this.rest.makeRequest('post', Endpoints.Channel(channel).invites, true, payload, undefined, reason)
-      .then(invite => new Invite(this.client, invite));
-  }
-
-  deleteInvite(invite, reason) {
-    return this.rest.makeRequest('delete', Endpoints.Invite(invite.code), true, undefined, undefined, reason)
-      .then(() => invite);
-  }
-
-  getInvite(code) {
-    return this.rest.makeRequest('get', Endpoints.Invite(code), true).then(invite =>
-      new Invite(this.client, invite)
-    );
-  }
-
-  getGuildInvites(guild) {
-    return this.rest.makeRequest('get', Endpoints.Guild(guild).invites, true).then(inviteItems => {
-      const invites = new Collection();
-      for (const inviteItem of inviteItems) {
-        const invite = new Invite(this.client, inviteItem);
-        invites.set(invite.code, invite);
-      }
-      return invites;
-    });
-  }
-
-  pruneGuildMembers(guild, days, dry, reason) {
-    return this.rest.makeRequest(dry ?
-      'get' :
-      'post',
-    `${Endpoints.Guild(guild).prune}?days=${days}`, true, undefined, undefined, reason)
-      .then(data => data.pruned);
-  }
-
-  createEmoji(guild, image, name, roles, reason) {
-    const data = { image, name };
-    if (roles) data.roles = roles.map(r => r.id ? r.id : r);
-    return this.rest.makeRequest('post', Endpoints.Guild(guild).emojis, true, data, undefined, reason)
-      .then(emoji => this.client.actions.GuildEmojiCreate.handle(guild, emoji).emoji);
-  }
-
-  updateEmoji(emoji, _data, reason) {
-    const data = {};
-    if (_data.name) data.name = _data.name;
-    if (_data.roles) data.roles = _data.roles.map(r => r.id ? r.id : r);
-    return this.rest.makeRequest('patch', Endpoints.Guild(emoji.guild).Emoji(emoji.id), true, data, undefined, reason)
-      .then(newEmoji => this.client.actions.GuildEmojiUpdate.handle(emoji, newEmoji).emoji);
-  }
-
-  deleteEmoji(emoji, reason) {
-    return this.rest.makeRequest('delete', Endpoints.Guild(emoji.guild).Emoji(emoji.id), true, undefined, reason)
-      .then(() => this.client.actions.GuildEmojiDelete.handle(emoji).data);
-  }
-
-  getGuildAuditLogs(guild, 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];
-
-    const queryString = (querystring.stringify({
-      before: options.before,
-      after: options.after,
-      limit: options.limit,
-      user_id: this.client.resolver.resolveUserID(options.user),
-      action_type: options.type,
-    }).match(/[^=&?]+=[^=&?]+/g) || []).join('&');
-
-    return this.rest.makeRequest('get', `${Endpoints.Guild(guild).auditLogs}?${queryString}`, true)
-      .then(data => GuildAuditLogs.build(guild, data));
-  }
-
-  getWebhook(id, token) {
-    return this.rest.makeRequest('get', Endpoints.Webhook(id, token), !token).then(data =>
-      new Webhook(this.client, data)
-    );
-  }
-
-  getGuildWebhooks(guild) {
-    return this.rest.makeRequest('get', Endpoints.Guild(guild).webhooks, true).then(data => {
-      const hooks = new Collection();
-      for (const hook of data) hooks.set(hook.id, new Webhook(this.client, hook));
-      return hooks;
-    });
-  }
-
-  getChannelWebhooks(channel) {
-    return this.rest.makeRequest('get', Endpoints.Channel(channel).webhooks, true).then(data => {
-      const hooks = new Collection();
-      for (const hook of data) hooks.set(hook.id, new Webhook(this.client, hook));
-      return hooks;
-    });
-  }
-
-  createWebhook(channel, name, avatar, reason) {
-    return this.rest.makeRequest('post', Endpoints.Channel(channel).webhooks, true, { name, avatar }, undefined, reason)
-      .then(data => new Webhook(this.client, data));
-  }
-
-  editWebhook(webhook, name, avatar) {
-    return this.rest.makeRequest('patch', Endpoints.Webhook(webhook.id, webhook.token), false, {
-      name,
-      avatar,
-    }).then(data => {
-      webhook.name = data.name;
-      webhook.avatar = data.avatar;
-      return webhook;
-    });
-  }
-
-  deleteWebhook(webhook, reason) {
-    return this.rest.makeRequest(
-      'delete', Endpoints.Webhook(webhook.id, webhook.token),
-      false, undefined, undefined, reason);
-  }
-
-  sendWebhookMessage(webhook, content, { avatarURL, tts, embeds, username } = {}, files = null) {
-    return new Promise((resolve, reject) => {
-      username = username || webhook.name;
-
-      if (content instanceof Array) {
-        const messages = [];
-        (function sendChunk(list, index) {
-          const options = index === list.length - 1 ? { tts, embeds, files } : { tts };
-          webhook.send(list[index], options).then(message => {
-            messages.push(message);
-            if (index >= list.length - 1) return resolve(messages);
-            return sendChunk(list, ++index);
-          }).catch(reject);
-        }(content, 0));
-      } else {
-        this.rest.makeRequest('post', `${Endpoints.Webhook(webhook.id, webhook.token)}?wait=true`, false, {
-          username,
-          avatar_url: avatarURL,
-          content,
-          tts,
-          embeds,
-        }, files).then(data => {
-          if (!this.client.channels) resolve(data);
-          else resolve(this.client.actions.MessageCreate.handle(data).message);
-        }, reject);
-      }
-    });
-  }
-
-  sendSlackWebhookMessage(webhook, body) {
-    return this.rest.makeRequest(
-      'post', `${Endpoints.Webhook(webhook.id, webhook.token)}/slack?wait=true`, false, body
-    );
-  }
-
-  fetchUserProfile(user) {
-    return this.rest.makeRequest('get', Endpoints.User(user).profile, true).then(data =>
-      new UserProfile(user, data)
-    );
-  }
-
-  fetchMentions(options) {
-    if (options.guild instanceof Guild) options.guild = options.guild.id;
-    Util.mergeDefault({ limit: 25, roles: true, everyone: true, guild: null }, options);
-
-    return this.rest.makeRequest(
-      'get', Endpoints.User('@me').Mentions(options.limit, options.roles, options.everyone, options.guild), true
-    ).then(data => data.map(m => new Message(this.client.channels.get(m.channel_id), m, this.client)));
-  }
-
-  addFriend(user) {
-    return this.rest.makeRequest('post', Endpoints.User('@me'), true, {
-      username: user.username,
-      discriminator: user.discriminator,
-    }).then(() => user);
-  }
-
-  removeFriend(user) {
-    return this.rest.makeRequest('delete', Endpoints.User('@me').Relationship(user.id), true)
-      .then(() => user);
-  }
-
-  blockUser(user) {
-    return this.rest.makeRequest('put', Endpoints.User('@me').Relationship(user.id), true, { type: 2 })
-      .then(() => user);
-  }
-
-  unblockUser(user) {
-    return this.rest.makeRequest('delete', Endpoints.User('@me').Relationship(user.id), true)
-      .then(() => user);
-  }
-
-  updateChannelPositions(guildID, channels) {
-    const data = new Array(channels.length);
-    for (let i = 0; i < channels.length; i++) {
-      data[i] = {
-        id: this.client.resolver.resolveChannelID(channels[i].channel),
-        position: channels[i].position,
-      };
-    }
-
-    return this.rest.makeRequest('patch', Endpoints.Guild(guildID).channels, true, data).then(() =>
-      this.client.actions.GuildChannelsPositionUpdate.handle({
-        guild_id: guildID,
-        channels,
-      }).guild
-    );
-  }
-
-  setRolePositions(guildID, roles) {
-    return this.rest.makeRequest('patch', Endpoints.Guild(guildID).roles, true, roles).then(() =>
-      this.client.actions.GuildRolesPositionUpdate.handle({
-        guild_id: guildID,
-        roles,
-      }).guild
-    );
-  }
-
-  setChannelPositions(guildID, channels) {
-    return this.rest.makeRequest('patch', Endpoints.Guild(guildID).channels, true, channels).then(() =>
-      this.client.actions.GuildChannelsPositionUpdate.handle({
-        guild_id: guildID,
-        channels,
-      }).guild
-    );
-  }
-
-  addMessageReaction(message, emoji) {
-    return this.rest.makeRequest(
-      'put', Endpoints.Message(message).Reaction(emoji).User('@me'), true
-    ).then(() =>
-      message._addReaction(Util.parseEmoji(emoji), message.client.user)
-    );
-  }
-
-  removeMessageReaction(message, emoji, userID) {
-    const endpoint = Endpoints.Message(message).Reaction(emoji).User(userID === this.client.user.id ? '@me' : userID);
-    return this.rest.makeRequest('delete', endpoint, true).then(() =>
-      this.client.actions.MessageReactionRemove.handle({
-        user_id: userID,
-        message_id: message.id,
-        emoji: Util.parseEmoji(emoji),
-        channel_id: message.channel.id,
-      }).reaction
-    );
-  }
-
-  removeMessageReactions(message) {
-    return this.rest.makeRequest('delete', Endpoints.Message(message).reactions, true)
-      .then(() => message);
-  }
-
-  getMessageReactionUsers(message, emoji, options) {
-    const queryString = (querystring.stringify(options).match(/[^=&?]+=[^=&?]+/g) || []).join('&');
-
-    return this.rest.makeRequest('get', `${Endpoints.Message(message).Reaction(emoji)}?${queryString}`, true);
-  }
-
-  getApplication(id) {
-    return this.rest.makeRequest('get', Endpoints.OAUTH2.Application(id), true).then(app =>
-      new OAuth2Application(this.client, app)
-    );
-  }
-
-  resetApplication(id) {
-    return this.rest.makeRequest('post', Endpoints.OAUTH2.Application(id).resetToken, true)
-      .then(() => this.rest.makeRequest('post', Endpoints.OAUTH2.Application(id).resetSecret, true))
-      .then(app => new OAuth2Application(this.client, app));
-  }
-
-  setNote(user, note) {
-    return this.rest.makeRequest('put', Endpoints.User(user).note, true, { note }).then(() => user);
-  }
-
-  acceptInvite(code) {
-    if (code.id) code = code.id;
-    return new Promise((resolve, reject) =>
-      this.rest.makeRequest('post', Endpoints.Invite(code), true).then(res => {
-        const handler = guild => {
-          if (guild.id === res.id) {
-            resolve(guild);
-            this.client.removeListener(Constants.Events.GUILD_CREATE, handler);
-          }
-        };
-        this.client.on(Constants.Events.GUILD_CREATE, handler);
-        this.client.setTimeout(() => {
-          this.client.removeListener(Constants.Events.GUILD_CREATE, handler);
-          reject(new Error('Accepting invite timed out'));
-        }, 120e3);
-      })
-    );
-  }
-
-  patchUserSettings(data) {
-    return this.rest.makeRequest('patch', Constants.Endpoints.User('@me').settings, true, data);
-  }
-
-  patchClientUserGuildSettings(guildID, data) {
-    return this.rest.makeRequest('patch', Constants.Endpoints.User('@me').Guild(guildID).settings, true, data);
-  }
-}
-
-module.exports = RESTMethods;

src/client/rest/RequestHandlers/Burst.js

@@ -1,71 +0,0 @@
-const RequestHandler = require('./RequestHandler');
-const DiscordAPIError = require('../DiscordAPIError');
-
-class BurstRequestHandler extends RequestHandler {
-  constructor(restManager, endpoint) {
-    super(restManager, endpoint);
-
-    this.client = restManager.client;
-
-    this.limit = Infinity;
-    this.resetTime = null;
-    this.remaining = 1;
-    this.timeDifference = 0;
-
-    this.resetTimeout = null;
-  }
-
-  push(request) {
-    super.push(request);
-    this.handle();
-  }
-
-  execute(item) {
-    if (!item) return;
-    item.request.gen().end((err, res) => {
-      if (res && res.headers) {
-        this.limit = Number(res.headers['x-ratelimit-limit']);
-        this.resetTime = Number(res.headers['x-ratelimit-reset']) * 1000;
-        this.remaining = Number(res.headers['x-ratelimit-remaining']);
-        this.timeDifference = Date.now() - new Date(res.headers.date).getTime();
-      }
-      if (err) {
-        if (err.status === 429) {
-          this.queue.unshift(item);
-          if (res.headers['x-ratelimit-global']) this.globalLimit = true;
-          if (this.resetTimeout) return;
-          this.resetTimeout = this.client.setTimeout(() => {
-            this.remaining = this.limit;
-            this.globalLimit = false;
-            this.handle();
-            this.resetTimeout = null;
-          }, Number(res.headers['retry-after']) + this.client.options.restTimeOffset);
-        } else if (err.status >= 500 && err.status < 600) {
-          this.queue.unshift(item);
-          this.resetTimeout = this.client.setTimeout(() => {
-            this.handle();
-            this.resetTimeout = null;
-          }, 1e3 + this.client.options.restTimeOffset);
-        } else {
-          item.reject(err.status >= 400 && err.status < 500 ? new DiscordAPIError(res.request.path, res.body) : err);
-          this.handle();
-        }
-      } else {
-        this.globalLimit = false;
-        const data = res && res.body ? res.body : {};
-        item.resolve(data);
-        this.handle();
-      }
-    });
-  }
-
-  handle() {
-    super.handle();
-    if (this.remaining <= 0 || this.queue.length === 0 || this.globalLimit) return;
-    this.execute(this.queue.shift());
-    this.remaining--;
-    this.handle();
-  }
-}
-
-module.exports = BurstRequestHandler;

src/client/rest/RequestHandlers/RequestHandler.js

@@ -1,54 +0,0 @@
-/**
- * A base class for different types of rate limiting handlers for the REST API.
- * @private
- */
-class RequestHandler {
-  /**
-   * @param {RESTManager} restManager The REST manager to use
-   */
-  constructor(restManager) {
-    /**
-     * The RESTManager that instantiated this RequestHandler
-     * @type {RESTManager}
-     */
-    this.restManager = restManager;
-
-    /**
-     * A list of requests that have yet to be processed
-     * @type {APIRequest[]}
-     */
-    this.queue = [];
-  }
-
-  /**
-   * Whether or not the client is being rate limited on every endpoint
-   * @type {boolean}
-   * @readonly
-   */
-  get globalLimit() {
-    return this.restManager.globallyRateLimited;
-  }
-
-  set globalLimit(value) {
-    this.restManager.globallyRateLimited = value;
-  }
-
-  /**
-   * Push a new API request into this bucket.
-   * @param {APIRequest} request The new request to push into the queue
-   */
-  push(request) {
-    this.queue.push(request);
-  }
-
-  /**
-   * Attempts to get this RequestHandler to process its current queue.
-   */
-  handle() {} // eslint-disable-line no-empty-function
-
-  destroy() {
-    this.queue = [];
-  }
-}
-
-module.exports = RequestHandler;

src/client/rest/RequestHandlers/Sequential.js

@@ -1,101 +0,0 @@
-const RequestHandler = require('./RequestHandler');
-const DiscordAPIError = require('../DiscordAPIError');
-
-/**
- * Handles API Requests sequentially, i.e. we wait until the current request is finished before moving onto
- * the next. This plays a _lot_ nicer in terms of avoiding 429's when there is more than one session of the account,
- * but it can be slower.
- * @extends {RequestHandler}
- * @private
- */
-class SequentialRequestHandler extends RequestHandler {
-  /**
-   * @param {RESTManager} restManager The REST manager to use
-   * @param {string} endpoint The endpoint to handle
-   */
-  constructor(restManager, endpoint) {
-    super(restManager, endpoint);
-
-    /**
-     * The endpoint that this handler is handling
-     * @type {string}
-     */
-    this.endpoint = endpoint;
-
-    /**
-     * The time difference between Discord's Dates and the local computer's Dates. A positive number means the local
-     * computer's time is ahead of Discord's
-     * @type {number}
-     */
-    this.timeDifference = 0;
-
-    /**
-     * Whether the queue is being processed or not
-     * @type {boolean}
-     */
-    this.busy = false;
-  }
-
-  push(request) {
-    super.push(request);
-    this.handle();
-  }
-
-  /**
-   * Performs a request then resolves a promise to indicate its readiness for a new request.
-   * @param {APIRequest} item The item to execute
-   * @returns {Promise<?Object|Error>}
-   */
-  execute(item) {
-    this.busy = true;
-    return new Promise(resolve => {
-      item.request.gen().end((err, res) => {
-        if (res && res.headers) {
-          this.requestLimit = Number(res.headers['x-ratelimit-limit']);
-          this.requestResetTime = Number(res.headers['x-ratelimit-reset']) * 1000;
-          this.requestRemaining = Number(res.headers['x-ratelimit-remaining']);
-          this.timeDifference = Date.now() - new Date(res.headers.date).getTime();
-        }
-        if (err) {
-          if (err.status === 429) {
-            this.queue.unshift(item);
-            this.restManager.client.setTimeout(() => {
-              this.globalLimit = false;
-              resolve();
-            }, Number(res.headers['retry-after']) + this.restManager.client.options.restTimeOffset);
-            if (res.headers['x-ratelimit-global']) this.globalLimit = true;
-          } else if (err.status >= 500 && err.status < 600) {
-            this.queue.unshift(item);
-            this.restManager.client.setTimeout(resolve, 1e3 + this.restManager.client.options.restTimeOffset);
-          } else {
-            item.reject(err.status >= 400 && err.status < 500 ? new DiscordAPIError(res.request.path, res.body) : err);
-            resolve(err);
-          }
-        } else {
-          this.globalLimit = false;
-          const data = res && res.body ? res.body : {};
-          item.resolve(data);
-          if (this.requestRemaining === 0) {
-            this.restManager.client.setTimeout(
-              () => resolve(data),
-              this.requestResetTime - Date.now() + this.timeDifference + this.restManager.client.options.restTimeOffset
-            );
-          } else {
-            resolve(data);
-          }
-        }
-      });
-    });
-  }
-
-  handle() {
-    super.handle();
-    if (this.busy || this.remaining === 0 || this.queue.length === 0 || this.globalLimit) return;
-    this.execute(this.queue.shift()).then(() => {
-      this.busy = false;
-      this.handle();
-    });
-  }
-}
-
-module.exports = SequentialRequestHandler;

src/client/rest/UserAgentManager.js

@@ -1,25 +0,0 @@
-const Constants = require('../../util/Constants');
-
-class UserAgentManager {
-  constructor() {
-    this.build(this.constructor.DEFAULT);
-  }
-
-  set({ url, version } = {}) {
-    this.build({
-      url: url || this.constructor.DFEAULT.url,
-      version: version || this.constructor.DEFAULT.version,
-    });
-  }
-
-  build(ua) {
-    this.userAgent = `DiscordBot (${ua.url}, ${ua.version}) Node.js/${process.version}`;
-  }
-}
-
-UserAgentManager.DEFAULT = {
-  url: Constants.Package.homepage.split('#')[0],
-  version: Constants.Package.version,
-};
-
-module.exports = UserAgentManager;

src/client/voice/ClientVoiceManager.js

@@ -1,17 +1,22 @@
-const Collection = require('../../util/Collection');
+'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
@@ -19,36 +24,52 @@ 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);
-    if (connection) {
-      connection.channel = this.client.channels.get(channel_id);
-      connection.setSessionID(session_id);
+    this.client.emit('debug', `[VOICE] connection? ${!!connection}, ${guild_id} ${session_id} ${channel_id}`);
+    if (!connection) return;
+    if (!channel_id) {
+      connection._disconnect();
+      this.connections.delete(guild_id);
+      return;
     }
+    connection.channel = this.client.channels.cache.get(channel_id);
+    connection.setSessionID(session_id);
   }
 
   /**
    * 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) => {
       if (!channel.joinable) {
-        if (channel.full) {
-          throw new Error('You do not have permission to join this voice channel; it is full.');
-        } else {
-          throw new Error('You do not have permission to join this voice channel.');
-        }
+        throw new Error('VOICE_JOIN_CHANNEL', channel.full);
       }
 
       let connection = this.connections.get(channel.guild.id);
@@ -61,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);
       }
 
@@ -69,9 +94,13 @@ class ClientVoiceManager {
         reject(reason);
       });
 
+      connection.on('error', reject);
+
       connection.once('authenticated', () => {
-        connection.once('ready', () => resolve(connection));
-        connection.once('error', reject);
+        connection.once('ready', () => {
+          resolve(connection);
+          connection.removeListener('error', reject);
+        });
         connection.once('disconnect', () => this.connections.delete(channel.guild.id));
       });
     });

src/client/voice/VoiceBroadcast.js

@@ -1,31 +1,26 @@
-const VolumeInterface = require('./util/VolumeInterface');
-const Prism = require('prism-media');
-const OpusEncoders = require('./opus/OpusEngineList');
-const Collection = require('../../util/Collection');
+'use strict';
 
-const ffmpegArguments = [
-  '-analyzeduration', '0',
-  '-loglevel', '0',
-  '-f', 's16le',
-  '-ar', '48000',
-  '-ac', '2',
-];
+const EventEmitter = require('events');
+const BroadcastAudioPlayer = require('./player/BroadcastAudioPlayer');
+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();
- * broadcast.playFile('./music.mp3');
+ * 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()) {
- *   connection.playBroadcast(broadcast);
+ * for (const connection of client.voice.connections.values()) {
+ *   connection.play(broadcast);
  * }
  * ```
- * @implements {VolumeInterface}
+ * @implements {PlayInterface}
+ * @extends {EventEmitter}
  */
-class VoiceBroadcast extends VolumeInterface {
+class VoiceBroadcast extends EventEmitter {
   constructor(client) {
     super();
     /**
@@ -33,334 +28,84 @@ class VoiceBroadcast extends VolumeInterface {
      * @type {Client}
      */
     this.client = client;
-    this._dispatchers = new Collection();
-    this._encoders = new Collection();
     /**
-     * The audio transcoder that this broadcast uses
-     * @type {Prism}
+     * The subscribed StreamDispatchers of this broadcast
+     * @type {StreamDispatcher[]}
      */
-    this.prism = new Prism();
-    /**
-     * The current audio transcoder that is being used
-     * @type {Object}
-     */
-    this.currentTranscoder = null;
-    this.tickInterval = null;
-    this._volume = 1;
+    this.subscribers = [];
+    this.player = new BroadcastAudioPlayer(this);
   }
 
   /**
-   * An array of subscribed dispatchers
-   * @type {StreamDispatcher[]}
+   * The current master dispatcher, if any. This dispatcher controls all that is played by subscribed dispatchers.
+   * @type {?BroadcastDispatcher}
    * @readonly
    */
-  get dispatchers() {
-    let d = [];
-    for (const container of this._dispatchers.values()) {
-      d = d.concat(Array.from(container.values()));
-    }
-    return d;
+  get dispatcher() {
+    return this.player.dispatcher;
   }
 
-  get _playableStream() {
-    const currentTranscoder = this.currentTranscoder;
-    if (!currentTranscoder) return null;
-    const transcoder = currentTranscoder.transcoder;
-    const options = currentTranscoder.options;
-    return (transcoder && transcoder.output) || options.stream;
+  /**
+   * Play an audio resource.
+   * @param {ReadableStream|string} resource The resource to play.
+   * @param {StreamOptions} [options] The options to play.
+   * @example
+   * // Play a local audio file
+   * broadcast.play('/home/hydrabolt/audio.mp3', { volume: 0.5 });
+   * @example
+   * // Play a ReadableStream
+   * broadcast.play(ytdl('https://www.youtube.com/watch?v=ZlAU_w7-Xp8', { filter: 'audioonly' }));
+   * @example
+   * // Using different protocols: https://ffmpeg.org/ffmpeg-protocols.html
+   * broadcast.play('http://www.sample-videos.com/audio/mp3/wave.mp3');
+   * @returns {BroadcastDispatcher}
+   */
+  play() {
+    return null;
   }
 
-  unregisterDispatcher(dispatcher, old) {
-    const volume = old || dispatcher.volume;
-
-    /**
-     * Emitted whenever a stream dispatcher unsubscribes from the broadcast.
-     * @event VoiceBroadcast#unsubscribe
-     * @param {StreamDispatcher} dispatcher The unsubscribed dispatcher
-     */
-    this.emit('unsubscribe', dispatcher);
-    for (const container of this._dispatchers.values()) {
-      container.delete(dispatcher);
-
-      if (!container.size) {
-        this._encoders.get(volume).destroy();
-        this._dispatchers.delete(volume);
-        this._encoders.delete(volume);
-      }
-    }
+  /**
+   * 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);
   }
 
-  registerDispatcher(dispatcher) {
-    if (!this._dispatchers.has(dispatcher.volume)) {
-      this._dispatchers.set(dispatcher.volume, new Set());
-      this._encoders.set(dispatcher.volume, OpusEncoders.fetch());
-    }
-    const container = this._dispatchers.get(dispatcher.volume);
-    if (!container.has(dispatcher)) {
-      container.add(dispatcher);
-      dispatcher.once('end', () => this.unregisterDispatcher(dispatcher));
-      dispatcher.on('volumeChange', (o, n) => {
-        this.unregisterDispatcher(dispatcher, o);
-        if (!this._dispatchers.has(n)) {
-          this._dispatchers.set(n, new Set());
-          this._encoders.set(n, OpusEncoders.fetch());
-        }
-        this._dispatchers.get(n).add(dispatcher);
-      });
+  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} dispatcher The subscribed dispatcher
+       * @param {StreamDispatcher} subscriber The subscribed dispatcher
        */
-      this.emit('subscribe', dispatcher);
+      this.emit(Events.VOICE_BROADCAST_SUBSCRIBE, dispatcher);
+      return true;
+    } else {
+      return false;
     }
   }
 
-  killCurrentTranscoder() {
-    if (this.currentTranscoder) {
-      if (this.currentTranscoder.transcoder) this.currentTranscoder.transcoder.kill();
-      this.currentTranscoder = null;
-      this.emit('end');
-    }
-  }
-
-  /**
-   * Plays any audio stream across the broadcast.
-   * @param {ReadableStream} stream The audio stream to play
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {VoiceBroadcast}
-   * @example
-   * // Play streams using ytdl-core
-   * const ytdl = require('ytdl-core');
-   * const streamOptions = { seek: 0, volume: 1 };
-   * const broadcast = client.createVoiceBroadcast();
-   *
-   * voiceChannel.join()
-   *   .then(connection => {
-   *     const stream = ytdl('https://www.youtube.com/watch?v=XAWgeLF9EVQ', { filter : 'audioonly' });
-   *     broadcast.playStream(stream);
-   *     const dispatcher = connection.playBroadcast(broadcast);
-   *   })
-   *   .catch(console.error);
-   */
-  playStream(stream, options = {}) {
-    this.setVolume(options.volume || 1);
-    return this._playTranscodable(stream, options);
-  }
-
-  /**
-   * Play the given file in the voice connection.
-   * @param {string} file The absolute path to the file
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {StreamDispatcher}
-   * @example
-   * // Play files natively
-   * const broadcast = client.createVoiceBroadcast();
-   *
-   * voiceChannel.join()
-   *   .then(connection => {
-   *     broadcast.playFile('C:/Users/Discord/Desktop/music.mp3');
-   *     const dispatcher = connection.playBroadcast(broadcast);
-   *   })
-   *   .catch(console.error);
-   */
-  playFile(file, options = {}) {
-    this.setVolume(options.volume || 1);
-    return this._playTranscodable(`file:${file}`, options);
-  }
-
-  _playTranscodable(media, options) {
-    this.killCurrentTranscoder();
-    const transcoder = this.prism.transcode({
-      type: 'ffmpeg',
-      media,
-      ffmpegArguments: ffmpegArguments.concat(['-ss', String(options.seek || 0)]),
-    });
-    /**
-     * Emitted whenever an error occurs.
-     * @event VoiceBroadcast#error
-     * @param {Error} error The error that occurred
-     */
-    transcoder.once('error', e => {
-      if (this.listenerCount('error') > 0) this.emit('error', e);
+  delete(dispatcher) {
+    const index = this.subscribers.indexOf(dispatcher);
+    if (index !== -1) {
+      this.subscribers.splice(index, 1);
+      dispatcher.destroy();
       /**
-       * Emitted whenever the VoiceBroadcast has any warnings.
-       * @event VoiceBroadcast#warn
-       * @param {string|Error} warning The warning that was raised
+       * Emitted whenever a stream dispatcher unsubscribes to the broadcast.
+       * @event VoiceBroadcast#unsubscribe
+       * @param {StreamDispatcher} dispatcher The unsubscribed dispatcher
        */
-      else this.emit('warn', e);
-    });
-    /**
-     * Emitted once the broadcast (the audio stream) ends.
-     * @event VoiceBroadcast#end
-     */
-    transcoder.once('end', () => this.killCurrentTranscoder());
-    this.currentTranscoder = {
-      transcoder,
-      options,
-    };
-    transcoder.output.once('readable', () => this._startPlaying());
-    return this;
-  }
-
-  /**
-   * Plays a stream of 16-bit signed stereo PCM.
-   * @param {ReadableStream} stream The audio stream to play
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {VoiceBroadcast}
-   */
-  playConvertedStream(stream, options = {}) {
-    this.killCurrentTranscoder();
-    this.setVolume(options.volume || 1);
-    this.currentTranscoder = { options: { stream } };
-    stream.once('readable', () => this._startPlaying());
-    return this;
-  }
-
-  /**
-   * Plays an Opus encoded stream.
-   * <warn>Note that inline volume is not compatible with this method.</warn>
-   * @param {ReadableStream} stream The Opus audio stream to play
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {StreamDispatcher}
-   */
-  playOpusStream(stream) {
-    this.currentTranscoder = { options: { stream }, opus: true };
-    stream.once('readable', () => this._startPlaying());
-    return this;
-  }
-
-  /**
-   * Play an arbitrary input that can be [handled by ffmpeg](https://ffmpeg.org/ffmpeg-protocols.html#Description)
-   * @param {string} input The arbitrary input
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {VoiceBroadcast}
-   */
-  playArbitraryInput(input, options = {}) {
-    this.setVolume(options.volume || 1);
-    options.input = input;
-    return this._playTranscodable(input, options);
-  }
-
-  /**
-   * Pauses the entire broadcast - all dispatchers also pause.
-   */
-  pause() {
-    this.paused = true;
-    for (const container of this._dispatchers.values()) {
-      for (const dispatcher of container.values()) {
-        dispatcher.pause();
-      }
-    }
-  }
-
-  /**
-   * Resumes the entire broadcast - all dispatchers also resume.
-   */
-  resume() {
-    this.paused = false;
-    for (const container of this._dispatchers.values()) {
-      for (const dispatcher of container.values()) {
-        dispatcher.resume();
-      }
-    }
-  }
-
-  _startPlaying() {
-    if (this.tickInterval) clearInterval(this.tickInterval);
-    // Old code?
-    // this.tickInterval = this.client.setInterval(this.tick.bind(this), 20);
-    this._startTime = Date.now();
-    this._count = 0;
-    this._pausedTime = 0;
-    this._missed = 0;
-    this.tick();
-  }
-
-  tick() {
-    if (!this._playableStream) return;
-    if (this.paused) {
-      this._pausedTime += 20;
-      setTimeout(() => this.tick(), 20);
-      return;
-    }
-
-    const opus = this.currentTranscoder.opus;
-    const buffer = this.readStreamBuffer();
-
-    if (!buffer) {
-      this._missed++;
-      if (this._missed < 5) {
-        this._pausedTime += 200;
-        setTimeout(() => this.tick(), 200);
-      } else {
-        this.killCurrentTranscoder();
-      }
-      return;
-    }
-
-    this._missed = 0;
-
-    let packetMatrix = {};
-
-    const getOpusPacket = volume => {
-      if (packetMatrix[volume]) return packetMatrix[volume];
-
-      const opusEncoder = this._encoders.get(volume);
-      const opusPacket = opusEncoder.encode(this.applyVolume(buffer, this._volume * volume));
-      packetMatrix[volume] = opusPacket;
-      return opusPacket;
-    };
-
-    for (const dispatcher of this.dispatchers) {
-      if (opus) {
-        dispatcher.processPacket(buffer);
-        continue;
-      }
-
-      const volume = dispatcher.volume;
-      dispatcher.processPacket(getOpusPacket(volume));
-    }
-
-    const next = 20 + (this._startTime + this._pausedTime + (this._count * 20) - Date.now());
-    this._count++;
-    setTimeout(() => this.tick(), next);
-  }
-
-  readStreamBuffer() {
-    const opus = this.currentTranscoder.opus;
-    const bufferLength = (opus ? 80 : 1920) * 2;
-    let buffer = this._playableStream.read(bufferLength);
-    if (opus) return buffer;
-    if (!buffer) return null;
-
-    if (buffer.length !== bufferLength) {
-      const newBuffer = Buffer.alloc(bufferLength).fill(0);
-      buffer.copy(newBuffer);
-      buffer = newBuffer;
-    }
-
-    return buffer;
-  }
-
-  /**
-   * Stop the current stream from playing without unsubscribing dispatchers.
-   */
-  end() {
-    this.killCurrentTranscoder();
-  }
-
-  /**
-   * End the current broadcast, all subscribed dispatchers will also end.
-   */
-  destroy() {
-    this.end();
-    for (const container of this._dispatchers.values()) {
-      for (const dispatcher of container.values()) {
-        dispatcher.destroy('end', 'broadcast ended');
-      }
+      this.emit(Events.VOICE_BROADCAST_UNSUBSCRIBE, dispatcher);
+      return true;
     }
+    return false;
   }
 }
 
+PlayInterface.applyToClass(VoiceBroadcast);
+
 module.exports = VoiceBroadcast;

src/client/voice/VoiceConnection.js

@@ -1,11 +1,26 @@
-const VoiceWebSocket = require('./VoiceWebSocket');
-const VoiceUDP = require('./VoiceUDPClient');
-const Util = require('../../util/Util');
-const Constants = require('../../util/Constants');
+'use strict';
+
+const EventEmitter = require('events');
+const VoiceUDP = require('./networking/VoiceUDPClient');
+const VoiceWebSocket = require('./networking/VoiceWebSocket');
 const AudioPlayer = require('./player/AudioPlayer');
-const VoiceReceiver = require('./receiver/VoiceReceiver');
-const EventEmitter = require('events').EventEmitter;
-const Prism = require('prism-media');
+const VoiceReceiver = require('./receiver/Receiver');
+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');
+
+// 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.
@@ -17,6 +32,7 @@ const Prism = require('prism-media');
  *   });
  * ```
  * @extends {EventEmitter}
+ * @implements {PlayInterface}
  */
 class VoiceConnection extends EventEmitter {
   constructor(voiceManager, channel) {
@@ -28,23 +44,6 @@ class VoiceConnection extends EventEmitter {
      */
     this.voiceManager = voiceManager;
 
-    /**
-     * The client that instantiated this connection
-     * @type {Client}
-     */
-    this.client = voiceManager.client;
-
-    /**
-     * @external Prism
-     * @see {@link https://github.com/hydrabolt/prism-media}
-     */
-
-    /**
-     * The audio transcoder for this connection
-     * @type {Prism}
-     */
-    this.prism = new Prism();
-
     /**
      * The voice channel this connection is currently serving
      * @type {VoiceChannel}
@@ -53,21 +52,15 @@ class VoiceConnection extends EventEmitter {
 
     /**
      * The current status of the voice connection
-     * @type {number}
+     * @type {VoiceStatus}
      */
-    this.status = Constants.VoiceStatus.AUTHENTICATING;
+    this.status = VoiceStatus.AUTHENTICATING;
 
     /**
-     * Whether we're currently transmitting audio
-     * @type {boolean}
+     * Our current speaking state
+     * @type {Readonly<Speaking>}
      */
-    this.speaking = false;
-
-    /**
-     * An array of Voice Receivers that have been created for this connection
-     * @type {VoiceReceiver[]}
-     */
-    this.receivers = [];
+    this.speaking = new Speaking().freeze();
 
     /**
      * The authentication data needed to connect to the voice server
@@ -100,13 +93,22 @@ class VoiceConnection extends EventEmitter {
       this.emit('warn', e);
     });
 
+    this.once('closing', () => this.player.destroy());
+
     /**
-     * Map SSRC to speaking values
-     * @type {Map<number, boolean>}
+     * Map SSRC values to user IDs
+     * @type {Map<number, Snowflake>}
      * @private
      */
     this.ssrcMap = new Map();
 
+    /**
+     * Tracks which users are talking
+     * @type {Map<Snowflake, Readonly<Speaking>>}
+     * @private
+     */
+    this._speaking = new Map();
+
     /**
      * Object that wraps contains the `ws` and `udp` sockets of this voice connection
      * @type {Object}
@@ -114,7 +116,20 @@ class VoiceConnection extends EventEmitter {
      */
     this.sockets = {};
 
-    this.authenticate();
+    /**
+     * The voice receiver of this connection
+     * @type {VoiceReceiver}
+     */
+    this.receiver = new VoiceReceiver(this);
+  }
+
+  /**
+   * The client that instantiated this connection
+   * @type {Client}
+   * @readonly
+   */
+  get client() {
+    return this.voiceManager.client;
   }
 
   /**
@@ -127,41 +142,61 @@ class VoiceConnection extends EventEmitter {
   }
 
   /**
-   * Sets whether the voice connection should display as "speaking" or not.
-   * @param {boolean} value Whether or not to speak
-   * @private
+   * Sets whether the voice connection should display as "speaking", "soundshare" or "none".
+   * @param {BitFieldResolvable} value The new speaking state
    */
   setSpeaking(value) {
-    if (this.speaking === value) return;
-    if (this.status !== Constants.VoiceStatus.CONNECTED) return;
-    this.speaking = value;
-    this.sockets.ws.sendPacket({
-      op: Constants.VoiceOPCodes.SPEAKING,
-      d: {
-        speaking: true,
-        delay: 0,
-      },
-    }).catch(e => {
-      this.emit('debug', e);
-    });
+    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);
+      });
+  }
+
+  /**
+   * 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: Constants.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,
+    );
   }
 
   /**
@@ -169,26 +204,29 @@ class VoiceConnection extends EventEmitter {
    * @param {string} token The voice token
    * @param {string} endpoint The voice endpoint
    * @returns {void}
+   * @private
    */
   setTokenAndEndpoint(token, endpoint) {
+    this.emit('debug', `Token "${token}" and endpoint "${endpoint}"`);
     if (!endpoint) {
       // Signifies awaiting endpoint stage
       return;
     }
 
     if (!token) {
-      this.authenticateFailed('Token not provided from voice server packet.');
+      this.authenticateFailed('VOICE_TOKEN_ABSENT');
       return;
     }
 
     endpoint = endpoint.match(/([^:]*)/)[0];
+    this.emit('debug', `Endpoint resolved as ${endpoint}`);
 
     if (!endpoint) {
-      this.authenticateFailed('Invalid endpoint received.');
+      this.authenticateFailed('VOICE_INVALID_ENDPOINT');
       return;
     }
 
-    if (this.status === Constants.VoiceStatus.AUTHENTICATING) {
+    if (this.status === VoiceStatus.AUTHENTICATING) {
       this.authentication.token = token;
       this.authentication.endpoint = endpoint;
       this.checkAuthenticated();
@@ -200,14 +238,16 @@ class VoiceConnection extends EventEmitter {
   /**
    * Sets the Session ID for the connection.
    * @param {string} sessionID The voice session ID
+   * @private
    */
   setSessionID(sessionID) {
+    this.emit('debug', `Setting sessionID ${sessionID} (stored as "${this.authentication.sessionID}")`);
     if (!sessionID) {
-      this.authenticateFailed('Session ID not supplied.');
+      this.authenticateFailed('VOICE_SESSION_ABSENT');
       return;
     }
 
-    if (this.status === Constants.VoiceStatus.AUTHENTICATING) {
+    if (this.status === VoiceStatus.AUTHENTICATING) {
       this.authentication.sessionID = sessionID;
       this.checkAuthenticated();
     } else if (sessionID !== this.authentication.sessionID) {
@@ -227,10 +267,9 @@ class VoiceConnection extends EventEmitter {
    */
   checkAuthenticated() {
     const { token, endpoint, sessionID } = this.authentication;
-
+    this.emit('debug', `Authenticated with sessionID ${sessionID}`);
     if (token && endpoint && sessionID) {
-      clearTimeout(this.connectTimeout);
-      this.status = Constants.VoiceStatus.CONNECTING;
+      this.status = VoiceStatus.CONNECTING;
       /**
        * Emitted when we successfully initiate a voice connection.
        * @event VoiceConnection#authenticated
@@ -246,8 +285,9 @@ class VoiceConnection extends EventEmitter {
    * @private
    */
   authenticateFailed(reason) {
-    clearTimeout(this.connectTimeout);
-    if (this.status === Constants.VoiceStatus.AUTHENTICATING) {
+    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.
        * @event VoiceConnection#failed
@@ -255,9 +295,14 @@ class VoiceConnection extends EventEmitter {
        */
       this.emit('failed', new Error(reason));
     } else {
+      /**
+       * Emitted whenever the connection encounters an error.
+       * @event VoiceConnection#error
+       * @param {Error} error The encountered error
+       */
       this.emit('error', new Error(reason));
     }
-    this.status = Constants.VoiceStatus.DISCONNECTED;
+    this.status = VoiceStatus.DISCONNECTED;
   }
 
   /**
@@ -276,8 +321,7 @@ class VoiceConnection extends EventEmitter {
    */
   authenticate() {
     this.sendVoiceStateUpdate();
-    this.connectTimeout = this.client.setTimeout(
-      () => this.authenticateFailed(new Error('Connection not established within 15 seconds.')), 15000);
+    this.connectTimeout = this.client.setTimeout(() => this.authenticateFailed('VOICE_CONNECTION_TIMEOUT'), 15000);
   }
 
   /**
@@ -289,8 +333,9 @@ class VoiceConnection extends EventEmitter {
   reconnect(token, endpoint) {
     this.authentication.token = token;
     this.authentication.endpoint = endpoint;
-
-    this.status = Constants.VoiceStatus.RECONNECTING;
+    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
@@ -300,16 +345,27 @@ class VoiceConnection extends EventEmitter {
   }
 
   /**
-   * Disconnect the voice connection, causing a disconnect and closing event to be emitted.
+   * Disconnects the voice connection, causing a disconnect and closing event to be emitted.
    */
   disconnect() {
     this.emit('closing');
+    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({
       channel_id: null,
     });
-    this.player.destroy();
+    this._disconnect();
+  }
+
+  /**
+   * Internally disconnects (doesn't send disconnect packet).
+   * @private
+   */
+  _disconnect() {
     this.cleanup();
-    this.status = Constants.VoiceStatus.DISCONNECTED;
+    this.status = VoiceStatus.DISCONNECTED;
     /**
      * Emitted when the voice connection disconnects.
      * @event VoiceConnection#disconnect
@@ -322,13 +378,18 @@ class VoiceConnection extends EventEmitter {
    * @private
    */
   cleanup() {
+    this.player.destroy();
+    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');
@@ -342,9 +403,10 @@ class VoiceConnection extends EventEmitter {
    * @private
    */
   connect() {
-    if (this.status !== Constants.VoiceStatus.RECONNECTING) {
-      if (this.sockets.ws) throw new Error('There is already an existing WebSocket connection.');
-      if (this.sockets.udp) throw new Error('There is already an existing UDP connection.');
+    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');
     }
 
     if (this.sockets.ws) this.sockets.ws.shutdown();
@@ -355,11 +417,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();
   }
 
   /**
@@ -367,39 +433,51 @@ class VoiceConnection extends EventEmitter {
    * @param {Object} data The received data
    * @private
    */
-  onReady({ port, ssrc }) {
-    this.authentication.port = port;
-    this.authentication.ssrc = ssrc;
-
-    const udp = this.sockets.udp;
-    /**
-     * Emitted whenever the connection encounters an error.
-     * @event VoiceConnection#error
-     * @param {Error} error The encountered error
-     */
-    udp.findEndpointAddress()
-      .then(address => {
-        udp.createUDPSocket(address);
-      }, e => this.emit('error', e));
+  onReady(data) {
+    Object.assign(this.authentication, data);
+    for (let mode of data.modes) {
+      if (SUPPORTED_MODES.includes(mode)) {
+        this.authentication.mode = mode;
+        this.emit('debug', `Selecting the ${mode} mode`);
+        break;
+      }
+    }
+    this.sockets.udp.createUDPSocket(data.ip);
   }
 
   /**
    * Invoked when a session description is received.
-   * @param {string} mode The encryption mode
-   * @param {string} secret The secret key
+   * @param {Object} data The received data
    * @private
    */
-  onSessionDescription(mode, secret) {
-    this.authentication.encryptionMode = mode;
-    this.authentication.secretKey = secret;
+  onSessionDescription(data) {
+    Object.assign(this.authentication, data);
+    this.status = VoiceStatus.CONNECTED;
+    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', volume: false });
+      dispatcher.once('finish', ready);
+    }
+  }
 
-    this.status = Constants.VoiceStatus.CONNECTED;
-    /**
-     * 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');
+  onStartSpeaking({ user_id, ssrc, speaking }) {
+    this.ssrcMap.set(+ssrc, {
+      ...(this.ssrcMap.get(+ssrc) || {}),
+      userID: user_id,
+      speaking: speaking,
+    });
   }
 
   /**
@@ -407,129 +485,42 @@ 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);
-    if (!speaking) {
-      for (const receiver of this.receivers) {
-        receiver.stoppedSpeaking(user);
+    const user = this.client.users.cache.get(user_id);
+    const old = this._speaking.get(user_id);
+    this._speaking.set(user_id, speaking);
+    /**
+     * Emitted whenever a user changes speaking state.
+     * @event VoiceConnection#speaking
+     * @param {User} user The user that has changed speaking state
+     * @param {Readonly<Speaking>} speaking The speaking state of the user
+     */
+    if (this.status === VoiceStatus.CONNECTED) {
+      this.emit('speaking', user, speaking);
+      if (!speaking.has(Speaking.FLAGS.SPEAKING)) {
+        this.receiver.packets._stoppedSpeaking(user_id);
+      }
+    }
+
+    if (guild && user && !speaking.equals(old)) {
+      const member = guild.member(user);
+      if (member) {
+        /**
+         * Emitted once a guild member changes speaking state.
+         * @event Client#guildMemberSpeaking
+         * @param {GuildMember} member The member that started/stopped speaking
+         * @param {Readonly<Speaking>} speaking The speaking state of the member
+         */
+        this.client.emit(Events.GUILD_MEMBER_SPEAKING, member, speaking);
       }
     }
-    /**
-     * Emitted whenever a user starts/stops speaking.
-     * @event VoiceConnection#speaking
-     * @param {User} user The user that has started/stopped speaking
-     * @param {boolean} speaking Whether or not the user is speaking
-     */
-    if (this.status === Constants.VoiceStatus.CONNECTED) this.emit('speaking', user, speaking);
-    guild._memberSpeakUpdate(user_id, speaking);
   }
 
-  /**
-   * Options that can be passed to stream-playing methods:
-   * @typedef {Object} StreamOptions
-   * @property {number} [seek=0] The time to seek to
-   * @property {number} [volume=1] The volume to play at
-   * @property {number} [passes=1] How many times to send the voice packet to reduce packet loss
-   * @property {number|string} [bitrate=48000] The bitrate (quality) of the audio.
-   * If set to 'auto', the voice channel's bitrate will be used
-   */
-
-  /**
-   * Play the given file in the voice connection.
-   * @param {string} file The absolute path to the file
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {StreamDispatcher}
-   * @example
-   * // Play files natively
-   * voiceChannel.join()
-   *   .then(connection => {
-   *     const dispatcher = connection.playFile('C:/Users/Discord/Desktop/music.mp3');
-   *   })
-   *   .catch(console.error);
-   */
-  playFile(file, options) {
-    return this.player.playUnknownStream(`file:${file}`, options);
-  }
-
-  /**
-   * Play an arbitrary input that can be [handled by ffmpeg](https://ffmpeg.org/ffmpeg-protocols.html#Description)
-   * @param {string} input the arbitrary input
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {StreamDispatcher}
-   */
-  playArbitraryInput(input, options) {
-    return this.player.playUnknownStream(input, options);
-  }
-
-  /**
-   * Plays and converts an audio stream in the voice connection.
-   * @param {ReadableStream} stream The audio stream to play
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {StreamDispatcher}
-   * @example
-   * // Play streams using ytdl-core
-   * const ytdl = require('ytdl-core');
-   * const streamOptions = { seek: 0, volume: 1 };
-   * voiceChannel.join()
-   *   .then(connection => {
-   *     const stream = ytdl('https://www.youtube.com/watch?v=XAWgeLF9EVQ', { filter : 'audioonly' });
-   *     const dispatcher = connection.playStream(stream, streamOptions);
-   *   })
-   *   .catch(console.error);
-   */
-  playStream(stream, options) {
-    return this.player.playUnknownStream(stream, options);
-  }
-
-  /**
-   * Plays a stream of 16-bit signed stereo PCM.
-   * @param {ReadableStream} stream The audio stream to play
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {StreamDispatcher}
-   */
-  playConvertedStream(stream, options) {
-    return this.player.playPCMStream(stream, options);
-  }
-
-  /**
-   * Plays an Opus encoded stream.
-   * <warn>Note that inline volume is not compatible with this method.</warn>
-   * @param {ReadableStream} stream The Opus audio stream to play
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {StreamDispatcher}
-   */
-  playOpusStream(stream, options) {
-    return this.player.playOpusStream(stream, options);
-  }
-
-  /**
-   * Plays a voice broadcast.
-   * @param {VoiceBroadcast} broadcast The broadcast to play
-   * @param {StreamOptions} [options] Options for playing the stream
-   * @returns {StreamDispatcher}
-   * @example
-   * // Play a broadcast
-   * const broadcast = client
-   *   .createVoiceBroadcast()
-   *   .playFile('./test.mp3');
-   * const dispatcher = voiceConnection.playBroadcast(broadcast);
-   */
-  playBroadcast(broadcast, options) {
-    return this.player.playBroadcast(broadcast, options);
-  }
-
-  /**
-   * Creates a VoiceReceiver so you can start listening to voice data.
-   * It's recommended to only create one of these.
-   * @returns {VoiceReceiver}
-   */
-  createReceiver() {
-    const receiver = new VoiceReceiver(this);
-    this.receivers.push(receiver);
-    return receiver;
-  }
+  play() {} // eslint-disable-line no-empty-function
 }
 
+PlayInterface.applyToClass(VoiceConnection);
+
 module.exports = VoiceConnection;