diff --git a/.eslintrc b/.eslintrc
index 5e26092..0e06e20 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -32,6 +32,7 @@
     "no-plusplus": "off",
     "no-shadow": "off",
     "no-return-assign": "off",
+    "no-await-in-loop": "off",
     "class-methods-use-this": "off",
     "no-continue": "off",
     "no-restricted-syntax": "off",
diff --git a/.github/workflow/eslint.yml b/.github/workflow/eslint.yml
new file mode 100644
index 0000000..f67ccc6
--- /dev/null
+++ b/.github/workflow/eslint.yml
@@ -0,0 +1,21 @@
+name: ESLint
+
+on:
+  push:
+    branches: [ production ]
+  pull_request:
+    branches: [ production ]
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '16'
+      - name: Install modules
+        run: yarn
+      - name: Run ESLint
+        run: yarn lint
diff --git a/README.md b/README.md
index 24e49be..8454b5f 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,10 @@
-# Discord Ping Blocker
+![ESLint](https://github.com/NewCircuit/ping-pewds/actions/workflows/eslint.yml/badge.svg?style=flat-square)
 
-This is a Discord bot written in Typescript, using Discord Commando.
+# Discord Ping Blocker (ping-pewds)
+
+### This is a Discord bot written in Typescript, using the [Sapphire Framework](https://www.sapphirejs.dev/)
+
+#### [View Available Commands](docs/commands.md)
 
 ## Requirements
 * [NodeJS](https://nodejs.org/)
@@ -39,8 +43,10 @@ npm run pm2
 ### Bot specific configuration
 |Key|Default|Description|
 |---|---|---|
+|dryrun|`false`|Prevents actually performing the discord punishment, however will insert a record into the database|
 |token|None|The oauth bot token provided by Discord|
 |prefix|`!`|The string the bot looks for to indicate a command is fired|
+|guild|None|The Guild ID to monitor (currently only watches one guild)|
 |owners|`[]`|An array of owner snowflakes|
 |blockTimeout|`10`|The delay in minutes to stop blocking pings if a `block`ed user has spoken|
 |block|`[]`|The user IDs that the bot will listen for and block mentions of|
@@ -48,6 +54,9 @@ npm run pm2
 |notifyRoles|`[]`|The role IDs that will get notified when a `block`ed user becomes active|
 |notifyChannels|`[]`|The channel IDs that a message will be sent to notify `notifyRoles`|
 |excludedChannels|`[]`|The channel IDs that the bot will completely ignore|
+|moderatorRoles|`[]`|The role IDs that the bot should consider moderators|
+|lenientRoles|`[]`|The role IDs that should be considered lenient when punishing|
+|muteRole|`''`|The role ID that will be assigned to *mute* them.|
 
 ### Database specific configuration
 |Key|Default|Description|
diff --git a/config.default.yml b/config.default.yml
index 1e119b3..3cf2c7a 100644
--- a/config.default.yml
+++ b/config.default.yml
@@ -1,13 +1,17 @@
 bot:
+  dryrun: false         # this skips the actual punishment if true, but displays and updates database as usual
   token: 'BotToken'
   prefix: '!'
+  guild: ''             # the guild that the bot will be attached to
   owners: ['id1', 'id2']
   blockTimeout: 10      # delay in minutes to stop blocking pings if a specific user has spoken
-  block: []             # User IDs that will the bot will listen for mentions of
   notifyTimeout: 10     # delay in minutes until notified roles will be alerted that the blocked users are no longer active
   notifyRoles: []       # Role IDs that will get notified when a blocked user is active
   notifyChannels: []    # Channel IDs that will get notified when a blocked user is active
   excludedChannels: []  # Channel IDs that should be ignored by the bot
+  moderatorRoles: []     # Role IDs that are considered moderators or administrators
+  lenientRoles: []      # Role IDs that when punished, will have lighter punishments
+  muteRole: ''          # the Role ID that will be assigned to muted users
 database:
   host: 'localhost'
   port: 5432
diff --git a/docs/commands.md b/docs/commands.md
new file mode 100644
index 0000000..f071b2f
--- /dev/null
+++ b/docs/commands.md
@@ -0,0 +1,107 @@
+# Commands provided by this bot
+
+This guide assumes that the command prefix is `!`. Wherever you see the `!` symbol, you should assume
+that this is whatever the prefix is set to by the administrators.
+
+## Monitored User Commands
+##### These are commands that are only available to users who should have ping protection.
+____
+
+### Extend Ping Window
+```
+!extend <TIME>
+```
+* `<TIME>` - The number of minutes that you will be allowed to be pinged
+
+This is primarily meant to act as an AFK button. If you plan to leave for longer than
+the standard ping window and you want to still be pinged, you can *extend* the time you'll be
+allowed to be pinged. **If you speak after running this command in a monitored channel**,
+your ping window will be reset back to the standard ping window.
+
+<div style="margin-bottom:50px"></div>
+
+### Clear Ping Window
+```
+!clear
+```
+Immediately stops you from being pinged. Anyone who pings you after you enter this command
+will be punished.
+
+
+____
+
+## Moderation Commands
+##### These commands are used to maintain punishment options and should only be available to those with a moderator role (that is contained in `moderatorRoles` in configuration)
+___
+
+### Punishments Help
+```
+!punishments [help]
+```
+* `help` - is optional
+
+Will give you an inline guide on what each sub command should do.
+
+<div style="margin-bottom:50px"></div>
+
+### Punishments List
+```
+!punishments list
+```
+
+Returns several embeds depending on how many users and roles are monitored.
+Below is an example output
+
+![Demo Punishments list](images/punishments_list.png)
+
+<div style="margin-bottom:50px"></div>
+
+### Punishment Create
+```
+!punishments create <INDEX> <TYPE> <TARGET> <KEY> <LIENIENT> <LENGTH>
+```
+* `<INDEX>` - The priority in which the punishment is given out. Lower priority is given first
+* `<TYPE>` - `ban`, `mute`, or `kick`
+* `<TARGET>` - `user` or `role`
+* `<KEY>` - Either a user ID or role ID depending on what `<TARGET>` you provide
+* `<LENIENT>` - yes/no/true/false (booleanish)
+* `<LENGTH>` - The amount of time in minutes the punishment should be
+
+This function is used to create punishment options for roles and users.
+You have the ability to define multiple punishments for virtually any person or role
+within the guild.
+
+<div style="margin-bottom:50px"></div>
+
+### Punishment Remove
+```
+!punishments remove <INDEX> <TARGET> <KEY> <LENIENT>
+```
+* `<INDEX>` - The priority in which the punishment is given out. Lower priority is given first
+* `<TARGET>` - `user` or `role`
+* `<KEY>` - Either a user ID or role ID depending on what `<TARGET>` you provide
+* `<LENIENT>` - yes/no/true/false (booleanish)
+
+This function is used to remove a punishment option for roles or roles. You will
+need to know all the information above, **but** you can get this information
+by running `!punishments list`.
+
+![Punishment Legend](images/punishment_legend.png)
+
+* **Green** - this is your index
+* **Pink** - this is your target
+* **orange** - this is your key
+* **Blue** - this is lenient or not
+
+<div style="margin-bottom:50px"></div>
+
+### Punishments For User
+```
+!punishments for <USER>
+```
+* `<USER>` - the user to look up punishments
+
+This returns an embed containing the punishments that
+the user has received in the past.
+
+![Punishment History](images/punishment_history.png)
diff --git a/docs/images/punishment_history.png b/docs/images/punishment_history.png
new file mode 100644
index 0000000..7378d94
Binary files /dev/null and b/docs/images/punishment_history.png differ
diff --git a/docs/images/punishment_legend.png b/docs/images/punishment_legend.png
new file mode 100644
index 0000000..6809b73
Binary files /dev/null and b/docs/images/punishment_legend.png differ
diff --git a/docs/images/punishments_list.png b/docs/images/punishments_list.png
new file mode 100644
index 0000000..df59b7e
Binary files /dev/null and b/docs/images/punishments_list.png differ
diff --git a/package.json b/package.json
index 660f828..36c7812 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "ping-pewds",
   "description": "A discord bot that blocks pings of specified users, unless they are actively talking",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "main": "lib/index.js",
   "license": "GPL-3.0",
   "author": {
@@ -14,20 +14,26 @@
   },
   "scripts": {
     "start": "node ./lib/index.js",
-    "dev": "nodemon --watch src/**/* -e ts,json --exec node --inspect=9229 -r ts-node/register src",
+    "debug": "node --inspect=9229 ./lib/index.js",
+    "dev": "yarn build && yarn debug",
+    "build": "yarn clean && tsc",
     "test-database": "mocha -r ts-node/register \"src/database/tests/**/runner.test.ts\" --watch --watch-files **/*.ts",
-    "build": "tsc",
-    "pm2": "pm2 start ecosystem.config.js",
-    "prettier": "prettier --write \"./src/**/*.{ts,tsx}\"",
     "lint": "eslint --ext .ts src/",
-    "lint:fix": "eslint --ext .ts src/ --fix"
+    "lint:fix": "eslint --ext .ts src/ --fix",
+    "prettier": "prettier --write \"./src/**/*.{ts,tsx}\"",
+    "pm2": "pm2 start ecosystem.config.js",
+    "clean": "rimraf ./lib"
   },
   "dependencies": {
+    "@sapphire/framework": "next",
+    "@sapphire/plugin-logger": "next",
+    "@sapphire/decorators": "next",
+    "@sapphire/plugin-subcommands": "next",
     "async-mutex": "^0.3.1",
-    "discord.js": "^12.5.3",
-    "discord.js-commando": "^0.12.3",
+    "discord.js": "13.1.0",
     "js-yaml": "^4.1.0",
     "pg": "^8.6.0",
+    "pg-protocol": "^1.5.0",
     "winston": "^3.3.3"
   },
   "devDependencies": {
@@ -47,6 +53,7 @@
     "mocha": "^9.0.2",
     "nodemon": "^2.0.7",
     "prettier": "^2.3.2",
+    "rimraf": "^3.0.2",
     "ts-node": "^10.0.0",
     "typescript": "^4.3.4"
   }
diff --git a/src/Bot.ts b/src/Bot.ts
index 66b2641..3f1d0e9 100644
--- a/src/Bot.ts
+++ b/src/Bot.ts
@@ -1,30 +1,37 @@
-import { CommandoClient, CommandoMessage } from 'discord.js-commando';
-import winston from 'winston';
+import { SapphireClient } from '@sapphire/framework';
 import { CONFIG } from './globals';
-import getLogger from './utils/logger';
-import IssueHandler from './IssueHandler';
-import EventHandler from './EventHandler';
+import { BotLogger } from './utils/logger';
 import { PingableUserController } from './controllers/PingableUserController';
 import DatabaseManager from './database/database';
 import { PingController } from './controllers/PingController';
-import ExtendTimeout from './commands/pingable/extendtimeout';
-import ClearTimeout from './commands/pingable/cleartimeout';
-
-class Bot extends CommandoClient {
-    private readonly events: EventHandler;
+import PunishmentController from './controllers/PunishmentController';
 
+class Bot extends SapphireClient {
     private readonly pingableUserController: PingableUserController;
 
     private readonly pingController: PingController;
 
+    private readonly punishmentController: PunishmentController;
+
     private readonly database: DatabaseManager;
 
+    private readonly synchronizeTimeout: number;
+
+    private synchronizeLoop: NodeJS.Timeout | undefined;
+
     constructor() {
         super({
-            commandPrefix: CONFIG.bot.prefix,
-            owner: CONFIG.bot.owners,
+            intents: ['GUILDS', 'GUILD_MESSAGE_REACTIONS', 'GUILD_MESSAGES'],
+            defaultPrefix: CONFIG.bot.prefix,
+            id: CONFIG.bot.token,
+            caseInsensitiveCommands: true,
+            logger: {
+                instance: BotLogger.getInstance(),
+            },
         });
 
+        this.synchronizeTimeout = 1000 * 60; // 1 minute
+
         this.database = new DatabaseManager({
             host: CONFIG.database.host,
             port: CONFIG.database.port,
@@ -37,30 +44,7 @@ class Bot extends CommandoClient {
 
         this.pingableUserController = new PingableUserController(this);
         this.pingController = new PingController(this);
-
-        this.events = new EventHandler(this);
-        this.registerEvents();
-
-        this.dispatcher.addInhibitor(this.inhibitor.bind(this));
-
-        this.registry
-            .registerDefaults()
-            .registerDefaultGroups()
-            .registerDefaultCommands({
-                help: false,
-                unknownCommand: false,
-                commandState: false,
-                eval: false,
-                prefix: false,
-                ping: false,
-            })
-            .registerGroups([['pingable', 'Commands for Pingable users']]);
-        // .registerCommandsIn(path.join(__dirname, './commands'))
-
-        // TODO replace this with .registerCommandsIn()
-        //      for some reason I can't get the commands to load from there
-        //      so I am forced to register them manually
-        this.registry.registerCommands([ExtendTimeout, ClearTimeout]);
+        this.punishmentController = new PunishmentController(this);
     }
 
     /**
@@ -68,33 +52,16 @@ class Bot extends CommandoClient {
      */
     public async start(): Promise<void> {
         await this.database.init();
-        await this.pingableUserController.init();
         await this.login(CONFIG.bot.token);
-    }
-
-    /**
-     * Register message listeners and command handlers
-     * @private
-     */
-    private registerEvents(): void {
-        const issues = new IssueHandler();
-        this.on('commandError', issues.onCommandError.bind(issues))
-            .on('commandRun', issues.onCommandRun.bind(issues))
-            .on('commandRegister', issues.onCommandRegister.bind(issues));
-
-        this.on('message', this.events.onMessage.bind(this.events));
-
-        this.once('ready', this.events.onReady.bind(this.events));
-    }
-
-    /**
-     * checks to see if the message starts with commandPrefix and message is not within a guild
-     * @param msg
-     * @private
-     */
-    private inhibitor(msg: CommandoMessage): false | string {
-        const passes = msg.content.startsWith(this.commandPrefix) && msg.guild !== null;
-        return passes ? false : '';
+        await this.punishmentController.synchronize(true);
+        await this.pingableUserController.init();
+        this.synchronizeLoop = setInterval(
+            () =>
+                this.punishmentController
+                    .synchronize()
+                    .catch((err) => Bot.getLogger('synchronization').error(err)),
+            this.synchronizeTimeout
+        );
     }
 
     public getPingableUserController(): PingableUserController {
@@ -105,12 +72,16 @@ class Bot extends CommandoClient {
         return this.pingController;
     }
 
+    public getPunishmentController(): PunishmentController {
+        return this.punishmentController;
+    }
+
     public getDatabase(): DatabaseManager {
         return this.database;
     }
 
-    public static getLogger(section: string): winston.Logger {
-        return getLogger(`Bot::${section}`);
+    public static getLogger(section: string): BotLogger {
+        return BotLogger.getInstance().getTitledInstance(section);
     }
 }
 
diff --git a/src/EventHandler.ts b/src/EventHandler.ts
deleted file mode 100644
index ce06990..0000000
--- a/src/EventHandler.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { Message } from 'discord.js';
-import winston from 'winston';
-import Bot from './Bot';
-
-class EventHandler {
-    private readonly bot: Bot;
-
-    constructor(bot: Bot) {
-        this.bot = bot;
-    }
-
-    onReady(): void {
-        EventHandler.getLogger().info('Bot is ready');
-    }
-
-    /**
-     * fires whenever a message is sent, checks to see if the
-     * sender is a pingable user, if it is, use the pingableController and return.
-     * if the message contains a ping of a user with managed pings, use pingController and return
-     * @param message
-     */
-    async onMessage(message: Message): Promise<void> {
-        const pingableController = this.bot.getPingableUserController();
-        if (await pingableController.handleMessage(message)) return;
-
-        const pingController = this.bot.getPingController();
-        await pingController.handleMessage(message);
-        // if (await pingController.handleMessage(message)) return;
-    }
-
-    private static getLogger(): winston.Logger {
-        return Bot.getLogger('EventHandler');
-    }
-}
-
-export default EventHandler;
diff --git a/src/IssueHandler.ts b/src/IssueHandler.ts
deleted file mode 100644
index e45addf..0000000
--- a/src/IssueHandler.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { Message } from 'discord.js';
-import { Command, CommandoMessage } from 'discord.js-commando';
-import winston from 'winston';
-import Bot from './Bot';
-import LogUtil from './utils/LogUtil';
-
-class IssueHandler {
-    /**
-     * Log command failures
-     * @param {Command} cmd Command that failed
-     * @param {Error} err Error that ocurred
-     * @param {CommandoMessage} msg The user's message that executed the command
-     * @param {any[]} _args Ignored arguments
-     */
-    public onCommandError(
-        cmd: Command,
-        err: Error,
-        msg: CommandoMessage,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-explicit-any
-        ..._args: any[]
-    ): void {
-        const log = this.getLogger(cmd);
-        const message = `${msg.author.tag} executed "${msg.command?.name}"
-${LogUtil.breakDownMsg(msg)}
-${LogUtil.breakDownErr(err)}`;
-
-        log.error(message);
-    }
-
-    /**
-     * Log when a command was added to Modmail
-     * @param {Command} c Command being added
-     */
-    public onCommandRegister(c: Command): void {
-        const log = this.getLogger(c);
-        const message = 'registered';
-
-        log.debug(message);
-    }
-
-    /**
-     * Log command executions
-     * @param {Command} c Command being executed
-     * @param {Promise} _p Command's result
-     * @param {CommandoMessage} msg The user's message that executed the command
-     */
-    public onCommandRun(
-        c: Command,
-        _p: Promise<Message | Message[] | null>,
-        msg: CommandoMessage
-    ): void {
-        const log = this.getLogger(c);
-        const message = `${msg.author.tag} executed this command\n${LogUtil.breakDownMsg(
-            msg
-        )}`;
-
-        log.debug(message);
-    }
-
-    private getLogger(c: Command): winston.Logger {
-        return Bot.getLogger(`command::${c.name}`);
-    }
-}
-
-export default IssueHandler;
diff --git a/src/commands/pingable/cleartimeout.ts b/src/commands/pingable/cleartimeout.ts
index 1e30b2d..f768d29 100644
--- a/src/commands/pingable/cleartimeout.ts
+++ b/src/commands/pingable/cleartimeout.ts
@@ -1,35 +1,38 @@
-import { Command, CommandoMessage } from 'discord.js-commando';
+import { Command, CommandOptions, PieceContext } from '@sapphire/framework';
+import { Message } from 'discord.js';
+import { ApplyOptions } from '@sapphire/decorators';
 import Bot from '../../Bot';
 import { CONFIG } from '../../globals';
 
+@ApplyOptions<CommandOptions>({
+    name: 'clear',
+    aliases: ['end', 'stop'],
+    description: 'Immediately stop all pings.',
+    preconditions: ['GuildOnly'],
+})
 export default class ClearTimeout extends Command {
-    constructor(client: Bot) {
-        super(client, {
-            name: 'clear',
-            aliases: ['end', 'stop'],
-            guildOnly: true,
-            description: 'Immediately stop all pings.',
-            group: 'pingable',
-            memberName: 'clear',
-        });
-    }
-
     /**
      * compares the message author id to the 'block' config array
      * @param message
      * @param ownerOverride
      */
-    public hasPermission(message: CommandoMessage, ownerOverride?: boolean): boolean {
-        return CONFIG.bot.block.indexOf(message.author.id) >= 0 || ownerOverride === true;
+    public hasPermission(message: Message, ownerOverride?: boolean): boolean {
+        const bot = this.container.client as Bot;
+        const author = message.guild?.members.resolve(message.author.id);
+        return (
+            bot.getPunishmentController().isMonitoredMember(author) ||
+            ownerOverride === true
+        );
     }
 
     /**
      * immediately stops all pings for the author
      * @param msg
      */
-    public async run(msg: CommandoMessage): Promise<null> {
+    public async run(msg: Message): Promise<null> {
+        if (!this.hasPermission(msg)) return null;
         const author = msg.author.id;
-        const client = this.client as Bot;
+        const client = this.container.client as Bot;
 
         const extended = await client
             .getPingableUserController()
@@ -40,7 +43,10 @@ export default class ClearTimeout extends Command {
             const notification = await msg.channel.send({
                 content: `<@${author}>, you'll no longer be able to be pinged.`,
             });
-            await notification.delete({ timeout: 5000 });
+
+            setTimeout(() => {
+                notification.delete();
+            }, 10000);
         }
 
         return null;
diff --git a/src/commands/pingable/extendtimeout.ts b/src/commands/pingable/extendtimeout.ts
index ac8275f..55cf739 100644
--- a/src/commands/pingable/extendtimeout.ts
+++ b/src/commands/pingable/extendtimeout.ts
@@ -1,43 +1,39 @@
-import { Command, CommandoMessage } from 'discord.js-commando';
+import { Command, PieceContext, Args, CommandOptions } from '@sapphire/framework';
+import { Message } from 'discord.js';
+import { ApplyOptions } from '@sapphire/decorators';
 import Bot from '../../Bot';
 import { CONFIG } from '../../globals';
 
-type Args = {
-    timeout: number;
-};
-
+@ApplyOptions<CommandOptions>({
+    name: 'extend',
+    description: 'Extend the time that that you want to allow users to ping you.',
+    preconditions: ['GuildOnly'],
+})
 export default class ExtendTimeout extends Command {
-    constructor(client: Bot) {
-        super(client, {
-            name: 'extend',
-            // aliases: [],
-            guildOnly: true,
-            description: 'Extend the time that that you want to allow users to ping you.',
-            group: 'pingable',
-            memberName: 'extend',
-            examples: ['extend 60', 'extend 3600'],
-            args: [
-                {
-                    default: 15,
-                    key: 'timeout',
-                    prompt: 'Timeout',
-                    label: 'time in minutes to extend',
-                    validate: (val: string) => val.match(/^\d+$/) !== null,
-                    parse: (val: string) => Number.parseInt(val, 10),
-                    wait: 10,
-                    error: 'Please enter a numeric value representing the number of minutes to extend.',
-                },
-            ],
-        });
-    }
-
     /**
      * compares the message author id to the 'block' config array
      * @param message
      * @param ownerOverride
      */
-    public hasPermission(message: CommandoMessage, ownerOverride?: boolean): boolean {
-        return CONFIG.bot.block.indexOf(message.author.id) >= 0 || ownerOverride === true;
+    public hasPermission(message: Message, ownerOverride?: boolean): boolean {
+        const bot = this.container.client as Bot;
+        const author = message.guild?.members.resolve(message.author.id);
+        return (
+            bot.getPunishmentController().isMonitoredMember(author) ||
+            ownerOverride === true
+        );
+    }
+
+    private async validateArgs(args: Args) {
+        try {
+            return {
+                timeout: await args.rest('number'),
+            };
+        } catch (_) {
+            return {
+                timeout: 15,
+            };
+        }
     }
 
     /**
@@ -45,10 +41,14 @@ export default class ExtendTimeout extends Command {
      * @param msg
      * @param args
      */
-    public async run(msg: CommandoMessage, args: Args): Promise<null> {
-        const { timeout } = args;
+    public async run(msg: Message, args: Args): Promise<null> {
+        if (!this.hasPermission(msg)) return null;
+
+        const { timeout } = await this.validateArgs(args); // await args.rest('number');
+
         const author = msg.author.id;
-        const client = this.client as Bot;
+        const client = this.container.client as Bot;
+
         const date = new Date();
         const extended = await client
             .getPingableUserController()
@@ -64,7 +64,10 @@ Please note that this command should only be used if you plan on going AFK. Once
                     CONFIG.bot.blockTimeout
                 } minutes** after your last message.`,
             });
-            await notification.delete({ timeout: 30000 });
+
+            setTimeout(() => {
+                notification.delete();
+            }, 10000);
         }
 
         return null;
diff --git a/src/commands/utility/punishments.ts b/src/commands/utility/punishments.ts
new file mode 100644
index 0000000..0ff4444
--- /dev/null
+++ b/src/commands/utility/punishments.ts
@@ -0,0 +1,547 @@
+import { ApplyOptions } from '@sapphire/decorators';
+import { Args, Command, CommandContext, CommandOptions } from '@sapphire/framework';
+import {
+    SubCommandPluginCommand,
+    SubCommandPluginCommandOptions,
+} from '@sapphire/plugin-subcommands';
+import { Message, MessageEmbedOptions, User } from 'discord.js';
+import Bot from '../../Bot';
+import { Parsed, Tables, TargetType } from '../../database/types';
+import { InsertError, DatabaseError } from '../../database/errors';
+import {
+    getRoleOrUser,
+    minutesToReadable,
+    parsedUserOrRole,
+    sentByAuthorizedUser,
+} from '../../utils';
+import { CONFIG } from '../../globals';
+
+const disclaimer = `*By entering the above command, you will receive an embed that will show you the full structure of the command.*`;
+
+@ApplyOptions<SubCommandPluginCommandOptions>({
+    name: 'punishments',
+    description:
+        'Show, create, and remove punishments for pinging them from users and roles',
+    preconditions: ['GuildOnly'],
+    subCommands: [
+        {
+            input: 'help',
+            default: true,
+        },
+        {
+            input: 'list',
+        },
+        {
+            input: 'create',
+        },
+        {
+            input: 'for',
+        },
+        {
+            input: 'remove',
+        },
+    ],
+})
+export default class Punishments extends SubCommandPluginCommand {
+    private static hasPermission(message: Message): boolean {
+        const author = message.guild?.members.resolve(message.author.id);
+        return sentByAuthorizedUser(author);
+    }
+
+    public async run(
+        message: Message,
+        args: Args,
+        context: CommandContext
+    ): Promise<void> {
+        if (!Punishments.hasPermission(message)) return;
+        await super.run(message, args, context);
+    }
+
+    /**
+     * Sends a help embed to show all sub commands available
+     * @param message
+     */
+    public async help(message: Message): Promise<void> {
+        message.channel.send({
+            content: `For more help than what is provided in the embed below, click the button below to view bot documentation.`,
+            embeds: [Punishments.HELP_EMBED],
+            components: [
+                {
+                    type: 'ACTION_ROW',
+                    components: [
+                        {
+                            type: 'BUTTON',
+                            // TODO change to commands documentation instead of default readme
+                            url: 'https://github.com/NewCircuit/ping-pewds',
+                            label: 'Github Repo',
+                            style: 'LINK',
+                        },
+                    ],
+                },
+            ],
+        });
+    }
+
+    /**
+     * Provides multiple embeds of punishments that currently being used.
+     * There is 1 embed per role or user.
+     * Each embed lists lenient and standard punishments
+     * @param message
+     */
+    public async list(message: Message): Promise<void> {
+        const bot = this.container.client as Bot;
+        const punishmentController = bot.getPunishmentController();
+        await punishmentController.synchronize(true);
+        const rolePunishments = punishmentController.getBlockedRoles();
+        const userPunishments = punishmentController.getBlockedUsers();
+
+        const mapPunishments =
+            (target: TargetType) =>
+            (key: string): MessageEmbedOptions => {
+                const punishment = punishmentController.getPunishments(target, key);
+                if (punishment) return Punishments.LIST_PUNISHMENTS_EMBED(punishment);
+                return {
+                    title: `${parsedUserOrRole(target, key)} has no punishments`,
+                };
+            };
+
+        const embeds = [
+            ...rolePunishments
+                .filter((k) => punishmentController.hasPunishments('role', k))
+                .map(mapPunishments('role')),
+            ...userPunishments
+                .filter((k) => punishmentController.hasPunishments('user', k))
+                .map(mapPunishments('user')),
+        ];
+
+        if (embeds.length === 0) {
+            await message.channel.send({
+                content: `There are no punishments set up. 
+Run the command \`${CONFIG.bot.prefix}punishments create\` to learn how to create commands.`,
+            });
+            return;
+        }
+
+        let first = true;
+        do {
+            const subsetEmbeds = embeds.splice(0, 10);
+            await message.channel.send({
+                content: first
+                    ? `Here is a list of punishments that can be given out, broken down by user and role.`
+                    : undefined,
+                embeds: subsetEmbeds,
+            });
+            first = false;
+        } while (embeds.length > 0);
+    }
+
+    /**
+     * Used to create a punishment handler for a specific user or role.
+     * @param message
+     * @param args
+     */
+    public async create(message: Message, args: Args): Promise<void> {
+        const parsedArgs = await Punishments.parseCreateArgs(args).catch(
+            (err: Error) => err
+        );
+
+        if (parsedArgs instanceof Error) {
+            await message.channel.send({
+                content:
+                    parsedArgs.message === 'There are no more arguments.'
+                        ? undefined
+                        : parsedArgs.message,
+                embeds: [Punishments.CREATE_PUNISHMENT_EMBED],
+            });
+            return;
+        }
+
+        const bot = this.container.client as Bot;
+        const created = await bot
+            .getDatabase()
+            .punishments.create({
+                index: parsedArgs.index,
+                target: parsedArgs.target,
+                targetKey: parsedArgs.targetKey,
+                type: parsedArgs.type,
+                length: parsedArgs.length ? parsedArgs.length * 1000 * 60 : undefined,
+                lenient: parsedArgs.lenient,
+            })
+            .catch((err: InsertError) => err);
+
+        if (created instanceof DatabaseError) {
+            message.channel.send({
+                content: `An error occurred while trying to create the punishment.
+Please notify a developer so that we can check the internal logs`,
+            });
+            this.container.logger.error(created);
+            return;
+        }
+
+        await message.reply({
+            allowedMentions: { users: [], roles: [], repliedUser: false },
+            content: `Successfully added punishment to ${
+                parsedArgs.target
+            } ${getRoleOrUser(parsedArgs)}.
+\`\`\`Punishment Type: ${parsedArgs.type}
+Punishment Target: ${parsedArgs.target}
+Punishment Target Key: ${parsedArgs.targetKey}
+Punishment is lenient: ${parsedArgs.lenient}
+Punishment length ${minutesToReadable(parsedArgs.length)}
+\`\`\``,
+        });
+
+        await bot.getPunishmentController().synchronize(true);
+    }
+
+    /**
+     * returns all punishments given to a user
+     * @param message
+     * @param args
+     */
+    public async for(message: Message, args: Args): Promise<void> {
+        let targetUser: User;
+
+        try {
+            targetUser = await args.pick('user');
+        } catch (_) {
+            // Invalid input was provided
+            message.channel.send({
+                content: `An invalid user was provided.
+Usage: \`${CONFIG.bot.prefix}punishments for (@user|User ID)\``,
+            });
+            return;
+        }
+        const bot = this.container.client as Bot;
+        const db = bot.getDatabase();
+        const punishments = await db.punishmentHistory.getByUserId(
+            targetUser.id,
+            true,
+            true
+        );
+
+        let first = true;
+        do {
+            const subsetEmbeds = punishments.splice(0, 10);
+            message.channel.send({
+                allowedMentions: { users: [] },
+                content: first
+                    ? `Here is a list of punishments for <@${targetUser.id}>.`
+                    : undefined,
+                embeds: [Punishments.LIST_PUNISHMENT_HISTORY(targetUser, subsetEmbeds)],
+            });
+            first = false;
+        } while (punishments.length > 0);
+    }
+
+    /**
+     * removes a punishment option from a specific user or role
+     * @param message
+     * @param args
+     */
+    public async remove(message: Message, args: Args): Promise<void> {
+        const parsedArgs = await Punishments.parseRemoveArgs(args).catch(
+            (err: Error) => err
+        );
+
+        if (parsedArgs instanceof Error) {
+            await message.channel.send({
+                content:
+                    parsedArgs.message === 'There are no more arguments.'
+                        ? undefined
+                        : parsedArgs.message,
+                embeds: [Punishments.REMOVE_PUNISH_EMBED],
+            });
+            return;
+        }
+
+        const bot = this.container.client as Bot;
+        const removed = await bot
+            .getDatabase()
+            .punishments.remove({
+                index: parsedArgs.index,
+                target: parsedArgs.target,
+                targetKey: parsedArgs.targetKey,
+                lenient: parsedArgs.lenient,
+            })
+            .catch((err: InsertError) => err);
+
+        if (removed instanceof DatabaseError) {
+            message.channel.send({
+                content: `An error occurred while trying to remove the punishment.
+Please notify a developer so that we can check the internal logs`,
+            });
+            this.container.logger.error(removed);
+            return;
+        }
+
+        await message.reply({
+            allowedMentions: { users: [], roles: [], repliedUser: false },
+            content: `Successfully removed punishment for ${
+                parsedArgs.target
+            } ${getRoleOrUser(parsedArgs)}.`,
+        });
+
+        await bot.getPunishmentController().synchronize(true);
+    }
+
+    /**
+     * internal function used to parse arguments provided in the create command
+     * @param argsObj
+     * @private
+     */
+    private static async parseCreateArgs(
+        argsObj: Args
+    ): Promise<Tables.Punishments.CreateObject> {
+        const numeric = /^(\.|\d)+$/;
+        const mention = /^<(@&?!?)(.*)>$/;
+        const argsStr = ((await argsObj.rest('string')) || '').toLowerCase();
+        // eslint-disable-next-line
+        let [index, type, target, targetKey, lenient, length]: any[] =
+            argsStr.split(/\s+/);
+
+        if (index.match(numeric) === null) throw new Error('index must be numeric');
+        index = Number.parseInt(index, 10);
+
+        if (['ban', 'kick', 'mute'].indexOf(type) === -1)
+            throw new Error('punishment type is invalid');
+
+        const requiresTargetKey = ['user', 'role'].indexOf(target);
+        if (requiresTargetKey === -1) throw new Error('punishment target is invalid');
+
+        const mentionedMatch = targetKey.match(mention);
+        if (targetKey.match(numeric) === null && mentionedMatch === null)
+            throw new Error('punishment target key must be numeric');
+
+        if (mentionedMatch !== null) {
+            // replace the mention string with just the ID
+            targetKey = mentionedMatch[2] as string;
+        }
+
+        if (
+            ['1', '0', 'yes', 'no', 'true', 'false'].indexOf(lenient.toLowerCase()) === -1
+        )
+            throw new Error('punishment leniency must be boolean(ish)');
+        lenient = ['1', 'yes', 'true'].indexOf(lenient) >= 0;
+
+        if ((length?.match(numeric) || null) === null) length = undefined;
+        else length = Number.parseInt(length, 10);
+
+        return {
+            index,
+            type,
+            target,
+            targetKey,
+            lenient,
+            length,
+        };
+    }
+
+    /**
+     * internal function used to parse arguments provided in the remove command
+     * @param argsObj
+     * @private
+     */
+    private static async parseRemoveArgs(
+        argsObj: Args
+    ): Promise<Tables.Punishments.RemoveObject> {
+        const numeric = /^(\.|\d)+$/;
+        const mention = /^<(@&?!?)(.*)>$/;
+        const argsStr = ((await argsObj.rest('string')) || '').toLowerCase();
+        // eslint-disable-next-line
+        let [index, target, targetKey, lenient]: any[] = argsStr.split(/\s+/);
+
+        if (index.match(numeric) === null) throw new Error('index must be numeric');
+        index = Number.parseInt(index, 10);
+
+        const requiresTargetKey = ['user', 'role'].indexOf(target);
+        if (requiresTargetKey === -1) throw new Error('punishment target is invalid');
+
+        const mentionedMatch = targetKey.match(mention);
+        if (targetKey.match(numeric) === null && mentionedMatch === null)
+            throw new Error('punishment target key must be numeric');
+
+        if (mentionedMatch !== null) {
+            // replace the mention string with just the ID
+            targetKey = mentionedMatch[2] as string;
+        }
+
+        if (
+            ['1', '0', 'yes', 'no', 'true', 'false'].indexOf(lenient.toLowerCase()) === -1
+        )
+            throw new Error('punishment leniency must be boolean(ish)');
+        lenient = ['1', 'yes', 'true'].indexOf(lenient) >= 0;
+
+        return {
+            index,
+            target,
+            targetKey,
+            lenient,
+        };
+    }
+
+    // ------------------------- //
+    // all embeds provided below //
+    // ------------------------- //
+
+    private static LIST_PUNISHMENTS_EMBED = (
+        punishments: Parsed.Punishment[]
+    ): MessageEmbedOptions => {
+        return {
+            title: `Punishments for pinging ${punishments[0].target}`,
+            description:
+                'The following punishments are in order based on their **Priority Index**. This is the order in which punishments are handed out.',
+            color: 'ORANGE',
+            fields: [
+                {
+                    name: 'Applies to:',
+                    value: `**${punishments[0].target} ${parsedUserOrRole(
+                        punishments[0].target,
+                        punishments[0].targetKey
+                    )}**`,
+                },
+                {
+                    inline: true,
+                    name: 'Lenient Punishments',
+                    value: Punishments.GENERATE_PUNISHMENTS_VALUE(punishments, true),
+                },
+                {
+                    inline: true,
+                    name: 'Standard Punishments',
+                    value: Punishments.GENERATE_PUNISHMENTS_VALUE(punishments),
+                },
+            ],
+        };
+    };
+
+    private static GENERATE_PUNISHMENTS_VALUE(
+        punishments: Parsed.Punishment[],
+        isLenient = false
+    ) {
+        return (
+            punishments
+                .filter(({ lenient }) => isLenient === lenient)
+                .map(
+                    ({ length, type, index }) =>
+                        `*#${index}*, **${type}** for ___${
+                            minutesToReadable((length || 0) / 1000 / 60) || 'eternity'
+                        }___`
+                )
+                .join('\n') || 'No punishments found.'
+        );
+    }
+
+    private static LIST_PUNISHMENT_HISTORY(
+        user: User,
+        history: Parsed.PunishmentHistory[]
+    ): MessageEmbedOptions {
+        const endTime = (item: Parsed.PunishmentHistory) =>
+            item.endsAt ? `<t:${item.endsAt.getTime() / 1000}>` : '**the end of time**';
+        const expiresTime = (item: Parsed.PunishmentHistory) =>
+            item.expiresAt
+                ? `<t:${item.expiresAt.getTime() / 1000}>`
+                : '**the end of time**';
+        const isPast = (item: Parsed.PunishmentHistory) =>
+            item.endsAt ? Date.now() > item.endsAt.getTime() : false;
+        return {
+            title: `Ping Punishments for ${user.username}`,
+            description: `The following is a list of punishments in order in which they were given. This includes expired and completed punishments\n${
+                history.length > 0 ? '' : '\n**There is no punishment history.**'
+            }`,
+            color: 'RED',
+            fields: history.map((item, idx) => ({
+                name: `Punishment #${idx + 1} ${
+                    isPast(item) ? '___*No Longer Active*___' : ''
+                }`,
+                value: `Punishment Given at <t:${item.createdAt.getTime() / 1000}>
+Punishment Completes at ${endTime(item)}
+Punishment Expires at ${expiresTime(item)}`,
+            })),
+        };
+    }
+
+    private static CREATE_PUNISHMENT_EMBED: MessageEmbedOptions = {
+        title: 'How To Create A Punishment',
+        description: `The following command is the structure you should use when creating a punishment via this command
+\`${CONFIG.bot.prefix}punishments create [PriorityIndex] [Type] [Target] [TargetKey] [Lenient] [Length?]\``,
+        color: 'GREEN',
+        fields: [
+            {
+                name: 'Priority Index',
+                value: '`Numeric, [0 - 10000]` (lower number means punishment is give first)',
+            },
+            {
+                name: 'Type',
+                value: '`Ban | Mute | Kick` (the type of punishment)',
+            },
+            {
+                name: 'Target',
+                value: '`Role | User` (role means anyone with the role will have ping protection)',
+            },
+            {
+                name: 'Target Key',
+                value: '`@user | @role | Role ID | User ID` (You can mention a user or role, or you can input the ID of the role or user)',
+            },
+            {
+                name: 'Lenient',
+                value: '`yes | no | true | false` (allows you to have two different types of punishments based on the punished users role, bros vs tiered punishment)',
+            },
+            {
+                name: 'Length *(optional)*',
+                value: '`numeric | nothing` The length of the punishment in minutes (1 day is 1440 minutes).\n**If blank, the punishment is indefinite**',
+            },
+        ],
+        footer: {
+            text: 'If you have any questions, get in touch with the developers.',
+        },
+    };
+
+    private static REMOVE_PUNISH_EMBED: MessageEmbedOptions = {
+        title: 'How To Remove A Punishment',
+        description: `In order to remove a punishment, you must know **four (4)** pieces of information about the punishment.
+        The following command is the structure you should use when removing a punishment via this command.
+\`${CONFIG.bot.prefix}punishments remove [PriorityIndex] [Target] [TargetKey] [Lenient]\`
+**Please Note:** removing a punishment does **not** effect punishment history at all.`,
+        color: 'RED',
+        fields: [
+            {
+                name: 'Priority Index',
+                value: '`Numeric, [0 - 10000]`',
+            },
+            {
+                name: 'Target',
+                value: '`Role | User`',
+            },
+            {
+                name: 'Target Key',
+                value: '`@user | @role | Role ID | User ID`',
+            },
+            {
+                name: 'Lenient',
+                value: '`yes | no | true | false`',
+            },
+        ],
+        footer: {
+            text: 'If you have any questions, get in touch with the developers.',
+        },
+    };
+
+    private static HELP_EMBED: MessageEmbedOptions = {
+        title: `${CONFIG.bot.prefix}punishments Walkthrough`,
+        description: `There are a few commands to be aware of.
+
+Returns this embed.
+\`\`\`${CONFIG.bot.prefix}punishments help\`\`\`
+Returns a single embed for each role or user that has ping protection.
+\`\`\`${CONFIG.bot.prefix}punishments list\`\`\`
+Returns all punishments that the selected user has received by the bot.
+\`\`\`${CONFIG.bot.prefix}punishments for @user\`\`\`
+Allows you to create new punishments. 
+${disclaimer}
+\`\`\`${CONFIG.bot.prefix}punishments create [options]\`\`\`
+Allows you to remove an existing punishment. 
+${disclaimer}
+\`\`\`${CONFIG.bot.prefix}punishments remove [options]\`\`\``,
+        color: 'YELLOW',
+    };
+}
diff --git a/src/config/bot.ts b/src/config/bot.ts
index 739dec3..f2f9503 100644
--- a/src/config/bot.ts
+++ b/src/config/bot.ts
@@ -5,9 +5,9 @@ class BotConfig extends Conf {
 
     public readonly prefix: string;
 
-    public readonly owners: string[];
+    public readonly guild: string;
 
-    public readonly block: string[];
+    public readonly owners: string[];
 
     public readonly blockTimeout: number;
 
@@ -17,19 +17,31 @@ class BotConfig extends Conf {
 
     public readonly notifyRoles: string[];
 
+    public readonly moderatorRoles: string[];
+
     public readonly notifyChannels: string[];
 
+    public readonly lenientRoles: string[];
+
+    public readonly muteRole: string;
+
+    public readonly dryrun: boolean;
+
     constructor() {
         super('bot');
         this.token = 'BotToken';
         this.prefix = '!';
+        this.guild = '';
         this.owners = ['id1', 'id2'];
-        this.block = [];
         this.excludedChannels = [];
         this.blockTimeout = 10;
         this.notifyTimeout = 10;
         this.notifyRoles = [];
         this.notifyChannels = [];
+        this.lenientRoles = [];
+        this.moderatorRoles = [];
+        this.muteRole = '';
+        this.dryrun = false;
     }
 }
 
diff --git a/src/controllers/PingController.ts b/src/controllers/PingController.ts
index d9a7e4a..79906f7 100644
--- a/src/controllers/PingController.ts
+++ b/src/controllers/PingController.ts
@@ -2,6 +2,8 @@ import { Message } from 'discord.js';
 import Controller from './controller';
 import Bot from '../Bot';
 import { CONFIG } from '../globals';
+import { FlaggedMention } from './PunishmentController';
+import { sentByAuthorizedUser } from '../utils';
 
 export class PingController extends Controller {
     constructor(bot: Bot) {
@@ -12,12 +14,15 @@ export class PingController extends Controller {
      * checks for messages that include pings of users who should not be pinged
      * if a ping is found, it is removed and a message is sent to the channel
      * telling the user to not ping this user.
-     * @todo handle punishments
      */
     public async handleMessage(message: Message): Promise<boolean> {
+        const punishmentController = this.bot.getPunishmentController();
+        const author = message.guild?.members.resolve(message.author.id);
+
         if (
             message.author.bot ||
-            CONFIG.bot.excludedChannels.indexOf(message.channel.id) >= 0
+            CONFIG.bot.excludedChannels.indexOf(message.channel.id) >= 0 ||
+            sentByAuthorizedUser(author)
         )
             return false;
 
@@ -26,35 +31,34 @@ export class PingController extends Controller {
 
         const pingedUsers: string[] = [];
         let canPing = true;
-        for (const mentionId of flaggedMentions) {
-            if (!this.canPing(mentionId)) {
-                canPing = false;
-                const flaggedMention = message.mentions.users.get(mentionId);
-                if (flaggedMention) {
-                    pingedUsers.push(`<@${flaggedMention.id}>`);
-                    this.getLogger().info(
-                        `A mention of '${flaggedMention.username}' was caught and  is pending deletion.`
-                    );
-                }
-            }
-        }
 
-        if (!canPing) {
-            await message.delete().catch(this.handleError);
-            const notification = await message.channel
-                .send({
-                    content: `Please do not ping ${pingedUsers.join(
-                        ', '
-                    )} unless they are active.`,
-                    allowedMentions: { users: [] },
-                })
-                .catch(this.handleError);
-
-            // TODO handle punishments
-
-            if (notification) {
-                await notification.delete({ timeout: 10000 }).catch(this.handleError);
-            }
+        flaggedMentions.forEach((mention) => {
+            if (this.canPing(mention.user)) return;
+            const flaggedUser = message.mentions.users.get(mention.user);
+            if (typeof flaggedUser === 'undefined') return;
+            canPing = false;
+            pingedUsers.push(`<@${flaggedUser.id}>`);
+            this.getLogger().info(
+                `A mention of '${flaggedUser.username}' was caught and  is pending deletion.`
+            );
+        });
+
+        if (canPing) return false;
+
+        await message.delete().catch(this.handleError);
+        const notification = await message.channel
+            .send({
+                content: `Please do not ping ${pingedUsers.join(
+                    ', '
+                )} unless they are active.`,
+                allowedMentions: { users: [] },
+            })
+            .catch(this.handleError);
+
+        await punishmentController.punish(message, flaggedMentions);
+
+        if (notification) {
+            setTimeout(() => notification.delete(), 5000);
         }
 
         return true;
@@ -64,8 +68,35 @@ export class PingController extends Controller {
      * checks to see if the message contains any pings of users that should not be pinged
      * and returns all the user id that are mentioned that should not be.
      */
-    private getFlaggedMentions(message: Message): string[] {
-        return CONFIG.bot.block.filter((id) => message.mentions.has(id));
+    private getFlaggedMentions(message: Message): FlaggedMention[] {
+        const punishmentController = this.bot.getPunishmentController();
+        const mentions: FlaggedMention[] = [];
+
+        const blockedUsers = punishmentController.getBlockedUsers();
+        blockedUsers.forEach((blocked) => {
+            if (message.mentions.has(blocked)) {
+                mentions.push({
+                    user: blocked,
+                    type: 'user',
+                });
+            }
+        });
+
+        const blockedRoles = punishmentController.getBlockedRoles();
+        blockedRoles.forEach((role) => {
+            const exists = message.mentions.members?.find((user) => {
+                return user.roles.resolve(role) !== null;
+            });
+            if (exists) {
+                mentions.push({
+                    user: exists.id,
+                    role,
+                    type: 'role',
+                });
+            }
+        });
+
+        return mentions;
     }
 
     /**
diff --git a/src/controllers/PingableUserController.ts b/src/controllers/PingableUserController.ts
index 38828c9..16198a9 100644
--- a/src/controllers/PingableUserController.ts
+++ b/src/controllers/PingableUserController.ts
@@ -3,6 +3,7 @@ import Controller from './controller';
 import Bot from '../Bot';
 import { CONFIG } from '../globals';
 import Timeout = NodeJS.Timeout;
+import { minutesToReadable } from '../utils';
 
 type Message = DiscordMessage & {
     command?: never | null;
@@ -34,13 +35,7 @@ export class PingableUserController extends Controller {
      */
     public async init(): Promise<void> {
         const db = this.bot.getDatabase();
-        const ids = CONFIG.bot.block
-            .filter((id) => id.match(/^\d+$/))
-            .map((id) => Number.parseInt(id, 10));
-
-        await db.blockedUsers.initializeUsers(ids);
-
-        const users = await db.blockedUsers.getById(ids);
+        const users = await db.monitoredUsers.getAll();
         users.forEach((user) =>
             user ? (this.usersLastMessage[`${user.id}`] = user.lastMessage) : undefined
         );
@@ -51,7 +46,15 @@ export class PingableUserController extends Controller {
      * extend the timeout for the user and notify notifiable roles
      */
     public async handleMessage(message: Message): Promise<boolean> {
-        if (CONFIG.bot.block.indexOf(message.author.id) < 0 && message.command !== null) {
+        const punishmentController = this.bot.getPunishmentController();
+        const author = message.guild?.members.resolve(message.author.id);
+        if (
+            !punishmentController.isMonitoredMember(author) ||
+            message.author.bot ||
+            message.content.startsWith(CONFIG.bot.prefix) ||
+            CONFIG.bot.excludedChannels.indexOf(message.channel.id) >= 0 ||
+            CONFIG.bot.notifyChannels.indexOf(message.channel.id) >= 0
+        ) {
             return false;
         }
 
@@ -59,7 +62,7 @@ export class PingableUserController extends Controller {
         await this.extend(message.author.id, now);
 
         await this.notify(message);
-        this.getLogger().verbose(
+        this.getLogger().debug(
             `message sent by '${message.author.username}' at ${now}... Waiting until ${
                 now + CONFIG.bot.blockTimeout * 1000 * 60
             }`
@@ -88,7 +91,7 @@ export class PingableUserController extends Controller {
         this.notifyTimeouts[authorId] = setTimeout(() => {
             CONFIG.bot.notifyChannels.map(async (channelId) => {
                 const channel = message.guild?.channels.resolve(channelId) as TextChannel;
-                if (channel && channel.type === 'text') {
+                if (channel && channel.type === 'GUILD_TEXT') {
                     await channel.send({
                         content: `<@${authorId}> doesn't seem to be around anymore, you can rest your eyes`,
                         allowedMentions: { users: [] },
@@ -102,17 +105,32 @@ export class PingableUserController extends Controller {
 
         const notifyChannels = CONFIG.bot.notifyChannels.map(async (channelId) => {
             const channel = message.guild?.channels.resolve(channelId) as TextChannel;
-            if (channel && channel.type === 'text') {
+            if (channel && channel.type === 'GUILD_TEXT') {
                 const notifiedRoles = CONFIG.bot.notifyRoles.map(
                     (roleId) => `<@&${roleId}>`
                 );
                 const link = `https://discord.com/channels/${message.guild?.id}/${message.channel.id}/${message.id}`;
                 await channel
                     .send({
-                        content: `${notifiedRoles.join(
-                            ', '
-                        )}, <@${authorId}> has made an appearance! I'll notify you once some time has past since they have sent a message.\n${link}`,
-                        allowedMentions: { roles: CONFIG.bot.notifyRoles },
+                        content: `**Attention ${notifiedRoles.join(', ')},** 
+<@${authorId}> has made an appearance!
+I'll notify you again after \`${minutesToReadable(
+                            timeout
+                        )}\` have passed since the last message they send.`,
+                        allowedMentions: { roles: CONFIG.bot.notifyRoles, users: [] },
+                        components: [
+                            {
+                                type: 'ACTION_ROW',
+                                components: [
+                                    {
+                                        type: 'BUTTON',
+                                        label: 'View Post',
+                                        url: link,
+                                        style: 'LINK',
+                                    },
+                                ],
+                            },
+                        ],
                     })
                     .catch(this.handleError);
             }
@@ -142,7 +160,7 @@ export class PingableUserController extends Controller {
         const action = () =>
             this.bot
                 .getDatabase()
-                .blockedUsers.updateLastMessage(
+                .monitoredUsers.updateLastMessage(
                     Number.parseInt(snowflake, 10),
                     timestamp + timeout * 1000 * 60
                 )
diff --git a/src/controllers/PunishmentController.ts b/src/controllers/PunishmentController.ts
new file mode 100644
index 0000000..c7ef212
--- /dev/null
+++ b/src/controllers/PunishmentController.ts
@@ -0,0 +1,362 @@
+import { Guild, GuildMember, Message, MessageEmbedOptions } from 'discord.js';
+import Controller from './controller';
+import Bot from '../Bot';
+import { CONFIG } from '../globals';
+import { Parsed, TargetType } from '../database/types';
+
+export type FlaggedMention = {
+    user: string;
+    role?: string;
+    type: TargetType;
+};
+
+type Punishment = Parsed.Punishment;
+
+type PunishmentCache = {
+    role: {
+        [s: string]: Punishment[];
+    };
+    user: {
+        [s: string]: Punishment[];
+    };
+};
+
+export default class PunishmentController extends Controller {
+    private punishments: PunishmentCache;
+
+    public constructor(bot: Bot) {
+        super(bot, 'PunishmentController');
+
+        this.punishments = this.organizePunishments();
+    }
+
+    /**
+     * used to ensure that all punishments are synchronized with the database for the guild.
+     * (It is currently used in a synchronization interval as well as called independently whenever
+     * punishments are created/removed)
+     * @param syncPunishments if true, synchronizes punishments as well as punishment history
+     */
+    public async synchronize(syncPunishments = false): Promise<void> {
+        const db = this.bot.getDatabase();
+        const activePunishments = await db.punishmentHistory.getAllLatest();
+
+        if (syncPunishments) {
+            const punishments = await db.punishments.getAllActive();
+            this.punishments = this.organizePunishments(punishments);
+        }
+
+        const guild = this.bot.guilds.resolve(CONFIG.bot.guild);
+        if (guild === null) throw new Error('Guild not found.');
+        const sync = this.syncHistory(guild);
+        await Promise.all(activePunishments.map(sync));
+    }
+
+    /**
+     * Creates a guild specific synchronization function used to make sure that
+     * will automatically unban/unmute punished users after their punishment is
+     * no longer active.
+     * @param guild
+     */
+    public syncHistory(
+        guild: Guild
+    ): (punishment: Parsed.PunishmentHistoryWithCount | null) => Promise<void> {
+        const db = this.bot.getDatabase();
+        return async (punishment: Parsed.PunishmentHistoryWithCount | null) => {
+            if (punishment === null) {
+                return;
+            }
+
+            const shouldRemovePunishment =
+                punishment.endsAt !== null &&
+                punishment.endsAt.getTime() < Date.now() &&
+                punishment.active;
+
+            if (!shouldRemovePunishment) return;
+
+            try {
+                const member = await guild.members.fetch(punishment.userId);
+                if (member) {
+                    await member.roles.remove(CONFIG.bot.muteRole);
+                    await db.punishmentHistory.setActive(punishment.id, false);
+                }
+            } catch (noop) {
+                // should only fire if the user is not in the guild
+            }
+
+            try {
+                await guild.members.unban(
+                    punishment.userId,
+                    'They have served their sentence.'
+                );
+                await db.punishmentHistory.setActive(punishment.id, false);
+                this.getLogger().info(`${punishment.userId} has served their sentence.`);
+            } catch (noop) {
+                // should only catch if the user was unbanned manually
+                // and we shouldn't care about them.
+            }
+        };
+    }
+
+    /**
+     * Creates a punishment record for the author of the message and sends discord notification.
+     * The punishment given is dependent upon how many punishments the author has previously
+     * received, along with whether or not the user has a lenient role.
+     * @param message
+     * @param mentions
+     */
+    public async punish(message: Message, mentions: FlaggedMention[]): Promise<void> {
+        const author = message.author.id;
+        const { guild } = message;
+        if (guild === null) {
+            throw new Error('guild not found.');
+        }
+
+        const guildMember = message.guild?.members.resolve(author);
+        if (guildMember === null || typeof guildMember === 'undefined') {
+            throw new Error('selected user is not a guild member somehow');
+        }
+
+        const db = this.bot.getDatabase();
+        const currentPunishments = await db.punishmentHistory.getByUserId(
+            guildMember.user.id,
+            true
+        );
+
+        const hasLenientRole =
+            CONFIG.bot.lenientRoles.findIndex((role) => {
+                return guildMember.roles.resolve(role) !== null;
+            }) >= 0;
+
+        const punishments: Punishment[] = [];
+
+        for (const mention of mentions) {
+            if (punishments.length > 0) break;
+            let key = mention.type === 'user' ? mention.user : undefined;
+            if (typeof key === 'undefined' && mention.type === 'role') key = mention.role;
+            punishments.push(...this.getPunishments(mention.type, key, hasLenientRole));
+        }
+
+        if (punishments.length === 0 && hasLenientRole) {
+            this.getLogger().warn({
+                error: 'No lenient punishments found.',
+                mentions,
+            });
+            return;
+        }
+
+        const nextPunishment =
+            punishments[Math.min(currentPunishments.length, punishments.length - 1)];
+
+        const endsAt =
+            typeof nextPunishment.length === 'number'
+                ? Date.now() + nextPunishment.length
+                : true;
+
+        await db.punishmentHistory.create({
+            userId: author,
+            endsAt,
+        });
+
+        await this.handleDiscordPunishment(
+            message,
+            nextPunishment,
+            mentions,
+            currentPunishments,
+            endsAt
+        );
+    }
+
+    /**
+     * Sends a DM to the author that they have been punished.
+     * This DM contains an embed that shows their punishment history along with how long their
+     * punishment will be.
+     * @param message
+     * @param punishment
+     * @param mentions
+     * @param punishmentHistory
+     * @param endsAt
+     * @private
+     */
+    private async handleDiscordPunishment(
+        message: Message,
+        punishment: Punishment,
+        mentions: FlaggedMention[],
+        punishmentHistory: Array<Parsed.PunishmentHistory | null>,
+        endsAt: number | true
+    ): Promise<void> {
+        const duration =
+            endsAt === true ? 'the end of time' : `<t:${Math.round(endsAt / 1000)}>`;
+        let description: string | undefined;
+
+        switch (punishment.type) {
+            case 'ban':
+                description = `You've been banned until ${duration} for pinging the following people.`;
+                break;
+            case 'mute':
+                description = `You've been muted until ${duration} for pinging the following people.`;
+                break;
+            case 'kick':
+                description = `You've been kicked for pinging the following people.`;
+                break;
+            default:
+                description = 'Unknown punishment given.';
+        }
+
+        const embed: MessageEmbedOptions = {
+            title: `You've been banned on ${message.guild?.name} server.`,
+            timestamp: Date.now(),
+            footer: {
+                text: `C'mon, you know better than this!`,
+            },
+            description,
+            fields: [
+                {
+                    name: 'Mentioned Users',
+                    value: mentions.map((mention) => `<@${mention.user}>`).join(', '),
+                },
+                {
+                    name: 'Punishment History',
+                    value:
+                        punishmentHistory.length > 0
+                            ? punishmentHistory
+                                  .map((pun) => {
+                                      return `Punished at <t:${Math.round(
+                                          (pun?.createdAt.getTime() || 0) / 1000
+                                      )}>`;
+                                  })
+                                  .join('\n')
+                            : 'No previous punishments',
+                },
+            ],
+            color: 'RED',
+        };
+
+        const channel = await message.author.createDM();
+        await channel.send({
+            embeds: [embed],
+        });
+
+        // skip the actual punishment for testing
+        if (CONFIG.bot.dryrun) return;
+
+        switch (punishment.type) {
+            case 'ban':
+                await message.guild?.members.ban(message.author, {
+                    reason: `Pinging people they shouldn't ping.`,
+                });
+                break;
+            case 'mute':
+                message.guild?.members
+                    .resolve(message.author)
+                    ?.roles.add(CONFIG.bot.muteRole);
+                break;
+            case 'kick':
+                if (message.member?.kickable)
+                    await message.member.kick("Pinging someone he shouldn't.");
+                else
+                    this.getLogger().warn(
+                        `${message.author.username} was not able to be kicked.`
+                    );
+                break;
+            default:
+                this.getLogger().error(`Unhandled punishment type ${punishment.type}`);
+        }
+    }
+
+    /**
+     * determine if the selected author is a monitored user by comparing their
+     * roles and user ID to the punishments cache of users and roles
+     * @param author
+     */
+    public isMonitoredMember(author?: GuildMember | null): boolean {
+        const hasMonitoredRole =
+            Object.keys(this.punishments.role).findIndex(
+                (role) => author?.roles.resolve(role) !== null
+            ) >= 0;
+        const isMonitoredUser = this.punishments.user[author?.id || 0] instanceof Array;
+
+        return isMonitoredUser || hasMonitoredRole;
+    }
+
+    /**
+     * simple function to check whether or not the target has any available punishments to give out.
+     * @param target ['user'|'role']
+     * @param targetKey [string]
+     */
+    public hasPunishments(target: TargetType, targetKey?: string): boolean {
+        if (typeof targetKey === 'string')
+            return this.punishments[target][targetKey].length > 0;
+        return false;
+    }
+
+    /**
+     * returns a list of users that should not be pinged
+     */
+    public getBlockedUsers(): string[] {
+        return Object.keys(this.punishments.user);
+    }
+
+    /**
+     * returns a list of roles that should not be pinged
+     */
+    public getBlockedRoles(): string[] {
+        return Object.keys(this.punishments.role);
+    }
+
+    /**
+     * Gets punishment options for a specific target, key, and leniency
+     * @param target
+     * @param targetKey
+     * @param lenient
+     */
+    public getPunishments(
+        target: TargetType,
+        targetKey?: string,
+        lenient?: boolean
+    ): Punishment[] {
+        if (!(typeof targetKey === 'string' && this.punishments[target][targetKey]))
+            return [];
+
+        if (!lenient) {
+            return [...this.punishments[target][targetKey]];
+        }
+
+        const filtered = this.punishments[target][targetKey].filter(
+            (k) => k.lenient === lenient
+        );
+        if (filtered.length === 0 && lenient) {
+            return this.punishments[target][targetKey].filter((k) => !k.lenient);
+        }
+        return filtered;
+    }
+
+    /**
+     * Used to remap the punishment options received from the databased and put them into a local cache
+     * @param punishments
+     * @private
+     */
+    private organizePunishments(punishments?: Punishment[]) {
+        const nextCache: PunishmentCache = {
+            role: {},
+            user: {},
+        };
+        if (typeof punishments === 'undefined') return nextCache;
+
+        punishments.forEach((punishment) => {
+            // eslint-disable-next-line
+            switch (punishment.target) {
+                case 'user':
+                    if (typeof nextCache.user[punishment.targetKey] === 'undefined')
+                        nextCache.user[punishment.targetKey] = [];
+                    nextCache.user[punishment.targetKey].push(punishment);
+                    break;
+                case 'role':
+                    if (typeof nextCache.role[punishment.targetKey] === 'undefined')
+                        nextCache.role[punishment.targetKey] = [];
+                    nextCache.role[punishment.targetKey].push(punishment);
+                    break;
+            }
+        });
+        return nextCache;
+    }
+}
diff --git a/src/controllers/controller.ts b/src/controllers/controller.ts
index 3d86276..71b24c7 100644
--- a/src/controllers/controller.ts
+++ b/src/controllers/controller.ts
@@ -4,8 +4,8 @@
  * @property {string}  name Name of the controller (for logging purposes)
  * @property {Bot} bot bot to get a logger instance
  */
-import winston from 'winston';
 import Bot from '../Bot';
+import { BotLogger } from '../utils/logger';
 
 class Controller {
     private readonly name: string;
@@ -25,8 +25,8 @@ class Controller {
         return null;
     };
 
-    protected getLogger(): winston.Logger {
-        return Bot.getLogger(`Controller::${this.name}`);
+    protected getLogger(): BotLogger {
+        return Bot.getLogger(`[Controller::${this.name}]`);
     }
 }
 
diff --git a/src/database/database.ts b/src/database/database.ts
index 54a812b..4a825d0 100644
--- a/src/database/database.ts
+++ b/src/database/database.ts
@@ -1,8 +1,10 @@
 import { Pool, PoolConfig, DatabaseError, PoolClient } from 'pg';
-import winston from 'winston';
 import Table from './models/Table';
-import BlockedUsersTable from './tables/BlockedUsers';
 import Bot from '../Bot';
+import { BotLogger } from '../utils/logger';
+import MonitoredUsersTable from './tables/MonitoredUsers';
+import PunishmentHistory from './tables/PunishmentHistory';
+import Punishments from './tables/Punishments';
 
 type CustomizedConfig = PoolConfig & {
     schema: string;
@@ -17,9 +19,13 @@ export default class DatabaseManager {
 
     private readonly username?: string;
 
-    private readonly logger: winston.Logger;
+    private readonly logger: BotLogger;
 
-    public readonly blockedUsers: BlockedUsersTable;
+    public readonly monitoredUsers: MonitoredUsersTable;
+
+    public readonly punishmentHistory: PunishmentHistory;
+
+    public readonly punishments: Punishments;
 
     constructor(config: CustomizedConfig) {
         const { schema, ...poolConfig } = config;
@@ -28,7 +34,10 @@ export default class DatabaseManager {
         this.schema = schema;
         this.escapedSchema = `"${schema}"`;
 
-        this.blockedUsers = new BlockedUsersTable(this);
+        this.monitoredUsers = new MonitoredUsersTable(this);
+        this.punishmentHistory = new PunishmentHistory(this);
+        this.punishments = new Punishments(this);
+
         this.logger = DatabaseManager.getLogger();
     }
 
@@ -97,7 +106,7 @@ export default class DatabaseManager {
             .filter((table) => typeof table !== 'undefined') as Table[];
     }
 
-    public static getLogger(section?: string): winston.Logger {
-        return Bot.getLogger(`Database${!!section && `::${section}`}`);
+    public static getLogger(section?: string): BotLogger {
+        return Bot.getLogger(`[Database${!!section && `::${section}`}]`);
     }
 }
diff --git a/src/database/errors/DatabaseError.ts b/src/database/errors/DatabaseError.ts
index 3486b00..8cb496b 100644
--- a/src/database/errors/DatabaseError.ts
+++ b/src/database/errors/DatabaseError.ts
@@ -1,26 +1,66 @@
-export default class DatabaseError extends Error {
-    static DELETE_ERROR = 'Delete Error';
+import { DatabaseError as DBError } from 'pg-protocol/dist/messages';
 
-    static INSERT_ERROR = 'Insert Error';
+type RippedDBError = Omit<DBError, 'message' | 'length' | 'name'>;
 
-    static UPDATE_ERROR = 'Update Error';
+export default class DatabaseError implements RippedDBError {
+    public static DELETE_ERROR = 'Delete Error';
 
-    static SELECT_ERROR = 'Select Error';
+    public static INSERT_ERROR = 'Insert Error';
 
-    readonly errorMessage?: string;
+    public static UPDATE_ERROR = 'Update Error';
 
-    constructor(type: string, message?: string);
+    public static SELECT_ERROR = 'Select Error';
 
-    constructor(error: Error, type: string, message?: string);
+    public readonly errorMessage?: string;
 
-    constructor(error: Error | string, type?: string, message?: string) {
-        if (!(error instanceof Error) && typeof message === 'undefined') {
+    public readonly errorName?: string;
+
+    public message: string;
+
+    public code: string | undefined;
+
+    public column: string | undefined;
+
+    public constraint: string | undefined;
+
+    public dataType: string | undefined;
+
+    public detail: string | undefined;
+
+    public file: string | undefined;
+
+    public hint: string | undefined;
+
+    public internalPosition: string | undefined;
+
+    public internalQuery: string | undefined;
+
+    public readonly length: number | undefined;
+
+    public line: string | undefined;
+
+    public name: string;
+
+    public position: string | undefined;
+
+    public routine: string | undefined;
+
+    public schema: string | undefined;
+
+    public severity: string | undefined;
+
+    public table: string | undefined;
+
+    public where: string | undefined;
+
+    constructor(error?: Error | string, message?: string) {
+        if (typeof error === 'string' && typeof message === 'undefined') {
             message = error;
+            error = undefined;
         }
         if (error instanceof Error && typeof message === 'undefined') {
             message = error.message;
         }
-        super(message);
 
         // remap the actual error into this error
         if (error instanceof Error) {
@@ -29,8 +69,11 @@ export default class DatabaseError extends Error {
                 // eslint-disable-next-line
                 this[key as never] = error[key as never];
             }
+            this.errorName = error.name;
             this.errorMessage = error.message;
         }
-        if (type) this.name = type;
+
+        this.name = 'Database Error';
+        this.message = message || '';
     }
 }
diff --git a/src/database/errors/DeleteError.ts b/src/database/errors/DeleteError.ts
index 66b8919..7fa09b4 100644
--- a/src/database/errors/DeleteError.ts
+++ b/src/database/errors/DeleteError.ts
@@ -9,16 +9,7 @@ export default class DeleteError extends DatabaseError {
     constructor(error: DBError, message: string);
 
     constructor(error?: DBError | string, message?: string) {
-        if (!(error instanceof DBError) && typeof message === 'undefined') {
-            message = error;
-        }
-        if (error instanceof DBError && typeof message === 'undefined') {
-            message = error.message;
-        }
-
-        if (error instanceof Error) super(error, DatabaseError.DELETE_ERROR, message);
-        else super(DatabaseError.DELETE_ERROR, message);
-
+        super(error, message);
         this.name = DatabaseError.DELETE_ERROR;
     }
 }
diff --git a/src/database/errors/InsertError.ts b/src/database/errors/InsertError.ts
index 5f95af6..15aad34 100644
--- a/src/database/errors/InsertError.ts
+++ b/src/database/errors/InsertError.ts
@@ -9,16 +9,7 @@ export default class InsertError extends DatabaseError {
     constructor(error: DBError, message: string);
 
     constructor(error?: DBError | string, message?: string) {
-        if (!(error instanceof Error) && typeof message === 'undefined') {
-            message = error;
-        }
-        if (error instanceof Error && typeof message === 'undefined') {
-            message = error.message;
-        }
-
-        if (error instanceof Error) super(error, DatabaseError.INSERT_ERROR, message);
-        else super(DatabaseError.INSERT_ERROR, message);
-
+        super(error, message);
         this.name = DatabaseError.INSERT_ERROR;
     }
 }
diff --git a/src/database/errors/SelectError.ts b/src/database/errors/SelectError.ts
index bc84ee0..2a6be0c 100644
--- a/src/database/errors/SelectError.ts
+++ b/src/database/errors/SelectError.ts
@@ -9,16 +9,7 @@ export default class SelectError extends DatabaseError {
     constructor(error: DBError, message: string);
 
     constructor(error?: DBError | string, message?: string) {
-        if (!(error instanceof Error) && typeof message === 'undefined') {
-            message = error;
-        }
-        if (error instanceof Error && typeof message === 'undefined') {
-            message = error.message;
-        }
-
-        if (error instanceof Error) super(error, DatabaseError.SELECT_ERROR, message);
-        else super(DatabaseError.SELECT_ERROR, message);
-
+        super(error, message);
         this.name = DatabaseError.SELECT_ERROR;
     }
 }
diff --git a/src/database/errors/UpdateError.ts b/src/database/errors/UpdateError.ts
index 779162c..92e4ce8 100644
--- a/src/database/errors/UpdateError.ts
+++ b/src/database/errors/UpdateError.ts
@@ -9,16 +9,7 @@ export default class UpdateError extends DatabaseError {
     constructor(error: DBError, message: string);
 
     constructor(error?: DBError | string, message?: string) {
-        if (!(error instanceof Error) && typeof message === 'undefined') {
-            message = error;
-        }
-        if (error instanceof Error && typeof message === 'undefined') {
-            message = error.message;
-        }
-
-        if (error instanceof Error) super(error, DatabaseError.UPDATE_ERROR, message);
-        else super(DatabaseError.UPDATE_ERROR, message);
-
+        super(error, message);
         this.name = DatabaseError.UPDATE_ERROR;
     }
 }
diff --git a/src/database/models/Table.ts b/src/database/models/Table.ts
index cf09549..31e412e 100644
--- a/src/database/models/Table.ts
+++ b/src/database/models/Table.ts
@@ -1,11 +1,8 @@
 import { PoolClient, QueryResult } from 'pg';
-import winston from 'winston';
 import DatabaseManager from '../database';
 import { DatabaseError } from '../errors';
 import { DBParsed, DBTable, ValidationState, ValueObject } from '../types';
-import getLogger from '../../utils/logger';
-
-const logger = getLogger('database:table');
+import { BotLogger } from '../../utils/logger';
 
 export default class Table<Row = DBTable, Parsed = DBParsed> {
     protected readonly manager: DatabaseManager;
@@ -140,6 +137,7 @@ export default class Table<Row = DBTable, Parsed = DBParsed> {
      */
     public async drop(connection?: PoolClient): Promise<void> {
         await this.query(connection, `DROP TABLE IF EXISTS ${this.full};`);
+        this.state = ValidationState.NOT_PROCESSED;
     }
 
     /**
@@ -170,9 +168,14 @@ export default class Table<Row = DBTable, Parsed = DBParsed> {
                     break;
                 case ValidationState.HAS_ADDITIONAL_INIT:
                     this.state = await this.init(connection);
-                    logger.verbose(`${this.full} required additional initialization.`);
+                    this.getLogger().debug(
+                        `${this.full} required additional initialization.`
+                    );
                     await this.validate(connection);
                     break;
+                case ValidationState.VALIDATED:
+                    // noop
+                    break;
                 default:
                     throw new DatabaseError(
                         'Initialization Failed',
@@ -181,7 +184,7 @@ export default class Table<Row = DBTable, Parsed = DBParsed> {
             }
         } else {
             this.state = await this.init(connection);
-            logger.verbose(`${this.name} table created.`);
+            this.getLogger().debug(`${this.name} table created.`);
             if (this.state >= ValidationState.NEEDS_MIGRATION) {
                 await this.validate(connection);
             }
@@ -215,7 +218,7 @@ export default class Table<Row = DBTable, Parsed = DBParsed> {
         throw new Error(`Table init for ${this.full} has not been implemented.`);
     }
 
-    protected getLogger(): winston.Logger {
+    protected getLogger(): BotLogger {
         return DatabaseManager.getLogger(`Table::${this.name}`);
     }
 }
diff --git a/src/database/tables/BlockedUsers.ts b/src/database/tables/MonitoredUsers.ts
similarity index 67%
rename from src/database/tables/BlockedUsers.ts
rename to src/database/tables/MonitoredUsers.ts
index 512670d..a0dd1b6 100644
--- a/src/database/tables/BlockedUsers.ts
+++ b/src/database/tables/MonitoredUsers.ts
@@ -2,22 +2,22 @@ import { PoolClient } from 'pg';
 import Table from '../models/Table';
 import { Parsed, Results, ValidationState } from '../types';
 import DatabaseManager from '../database';
-import { InsertError, SelectError, UpdateError } from '../errors';
+import { DatabaseError, InsertError, SelectError, UpdateError } from '../errors';
 
-export default class BlockedUsersTable extends Table<
-    Results.DBBlockedUser,
-    Parsed.BlockedUser
+export default class MonitoredUsersTable extends Table<
+    Results.DBMonitoredUser,
+    Parsed.MonitoredUser
 > {
-    protected readonly accepted: Array<keyof Parsed.BlockedUser>;
+    protected readonly accepted: Array<keyof Parsed.MonitoredUser>;
 
-    protected readonly nullables: Array<keyof Parsed.BlockedUser>;
+    protected readonly nullables: Array<keyof Parsed.MonitoredUser>;
 
     protected readonly mappedKeys: {
-        [s in keyof Parsed.BlockedUser]: keyof Results.DBBlockedUser;
+        [s in keyof Parsed.MonitoredUser]: keyof Results.DBMonitoredUser;
     };
 
     constructor(manager: DatabaseManager) {
-        super(manager, 'blocked_users');
+        super(manager, 'monitored_users');
         this.nullables = ['lastMessage'];
         this.accepted = ['id', 'lastMessage'];
 
@@ -27,10 +27,6 @@ export default class BlockedUsersTable extends Table<
         };
     }
 
-    /**
-     * creates a record for each user that should have pings blocked.
-     * @param ids user ids to have records created for
-     */
     public async initializeUsers(ids: number | number[]): Promise<boolean>;
 
     public async initializeUsers(
@@ -38,6 +34,12 @@ export default class BlockedUsersTable extends Table<
         ids: number | number[]
     ): Promise<boolean>;
 
+    /**
+     * creates a record for each user that should have pings blocked.
+     * *unused now*
+     * @param connection
+     * @param ids user ids to have records created for
+     */
     public async initializeUsers(
         connection?: PoolClient | number | number[],
         ids?: number | number[]
@@ -57,13 +59,13 @@ export default class BlockedUsersTable extends Table<
             ids
         ).catch((err) => new InsertError(err));
 
-        if (response instanceof Error) throw response;
+        if (response instanceof DatabaseError) throw response;
 
         return response.rowCount > 0;
     }
 
     /**
-     * Updates the timestamp for the last message send by the user id provided
+     * Inserts or Updates the timestamp for the last message send by the user id provided
      * @param id user id to have record updated
      * @param timestamp the timestamp to be updated to
      */
@@ -88,11 +90,14 @@ export default class BlockedUsersTable extends Table<
 
         const response = await this.query(
             connection as PoolClient | undefined,
-            `UPDATE ${this.full} SET ${this.mappedKeys.lastMessage} = $2 WHERE ${this.mappedKeys.id} = $1;`,
+            `INSERT INTO ${this.full}
+                (${this.mappedKeys.id}, ${this.mappedKeys.lastMessage})
+                VALUES ($1, $2) ON CONFLICT (${this.mappedKeys.id})
+                DO UPDATE SET ${this.mappedKeys.lastMessage} = $2`,
             [id, timestamp as number]
         ).catch((err) => new UpdateError(err));
 
-        if (response instanceof Error) throw response;
+        if (response instanceof DatabaseError) throw response;
 
         return response.rowCount === 1;
     }
@@ -114,13 +119,13 @@ export default class BlockedUsersTable extends Table<
             connection = undefined;
         }
 
-        const response = await this.query<Results.DBBlockedUser>(
+        const response = await this.query<Results.DBMonitoredUser>(
             connection as PoolClient | undefined,
             `SELECT ${this.mappedKeys.lastMessage} FROM ${this.full} WHERE ${this.mappedKeys.id} = $1`,
             [id as number]
         ).catch((err) => new SelectError(err));
 
-        if (response instanceof Error) throw response;
+        if (response instanceof DatabaseError) throw response;
 
         if (response.rows.length === 1) {
             const date = new Date();
@@ -131,38 +136,14 @@ export default class BlockedUsersTable extends Table<
     }
 
     /**
-     * returns an array for the entire record for the selected user id(s)
-     * @param ids users ids to fetch
+     * return all monitored users
      */
-    public async getById(
-        ids: number | number[]
-    ): Promise<Array<Parsed.BlockedUser | null>>;
-
-    public async getById(
-        connection: PoolClient,
-        ids: number | number[]
-    ): Promise<Array<Parsed.BlockedUser | null>>;
-
-    public async getById(
-        connection: PoolClient | number | number[] | undefined,
-        ids?: number | number[]
-    ): Promise<Array<Parsed.BlockedUser | null>> {
-        if (connection instanceof Array || typeof connection === 'number') {
-            ids = connection;
-            connection = undefined;
-        }
-        if (typeof ids === 'undefined')
-            throw new InsertError('No ids entered to initialize.');
-        if (typeof ids === 'number') ids = [ids];
-        const params = ids.map((noop, idx) => `$${idx + 1}`).join(',');
+    public async getAll(connection?: PoolClient): Promise<Array<Parsed.MonitoredUser>> {
+        const response = await this.query(connection, `SELECT * FROM ${this.full}`).catch(
+            (err) => new SelectError(err)
+        );
 
-        const response = await this.query<Results.DBBlockedUser>(
-            connection as PoolClient | undefined,
-            `SELECT * FROM ${this.full} WHERE ${this.mappedKeys.id} IN (${params});`,
-            ids
-        ).catch((err) => new SelectError(err));
-
-        if (response instanceof Error) throw response;
+        if (response instanceof DatabaseError) throw response;
 
         return response.rows.map(this.parse);
     }
@@ -206,13 +187,10 @@ export default class BlockedUsersTable extends Table<
      * @param data
      * @protected
      */
-    protected parse(data?: Results.DBBlockedUser): Parsed.BlockedUser | null {
-        if (data) {
-            return {
-                id: data.user_id,
-                lastMessage: Number.parseInt(`${data.user_last_message}`, 10),
-            };
-        }
-        return null;
+    protected parse(data: Results.DBMonitoredUser): Parsed.MonitoredUser {
+        return {
+            id: data.user_id,
+            lastMessage: Number.parseInt(`${data.user_last_message}`, 10),
+        };
     }
 }
diff --git a/src/database/tables/PunishmentHistory.ts b/src/database/tables/PunishmentHistory.ts
new file mode 100644
index 0000000..cb4549d
--- /dev/null
+++ b/src/database/tables/PunishmentHistory.ts
@@ -0,0 +1,316 @@
+import { PoolClient } from 'pg';
+import Table from '../models/Table';
+import { Parsed, Results, ValidationState } from '../types';
+import DatabaseManager from '../database';
+import { DatabaseError, InsertError, SelectError, UpdateError } from '../errors';
+
+type HistoryObject = {
+    userId: number | string;
+    endsAt: number | boolean;
+    expiresAt?: number;
+    active?: boolean;
+};
+
+export default class PunishmentHistory extends Table<
+    Results.DBPunishmentHistory,
+    Parsed.PunishmentHistory
+> {
+    protected readonly accepted: Array<keyof Parsed.PunishmentHistory>;
+
+    protected readonly nullables: Array<keyof Parsed.PunishmentHistory>;
+
+    protected readonly mappedKeys: {
+        [s in keyof Parsed.PunishmentHistory]: keyof Results.DBPunishmentHistory;
+    };
+
+    constructor(manager: DatabaseManager) {
+        super(manager, 'punishment_history');
+
+        this.nullables = ['expiresAt'];
+        this.accepted = ['userId', 'endsAt', 'active', 'expiresAt'];
+
+        this.mappedKeys = {
+            id: 'history_id',
+            userId: 'history_user_id',
+            active: 'history_active',
+            endsAt: 'history_ends_at',
+            expiresAt: 'history_expires_at',
+            createdAt: 'history_created_at',
+        };
+    }
+
+    public async create(history: HistoryObject): Promise<boolean>;
+
+    public async create(connection: PoolClient, history: HistoryObject): Promise<boolean>;
+
+    /**
+     * Create an actual punishment for a user.
+     * @param connection
+     * @param history
+     */
+    public async create(
+        connection: PoolClient | HistoryObject | undefined,
+        history?: HistoryObject
+    ): Promise<boolean> {
+        if (
+            typeof (connection as HistoryObject).userId === 'number' ||
+            typeof (connection as HistoryObject).userId === 'string'
+        ) {
+            history = connection as HistoryObject;
+            connection = undefined;
+        }
+
+        if (typeof history?.userId !== 'number' && typeof history?.userId !== 'string') {
+            throw new InsertError('history object is not valid');
+        }
+
+        const values = [
+            history.userId,
+            // Math.round(punishment.endsAt / 1000),
+        ];
+        const fields = [
+            this.mappedKeys.userId,
+            // this.mappedKeys.endsAt
+        ];
+
+        if (typeof history.endsAt === 'number') {
+            values.push(Math.round(history.endsAt / 1000));
+            fields.push(this.mappedKeys.endsAt);
+        }
+
+        if (typeof history.expiresAt === 'number') {
+            values.push(Math.round(history.expiresAt / 1000));
+            fields.push(this.mappedKeys.expiresAt);
+        }
+
+        if (typeof history.active === 'boolean') {
+            values.push(history.active ? 1 : 0);
+            fields.push(this.mappedKeys.active);
+        }
+
+        const response = await this.query(
+            connection as PoolClient | undefined,
+            `INSERT INTO ${this.full} (${fields.join(', ')}) VALUES (${values
+                .map((_, idx) => `$${idx + 1}`)
+                .join(', ')});`,
+            values
+        ).catch((err) => new InsertError(err));
+
+        if (response instanceof DatabaseError) throw response;
+
+        return response.rowCount > 0;
+    }
+
+    public async getByUserId(
+        userId: string | number
+    ): Promise<Array<Parsed.PunishmentHistory>>;
+
+    public async getByUserId(
+        userId: string | number,
+        includeEnded: boolean
+    ): Promise<Array<Parsed.PunishmentHistory>>;
+
+    public async getByUserId(
+        userId: string | number,
+        includeEnded: boolean,
+        includeExpired: boolean
+    ): Promise<Array<Parsed.PunishmentHistory>>;
+
+    public async getByUserId(
+        connection: PoolClient,
+        userId: string | number
+    ): Promise<Array<Parsed.PunishmentHistory>>;
+
+    public async getByUserId(
+        connection: PoolClient,
+        userId: string | number,
+        includeEnded: boolean
+    ): Promise<Array<Parsed.PunishmentHistory>>;
+
+    public async getByUserId(
+        connection: PoolClient,
+        userId: string | number,
+        includeEnded: boolean,
+        includeExpired: boolean
+    ): Promise<Array<Parsed.PunishmentHistory>>;
+
+    /**
+     * Get a specific users punishment history
+     * @param connection [PoolClient | string | number | boolean | undefined]
+     * @param userId [string | number | boolean]
+     * @param includeEnded [boolean]
+     * @param includeExpired [boolean]
+     */
+    public async getByUserId(
+        connection: PoolClient | string | number | undefined,
+        userId?: string | number | boolean,
+        includeEnded = false,
+        includeExpired = false
+    ): Promise<Array<Parsed.PunishmentHistory>> {
+        if (typeof connection === 'string' || typeof connection === 'number') {
+            includeExpired = includeEnded || false;
+            includeEnded = (userId as boolean) || false;
+            userId = connection;
+            connection = undefined;
+        }
+
+        if (typeof userId !== 'number' && typeof userId !== 'string')
+            throw new SelectError('user id is not a number');
+
+        let filter = '';
+        if (!includeEnded) {
+            filter = `AND (${this.mappedKeys.endsAt} >= EXTRACT(EPOCH FROM NOW()) OR ${this.mappedKeys.endsAt} IS NULL) `;
+        }
+
+        if (!includeExpired) {
+            filter += `AND (${this.mappedKeys.expiresAt} >= EXTRACT(EPOCH FROM NOW()) OR ${this.mappedKeys.expiresAt} IS NULL) `;
+        }
+
+        const response = await this.query<Results.DBPunishmentHistory>(
+            connection as PoolClient | undefined,
+            `SELECT * FROM ${this.full} WHERE ${this.mappedKeys.userId} = $1 ${filter};`,
+            [userId]
+        ).catch((err) => new SelectError(err));
+
+        if (response instanceof DatabaseError) throw response;
+
+        return response.rows.map(this.parse);
+    }
+
+    public async getAllLatest(): Promise<Array<Parsed.PunishmentHistoryWithCount | null>>;
+
+    public async getAllLatest(
+        connection: PoolClient
+    ): Promise<Array<Parsed.PunishmentHistoryWithCount | null>>;
+
+    /**
+     * returns the latest active punishment for each user who has been punished by the bot.
+     * @param connection
+     */
+    public async getAllLatest(
+        connection?: PoolClient
+    ): Promise<Array<Parsed.PunishmentHistoryWithCount | null>> {
+        const response = await this.query<Results.DBPunishmentHistoryWithCount>(
+            connection,
+            `SELECT DISTINCT ON(${this.mappedKeys.userId}) *, (
+                SELECT count(*) as count FROM ${this.full} b
+                    WHERE b.${this.mappedKeys.userId} = a.${this.mappedKeys.userId}
+                    -- AND (b.${this.mappedKeys.endsAt} >= EXTRACT(EPOCH FROM NOW()) OR b.${this.mappedKeys.endsAt} IS NULL)
+                    AND (b.${this.mappedKeys.expiresAt} >= EXTRACT(EPOCH FROM NOW()) OR b.${this.mappedKeys.expiresAt} IS NULL)
+                ) FROM ${this.full} a WHERE 
+                (a.${this.mappedKeys.expiresAt} >= EXTRACT(EPOCH FROM NOW()) OR a.${this.mappedKeys.expiresAt} IS NULL)
+                -- AND (a.${this.mappedKeys.endsAt} >= EXTRACT(EPOCH FROM NOW()) OR a.${this.mappedKeys.endsAt} IS NULL)
+                AND a.${this.mappedKeys.active} = 1
+                ORDER BY ${this.mappedKeys.userId}, ${this.mappedKeys.id} DESC;`
+        ).catch((err) => new SelectError(err));
+
+        if (response instanceof DatabaseError) throw response;
+
+        return response.rows.map((item) => {
+            const parsed = this.parse(item);
+            if (parsed) {
+                return {
+                    ...parsed,
+                    count: Number.parseInt(item.count, 10),
+                };
+            }
+            return null;
+        });
+    }
+
+    public async setActive(id: string | number, active: boolean): Promise<boolean>;
+
+    public async setActive(
+        connection: PoolClient,
+        id: string | number,
+        active: boolean
+    ): Promise<boolean>;
+
+    /**
+     * sets the selected punishment's active state to the state you provide.
+     * @param connection [PoolClient | string | number | undefined]
+     * @param id [string | number | boolean]
+     * @param active [boolean | undefined]
+     */
+    public async setActive(
+        connection: PoolClient | string | number | undefined,
+        id: string | number | boolean,
+        active?: boolean
+    ): Promise<boolean> {
+        if (typeof connection === 'string' || typeof connection === 'number') {
+            active = id as boolean;
+            id = connection;
+            connection = undefined;
+        }
+
+        const response = await this.query(
+            connection as PoolClient | undefined,
+            `UPDATE ${this.full} SET ${this.mappedKeys.active} = $2 WHERE ${this.mappedKeys.id} = $1`,
+            [id, active ? 1 : 0]
+        ).catch((err) => new UpdateError(err));
+
+        if (response instanceof DatabaseError) throw response;
+
+        return response.rowCount > 0;
+    }
+
+    /**
+     * Create table if it does not exist
+     */
+    protected async init(connection?: PoolClient): Promise<ValidationState> {
+        try {
+            if (typeof connection === 'undefined') connection = await this.acquire();
+
+            await this.query(
+                connection,
+                `CREATE TABLE ${this.full}
+                 (
+                     ${this.mappedKeys.id} serial NOT NULL,
+                     ${this.mappedKeys.userId} BIGINT NOT NULL,
+                     ${this.mappedKeys.active} INT DEFAULT 1,
+                     ${this.mappedKeys.endsAt} INT,
+                     ${this.mappedKeys.expiresAt} INT,
+                     ${this.mappedKeys.createdAt} INT DEFAULT EXTRACT(EPOCH FROM NOW())
+                 );`
+            );
+
+            await this.query(
+                connection,
+                `CREATE INDEX ${this.name}_user_id_index
+                    ON ${this.full} (${this.mappedKeys.userId});`
+            );
+
+            await this.query(
+                connection,
+                `CREATE INDEX ${this.name}_ends_at_index
+                    ON ${this.full} (${this.mappedKeys.endsAt});`
+            );
+
+            await this.query(
+                connection,
+                `ALTER TABLE ${this.full} ADD CONSTRAINT ${this.name}_pk PRIMARY KEY (${this.mappedKeys.id});`
+            );
+
+            return ValidationState.VALIDATED;
+        } catch (e) {
+            this.getLogger().error(e);
+            return ValidationState.INVALID;
+        }
+    }
+
+    /**
+     * parse the raw database data into usable objects
+     */
+    protected parse(data: Results.DBPunishmentHistory): Parsed.PunishmentHistory {
+        return {
+            id: data.history_id,
+            active: data.history_active === 1,
+            userId: data.history_user_id,
+            endsAt: data.history_ends_at ? new Date(data.history_ends_at * 1000) : null,
+            expiresAt: data.history_expires_at
+                ? new Date(data.history_expires_at * 1000)
+                : null,
+            createdAt: new Date(data.history_created_at * 1000),
+        };
+    }
+}
diff --git a/src/database/tables/Punishments.ts b/src/database/tables/Punishments.ts
new file mode 100644
index 0000000..471e91c
--- /dev/null
+++ b/src/database/tables/Punishments.ts
@@ -0,0 +1,250 @@
+import { PoolClient } from 'pg';
+import Table from '../models/Table';
+import { Parsed, Results, Tables, ValidationState } from '../types';
+import DatabaseManager from '../database';
+import { DatabaseError, DeleteError, InsertError, SelectError } from '../errors';
+
+type CreateObject = Tables.Punishments.CreateObject;
+type RemoveObject = Tables.Punishments.RemoveObject;
+
+export default class Punishments extends Table<Results.DBPunishment, Parsed.Punishment> {
+    protected readonly accepted: Array<keyof Parsed.Punishment>;
+
+    protected readonly nullables: Array<keyof Parsed.Punishment>;
+
+    protected readonly mappedKeys: {
+        [s in keyof Parsed.Punishment]: keyof Results.DBPunishment;
+    };
+
+    public constructor(manager: DatabaseManager) {
+        super(manager, 'punishments');
+
+        this.nullables = ['targetKey', 'length'];
+        this.accepted = [
+            'active',
+            'type',
+            'lenient',
+            'length',
+            'target',
+            'targetKey',
+            'index',
+        ];
+
+        this.mappedKeys = {
+            id: 'punishment_id',
+            active: 'punishment_active',
+            index: 'punishment_index',
+            type: 'punishment_type',
+            lenient: 'punishment_lenient',
+            length: 'punishment_length',
+            target: 'punishment_target',
+            targetKey: 'punishment_target_key',
+        };
+    }
+
+    public async create(punishment: CreateObject): Promise<boolean>;
+
+    public async create(
+        connection: PoolClient | undefined,
+        punishment: CreateObject
+    ): Promise<boolean>;
+
+    /**
+     * Used to create a punishment record in the database. This record contains...
+     * > the priority index
+     * > type of punishment
+     * > target ID (role or user ID)
+     * > target key (role or user)
+     * > is punishment lenient
+     * > length in seconds to punish
+     * @param connection [PoolClient | CreateObject | undefined]
+     * @param punishment [CreateObject]
+     */
+    public async create(
+        connection: PoolClient | CreateObject | undefined,
+        punishment?: CreateObject
+    ): Promise<boolean> {
+        if (typeof (connection as CreateObject)?.type === 'string') {
+            punishment = connection as CreateObject;
+            connection = undefined;
+        }
+
+        if (typeof punishment === 'undefined') {
+            throw new InsertError('No punishment object provided');
+        }
+
+        if (['ban', 'kick', 'mute'].indexOf(punishment.type) === -1) {
+            throw new InsertError(
+                `An invalid punishment type was provided: ${punishment.type}`
+            );
+        }
+
+        if (
+            ['user', 'role'].indexOf(punishment.target) === -1 &&
+            typeof punishment.targetKey !== 'string'
+        ) {
+            throw new InsertError(`${punishment.target} requires a targetKey`);
+        }
+
+        const values = [
+            1, // active flag
+            punishment.index,
+            punishment.type,
+            punishment.target,
+            punishment.targetKey,
+            punishment.lenient ? 1 : 0,
+            typeof punishment.length === 'number' ? punishment.length : null,
+        ] as never[];
+
+        const fields = [
+            this.mappedKeys.active,
+            this.mappedKeys.index,
+            this.mappedKeys.type,
+            this.mappedKeys.target,
+            this.mappedKeys.targetKey,
+            this.mappedKeys.lenient,
+            this.mappedKeys.length,
+        ];
+
+        const response = await this.query(
+            connection as PoolClient | undefined,
+            `INSERT INTO ${this.full} (${fields.join(', ')}) VALUES (${values
+                .map((_, idx) => `$${idx + 1}`)
+                .join(', ')});`,
+            values
+        ).catch((err) => new InsertError(err));
+
+        if (response instanceof DatabaseError) throw response;
+
+        return response.rowCount > 0;
+    }
+
+    /**
+     * Returns all active punishments
+     * @param connection [PoolClient | undefined]
+     * @returns Promise<Parsed.Punishment[]>
+     */
+    public async getAllActive(connection?: PoolClient): Promise<Parsed.Punishment[]> {
+        const response = await this.query<Results.DBPunishment>(
+            connection,
+            `SELECT * FROM ${this.full} WHERE ${this.mappedKeys.active} = 1
+                ORDER BY ${this.mappedKeys.index}, ${this.mappedKeys.target}, ${this.mappedKeys.targetKey}, ${this.mappedKeys.lenient};`
+        ).catch((err) => new SelectError(err));
+
+        if (response instanceof DatabaseError) throw response;
+
+        return response.rows.map(this.parse);
+    }
+
+    public async remove(punishmment: RemoveObject): Promise<boolean>;
+
+    public async remove(
+        connection: PoolClient | undefined,
+        punishment: RemoveObject
+    ): Promise<boolean>;
+
+    /**
+     * Used to remove a punishment record from the database.
+     * Requires the following properties...
+     * [index, target, targetKey, lenient]
+     * @param connection [PoolClient | RemoveObject | undefined]
+     * @param punishment [RemoveObject]
+     */
+    public async remove(
+        connection: PoolClient | RemoveObject | undefined,
+        punishment?: RemoveObject
+    ): Promise<boolean> {
+        if (typeof (connection as RemoveObject)?.target === 'string') {
+            punishment = connection as RemoveObject;
+            connection = undefined;
+        }
+
+        if (typeof punishment === 'undefined') {
+            throw new InsertError('No punishment object provided');
+        }
+
+        if (
+            ['user', 'role'].indexOf(punishment.target) === -1 &&
+            typeof punishment.targetKey !== 'string'
+        ) {
+            throw new InsertError(`${punishment.target} requires a targetKey`);
+        }
+
+        const fields = [
+            punishment.index,
+            punishment.target,
+            punishment.targetKey,
+            punishment.lenient ? 1 : 0,
+        ];
+
+        const response = await this.query(
+            connection as PoolClient | undefined,
+            `DELETE FROM ${this.full} WHERE
+                ${this.mappedKeys.index} = $1
+                AND ${this.mappedKeys.target} = $2
+                AND ${this.mappedKeys.targetKey} = $3
+                AND ${this.mappedKeys.lenient} = $4;`,
+            fields
+        ).catch((err) => new DeleteError(err));
+
+        if (response instanceof DatabaseError) throw response;
+
+        return response.rowCount > 0;
+    }
+
+    /**
+     * create table if doesn't exist
+     */
+    protected async init(connection?: PoolClient): Promise<ValidationState> {
+        try {
+            await this.query(
+                connection,
+                `CREATE TABLE ${this.full}
+                 (
+                     ${this.mappedKeys.id} serial NOT NULL,
+                     ${this.mappedKeys.index} INT NOT NULL,
+                     ${this.mappedKeys.active} INT DEFAULT 1,
+                     ${this.mappedKeys.type} VARCHAR(16) NOT NULL,
+                     ${this.mappedKeys.target} VARCHAR(16) NOT NULL,
+                     ${this.mappedKeys.targetKey} BIGINT,
+                     ${this.mappedKeys.length} INT,
+                     ${this.mappedKeys.lenient} INT DEFAULT 1
+                 );`
+            );
+            if (typeof connection === 'undefined') connection = await this.acquire();
+
+            await this.query(
+                connection,
+                `ALTER TABLE ${this.full} ADD CONSTRAINT ${this.name}_pk
+                    PRIMARY KEY (${this.mappedKeys.id}, ${this.mappedKeys.index});`
+            );
+
+            await this.query(
+                connection,
+                `CREATE UNIQUE INDEX ${this.name}_unique_idx ON ${this.full}
+                    (${this.mappedKeys.index}, ${this.mappedKeys.target}, ${this.mappedKeys.targetKey}, ${this.mappedKeys.lenient})`
+            );
+
+            return ValidationState.VALIDATED;
+        } catch (e) {
+            this.getLogger().error(e);
+            return ValidationState.INVALID;
+        }
+    }
+
+    /**
+     * parse the raw database data into usable objects
+     */
+    protected parse(data: Results.DBPunishment): Parsed.Punishment {
+        return {
+            id: data.punishment_id,
+            active: data.punishment_active === 1,
+            index: data.punishment_index,
+            type: data.punishment_type,
+            lenient: data.punishment_lenient === 1,
+            length: data.punishment_length,
+            target: data.punishment_target,
+            targetKey: data.punishment_target_key as never,
+        };
+    }
+}
diff --git a/src/database/tests/blockedUsers.test.ts b/src/database/tests/monitoredUsers.test.ts
similarity index 78%
rename from src/database/tests/blockedUsers.test.ts
rename to src/database/tests/monitoredUsers.test.ts
index ca2f12b..247f8e9 100644
--- a/src/database/tests/blockedUsers.test.ts
+++ b/src/database/tests/monitoredUsers.test.ts
@@ -21,24 +21,24 @@ describe('Start standard blocked users tests', async function () {
     });
 
     it('should initialize one blocking user', async function () {
-        const response = await db.blockedUsers.initializeUsers(1111);
+        const response = await db.monitoredUsers.initializeUsers(1111);
         assert.isTrue(response);
     });
 
     it('should initialize two blocking users', async function () {
-        const response = await db.blockedUsers.initializeUsers([2222, 3333]);
+        const response = await db.monitoredUsers.initializeUsers([2222, 3333]);
         assert.isTrue(response);
     });
 
     it('should initialize 100 blocking users', async function () {
         const users = [];
         for (let i = 100; i < 200; i++) users.push(i);
-        const response = await db.blockedUsers.initializeUsers(users);
+        const response = await db.monitoredUsers.initializeUsers(users);
         assert.isTrue(response);
     });
 
     it('should set last ping for id 1111', async function () {
-        const response = await db.blockedUsers.updateLastMessage(
+        const response = await db.monitoredUsers.updateLastMessage(
             1111,
             new Date().getTime()
         );
@@ -46,12 +46,12 @@ describe('Start standard blocked users tests', async function () {
     });
 
     it('should get an absent last ping', async function () {
-        const response = await db.blockedUsers.getLastMessage(2222);
+        const response = await db.monitoredUsers.getLastMessage(2222);
         assert.equal(response.getFullYear(), 1969);
     });
 
     it('should get last ping of id 1111', async function () {
-        const response = await db.blockedUsers.getLastMessage(1111);
+        const response = await db.monitoredUsers.getLastMessage(1111);
         assert.equal(response.getFullYear(), new Date().getFullYear());
     });
 });
diff --git a/src/database/tests/punishmentHistory.test.ts b/src/database/tests/punishmentHistory.test.ts
new file mode 100644
index 0000000..1b1ebfd
--- /dev/null
+++ b/src/database/tests/punishmentHistory.test.ts
@@ -0,0 +1,79 @@
+/* eslint-disable func-names, import/no-extraneous-dependencies */
+import { describe, it, after } from 'mocha';
+import { assert } from 'chai';
+import { CONFIG } from '../../globals';
+import DatabaseManager from '../database';
+
+describe('Start punishment history tests', async function () {
+    this.timeout(10000);
+    let db: DatabaseManager;
+
+    before(function () {
+        db = new DatabaseManager({
+            host: CONFIG.database.host,
+            port: CONFIG.database.port,
+            user: CONFIG.database.user,
+            database: CONFIG.database.database,
+            schema: `${CONFIG.database.schema}_test`,
+            password: CONFIG.database.pass,
+            max: CONFIG.database.connections,
+        });
+    });
+
+    it('should create a history item with no expiration', async () => {
+        const ending = 1000 * 60 * 10; // 10 minutes
+        const created = await db.punishmentHistory.create({
+            userId: 1,
+            endsAt: new Date(Date.now() + ending).getTime(),
+        });
+
+        assert.isTrue(created);
+    });
+
+    it('should create a history item with an expiration', async () => {
+        const ending = 1000 * 60 * 60; // 1 hour
+        const created = await db.punishmentHistory.create({
+            userId: 1,
+            endsAt: new Date(Date.now() + ending).getTime(),
+            expiresAt: new Date(Date.now() + ending * 2).getTime(),
+        });
+
+        assert.isTrue(created);
+    });
+
+    it('should created ended history item for user 1', async () => {
+        const ending = 1000 * 60 * 10; // 10 minutes
+        const created = await db.punishmentHistory.create({
+            userId: 1,
+            endsAt: new Date(Date.now() - ending).getTime(),
+        });
+
+        assert.isTrue(created);
+    });
+
+    it('should created expired history item for user 1', async () => {
+        const ending = 1000 * 60 * 10; // 10 minutes
+        const created = await db.punishmentHistory.create({
+            userId: 1,
+            endsAt: new Date(Date.now() - ending).getTime(),
+            expiresAt: new Date(Date.now() - ending).getTime(),
+        });
+
+        assert.isTrue(created);
+    });
+
+    it('should get only active history items for user 1', async () => {
+        const punishments = await db.punishmentHistory.getByUserId(1);
+        assert.lengthOf(punishments, 2);
+    });
+
+    it('should get all not expired history items for user 1', async () => {
+        const punishments = await db.punishmentHistory.getByUserId(1, true);
+        assert.lengthOf(punishments, 3);
+    });
+
+    it('should get all history items for user 1', async () => {
+        const punishments = await db.punishmentHistory.getByUserId(1, true, true);
+        assert.lengthOf(punishments, 4);
+    });
+});
diff --git a/src/database/tests/punishments.test.ts b/src/database/tests/punishments.test.ts
new file mode 100644
index 0000000..63e87e2
--- /dev/null
+++ b/src/database/tests/punishments.test.ts
@@ -0,0 +1,71 @@
+/* eslint-disable func-names, import/no-extraneous-dependencies */
+import { describe, it, after } from 'mocha';
+import { assert } from 'chai';
+import { CONFIG } from '../../globals';
+import DatabaseManager from '../database';
+
+describe('Start punishments tests', async function () {
+    this.timeout(10000);
+    let db: DatabaseManager;
+
+    before(function () {
+        db = new DatabaseManager({
+            host: CONFIG.database.host,
+            port: CONFIG.database.port,
+            user: CONFIG.database.user,
+            database: CONFIG.database.database,
+            schema: `${CONFIG.database.schema}_test`,
+            password: CONFIG.database.pass,
+            max: CONFIG.database.connections,
+        });
+    });
+
+    it('should create a punishment', async () => {
+        let created = await db.punishments.create({
+            index: 0,
+            type: 'ban',
+            target: 'user',
+            targetKey: '1234',
+            lenient: false,
+        });
+
+        assert.isTrue(created);
+
+        created = await db.punishments.create({
+            index: 2,
+            type: 'ban',
+            target: 'user',
+            targetKey: '1234',
+            lenient: false,
+        });
+
+        assert.isTrue(created);
+    });
+
+    it('should fetch all active punishments', async () => {
+        const punishments = await db.punishments.getAllActive();
+
+        assert.isTrue(punishments.length > 0);
+    });
+
+    it('should create and then delete a punishment', async () => {
+        const created = await db.punishments.create({
+            index: 999,
+            type: 'ban',
+            target: 'user',
+            targetKey: '123',
+            lenient: false,
+        });
+
+        assert.isTrue(created);
+
+        const removed = await db.punishments.remove({
+            index: 999,
+            target: 'user',
+            targetKey: '123',
+            lenient: false,
+        });
+
+        assert.isTrue(removed);
+    });
+});
diff --git a/src/database/tests/runner.test.ts b/src/database/tests/runner.test.ts
index 7eddcb7..57b3c66 100644
--- a/src/database/tests/runner.test.ts
+++ b/src/database/tests/runner.test.ts
@@ -1,2 +1,4 @@
 import './database.test';
-import './blockedUsers.test';
+import './monitoredUsers.test';
+import './punishmentHistory.test';
+import './punishments.test';
diff --git a/src/database/types.ts b/src/database/types.ts
index 926a900..b40b8cf 100644
--- a/src/database/types.ts
+++ b/src/database/types.ts
@@ -1,3 +1,5 @@
+import PunishmentHistory from './tables/PunishmentHistory';
+
 export enum ValidationState {
     NOT_PROCESSED,
     INVALID,
@@ -6,24 +8,110 @@ export enum ValidationState {
     HAS_ADDITIONAL_INIT,
 }
 
+export type Nullable<T> = null | T;
+
+export type PunishmentType = 'ban' | 'mute' | 'kick';
+
+export type TargetType = 'role' | 'user';
+
+type StandardPunishment = {
+    target: 'standard';
+    targetKey: null;
+};
+
+type TargetedPunishment = {
+    target: 'role' | 'user';
+    targetKey: string;
+};
+
+type DefaultPunishmentProps = {
+    id: number;
+    index: number;
+    active: boolean;
+    lenient: boolean;
+    length: number | null;
+    type: PunishmentType;
+    target: TargetType;
+    targetKey: Nullable<string>;
+};
+
 export namespace Results {
-    export type DBBlockedUser = {
+    export type DBMonitoredUser = {
         user_id: number;
         user_last_message: number;
     };
+
+    export type DBPunishmentHistory = {
+        history_id: number;
+        history_user_id: string;
+        history_active: number;
+        history_ends_at: number;
+        history_expires_at: number | null;
+        history_created_at: number;
+    };
+
+    export type DBPunishmentHistoryWithCount = DBPunishmentHistory & {
+        count: string;
+    };
+
+    export type DBPunishment = {
+        punishment_id: number;
+        punishment_index: number;
+        punishment_active: number;
+        punishment_lenient: number;
+        punishment_type: PunishmentType;
+        punishment_target: TargetType;
+        punishment_target_key: Nullable<string>;
+        punishment_length: Nullable<number>;
+    };
 }
 
 export namespace Parsed {
-    export type BlockedUser = {
+    export type MonitoredUser = {
         id: number;
         lastMessage: number;
     };
+
+    export type PunishmentHistory = {
+        id: number;
+        userId: string;
+        active: boolean;
+        endsAt: Date | null;
+        expiresAt: Date | null;
+        createdAt: Date;
+    };
+
+    export type PunishmentHistoryWithCount = PunishmentHistory & {
+        count: number;
+    };
+
+    export type Punishment = DefaultPunishmentProps &
+        (StandardPunishment | TargetedPunishment);
 }
 
 export type ValueObject = Array<string | number | boolean>;
 
-export type DBTable = Results.DBBlockedUser;
+export type DBTable =
+    | Results.DBMonitoredUser
+    | Results.DBPunishmentHistory
+    | Results.DBPunishment;
 // | Results.NextTable
 
-export type DBParsed = Parsed.BlockedUser;
+export type DBParsed =
+    | Parsed.MonitoredUser
+    | Parsed.PunishmentHistory
+    | Parsed.Punishment;
 // | Parsed.NextTable
+
+export namespace Tables {
+    export namespace Punishments {
+        export type CreateObject = Omit<Parsed.Punishment, 'id' | 'active' | 'length'> & {
+            length?: number;
+        };
+
+        export type RemoveObject = Omit<
+            Parsed.Punishment,
+            'id' | 'active' | 'length' | 'type'
+        >;
+    }
+}
diff --git a/src/listeners/commandError.ts b/src/listeners/commandError.ts
new file mode 100644
index 0000000..e01cf42
--- /dev/null
+++ b/src/listeners/commandError.ts
@@ -0,0 +1,15 @@
+import { CommandRunPayload, Listener } from '@sapphire/framework';
+import LogUtil from '../utils/LogUtil';
+
+class CommandErrorEvent extends Listener<'commandError'> {
+    public async run(err: Error, payload: CommandRunPayload): Promise<void> {
+        const log = this.container.logger;
+        const message = `${payload.message.author.tag} executed "${payload.command?.name}"
+${await LogUtil.breakDownMsg(payload)}
+${LogUtil.breakDownErr(err)}`;
+
+        log.error(message);
+    }
+}
+
+export default CommandErrorEvent;
diff --git a/src/listeners/commandRun.ts b/src/listeners/commandRun.ts
new file mode 100644
index 0000000..f674942
--- /dev/null
+++ b/src/listeners/commandRun.ts
@@ -0,0 +1,20 @@
+import { Command, CommandRunPayload, Listener } from '@sapphire/framework';
+import { Message } from 'discord.js';
+import LogUtil from '../utils/LogUtil';
+
+class CommandRunEvent extends Listener<'commandRun'> {
+    public async run(
+        msg: Message,
+        command: Command,
+        payload: CommandRunPayload
+    ): Promise<void> {
+        const log = this.container.logger;
+        const message = `${
+            msg.author.tag
+        } executed this command\n${await LogUtil.breakDownMsg(payload)}`;
+
+        log.debug(message);
+    }
+}
+
+export default CommandRunEvent;
diff --git a/src/listeners/listenerError.ts b/src/listeners/listenerError.ts
new file mode 100644
index 0000000..9b0cf41
--- /dev/null
+++ b/src/listeners/listenerError.ts
@@ -0,0 +1,16 @@
+import { Listener, ListenerErrorPayload } from '@sapphire/framework';
+
+class ListenerErrorEvent extends Listener<'listenerError'> {
+    public async run(err: Error, payload: ListenerErrorPayload): Promise<void> {
+        const log = this.container.logger;
+        const message = `${payload.piece.event} executed
+Name: ${payload.piece.name}
+Path: ${payload.piece.path}
+Error: ${err.name}, ${err.message}
+Stack: ${err.stack}`;
+
+        log.error(message);
+    }
+}
+
+export default ListenerErrorEvent;
diff --git a/src/listeners/messageCreate.ts b/src/listeners/messageCreate.ts
new file mode 100644
index 0000000..db3b2d7
--- /dev/null
+++ b/src/listeners/messageCreate.ts
@@ -0,0 +1,18 @@
+import { Listener } from '@sapphire/framework';
+import { Message } from 'discord.js';
+import Bot from '../Bot';
+
+class MessageCreateEvent extends Listener<'messageCreate'> {
+    public async run(message: Message): Promise<void> {
+        const bot = this.container.client as Bot;
+
+        const pingableController = bot.getPingableUserController();
+        const pingController = bot.getPingController();
+
+        if (await pingableController.handleMessage(message)) return;
+
+        await pingController.handleMessage(message);
+    }
+}
+
+export default MessageCreateEvent;
diff --git a/src/listeners/ready.ts b/src/listeners/ready.ts
new file mode 100644
index 0000000..25dcacc
--- /dev/null
+++ b/src/listeners/ready.ts
@@ -0,0 +1,9 @@
+import { Listener } from '@sapphire/framework';
+
+class ReadyEvent extends Listener<'ready'> {
+    public async run(): Promise<void> {
+        this.container.logger.debug('Bot is ready.');
+    }
+}
+
+export default ReadyEvent;
diff --git a/src/utils/LogUtil.ts b/src/utils/LogUtil.ts
index 444d38a..3c3cd1d 100644
--- a/src/utils/LogUtil.ts
+++ b/src/utils/LogUtil.ts
@@ -1,18 +1,15 @@
-import { Command, CommandoMessage } from 'discord.js-commando';
-import Bot from '../Bot';
-import getLogger from './logger';
+import { CommandRunPayload } from '@sapphire/framework';
 
 class LogUtil {
     /**
      * This breaks down the details of a command that was executed
-     * @param {CommandoMessage} msg The message that executed the command
+     * @param {CommandRunPayload} cmd The message that executed the command
      * @returns {string}
      */
-    public static breakDownMsg(msg: CommandoMessage): string {
-        return ` * Time: ${msg.createdAt}
- * Full: ${msg.command?.name} ${msg.parseArgs()}
- * Args: ${msg.parseArgs()}
- * Guild: ${msg.guild ? msg.guild.name : 'No Guild'}`;
+    public static async breakDownMsg(cmd: CommandRunPayload): Promise<string> {
+        return ` * Time: ${cmd.message.createdAt}
+ * Full: ${cmd.message.content}
+ * Guild: ${cmd.message.guild ? cmd.message.guild.name : 'No Guild'}`;
     }
 
     /**
@@ -23,33 +20,6 @@ class LogUtil {
     public static breakDownErr(err: Error): string {
         return ` * Error: ${err.message}\n * Stack: ${err.stack}`;
     }
-
-    /**
-     * Log a warning from a command
-     * @param {CommandoMessage} msg
-     * @param {string} context Added context
-     */
-    public static cmdWarn(msg: CommandoMessage, context: string): void {
-        const log = LogUtil.getCmdLogger(msg.command as Command);
-        const message = `${msg.author.tag} executed "${msg.command?.name}"
-    ${LogUtil.breakDownMsg(msg)}
-     * Context: ${context}`;
-        log.warn(message);
-    }
-
-    public static cmdError(msg: CommandoMessage, err: Error, context: string): void {
-        const log = LogUtil.getCmdLogger(msg.command as Command);
-        const message = `${msg.author.tag} executed "${msg.command?.name}"
-    ${LogUtil.breakDownMsg(msg)}
-     * Context: ${context}
-     ${LogUtil.breakDownErr(err)}`;
-        log.error(message);
-    }
-
-    private static getCmdLogger(c: Command) {
-        return getLogger(`command::${c.name}`);
-    }
 }
 
 export default LogUtil;
-
diff --git a/src/utils/index.ts b/src/utils/index.ts
new file mode 100644
index 0000000..c55f332
--- /dev/null
+++ b/src/utils/index.ts
@@ -0,0 +1,52 @@
+import { GuildMember } from 'discord.js';
+import { CONFIG } from '../globals';
+import { TargetType } from '../database/types';
+
+export function minutesToReadable(minutes?: number | null): string {
+    if (typeof minutes !== 'number') {
+        return '0 minutes';
+    }
+    let hours = 0;
+    let days = 0;
+    if (minutes >= 60) {
+        hours = minutes / 60;
+        minutes %= 60;
+    }
+    if (hours >= 24) {
+        days = hours / 24;
+        hours %= 24;
+    }
+    let str = '';
+    if (minutes > 0) {
+        str = `${Math.floor(minutes)} minutes`;
+    }
+    if (hours > 0) {
+        str = `${Math.floor(hours)} hours, ${str}`;
+    }
+    if (days > 0) {
+        str = `${Math.floor(days)} days, ${str}`;
+    }
+    return str;
+}
+
+export function parsedUserOrRole(target?: TargetType, key?: string): string {
+    if (!(target && key)) return 'N/A';
+    return `<@${target === 'role' ? '&' : ''}${key}>`;
+}
+
+export function sentByAuthorizedUser(author?: GuildMember | null): boolean {
+    return (
+        CONFIG.bot.moderatorRoles.findIndex(
+            (role) => author?.roles.resolve(role) !== null
+        ) >= 0
+    );
+}
+
+export function getRoleOrUser(args: {
+    target?: string;
+    targetKey?: string;
+}): string | undefined {
+    if (args.target === 'role') return `<@&${args.targetKey}>`;
+    if (args.target === 'user') return `<@${args.targetKey}>`;
+    return args.targetKey;
+}
diff --git a/src/utils/logger.ts b/src/utils/logger.ts
index 856222e..906bcca 100644
--- a/src/utils/logger.ts
+++ b/src/utils/logger.ts
@@ -1,33 +1,41 @@
 import winston, { format } from 'winston';
+// import { Logger, LoggerLevel } from '@sapphire/plugin-logger';
+// import {LogLevel} from "@sapphire/framework";
+import { Logger, LogLevel } from '@sapphire/framework';
 
 const { label, timestamp, combine, prettyPrint } = format;
 type Meta = {
     [s: string]: string | boolean | number | Meta | undefined;
 };
 
-/**
- * get a logger instance with {name} and optional {meta} data
- * @param name
- * @param meta
- */
-function getLogger(name: string, meta?: Meta): winston.Logger {
-    if (winston.loggers.has(name)) {
-        return winston.loggers.get(name);
+export class BotLogger extends Logger {
+    private static instance: BotLogger | null = null;
+
+    private readonly title?: string;
+
+    public constructor(level?: LogLevel, title?: string) {
+        super(level || LogLevel.Debug);
+        // super({
+        //     level: level || LogLevel.Trace,
+        // });
+        this.title = title;
+    }
+
+    public write(level: LogLevel, ...values: unknown[]): void {
+        if (this.title) {
+            values.unshift(this.title);
+        }
+        super.write(level, ...values);
     }
-    return winston.loggers.add(name, {
-        transports: [
-            new winston.transports.Console({
-                handleExceptions: true,
-                debugStdout: true,
-                format: combine(
-                    timestamp(),
-                    label({ label: name }),
-                    prettyPrint({ colorize: true, depth: 5 })
-                ),
-            }),
-        ],
-        defaultMeta: meta,
-    });
-}
 
-export default getLogger;
+    public getTitledInstance(title?: string): BotLogger {
+        return new BotLogger(this.level, title);
+    }
+
+    public static getInstance(level?: LogLevel): BotLogger {
+        if (BotLogger.instance && level) {
+            BotLogger.instance.level = level;
+        }
+        return BotLogger.instance || new BotLogger(level);
+    }
+}
diff --git a/yarn.lock b/yarn.lock
index 9350e5f..ff35bea 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -23,6 +23,18 @@
     chalk "^2.0.0"
     js-tokens "^4.0.0"
 
+"@cspotcode/source-map-consumer@0.8.0":
+  version "0.8.0"
+  resolved "https://registry.yarnpkg.com/@cspotcode/source-map-consumer/-/source-map-consumer-0.8.0.tgz#33bf4b7b39c178821606f669bbc447a6a629786b"
+  integrity sha512-41qniHzTU8yAGbCp04ohlmSrZf8bkf/iJsl3V0dRGsQN/5GFfx+LbCSsCpp2gqrqjTVg/K6O8ycoV35JIwAzAg==
+
+"@cspotcode/source-map-support@0.6.1":
+  version "0.6.1"
+  resolved "https://registry.yarnpkg.com/@cspotcode/source-map-support/-/source-map-support-0.6.1.tgz#118511f316e2e87ee4294761868e254d3da47960"
+  integrity sha512-DX3Z+T5dt1ockmPdobJS/FAsQPW4V4SrWEhD2iYQT2Cb2tQsiMnYxrcUH9By/Z3B+v0S5LMBkQtV/XOBbpLEOg==
+  dependencies:
+    "@cspotcode/source-map-consumer" "0.8.0"
+
 "@dabh/diagnostics@^2.0.2":
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/@dabh/diagnostics/-/diagnostics-2.0.2.tgz#290d08f7b381b8f94607dc8f471a12c675f9db31"
@@ -32,10 +44,21 @@
     enabled "2.0.x"
     kuler "^2.0.0"
 
-"@discordjs/collection@^0.1.6":
-  version "0.1.6"
-  resolved "https://registry.yarnpkg.com/@discordjs/collection/-/collection-0.1.6.tgz#9e9a7637f4e4e0688fd8b2b5c63133c91607682c"
-  integrity sha512-utRNxnd9kSS2qhyivo9lMlt5qgAUasH2gb7BEOn6p0efFh24gjGomHzWKMAPn2hEReOPQZCJaRKoURwRotKucQ==
+"@discordjs/builders@^0.5.0":
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/@discordjs/builders/-/builders-0.5.0.tgz#646cbea9cc67f68639e6fb70ed1278b26dacdb14"
+  integrity sha512-HP5y4Rqw68o61Qv4qM5tVmDbWi4mdTFftqIOGRo33SNPpLJ1Ga3KEIR2ibKofkmsoQhEpLmopD1AZDs3cKpHuw==
+  dependencies:
+    "@sindresorhus/is" "^4.0.1"
+    discord-api-types "^0.22.0"
+    ow "^0.27.0"
+    ts-mixer "^6.0.0"
+    tslib "^2.3.0"
+
+"@discordjs/collection@^0.2.1":
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/@discordjs/collection/-/collection-0.2.1.tgz#ea4bc7b41b7b7b6daa82e439141222ec95c469b2"
+  integrity sha512-vhxqzzM8gkomw0TYRF3tgx7SwElzUlXT/Aa41O7mOcyN6wIJfj5JmDWaO5XGKsGSsNx7F3i5oIlrucCCWV1Nog==
 
 "@discordjs/form-data@^3.0.1":
   version "3.0.1"
@@ -96,11 +119,125 @@
     "@nodelib/fs.scandir" "2.1.5"
     fastq "^1.6.0"
 
+"@sapphire/async-queue@^1.1.4":
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/@sapphire/async-queue/-/async-queue-1.1.4.tgz#ae431310917a8880961cebe8e59df6ffa40f2957"
+  integrity sha512-fFrlF/uWpGOX5djw5Mu2Hnnrunao75WGey0sP0J3jnhmrJ5TAPzHYOmytD5iN/+pMxS+f+u/gezqHa9tPhRHEA==
+
+"@sapphire/decorators@next":
+  version "3.0.0-next.c4f992f5.0"
+  resolved "https://registry.yarnpkg.com/@sapphire/decorators/-/decorators-3.0.0-next.c4f992f5.0.tgz#ba3631997299d8e1bdcc4664b8091c06773bf39a"
+  integrity sha512-Bio2DKC+MNGen096zyluEmJON6OFSNcOSCPPWc7GhPC7JLDFwy2VQpfSbBQOCR2gDA8a8kGKchTG/58tIboICg==
+  dependencies:
+    tslib "2.x"
+
+"@sapphire/discord-utilities@^2.1.5":
+  version "2.1.5"
+  resolved "https://registry.yarnpkg.com/@sapphire/discord-utilities/-/discord-utilities-2.1.5.tgz#8b70b3949266d5b643a57c893985623f03297e8a"
+  integrity sha512-GQ1n+UCF3jsn1KmNLzEbjy6+ecfJPvWBaD7CZmQoXl385mTx4M2jen2w/guylJcScrsnUnbu6hgB3vSfkHXlFg==
+  dependencies:
+    twemoji-parser "^13.1.0"
+
+"@sapphire/discord-utilities@^2.2.0-next.c4f992f5.0":
+  version "2.2.0-pr-160.676f855.0"
+  resolved "https://registry.yarnpkg.com/@sapphire/discord-utilities/-/discord-utilities-2.2.0-pr-160.676f855.0.tgz#5823cc9dd8c6bd58d9661799f622121f256b0759"
+  integrity sha512-GffUWgLDI3DClwQ4babs17VdvWIZQb0qkTCDhUnOjn5QKLq+li+oaQ1dRreZD+yFXsyQrmS6nVHAr+HApXlotw==
+  dependencies:
+    twemoji-parser "^13.1.0"
+
+"@sapphire/discord.js-utilities@next":
+  version "3.0.0-next.c4f992f5.0"
+  resolved "https://registry.yarnpkg.com/@sapphire/discord.js-utilities/-/discord.js-utilities-3.0.0-next.c4f992f5.0.tgz#0ec8f21f502670abd1dbf583539d3d576b21e6ed"
+  integrity sha512-ojkVaH+982dVI67TzX0xERWifRQs1S99h0dmRDfC5Pl/SgGg6ifdzocYdynUMmgyrkDZiP1hCIzVnx4jxnTDWA==
+  dependencies:
+    "@sapphire/discord-utilities" "^2.2.0-next.c4f992f5.0"
+    "@sapphire/time-utilities" "^1.4.0-next.c4f992f5.0"
+    "@sapphire/utilities" "^2.1.0-next.c4f992f5.0"
+
+"@sapphire/framework@next":
+  version "2.0.0-next.9f81b7bb.0"
+  resolved "https://registry.yarnpkg.com/@sapphire/framework/-/framework-2.0.0-next.9f81b7bb.0.tgz#3a6b9264a87da3d574def574a5b2036fc062a93a"
+  integrity sha512-E3vWLaEFsKE4X3i5SgJYtr1DGA82bHZT2CjJydwxAbk7YM9Rf7Pd97QR3mQEggkI3ofdOZZEv50XBenzZcI7uQ==
+  dependencies:
+    "@sapphire/discord-utilities" "^2.1.5"
+    "@sapphire/discord.js-utilities" next
+    "@sapphire/pieces" "^2.2.0"
+    "@sapphire/ratelimits" "^2.0.1"
+    "@sapphire/utilities" "^2.0.1"
+    lexure "^0.17.0"
+    tslib "^2.3.1"
+
+"@sapphire/pieces@^2.2.0":
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/@sapphire/pieces/-/pieces-2.2.0.tgz#9e45fe1462996d35d513dbafeab713aa5eb4adae"
+  integrity sha512-VhUMUshM7IvKQ/JXJBUUZYO28fHQQ4+2mxHf2q+Rrm6ZOJAOXrYuplc/JBJ7sHb+Icr8WFhUazlarjKbEjErZw==
+  dependencies:
+    "@discordjs/collection" "^0.2.1"
+    "@sapphire/utilities" "^2.0.1"
+    tslib "^2.3.1"
+
+"@sapphire/plugin-logger@next":
+  version "1.0.14-next.3bd3e99.0"
+  resolved "https://registry.yarnpkg.com/@sapphire/plugin-logger/-/plugin-logger-1.0.14-next.3bd3e99.0.tgz#f027c001097c05953d353f3bb53b92c5df166d42"
+  integrity sha512-yvvdO23qRCJiJyIJ+xZnCRydSO+7+A4FjzAaJOfx1FFD/vmpNr8cQQDjoWZzwPZnJE+QR9xzgaFs3z07lz7wpQ==
+  dependencies:
+    "@sapphire/time-utilities" "^1.3.8"
+    colorette "^1.3.0"
+    tslib "^2.3.1"
+
+"@sapphire/plugin-subcommands@next":
+  version "2.0.0-next.e24c125.0"
+  resolved "https://registry.yarnpkg.com/@sapphire/plugin-subcommands/-/plugin-subcommands-2.0.0-next.e24c125.0.tgz#c956e210f61746f56fde043a4b72297c102199cf"
+  integrity sha512-+gOIorZQAFoUP4p7D5JAJDLLOK0bux3qdTCdRZHZIIeXwRb8KO371uVEAj9XgRAbbW3y5NT4wvCbsxc+jqU9/A==
+  dependencies:
+    tslib "^2.3.1"
+
+"@sapphire/ratelimits@^2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@sapphire/ratelimits/-/ratelimits-2.0.1.tgz#e2195d6d93cbb19ed4f54f5078973a7c60e1a6bd"
+  integrity sha512-Q4PXoOv41c991YvFHUbhydnkSFSJJtBt8A7Jip5bRyGt44R8qcfApDFROWri88agH6ydUTAAYKKkHX4BSWOrIw==
+  dependencies:
+    "@sapphire/time-utilities" "^1.3.8"
+
+"@sapphire/time-utilities@^1.3.8":
+  version "1.3.8"
+  resolved "https://registry.yarnpkg.com/@sapphire/time-utilities/-/time-utilities-1.3.8.tgz#70297b2b3321ada652ed424e9f32a82235ca2f9d"
+  integrity sha512-pmEoy24pW0xENjIGgws0r4TgeY7eemqkgDp35vRk9K4vi+RiEu9WMYfur1EI422mocQJNtfyQUo7mBKkBhSkTw==
+  dependencies:
+    "@sapphire/utilities" "^2.0.1"
+
+"@sapphire/time-utilities@^1.4.0-next.c4f992f5.0":
+  version "1.4.0-pr-160.676f855.0"
+  resolved "https://registry.yarnpkg.com/@sapphire/time-utilities/-/time-utilities-1.4.0-pr-160.676f855.0.tgz#50787f31d3b1be86ebee71d55089d160dc1daf94"
+  integrity sha512-qjvsSdDl/LFH4sVC51FzWsENyYzQcmTlxC4XabODZFkdMNaCfqahtf8h8Gf/bVmFG7jSbzMJHXIn7r9WE32bTw==
+  dependencies:
+    "@sapphire/utilities" "^3.0.0-pr-160.676f855.0"
+
+"@sapphire/utilities@^2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@sapphire/utilities/-/utilities-2.0.1.tgz#c436c5b2b72679c89a40abe46d2f9301d03e63e2"
+  integrity sha512-KgJsgQ1cnfVKqscrMX4GH29mIVhVQkF8kSTIRCB+hgCCRfIvUU5peE4g/cegnesPS5eMiQqV+NWk7cNwhjextQ==
+
+"@sapphire/utilities@^2.1.0-next.c4f992f5.0":
+  version "2.1.0-pr-159.fae7a606.0"
+  resolved "https://registry.yarnpkg.com/@sapphire/utilities/-/utilities-2.1.0-pr-159.fae7a606.0.tgz#ceba7a08bc96ed18b2636e5dcad57f13e394e609"
+  integrity sha512-tksK8j0/5xhmEfPQ5NRlm/aTyWMxq6HhBOO1O1hiv2fbiBUsG4pp+Y/xZV4zVAB9SdpKiwthqQSWt17fcZ4lOQ==
+
+"@sapphire/utilities@^3.0.0-pr-160.676f855.0":
+  version "3.0.0-pr-160.676f855.0"
+  resolved "https://registry.yarnpkg.com/@sapphire/utilities/-/utilities-3.0.0-pr-160.676f855.0.tgz#9165d68de8845751a2276f6a53c2dbdc293a1c2e"
+  integrity sha512-g2Qi+E6rai2WXaDyRCazqWLsOkxF0o103uzo9/+l3utgu4R4xZ7yz5/vfOcla9dQAapX7KlYHrWZENShaFQWjA==
+
 "@sindresorhus/is@^0.14.0":
   version "0.14.0"
   resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-0.14.0.tgz#9fb3a3cf3132328151f353de4632e01e52102bea"
   integrity sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==
 
+"@sindresorhus/is@^4.0.1":
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-4.0.1.tgz#d26729db850fa327b7cacc5522252194404226f5"
+  integrity sha512-Qm9hBEBu18wt1PO2flE7LPb30BHMQt1eQgbV76YntdNk73XZGpn3izvGTYxbGgzXKgbCjiia0uxTd3aTNQrY/g==
+
 "@szmarczak/http-timer@^1.1.2":
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/@szmarczak/http-timer/-/http-timer-1.1.2.tgz#b1665e2c461a2cd92f4c1bbf50d5454de0d4b421"
@@ -123,7 +260,7 @@
   resolved "https://registry.yarnpkg.com/@tsconfig/node14/-/node14-1.0.1.tgz#95f2d167ffb9b8d2068b0b235302fafd4df711f2"
   integrity sha512-509r2+yARFfHHE7T6Puu2jjkoycftovhXRqW328PDXTVGKihlb1P8Z9mMZH04ebyajfRY7dedfGynlrFHJUQCg==
 
-"@tsconfig/node16@^1.0.1":
+"@tsconfig/node16@^1.0.2":
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.2.tgz#423c77877d0569db20e1fc80885ac4118314010e"
   integrity sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA==
@@ -134,14 +271,19 @@
   integrity sha512-yd+9qKmJxm496BOV9CMNaey8TWsikaZOwMRwPHQIjcOJM9oV+fi9ZMNw3JsVnbEEbo2gRTDnGEBv8pjyn67hNg==
 
 "@types/js-yaml@^4.0.1":
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/@types/js-yaml/-/js-yaml-4.0.2.tgz#4117a7a378593a218e9d6f0ef44ce6d5d9edf7fa"
-  integrity sha512-KbeHS/Y4R+k+5sWXEYzAZKuB1yQlZtEghuhRxrVRLaqhtoG5+26JwQsa4HyS3AWX8v1Uwukma5HheduUDskasA==
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/@types/js-yaml/-/js-yaml-4.0.3.tgz#9f33cd6fbf0d5ec575dc8c8fc69c7fec1b4eb200"
+  integrity sha512-5t9BhoORasuF5uCPr+d5/hdB++zRFUTMIZOzbNkr+jZh3yQht4HYbRDyj9fY8n2TZT30iW9huzav73x4NikqWg==
 
 "@types/json-schema@^7.0.7":
-  version "7.0.8"
-  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.8.tgz#edf1bf1dbf4e04413ca8e5b17b3b7d7d54b59818"
-  integrity sha512-YSBPTLTVm2e2OoQIDYx8HaeWJ5tTToLH67kXR7zYNGupXMEHa2++G8k+DczX2cFVgalypqtyZIcU19AFcmOpmg==
+  version "7.0.9"
+  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.9.tgz#97edc9037ea0c38585320b28964dde3b39e4660d"
+  integrity sha512-qcUXuemtEu+E5wZSJHNxUXeCZhAfXKQ41D+duX+VYPde7xyEVZci+/oXKJL13tnRs9lR2pr4fod59GT6/X1/yQ==
+
+"@types/json5@^0.0.29":
+  version "0.0.29"
+  resolved "https://registry.yarnpkg.com/@types/json5/-/json5-0.0.29.tgz#ee28707ae94e11d2b827bcbe5270bcea7f3e71ee"
+  integrity sha1-7ihweulOEdK4J7y+UnC86n8+ce4=
 
 "@types/mocha@^8.2.1":
   version "8.2.3"
@@ -149,14 +291,14 @@
   integrity sha512-ekGvFhFgrc2zYQoX4JeZPmVzZxw6Dtllga7iGHzfbYIYkAMUx/sAFP2GdFpLff+vdHXu5fl7WX9AT+TtqYcsyw==
 
 "@types/node@*":
-  version "16.4.0"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-16.4.0.tgz#2c219eaa3b8d1e4d04f4dd6e40bc68c7467d5272"
-  integrity sha512-HrJuE7Mlqcjj+00JqMWpZ3tY8w7EUd+S0U3L1+PQSWiXZbOgyQDvi+ogoUxaHApPJq5diKxYBQwA3iIlNcPqOg==
+  version "16.7.10"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-16.7.10.tgz#7aa732cc47341c12a16b7d562f519c2383b6d4fc"
+  integrity sha512-S63Dlv4zIPb8x6MMTgDq5WWRJQe56iBEY0O3SOFA9JrRienkOVDXSXBjjJw6HTNQYSE2JI6GMCR6LVbIMHJVvA==
 
 "@types/node@^15.12.4":
-  version "15.14.2"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-15.14.2.tgz#7af8ab20156586f076f4760bc1b3c5ddfffd1ff2"
-  integrity sha512-dvMUE/m2LbXPwlvVuzCyslTEtQ2ZwuuFClDrOQ6mp2CenCg971719PTILZ4I6bTP27xfFFc+o7x2TkLuun/MPw==
+  version "15.14.9"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-15.14.9.tgz#bc43c990c3c9be7281868bbc7b8fdd6e2b57adfa"
+  integrity sha512-qjd88DrCxupx/kJD5yQgZdcYKZKSIGBVDIBE1/LTGcNm3d2Np/jxojkdePDdfnBHJc5W7vSMpbJ1aB7p/Py69A==
 
 "@types/pg@^8.6.1":
   version "8.6.1"
@@ -167,73 +309,80 @@
     pg-protocol "*"
     pg-types "^2.2.0"
 
+"@types/ws@^7.4.7":
+  version "7.4.7"
+  resolved "https://registry.yarnpkg.com/@types/ws/-/ws-7.4.7.tgz#f7c390a36f7a0679aa69de2d501319f4f8d9b702"
+  integrity sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==
+  dependencies:
+    "@types/node" "*"
+
 "@typescript-eslint/eslint-plugin@^4.29.2":
-  version "4.29.2"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.29.2.tgz#f54dc0a32b8f61c6024ab8755da05363b733838d"
-  integrity sha512-x4EMgn4BTfVd9+Z+r+6rmWxoAzBaapt4QFqE+d8L8sUtYZYLDTK6VG/y/SMMWA5t1/BVU5Kf+20rX4PtWzUYZg==
+  version "4.30.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.30.0.tgz#4a0c1ae96b953f4e67435e20248d812bfa55e4fb"
+  integrity sha512-NgAnqk55RQ/SD+tZFD9aPwNSeHmDHHe5rtUyhIq0ZeCWZEvo4DK9rYz7v9HDuQZFvn320Ot+AikaCKMFKLlD0g==
   dependencies:
-    "@typescript-eslint/experimental-utils" "4.29.2"
-    "@typescript-eslint/scope-manager" "4.29.2"
+    "@typescript-eslint/experimental-utils" "4.30.0"
+    "@typescript-eslint/scope-manager" "4.30.0"
     debug "^4.3.1"
     functional-red-black-tree "^1.0.1"
     regexpp "^3.1.0"
     semver "^7.3.5"
     tsutils "^3.21.0"
 
-"@typescript-eslint/experimental-utils@4.29.2":
-  version "4.29.2"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-4.29.2.tgz#5f67fb5c5757ef2cb3be64817468ba35c9d4e3b7"
-  integrity sha512-P6mn4pqObhftBBPAv4GQtEK7Yos1fz/MlpT7+YjH9fTxZcALbiiPKuSIfYP/j13CeOjfq8/fr9Thr2glM9ub7A==
+"@typescript-eslint/experimental-utils@4.30.0":
+  version "4.30.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-4.30.0.tgz#9e49704fef568432ae16fc0d6685c13d67db0fd5"
+  integrity sha512-K8RNIX9GnBsv5v4TjtwkKtqMSzYpjqAQg/oSphtxf3xxdt6T0owqnpojztjjTcatSteH3hLj3t/kklKx87NPqw==
   dependencies:
     "@types/json-schema" "^7.0.7"
-    "@typescript-eslint/scope-manager" "4.29.2"
-    "@typescript-eslint/types" "4.29.2"
-    "@typescript-eslint/typescript-estree" "4.29.2"
+    "@typescript-eslint/scope-manager" "4.30.0"
+    "@typescript-eslint/types" "4.30.0"
+    "@typescript-eslint/typescript-estree" "4.30.0"
     eslint-scope "^5.1.1"
     eslint-utils "^3.0.0"
 
 "@typescript-eslint/parser@^4.29.2":
-  version "4.29.2"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-4.29.2.tgz#1c7744f4c27aeb74610c955d3dce9250e95c370a"
-  integrity sha512-WQ6BPf+lNuwteUuyk1jD/aHKqMQ9jrdCn7Gxt9vvBnzbpj7aWEf+aZsJ1zvTjx5zFxGCt000lsbD9tQPEL8u6g==
+  version "4.30.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-4.30.0.tgz#6abd720f66bd790f3e0e80c3be77180c8fcb192d"
+  integrity sha512-HJ0XuluSZSxeboLU7Q2VQ6eLlCwXPBOGnA7CqgBnz2Db3JRQYyBDJgQnop6TZ+rsbSx5gEdWhw4rE4mDa1FnZg==
   dependencies:
-    "@typescript-eslint/scope-manager" "4.29.2"
-    "@typescript-eslint/types" "4.29.2"
-    "@typescript-eslint/typescript-estree" "4.29.2"
+    "@typescript-eslint/scope-manager" "4.30.0"
+    "@typescript-eslint/types" "4.30.0"
+    "@typescript-eslint/typescript-estree" "4.30.0"
     debug "^4.3.1"
 
-"@typescript-eslint/scope-manager@4.29.2":
-  version "4.29.2"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-4.29.2.tgz#442b0f029d981fa402942715b1718ac7fcd5aa1b"
-  integrity sha512-mfHmvlQxmfkU8D55CkZO2sQOueTxLqGvzV+mG6S/6fIunDiD2ouwsAoiYCZYDDK73QCibYjIZmGhpvKwAB5BOA==
+"@typescript-eslint/scope-manager@4.30.0":
+  version "4.30.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-4.30.0.tgz#1a3ffbb385b1a06be85cd5165a22324f069a85ee"
+  integrity sha512-VJ/jAXovxNh7rIXCQbYhkyV2Y3Ac/0cVHP/FruTJSAUUm4Oacmn/nkN5zfWmWFEanN4ggP0vJSHOeajtHq3f8A==
   dependencies:
-    "@typescript-eslint/types" "4.29.2"
-    "@typescript-eslint/visitor-keys" "4.29.2"
+    "@typescript-eslint/types" "4.30.0"
+    "@typescript-eslint/visitor-keys" "4.30.0"
 
-"@typescript-eslint/types@4.29.2":
-  version "4.29.2"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.29.2.tgz#fc0489c6b89773f99109fb0aa0aaddff21f52fcd"
-  integrity sha512-K6ApnEXId+WTGxqnda8z4LhNMa/pZmbTFkDxEBLQAbhLZL50DjeY0VIDCml/0Y3FlcbqXZrABqrcKxq+n0LwzQ==
+"@typescript-eslint/types@4.30.0":
+  version "4.30.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.30.0.tgz#fb9d9b0358426f18687fba82eb0b0f869780204f"
+  integrity sha512-YKldqbNU9K4WpTNwBqtAerQKLLW/X2A/j4yw92e3ZJYLx+BpKLeheyzoPfzIXHfM8BXfoleTdiYwpsvVPvHrDw==
 
-"@typescript-eslint/typescript-estree@4.29.2":
-  version "4.29.2"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.29.2.tgz#a0ea8b98b274adbb2577100ba545ddf8bf7dc219"
-  integrity sha512-TJ0/hEnYxapYn9SGn3dCnETO0r+MjaxtlWZ2xU+EvytF0g4CqTpZL48SqSNn2hXsPolnewF30pdzR9a5Lj3DNg==
+"@typescript-eslint/typescript-estree@4.30.0":
+  version "4.30.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.30.0.tgz#ae57833da72a753f4846cd3053758c771670c2ac"
+  integrity sha512-6WN7UFYvykr/U0Qgy4kz48iGPWILvYL34xXJxvDQeiRE018B7POspNRVtAZscWntEPZpFCx4hcz/XBT+erenfg==
   dependencies:
-    "@typescript-eslint/types" "4.29.2"
-    "@typescript-eslint/visitor-keys" "4.29.2"
+    "@typescript-eslint/types" "4.30.0"
+    "@typescript-eslint/visitor-keys" "4.30.0"
     debug "^4.3.1"
     globby "^11.0.3"
     is-glob "^4.0.1"
     semver "^7.3.5"
     tsutils "^3.21.0"
 
-"@typescript-eslint/visitor-keys@4.29.2":
-  version "4.29.2"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.29.2.tgz#d2da7341f3519486f50655159f4e5ecdcb2cd1df"
-  integrity sha512-bDgJLQ86oWHJoZ1ai4TZdgXzJxsea3Ee9u9wsTAvjChdj2WLcVsgWYAPeY7RQMn16tKrlQaBnpKv7KBfs4EQag==
+"@typescript-eslint/visitor-keys@4.30.0":
+  version "4.30.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.30.0.tgz#a47c6272fc71b0c627d1691f68eaecf4ad71445e"
+  integrity sha512-pNaaxDt/Ol/+JZwzP7MqWc8PJQTUhZwoee/PVlQ+iYoYhagccvoHnC9e4l+C/krQYYkENxznhVSDwClIbZVxRw==
   dependencies:
-    "@typescript-eslint/types" "4.29.2"
+    "@typescript-eslint/types" "4.30.0"
     eslint-visitor-keys "^2.0.0"
 
 "@ungap/promise-all-settled@1.1.2":
@@ -246,23 +395,26 @@ abbrev@1:
   resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
   integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==
 
-abort-controller@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/abort-controller/-/abort-controller-3.0.0.tgz#eaf54d53b62bae4138e809ca225c8439a6efb392"
-  integrity sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==
-  dependencies:
-    event-target-shim "^5.0.0"
-
 acorn-jsx@^5.3.1:
   version "5.3.2"
   resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937"
   integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
 
+acorn-walk@^8.1.1:
+  version "8.1.1"
+  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.1.1.tgz#3ddab7f84e4a7e2313f6c414c5b7dac85f4e3ebc"
+  integrity sha512-FbJdceMlPHEAWJOILDk1fXD8lnTlEIWFkqtfk+MvmL5q/qlHfN7GEHcsFZWt/Tea9jRNPWUZG4G976nqAAmU9w==
+
 acorn@^7.4.0:
   version "7.4.1"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa"
   integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==
 
+acorn@^8.4.1:
+  version "8.4.1"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.4.1.tgz#56c36251fc7cabc7096adc18f05afe814321a28c"
+  integrity sha512-asabaBSkEKosYKMITunzX177CXxQ4Q8BSSzMTKD+FefUhipQC70gfW5SiUDhYQ3vk8G+81HqQk7Fv9OXwwn9KA==
+
 ajv@^6.10.0, ajv@^6.12.4:
   version "6.12.6"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
@@ -385,16 +537,16 @@ astral-regex@^2.0.0:
   integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==
 
 async-mutex@^0.3.1:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/async-mutex/-/async-mutex-0.3.1.tgz#7033af665f1c7cebed8b878267a43ba9e77c5f67"
-  integrity sha512-vRfQwcqBnJTLzVQo72Sf7KIUbcSUP5hNchx6udI1U6LuPQpfePgdjJzlCe76yFZ8pxlLjn9lwcl/Ya0TSOv0Tw==
+  version "0.3.2"
+  resolved "https://registry.yarnpkg.com/async-mutex/-/async-mutex-0.3.2.tgz#1485eda5bda1b0ec7c8df1ac2e815757ad1831df"
+  integrity sha512-HuTK7E7MT7jZEh1P9GtRW9+aTWiDWWi9InbZ5hjxrnRa39KS4BW04+xLBhYNS2aXhHUIKZSw3gj4Pn1pj+qGAA==
   dependencies:
-    tslib "^2.1.0"
+    tslib "^2.3.1"
 
 async@^3.1.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/async/-/async-3.2.0.tgz#b3a2685c5ebb641d3de02d161002c60fc9f85720"
-  integrity sha512-TR2mEZFVOj2pLStYxLht7TyfuRzaydfpxr3k9RpHIzMgw7A64dzsdqCxH1WJyQdoe8T10nDXd9wnEigmiuHIZw==
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/async/-/async-3.2.1.tgz#d3274ec66d107a47476a4c49136aacdb00665fc8"
+  integrity sha512-XdD5lRO/87udXCMC9meWdYiR+Nq6ZjUfXidViUZGu2F1MO4T3XwZ1et0hb2++BgLfhyJwy44BGB/yx80ABx8hg==
 
 asynckit@^0.4.0:
   version "0.4.0"
@@ -445,11 +597,6 @@ browser-stdout@1.3.1:
   resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60"
   integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
 
-buffer-from@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
-  integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==
-
 buffer-writer@2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/buffer-writer/-/buffer-writer-2.0.0.tgz#ce7eb81a38f7829db09c873f2fbb792c0c98ec04"
@@ -476,7 +623,7 @@ call-bind@^1.0.0, call-bind@^1.0.2:
     function-bind "^1.1.1"
     get-intrinsic "^1.0.2"
 
-callsites@^3.0.0:
+callsites@^3.0.0, callsites@^3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
   integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
@@ -520,7 +667,7 @@ chalk@^3.0.0:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
-chalk@^4.0.0:
+chalk@^4.0.0, chalk@^4.1.0:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
   integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
@@ -528,14 +675,6 @@ chalk@^4.0.0:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
-chalk@^4.1.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.1.tgz#c80b3fab28bf6371e6863325eee67e618b77e6ad"
-  integrity sha512-diHzdDKxcU+bAsUboHLPEDQiw0qEe0qd7SYUn3HgcFlWgbDcfLGswOHYeGrHKzG9z6UYf01d9VFMfZxPM1xZSg==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
 check-error@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/check-error/-/check-error-1.0.2.tgz#574d312edd88bb5dd8912e9286dd6c0aed4aac82"
@@ -622,6 +761,11 @@ color@3.0.x:
     color-convert "^1.9.1"
     color-string "^1.5.2"
 
+colorette@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/colorette/-/colorette-1.3.0.tgz#ff45d2f0edb244069d3b772adeb04fed38d0a0af"
+  integrity sha512-ecORCqbSFP7Wm8Y6lyqMJjexBQqXSF7SSeaTyGGphogUjBlFP9m9o08wy86HL2uB7fMTxtOUzLMk7ogKcxMg1w==
+
 colors@^1.2.1:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/colors/-/colors-1.4.0.tgz#c50491479d4c1bdaed2c9ced32cf7c7dc2360f78"
@@ -642,11 +786,6 @@ combined-stream@^1.0.8:
   dependencies:
     delayed-stream "~1.0.0"
 
-common-tags@^1.8.0:
-  version "1.8.0"
-  resolved "https://registry.yarnpkg.com/common-tags/-/common-tags-1.8.0.tgz#8e3153e542d4a39e9b10554434afaaf98956a937"
-  integrity sha512-6P6g0uetGpW/sdyUy/iQQCbFF0kWVMSIVSyYz7Zgjcgh8mgw8PQzDNZeyZ5DQ2gM7LBoZPHmnjz8rUthkBG5tw==
-
 concat-map@0.0.1:
   version "0.0.1"
   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
@@ -670,9 +809,9 @@ confusing-browser-globals@^1.0.10:
   integrity sha512-gNld/3lySHwuhaVluJUKLePYirM3QNCKzVxqAdhJII9/WXKVX5PURzMVJspS1jTslSqjeuG4KMVTSouit5YPHA==
 
 core-util-is@~1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
-  integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85"
+  integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==
 
 create-require@^1.1.0:
   version "1.1.1"
@@ -784,29 +923,24 @@ dir-glob@^3.0.1:
   dependencies:
     path-type "^4.0.0"
 
-discord.js-commando@^0.12.3:
-  version "0.12.3"
-  resolved "https://registry.yarnpkg.com/discord.js-commando/-/discord.js-commando-0.12.3.tgz#4602763925ade467153d54976d2a3821fe51b072"
-  integrity sha512-BNLhTnyFuNsF1TOd9JOu8tRoV1wi3G4AG3WWMc8qtfur8W0fYQ2jmi5CklKU4Q6JqFYjHkLeRMeZv3rAfDOKjQ==
-  dependencies:
-    common-tags "^1.8.0"
-    emoji-regex "^9.2.0"
-    is-promise "^4.0.0"
-    require-all "^3.0.0"
+discord-api-types@^0.22.0:
+  version "0.22.0"
+  resolved "https://registry.yarnpkg.com/discord-api-types/-/discord-api-types-0.22.0.tgz#34dc57fe8e016e5eaac5e393646cd42a7e1ccc2a"
+  integrity sha512-l8yD/2zRbZItUQpy7ZxBJwaLX/Bs2TGaCthRppk8Sw24LOIWg12t9JEreezPoYD0SQcC2htNNo27kYEpYW/Srg==
 
-discord.js@^12.5.3:
-  version "12.5.3"
-  resolved "https://registry.yarnpkg.com/discord.js/-/discord.js-12.5.3.tgz#56820d473c24320871df9ea0bbc6b462f21cf85c"
-  integrity sha512-D3nkOa/pCkNyn6jLZnAiJApw2N9XrIsXUAdThf01i7yrEuqUmDGc7/CexVWwEcgbQR97XQ+mcnqJpmJ/92B4Aw==
+discord.js@13.1.0:
+  version "13.1.0"
+  resolved "https://registry.yarnpkg.com/discord.js/-/discord.js-13.1.0.tgz#99f6a2a8be88d31906ff0148e9b1cb603ebb2e2e"
+  integrity sha512-gxO4CXKdHpqA+WKG+f5RNnd3srTDj5uFJHgOathksDE90YNq/Qijkd2WlMgTTMS6AJoEnHxI7G9eDQHCuZ+xDA==
   dependencies:
-    "@discordjs/collection" "^0.1.6"
+    "@discordjs/builders" "^0.5.0"
+    "@discordjs/collection" "^0.2.1"
     "@discordjs/form-data" "^3.0.1"
-    abort-controller "^3.0.0"
+    "@sapphire/async-queue" "^1.1.4"
+    "@types/ws" "^7.4.7"
+    discord-api-types "^0.22.0"
     node-fetch "^2.6.1"
-    prism-media "^1.2.9"
-    setimmediate "^1.0.5"
-    tweetnacl "^1.0.3"
-    ws "^7.4.4"
+    ws "^7.5.1"
 
 doctrine@^2.1.0:
   version "2.1.0"
@@ -829,6 +963,13 @@ dot-prop@^5.2.0:
   dependencies:
     is-obj "^2.0.0"
 
+dot-prop@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-6.0.1.tgz#fc26b3cf142b9e59b74dbd39ed66ce620c681083"
+  integrity sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==
+  dependencies:
+    is-obj "^2.0.0"
+
 duplexer3@^0.1.4:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/duplexer3/-/duplexer3-0.1.4.tgz#ee01dd1cac0ed3cbc7fdbea37dc0a8f1ce002ce2"
@@ -844,11 +985,6 @@ emoji-regex@^8.0.0:
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
   integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
 
-emoji-regex@^9.2.0:
-  version "9.2.2"
-  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
-  integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
-
 enabled@2.0.x:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/enabled/-/enabled-2.0.0.tgz#f9dd92ec2d6f4bbc0d5d1e64e21d61cd4665e7c2"
@@ -958,9 +1094,9 @@ eslint-module-utils@^2.6.2:
     pkg-dir "^2.0.0"
 
 eslint-plugin-import@^2.24.1:
-  version "2.24.1"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-import/-/eslint-plugin-import-2.24.1.tgz#64aba8b567a1ba9921d5465586e86c491b8e2135"
-  integrity sha512-KSFWhNxPH8OGJwpRJJs+Z7I0a13E2iFQZJIvSnCu6KUs4qmgAm3xN9GYBCSoiGWmwA7gERZPXqYQjcoCROnYhQ==
+  version "2.24.2"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-import/-/eslint-plugin-import-2.24.2.tgz#2c8cd2e341f3885918ee27d18479910ade7bb4da"
+  integrity sha512-hNVtyhiEtZmpsabL4neEj+6M5DCLgpYyG9nzJY8lZQeQXEn5UPW1DpUdsMHMXsq98dbNm7nt1w9ZMSVpfJdi8Q==
   dependencies:
     array-includes "^3.1.3"
     array.prototype.flat "^1.2.4"
@@ -976,7 +1112,7 @@ eslint-plugin-import@^2.24.1:
     pkg-up "^2.0.0"
     read-pkg-up "^3.0.0"
     resolve "^1.20.0"
-    tsconfig-paths "^3.10.1"
+    tsconfig-paths "^3.11.0"
 
 eslint-plugin-prettier@^3.4.1:
   version "3.4.1"
@@ -1106,11 +1242,6 @@ esutils@^2.0.2:
   resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
   integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
 
-event-target-shim@^5.0.0:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/event-target-shim/-/event-target-shim-5.0.1.tgz#5d4d3ebdf9583d63a5333ce2deb7480ab2b05789"
-  integrity sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==
-
 fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
   version "3.1.3"
   resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
@@ -1148,9 +1279,9 @@ fast-safe-stringify@^2.0.4:
   integrity sha512-lXatBjf3WPjmWD6DpIZxkeSsCOwqI0maYMpgDlx8g4U2qi4lbjA9oH/HD2a87G+KfsUmo5WbJFmqBZlPxtptag==
 
 fastq@^1.6.0:
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.11.1.tgz#5d8175aae17db61947f8b162cfc7f63264d22807"
-  integrity sha512-HOnr8Mc60eNYl1gzwp6r5RoUyAn5/glBolUzP/Ez6IFVPMPirxn/9phgL6zhOtaTy7ISwPvQ+wT+hfcRZh/bzw==
+  version "1.12.0"
+  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.12.0.tgz#ed7b6ab5d62393fb2cc591c853652a5c318bf794"
+  integrity sha512-VNX0QkHK3RsXVKr9KrlUv/FoTa0NdbYoHHl7uXHv2rzyHSlxjdNAKug2twd9luJxpcyNeAgf5iPPMutJO67Dfg==
   dependencies:
     reusify "^1.0.4"
 
@@ -1327,9 +1458,9 @@ got@^9.6.0:
     url-parse-lax "^3.0.0"
 
 graceful-fs@^4.1.2:
-  version "4.2.6"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.6.tgz#ff040b2b0853b23c3d31027523706f1885d76bee"
-  integrity sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==
+  version "4.2.8"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.8.tgz#e412b8d33f5e006593cbd3cee6df9f2cebbe802a"
+  integrity sha512-qkIilPUYcNhJpd33n0GBXTB1MMPp14TxEsEs0pTrsSVucApsYzW5V+Q8Qxhik6KU3evy+qkAAowTByymK0avdg==
 
 growl@1.10.5:
   version "1.10.5"
@@ -1580,11 +1711,6 @@ is-plain-obj@^2.1.0:
   resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-2.1.0.tgz#45e42e37fccf1f40da8e5f76ee21515840c09287"
   integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==
 
-is-promise@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-4.0.0.tgz#42ff9f84206c1991d26debf520dd5c01042dd2f3"
-  integrity sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==
-
 is-regex@^1.1.3:
   version "1.1.4"
   resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.4.tgz#eef5663cd59fa4c0ae339505323df6854bb15958"
@@ -1594,9 +1720,9 @@ is-regex@^1.1.3:
     has-tostringtag "^1.0.0"
 
 is-stream@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.0.tgz#bde9c32680d6fae04129d6ac9d921ce7815f78e3"
-  integrity sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
+  integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
 
 is-string@^1.0.5, is-string@^1.0.6:
   version "1.0.7"
@@ -1682,12 +1808,12 @@ json-stable-stringify-without-jsonify@^1.0.1:
   resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
   integrity sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=
 
-json5@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3"
-  integrity sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==
+json5@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/json5/-/json5-1.0.1.tgz#779fb0018604fa854eacbf6252180d83543e3dbe"
+  integrity sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==
   dependencies:
-    minimist "^1.2.5"
+    minimist "^1.2.0"
 
 keyv@^3.0.0:
   version "3.1.0"
@@ -1716,6 +1842,11 @@ levn@^0.4.1:
     prelude-ls "^1.2.1"
     type-check "~0.4.0"
 
+lexure@^0.17.0:
+  version "0.17.0"
+  resolved "https://registry.yarnpkg.com/lexure/-/lexure-0.17.0.tgz#95c26ee49dc3df5f28e2826b1647eb7569aab12a"
+  integrity sha512-0L8GqFgPW36sLNqxdp2VOOef5Ajpb98kc0Zk4AzE+Yf0xYTDndcT1vpFqwkTdrCCw+FV8DH4mC9NUw0RlARThA==
+
 load-json-file@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-4.0.0.tgz#2f5f45ab91e33216234fd53adab668eb4ec0993b"
@@ -1746,6 +1877,11 @@ lodash.clonedeep@^4.5.0:
   resolved "https://registry.yarnpkg.com/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz#e23f3f9c4f8fbdde872529c1071857a086e5ccef"
   integrity sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=
 
+lodash.isequal@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/lodash.isequal/-/lodash.isequal-4.5.0.tgz#415c4478f2bcc30120c22ce10ed3226f7d3e18e0"
+  integrity sha1-QVxEePK8wwEgwizhDtMib30+GOA=
+
 lodash.merge@^4.6.2:
   version "4.6.2"
   resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
@@ -1817,17 +1953,17 @@ micromatch@^4.0.4:
     braces "^3.0.1"
     picomatch "^2.2.3"
 
-mime-db@1.48.0:
-  version "1.48.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.48.0.tgz#e35b31045dd7eada3aaad537ed88a33afbef2d1d"
-  integrity sha512-FM3QwxV+TnZYQ2aRqhlKBMHxk10lTbMt3bBkMAp54ddrNeVSfcQYOOKuGuy3Ddrm38I04If834fOUSq1yzslJQ==
+mime-db@1.49.0:
+  version "1.49.0"
+  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.49.0.tgz#f3dfde60c99e9cf3bc9701d687778f537001cbed"
+  integrity sha512-CIc8j9URtOVApSFCQIF+VBkX1RwXp/oMMOrqdyXSBXq5RWNEsRfyj1kiRnQgmNXmHxPoFIxOroKA3zcU9P+nAA==
 
 mime-types@^2.1.12:
-  version "2.1.31"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.31.tgz#a00d76b74317c61f9c2db2218b8e9f8e9c5c9e6b"
-  integrity sha512-XGZnNzm3QvgKxa8dpzyhFTHmpP3l5YNusmne07VUOXxou9CqUqYa/HBy124RqtVh/O2pECas/MOcsDgpilPOPg==
+  version "2.1.32"
+  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.32.tgz#1d00e89e7de7fe02008db61001d9e02852670fd5"
+  integrity sha512-hJGaVS4G4c9TSMYh2n6SQAGrC4RnfU+daP8G7cSCmaqNjiOoUY0VHCMS42pxnQmVF1GWwFhbHWn3RIxCqTmZ9A==
   dependencies:
-    mime-db "1.48.0"
+    mime-db "1.49.0"
 
 mimic-response@^1.0.0, mimic-response@^1.0.1:
   version "1.0.1"
@@ -1841,15 +1977,15 @@ minimatch@3.0.4, minimatch@^3.0.4:
   dependencies:
     brace-expansion "^1.1.7"
 
-minimist@^1.2.0, minimist@^1.2.5:
+minimist@^1.2.0:
   version "1.2.5"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
   integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
 
 mocha@^9.0.2:
-  version "9.0.2"
-  resolved "https://registry.yarnpkg.com/mocha/-/mocha-9.0.2.tgz#e84849b61f406a680ced85af76425f6f3108d1a0"
-  integrity sha512-FpspiWU+UT9Sixx/wKimvnpkeW0mh6ROAKkIaPokj3xZgxeRhcna/k5X57jJghEr8X+Cgu/Vegf8zCX5ugSuTA==
+  version "9.1.1"
+  resolved "https://registry.yarnpkg.com/mocha/-/mocha-9.1.1.tgz#33df2eb9c6262434630510c5f4283b36efda9b61"
+  integrity sha512-0wE74YMgOkCgBUj8VyIDwmLUjTsS13WV1Pg7l0SHea2qzZzlq7MDnfbPsHKcELBRk3+izEVkRofjmClpycudCA==
   dependencies:
     "@ungap/promise-all-settled" "1.1.2"
     ansi-colors "4.1.1"
@@ -2014,6 +2150,18 @@ optionator@^0.9.1:
     type-check "^0.4.0"
     word-wrap "^1.2.3"
 
+ow@^0.27.0:
+  version "0.27.0"
+  resolved "https://registry.yarnpkg.com/ow/-/ow-0.27.0.tgz#d44da088e8184fa11de64b5813206f9f86ab68d0"
+  integrity sha512-SGnrGUbhn4VaUGdU0EJLMwZWSupPmF46hnTRII7aCLCrqixTAC5eKo8kI4/XXf1eaaI8YEVT+3FeGNJI9himAQ==
+  dependencies:
+    "@sindresorhus/is" "^4.0.1"
+    callsites "^3.1.0"
+    dot-prop "^6.0.1"
+    lodash.isequal "^4.5.0"
+    type-fest "^1.2.1"
+    vali-date "^1.0.0"
+
 p-cancelable@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/p-cancelable/-/p-cancelable-1.1.0.tgz#d078d15a3af409220c886f1d9a0ca2e441ab26cc"
@@ -2134,10 +2282,10 @@ pg-int8@1.0.1:
   resolved "https://registry.yarnpkg.com/pg-int8/-/pg-int8-1.0.1.tgz#943bd463bf5b71b4170115f80f8efc9a0c0eb78c"
   integrity sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==
 
-pg-pool@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/pg-pool/-/pg-pool-3.3.0.tgz#12d5c7f65ea18a6e99ca9811bd18129071e562fc"
-  integrity sha512-0O5huCql8/D6PIRFAlmccjphLYWC+JIzvUhSzXSpGaf+tjTZc4nn+Lr7mLXBbFJfvwbP0ywDv73EiaBsxn7zdg==
+pg-pool@^3.4.1:
+  version "3.4.1"
+  resolved "https://registry.yarnpkg.com/pg-pool/-/pg-pool-3.4.1.tgz#0e71ce2c67b442a5e862a9c182172c37eda71e9c"
+  integrity sha512-TVHxR/gf3MeJRvchgNHxsYsTCHQ+4wm3VIHSS19z8NC0+gioEhq1okDY1sm/TYbfoP6JLFx01s0ShvZ3puP/iQ==
 
 pg-protocol@*, pg-protocol@^1.5.0:
   version "1.5.0"
@@ -2156,14 +2304,14 @@ pg-types@^2.1.0, pg-types@^2.2.0:
     postgres-interval "^1.1.0"
 
 pg@^8.6.0:
-  version "8.6.0"
-  resolved "https://registry.yarnpkg.com/pg/-/pg-8.6.0.tgz#e222296b0b079b280cce106ea991703335487db2"
-  integrity sha512-qNS9u61lqljTDFvmk/N66EeGq3n6Ujzj0FFyNMGQr6XuEv4tgNTXvJQTfJdcvGit5p5/DWPu+wj920hAJFI+QQ==
+  version "8.7.1"
+  resolved "https://registry.yarnpkg.com/pg/-/pg-8.7.1.tgz#9ea9d1ec225980c36f94e181d009ab9f4ce4c471"
+  integrity sha512-7bdYcv7V6U3KAtWjpQJJBww0UEsWuh4yQ/EjNf2HeO/NnvKjpvhEIe/A/TleP6wtmSKnUnghs5A9jUoK6iDdkA==
   dependencies:
     buffer-writer "2.0.0"
     packet-reader "1.0.0"
     pg-connection-string "^2.5.0"
-    pg-pool "^3.3.0"
+    pg-pool "^3.4.1"
     pg-protocol "^1.5.0"
     pg-types "^2.1.0"
     pgpass "1.x"
@@ -2243,11 +2391,6 @@ prettier@^2.3.2:
   resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.3.2.tgz#ef280a05ec253712e486233db5c6f23441e7342d"
   integrity sha512-lnJzDfJ66zkMy58OL5/NY5zp70S7Nz6KqcKkXYzn2tMVrNxvbqaBpg7H3qHaLxCJ5lNMsGuM8+ohS7cZrthdLQ==
 
-prism-media@^1.2.9:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/prism-media/-/prism-media-1.3.1.tgz#418acd2b122bedea2e834056d678f9a5ad2943ae"
-  integrity sha512-nyYAa3KB4qteJIqdguKmwxTJgy55xxUtkJ3uRnOvO5jO+frci+9zpRXw6QZVcfDeva3S654fU9+26P2OSTzjHw==
-
 process-nextick-args@~2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
@@ -2370,11 +2513,6 @@ registry-url@^5.0.0:
   dependencies:
     rc "^1.2.8"
 
-require-all@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/require-all/-/require-all-3.0.0.tgz#473d49704be310115ce124f77383b1ebd8671312"
-  integrity sha1-Rz1JcEvjEBFc4ST3c4Ox69hnExI=
-
 require-directory@^2.1.1:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
@@ -2465,11 +2603,6 @@ serialize-javascript@6.0.0:
   dependencies:
     randombytes "^2.1.0"
 
-setimmediate@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
-  integrity sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=
-
 shebang-command@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
@@ -2517,19 +2650,6 @@ slice-ansi@^4.0.0:
     astral-regex "^2.0.0"
     is-fullwidth-code-point "^3.0.0"
 
-source-map-support@^0.5.17:
-  version "0.5.19"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
-  integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
-  dependencies:
-    buffer-from "^1.0.0"
-    source-map "^0.6.0"
-
-source-map@^0.6.0:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
-  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
-
 spdx-correct@^3.0.0:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.1.1.tgz#dece81ac9c1e6713e5f7d1b6f17d468fa53d89a9"
@@ -2737,41 +2857,49 @@ triple-beam@^1.2.0, triple-beam@^1.3.0:
   resolved "https://registry.yarnpkg.com/triple-beam/-/triple-beam-1.3.0.tgz#a595214c7298db8339eeeee083e4d10bd8cb8dd9"
   integrity sha512-XrHUvV5HpdLmIj4uVMxHggLbFSZYIn7HEWsqePZcI50pco+MPqJ50wMGY794X7AOOhxOBAjbkqfAbEe/QMp2Lw==
 
+ts-mixer@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/ts-mixer/-/ts-mixer-6.0.0.tgz#4e631d3a36e3fa9521b973b132e8353bc7267f9f"
+  integrity sha512-nXIb1fvdY5CBSrDIblLn73NW0qRDk5yJ0Sk1qPBF560OdJfQp9jhl+0tzcY09OZ9U+6GpeoI9RjwoIKFIoB9MQ==
+
 ts-node@^10.0.0:
-  version "10.1.0"
-  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.1.0.tgz#e656d8ad3b61106938a867f69c39a8ba6efc966e"
-  integrity sha512-6szn3+J9WyG2hE+5W8e0ruZrzyk1uFLYye6IGMBadnOzDh8aP7t8CbFpsfCiEx2+wMixAhjFt7lOZC4+l+WbEA==
+  version "10.2.1"
+  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.2.1.tgz#4cc93bea0a7aba2179497e65bb08ddfc198b3ab5"
+  integrity sha512-hCnyOyuGmD5wHleOQX6NIjJtYVIO8bPP8F2acWkB4W06wdlkgyvJtubO/I9NkI88hCFECbsEgoLc0VNkYmcSfw==
   dependencies:
+    "@cspotcode/source-map-support" "0.6.1"
     "@tsconfig/node10" "^1.0.7"
     "@tsconfig/node12" "^1.0.7"
     "@tsconfig/node14" "^1.0.0"
-    "@tsconfig/node16" "^1.0.1"
+    "@tsconfig/node16" "^1.0.2"
+    acorn "^8.4.1"
+    acorn-walk "^8.1.1"
     arg "^4.1.0"
     create-require "^1.1.0"
     diff "^4.0.1"
     make-error "^1.1.1"
-    source-map-support "^0.5.17"
     yn "3.1.1"
 
-tsconfig-paths@^3.10.1:
-  version "3.10.1"
-  resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-3.10.1.tgz#79ae67a68c15289fdf5c51cb74f397522d795ed7"
-  integrity sha512-rETidPDgCpltxF7MjBZlAFPUHv5aHH2MymyPvh+vEyWAED4Eb/WeMbsnD/JDr4OKPOA1TssDHgIcpTN5Kh0p6Q==
+tsconfig-paths@^3.11.0:
+  version "3.11.0"
+  resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-3.11.0.tgz#954c1fe973da6339c78e06b03ce2e48810b65f36"
+  integrity sha512-7ecdYDnIdmv639mmDwslG6KQg1Z9STTz1j7Gcz0xa+nshh/gKDAHcPxRbWOsA3SPp0tXP2leTcY9Kw+NAkfZzA==
   dependencies:
-    json5 "^2.2.0"
+    "@types/json5" "^0.0.29"
+    json5 "^1.0.1"
     minimist "^1.2.0"
     strip-bom "^3.0.0"
 
+tslib@2.x, tslib@^2.3.0, tslib@^2.3.1:
+  version "2.3.1"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.3.1.tgz#e8a335add5ceae51aa261d32a490158ef042ef01"
+  integrity sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw==
+
 tslib@^1.8.1:
   version "1.14.1"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
   integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
 
-tslib@^2.1.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.3.0.tgz#803b8cdab3e12ba581a4ca41c8839bbb0dacb09e"
-  integrity sha512-N82ooyxVNm6h1riLCoyS9e3fuJ3AMG2zIZs2Gd1ATcSFjSA23Q0fzjjZeh0jbJvWVDZ0cJT8yaNNaaXHzueNjg==
-
 tsutils@^3.21.0:
   version "3.21.0"
   resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623"
@@ -2779,10 +2907,10 @@ tsutils@^3.21.0:
   dependencies:
     tslib "^1.8.1"
 
-tweetnacl@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-1.0.3.tgz#ac0af71680458d8a6378d0d0d050ab1407d35596"
-  integrity sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==
+twemoji-parser@^13.1.0:
+  version "13.1.0"
+  resolved "https://registry.yarnpkg.com/twemoji-parser/-/twemoji-parser-13.1.0.tgz#65e7e449c59258791b22ac0b37077349127e3ea4"
+  integrity sha512-AQOzLJpYlpWMy8n+0ATyKKZzWlZBJN+G0C+5lhX7Ftc2PeEVdUU/7ns2Pn2vVje26AIZ/OHwFoUbdv6YYD/wGg==
 
 type-check@^0.4.0, type-check@~0.4.0:
   version "0.4.0"
@@ -2806,6 +2934,11 @@ type-fest@^0.8.1:
   resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d"
   integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==
 
+type-fest@^1.2.1:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-1.4.0.tgz#e9fb813fe3bf1744ec359d55d1affefa76f14be1"
+  integrity sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==
+
 typedarray-to-buffer@^3.1.5:
   version "3.1.5"
   resolved "https://registry.yarnpkg.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz#a97ee7a9ff42691b9f783ff1bc5112fe3fca9080"
@@ -2814,9 +2947,9 @@ typedarray-to-buffer@^3.1.5:
     is-typedarray "^1.0.0"
 
 typescript@^4.3.4:
-  version "4.3.5"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.3.5.tgz#4d1c37cc16e893973c45a06886b7113234f119f4"
-  integrity sha512-DqQgihaQ9cUrskJo9kIyW/+g0Vxsk8cDtZ52a3NGh0YNTfpUSArXSohyUGnvbPazEPLu398C0UxmKSOrPumUzA==
+  version "4.4.2"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.4.2.tgz#6d618640d430e3569a1dfb44f7d7e600ced3ee86"
+  integrity sha512-gzP+t5W4hdy4c+68bfcv0t400HVJMMd2+H9B7gae1nQlBzCqvrXX+6GL/b3GAgyTH966pzrZ70/fRjwAtZksSQ==
 
 unbox-primitive@^1.0.1:
   version "1.0.1"
@@ -2885,6 +3018,11 @@ v8-compile-cache@^2.0.3:
   resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee"
   integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==
 
+vali-date@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/vali-date/-/vali-date-1.0.0.tgz#1b904a59609fb328ef078138420934f6b86709a6"
+  integrity sha1-G5BKWWCfsyjvB4E4Qgk09rhnCaY=
+
 validate-npm-package-license@^3.0.1:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
@@ -2982,10 +3120,10 @@ write-file-atomic@^3.0.0:
     signal-exit "^3.0.2"
     typedarray-to-buffer "^3.1.5"
 
-ws@^7.4.4:
-  version "7.5.3"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.3.tgz#160835b63c7d97bfab418fc1b8a9fced2ac01a74"
-  integrity sha512-kQ/dHIzuLrS6Je9+uv81ueZomEwH0qVYstcAQ4/Z93K8zeko9gtAbttJWzoC5ukqXY1PpoouV3+VSOqEAFt5wg==
+ws@^7.5.1:
+  version "7.5.4"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.4.tgz#56bfa20b167427e138a7795de68d134fe92e21f9"
+  integrity sha512-zP9z6GXm6zC27YtspwH99T3qTG7bBFv2VIkeHstMLrLlDJuzA7tQ5ls3OJ1hOGGCzTQPniNJoHXIAOS0Jljohg==
 
 xdg-basedir@^4.0.0:
   version "4.0.0"