From 0919c1c13ccc13bb86d82a735c66bf1356f6f10a Mon Sep 17 00:00:00 2001
From: Erik <robere2@rpi.edu>
Date: Mon, 10 Aug 2020 18:53:50 -0400
Subject: [PATCH] Ported files from other projects and made some modifications.

---
 .gitignore                                    | 105 +----------
 AliasedAction.ts                              |  51 ++++++
 Button.ts                                     |  56 ++++++
 Screen.ts                                     |  79 ++++++++
 actions/Action.ts                             |  83 +++++++++
 actions/ActionBus.ts                          |  75 ++++++++
 actions/Resolver.ts                           | 127 +++++++++++++
 .../clientbound/AuthBeginHandshakeAction.ts   |  28 +++
 actions/clientbound/AuthCompleteAction.ts     |  33 ++++
 actions/clientbound/DisableModAction.ts       |  30 +++
 actions/clientbound/EnableModAction.ts        |  18 ++
 actions/clientbound/OpenGuiAction.ts          |  38 ++++
 actions/clientbound/OpenScreenAction.ts       |  30 +++
 actions/clientbound/RefreshCacheAction.ts     |  20 ++
 actions/clientbound/ResetConfigAction.ts      |  18 ++
 actions/clientbound/SendChatCommandAction.ts  |  35 ++++
 .../clientbound/SendChatComponentAction.ts    |  31 ++++
 actions/clientbound/SetAliasedActionAction.ts |  35 ++++
 actions/clientbound/SetButtonAction.ts        |  39 ++++
 actions/clientbound/SetCurrentServerAction.ts |  35 ++++
 actions/clientbound/SetGlyphForUserAction.ts  |  47 +++++
 actions/clientbound/SetKeybindsAction.ts      |  32 ++++
 actions/clientbound/SetPremiumAboutAction.ts  |  31 ++++
 actions/clientbound/SetScreenAction.ts        |  43 +++++
 actions/clientbound/SetTranslationAction.ts   |  36 ++++
 actions/clientbound/SystemOutAction.ts        |  27 +++
 actions/serverbound/AuthEndHandshakeAction.ts |  31 ++++
 actions/serverbound/ButtonPressedAction.ts    |  31 ++++
 actions/serverbound/ExceptionThrownAction.ts  |  68 +++++++
 .../HypixelLocationChangedAction.ts           |  31 ++++
 actions/serverbound/InitializeClientAction.ts |  66 +++++++
 actions/serverbound/LanguageChangedAction.ts  |  31 ++++
 actions/serverbound/MigrateKeybindsAction.ts  |  33 ++++
 actions/serverbound/ServerJoinedAction.ts     |  35 ++++
 actions/serverbound/ServerLeftAction.ts       |  19 ++
 chat-components/ChatComponent.ts              | 171 ++++++++++++++++++
 chat-components/ChatFormatting.ts             |  20 ++
 chat-components/ClickEvent.ts                 |  78 ++++++++
 chat-components/HoverEvent.ts                 |  75 ++++++++
 chat-components/Message.ts                    |  31 ++++
 index.ts                                      |  86 +++++++++
 package-lock.json                             |  33 ++++
 package.json                                  |  36 ++++
 tsconfig.json                                 |  73 ++++++++
 44 files changed, 2027 insertions(+), 103 deletions(-)
 create mode 100644 AliasedAction.ts
 create mode 100644 Button.ts
 create mode 100644 Screen.ts
 create mode 100644 actions/Action.ts
 create mode 100644 actions/ActionBus.ts
 create mode 100644 actions/Resolver.ts
 create mode 100644 actions/clientbound/AuthBeginHandshakeAction.ts
 create mode 100644 actions/clientbound/AuthCompleteAction.ts
 create mode 100644 actions/clientbound/DisableModAction.ts
 create mode 100644 actions/clientbound/EnableModAction.ts
 create mode 100644 actions/clientbound/OpenGuiAction.ts
 create mode 100644 actions/clientbound/OpenScreenAction.ts
 create mode 100644 actions/clientbound/RefreshCacheAction.ts
 create mode 100644 actions/clientbound/ResetConfigAction.ts
 create mode 100644 actions/clientbound/SendChatCommandAction.ts
 create mode 100644 actions/clientbound/SendChatComponentAction.ts
 create mode 100644 actions/clientbound/SetAliasedActionAction.ts
 create mode 100644 actions/clientbound/SetButtonAction.ts
 create mode 100644 actions/clientbound/SetCurrentServerAction.ts
 create mode 100644 actions/clientbound/SetGlyphForUserAction.ts
 create mode 100644 actions/clientbound/SetKeybindsAction.ts
 create mode 100644 actions/clientbound/SetPremiumAboutAction.ts
 create mode 100644 actions/clientbound/SetScreenAction.ts
 create mode 100644 actions/clientbound/SetTranslationAction.ts
 create mode 100644 actions/clientbound/SystemOutAction.ts
 create mode 100644 actions/serverbound/AuthEndHandshakeAction.ts
 create mode 100644 actions/serverbound/ButtonPressedAction.ts
 create mode 100644 actions/serverbound/ExceptionThrownAction.ts
 create mode 100644 actions/serverbound/HypixelLocationChangedAction.ts
 create mode 100644 actions/serverbound/InitializeClientAction.ts
 create mode 100644 actions/serverbound/LanguageChangedAction.ts
 create mode 100644 actions/serverbound/MigrateKeybindsAction.ts
 create mode 100644 actions/serverbound/ServerJoinedAction.ts
 create mode 100644 actions/serverbound/ServerLeftAction.ts
 create mode 100644 chat-components/ChatComponent.ts
 create mode 100644 chat-components/ChatFormatting.ts
 create mode 100644 chat-components/ClickEvent.ts
 create mode 100644 chat-components/HoverEvent.ts
 create mode 100644 chat-components/Message.ts
 create mode 100644 index.ts
 create mode 100644 package-lock.json
 create mode 100644 package.json
 create mode 100644 tsconfig.json

diff --git a/.gitignore b/.gitignore
index 6704566..c4de136 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,104 +1,3 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-lerna-debug.log*
-
-# Diagnostic reports (https://nodejs.org/api/report.html)
-report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
-
-# Runtime data
-pids
-*.pid
-*.seed
-*.pid.lock
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-*.lcov
-
-# nyc test coverage
-.nyc_output
-
-# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# Bower dependency directory (https://bower.io/)
-bower_components
-
-# node-waf configuration
-.lock-wscript
-
-# Compiled binary addons (https://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directories
-node_modules/
-jspm_packages/
-
-# TypeScript v1 declaration files
-typings/
-
-# TypeScript cache
-*.tsbuildinfo
-
-# Optional npm cache directory
-.npm
-
-# Optional eslint cache
-.eslintcache
-
-# Microbundle cache
-.rpt2_cache/
-.rts2_cache_cjs/
-.rts2_cache_es/
-.rts2_cache_umd/
-
-# Optional REPL history
-.node_repl_history
-
-# Output of 'npm pack'
-*.tgz
-
-# Yarn Integrity file
-.yarn-integrity
-
-# dotenv environment variables file
-.env
-.env.test
-
-# parcel-bundler cache (https://parceljs.org/)
-.cache
-
-# Next.js build output
-.next
-
-# Nuxt.js build / generate output
-.nuxt
 dist
-
-# Gatsby files
-.cache/
-# Comment in the public line in if your project uses Gatsby and *not* Next.js
-# https://nextjs.org/blog/next-9-1#public-directory-support
-# public
-
-# vuepress build output
-.vuepress/dist
-
-# Serverless directories
-.serverless/
-
-# FuseBox cache
-.fusebox/
-
-# DynamoDB Local files
-.dynamodb/
-
-# TernJS port file
-.tern-port
+node_modules
+.npmrc
diff --git a/AliasedAction.ts b/AliasedAction.ts
new file mode 100644
index 0000000..83d6ff4
--- /dev/null
+++ b/AliasedAction.ts
@@ -0,0 +1,51 @@
+import Action from './actions/Action'
+import Resolver from './actions/Resolver'
+
+/**
+ * AliasedActions are the lowest level of user-facing elements. Actions are executed by the user and are simply
+ * a wrapper to reference an Action and it's arguments.
+ */
+class AliasedAction {
+
+    /**
+     * The key of this AliasedAction. Should probably be CAPS_SNAKE_CASE.
+     */
+    key: string
+    /**
+     * Array of server identifiers that this AliasedAction is available on.
+     */
+    availableOn: string[] = []
+    /**
+     * The Action which this AliasedAction is a wrapper for.
+     */
+    action: Action
+
+    /**
+     * Constructor
+     * @param key {string} The key of this item.
+     */
+    constructor (key: string) {
+        this.key = key
+
+    }
+
+    /**
+     * Deserialize a JSON-stringified AliasedAction into an AliasedAction object.
+     * @param json {string} The JSON to deserialize.
+     * @return {Promise<AliasedAction>} The AliasedAction that was deserialized.
+     */
+    static async deserialize(json: string) : Promise<AliasedAction> {
+        const obj = JSON.parse(json)
+        const aa = new AliasedAction(obj.key)
+        for(const prop in obj) {
+            if(!obj.hasOwnProperty(prop)) {
+                continue
+            }
+            aa[prop] = obj[prop]
+        }
+        aa.action = await Resolver.deserialize(JSON.stringify(obj.action))
+        return aa
+    }
+}
+
+export default AliasedAction
diff --git a/Button.ts b/Button.ts
new file mode 100644
index 0000000..50e728a
--- /dev/null
+++ b/Button.ts
@@ -0,0 +1,56 @@
+/**
+ * Buttons are the median user-facing element, between AliasedActions and Screens. Screens contain a list of
+ * Buttons, and Buttons contain a list of AliasedActions.
+ */
+class Button {
+
+    /**
+     * The key of this Button. Unique identifier, should probably be CAPS_SNAKE_CASE
+     */
+    key: string
+    /**
+     * Array of server identifiers that this Button is available on.
+     */
+    availableOn: string[] = []
+    /**
+     * Array of AliasedAction keys which this Button executes. AliasedAction objects are not used directly to reduce
+     * Action size, remove redundant references to AliasedActions, and due to the async nature in how AliasedActions are
+     * handled by the client.
+     */
+    actions: string[] = []
+    /**
+     * The URL to the image which can be displayed as this Button, specifically on "IMAGES" type Screens.
+     */
+    imageURL = ''
+    /**
+     * The translation key for this Button's title.
+     */
+    translationKey = ''
+
+    /**
+     * Constructor
+     * @param key {string} The key/ID of this item.
+     */
+    constructor (key: string) {
+        this.key = key
+    }
+
+    /**
+     * Deserialize a JSON-stringified Button into an Button object.
+     * @param json {string} The JSON to deserialize.
+     * @return {Promise<Button>} The Button that was deserialized.
+     */
+    static async deserialize(json: string) : Promise<Button> {
+        const obj = JSON.parse(json)
+        const btn = new Button(obj.key)
+        for(const prop in obj) {
+            if(!obj.hasOwnProperty(prop)) {
+                continue
+            }
+            btn[prop] = obj[prop]
+        }
+        return btn
+    }
+}
+
+export default Button
diff --git a/Screen.ts b/Screen.ts
new file mode 100644
index 0000000..520904d
--- /dev/null
+++ b/Screen.ts
@@ -0,0 +1,79 @@
+const ScreenTypes = Object.freeze({
+    IMAGES: 'IMAGES',
+    BUTTONS: 'BUTTONS'
+})
+
+/**
+ * A Screen in Quickplay is the highest level of user-facing objects. Screens are a set of Buttons which can be laid
+ * out in a variety of ways. The client can display these Screens.
+ */
+class Screen {
+
+    /**
+     * The key of this Screen. Unique identifier, should probably be CAPS_SNAKE_CASE.
+     */
+    key: string
+    /**
+     * Array of server identifiers that this Screen is available on.
+     */
+    availableOn: string[] = []
+    /**
+     * Array of Button keys which this Screen renders. Button objects are not used directly to reduce Action
+     * size, remove redundant references to Buttons, and due to the async nature in how Buttons are
+     * handled by the client.
+     */
+    buttons: string[] = []
+    /**
+     * Type of Screen that this Screen is. Should be "IMAGES" or "BUTTONS", in most cases.
+     * @see ScreenTypes
+     */
+    screenType = ''
+    /**
+     * The translation key for this Screen's title.
+     */
+    translationKey = ''
+    /**
+     * List of AliasedActions which should be executed when the client clicks this Screen's back button.
+     */
+    backButtonActions: string[] = []
+    /**
+     * The URL to the image which can be displayed at the top of this Screen.
+     */
+    imageURL = ''
+
+    /**
+     * Constructor
+     * @param key {string} The key/ID of this item.
+     * @param screenType {string} Type of screen that this screen is.
+     */
+    constructor (key: string, screenType: string) {
+        this.key = key
+        this.buttons = []
+        this.screenType = screenType
+        if(!ScreenTypes[this.screenType]) {
+            throw new Error('Invalid screen type: Screen type must be IMAGES or BUTTONS.')
+        }
+        this.backButtonActions = []
+    }
+
+    /**
+     * Deserialize a JSON-stringified Screen into an Screen object.
+     * @param json {string} The JSON to deserialize.
+     * @return {Promise<Screen>} The Screen that was deserialized.
+     */
+    static async deserialize(json: string) : Promise<Screen> {
+        const obj = JSON.parse(json)
+        const screen = new Screen(obj.key, obj.screenType)
+        for(const prop in obj) {
+            if(!obj.hasOwnProperty(prop)) {
+                continue
+            }
+            screen[prop] = obj[prop]
+        }
+        return screen
+    }
+
+}
+
+export default Screen
+export {ScreenTypes}
diff --git a/actions/Action.ts b/actions/Action.ts
new file mode 100644
index 0000000..6a91528
--- /dev/null
+++ b/actions/Action.ts
@@ -0,0 +1,83 @@
+import {Buffer} from 'buffer'
+
+/**
+ * Actions are the core mechanism behind how Quickplay operates. Whenever the client/user
+ * clicks a button, presses a keybind, receives instructions from the web server, etc.,
+ * Besides some of the current commands system, the client is not able to do any I/O other than what
+ * is available through Actions (eventually, ideally all the Quickplay commands would also run Actions).
+ *
+ * Actions are serializable in a similar format to Minecraft packets, and can be sent over the wire.
+ * The structure is as follows:
+ * When serialized, all Actions must contain at least 2 bytes. These are the first two bytes, which
+ * are the Action's ID. All subsequent bytes are considered the payload. They can be considered arguments
+ * to the Action, and are split up into partitions, each of which is one argument. An argument begins
+ * with the first 4 bytes being the length x of the argument. After those bytes, the next x bytes are
+ * the actual argument. This signature repeats, until there are no more bytes.
+ *
+ * If there are too few bytes in the Action, a RangeError will be thrown. It is possible
+ * for a serialized Action to be valid, but the subsequent execution of the Action to fail if there were
+ * not enough arguments provided in the payload.
+ *
+ * Actions can also be sent to the web server, providing context to actions/events occurring on the client,
+ * such as exceptions, connection status, button presses, etc.
+ */
+class Action {
+
+    static id = 0
+    id = 0
+    payloadObjs:Buffer[] = []
+
+    /**
+     * Build an action into a Buffer from its ID and payload list.
+     * @return {Buffer} Built buffer which can be sent over the wire.
+     */
+    build () : Buffer {
+        let body = Buffer.alloc(2)
+        body.writeUInt16BE(this.id, 0)
+
+        for(let i = 0; i < this.payloadObjs.length; i++) {
+            const payloadSize = Buffer.alloc(4)
+
+            payloadSize.writeInt32BE(this.payloadObjs[i].byteLength, 0)
+            body = Buffer.concat([body, payloadSize, this.payloadObjs[i]])
+        }
+
+        return body
+    }
+
+    /**
+     * Add an item to the payload.
+     * @param obj {Buffer} Item to add.
+     */
+    addPayload (obj: Buffer) : void {
+        this.payloadObjs.push(obj)
+    }
+
+    /**
+     * Get an object from the payload at the specified index
+     * @param index {number} Index of the item to get. Should be >= 0 and < payloadObjs.length
+     * @return {Buffer} The payload item, or null if it does not exist.
+     */
+    getPayloadObject(index: number) : Buffer {
+        if(this.payloadObjs.length <= index) {
+            return null
+        }
+        return this.payloadObjs[index]
+    }
+
+    /**
+     * Get an item from the Payload and convert it to a String in UTF-8.
+     * @param index {number} Index of the item to get. Must be >= 0 and < payloadObjs.length
+     * @return {string} Decoded String
+     */
+    getPayloadObjectAsString(index: number) : string {
+        const obj = this.getPayloadObject(index)
+        if(obj == null) {
+            return null
+        }
+        return obj.toString()
+    }
+
+}
+
+export default Action
diff --git a/actions/ActionBus.ts b/actions/ActionBus.ts
new file mode 100644
index 0000000..107b5ee
--- /dev/null
+++ b/actions/ActionBus.ts
@@ -0,0 +1,75 @@
+import Action from "./Action";
+
+/**
+ * The ActionBus is the bus to allow different elements of your program to be notified when a new Action is published,
+ * i.e. a new Action is received.
+ */
+class ActionBus {
+
+    /**
+     * The subscribed functions. Map of Action IDs to all the subscribed Functions for that Action ID.
+     */
+    private subscribers : Record<number, Function[]> = {}
+
+    /**
+     * Subscribe to listen for new Actions of a certain type to come in, at which point the passed function
+     * will be called. The same Function can be subscribed multiple times.
+     * @param action {typeof Action|number} The Action type to listen for. Can be an Action class, or an Action ID.
+     * @param fn {Function} The function to be called when the Action is received. Should be non-null. Should take
+     * one argument, which is the Action.
+     * @returns {boolean} True if the subscriber is added successfully, false otherwise.
+     */
+    public subscribe(action: typeof Action|number, fn: Function) : boolean {
+        if(action == null || fn == null) {
+            return false
+        }
+        const actionId = typeof action == "number" ? action : action.id
+        if(this.subscribers[actionId] == null) {
+            this.subscribers[actionId] = []
+        }
+        this.subscribers[actionId].push(fn)
+        return true
+    }
+
+    /**
+     * Unsubscribe to stop listening for a type of Action on a specific Function. Will only unsubscribe the Function
+     * once, so if the passed Function was subscribed multiple times, you will need to unsubscribe multiple times.
+     * @param action {typeof Action|number} The Action type to listen for. Can be an Action class, or an Action ID.
+     * @param fn {Function} The function to be called when the Action is received. Should be non-null. Should take
+     * one argument, which is the Action.
+     * @returns {boolean} True if the subscriber is added successfully, false otherwise. Returns true if the
+     * passed Function was never subscribed to the passed Action in the first place.
+     */
+    public unsubscribe(action: typeof Action|number, fn: Function) : boolean {
+        if(action == null || fn == null) {
+            return true
+        }
+
+        const actionId = typeof action == "number" ? action : action.id
+        if(this.subscribers[actionId] == null) {
+            return true
+        }
+        const index = this.subscribers[actionId].indexOf(fn)
+        if(index < 0 || index >= this.subscribers[actionId].length) {
+            return true
+        }
+        this.subscribers[actionId].splice(index, 1)
+
+        return true
+    }
+
+    /**
+     * Publish a new Action to this ActionBus, notifying all Functions subscribed to the type of Action published.
+     * @param action {Action} The action to publish. Should be non-null.
+     */
+    public publish(action: Action) : void {
+        if(action == null || this.subscribers[action.id] == null) {
+            return
+        }
+        for(let i = 0; i < this.subscribers[action.id].length; i++) {
+            this.subscribers[action.id][i](action)
+        }
+    }
+}
+
+export default ActionBus
diff --git a/actions/Resolver.ts b/actions/Resolver.ts
new file mode 100644
index 0000000..36a3aa5
--- /dev/null
+++ b/actions/Resolver.ts
@@ -0,0 +1,127 @@
+import Action from './Action'
+import EnableModAction from './clientbound/EnableModAction'
+import DisableModAction from './clientbound/DisableModAction'
+import SendChatComponentAction from './clientbound/SendChatComponentAction'
+import SystemOutAction from './clientbound/SystemOutAction'
+import ResetConfigAction from './clientbound/ResetConfigAction'
+import SendChatCommandAction from './clientbound/SendChatCommandAction'
+import SetAliasedActionAction from './clientbound/SetAliasedActionAction'
+import SetButtonAction from './clientbound/SetButtonAction'
+import SetScreenAction from './clientbound/SetScreenAction'
+import OpenGuiAction from './clientbound/OpenGuiAction'
+import OpenScreenAction from './clientbound/OpenScreenAction'
+import RefreshCacheAction from './clientbound/RefreshCacheAction'
+import SetCurrentServerAction from './clientbound/SetCurrentServerAction'
+import SetGlyphForUserAction from './clientbound/SetGlyphForUserAction'
+import SetKeybindsAction from './clientbound/SetKeybindsAction'
+import SetPremiumAboutAction from './clientbound/SetPremiumAboutAction'
+import SetTranslationAction from './clientbound/SetTranslationAction'
+import ButtonPressedAction from './serverbound/ButtonPressedAction'
+import ExceptionThrownAction from './serverbound/ExceptionThrownAction'
+import HypixelLocationChangedAction from './serverbound/HypixelLocationChangedAction'
+import MigrateKeybindsAction from './serverbound/MigrateKeybindsAction'
+import LanguageChangedAction from './serverbound/LanguageChangedAction'
+import ServerJoinedAction from './serverbound/ServerJoinedAction'
+import ServerLeftAction from './serverbound/ServerLeftAction'
+import InitializeClientAction from './serverbound/InitializeClientAction'
+import AuthBeginHandshakeAction from './clientbound/AuthBeginHandshakeAction'
+import AuthEndHandshakeAction from './serverbound/AuthEndHandshakeAction'
+import AuthCompleteAction from './clientbound/AuthCompleteAction'
+import {Buffer} from 'buffer'
+
+/**
+ * Action resolver - Resolves Actions from their base Action type, and deserializes Actions from Buffers into
+ * their Action objects. Does not need to be instantiated.
+ */
+export default class Resolver {
+
+    /**
+     * Mapping Actions from their IDs to their classes
+     */
+    private static actionMap = [
+        Action,
+        EnableModAction,
+        DisableModAction,
+        SendChatComponentAction,
+        SystemOutAction,
+        ResetConfigAction,
+        SendChatCommandAction,
+        SetAliasedActionAction,
+        SetButtonAction,
+        SetScreenAction,
+        OpenGuiAction,
+        OpenScreenAction,
+        RefreshCacheAction,
+        SetCurrentServerAction,
+        SetGlyphForUserAction,
+        SetKeybindsAction,
+        SetPremiumAboutAction,
+        SetTranslationAction,
+        ButtonPressedAction,
+        ExceptionThrownAction,
+        HypixelLocationChangedAction,
+        MigrateKeybindsAction,
+        LanguageChangedAction,
+        ServerJoinedAction,
+        ServerLeftAction,
+        InitializeClientAction,
+        AuthBeginHandshakeAction,
+        AuthEndHandshakeAction,
+        AuthCompleteAction
+    ]
+
+    /**
+     * Get an action from an ID.
+     * @param id ID of the action to get.
+     * @returns the Action, or null if there is no Action for the specified ID.
+     */
+    static get (id: number) : typeof Action {
+        if(id < 0 || id >= this.actionMap.length) {
+            return null
+        }
+        return this.actionMap[id]
+    }
+
+    /**
+     * Decode an Action from a Buffer
+     * @param buf {Buffer} Buffer to decode
+     */
+    static from (buf: Buffer) : Action {
+        const id = buf.readInt16BE(0)
+        const action = new Resolver.actionMap[id]()
+        action.id = id
+        let offset = 2
+        // Loop until the end of the buffer is reached
+        while(buf.byteLength > offset) {
+            // Read length of payload slice
+            const length = buf.readInt32BE(offset)
+            offset += 4
+            // Read payload slice
+            action.addPayload(buf.slice(offset, offset + length))
+            offset += length
+        }
+        return action
+    }
+
+    /**
+     * Deserialize an Action from JSON into its Action object.
+     * @param json {string} The JSON to deserialize.
+     */
+    static async deserialize(json: string): Promise<Action> {
+        const obj = JSON.parse(json)
+        const action = new Resolver.actionMap[obj.id]()
+        for(const prop in obj) {
+            if(!obj.hasOwnProperty(prop)) {
+                continue
+            }
+            action[prop] = obj[prop]
+        }
+        // Convert all Buffers from Objects into Buffer instances.
+        if(action.payloadObjs != null) {
+            for(let i = 0; i < action.payloadObjs.length; i++) {
+                action.payloadObjs[i] = Buffer.from((action.payloadObjs[i] as unknown as {data: number[]}).data)
+            }
+        }
+        return action
+    }
+}
diff --git a/actions/clientbound/AuthBeginHandshakeAction.ts b/actions/clientbound/AuthBeginHandshakeAction.ts
new file mode 100644
index 0000000..e718ca1
--- /dev/null
+++ b/actions/clientbound/AuthBeginHandshakeAction.ts
@@ -0,0 +1,28 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 26
+ * Begin authentication with the backend by sending a handshake token to the client.
+ *
+ * Payload Order:
+ * Handshake token
+ */
+class AuthBeginHandshakeAction extends Action {
+
+    /**
+	 * Create a new AuthBeginHandshakeAction.
+	 * @param handshakeToken {string} Handshake token to send
+	 */
+    constructor (handshakeToken?: string) {
+        super()
+        this.id = 26
+        if(handshakeToken == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(handshakeToken))
+    }
+}
+
+export default AuthBeginHandshakeAction
diff --git a/actions/clientbound/AuthCompleteAction.ts b/actions/clientbound/AuthCompleteAction.ts
new file mode 100644
index 0000000..7c73aa4
--- /dev/null
+++ b/actions/clientbound/AuthCompleteAction.ts
@@ -0,0 +1,33 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 28
+ * Finalize authentication by sending the client a session token and when this session expires
+ *
+ * Payload Order:
+ * Session token
+ * Expiration timestamp
+ */
+class AuthCompleteAction extends Action {
+
+    /**
+     * Create a new AuthCompleteAction.
+     * @param sessionToken {string} Session token to send
+     * @param expiration {Date} Timestamp at which this session expires
+     */
+    constructor (sessionToken?: string, expiration?: Date) {
+        super()
+        this.id = 28
+        if(sessionToken == undefined || expiration == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(sessionToken))
+        const buf = Buffer.alloc(4)
+        buf.writeUInt32BE(expiration.getTime(), 0)
+        this.addPayload(buf)
+    }
+}
+
+export default AuthCompleteAction
diff --git a/actions/clientbound/DisableModAction.ts b/actions/clientbound/DisableModAction.ts
new file mode 100644
index 0000000..8d2ccde
--- /dev/null
+++ b/actions/clientbound/DisableModAction.ts
@@ -0,0 +1,30 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 2
+ * Disable the Quickplay mod for the receiving client.
+ *
+ * Payload Order:
+ * Reason
+ */
+class DisableModAction extends Action {
+
+    /**
+	 * Create a new DisableModAction.
+     * @param reason {string} The reason the mod was disabled
+	 */
+    constructor (reason?: string) {
+        super()
+        this.id = 2
+
+        // Don't add payload if the first payload item wasn't provided
+        if(reason == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(reason))
+    }
+}
+
+export default DisableModAction
diff --git a/actions/clientbound/EnableModAction.ts b/actions/clientbound/EnableModAction.ts
new file mode 100644
index 0000000..b0dba5d
--- /dev/null
+++ b/actions/clientbound/EnableModAction.ts
@@ -0,0 +1,18 @@
+import Action from '../Action'
+
+/**
+ * ID: 1
+ * Enable the Quickplay mod for the receiving client.
+ */
+class EnableModAction extends Action {
+
+    /**
+	 * Create a new EnableModAction.
+	 */
+    constructor () {
+        super()
+        this.id = 1
+    }
+}
+
+export default EnableModAction
diff --git a/actions/clientbound/OpenGuiAction.ts b/actions/clientbound/OpenGuiAction.ts
new file mode 100644
index 0000000..5b02816
--- /dev/null
+++ b/actions/clientbound/OpenGuiAction.ts
@@ -0,0 +1,38 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 10
+ * Open a class with the specified classpath as a GUI on the client. Should extend GuiScreen.
+ *
+ * Payload Order:
+ * class path
+ * Each argument is an individual item
+ */
+class OpenGuiAction extends Action {
+
+    /**
+     * Create a new OpenGuiAction.
+     * @param classpath {string} The path of the class to open as a GUI.
+     * @param args {string[]} The arguments to pass to the class constructor.
+     */
+    constructor (classpath?: string, ...args: string[]) {
+        super()
+        this.id = 10
+
+        // Don't add payload if the first payload item wasn't provided
+        if(classpath == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(classpath))
+        if(args.length <= 0) {
+            return
+        }
+        for(let i = 0; i < args.length; i++) {
+            this.addPayload(Buffer.from(args[i]))
+        }
+    }
+}
+
+export default OpenGuiAction
diff --git a/actions/clientbound/OpenScreenAction.ts b/actions/clientbound/OpenScreenAction.ts
new file mode 100644
index 0000000..31b3848
--- /dev/null
+++ b/actions/clientbound/OpenScreenAction.ts
@@ -0,0 +1,30 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 11
+ * Open a screen on the client. The client should have already been sent this screen this session.
+ *
+ * Payload Order:
+ * screen name
+ */
+class OpenScreenAction extends Action {
+
+    /**
+	 * Create a new OpenScreenAction.
+	 * @param screenName {string} The name of the screen that the client should open.
+	 */
+    constructor (screenName?: string) {
+        super()
+        this.id = 11
+
+        // Don't add payload if the first payload item wasn't provided
+        if(screenName == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(screenName))
+    }
+}
+
+export default OpenScreenAction
diff --git a/actions/clientbound/RefreshCacheAction.ts b/actions/clientbound/RefreshCacheAction.ts
new file mode 100644
index 0000000..b23e0de
--- /dev/null
+++ b/actions/clientbound/RefreshCacheAction.ts
@@ -0,0 +1,20 @@
+import Action from '../Action'
+
+/**
+ * ID: 12
+ * Delete all cached files/images/etc on the client and force them to be recreated.
+ * Does not delete session cache (e.g. screen list), but cache that persists across
+ * sessions (e.g. directory with Glyph images).
+ */
+class RefreshCacheAction extends Action {
+
+    /**
+	 * Create a new RefreshCacheAction.
+	 */
+    constructor () {
+        super()
+        this.id = 12
+    }
+}
+
+export default RefreshCacheAction
diff --git a/actions/clientbound/ResetConfigAction.ts b/actions/clientbound/ResetConfigAction.ts
new file mode 100644
index 0000000..a2c42db
--- /dev/null
+++ b/actions/clientbound/ResetConfigAction.ts
@@ -0,0 +1,18 @@
+import Action from '../Action'
+
+/**
+ * ID: 5
+ * Reset the client's configuration. Use sparingly.
+ */
+class ResetConfigAction extends Action {
+
+    /**
+	 * Create a new ResetConfigAction.
+	 */
+    constructor () {
+        super()
+        this.id = 5
+    }
+}
+
+export default ResetConfigAction
diff --git a/actions/clientbound/SendChatCommandAction.ts b/actions/clientbound/SendChatCommandAction.ts
new file mode 100644
index 0000000..d80c695
--- /dev/null
+++ b/actions/clientbound/SendChatCommandAction.ts
@@ -0,0 +1,35 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 6
+ * Send a command to the server the client is connected to.
+ *
+ * Payload Order:
+ * Chat command
+ */
+class SendChatCommandAction extends Action {
+
+    /**
+	 * Create a new SendChatCommandAction.
+	 * @param cmd {string} Command to send. Beginning slash will automatically be removed if provided,
+	 * and the client will add it back. To run a command that begins with two slashes (e.g. //wand, like WorldEdit), you
+	 * must provide both slashes.
+	 */
+    constructor (cmd?: string) {
+        super()
+        this.id = 6
+
+        // Don't add payload if the first payload item wasn't provided
+        if(cmd == undefined) {
+            return
+        }
+
+        if (cmd.startsWith('/')) { // Remove beginning slash if provided.
+            cmd = cmd.slice(1)
+        }
+        this.addPayload(Buffer.from(cmd))
+    }
+}
+
+export default SendChatCommandAction
diff --git a/actions/clientbound/SendChatComponentAction.ts b/actions/clientbound/SendChatComponentAction.ts
new file mode 100644
index 0000000..50cab1e
--- /dev/null
+++ b/actions/clientbound/SendChatComponentAction.ts
@@ -0,0 +1,31 @@
+import Action from '../Action'
+import Message from '../../chat-components/Message'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 3
+ * Send a Quickplay chat message to the client's chat.
+ *
+ * Payload Order:
+ * Chat component
+ */
+class SendChatComponentAction extends Action {
+
+    /**
+	 * Create a new SendChatComponentAction.
+	 * @param component {Message} Chat component message for the client to send
+	 */
+    constructor (component?: Message) {
+        super()
+        this.id = 3
+
+        // Don't add payload if the first payload item wasn't provided
+        if(component == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(JSON.stringify(component)))
+    }
+}
+
+export default SendChatComponentAction
diff --git a/actions/clientbound/SetAliasedActionAction.ts b/actions/clientbound/SetAliasedActionAction.ts
new file mode 100644
index 0000000..bb24fac
--- /dev/null
+++ b/actions/clientbound/SetAliasedActionAction.ts
@@ -0,0 +1,35 @@
+import Action from '../Action'
+import AliasedAction from "../../AliasedAction"
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 7
+ * Set an aliased action in the client with the provided key and parameters.
+ *
+ * Payload Order:
+ * key
+ * availableOn JSON array
+ * The Action built as normal
+ */
+class SetAliasedActionAction extends Action {
+
+    /**
+     * Create a new SetAliasedActionAction.
+     * @param aliasedAction {AliasedAction} Aliased action to be saved to the client.
+     */
+    constructor (aliasedAction?: AliasedAction) {
+        super()
+        this.id = 7
+
+        // Don't add payload if the first payload item wasn't provided
+        if(aliasedAction == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(aliasedAction.key))
+        this.addPayload(Buffer.from(JSON.stringify(aliasedAction.availableOn || [])))
+        this.addPayload(aliasedAction.action.build())
+    }
+}
+
+export default SetAliasedActionAction
diff --git a/actions/clientbound/SetButtonAction.ts b/actions/clientbound/SetButtonAction.ts
new file mode 100644
index 0000000..e46fc98
--- /dev/null
+++ b/actions/clientbound/SetButtonAction.ts
@@ -0,0 +1,39 @@
+import Action from '../Action'
+import Button from "../../Button"
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 8
+ * Set a button in the client with the provided key and parameters.
+ *
+ * Payload Order:
+ * key
+ * availableOn JSON array
+ * actions JSON array of aliased action keys
+ * imageURL
+ * translationKey
+ */
+class SetButtonAction extends Action {
+
+    /**
+     * Create a new SetButtonAction.
+     * @param button {Button} Button to be saved to the client.
+     */
+    constructor (button?: Button) {
+        super()
+        this.id = 8
+
+        // Don't add payload if the first payload item wasn't provided
+        if(button == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(button.key))
+        this.addPayload(Buffer.from(JSON.stringify(button.availableOn || [])))
+        this.addPayload(Buffer.from(JSON.stringify(button.actions || [])))
+        this.addPayload(Buffer.from(button.imageURL || ''))
+        this.addPayload(Buffer.from(button.translationKey || ''))
+    }
+}
+
+export default SetButtonAction
diff --git a/actions/clientbound/SetCurrentServerAction.ts b/actions/clientbound/SetCurrentServerAction.ts
new file mode 100644
index 0000000..89bd46b
--- /dev/null
+++ b/actions/clientbound/SetCurrentServerAction.ts
@@ -0,0 +1,35 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 13
+ * Notify the client that it's changed to a recognized (or unrecognized) server by Quickplay.
+ * If server is not recognized or client is not connected to a server, "unknown" should be sent.
+ *
+ * Quickplay supports multiple servers. When the client reports a serverbound ServerJoinedAction, the server will
+ * respond with this, saying what server it thinks the client is currently on, based on the information provided by the client.
+ * This will correspond to actions, screens, etc. and what servers they are available on.
+ *
+ * Payload Order:
+ * server name
+ */
+class SetCurrentServerAction extends Action {
+
+    /**
+	 * Create a new SetCurrentServerAction.
+	 * @param serverName {string} The name of the server that the client has connected to.
+	 */
+    constructor (serverName?: string) {
+        super()
+        this.id = 13
+
+        // Don't add payload if the first payload item wasn't provided
+        if(serverName == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(serverName))
+    }
+}
+
+export default SetCurrentServerAction
diff --git a/actions/clientbound/SetGlyphForUserAction.ts b/actions/clientbound/SetGlyphForUserAction.ts
new file mode 100644
index 0000000..b863d8d
--- /dev/null
+++ b/actions/clientbound/SetGlyphForUserAction.ts
@@ -0,0 +1,47 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 14
+ * Set the URL for a user's Glyph. The client will download this image if it is necessary.
+ *
+ * Payload Order:
+ * user UUID
+ * glyph URL
+ * glyph height (32intBE)
+ * glyph offset (floatBE)
+ * glyph in-game visibility (1byte, 1 or 0 for boolean)
+ */
+class SetGlyphForUserAction extends Action {
+
+    /**
+     * Create a new SetGlyphForUserAction.
+     * @param uuid {string} The UUID of the user for which this Glyph belongs.
+     * @param url {string} The URL of the Glyph.
+     * @param height {number} The height of this glyph
+     * @param yOffset {number} The offset from the top of the player of this glyph
+     * @param displayInGames {boolean} Whether this glyph should be displayed in games or not.
+     */
+    constructor (uuid?: string, url?: string, height?: number, yOffset?: number, displayInGames?: boolean) {
+        super()
+        this.id = 14
+
+        // Don't add payload if the first payload item wasn't provided
+        if(uuid == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(uuid))
+        this.addPayload(Buffer.from(url))
+        const heightBuf = Buffer.alloc(4)
+        heightBuf.writeInt32BE(height, 0)
+        this.addPayload(heightBuf)
+        const offsetBuf = Buffer.alloc(8)
+        offsetBuf.writeFloatBE(height, 0)
+        this.addPayload(offsetBuf)
+        const displayInGamesBuf = Buffer.alloc(1)
+        displayInGamesBuf.writeUInt8(displayInGames ? 1 : 0, 0)
+    }
+}
+
+export default SetGlyphForUserAction
diff --git a/actions/clientbound/SetKeybindsAction.ts b/actions/clientbound/SetKeybindsAction.ts
new file mode 100644
index 0000000..9abd0af
--- /dev/null
+++ b/actions/clientbound/SetKeybindsAction.ts
@@ -0,0 +1,32 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 15
+ * Set the list keybinds to a new JSON object for this user.
+ * This is currently only used to migrate keybinds from pre-2.1.0 to post-2.1.0.
+ * @see MigrateKeybindsAction
+ *
+ * Payload Order:
+ * valid JSON that goes into keybinds.json
+ */
+class SetKeybindsAction extends Action {
+
+    /**
+	 * Create a new SetKeybindsAction.
+	 * @param keybinds {Record<string, ?>[]} New keybinds to serialize and send to the client.
+	 */
+    constructor (keybinds?: Record<string, unknown>[]) {
+        super()
+        this.id = 15
+
+        // Don't add payload if the first payload item wasn't provided
+        if(keybinds == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(JSON.stringify(keybinds)))
+    }
+}
+
+export default SetKeybindsAction
diff --git a/actions/clientbound/SetPremiumAboutAction.ts b/actions/clientbound/SetPremiumAboutAction.ts
new file mode 100644
index 0000000..2ed8fb6
--- /dev/null
+++ b/actions/clientbound/SetPremiumAboutAction.ts
@@ -0,0 +1,31 @@
+import Action from '../Action'
+import ChatComponent from '../../chat-components/ChatComponent'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 16
+ * Set the Quickplay Premium about text.
+ *
+ * Payload Order:
+ * about text chat component
+ */
+class SetPremiumAboutAction extends Action {
+
+    /**
+	 * Create a new SetPremiumAboutAction.
+	 * @param component {ChatComponent} Chat component to set the about text to.
+	 */
+    constructor (component?: ChatComponent) {
+        super()
+        this.id = 16
+
+        // Don't add payload if the first payload item wasn't provided
+        if(component == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(JSON.stringify(component)))
+    }
+}
+
+export default SetPremiumAboutAction
diff --git a/actions/clientbound/SetScreenAction.ts b/actions/clientbound/SetScreenAction.ts
new file mode 100644
index 0000000..1bc8dc7
--- /dev/null
+++ b/actions/clientbound/SetScreenAction.ts
@@ -0,0 +1,43 @@
+import Action from '../Action'
+import Screen from "../../Screen"
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 9
+ * Set a screen in the client with the provided key and parameters.
+ *
+ * Payload Order:
+ * key
+ * screenType
+ * availableOn JSON array
+ * buttons JSON array of button keys
+ * backButtonActions JSON array of aliased action keys which execute when the back button is pressed
+ * translationKey
+ * imageURL
+ */
+class SetScreenAction extends Action {
+
+    /**
+     * Create a new SetScreenAction.
+     * @param screen {Screen} Screen to be saved to the client.
+     */
+    constructor (screen?: Screen) {
+        super()
+        this.id = 9
+
+        // Don't add payload if the first payload item wasn't provided
+        if(screen == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(screen.key))
+        this.addPayload(Buffer.from(screen.screenType))
+        this.addPayload(Buffer.from(JSON.stringify(screen.availableOn || [])))
+        this.addPayload(Buffer.from(JSON.stringify(screen.buttons || [])))
+        this.addPayload(Buffer.from(JSON.stringify(screen.backButtonActions || [])))
+        this.addPayload(Buffer.from(screen.translationKey || ''))
+        this.addPayload(Buffer.from(screen.imageURL || ''))
+    }
+}
+
+export default SetScreenAction
diff --git a/actions/clientbound/SetTranslationAction.ts b/actions/clientbound/SetTranslationAction.ts
new file mode 100644
index 0000000..d1f525f
--- /dev/null
+++ b/actions/clientbound/SetTranslationAction.ts
@@ -0,0 +1,36 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 17
+ * Set the translation value of a specified key in a specified language.
+ *
+ * Payload Order:
+ * key
+ * language
+ * value
+ */
+class SetTranslationAction extends Action {
+
+    /**
+	 * Create a new SetTranslationAction.
+     * @param key {string} The key of the translation to set.
+     * @param lang {string} The language to set the key for.
+     * @param val {string} The value to set the key to.
+	 */
+    constructor (key?: string, lang?: string, val?: string) {
+        super()
+        this.id = 17
+
+        // Don't add payload if the first payload item wasn't provided
+        if(key == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(key))
+        this.addPayload(Buffer.from(lang))
+        this.addPayload(Buffer.from(val || ''))
+    }
+}
+
+export default SetTranslationAction
diff --git a/actions/clientbound/SystemOutAction.ts b/actions/clientbound/SystemOutAction.ts
new file mode 100644
index 0000000..7764438
--- /dev/null
+++ b/actions/clientbound/SystemOutAction.ts
@@ -0,0 +1,27 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * ID: 4
+ * Send a message to the client's system.out. Mainly used for debugging.
+ */
+class SystemOutAction extends Action {
+
+    /**
+	 * Create a new SystemOutAction.
+	 * @param message {string} the message to send to the client's logs
+	 */
+    constructor (message?: string) {
+        super()
+        this.id = 4
+
+        // Don't add payload if the first payload item wasn't provided
+        if(message == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(message))
+    }
+}
+
+export default SystemOutAction
diff --git a/actions/serverbound/AuthEndHandshakeAction.ts b/actions/serverbound/AuthEndHandshakeAction.ts
new file mode 100644
index 0000000..a2e7493
--- /dev/null
+++ b/actions/serverbound/AuthEndHandshakeAction.ts
@@ -0,0 +1,31 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * SERVERBOUND - Server should not instantiate.
+ * ID: 27
+ * Received by the server when the client is done authenticating with
+ * Mojang's servers, and Quickplay's backend should check for authenticity.
+ *
+ * Payload Order:
+ * Minecraft username
+ */
+class AuthEndHandshakeAction extends Action {
+
+    /**
+	 * Create a new AuthEndHandshakeAction.
+     * @param username {string} The current client's username
+	 */
+    constructor (username?: string) {
+        super()
+        this.id = 27
+
+        if(username == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(username || ''))
+    }
+}
+
+export default AuthEndHandshakeAction
diff --git a/actions/serverbound/ButtonPressedAction.ts b/actions/serverbound/ButtonPressedAction.ts
new file mode 100644
index 0000000..f3992b0
--- /dev/null
+++ b/actions/serverbound/ButtonPressedAction.ts
@@ -0,0 +1,31 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * SERVERBOUND - Server should not instantiate.
+ * ID: 18
+ * Received by the server when the client has pressed a Quickplay button, or a keybind which points to a button.
+ *
+ * Payload Order:
+ * Button key
+ */
+class ButtonPressedAction extends Action {
+
+    /**
+	 * Create a new ButtonPressedAction.
+	 * @param buttonKey {string} The key of the button which was pressed
+	 */
+    constructor (buttonKey?: string) {
+        super()
+        this.id = 18
+
+        // Don't add payload if the first payload item wasn't provided
+        if(buttonKey == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(buttonKey))
+    }
+}
+
+export default ButtonPressedAction
diff --git a/actions/serverbound/ExceptionThrownAction.ts b/actions/serverbound/ExceptionThrownAction.ts
new file mode 100644
index 0000000..a0e14a1
--- /dev/null
+++ b/actions/serverbound/ExceptionThrownAction.ts
@@ -0,0 +1,68 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * SERVERBOUND - Server should not instantiate.
+ * ID: 19
+ * Received by the server when an exception is reported by the client.
+ *
+ * This Action should NOT be sent if the user has not agreed to send this data.
+ *
+ * If you are a third party implementing Quickplay into your client, you may remove this Action from your client.
+ * Any exceptions which are not sent by a user agent maintained by Quickplay developers will be disregarded. If you
+ * wish for this information to be sent to you, create your own system or get in contact on the Quickplay Discord.
+ *
+ * If any of this information does not apply to your client, send an empty payload for that item.
+ *
+ * Payload Order:
+ * The type of the exception
+ * The message of the exception
+ * The stacktrace of the exception
+ * Minecraft version
+ * Client version
+ * Java version
+ * OS name
+ * Enabled state
+ * Current IP
+ */
+class ExceptionThrownAction extends Action {
+
+    /**
+     * Create a new ExceptionThrownAction.
+     * @param type {string} The type of this exception.
+     * @param message {string} The message of this exception.
+     * @param stacktrace {string} The stacktrace of this exception.
+     * @param mcVersion Minecraft version.
+     * @param clientVersion Version of the client the user is using.
+     * @param javaVersion Java version.
+     * @param osName Operating system name.
+     * @param enabledState Whether Quickplay is enabled or not.
+     * @param currentIp The Minecraft server IP the client is currently connected to.
+     */
+    constructor (type?: string, message?: string, stacktrace?: string, mcVersion?: string, clientVersion?: string,
+        javaVersion?: string, osName?: string, enabledState?: boolean, currentIp?: string) {
+        super()
+        this.id = 19
+
+        // Don't add payload if the first payload item wasn't provided
+        if(type == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(type))
+        this.addPayload(Buffer.from(message))
+        this.addPayload(Buffer.from(stacktrace))
+        this.addPayload(Buffer.from(mcVersion))
+        this.addPayload(Buffer.from(clientVersion))
+        this.addPayload(Buffer.from(javaVersion))
+        this.addPayload(Buffer.from(osName))
+
+        const buf = Buffer.alloc(1)
+        buf.writeUInt8(enabledState ? 1 : 0, 0)
+        this.addPayload(buf)
+
+        this.addPayload(Buffer.from(currentIp))
+    }
+}
+
+export default ExceptionThrownAction
diff --git a/actions/serverbound/HypixelLocationChangedAction.ts b/actions/serverbound/HypixelLocationChangedAction.ts
new file mode 100644
index 0000000..5b43aa4
--- /dev/null
+++ b/actions/serverbound/HypixelLocationChangedAction.ts
@@ -0,0 +1,31 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * SERVERBOUND - Server should not instantiate.
+ * ID: 20
+ * Received by the server when the client changes locations on Hypixel.
+ *
+ * Payload Order:
+ * Location JSON
+ */
+class HypixelLocationChangedAction extends Action {
+
+    /**
+	 * Create a new HypixelLocationChangedAction.
+	 * @param locationJson {string} JSON about this player's location.
+	 */
+    constructor (locationJson?: string) {
+        super()
+        this.id = 20
+
+        // Don't add payload if the first payload item wasn't provided
+        if(locationJson == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(locationJson))
+    }
+}
+
+export default HypixelLocationChangedAction
diff --git a/actions/serverbound/InitializeClientAction.ts b/actions/serverbound/InitializeClientAction.ts
new file mode 100644
index 0000000..b7c6b66
--- /dev/null
+++ b/actions/serverbound/InitializeClientAction.ts
@@ -0,0 +1,66 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * SERVERBOUND - Server should not instantiate.
+ * ID: 25
+ * Received by the server when the client first initializes the socket. Intended to send client metadata.
+ *
+ * As an attempt to make porting Quickplay to other clients as easy as possible, only the first three payload items
+ * are required. If you are a third party implementing Quickplay into your client, the other items may not be
+ * relevant to your client, or your implementation or legal obligations may vary, rendering them difficult or
+ * impossible to include. Additionally, they are not relevant to the Quickplay backend, but instead are used
+ * to target a better user experience, debug issues, and gather user analytics.
+ *
+ * On the other hand, the player UUID, user agent, Quickplay version, and Minecraft language ARE required. The
+ * Quickplay backend uses these items to determine what actions to send to the user, and what those actions should
+ * contain in their payload. If these items are not included, the socket connection will be disconnected. If they are
+ * not accurate, the user could receive actions which they should not receive, which could result in incorrect
+ * buttons/translations or, at worst, client crashes.
+ *
+ * If a player UUID is not relevant to your client (e.g. your client only supports offline mode), submit a UUID of
+ * all 0's. If you are not sure what your Quickplay user agent should be, it does not matter as long as you are
+ * confident that it is unique to your client. If you are not sure what your Quickplay version should be, use the
+ * version of Quickplay from which you are porting. If a Minecraft language is not relevant to your client, use
+ * the default language of your client or "en_US".
+ *
+ * Payload Order:
+ * Player UUID
+ * User agent - This is the name of the client which the user is using.
+ * Quickplay version
+ * Minecraft language
+ * Minecraft version
+ * Client version - This is the version of the user agent, e.g. for Forge, it'd be the Forge version.
+ */
+class InitializeClientAction extends Action {
+
+    /**
+     * Create a new InitializeClientAction.
+     */
+    constructor (uuid?: string, userAgent?: string, qpVersion?: string, lang?: string, mcVersion?: string, clientVersion?: string) {
+        super()
+        this.id = 25
+
+        // Don't add payload if the first payload item wasn't provided
+        if(uuid == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(uuid))
+        this.addPayload(Buffer.from(userAgent))
+        this.addPayload(Buffer.from(qpVersion))
+        this.addPayload(Buffer.from(lang))
+
+        if(mcVersion == null) {
+            mcVersion = ''
+        }
+        if(clientVersion == null) {
+            clientVersion = ''
+        }
+
+        this.addPayload(Buffer.from(mcVersion))
+        this.addPayload(Buffer.from(clientVersion))
+    }
+}
+
+export default InitializeClientAction
diff --git a/actions/serverbound/LanguageChangedAction.ts b/actions/serverbound/LanguageChangedAction.ts
new file mode 100644
index 0000000..f4a8fc1
--- /dev/null
+++ b/actions/serverbound/LanguageChangedAction.ts
@@ -0,0 +1,31 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * SERVERBOUND - Server should not instantiate.
+ * ID: 22
+ * Received by the server when the client changes languages.
+ *
+ * Payload Order:
+ * New language ID
+ */
+class LanguageChangedAction extends Action {
+
+    /**
+	 * Create a new LanguageChangedAction.
+	 * @param langId {string} New language ID
+	 */
+    constructor (langId?: string) {
+        super()
+        this.id = 22
+
+        // Don't add payload if the first payload item wasn't provided
+        if(langId == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(langId))
+    }
+}
+
+export default LanguageChangedAction
diff --git a/actions/serverbound/MigrateKeybindsAction.ts b/actions/serverbound/MigrateKeybindsAction.ts
new file mode 100644
index 0000000..bbb5d06
--- /dev/null
+++ b/actions/serverbound/MigrateKeybindsAction.ts
@@ -0,0 +1,33 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * SERVERBOUND - Server should not instantiate.
+ * ID: 21
+ * Send the list keybinds to the server so the server can respond with a migrated keybinds list.
+ * This is currently only used to migrate keybinds from pre-2.1.0 to post-2.1.0.
+ * @see SetKeybindsAction
+ *
+ * Payload Order:
+ * valid JSON that goes into keybinds.json FROM QP 2.0.3 or earlier.
+ */
+class MigrateKeybindsAction extends Action {
+
+    /**
+     * Create a new MigrateKeybindsAction.
+     * @param keybinds {Record<string, ?>[]} New keybinds to serialize and send to the server.
+     */
+    constructor (keybinds?: Record<string, unknown>[]) {
+        super()
+        this.id = 21
+
+        // Don't add payload if the first payload item wasn't provided
+        if(keybinds == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(JSON.stringify(keybinds)))
+    }
+}
+
+export default MigrateKeybindsAction
diff --git a/actions/serverbound/ServerJoinedAction.ts b/actions/serverbound/ServerJoinedAction.ts
new file mode 100644
index 0000000..45834fe
--- /dev/null
+++ b/actions/serverbound/ServerJoinedAction.ts
@@ -0,0 +1,35 @@
+import Action from '../Action'
+import {Buffer} from 'buffer'
+
+/**
+ * SERVERBOUND - Server should not instantiate.
+ * ID: 23
+ * Received by the server when the client connects to a new Minecraft server.
+ * Could be singleplayer, in which case the IP is "singleplayer".
+ *
+ * Payload Order:
+ * The IP of the server joined
+ * Metadata JSON about the server
+ */
+class ServerJoinedAction extends Action {
+
+    /**
+     * Create a new ServerJoinedAction.
+     * @param ip {string} The IP of the server the client joined.
+     * @param metadata {string} JSON data about the server the client joined, e.g. logo.
+     */
+    constructor (ip?: string, metadata?: string) {
+        super()
+        this.id = 23
+
+        // Don't add payload if the first payload item wasn't provided
+        if(ip == undefined) {
+            return
+        }
+
+        this.addPayload(Buffer.from(ip))
+        this.addPayload(Buffer.from(JSON.stringify(metadata)))
+    }
+}
+
+export default ServerJoinedAction
diff --git a/actions/serverbound/ServerLeftAction.ts b/actions/serverbound/ServerLeftAction.ts
new file mode 100644
index 0000000..e38fedc
--- /dev/null
+++ b/actions/serverbound/ServerLeftAction.ts
@@ -0,0 +1,19 @@
+import Action from '../Action'
+
+/**
+ * SERVERBOUND - Server should not instantiate.
+ * ID: 24
+ * Received by the server when the client disconnects from the server they were previously on.
+ */
+class ServerLeftAction extends Action {
+
+    /**
+     * Create a new ServerLeftAction.
+     */
+    constructor () {
+        super()
+        this.id = 24
+    }
+}
+
+export default ServerLeftAction
diff --git a/chat-components/ChatComponent.ts b/chat-components/ChatComponent.ts
new file mode 100644
index 0000000..1d6a016
--- /dev/null
+++ b/chat-components/ChatComponent.ts
@@ -0,0 +1,171 @@
+import ChatFormatting from './ChatFormatting'
+import ClickEvent from './ClickEvent'
+import HoverEvent from './HoverEvent'
+
+/**
+ * JavaScript implementation of Minecraft's ChatComponent. Can be serialized to JSON and deserialized by the client.
+ */
+class ChatComponent {
+
+    /**
+     * Text of the chat component.
+     */
+    text = ''
+    /**
+     * Color of the chat component.
+     * @see ChatFormatting
+     */
+    color: string
+    /**
+     * ClickEvent when this chat component is clicked.
+     * @see ClickEvent
+     */
+    clickEvent: ClickEvent
+    /**
+     * HoverEvent when this chat component is hovered over.
+     * @see HoverEvent
+     */
+    hoverEvent: HoverEvent
+    /**
+     * Whether this chat component's text is italicized.
+     */
+    italic: boolean
+    /**
+     * Whether this chat component's text is obfuscated.
+     */
+    obfuscated: boolean
+    /**
+     * Whether this chat component's text is bolded.
+     */
+    bold: boolean
+    /**
+     * Whether this chat component's text is underlined.
+     */
+    underline: boolean
+    /**
+     * Whether this chat component's text is striked through.
+     */
+    strikethrough: boolean
+    /**
+     * Extra chat components to be appended to this ChatComponent.
+     */
+    extra: ChatComponent[]
+
+    constructor(text: string) {
+        this.setColor(ChatFormatting.white)
+        this.text = text
+    }
+
+    /**
+     * Setter for {@link color}
+     * @see ChatFormatting
+     * @param color {string} Color to set to. Should be an item in {@link ChatFormatting}
+     */
+    setColor(color: string): ChatComponent {
+        for(const loopColor in ChatFormatting) {
+            if (ChatFormatting.hasOwnProperty(loopColor) && ChatFormatting[loopColor] === color) {
+                this.color = loopColor
+                return this
+            }
+        }
+
+        throw new Error('Invalid color! Must be property of ChatFormatting.')
+    }
+
+    /**
+     * Setter for {@link clickEvent}
+     * @see ClickEvent
+     * @param clickEvent {ClickEvent} new ClickEvent
+     */
+    setClickEvent(clickEvent: ClickEvent): ChatComponent {
+        if(clickEvent instanceof ClickEvent) {
+            this.clickEvent = clickEvent
+            return this
+        } else {
+            throw new Error('Invalid clickEvent! Must be of type ClickEvent.')
+        }
+    }
+
+    /**
+     * Setter for {@link hoverEvent}
+     * @see HoverEvent
+     * @param hoverEvent {HoverEvent} new HoverEvent
+     */
+    setHoverEvent(hoverEvent: HoverEvent): ChatComponent {
+        if(hoverEvent instanceof HoverEvent) {
+            this.hoverEvent = hoverEvent
+            return this
+        } else {
+            throw new Error('Invalid hoverEvent! Must be of type HoverEvent.')
+        }
+    }
+
+    /**
+     * Setter for {@link italic}
+     * @param bool {boolean} new italic status
+     */
+    setItalic(bool: boolean): ChatComponent {
+        this.italic = !!bool
+        return this
+    }
+
+    /**
+     * Setter for {@link obfuscated}
+     * @param bool {boolean} new obfuscated status
+     */
+    setObfuscated(bool: boolean): ChatComponent {
+        this.obfuscated = !!bool
+        return this
+    }
+
+    /**
+     * Setter for {@link strikethrough}
+     * @param bool {boolean} new strikethrough status
+     */
+    setStrikethrough(bool: boolean): ChatComponent {
+        this.strikethrough = !!bool
+        return this
+    }
+
+    /**
+     * Setter for {@link bold}
+     * @param bool {boolean} new bold status
+     */
+    setBold(bool: boolean): ChatComponent {
+        this.bold = !!bool
+        return this
+    }
+
+    /**
+     * Setter for {@link underline}
+     * @param bool {boolean} new underline status
+     */
+    setUnderline(bool: boolean): ChatComponent {
+        this.underline = !!bool
+        return this
+    }
+
+    /**
+     * Append a new ChatComponent to this chat component.
+     * @param sibling {ChatComponent} Component to append.
+     */
+    appendSibling(sibling: ChatComponent): ChatComponent {
+        if(!Array.isArray(this.extra)) {
+            this.extra = []
+        }
+
+        this.extra.push(sibling)
+        return this
+    }
+
+    /**
+     * Append text to this chat component.
+     * @param text {string} Text to append.
+     */
+    appendText(text: string): ChatComponent {
+        this.text += text
+        return this
+    }
+}
+
+export default ChatComponent
diff --git a/chat-components/ChatFormatting.ts b/chat-components/ChatFormatting.ts
new file mode 100644
index 0000000..7e7cc76
--- /dev/null
+++ b/chat-components/ChatFormatting.ts
@@ -0,0 +1,20 @@
+enum ChatFormatting {
+    black= '§0',
+    dark_blue= '§1',
+    dark_green= '§2',
+    dark_aqua= '§3',
+    dark_red= '§4',
+    dark_purple= '§5',
+    gold= '§6',
+    gray= '§7',
+    dark_gray= '§8',
+    blue= '§9',
+    green= '§a',
+    aqua= '§b',
+    red= '§c',
+    light_purple= '§d',
+    yellow= '§e',
+    white= '§f'
+}
+
+export default ChatFormatting
diff --git a/chat-components/ClickEvent.ts b/chat-components/ClickEvent.ts
new file mode 100644
index 0000000..8e942e9
--- /dev/null
+++ b/chat-components/ClickEvent.ts
@@ -0,0 +1,78 @@
+
+const ClickEventAction = Object.freeze({
+    OPEN_URL: {
+        allowedInChat: true,
+        canonicalName: 'open_url'
+    },
+    OPEN_FILE: {
+        allowedInChat: false,
+        canonicalName: 'open_file'
+    },
+    RUN_COMMAND: {
+        allowedInChat: true,
+        canonicalName: 'run_command'
+    },
+    TWITCH_USER_INFO: {
+        allowedInChat: false,
+        canonicalName: 'twitch_user_info'
+    },
+    SUGGEST_COMMAND: {
+        allowedInChat: true,
+        canonicalName: 'suggest_command'
+    },
+    CHANGE_PAGE: {
+        allowedInChat: true,
+        canonicalName: 'change_page'
+    }
+})
+
+interface ClickEventAction {
+    allowedInChat: boolean, canonicalName: string
+}
+
+/**
+ * Click events in Minecraft are fired when the user clicks on a ChatComponent with a given ClickEvent.
+ */
+class ClickEvent {
+
+    /**
+     * Canonical name of the action
+     */
+    action: string
+    /**
+     * Value of the action
+     */
+    value: string
+
+    constructor(action: ClickEventAction, value: string) {
+        this.setAction(action)
+        this.setValue(value)
+    }
+
+    /**
+     * Set the action that should be executed with this ClickEvent is fired.
+     * @param action {ClickEventAction} new action
+     */
+    setAction(action: ClickEventAction) : ClickEvent {
+
+        for(const loopAction in ClickEventAction) {
+            if (ClickEventAction.hasOwnProperty(loopAction) && ClickEventAction[loopAction] === action) {
+                this.action = action.canonicalName
+                return this
+            }
+        }
+
+        throw new Error('Invalid action! Action must be property of ClickEventAction')
+    }
+
+    /**
+     * Set the value of this ClickEvent's ClickEventAction.
+     * @param value {string} New click event action value
+     */
+    setValue(value: string) : void {
+        this.value = String(value)
+    }
+}
+
+export default ClickEvent
+export {ClickEventAction}
diff --git a/chat-components/HoverEvent.ts b/chat-components/HoverEvent.ts
new file mode 100644
index 0000000..90faae2
--- /dev/null
+++ b/chat-components/HoverEvent.ts
@@ -0,0 +1,75 @@
+import ChatComponent from './ChatComponent'
+
+const HoverEventAction = Object.freeze({
+    SHOW_TEXT: {
+        allowedInChat: true,
+        canonicalName: 'show_text'
+    },
+    SHOW_ACHIEVEMENT: {
+        allowedInChat: true,
+        canonicalName: 'show_achievement'
+    },
+    SHOW_ITEM: {
+        allowedInChat: true,
+        canonicalName: 'show_item'
+    },
+    SHOW_ENTITY: {
+        allowedInChat: true,
+        canonicalName: 'show_entity'
+    }
+})
+
+interface HoverEventAction {
+    allowedInChat: boolean, canonicalName: string
+}
+
+/**
+ * Hover events in Minecraft are fired when the user hovers over a ChatComponent with a given HoverEvent.
+ */
+class HoverEvent {
+
+    /**
+     * Canonical name of the action
+     */
+    action: string
+    /**
+     * Value of the action
+     */
+    value: ChatComponent
+
+    constructor(action: HoverEventAction, value: ChatComponent) {
+        this.setAction(action)
+        this.setValue(value)
+    }
+
+    /**
+     * Set the action that should be executed with this HoverEvent is fired.
+     * @param action {HoverEventAction} new action
+     */
+    setAction(action: HoverEventAction): HoverEvent {
+
+        for(const loopAction in HoverEventAction) {
+            if (HoverEventAction.hasOwnProperty(loopAction) && HoverEventAction[loopAction] === action) {
+                this.action = action.canonicalName
+                return this
+            }
+        }
+
+        throw new Error('Invalid action! Action must be property of HoverEventAction')
+    }
+
+    /**
+     * Set the value of this HoverEvent's HoverEventAction.
+     * @param value {ChatComponent} New hover event action value
+     */
+    setValue(value: ChatComponent): void {
+        if(value instanceof ChatComponent) {
+            this.value = value
+        } else {
+            throw new Error('Invalid value! Value must be instance of ChatComponent.')
+        }
+    }
+}
+
+export default HoverEvent
+export {HoverEventAction}
diff --git a/chat-components/Message.ts b/chat-components/Message.ts
new file mode 100644
index 0000000..bac5000
--- /dev/null
+++ b/chat-components/Message.ts
@@ -0,0 +1,31 @@
+import ChatComponent from './ChatComponent'
+
+/**
+ * Messages are a wrapper around chat components in Quickplay which control whether the chat component
+ * should be surrounded by "separators", and whether the message should be sent regardless of whether or not
+ * Quickplay is enabled.
+ */
+class Message {
+
+    message: ChatComponent
+    separators = false
+    bypassEnabledSetting = false
+
+    /**
+     * Constructor
+     * @param component {ChatComponent} The chat component to send.
+     * @param separators {boolean} Whether separators should be added on top of and below the message.
+     * @param bypassEnabledSetting {boolean} Whether the message should still send even if Quickplay is disabled.
+     */
+    constructor(component: ChatComponent, separators?: boolean, bypassEnabledSetting?: boolean) {
+        if(!(component instanceof ChatComponent)) {
+            throw new Error('Invalid component! Must be instance of ChatComponent')
+        } else {
+            this.message = component
+            this.separators = separators
+            this.bypassEnabledSetting = bypassEnabledSetting
+        }
+    }
+}
+
+export default Message
diff --git a/index.ts b/index.ts
new file mode 100644
index 0000000..5da794b
--- /dev/null
+++ b/index.ts
@@ -0,0 +1,86 @@
+import Action from "./actions/Action";
+import Resolver from "./actions/Resolver";
+import ActionBus from "./actions/ActionBus";
+import Button from "./Button";
+import Screen from "./Screen";
+import AliasedAction from "./AliasedAction";
+import ChatComponent from "./chat-components/ChatComponent";
+import ChatFormatting from "./chat-components/ChatFormatting";
+import ClickEvent from "./chat-components/ClickEvent";
+import HoverEvent from "./chat-components/HoverEvent";
+import Message from "./chat-components/Message";
+import AuthBeginHandshakeAction from "./actions/clientbound/AuthBeginHandshakeAction";
+import SetButtonAction from "./actions/clientbound/SetButtonAction";
+import SetTranslationAction from "./actions/clientbound/SetTranslationAction";
+import SetScreenAction from "./actions/clientbound/SetScreenAction";
+import SetPremiumAboutAction from "./actions/clientbound/SetPremiumAboutAction";
+import SetKeybindsAction from "./actions/clientbound/SetKeybindsAction";
+import SetGlyphForUserAction from "./actions/clientbound/SetGlyphForUserAction";
+import SetAliasedActionAction from "./actions/clientbound/SetAliasedActionAction";
+import SystemOutAction from "./actions/clientbound/SystemOutAction";
+import SendChatComponentAction from "./actions/clientbound/SendChatComponentAction";
+import SendChatCommandAction from "./actions/clientbound/SendChatCommandAction";
+import ResetConfigAction from "./actions/clientbound/ResetConfigAction";
+import RefreshCacheAction from "./actions/clientbound/RefreshCacheAction";
+import OpenScreenAction from "./actions/clientbound/OpenScreenAction";
+import OpenGuiAction from "./actions/clientbound/OpenGuiAction";
+import EnableModAction from "./actions/clientbound/EnableModAction";
+import DisableModAction from "./actions/clientbound/DisableModAction";
+import AuthCompleteAction from "./actions/clientbound/AuthCompleteAction";
+import ServerLeftAction from "./actions/serverbound/ServerLeftAction";
+import ServerJoinedAction from "./actions/serverbound/ServerJoinedAction";
+import MigrateKeybindsAction from "./actions/serverbound/MigrateKeybindsAction";
+import LanguageChangedAction from "./actions/serverbound/LanguageChangedAction";
+import InitializeClientAction from "./actions/serverbound/InitializeClientAction";
+import HypixelLocationChangedAction from "./actions/serverbound/HypixelLocationChangedAction";
+import ExceptionThrownAction from "./actions/serverbound/ExceptionThrownAction";
+import ButtonPressedAction from "./actions/serverbound/ButtonPressedAction";
+import AuthEndHandshakeAction from "./actions/serverbound/AuthEndHandshakeAction";
+
+export {Action}
+export {Resolver}
+export {ActionBus}
+export {Button}
+export {Screen}
+export {AliasedAction}
+
+export declare namespace Chat {
+    export {ChatComponent}
+    export {ChatFormatting}
+    export {ClickEvent}
+    export {HoverEvent}
+    export {Message}
+}
+
+export declare namespace Clientbound {
+    export {AuthBeginHandshakeAction}
+    export {AuthCompleteAction}
+    export {DisableModAction}
+    export {EnableModAction}
+    export {OpenGuiAction}
+    export {OpenScreenAction}
+    export {RefreshCacheAction}
+    export {ResetConfigAction}
+    export {SendChatCommandAction}
+    export {SendChatComponentAction}
+    export {SetAliasedActionAction}
+    export {SetButtonAction}
+    export {SetGlyphForUserAction}
+    export {SetKeybindsAction}
+    export {SetPremiumAboutAction}
+    export {SetScreenAction}
+    export {SetTranslationAction}
+    export {SystemOutAction}
+}
+
+export declare namespace Serverbound {
+    export {AuthEndHandshakeAction}
+    export {ButtonPressedAction}
+    export {ExceptionThrownAction}
+    export {HypixelLocationChangedAction}
+    export {InitializeClientAction}
+    export {LanguageChangedAction}
+    export {MigrateKeybindsAction}
+    export {ServerJoinedAction}
+    export {ServerLeftAction}
+}
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..c32c264
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,33 @@
+{
+  "name": "@quickplaymod/quickplay-actions-js",
+  "version": "1.0.0",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "base64-js": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.1.tgz",
+      "integrity": "sha512-mLQ4i2QO1ytvGWFWmcngKO//JXAQueZvwEKtjgQFM4jIK0kU+ytMfplL8j+n5mspOfjHwoAg+9yhb7BwAHm36g=="
+    },
+    "buffer": {
+      "version": "5.6.0",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.6.0.tgz",
+      "integrity": "sha512-/gDYp/UtU0eA1ys8bOs9J6a+E/KWIY+DZ+Q2WESNUA0jFRsJOc0SNUO6xJ5SGA1xueg3NL65W6s+NY5l9cunuw==",
+      "requires": {
+        "base64-js": "^1.0.2",
+        "ieee754": "^1.1.4"
+      }
+    },
+    "ieee754": {
+      "version": "1.1.13",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.13.tgz",
+      "integrity": "sha512-4vf7I2LYV/HaWerSo3XmlMkp5eZ83i+/CDluXi/IGTs/O1sejBNhTtnxzmRZfvOUqj7lZjqHkeTvpgSFDlWZTg=="
+    },
+    "typescript": {
+      "version": "3.9.7",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.7.tgz",
+      "integrity": "sha512-BLbiRkiBzAwsjut4x/dsibSTB6yWpwT5qWmC2OfuCg3GgVQCSgMs4vEctYPhsaGtd0AeuuHMkjZ2h2WG8MSzRw==",
+      "dev": true
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..8a368a9
--- /dev/null
+++ b/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "@quickplaymod/quickplay-actions-js",
+  "version": "1.0.0",
+  "description": "Quickplay's central Action controller, written in TypeScript.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "prepublish": "tsc",
+  "dependencies": {
+    "buffer": "^5.6.0"
+  },
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com/"
+  },
+  "devDependencies": {
+    "typescript": "^3.9.7"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/quickplaymod/quickplay-actions-js.git"
+  },
+  "keywords": [
+    "hypixel",
+    "minecraft",
+    "forge",
+    "quickplay"
+  ],
+  "author": "Quickplay Mod",
+  "license": "GPL-3.0",
+  "bugs": {
+    "url": "https://github.com/quickplaymod/quickplay-actions-js/issues"
+  },
+  "homepage": "https://bugg.co/quickplay"
+}
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..f0f2342
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,73 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                   /* Enable incremental compilation */
+    "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+    "lib": ["ES2015", "ES6"],                 /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                       /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    "declaration": true,                      /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    "sourceMap": true,                        /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    "outDir": "./dist",                       /* Redirect output structure to the directory. */
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    // "strict": true,                        /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true,                     /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
+  },
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}