diff --git a/DisCatSharp.ApplicationCommands/ApplicationCommandsConfiguration.cs b/DisCatSharp.ApplicationCommands/ApplicationCommandsConfiguration.cs
index 358b25eb2..dd7bc65d0 100644
--- a/DisCatSharp.ApplicationCommands/ApplicationCommandsConfiguration.cs
+++ b/DisCatSharp.ApplicationCommands/ApplicationCommandsConfiguration.cs
@@ -1,75 +1,75 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.ApplicationCommands
 {
 	/// <summary>
 	/// A configuration for a <see cref="ApplicationCommandsExtension"/>
 	/// </summary>
 	public class ApplicationCommandsConfiguration
 	{
 		/// <summary>
 		/// <para>Sets the service provider.</para>
 		/// <para>Objects in this provider are used when instantiating application command modules. This allows passing data around without resorting to static members.</para>
 		/// <para>Defaults to null.</para>
 		/// </summary>
 		public IServiceProvider ServiceProvider { internal get; set; } = new ServiceCollection().BuildServiceProvider(true);
 
 		/// <summary>
 		/// <para>Sets whether to enable default help command.</para>
 		/// <para>Disabling this will allow you to make your own help command.</para>
 		/// <para>
 		/// </para>
 		/// <para>Defaults to true.</para>
 		/// </summary>
 		public bool EnableDefaultHelp { internal get; set; } = true;
 
 		/// <summary>
 		/// Debugs the startups expected and actual count.
 		/// </summary>
-		public bool DebugStartupCounts { internal get; set; } = false;
+		public bool DebugStartupCounts { internal get; set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ApplicationCommandsConfiguration"/> class.
 		/// </summary>
 		/// <param name="provider">The service provider.</param>
 		[ActivatorUtilitiesConstructor]
 		public ApplicationCommandsConfiguration(IServiceProvider provider = null)
 		{
 			this.ServiceProvider = provider;
 		}
 
 		/// <summary>
 		/// Creates a new instance of <see cref="ApplicationCommandsConfiguration"/>, copying the properties of another configuration.
 		/// </summary>
 		/// <param name="acc">Configuration the properties of which are to be copied.</param>
 		public ApplicationCommandsConfiguration(ApplicationCommandsConfiguration acc)
 		{
 			this.EnableDefaultHelp = acc.EnableDefaultHelp;
 			this.ServiceProvider = acc.ServiceProvider;
 			this.DebugStartupCounts = acc.DebugStartupCounts;
 		}
 	}
 }
diff --git a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
index 927d3a333..36a2aa9b5 100644
--- a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
+++ b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
@@ -1,1776 +1,1774 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
 using DisCatSharp.ApplicationCommands.Attributes;
 using DisCatSharp.ApplicationCommands.EventArgs;
 using DisCatSharp.Common;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.ApplicationCommands
 {
 	/// <summary>
 	/// A class that handles slash commands for a client.
 	/// </summary>
 	public sealed class ApplicationCommandsExtension : BaseExtension
 	{
 		/// <summary>
 		/// A list of methods for top level commands.
 		/// </summary>
-		private static List<CommandMethod> s_commandMethods { get; set; } = new List<CommandMethod>();
+		private static List<CommandMethod> s_commandMethods { get; set; } = new();
 
 		/// <summary>
 		/// List of groups.
 		/// </summary>
-		private static List<GroupCommand> s_groupCommands { get; set; } = new List<GroupCommand>();
+		private static List<GroupCommand> s_groupCommands { get; set; } = new();
 
 		/// <summary>
 		/// List of groups with subgroups.
 		/// </summary>
-		private static List<SubGroupCommand> s_subGroupCommands { get; set; } = new List<SubGroupCommand>();
+		private static List<SubGroupCommand> s_subGroupCommands { get; set; } = new();
 
 		/// <summary>
 		/// List of context menus.
 		/// </summary>
-		private static List<ContextMenuCommand> s_contextMenuCommands { get; set; } = new List<ContextMenuCommand>();
+		private static List<ContextMenuCommand> s_contextMenuCommands { get; set; } = new();
 
 		/// <summary>
 		/// List of global commands on discords backend.
 		/// </summary>
-		internal static List<DiscordApplicationCommand> GlobalDiscordCommands { get; set; } = null;
+		internal static List<DiscordApplicationCommand> GlobalDiscordCommands { get; set; }
 
 		/// <summary>
 		/// List of guild commands on discords backend.
 		/// </summary>
-		internal static Dictionary<ulong, List<DiscordApplicationCommand>> GuildDiscordCommands { get; set; } = null;
+		internal static Dictionary<ulong, List<DiscordApplicationCommand>> GuildDiscordCommands { get; set; }
 
 		/// <summary>
 		/// Singleton modules.
 		/// </summary>
-		private static List<object> s_singletonModules { get; set; } = new List<object>();
+		private static List<object> s_singletonModules { get; set; } = new();
 
 		/// <summary>
 		/// List of modules to register.
 		/// </summary>
 		private readonly List<KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>> _updateList = new();
 
 		/// <summary>
 		/// Configuration for Discord.
 		/// </summary>
 		internal static ApplicationCommandsConfiguration Configuration;
 
 		/// <summary>
 		/// Discord client.
 		/// </summary>
 		internal static DiscordClient ClientInternal;
 
 		/// <summary>
 		/// Set to true if anything fails when registering.
 		/// </summary>
-		private static bool s_errored { get; set; } = false;
+		private static bool s_errored { get; set; }
 
 		/// <summary>
 		/// Gets a list of registered commands. The key is the guild id (null if global).
 		/// </summary>
 		public IReadOnlyList<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> RegisteredCommands
 			=> s_registeredCommands;
 		private static readonly List<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> s_registeredCommands = new();
 
 		/// <summary>
 		/// Gets a list of registered global commands.
 		/// </summary>
 		public IReadOnlyList<DiscordApplicationCommand> GlobalCommands
 			=> GlobalCommandsInternal;
 		internal static readonly List<DiscordApplicationCommand> GlobalCommandsInternal = new();
 
 		/// <summary>
 		/// Gets a list of registered guild commands mapped by guild id.
 		/// </summary>
 		public IReadOnlyDictionary<ulong, IReadOnlyList<DiscordApplicationCommand>> GuildCommands
 		=> GuildCommandsInternal;
 		internal static readonly Dictionary<ulong, IReadOnlyList<DiscordApplicationCommand>> GuildCommandsInternal = new();
 
 		/// <summary>
 		/// Gets the registration count.
 		/// </summary>
-		private static int s_registrationCount { get; set; } = 0;
+		private static int s_registrationCount { get; set; }
 
 		/// <summary>
 		/// Gets the expected count.
 		/// </summary>
-		private static int s_expectedCount { get; set; } = 0;
+		private static int s_expectedCount { get; set; }
 
 		/// <summary>
 		/// Gets the guild ids where the applications.commands scope is missing.
 		/// </summary>
 		private IReadOnlyList<ulong> _missingScopeGuildIds;
 
 		/// <summary>
 		/// Gets whether debug is enabled.
 		/// </summary>
 		private static bool s_debugEnabled { get; set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ApplicationCommandsExtension"/> class.
 		/// </summary>
 		/// <param name="configuration">The configuration.</param>
 		internal ApplicationCommandsExtension(ApplicationCommandsConfiguration configuration)
 		{
 			Configuration = configuration;
 			s_debugEnabled = configuration.DebugStartupCounts;
 		}
 
 		/// <summary>
 		/// Runs setup. DO NOT RUN THIS MANUALLY. DO NOT DO ANYTHING WITH THIS.
 		/// </summary>
 		/// <param name="client">The client to setup on.</param>
 		protected internal override void Setup(DiscordClient client)
 		{
 			if (this.Client != null)
 				throw new InvalidOperationException("What did I tell you?");
 
 			this.Client = client;
 			ClientInternal = client;
 
 			this._slashError = new AsyncEvent<ApplicationCommandsExtension, SlashCommandErrorEventArgs>("SLASHCOMMAND_ERRORED", TimeSpan.Zero, null);
 			this._slashExecuted = new AsyncEvent<ApplicationCommandsExtension, SlashCommandExecutedEventArgs>("SLASHCOMMAND_EXECUTED", TimeSpan.Zero, null);
 			this._contextMenuErrored = new AsyncEvent<ApplicationCommandsExtension, ContextMenuErrorEventArgs>("CONTEXTMENU_ERRORED", TimeSpan.Zero, null);
 			this._contextMenuExecuted = new AsyncEvent<ApplicationCommandsExtension, ContextMenuExecutedEventArgs>("CONTEXTMENU_EXECUTED", TimeSpan.Zero, null);
 			this._applicationCommandsModuleReady = new AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs>("APPLICATION_COMMANDS_MODULE_READY", TimeSpan.Zero, null);
 			this._applicationCommandsModuleStartupFinished = new AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs>("APPLICATION_COMMANDS_MODULE_STARTUP_FINISHED", TimeSpan.Zero, null);
 			this._globalApplicationCommandsRegistered = new AsyncEvent<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs>("GLOBAL_COMMANDS_REGISTERED", TimeSpan.Zero, null);
 			this._guildApplicationCommandsRegistered = new AsyncEvent<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs>("GUILD_COMMANDS_REGISTERED", TimeSpan.Zero, null);
 
 			this.Client.GuildDownloadCompleted += async (c, e) => await this.UpdateAsync();
 			this.Client.InteractionCreated += this.CatchInteractionsOnStartup;
 			this.Client.ContextMenuInteractionCreated += this.CatchContextMenuInteractionsOnStartup;
 		}
 
 		private async Task CatchInteractionsOnStartup(DiscordClient sender, InteractionCreateEventArgs e)
 			=> await e.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AsEphemeral(true).WithContent("Attention: This application is still starting up. Application commands are unavailable for now."));
 
 		private async Task CatchContextMenuInteractionsOnStartup(DiscordClient sender, ContextMenuInteractionCreateEventArgs e)
 			=> await e.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AsEphemeral(true).WithContent("Attention: This application is still starting up. Context menu commands are unavailable for now."));
 
 		private void FinishedRegistration()
 		{
 			this.Client.InteractionCreated -= this.CatchInteractionsOnStartup;
 			this.Client.ContextMenuInteractionCreated -= this.CatchContextMenuInteractionsOnStartup;
 
 			this.Client.InteractionCreated += this.InteractionHandler;
 			this.Client.ContextMenuInteractionCreated += this.ContextMenuHandler;
 		}
 
 		/// <summary>
 		/// Registers a command class.
 		/// </summary>
 		/// <typeparam name="T">The command class to register.</typeparam>
 		/// <param name="guildId">The guild id to register it on. If you want global commands, leave it null.</param>
 		public void RegisterCommands<T>(ulong? guildId = null) where T : ApplicationCommandsModule
 		{
 			if (this.Client.ShardId == 0)
 				this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(typeof(T))));
 		}
 
 		/// <summary>
 		/// Registers a command class.
 		/// </summary>
 		/// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
 		/// <param name="guildId">The guild id to register it on. If you want global commands, leave it null.</param>
 		public void RegisterCommands(Type type, ulong? guildId = null)
 		{
 			if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
 				throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
 			//If sharding, only register for shard 0
 			if (this.Client.ShardId == 0)
 				this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(type)));
 		}
 
 		/// <summary>
 		/// Cleans all guild application commands.
 		/// </summary>
 		public async Task CleanGuildCommandsAsync()
 		{
 			foreach (var guild in this.Client.Guilds.Values)
 			{
 				await this.Client.BulkOverwriteGuildApplicationCommandsAsync(guild.Id, Array.Empty<DiscordApplicationCommand>());
 			}
 		}
 
 		/// <summary>
 		/// Cleans the global application commands.
 		/// </summary>
 		public async Task CleanGlobalCommandsAsync()
 			=> await this.Client.BulkOverwriteGlobalApplicationCommandsAsync(Array.Empty<DiscordApplicationCommand>());
 
 		/// <summary>
 		/// Registers a command class with permission and translation setup.
 		/// </summary>
 		/// <typeparam name="T">The command class to register.</typeparam>
 		/// <param name="guildId">The guild id to register it on.</param>
 		/// <param name="permissionSetup">A callback to setup permissions with.</param>
 		/// <param name="translationSetup">A callback to setup translations with.</param>
 		public void RegisterCommands<T>(ulong guildId, Action<ApplicationCommandsPermissionContext> permissionSetup = null, Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
 		{
 			if (this.Client.ShardId == 0)
 				this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(typeof(T), permissionSetup, translationSetup)));
 		}
 
 		/// <summary>
 		/// Registers a command class with permission and translation setup.
 		/// </summary>
 		/// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
 		/// <param name="guildId">The guild id to register it on.</param>
 		/// <param name="permissionSetup">A callback to setup permissions with.</param>
 		/// <param name="translationSetup">A callback to setup translations with.</param>
 		public void RegisterCommands(Type type, ulong guildId, Action<ApplicationCommandsPermissionContext> permissionSetup = null, Action<ApplicationCommandsTranslationContext> translationSetup = null)
 		{
 			if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
 				throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
 			//If sharding, only register for shard 0
 			if (this.Client.ShardId == 0)
 				this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(type, permissionSetup, translationSetup)));
 		}
 
 		/*
         /// <summary>
         /// Registers a command class with permission setup but without a guild id.
         /// </summary>
         /// <typeparam name="T">The command class to register.</typeparam>
         /// <param name="permissionSetup">A callback to setup permissions with.</param>
         public void RegisterCommands<T>(Action<ApplicationCommandsPermissionContext> permissionSetup = null) where T : ApplicationCommandsModule
         {
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(typeof(T), permissionSetup)));
         }
 
         /// <summary>
         /// Registers a command class with permission setup but without a guild id.
         /// </summary>
         /// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
         /// <param name="permissionSetup">A callback to setup permissions with.</param>
         public void RegisterCommands(Type type, Action<ApplicationCommandsPermissionContext> permissionSetup = null)
         {
             if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
                 throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
             //If sharding, only register for shard 0
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(type, permissionSetup)));
         }
         */
 
 		/// <summary>
 		/// Fired when the application commands module is ready.
 		/// </summary>
 		public event AsyncEventHandler<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs> ApplicationCommandsModuleReady
 		{
-			add { this._applicationCommandsModuleReady.Register(value); }
-			remove { this._applicationCommandsModuleReady.Unregister(value); }
+			add => this._applicationCommandsModuleReady.Register(value);
+			remove => this._applicationCommandsModuleReady.Unregister(value);
 		}
 		private AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs> _applicationCommandsModuleReady;
 
 		/// <summary>
 		/// Fired when the application commands modules startup is finished.
 		/// </summary>
 		public event AsyncEventHandler<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs> ApplicationCommandsModuleStartupFinished
 		{
-			add { this._applicationCommandsModuleStartupFinished.Register(value); }
-			remove { this._applicationCommandsModuleStartupFinished.Unregister(value); }
+			add => this._applicationCommandsModuleStartupFinished.Register(value);
+			remove => this._applicationCommandsModuleStartupFinished.Unregister(value);
 		}
 		private AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs> _applicationCommandsModuleStartupFinished;
 
 
 		/// <summary>
 		/// Fired when guild commands are registered on a guild.
 		/// </summary>
 		public event AsyncEventHandler<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs> GuildApplicationCommandsRegistered
 		{
-			add { this._guildApplicationCommandsRegistered.Register(value); }
-			remove { this._guildApplicationCommandsRegistered.Unregister(value); }
+			add => this._guildApplicationCommandsRegistered.Register(value);
+			remove => this._guildApplicationCommandsRegistered.Unregister(value);
 		}
 		private AsyncEvent<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs> _guildApplicationCommandsRegistered;
 
 		/// <summary>
 		/// Fired when the global commands are registered.
 		/// </summary>
 		public event AsyncEventHandler<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs> GlobalApplicationCommandsRegistered
 		{
-			add { this._globalApplicationCommandsRegistered.Register(value); }
-			remove { this._globalApplicationCommandsRegistered.Unregister(value); }
+			add => this._globalApplicationCommandsRegistered.Register(value);
+			remove => this._globalApplicationCommandsRegistered.Unregister(value);
 		}
 		private AsyncEvent<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs> _globalApplicationCommandsRegistered;
 
 		/// <summary>
 		/// Used for RegisterCommands and the <see cref="DisCatSharp.DiscordClient.GuildDownloadCompleted"/> event.
 		/// </summary>
 		internal async Task UpdateAsync()
 		{
 			//Only update for shard 0
 			if (this.Client.ShardId == 0)
 			{
-				GlobalDiscordCommands = new();
-				GuildDiscordCommands = new();
+				GlobalDiscordCommands = new List<DiscordApplicationCommand>();
+				GuildDiscordCommands = new Dictionary<ulong, List<DiscordApplicationCommand>>();
 
 				var commandsPending = this._updateList.Select(x => x.Key).Distinct();
 				s_expectedCount = commandsPending.Count();
 
 				if (s_debugEnabled)
 					this.Client.Logger.LogDebug($"Expected Count: {s_expectedCount}");
 
 				List<ulong> failedGuilds = new();
 				IEnumerable<DiscordApplicationCommand> globalCommands = null;
 				globalCommands = await this.Client.GetGlobalApplicationCommandsAsync() ?? null;
 				foreach (var guild in this.Client.Guilds.Keys)
 				{
 					IEnumerable<DiscordApplicationCommand> commands = null;
 					var unauthorized = false;
 					try
 					{
 						commands = await this.Client.GetGuildApplicationCommandsAsync(guild) ?? null;
 					}
 					catch (UnauthorizedException)
 					{
 						unauthorized = true;
 					}
 					finally
 					{
 						if (!unauthorized && commands != null && commands.Any())
 							GuildDiscordCommands.Add(guild, commands.ToList());
 						else if (!unauthorized)
 							GuildDiscordCommands.Add(guild, null);
 						else
 							failedGuilds.Add(guild);
 					}
 				}
 				//Default should be to add the help and slash commands can be added without setting any configuration
 				//so this should still add the default help
 				if (Configuration is null || (Configuration is not null && Configuration.EnableDefaultHelp))
 				{
 					foreach (var key in commandsPending.ToList())
 					{
 						this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>
 							(key, new ApplicationCommandsModuleConfiguration(typeof(DefaultHelpModule))));
 					}
 				}
 				if (globalCommands != null && globalCommands.Any())
 					GlobalDiscordCommands.AddRange(globalCommands);
 				foreach (var key in commandsPending.ToList())
 				{
 					this.Client.Logger.LogDebug(key.HasValue ? $"Registering commands in guild {key.Value}" : "Registering global commands.");
 					this.RegisterCommands(this._updateList.Where(x => x.Key == key).Select(x => x.Value), key);
 				}
 
 				this._missingScopeGuildIds = failedGuilds;
 
 				await this._applicationCommandsModuleReady.InvokeAsync(this, new ApplicationCommandsModuleReadyEventArgs(Configuration?.ServiceProvider)
 				{
 					Handled = true,
 					GuildsWithoutScope = failedGuilds
 				});
 			}
 		}
 
 		/// <summary>
 		/// Method for registering commands for a target from modules.
 		/// </summary>
 		/// <param name="types">The types.</param>
 		/// <param name="guildid">The optional guild id.</param>
 		private void RegisterCommands(IEnumerable<ApplicationCommandsModuleConfiguration> types, ulong? guildid)
 		{
 			//Initialize empty lists to be added to the global ones at the end
 			var commandMethods = new List<CommandMethod>();
 			var groupCommands = new List<GroupCommand>();
 			var subGroupCommands = new List<SubGroupCommand>();
 			var contextMenuCommands = new List<ContextMenuCommand>();
 			var updateList = new List<DiscordApplicationCommand>();
 
 			var commandTypeSources = new List<KeyValuePair<Type, Type>>();
 
 			_ = Task.Run(async () =>
 			{
 				//Iterates over all the modules
 				foreach (var config in types)
 				{
 					var type = config.Type;
 					try
 					{
 						var module = type.GetTypeInfo();
 						var classes = new List<TypeInfo>();
 
 						var ctx = new ApplicationCommandsTranslationContext(type, module.FullName);
 						config.Translations?.Invoke(ctx);
 
 						//Add module to classes list if it's a group
 						if (module.GetCustomAttribute<SlashCommandGroupAttribute>() != null)
 						{
 							classes.Add(module);
 						}
 						else
 						{
 							//Otherwise add the nested groups
 							classes = module.DeclaredNestedTypes.Where(x => x.GetCustomAttribute<SlashCommandGroupAttribute>() != null).ToList();
 						}
 
 						List<GroupTranslator> groupTranslations = null;
 
 						if (!string.IsNullOrEmpty(ctx.Translations))
 						{
 							groupTranslations = JsonConvert.DeserializeObject<List<GroupTranslator>>(ctx.Translations);
 						}
 
 						var slashGroupsTulpe = NestedCommandWorker.ParseSlashGroupsAsync(type, classes, guildid, groupTranslations).Result;
 
 						if (slashGroupsTulpe.applicationCommands != null && slashGroupsTulpe.applicationCommands.Any())
 							updateList.AddRange(slashGroupsTulpe.applicationCommands);
 
 						if (slashGroupsTulpe.commandTypeSources != null && slashGroupsTulpe.commandTypeSources.Any())
 							commandTypeSources.AddRange(slashGroupsTulpe.commandTypeSources);
 
 						if (slashGroupsTulpe.singletonModules != null && slashGroupsTulpe.singletonModules.Any())
 							s_singletonModules.AddRange(slashGroupsTulpe.singletonModules);
 
 						if (slashGroupsTulpe.groupCommands != null && slashGroupsTulpe.groupCommands.Any())
 							groupCommands.AddRange(slashGroupsTulpe.groupCommands);
 
 						if (slashGroupsTulpe.subGroupCommands != null && slashGroupsTulpe.subGroupCommands.Any())
 							subGroupCommands.AddRange(slashGroupsTulpe.subGroupCommands);
 
 						//Handles methods and context menus, only if the module isn't a group itself
 						if (module.GetCustomAttribute<SlashCommandGroupAttribute>() == null)
 						{
 							List<CommandTranslator> commandTranslations = null;
 
 							if (!string.IsNullOrEmpty(ctx.Translations))
 							{
 								commandTranslations = JsonConvert.DeserializeObject<List<CommandTranslator>>(ctx.Translations);
 							}
 
 							//Slash commands
 							var methods = module.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null);
 
 							var slashCommands = CommandWorker.ParseBasicSlashCommandsAsync(type, methods, guildid, commandTranslations).Result;
 
 							if (slashCommands.applicationCommands != null && slashCommands.applicationCommands.Any())
 								updateList.AddRange(slashCommands.applicationCommands);
 
 							if (slashCommands.commandTypeSources != null && slashCommands.commandTypeSources.Any())
 								commandTypeSources.AddRange(slashCommands.commandTypeSources);
 
 							if (slashCommands.commandMethods != null && slashCommands.commandMethods.Any())
 								commandMethods.AddRange(slashCommands.commandMethods);
 
 							//Context Menus
 							var contextMethods = module.DeclaredMethods.Where(x => x.GetCustomAttribute<ContextMenuAttribute>() != null);
 
 							var contextCommands = await CommandWorker.ParseContextMenuCommands(type, contextMethods, commandTranslations);
 
 							if (contextCommands.applicationCommands != null && contextCommands.applicationCommands.Any())
 								updateList.AddRange(contextCommands.applicationCommands);
 
 							if (contextCommands.commandTypeSources != null && contextCommands.commandTypeSources.Any())
 								commandTypeSources.AddRange(contextCommands.commandTypeSources);
 
 							if (contextCommands.contextMenuCommands != null && contextCommands.contextMenuCommands.Any())
 								contextMenuCommands.AddRange(contextCommands.contextMenuCommands);
 
 							//Accounts for lifespans
 							if (module.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null && module.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
 							{
 								s_singletonModules.Add(CreateInstance(module, Configuration?.ServiceProvider));
 							}
 						}
 					}
 					catch (Exception ex)
 					{
 						if (ex is BadRequestException brex)
 							this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.JsonMessage}");
 						else
 							this.Client.Logger.LogCritical(ex, $"There was an error registering application commands");
 						s_errored = true;
 					}
 				}
 				if (!s_errored)
 				{
 					try
 					{
 						List<DiscordApplicationCommand> commands = new();
 
 						try
 						{
 							if (guildid == null)
 							{
 								if (updateList != null && updateList.Any())
 								{
 									var regCommands = await RegistrationWorker.RegisterGlobalCommandsAsync(updateList);
 									var actualCommands = regCommands.Distinct().ToList();
 									commands.AddRange(actualCommands);
 									GlobalCommandsInternal.AddRange(actualCommands);
 								}
 								else
 								{
 									foreach (var cmd in GlobalDiscordCommands)
 									{
 										try
 										{
 											await this.Client.DeleteGlobalApplicationCommandAsync(cmd.Id);
 										}
 										catch (NotFoundException)
 										{
 											this.Client.Logger.LogError($"Could not delete global command {cmd.Id}. Please clean up manually");
 										}
 									}
 								}
 							}
 							else
 							{
 								if (updateList != null && updateList.Any())
 								{
 									var regCommands = await RegistrationWorker.RegisterGuilldCommandsAsync(guildid.Value, updateList);
 									var actualCommands = regCommands.Distinct().ToList();
 									commands.AddRange(actualCommands);
 									GuildCommandsInternal.Add(guildid.Value, actualCommands);
 									if (this.Client.Guilds.TryGetValue(guildid.Value, out var guild))
 									{
-										guild.InternalRegisteredApplicationCommands = new();
+										guild.InternalRegisteredApplicationCommands = new List<DiscordApplicationCommand>();
 										guild.InternalRegisteredApplicationCommands.AddRange(actualCommands);
 									}
 
 								}
 								else
 								{
 									foreach (var cmd in GuildDiscordCommands[guildid.Value])
 									{
 										try
 										{
 											await this.Client.DeleteGuildApplicationCommandAsync(guildid.Value, cmd.Id);
 										}
 										catch (NotFoundException)
 										{
 											this.Client.Logger.LogError($"Could not delete guild command {cmd.Id} in guild {guildid.Value}. Please clean up manually");
 										}
 									}
 								}
 							}
 						}
 						catch (UnauthorizedException ex)
 						{
 							this.Client.Logger.LogError($"Could not register application commands for guild {guildid}.\nError: {ex.JsonMessage}");
 							return;
 						}
 
 						//Creates a guild command if a guild id is specified, otherwise global
 						//Checks against the ids and adds them to the command method lists
 						foreach (var command in commands)
 						{
 							if (commandMethods.GetFirstValueWhere(x => x.Name == command.Name, out var com))
 							{
 								com.CommandId = command.Id;
 
 								var source = commandTypeSources.FirstOrDefault(f => f.Key == com.Method.DeclaringType);
 								await PermissionWorker.UpdateCommandPermissionAsync(types, guildid, command.Id, com.Name, source.Value, source.Key);
 							}
 							else if (groupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var groupCom))
 							{
 								groupCom.CommandId = command.Id;
 								foreach (var gCom in groupCom.Methods)
 								{
 									var source = commandTypeSources.FirstOrDefault(f => f.Key == gCom.Value.DeclaringType);
 									await PermissionWorker.UpdateCommandPermissionAsync(types, guildid, groupCom.CommandId, gCom.Key, source.Key, source.Value);
 								}
 							}
 							else if (subGroupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var subCom))
 							{
 								subCom.CommandId = command.Id;
 
 								foreach (var groupComs in subCom.SubCommands)
 								{
 									foreach (var gCom in groupComs.Methods)
 									{
 										var source = commandTypeSources.FirstOrDefault(f => f.Key == gCom.Value.DeclaringType);
 										await PermissionWorker.UpdateCommandPermissionAsync(types, guildid, subCom.CommandId, gCom.Key, source.Key, source.Value);
 									}
 								}
 							}
 							else if (contextMenuCommands.GetFirstValueWhere(x => x.Name == command.Name, out var cmCom))
 							{
 								cmCom.CommandId = command.Id;
 
 								var source = commandTypeSources.First(f => f.Key == cmCom.Method.DeclaringType);
 								await PermissionWorker.UpdateCommandPermissionAsync(types, guildid, command.Id, cmCom.Name, source.Value, source.Key);
 							}
 						}
 
 						//Adds to the global lists finally
 						s_commandMethods.AddRange(commandMethods);
 						s_groupCommands.AddRange(groupCommands);
 						s_subGroupCommands.AddRange(subGroupCommands);
 						s_contextMenuCommands.AddRange(contextMenuCommands);
 
 						s_registeredCommands.Add(new KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>(guildid, commands.ToList()));
 
 						foreach (var command in commandMethods)
 						{
 							var app = types.First(t => t.Type == command.Method.DeclaringType);
 						}
 
 						s_registrationCount++;
 						if (s_debugEnabled)
 							this.Client.Logger.LogDebug($"Expected Count: {s_expectedCount}\nCurrent Count: {s_registrationCount}");
 
 						if (guildid.HasValue)
 						{
 							await this._guildApplicationCommandsRegistered.InvokeAsync(this, new GuildApplicationCommandsRegisteredEventArgs(Configuration?.ServiceProvider)
 							{
 								Handled = true,
 								GuildId = guildid.Value,
 								RegisteredCommands = GuildCommandsInternal.Any(c => c.Key == guildid.Value) ? GuildCommandsInternal.FirstOrDefault(c => c.Key == guildid.Value).Value : null
 							});
 						}
 						else
 						{
 							await this._globalApplicationCommandsRegistered.InvokeAsync(this, new GlobalApplicationCommandsRegisteredEventArgs(Configuration?.ServiceProvider)
 							{
 								Handled = true,
 								RegisteredCommands = GlobalCommandsInternal
 							});
 						}
 
 						this.CheckRegistrationStartup();
 					}
 					catch (Exception ex)
 					{
 						if (ex is BadRequestException brex)
 							this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.JsonMessage}");
 						else
 							this.Client.Logger.LogCritical(ex, $"There was an error registering application commands");
 						s_errored = true;
 					}
 				}
 			});
 		}
 
 		private async void CheckRegistrationStartup()
 		{
 			if (s_debugEnabled)
 				this.Client.Logger.LogDebug($"Checking counts...\n\nExpected Count: {s_expectedCount}\nCurrent Count: {s_registrationCount}");
 			if (s_registrationCount == s_expectedCount)
 			{
 				await this._applicationCommandsModuleStartupFinished.InvokeAsync(this, new ApplicationCommandsModuleStartupFinishedEventArgs(Configuration?.ServiceProvider)
 				{
 					RegisteredGlobalCommands = GlobalCommandsInternal,
 					RegisteredGuildCommands = GuildCommandsInternal,
 					GuildsWithoutScope = this._missingScopeGuildIds
 				});
 
 				this.FinishedRegistration();
 			}
 		}
 
 		/// <summary>
 		/// Interaction handler.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">The event args.</param>
 		private Task InteractionHandler(DiscordClient client, InteractionCreateEventArgs e)
 		{
 			_ = Task.Run(async () =>
 			{
 				if (e.Interaction.Type == InteractionType.ApplicationCommand)
 				{
 					//Creates the context
 					var context = new InteractionContext
 					{
 						Interaction = e.Interaction,
 						Channel = e.Interaction.Channel,
 						Guild = e.Interaction.Guild,
 						User = e.Interaction.User,
 						Client = client,
 						ApplicationCommandsExtension = this,
 						CommandName = e.Interaction.Data.Name,
 						InteractionId = e.Interaction.Id,
 						Token = e.Interaction.Token,
 						Services = Configuration?.ServiceProvider,
 						ResolvedUserMentions = e.Interaction.Data.Resolved?.Users?.Values.ToList(),
 						ResolvedRoleMentions = e.Interaction.Data.Resolved?.Roles?.Values.ToList(),
 						ResolvedChannelMentions = e.Interaction.Data.Resolved?.Channels?.Values.ToList(),
 						ResolvedAttachments = e.Interaction.Data.Resolved?.Attachments?.Values.ToList(),
 						Type = ApplicationCommandType.ChatInput,
 						Locale = e.Interaction.Locale,
 						GuildLocale = e.Interaction.GuildLocale
 					};
 
 					try
 					{
 						if (s_errored)
 							throw new InvalidOperationException("Slash commands failed to register properly on startup.");
 
 						var methods = s_commandMethods.Where(x => x.CommandId == e.Interaction.Data.Id);
 						var groups = s_groupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 						var subgroups = s_subGroupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 						if (!methods.Any() && !groups.Any() && !subgroups.Any())
 							throw new InvalidOperationException("A slash command was executed, but no command was registered for it.");
 
 						if (methods.Any())
 						{
 							var method = methods.First().Method;
 
 							var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options);
 
 							await this.RunCommandAsync(context, method, args);
 						}
 						else if (groups.Any())
 						{
 							var command = e.Interaction.Data.Options.First();
 							var method = groups.First().Methods.First(x => x.Key == command.Name).Value;
 
 							var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options.First().Options);
 
 							await this.RunCommandAsync(context, method, args);
 						}
 						else if (subgroups.Any())
 						{
 							var command = e.Interaction.Data.Options.First();
 							var group = subgroups.First().SubCommands.First(x => x.Name == command.Name);
 
 							var method = group.Methods.First(x => x.Key == command.Options.First().Name).Value;
 
 							var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options.First().Options.First().Options);
 
 							await this.RunCommandAsync(context, method, args);
 						}
 
 						await this._slashExecuted.InvokeAsync(this, new SlashCommandExecutedEventArgs(this.Client.ServiceProvider) { Context = context });
 					}
 					catch (Exception ex)
 					{
 						await this._slashError.InvokeAsync(this, new SlashCommandErrorEventArgs(this.Client.ServiceProvider) { Context = context, Exception = ex });
 					}
 				}
 				else if (e.Interaction.Type == InteractionType.AutoComplete)
 				{
 					if (s_errored)
 						throw new InvalidOperationException("Slash commands failed to register properly on startup.");
 
 					var methods = s_commandMethods.Where(x => x.CommandId == e.Interaction.Data.Id);
 					var groups = s_groupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 					var subgroups = s_subGroupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 					if (!methods.Any() && !groups.Any() && !subgroups.Any())
 						throw new InvalidOperationException("An autocomplete interaction was created, but no command was registered for it.");
 
 					try
 					{
 						if (methods.Any())
 						{
 							var focusedOption = e.Interaction.Data.Options.First(o => o.Focused);
 							var method = methods.First().Method;
 
 							var option = method.GetParameters().Skip(1).First(p => p.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name);
 							var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
 							var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
 							var providerInstance = Activator.CreateInstance(provider);
 
 							var context = new AutocompleteContext
 							{
 								Interaction = e.Interaction,
 								Client = this.Client,
 								Services = Configuration?.ServiceProvider,
 								ApplicationCommandsExtension = this,
 								Guild = e.Interaction.Guild,
 								Channel = e.Interaction.Channel,
 								User = e.Interaction.User,
 								Options = e.Interaction.Data.Options.ToList(),
 								FocusedOption = focusedOption,
 								Locale = e.Interaction.Locale,
 								GuildLocale = e.Interaction.GuildLocale
 							};
 
 							var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
 							await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
 						}
 						else if (groups.Any())
 						{
 							var command = e.Interaction.Data.Options.First();
 							var group = groups.First().Methods.First(x => x.Key == command.Name).Value;
 
 							var focusedOption = command.Options.First(o => o.Focused);
 							var option = group.GetParameters().Skip(1).First(p => p.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name);
 							var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
 							var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
 							var providerInstance = Activator.CreateInstance(provider);
 
 							var context = new AutocompleteContext
 							{
 								Interaction = e.Interaction,
 								Services = Configuration?.ServiceProvider,
 								ApplicationCommandsExtension = this,
 								Guild = e.Interaction.Guild,
 								Channel = e.Interaction.Channel,
 								User = e.Interaction.User,
 								Options = command.Options.ToList(),
 								FocusedOption = focusedOption,
 								Locale = e.Interaction.Locale,
 								GuildLocale = e.Interaction.GuildLocale
 							};
 
 							var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
 							await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
 						}
 						/*else if (subgroups.Any())
                         {
                             var command = e.Interaction.Data.Options.First();
                             var method = methods.First().Method;
                             var group = subgroups.First().SubCommands.First(x => x.Name == command.Name);
 
                             var focusedOption = command.Options.First(x => x.Name == group.Name).Options.First(o => o.Focused);
                             this.Client.Logger.LogDebug("SUBGROUP::" + focusedOption.Name + ": " + focusedOption.RawValue);
 
                             var option = group.Methods.First(p => p.Value.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name).Value;
                             var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
                             var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
                             var providerInstance = Activator.CreateInstance(provider);
 
                             var context = new AutocompleteContext
                             {
                                 Interaction = e.Interaction,
                                 Services = this._configuration?.Services,
                                 ApplicationCommandsExtension = this,
                                 Guild = e.Interaction.Guild,
                                 Channel = e.Interaction.Channel,
                                 User = e.Interaction.User,
                                 Options = command.Options.First(x => x.Name == group.Name).Options.ToList(),
                                 FocusedOption = focusedOption
                             };
 
                             var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
                             await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
                         }*/
 					}
 					catch (Exception ex)
 					{
 						this.Client.Logger.LogError(ex, "Error in autocomplete interaction");
 					}
 				}
 			});
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Context menu handler.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">The event args.</param>
 		private Task ContextMenuHandler(DiscordClient client, ContextMenuInteractionCreateEventArgs e)
 		{
 			_ = Task.Run(async () =>
 			{
 				//Creates the context
 				var context = new ContextMenuContext
 				{
 					Interaction = e.Interaction,
 					Channel = e.Interaction.Channel,
 					Client = client,
 					Services = Configuration?.ServiceProvider,
 					CommandName = e.Interaction.Data.Name,
 					ApplicationCommandsExtension = this,
 					Guild = e.Interaction.Guild,
 					InteractionId = e.Interaction.Id,
 					User = e.Interaction.User,
 					Token = e.Interaction.Token,
 					TargetUser = e.TargetUser,
 					TargetMessage = e.TargetMessage,
 					Type = e.Type,
 					Locale = e.Interaction.Locale,
 					GuildLocale = e.Interaction.GuildLocale
 				};
 
 				try
 				{
 					if (s_errored)
 						throw new InvalidOperationException("Context menus failed to register properly on startup.");
 
 					//Gets the method for the command
 					var method = s_contextMenuCommands.FirstOrDefault(x => x.CommandId == e.Interaction.Data.Id);
 
 					if (method == null)
 						throw new InvalidOperationException("A context menu was executed, but no command was registered for it.");
 
 					await this.RunCommandAsync(context, method.Method, new[] { context });
 
 					await this._contextMenuExecuted.InvokeAsync(this, new ContextMenuExecutedEventArgs(this.Client.ServiceProvider) { Context = context });
 				}
 				catch (Exception ex)
 				{
 					await this._contextMenuErrored.InvokeAsync(this, new ContextMenuErrorEventArgs(this.Client.ServiceProvider) { Context = context, Exception = ex });
 				}
 			});
 
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Runs a command.
 		/// </summary>
 		/// <param name="context">The base context.</param>
 		/// <param name="method">The method info.</param>
 		/// <param name="args">The arguments.</param>
 		[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0066:Convert switch statement to expression", Justification = "<Pending>")]
 		internal async Task RunCommandAsync(BaseContext context, MethodInfo method, IEnumerable<object> args)
 		{
 			object classInstance;
 
 			//Accounts for lifespans
 			var moduleLifespan = (method.DeclaringType.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null ? method.DeclaringType.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>()?.Lifespan : ApplicationCommandModuleLifespan.Transient) ?? ApplicationCommandModuleLifespan.Transient;
 			switch (moduleLifespan)
 			{
 				case ApplicationCommandModuleLifespan.Scoped:
 					//Accounts for static methods and adds DI
 					classInstance = method.IsStatic ? ActivatorUtilities.CreateInstance(Configuration?.ServiceProvider.CreateScope().ServiceProvider, method.DeclaringType) : CreateInstance(method.DeclaringType, Configuration?.ServiceProvider.CreateScope().ServiceProvider);
 					break;
 
 				case ApplicationCommandModuleLifespan.Transient:
 					//Accounts for static methods and adds DI
 					classInstance = method.IsStatic ? ActivatorUtilities.CreateInstance(Configuration?.ServiceProvider, method.DeclaringType) : CreateInstance(method.DeclaringType, Configuration?.ServiceProvider);
 					break;
 
 				//If singleton, gets it from the singleton list
 				case ApplicationCommandModuleLifespan.Singleton:
 					classInstance = s_singletonModules.First(x => ReferenceEquals(x.GetType(), method.DeclaringType));
 					break;
 
 				default:
 					throw new Exception($"An unknown {nameof(ApplicationCommandModuleLifespanAttribute)} scope was specified on command {context.CommandName}");
 			}
 
 			ApplicationCommandsModule module = null;
 			if (classInstance is ApplicationCommandsModule mod)
 				module = mod;
 
 			// Slash commands
 			if (context is InteractionContext slashContext)
 			{
 				await this.RunPreexecutionChecksAsync(method, slashContext);
 
 				var shouldExecute = await (module?.BeforeSlashExecutionAsync(slashContext) ?? Task.FromResult(true));
 
 				if (shouldExecute)
 				{
 					await (Task)method.Invoke(classInstance, args.ToArray());
 
 					await (module?.AfterSlashExecutionAsync(slashContext) ?? Task.CompletedTask);
 				}
 			}
 			// Context menus
 			if (context is ContextMenuContext contextMenuContext)
 			{
 				await this.RunPreexecutionChecksAsync(method, contextMenuContext);
 
 				var shouldExecute = await (module?.BeforeContextMenuExecutionAsync(contextMenuContext) ?? Task.FromResult(true));
 
 				if (shouldExecute)
 				{
 					await (Task)method.Invoke(classInstance, args.ToArray());
 
 					await (module?.AfterContextMenuExecutionAsync(contextMenuContext) ?? Task.CompletedTask);
 				}
 			}
 		}
 
 		/// <summary>
 		/// Property injection
 		/// </summary>
 		/// <param name="t">The type.</param>
 		/// <param name="services">The services.</param>
 		internal static object CreateInstance(Type t, IServiceProvider services)
 		{
 			var ti = t.GetTypeInfo();
 			var constructors = ti.DeclaredConstructors
 				.Where(xci => xci.IsPublic)
 				.ToArray();
 
 			if (constructors.Length != 1)
 				throw new ArgumentException("Specified type does not contain a public constructor or contains more than one public constructor.");
 
 			var constructor = constructors[0];
 			var constructorArgs = constructor.GetParameters();
 			var args = new object[constructorArgs.Length];
 
 			if (constructorArgs.Length != 0 && services == null)
 				throw new InvalidOperationException("Dependency collection needs to be specified for parameterized constructors.");
 
 			// inject via constructor
 			if (constructorArgs.Length != 0)
 				for (var i = 0; i < args.Length; i++)
 					args[i] = services.GetRequiredService(constructorArgs[i].ParameterType);
 
 			var moduleInstance = Activator.CreateInstance(t, args);
 
 			// inject into properties
 			var props = t.GetRuntimeProperties().Where(xp => xp.CanWrite && xp.SetMethod != null && !xp.SetMethod.IsStatic && xp.SetMethod.IsPublic);
 			foreach (var prop in props)
 			{
 				if (prop.GetCustomAttribute<DontInjectAttribute>() != null)
 					continue;
 
 				var service = services.GetService(prop.PropertyType);
 				if (service == null)
 					continue;
 
 				prop.SetValue(moduleInstance, service);
 			}
 
 			// inject into fields
 			var fields = t.GetRuntimeFields().Where(xf => !xf.IsInitOnly && !xf.IsStatic && xf.IsPublic);
 			foreach (var field in fields)
 			{
 				if (field.GetCustomAttribute<DontInjectAttribute>() != null)
 					continue;
 
 				var service = services.GetService(field.FieldType);
 				if (service == null)
 					continue;
 
 				field.SetValue(moduleInstance, service);
 			}
 
 			return moduleInstance;
 		}
 
 		/// <summary>
 		/// Resolves the slash command parameters.
 		/// </summary>
 		/// <param name="e">The event arguments.</param>
 		/// <param name="context">The interaction context.</param>
 		/// <param name="method">The method info.</param>
 		/// <param name="options">The options.</param>
 		private async Task<List<object>> ResolveInteractionCommandParameters(InteractionCreateEventArgs e, InteractionContext context, MethodInfo method, IEnumerable<DiscordInteractionDataOption> options)
 		{
 			var args = new List<object> { context };
 			var parameters = method.GetParameters().Skip(1);
 
 			for (var i = 0; i < parameters.Count(); i++)
 			{
 				var parameter = parameters.ElementAt(i);
 
 				//Accounts for optional arguments without values given
 				if (parameter.IsOptional && (options == null || (!options?.Any(x => x.Name == parameter.GetCustomAttribute<OptionAttribute>().Name.ToLower()) ?? true)))
 					args.Add(parameter.DefaultValue);
 				else
 				{
 					var option = options.Single(x => x.Name == parameter.GetCustomAttribute<OptionAttribute>().Name.ToLower());
 
 					if (parameter.ParameterType == typeof(string))
 						args.Add(option.Value.ToString());
 					else if (parameter.ParameterType.IsEnum)
 						args.Add(Enum.Parse(parameter.ParameterType, (string)option.Value));
 					else if (parameter.ParameterType == typeof(long) || parameter.ParameterType == typeof(long?))
 						args.Add((long?)option.Value);
 					else if (parameter.ParameterType == typeof(bool) || parameter.ParameterType == typeof(bool?))
 						args.Add((bool?)option.Value);
 					else if (parameter.ParameterType == typeof(double) || parameter.ParameterType == typeof(double?))
 						args.Add((double?)option.Value);
 					else if (parameter.ParameterType == typeof(int) || parameter.ParameterType == typeof(int?))
 						args.Add((int?)option.Value);
 					else if (parameter.ParameterType == typeof(DiscordAttachment))
 					{
 						//Checks through resolved
 						if (e.Interaction.Data.Resolved.Attachments != null &&
 							e.Interaction.Data.Resolved.Attachments.TryGetValue((ulong)option.Value, out var attachment))
 							args.Add(attachment);
 						else
 							args.Add(new DiscordAttachment() { Id = (ulong)option.Value, Discord = this.Client.ApiClient.Discord });
 					}
 					else if (parameter.ParameterType == typeof(DiscordUser))
 					{
 						//Checks through resolved
 						if (e.Interaction.Data.Resolved.Members != null &&
 							e.Interaction.Data.Resolved.Members.TryGetValue((ulong)option.Value, out var member))
 							args.Add(member);
 						else if (e.Interaction.Data.Resolved.Users != null &&
 								 e.Interaction.Data.Resolved.Users.TryGetValue((ulong)option.Value, out var user))
 							args.Add(user);
 						else
 							args.Add(await this.Client.GetUserAsync((ulong)option.Value));
 					}
 					else if (parameter.ParameterType == typeof(DiscordChannel))
 					{
 						//Checks through resolved
 						if (e.Interaction.Data.Resolved.Channels != null &&
 							e.Interaction.Data.Resolved.Channels.TryGetValue((ulong)option.Value, out var channel))
 							args.Add(channel);
 						else
 							args.Add(e.Interaction.Guild.GetChannel((ulong)option.Value));
 					}
 					else if (parameter.ParameterType == typeof(DiscordRole))
 					{
 						//Checks through resolved
 						if (e.Interaction.Data.Resolved.Roles != null &&
 							e.Interaction.Data.Resolved.Roles.TryGetValue((ulong)option.Value, out var role))
 							args.Add(role);
 						else
 							args.Add(e.Interaction.Guild.GetRole((ulong)option.Value));
 					}
 					else if (parameter.ParameterType == typeof(SnowflakeObject))
 					{
 						//Checks through resolved
 						if (e.Interaction.Data.Resolved.Roles != null && e.Interaction.Data.Resolved.Roles.TryGetValue((ulong)option.Value, out var role))
 							args.Add(role);
 						else if (e.Interaction.Data.Resolved.Members != null && e.Interaction.Data.Resolved.Members.TryGetValue((ulong)option.Value, out var member))
 							args.Add(member);
 						else if (e.Interaction.Data.Resolved.Users != null && e.Interaction.Data.Resolved.Users.TryGetValue((ulong)option.Value, out var user))
 							args.Add(user);
 						else if (e.Interaction.Data.Resolved.Attachments != null && e.Interaction.Data.Resolved.Attachments.TryGetValue((ulong)option.Value, out var attachment))
 							args.Add(attachment);
 						else
 							throw new ArgumentException("Error resolving mentionable option.");
 					}
 					else
 						throw new ArgumentException($"Error resolving interaction.");
 				}
 			}
 
 			return args;
 		}
 
 		/// <summary>
 		/// Runs the preexecution checks.
 		/// </summary>
 		/// <param name="method">The method info.</param>
 		/// <param name="context">The base context.</param>
 		private async Task RunPreexecutionChecksAsync(MethodInfo method, BaseContext context)
 		{
 			if (context is InteractionContext ctx)
 			{
 				//Gets all attributes from parent classes as well and stuff
 				var attributes = new List<SlashCheckBaseAttribute>();
 				attributes.AddRange(method.GetCustomAttributes<SlashCheckBaseAttribute>(true));
 				attributes.AddRange(method.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 				if (method.DeclaringType.DeclaringType != null)
 				{
 					attributes.AddRange(method.DeclaringType.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 					if (method.DeclaringType.DeclaringType.DeclaringType != null)
 					{
 						attributes.AddRange(method.DeclaringType.DeclaringType.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 					}
 				}
 
 				var dict = new Dictionary<SlashCheckBaseAttribute, bool>();
 				foreach (var att in attributes)
 				{
 					//Runs the check and adds the result to a list
 					var result = await att.ExecuteChecksAsync(ctx);
 					dict.Add(att, result);
 				}
 
 				//Checks if any failed, and throws an exception
 				if (dict.Any(x => x.Value == false))
 					throw new SlashExecutionChecksFailedException { FailedChecks = dict.Where(x => x.Value == false).Select(x => x.Key).ToList() };
 			}
 			if (context is ContextMenuContext cMctx)
 			{
 				var attributes = new List<ContextMenuCheckBaseAttribute>();
 				attributes.AddRange(method.GetCustomAttributes<ContextMenuCheckBaseAttribute>(true));
 				attributes.AddRange(method.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 				if (method.DeclaringType.DeclaringType != null)
 				{
 					attributes.AddRange(method.DeclaringType.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 					if (method.DeclaringType.DeclaringType.DeclaringType != null)
 					{
 						attributes.AddRange(method.DeclaringType.DeclaringType.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 					}
 				}
 
 				var dict = new Dictionary<ContextMenuCheckBaseAttribute, bool>();
 				foreach (var att in attributes)
 				{
 					//Runs the check and adds the result to a list
 					var result = await att.ExecuteChecksAsync(cMctx);
 					dict.Add(att, result);
 				}
 
 				//Checks if any failed, and throws an exception
 				if (dict.Any(x => x.Value == false))
 					throw new ContextMenuExecutionChecksFailedException { FailedChecks = dict.Where(x => x.Value == false).Select(x => x.Key).ToList() };
 			}
 		}
 
 		/// <summary>
 		/// Gets the choice attributes from choice provider.
 		/// </summary>
 		/// <param name="customAttributes">The custom attributes.</param>
 		/// <param name="guildId">The optional guild id</param>
 		private static async Task<List<DiscordApplicationCommandOptionChoice>> GetChoiceAttributesFromProvider(IEnumerable<ChoiceProviderAttribute> customAttributes, ulong? guildId = null)
 		{
 			var choices = new List<DiscordApplicationCommandOptionChoice>();
 			foreach (var choiceProviderAttribute in customAttributes)
 			{
 				var method = choiceProviderAttribute.ProviderType.GetMethod(nameof(IChoiceProvider.Provider));
 
 				if (method == null)
 					throw new ArgumentException("ChoiceProviders must inherit from IChoiceProvider.");
 				else
 				{
 					var instance = Activator.CreateInstance(choiceProviderAttribute.ProviderType);
 
 					// Abstract class offers more properties that can be set
 					if (choiceProviderAttribute.ProviderType.IsSubclassOf(typeof(ChoiceProvider)))
 					{
 						choiceProviderAttribute.ProviderType.GetProperty(nameof(ChoiceProvider.GuildId))
 							?.SetValue(instance, guildId);
 
 						choiceProviderAttribute.ProviderType.GetProperty(nameof(ChoiceProvider.Services))
 							?.SetValue(instance, Configuration.ServiceProvider);
 					}
 
 					//Gets the choices from the method
 					var result = await (Task<IEnumerable<DiscordApplicationCommandOptionChoice>>)method.Invoke(instance, null);
 
 					if (result.Any())
 					{
 						choices.AddRange(result);
 					}
 				}
 			}
 
 			return choices;
 		}
 		/// <summary>
 		/// Gets the choice attributes from enum parameter.
 		/// </summary>
 		/// <param name="enumParam">The enum parameter.</param>
 		private static List<DiscordApplicationCommandOptionChoice> GetChoiceAttributesFromEnumParameter(Type enumParam)
 		{
 			var choices = new List<DiscordApplicationCommandOptionChoice>();
 			foreach (Enum enumValue in Enum.GetValues(enumParam))
 			{
 				choices.Add(new DiscordApplicationCommandOptionChoice(enumValue.GetName(), enumValue.ToString()));
 			}
 			return choices;
 		}
 
 		/// <summary>
 		/// Gets the parameter type.
 		/// </summary>
 		/// <param name="type">The type.</param>
 		private static ApplicationCommandOptionType GetParameterType(Type type)
 		{
 			var parametertype = type == typeof(string)
 				? ApplicationCommandOptionType.String
 				: type == typeof(long) || type == typeof(long?) || type == typeof(int) || type == typeof(int?)
 				? ApplicationCommandOptionType.Integer
 				: type == typeof(bool) || type == typeof(bool?)
 				? ApplicationCommandOptionType.Boolean
 				: type == typeof(double) || type == typeof(double?)
 				? ApplicationCommandOptionType.Number
 				: type == typeof(DiscordChannel)
 				? ApplicationCommandOptionType.Channel
 				: type == typeof(DiscordUser)
 				? ApplicationCommandOptionType.User
 				: type == typeof(DiscordRole)
 				? ApplicationCommandOptionType.Role
 				: type == typeof(SnowflakeObject)
 				? ApplicationCommandOptionType.Mentionable
 				: type == typeof(DiscordAttachment)
 				? ApplicationCommandOptionType.Attachment
 				: type.IsEnum
 				? ApplicationCommandOptionType.String
 				: throw new ArgumentException("Cannot convert type! Argument types must be string, int, long, bool, double, DiscordChannel, DiscordUser, DiscordRole, SnowflakeObject, DiscordAttachment or an Enum.");
 			return parametertype;
 		}
 
 		/// <summary>
 		/// Gets the choice attributes from parameter.
 		/// </summary>
 		/// <param name="choiceattributes">The choice attributes.</param>
-		private static List<DiscordApplicationCommandOptionChoice> GetChoiceAttributesFromParameter(IEnumerable<ChoiceAttribute> choiceattributes)
-		{
-			return !choiceattributes.Any()
+		private static List<DiscordApplicationCommandOptionChoice> GetChoiceAttributesFromParameter(IEnumerable<ChoiceAttribute> choiceattributes) =>
+			!choiceattributes.Any()
 				? null
 				: choiceattributes.Select(att => new DiscordApplicationCommandOptionChoice(att.Name, att.Value)).ToList();
-		}
 
 		/// <summary>
 		/// Parses the parameters.
 		/// </summary>
 		/// <param name="parameters">The parameters.</param>
 		/// <param name="guildId">The optional guild id.</param>
 		internal static async Task<List<DiscordApplicationCommandOption>> ParseParametersAsync(ParameterInfo[] parameters, ulong? guildId)
 		{
 			var options = new List<DiscordApplicationCommandOption>();
 			foreach (var parameter in parameters)
 			{
 				//Gets the attribute
 				var optionattribute = parameter.GetCustomAttribute<OptionAttribute>();
 				if (optionattribute == null)
 					throw new ArgumentException("Arguments must have the Option attribute!");
 
 				var minimumValue = parameter.GetCustomAttribute<MinimumAttribute>()?.Value ?? null;
 				var maximumValue = parameter.GetCustomAttribute<MaximumAttribute>()?.Value ?? null;
 
 
 				var autocompleteAttribute = parameter.GetCustomAttribute<AutocompleteAttribute>();
 				if (optionattribute.Autocomplete && autocompleteAttribute == null)
 					throw new ArgumentException("Autocomplete options must have the Autocomplete attribute!");
 				if (!optionattribute.Autocomplete && autocompleteAttribute != null)
 					throw new ArgumentException("Setting an autocomplete provider requires the option to have autocomplete set to true!");
 
 				//Sets the type
 				var type = parameter.ParameterType;
 				var parametertype = GetParameterType(type);
 
 				//Handles choices
 				//From attributes
 				var choices = GetChoiceAttributesFromParameter(parameter.GetCustomAttributes<ChoiceAttribute>());
 				//From enums
 				if (parameter.ParameterType.IsEnum)
 				{
 					choices = GetChoiceAttributesFromEnumParameter(parameter.ParameterType);
 				}
 				//From choice provider
 				var choiceProviders = parameter.GetCustomAttributes<ChoiceProviderAttribute>();
 				if (choiceProviders.Any())
 				{
 					choices = await GetChoiceAttributesFromProvider(choiceProviders, guildId);
 				}
 
 				var channelTypes = parameter.GetCustomAttribute<ChannelTypesAttribute>()?.ChannelTypes ?? null;
 
 				options.Add(new DiscordApplicationCommandOption(optionattribute.Name, optionattribute.Description, parametertype, !parameter.IsOptional, choices, null, channelTypes, optionattribute.Autocomplete, minimumValue, maximumValue));
 			}
 
 			return options;
 		}
 
 		/// <summary>
 		/// <para>Refreshes your commands, used for refreshing choice providers or applying commands registered after the ready event on the discord client.
 		/// Should only be run on the slash command extension linked to shard 0 if sharding.</para>
 		/// <para>Not recommended and should be avoided since it can make slash commands be unresponsive for a while.</para>
 		/// </summary>
 		public async Task RefreshCommandsAsync()
 		{
 			s_commandMethods.Clear();
 			s_groupCommands.Clear();
 			s_subGroupCommands.Clear();
 			s_registeredCommands.Clear();
 			s_contextMenuCommands.Clear();
 			GlobalDiscordCommands.Clear();
 			GuildDiscordCommands.Clear();
 			GlobalDiscordCommands = null;
 			GuildDiscordCommands = null;
 			GuildCommandsInternal.Clear();
 			GlobalCommandsInternal.Clear();
 
 			await this.UpdateAsync();
 		}
 
 		/// <summary>
 		/// Fires when the execution of a slash command fails.
 		/// </summary>
 		public event AsyncEventHandler<ApplicationCommandsExtension, SlashCommandErrorEventArgs> SlashCommandErrored
 		{
-			add { this._slashError.Register(value); }
-			remove { this._slashError.Unregister(value); }
+			add => this._slashError.Register(value);
+			remove => this._slashError.Unregister(value);
 		}
 		private AsyncEvent<ApplicationCommandsExtension, SlashCommandErrorEventArgs> _slashError;
 
 		/// <summary>
 		/// Fires when the execution of a slash command is successful.
 		/// </summary>
 		public event AsyncEventHandler<ApplicationCommandsExtension, SlashCommandExecutedEventArgs> SlashCommandExecuted
 		{
-			add { this._slashExecuted.Register(value); }
-			remove { this._slashExecuted.Unregister(value); }
+			add => this._slashExecuted.Register(value);
+			remove => this._slashExecuted.Unregister(value);
 		}
 		private AsyncEvent<ApplicationCommandsExtension, SlashCommandExecutedEventArgs> _slashExecuted;
 
 		/// <summary>
 		/// Fires when the execution of a context menu fails.
 		/// </summary>
 		public event AsyncEventHandler<ApplicationCommandsExtension, ContextMenuErrorEventArgs> ContextMenuErrored
 		{
-			add { this._contextMenuErrored.Register(value); }
-			remove { this._contextMenuErrored.Unregister(value); }
+			add => this._contextMenuErrored.Register(value);
+			remove => this._contextMenuErrored.Unregister(value);
 		}
 		private AsyncEvent<ApplicationCommandsExtension, ContextMenuErrorEventArgs> _contextMenuErrored;
 
 		/// <summary>
 		/// Fire when the execution of a context menu is successful.
 		/// </summary>
 		public event AsyncEventHandler<ApplicationCommandsExtension, ContextMenuExecutedEventArgs> ContextMenuExecuted
 		{
-			add { this._contextMenuExecuted.Register(value); }
-			remove { this._contextMenuExecuted.Unregister(value); }
+			add => this._contextMenuExecuted.Register(value);
+			remove => this._contextMenuExecuted.Unregister(value);
 		}
 		private AsyncEvent<ApplicationCommandsExtension, ContextMenuExecutedEventArgs> _contextMenuExecuted;
 	}
 
 	/// <summary>
 	/// Holds configuration data for setting up an application command.
 	/// </summary>
 	internal class ApplicationCommandsModuleConfiguration
 	{
 		/// <summary>
 		/// The type of the command module.
 		/// </summary>
 		public Type Type { get; }
 
 		/// <summary>
 		/// The permission setup.
 		/// </summary>
 		public Action<ApplicationCommandsPermissionContext> Setup { get; }
 
 		public Action<ApplicationCommandsTranslationContext> Translations { get; }
 
 		/// <summary>
 		/// Creates a new command configuration.
 		/// </summary>
 		/// <param name="type">The type of the command module.</param>
 		/// <param name="setup">The permission setup callback.</param>
 		/// <param name="translations">The translation setup callback.</param>
 		public ApplicationCommandsModuleConfiguration(Type type, Action<ApplicationCommandsPermissionContext> setup = null, Action<ApplicationCommandsTranslationContext> translations = null)
 		{
 			this.Type = type;
 			this.Setup = setup;
 			this.Translations = translations;
 		}
 	}
 
 	/// <summary>
 	/// Links a command to its original command module.
 	/// </summary>
 	internal class ApplicationCommandSourceLink
 	{
 		/// <summary>
 		/// The command.
 		/// </summary>
 		public DiscordApplicationCommand ApplicationCommand { get; set; }
 
 		/// <summary>
 		/// The base/root module the command is contained in.
 		/// </summary>
 		public Type RootCommandContainerType { get; set; }
 
 		/// <summary>
 		/// The direct group the command is contained in.
 		/// </summary>
 		public Type CommandContainerType { get; set; }
 	}
 
 	/// <summary>
 	/// The command method.
 	/// </summary>
 	internal class CommandMethod
 	{
 		/// <summary>
 		/// Gets or sets the command id.
 		/// </summary>
 		public ulong CommandId { get; set; }
 
 		/// <summary>
 		/// Gets or sets the name.
 		/// </summary>
 		public string Name { get; set; }
 
 		/// <summary>
 		/// Gets or sets the method.
 		/// </summary>
 		public MethodInfo Method { get; set; }
 	}
 
 	/// <summary>
 	/// The group command.
 	/// </summary>
 	internal class GroupCommand
 	{
 		/// <summary>
 		/// Gets or sets the command id.
 		/// </summary>
 		public ulong CommandId { get; set; }
 
 		/// <summary>
 		/// Gets or sets the name.
 		/// </summary>
 		public string Name { get; set; }
 
 		/// <summary>
 		/// Gets or sets the methods.
 		/// </summary>
 		public List<KeyValuePair<string, MethodInfo>> Methods { get; set; } = null;
 	}
 
 	/// <summary>
 	/// The sub group command.
 	/// </summary>
 	internal class SubGroupCommand
 	{
 		/// <summary>
 		/// Gets or sets the command id.
 		/// </summary>
 		public ulong CommandId { get; set; }
 
 		/// <summary>
 		/// Gets or sets the name.
 		/// </summary>
 		public string Name { get; set; }
 
 		/// <summary>
 		/// Gets or sets the sub commands.
 		/// </summary>
-		public List<GroupCommand> SubCommands { get; set; } = new List<GroupCommand>();
+		public List<GroupCommand> SubCommands { get; set; } = new();
 	}
 
 	/// <summary>
 	/// The context menu command.
 	/// </summary>
 	internal class ContextMenuCommand
 	{
 		/// <summary>
 		/// Gets or sets the command id.
 		/// </summary>
 		public ulong CommandId { get; set; }
 
 		/// <summary>
 		/// Gets or sets the name.
 		/// </summary>
 		public string Name { get; set; }
 
 		/// <summary>
 		/// Gets or sets the method.
 		/// </summary>
 		public MethodInfo Method { get; set; }
 	}
 
 	#region Default Help
 	/// <summary>
 	/// Represents the default help module.
 	/// </summary>
 	public class DefaultHelpModule : ApplicationCommandsModule
 	{
 		public class DefaultHelpAutoCompleteProvider : IAutocompleteProvider
 		{
 			public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 			{
 				var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 
 				var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 				var guildCommandsTask= context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 
 				var slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First()).
 					Where(ac => ac.Name.StartsWith(context.Options[0].Value.ToString(), StringComparison.OrdinalIgnoreCase)).ToList();
 				foreach (var sc in slashCommands.Take(25))
 				{
 					options.Add(new DiscordApplicationCommandAutocompleteChoice(sc.Name, sc.Name.Trim()));
 				}
 				return options.AsEnumerable();
 			}
 		}
 
 		public class DefaultHelpAutoCompleteLevelOneProvider : IAutocompleteProvider
 		{
 			public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 			{
 				var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 				var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 				var guildCommandsTask= context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 
 				var slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 				.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 				.GroupBy(ac => ac.Name).Select(x => x.First());
 				var command = slashCommands.FirstOrDefault(ac =>
 					ac.Name.Equals(context.Options[0].Value.ToString().Trim(),StringComparison.OrdinalIgnoreCase));
 				if (command is null || command.Options is null)
 				{
 					options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 				}
 				else
 				{
 					var opt = command.Options.Where(c => c.Type is ApplicationCommandOptionType.SubCommandGroup or ApplicationCommandOptionType.SubCommand
 														 && c.Name.StartsWith(context.Options[1].Value.ToString(), StringComparison.InvariantCultureIgnoreCase)).ToList();
 					foreach (var option in opt.Take(25))
 					{
 						options.Add(new DiscordApplicationCommandAutocompleteChoice(option.Name, option.Name.Trim()));
 					}
 				}
 				return options.AsEnumerable();
 			}
 		}
 
 		public class DefaultHelpAutoCompleteLevelTwoProvider : IAutocompleteProvider
 		{
 			public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 			{
 				var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 				var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 				var guildCommandsTask= context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 
 				var slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 				.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 				.GroupBy(ac => ac.Name).Select(x => x.First());
 				var command = slashCommands.FirstOrDefault(ac =>
 					ac.Name.Equals(context.Options[0].Value.ToString().Trim(), StringComparison.OrdinalIgnoreCase));
 				if (command.Options is null)
 				{
 					options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 					return options.AsEnumerable();
 				}
 				var foundCommand = command.Options.FirstOrDefault(op => op.Name.Equals(context.Options[1].Value.ToString().Trim(), StringComparison.OrdinalIgnoreCase));
 				if (foundCommand is null || foundCommand.Options is null)
 				{
 					options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 				}
 				else
 				{
 					var opt = foundCommand.Options.Where(x => x.Type == ApplicationCommandOptionType.SubCommand &&
 															  x.Name.StartsWith(context.Options[2].Value.ToString(), StringComparison.OrdinalIgnoreCase)).ToList();
 					foreach (var option in opt.Take(25))
 					{
 						options.Add(new DiscordApplicationCommandAutocompleteChoice(option.Name, option.Name.Trim()));
 					}
 				}
 				return options.AsEnumerable();
 			}
 		}
 
 		[SlashCommand("help", "Displays command help")]
 		public async Task DefaultHelpAsync(InteractionContext ctx,
 			[Autocomplete(typeof(DefaultHelpAutoCompleteProvider))]
 			[Option("option_one", "top level command to provide help for", true)] string commandName,
 			[Autocomplete(typeof(DefaultHelpAutoCompleteLevelOneProvider))]
 			[Option("option_two", "subgroup or command to provide help for", true)] string commandOneName = null,
 			[Autocomplete(typeof(DefaultHelpAutoCompleteLevelTwoProvider))]
 			[Option("option_three", "command to provide help for", true)] string commandTwoName = null)
 		{
 			var globalCommandsTask = ctx.Client.GetGlobalApplicationCommandsAsync();
 			var guildCommandsTask= ctx.Client.GetGuildApplicationCommandsAsync(ctx.Guild.Id);
 
 			await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 
 			var applicationCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 				.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 				.GroupBy(ac => ac.Name).Select(x => x.First())
 				.ToList();
 			if (applicationCommands.Count < 1)
 			{
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder()
 					.WithContent($"There are no slash commands for guild {ctx.Guild.Name}").AsEphemeral(true));
 				return;
 			}
 			if (commandTwoName is not null && !commandTwoName.Equals("no_options_for_this_command"))
 			{
 				var commandsWithSubCommands = applicationCommands.FindAll(ac => ac.Options is not null && ac.Options.Any(op => op.Type == ApplicationCommandOptionType.SubCommandGroup));
 				var cmdParent = commandsWithSubCommands.FirstOrDefault(cm => cm.Options.Any(op => op.Name.Equals(commandOneName))).Options
 						.FirstOrDefault(opt => opt.Name.Equals(commandOneName,StringComparison.OrdinalIgnoreCase));
 				var cmd = cmdParent.Options.FirstOrDefault(op => op.Name.Equals(commandTwoName,StringComparison.OrdinalIgnoreCase));
 				var discordEmbed = new DiscordEmbedBuilder
 				{
 					Title = "Help",
 					Description = $"{Formatter.InlineCode(cmd.Name)}: {cmd.Description ?? "No description provided."}"
 				};
 				if (cmd.Options is not null)
 				{
 					var commandOptions = cmd.Options.ToList();
 					var sb = new StringBuilder();
 
 					foreach (var option in commandOptions)
 						sb.Append('`').Append(option.Name).Append(" (").Append(")`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 					sb.Append('\n');
 					discordEmbed.AddField("Arguments", sb.ToString().Trim(), false);
 				}
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 					new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 			}
 			else if (commandOneName is not null && commandTwoName is null && !commandOneName.Equals("no_options_for_this_command"))
 			{
 				var commandsWithOptions = applicationCommands.FindAll(ac => ac.Options is not null && ac.Options.All(op => op.Type == ApplicationCommandOptionType.SubCommand));
 				var subCommandParent = commandsWithOptions.FirstOrDefault(cm => cm.Name.Equals(commandName,StringComparison.OrdinalIgnoreCase));
 				var subCommand = subCommandParent.Options.FirstOrDefault(op => op.Name.Equals(commandOneName,StringComparison.OrdinalIgnoreCase));
 				var discordEmbed = new DiscordEmbedBuilder
 				{
 					Title = "Help",
 					Description = $"{Formatter.InlineCode(subCommand.Name)}: {subCommand.Description ?? "No description provided."}"
 				};
 				if (subCommand.Options is not null)
 				{
 					var commandOptions = subCommand.Options.ToList();
 					var sb = new StringBuilder();
 
 					foreach (var option in commandOptions)
 						sb.Append('`').Append(option.Name).Append(" (").Append(")`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 					sb.Append('\n');
 					discordEmbed.AddField("Arguments", sb.ToString().Trim(), false);
 				}
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 					new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 			}
 			else
 			{
 				var command = applicationCommands.FirstOrDefault(cm => cm.Name.Equals(commandName, StringComparison.OrdinalIgnoreCase));
 				if (command is null)
 				{
 					await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder()
 							.WithContent($"No command called {commandName} in guild {ctx.Guild.Name}").AsEphemeral(true));
 					return;
 				}
 				var discordEmbed = new DiscordEmbedBuilder
 				{
 					Title = "Help",
 					Description = $"{Formatter.InlineCode(command.Name)}: {command.Description ?? "No description provided."}"
 				};
 				if (command.Options is not null)
 				{
 					var commandOptions = command.Options.ToList();
 					var sb = new StringBuilder();
 
 					foreach (var option in commandOptions)
 						sb.Append('`').Append(option.Name).Append(" (").Append(")`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 					sb.Append('\n');
 					discordEmbed.AddField("Arguments", sb.ToString().Trim(), false);
 				}
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 					new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 			}
 		}
 	}
 	#endregion
 }
diff --git a/DisCatSharp.ApplicationCommands/Workers/ApplicationCommandWorker.cs b/DisCatSharp.ApplicationCommands/Workers/ApplicationCommandWorker.cs
index 78f8b7235..27ae79ac3 100644
--- a/DisCatSharp.ApplicationCommands/Workers/ApplicationCommandWorker.cs
+++ b/DisCatSharp.ApplicationCommands/Workers/ApplicationCommandWorker.cs
@@ -1,382 +1,382 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 
 namespace DisCatSharp.ApplicationCommands
 {
 	/// <summary>
 	/// Represents a <see cref="CommandWorker"/>.
 	/// </summary>
 	internal class CommandWorker
 	{
 		/// <summary>
 		/// Parses context menu application commands.
 		/// </summary>
 		/// <param name="type">The type.</param>
 		/// <param name="methods">List of method infos.</param>
 		/// <param name="translator">The optional command translations.</param>
 		/// <returns>Too much.</returns>
 		internal static Task<
 			(
 				List<DiscordApplicationCommand> applicationCommands,
 				List<KeyValuePair<Type, Type>> commandTypeSources,
 				List<ContextMenuCommand> contextMenuCommands
 			)
 			> ParseContextMenuCommands(Type type, IEnumerable<MethodInfo> methods, List<CommandTranslator> translator = null)
 		{
 			List<DiscordApplicationCommand> commands = new();
 			List<KeyValuePair<Type, Type>> commandTypeSources = new();
 			List<ContextMenuCommand> contextMenuCommands = new();
 
 
 			foreach (var contextMethod in methods)
 			{
 				var contextAttribute = contextMethod.GetCustomAttribute<ContextMenuAttribute>();
 
 				DiscordApplicationCommandLocalization nameLocalizations = null;
 
 				var commandTranslation = translator?.Single(c => c.Name == contextAttribute.Name && c.Type == contextAttribute.Type);
 				if (commandTranslation != null)
 					nameLocalizations = commandTranslation.NameTranslations;
 
 				var command = new DiscordApplicationCommand(contextAttribute.Name, null, null, contextAttribute.DefaultPermission, contextAttribute.Type, nameLocalizations);
 
 				var parameters = contextMethod.GetParameters();
 				if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.FirstOrDefault()?.ParameterType, typeof(ContextMenuContext)))
 					throw new ArgumentException($"The first argument must be a ContextMenuContext!");
 				if (parameters.Length > 1)
 					throw new ArgumentException($"A context menu cannot have parameters!");
 
 				contextMenuCommands.Add(new ContextMenuCommand { Method = contextMethod, Name = contextAttribute.Name });
 
 				commands.Add(command);
 				commandTypeSources.Add(new KeyValuePair<Type, Type>(type, type));
 			}
 
 			return Task.FromResult((commands, commandTypeSources, contextMenuCommands));
 		}
 
 		/// <summary>
 		/// Parses single application commands.
 		/// </summary>
 		/// <param name="type">The type.</param>
 		/// <param name="methods">List of method infos.</param>
 		/// <param name="guildId">The optional guild id.</param>
 		/// <param name="translator">The optional command translations.</param>
 		/// <returns>Too much.</returns>
 		internal static async Task<
 			(
 				List<DiscordApplicationCommand> applicationCommands,
 				List<KeyValuePair<Type, Type>> commandTypeSources,
 				List<CommandMethod> commandMethods
 			)
 			> ParseBasicSlashCommandsAsync(Type type, IEnumerable<MethodInfo> methods, ulong? guildId = null, List<CommandTranslator> translator = null)
 		{
 			List<DiscordApplicationCommand> commands = new();
 			List<KeyValuePair<Type, Type>> commandTypeSources = new();
 			List<CommandMethod> commandMethods = new();
 
 			foreach (var method in methods)
 			{
 				var commandattribute = method.GetCustomAttribute<SlashCommandAttribute>();
 
 				var parameters = method.GetParameters();
 				if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.FirstOrDefault()?.ParameterType, typeof(InteractionContext)))
 					throw new ArgumentException($"The first argument must be an InteractionContext!");
 				parameters = parameters.Skip(1).ToArray();
 				var options = await ApplicationCommandsExtension.ParseParametersAsync(parameters, guildId);
 
 				commandMethods.Add(new CommandMethod { Method = method, Name = commandattribute.Name });
 
 				DiscordApplicationCommandLocalization nameLocalizations = null;
 				DiscordApplicationCommandLocalization descriptionLocalizations = null;
 				List<DiscordApplicationCommandOption> localizisedOptions = null;
 
 				var commandTranslation = translator?.Single(c => c.Name == commandattribute.Name && c.Type == ApplicationCommandType.ChatInput);
 
 				if (commandTranslation != null && commandTranslation.Options != null)
 				{
-					localizisedOptions = new(options.Count);
+					localizisedOptions = new List<DiscordApplicationCommandOption>(options.Count);
 					foreach (var option in options)
 					{
-						List<DiscordApplicationCommandOptionChoice> choices = option.Choices != null ? new(option.Choices.Count()) : null;
+						List<DiscordApplicationCommandOptionChoice> choices = option.Choices != null ? new List<DiscordApplicationCommandOptionChoice>(option.Choices.Count()) : null;
 						if (option.Choices != null)
 						{
 							foreach (var choice in option.Choices)
 							{
 								choices.Add(new DiscordApplicationCommandOptionChoice(choice.Name, choice.Value, commandTranslation.Options.Single(o => o.Name == option.Name).Choices.Single(c => c.Name == choice.Name).NameTranslations));
 							}
 						}
 
 						localizisedOptions.Add(new DiscordApplicationCommandOption(option.Name, option.Description, option.Type, option.Required,
 							choices, option.Options, option.ChannelTypes, option.AutoComplete, option.MinimumValue, option.MaximumValue,
 							commandTranslation.Options.Single(o => o.Name == option.Name).NameTranslations, commandTranslation.Options.Single(o => o.Name == option.Name).DescriptionTranslations
 						));
 					}
 
 					nameLocalizations = commandTranslation.NameTranslations;
 					descriptionLocalizations = commandTranslation.DescriptionTranslations;
 				}
 
 				var payload = new DiscordApplicationCommand(commandattribute.Name, commandattribute.Description, localizisedOptions ?? options, commandattribute.DefaultPermission, ApplicationCommandType.ChatInput, nameLocalizations, descriptionLocalizations);
 				commands.Add(payload);
 				commandTypeSources.Add(new KeyValuePair<Type, Type>(type, type));
 			}
 
 			return (commands, commandTypeSources, commandMethods);
 		}
 	}
 
 	/// <summary>
 	/// Represents a <see cref="NestedCommandWorker"/>.
 	/// </summary>
 	internal class NestedCommandWorker
 	{
 		/// <summary>
 		/// Parses application command groups.
 		/// </summary>
 		/// <param name="type">The type.</param>
 		/// <param name="types">List of type infos.</param>
 		/// <param name="guildId">The optional guild id.</param>
 		/// <param name="translator">The optional group translations.</param>
 		/// <returns>Too much.</returns>
 		internal static async Task<
 			(
 				List<DiscordApplicationCommand> applicationCommands,
 				List<KeyValuePair<Type, Type>> commandTypeSources,
 				List<object> singletonModules,
 				List<GroupCommand> groupCommands,
 				List<SubGroupCommand> subGroupCommands
 			)
 			> ParseSlashGroupsAsync(Type type, List<TypeInfo> types, ulong? guildId = null, List<GroupTranslator> translator = null)
 		{
 			List<DiscordApplicationCommand> commands = new();
 			List<KeyValuePair<Type, Type>> commandTypeSources = new();
 			List<GroupCommand> groupCommands = new();
 			List<SubGroupCommand> subGroupCommands = new();
 			List<object> singletonModules = new();
 
 			//Handles groups
 			foreach (var subclassinfo in types)
 			{
 				//Gets the attribute and methods in the group
 				var groupAttribute = subclassinfo.GetCustomAttribute<SlashCommandGroupAttribute>();
 				var submethods = subclassinfo.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null).ToList();
 				var subclasses = subclassinfo.DeclaredNestedTypes.Where(x => x.GetCustomAttribute<SlashCommandGroupAttribute>() != null).ToList();
 				if (subclasses.Any() && submethods.Any())
 				{
 					throw new ArgumentException("Slash command groups cannot have both subcommands and subgroups!");
 				}
 
 				DiscordApplicationCommandLocalization nameLocalizations = null;
 				DiscordApplicationCommandLocalization descriptionLocalizations = null;
 
 				if (translator != null)
 				{
 					var commandTranslation = translator.Single(c => c.Name == groupAttribute.Name);
 					if (commandTranslation != null)
 					{
 						nameLocalizations = commandTranslation.NameTranslations;
 						descriptionLocalizations = commandTranslation.DescriptionTranslations;
 					}
 				}
 
 				//Initializes the command
 				var payload = new DiscordApplicationCommand(groupAttribute.Name, groupAttribute.Description, defaultPermission: groupAttribute.DefaultPermission, nameLocalizations: nameLocalizations, descriptionLocalizations: descriptionLocalizations);
 				commandTypeSources.Add(new KeyValuePair<Type, Type>(type, type));
 
 				var commandmethods = new List<KeyValuePair<string, MethodInfo>>();
 				//Handles commands in the group
 				foreach (var submethod in submethods)
 				{
 					var commandAttribute = submethod.GetCustomAttribute<SlashCommandAttribute>();
 
 					//Gets the paramaters and accounts for InteractionContext
 					var parameters = submethod.GetParameters();
 					if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.First().ParameterType, typeof(InteractionContext)))
 						throw new ArgumentException($"The first argument must be an InteractionContext!");
 					parameters = parameters.Skip(1).ToArray();
 
 					var options = await ApplicationCommandsExtension.ParseParametersAsync(parameters, guildId);
 
 					DiscordApplicationCommandLocalization subNameLocalizations = null;
 					DiscordApplicationCommandLocalization subDescriptionLocalizations = null;
 					List<DiscordApplicationCommandOption> localizisedOptions = null;
 
 					var commandTranslation = translator?.Single(c => c.Name == payload.Name);
 
 					if (commandTranslation?.Commands != null)
 					{
 
 						var subCommandTranslation = commandTranslation.Commands.Single(sc => sc.Name == commandAttribute.Name);
 						if (subCommandTranslation.Options != null)
 						{
-							localizisedOptions = new(options.Count);
+							localizisedOptions = new List<DiscordApplicationCommandOption>(options.Count);
 							foreach (var option in options)
 							{
-								List<DiscordApplicationCommandOptionChoice> choices = option.Choices != null ? new(option.Choices.Count()) : null;
+								List<DiscordApplicationCommandOptionChoice> choices = option.Choices != null ? new List<DiscordApplicationCommandOptionChoice>(option.Choices.Count()) : null;
 								if (option.Choices != null)
 								{
 									foreach (var choice in option.Choices)
 									{
 										choices.Add(new DiscordApplicationCommandOptionChoice(choice.Name, choice.Value, subCommandTranslation.Options.Single(o => o.Name == option.Name).Choices.Single(c => c.Name == choice.Name).NameTranslations));
 									}
 								}
 
 								localizisedOptions.Add(new DiscordApplicationCommandOption(option.Name, option.Description, option.Type, option.Required,
 									choices, option.Options, option.ChannelTypes, option.AutoComplete, option.MinimumValue, option.MaximumValue,
 									subCommandTranslation.Options.Single(o => o.Name == option.Name).NameTranslations, subCommandTranslation.Options.Single(o => o.Name == option.Name).DescriptionTranslations
 								));
 							}
 						}
 
 						subNameLocalizations = subCommandTranslation.NameTranslations;
 						subDescriptionLocalizations = subCommandTranslation.DescriptionTranslations;
 					}
 
 
 					//Creates the subcommand and adds it to the main command
 					var subpayload = new DiscordApplicationCommandOption(commandAttribute.Name, commandAttribute.Description, ApplicationCommandOptionType.SubCommand, null, null, localizisedOptions ?? options, nameLocalizations: subNameLocalizations, descriptionLocalizations: subDescriptionLocalizations);
 					payload = new DiscordApplicationCommand(payload.Name, payload.Description, payload.Options?.Append(subpayload) ?? new[] { subpayload }, payload.DefaultPermission, nameLocalizations: payload.NameLocalizations, descriptionLocalizations: payload.DescriptionLocalizations);
 					commandTypeSources.Add(new KeyValuePair<Type, Type>(subclassinfo, type));
 
 					//Adds it to the method lists
 					commandmethods.Add(new KeyValuePair<string, MethodInfo>(commandAttribute.Name, submethod));
 					groupCommands.Add(new GroupCommand { Name = groupAttribute.Name, Methods = commandmethods });
 				}
 
 				var command = new SubGroupCommand { Name = groupAttribute.Name };
 				//Handles subgroups
 				foreach (var subclass in subclasses)
 				{
 					var subGroupAttribute = subclass.GetCustomAttribute<SlashCommandGroupAttribute>();
 					var subsubmethods = subclass.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null);
 
 					var options = new List<DiscordApplicationCommandOption>();
 
 					var currentMethods = new List<KeyValuePair<string, MethodInfo>>();
 
 
 					DiscordApplicationCommandLocalization subNameLocalizations = null;
 					DiscordApplicationCommandLocalization subDescriptionLocalizations = null;
 
 					if (translator != null)
 					{
 						var commandTranslation = translator.Single(c => c.Name == payload.Name);
 						if (commandTranslation != null && commandTranslation.SubGroups != null)
 						{
 
 							var subCommandTranslation = commandTranslation.SubGroups.Single(sc => sc.Name == subGroupAttribute.Name);
 
 							if (subCommandTranslation != null)
 							{
 								subNameLocalizations = subCommandTranslation.NameTranslations;
 								subDescriptionLocalizations = subCommandTranslation.DescriptionTranslations;
 							}
 						}
 					}
 
 					//Similar to the one for regular groups
 					foreach (var subsubmethod in subsubmethods)
 					{
 						var suboptions = new List<DiscordApplicationCommandOption>();
 						var commatt = subsubmethod.GetCustomAttribute<SlashCommandAttribute>();
 						var parameters = subsubmethod.GetParameters();
 						if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.First().ParameterType, typeof(InteractionContext)))
 							throw new ArgumentException($"The first argument must be an InteractionContext!");
 
 						parameters = parameters.Skip(1).ToArray();
 						suboptions = suboptions.Concat(await ApplicationCommandsExtension.ParseParametersAsync(parameters, guildId)).ToList();
 
 						DiscordApplicationCommandLocalization subSubNameLocalizations = null;
 						DiscordApplicationCommandLocalization subSubDescriptionLocalizations = null;
 						List<DiscordApplicationCommandOption> localizisedOptions = null;
 
 						var commandTranslation = translator?.Single(c => c.Name == payload.Name);
 
 						var subCommandTranslation = commandTranslation?.SubGroups?.Single(sc => sc.Name == commatt.Name);
 
 						var subSubCommandTranslation = subCommandTranslation?.Commands.Single(sc => sc.Name == commatt.Name);
 
 						if (subSubCommandTranslation != null && subSubCommandTranslation.Options != null)
 						{
-							localizisedOptions = new(suboptions.Count);
+							localizisedOptions = new List<DiscordApplicationCommandOption>(suboptions.Count);
 							foreach (var option in suboptions)
 							{
-								List<DiscordApplicationCommandOptionChoice> choices = option.Choices != null ? new(option.Choices.Count) : null;
+								List<DiscordApplicationCommandOptionChoice> choices = option.Choices != null ? new List<DiscordApplicationCommandOptionChoice>(option.Choices.Count) : null;
 								if (option.Choices != null)
 								{
 									foreach (var choice in option.Choices)
 									{
 										choices.Add(new DiscordApplicationCommandOptionChoice(choice.Name, choice.Value, subSubCommandTranslation.Options.Single(o => o.Name == option.Name).Choices.Single(c => c.Name == choice.Name).NameTranslations));
 									}
 								}
 
 								localizisedOptions.Add(new DiscordApplicationCommandOption(option.Name, option.Description, option.Type, option.Required,
 									choices, option.Options, option.ChannelTypes, option.AutoComplete, option.MinimumValue, option.MaximumValue,
 									subSubCommandTranslation.Options.Single(o => o.Name == option.Name).NameTranslations, subSubCommandTranslation.Options.Single(o => o.Name == option.Name).DescriptionTranslations
 								));
 							}
 
 							subSubNameLocalizations = subSubCommandTranslation.NameTranslations;
 							subSubDescriptionLocalizations = subSubCommandTranslation.DescriptionTranslations;
 						}
 
 						var subsubpayload = new DiscordApplicationCommandOption(commatt.Name, commatt.Description, ApplicationCommandOptionType.SubCommand, null, null, localizisedOptions ?? suboptions, nameLocalizations: subSubNameLocalizations, descriptionLocalizations: subSubDescriptionLocalizations);
 						options.Add(subsubpayload);
 						commandmethods.Add(new KeyValuePair<string, MethodInfo>(commatt.Name, subsubmethod));
 						currentMethods.Add(new KeyValuePair<string, MethodInfo>(commatt.Name, subsubmethod));
 					}
 
 					//Adds the group to the command and method lists
 					var subpayload = new DiscordApplicationCommandOption(subGroupAttribute.Name, subGroupAttribute.Description, ApplicationCommandOptionType.SubCommandGroup, null, null, options, nameLocalizations: subNameLocalizations, descriptionLocalizations: subDescriptionLocalizations);
 					command.SubCommands.Add(new GroupCommand { Name = subGroupAttribute.Name, Methods = currentMethods });
 					payload = new DiscordApplicationCommand(payload.Name, payload.Description, payload.Options?.Append(subpayload) ?? new[] { subpayload }, payload.DefaultPermission, nameLocalizations: payload.NameLocalizations, descriptionLocalizations: payload.DescriptionLocalizations);
 					commandTypeSources.Add(new KeyValuePair<Type, Type>(subclass, type));
 
 					//Accounts for lifespans for the sub group
 					if (subclass.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null && subclass.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
 					{
 						singletonModules.Add(ApplicationCommandsExtension.CreateInstance(subclass, ApplicationCommandsExtension.Configuration?.ServiceProvider));
 					}
 				}
 				if (command.SubCommands.Any()) subGroupCommands.Add(command);
 				commands.Add(payload);
 
 				//Accounts for lifespans
 				if (subclassinfo.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null && subclassinfo.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
 				{
 					singletonModules.Add(ApplicationCommandsExtension.CreateInstance(subclassinfo, ApplicationCommandsExtension.Configuration?.ServiceProvider));
 				}
 			}
 
 			return (commands, commandTypeSources, singletonModules, groupCommands, subGroupCommands);
 		}
 	}
 }
diff --git a/DisCatSharp.CommandsNext/CommandsNextConfiguration.cs b/DisCatSharp.CommandsNext/CommandsNextConfiguration.cs
index aab2f2755..cc5fae289 100644
--- a/DisCatSharp.CommandsNext/CommandsNextConfiguration.cs
+++ b/DisCatSharp.CommandsNext/CommandsNextConfiguration.cs
@@ -1,159 +1,159 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.CommandsNext.Attributes;
 using DisCatSharp.Entities;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.CommandsNext
 {
 	/// <summary>
 	/// <para>Represents a delegate for a function that takes a message, and returns the position of the start of command invocation in the message. It has to return -1 if prefix is not present.</para>
 	/// <para>
 	/// It is recommended that helper methods <see cref="CommandsNextUtilities.GetStringPrefixLength(DiscordMessage, string, StringComparison)"/> and <see cref="CommandsNextUtilities.GetMentionPrefixLength(DiscordMessage, DiscordUser)"/>
 	/// be used internally for checking. Their output can be passed through.
 	/// </para>
 	/// </summary>
 	/// <param name="msg">Message to check for prefix.</param>
 	/// <returns>Position of the command invocation or -1 if not present.</returns>
 	public delegate Task<int> PrefixResolverDelegate(DiscordMessage msg);
 
 	/// <summary>
 	/// Represents a configuration for <see cref="CommandsNextExtension"/>.
 	/// </summary>
 	public sealed class CommandsNextConfiguration
 	{
 		/// <summary>
 		/// <para>Sets the string prefixes used for commands.</para>
 		/// <para>Defaults to no value (disabled).</para>
 		/// </summary>
 		public IEnumerable<string> StringPrefixes { internal get; set; }
 
 		/// <summary>
 		/// <para>Sets the custom prefix resolver used for commands.</para>
 		/// <para>Defaults to none (disabled).</para>
 		/// </summary>
-		public PrefixResolverDelegate PrefixResolver { internal get; set; } = null;
+		public PrefixResolverDelegate PrefixResolver { internal get; set; }
 
 		/// <summary>
 		/// <para>Sets whether to allow mentioning the bot to be used as command prefix.</para>
 		/// <para>Defaults to true.</para>
 		/// </summary>
 		public bool EnableMentionPrefix { internal get; set; } = true;
 
 		/// <summary>
 		/// <para>Sets whether strings should be matched in a case-sensitive manner.</para>
 		/// <para>This switch affects the behaviour of default prefix resolver, command searching, and argument conversion.</para>
 		/// <para>Defaults to false.</para>
 		/// </summary>
-		public bool CaseSensitive { internal get; set; } = false;
+		public bool CaseSensitive { internal get; set; }
 
 		/// <summary>
 		/// <para>Sets whether to enable default help command.</para>
 		/// <para>Disabling this will allow you to make your own help command.</para>
 		/// <para>
 		/// Modifying default help can be achieved via custom help formatters (see <see cref="DisCatSharp.CommandsNext.Converters.BaseHelpFormatter"/> and <see cref="CommandsNextExtension.SetHelpFormatter{T}()"/> for more details).
 		/// It is recommended to use help formatter instead of disabling help.
 		/// </para>
 		/// <para>Defaults to true.</para>
 		/// </summary>
 		public bool EnableDefaultHelp { internal get; set; } = true;
 
 		/// <summary>
 		/// <para>Controls whether the default help will be sent via DMs or not.</para>
 		/// <para>Enabling this will make the bot respond with help via direct messages.</para>
 		/// <para>Defaults to false.</para>
 		/// </summary>
-		public bool DmHelp { internal get; set; } = false;
+		public bool DmHelp { internal get; set; }
 
 		/// <summary>
 		/// <para>Sets the default pre-execution checks for the built-in help command.</para>
 		/// <para>Only applicable if default help is enabled.</para>
 		/// <para>Defaults to null.</para>
 		/// </summary>
-		public IEnumerable<CheckBaseAttribute> DefaultHelpChecks { internal get; set; } = null;
+		public IEnumerable<CheckBaseAttribute> DefaultHelpChecks { internal get; set; }
 
 		/// <summary>
 		/// <para>Sets whether commands sent via direct messages should be processed.</para>
 		/// <para>Defaults to true.</para>
 		/// </summary>
 		public bool EnableDms { internal get; set; } = true;
 
 		/// <summary>
 		/// <para>Sets the service provider for this CommandsNext instance.</para>
 		/// <para>Objects in this provider are used when instantiating command modules. This allows passing data around without resorting to static members.</para>
 		/// <para>Defaults to null.</para>
 		/// </summary>
 		public IServiceProvider ServiceProvider { internal get; set; } = new ServiceCollection().BuildServiceProvider(true);
 
 		/// <summary>
 		/// <para>Gets whether any extra arguments passed to commands should be ignored or not. If this is set to false, extra arguments will throw, otherwise they will be ignored.</para>
 		/// <para>Defaults to false.</para>
 		/// </summary>
-		public bool IgnoreExtraArguments { internal get; set; } = false;
+		public bool IgnoreExtraArguments { internal get; set; }
 
 		/// <summary>
 		/// <para>Gets or sets whether to automatically enable handling commands.</para>
 		/// <para>If this is set to false, you will need to manually handle each incoming message and pass it to CommandsNext.</para>
 		/// <para>Defaults to true.</para>
 		/// </summary>
 		public bool UseDefaultCommandHandler { internal get; set; } = true;
 
 		/// <summary>
 		/// Creates a new instance of <see cref="CommandsNextConfiguration"/>.
 		/// </summary>
 		public CommandsNextConfiguration() { }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="CommandsNextConfiguration"/> class.
 		/// </summary>
 		/// <param name="provider">The service provider.</param>
 		[ActivatorUtilitiesConstructor]
 		public CommandsNextConfiguration(IServiceProvider provider)
 		{
 			this.ServiceProvider = provider;
 		}
 
 		/// <summary>
 		/// Creates a new instance of <see cref="CommandsNextConfiguration"/>, copying the properties of another configuration.
 		/// </summary>
 		/// <param name="other">Configuration the properties of which are to be copied.</param>
 		public CommandsNextConfiguration(CommandsNextConfiguration other)
 		{
 			this.CaseSensitive = other.CaseSensitive;
 			this.PrefixResolver = other.PrefixResolver;
 			this.DefaultHelpChecks = other.DefaultHelpChecks;
 			this.EnableDefaultHelp = other.EnableDefaultHelp;
 			this.EnableDms = other.EnableDms;
 			this.EnableMentionPrefix = other.EnableMentionPrefix;
 			this.IgnoreExtraArguments = other.IgnoreExtraArguments;
 			this.UseDefaultCommandHandler = other.UseDefaultCommandHandler;
 			this.ServiceProvider = other.ServiceProvider;
 			this.StringPrefixes = other.StringPrefixes?.ToArray();
 			this.DmHelp = other.DmHelp;
 		}
 	}
 }
diff --git a/DisCatSharp.CommandsNext/CommandsNextEvents.cs b/DisCatSharp.CommandsNext/CommandsNextEvents.cs
index 880eabebc..8de2c0b4e 100644
--- a/DisCatSharp.CommandsNext/CommandsNextEvents.cs
+++ b/DisCatSharp.CommandsNext/CommandsNextEvents.cs
@@ -1,42 +1,42 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.CommandsNext
 {
 	/// <summary>
 	/// Contains well-defined event IDs used by CommandsNext.
 	/// </summary>
 	public static class CommandsNextEvents
 	{
 		/// <summary>
 		/// Miscellaneous events, that do not fit in any other category.
 		/// </summary>
-		internal static EventId Misc { get; } = new EventId(200, "CommandsNext");
+		internal static EventId Misc { get; } = new(200, "CommandsNext");
 
 		/// <summary>
 		/// Events pertaining to Gateway Intents. Typically diagnostic information.
 		/// </summary>
-		internal static EventId Intents { get; } = new EventId(201, nameof(Intents));
+		internal static EventId Intents { get; } = new(201, nameof(Intents));
 	}
 }
diff --git a/DisCatSharp.CommandsNext/CommandsNextExtension.cs b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
index 47461404b..32eb0429e 100644
--- a/DisCatSharp.CommandsNext/CommandsNextExtension.cs
+++ b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
@@ -1,1083 +1,1083 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using DisCatSharp.CommandsNext.Attributes;
 using DisCatSharp.CommandsNext.Builders;
 using DisCatSharp.CommandsNext.Converters;
 using DisCatSharp.CommandsNext.Entities;
 using DisCatSharp.CommandsNext.Exceptions;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.CommandsNext
 {
 	/// <summary>
 	/// This is the class which handles command registration, management, and execution.
 	/// </summary>
 	public class CommandsNextExtension : BaseExtension
 	{
 		/// <summary>
 		/// Gets the config.
 		/// </summary>
 		private readonly CommandsNextConfiguration _config;
 
 		/// <summary>
 		/// Gets the help formatter.
 		/// </summary>
 		private readonly HelpFormatterFactory _helpFormatter;
 
 		/// <summary>
 		/// Gets the convert generic.
 		/// </summary>
 		private readonly MethodInfo _convertGeneric;
 
 		/// <summary>
 		/// Gets the user friendly type names.
 		/// </summary>
 		private readonly Dictionary<Type, string> _userFriendlyTypeNames;
 		/// <summary>
 		/// Gets the argument converters.
 		/// </summary>
 		internal Dictionary<Type, IArgumentConverter> ArgumentConverters { get; }
 
 		/// <summary>
 		/// Gets the service provider this CommandsNext module was configured with.
 		/// </summary>
 		public IServiceProvider Services
 			=> this._config.ServiceProvider;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="CommandsNextExtension"/> class.
 		/// </summary>
 		/// <param name="cfg">The cfg.</param>
 		internal CommandsNextExtension(CommandsNextConfiguration cfg)
 		{
 			this._config = new CommandsNextConfiguration(cfg);
 			this._topLevelCommands = new Dictionary<string, Command>();
 			this._registeredCommandsLazy = new Lazy<IReadOnlyDictionary<string, Command>>(() => new ReadOnlyDictionary<string, Command>(this._topLevelCommands));
 			this._helpFormatter = new HelpFormatterFactory();
 			this._helpFormatter.SetFormatterType<DefaultHelpFormatter>();
 
 			this.ArgumentConverters = new Dictionary<Type, IArgumentConverter>
 			{
 				[typeof(string)] = new StringConverter(),
 				[typeof(bool)] = new BoolConverter(),
 				[typeof(sbyte)] = new Int8Converter(),
 				[typeof(byte)] = new Uint8Converter(),
 				[typeof(short)] = new Int16Converter(),
 				[typeof(ushort)] = new Uint16Converter(),
 				[typeof(int)] = new Int32Converter(),
 				[typeof(uint)] = new Uint32Converter(),
 				[typeof(long)] = new Int64Converter(),
 				[typeof(ulong)] = new Uint64Converter(),
 				[typeof(float)] = new Float32Converter(),
 				[typeof(double)] = new Float64Converter(),
 				[typeof(decimal)] = new Float128Converter(),
 				[typeof(DateTime)] = new DateTimeConverter(),
 				[typeof(DateTimeOffset)] = new DateTimeOffsetConverter(),
 				[typeof(TimeSpan)] = new TimeSpanConverter(),
 				[typeof(Uri)] = new UriConverter(),
 				[typeof(DiscordUser)] = new DiscordUserConverter(),
 				[typeof(DiscordMember)] = new DiscordMemberConverter(),
 				[typeof(DiscordRole)] = new DiscordRoleConverter(),
 				[typeof(DiscordChannel)] = new DiscordChannelConverter(),
 				[typeof(DiscordGuild)] = new DiscordGuildConverter(),
 				[typeof(DiscordMessage)] = new DiscordMessageConverter(),
 				[typeof(DiscordEmoji)] = new DiscordEmojiConverter(),
 				[typeof(DiscordThreadChannel)] = new DiscordThreadChannelConverter(),
 				[typeof(DiscordInvite)] = new DiscordInviteConverter(),
 				[typeof(DiscordColor)] = new DiscordColorConverter(),
 				[typeof(DiscordScheduledEvent)] = new DiscordScheduledEventConverter(),
 			};
 
 			this._userFriendlyTypeNames = new Dictionary<Type, string>()
 			{
 				[typeof(string)] = "string",
 				[typeof(bool)] = "boolean",
 				[typeof(sbyte)] = "signed byte",
 				[typeof(byte)] = "byte",
 				[typeof(short)] = "short",
 				[typeof(ushort)] = "unsigned short",
 				[typeof(int)] = "int",
 				[typeof(uint)] = "unsigned int",
 				[typeof(long)] = "long",
 				[typeof(ulong)] = "unsigned long",
 				[typeof(float)] = "float",
 				[typeof(double)] = "double",
 				[typeof(decimal)] = "decimal",
 				[typeof(DateTime)] = "date and time",
 				[typeof(DateTimeOffset)] = "date and time",
 				[typeof(TimeSpan)] = "time span",
 				[typeof(Uri)] = "URL",
 				[typeof(DiscordUser)] = "user",
 				[typeof(DiscordMember)] = "member",
 				[typeof(DiscordRole)] = "role",
 				[typeof(DiscordChannel)] = "channel",
 				[typeof(DiscordGuild)] = "guild",
 				[typeof(DiscordMessage)] = "message",
 				[typeof(DiscordEmoji)] = "emoji",
 				[typeof(DiscordThreadChannel)] = "thread",
 				[typeof(DiscordInvite)] = "invite",
 				[typeof(DiscordColor)] = "color",
 				[typeof(DiscordScheduledEvent)] = "event"
 			};
 
 			var ncvt = typeof(NullableConverter<>);
 			var nt = typeof(Nullable<>);
 			var cvts = this.ArgumentConverters.Keys.ToArray();
 			foreach (var xt in cvts)
 			{
 				var xti = xt.GetTypeInfo();
 				if (!xti.IsValueType)
 					continue;
 
 				var xcvt = ncvt.MakeGenericType(xt);
 				var xnt = nt.MakeGenericType(xt);
 				if (this.ArgumentConverters.ContainsKey(xcvt))
 					continue;
 
 				var xcv = Activator.CreateInstance(xcvt) as IArgumentConverter;
 				this.ArgumentConverters[xnt] = xcv;
 				this._userFriendlyTypeNames[xnt] = this._userFriendlyTypeNames[xt];
 			}
 
 			var t = typeof(CommandsNextExtension);
 			var ms = t.GetTypeInfo().DeclaredMethods;
 			var m = ms.FirstOrDefault(xm => xm.Name == "ConvertArgument" && xm.ContainsGenericParameters && !xm.IsStatic && xm.IsPublic);
 			this._convertGeneric = m;
 		}
 
 		/// <summary>
 		/// Sets the help formatter to use with the default help command.
 		/// </summary>
 		/// <typeparam name="T">Type of the formatter to use.</typeparam>
 		public void SetHelpFormatter<T>() where T : BaseHelpFormatter => this._helpFormatter.SetFormatterType<T>();
 
 		#region DiscordClient Registration
 		/// <summary>
 		/// DO NOT USE THIS MANUALLY.
 		/// </summary>
 		/// <param name="client">DO NOT USE THIS MANUALLY.</param>
 		/// <exception cref="System.InvalidOperationException"/>
 		protected internal override void Setup(DiscordClient client)
 		{
 			if (this.Client != null)
 				throw new InvalidOperationException("What did I tell you?");
 
 			this.Client = client;
 
 			this._executed = new AsyncEvent<CommandsNextExtension, CommandExecutionEventArgs>("COMMAND_EXECUTED", TimeSpan.Zero, this.Client.EventErrorHandler);
 			this._error = new AsyncEvent<CommandsNextExtension, CommandErrorEventArgs>("COMMAND_ERRORED", TimeSpan.Zero, this.Client.EventErrorHandler);
 
 			if (this._config.UseDefaultCommandHandler)
 				this.Client.MessageCreated += this.HandleCommandsAsync;
 			else
 				this.Client.Logger.LogWarning(CommandsNextEvents.Misc, "Not attaching default command handler - if this is intentional, you can ignore this message");
 
 			if (this._config.EnableDefaultHelp)
 			{
 				this.RegisterCommands(typeof(DefaultHelpModule), null, null, out var tcmds);
 
 				if (this._config.DefaultHelpChecks != null)
 				{
 					var checks = this._config.DefaultHelpChecks.ToArray();
 
 					for (var i = 0; i < tcmds.Count; i++)
 						tcmds[i].WithExecutionChecks(checks);
 				}
 
 				if (tcmds != null)
 					foreach (var xc in tcmds)
 						this.AddToCommandDictionary(xc.Build(null));
 			}
 
 		}
 		#endregion
 
 		#region Command Handling
 		/// <summary>
 		/// Handles the commands async.
 		/// </summary>
 		/// <param name="sender">The sender.</param>
 		/// <param name="e">The e.</param>
 		/// <returns>A Task.</returns>
 		private async Task HandleCommandsAsync(DiscordClient sender, MessageCreateEventArgs e)
 		{
 			if (e.Author.IsBot) // bad bot
 				return;
 
 			if (!this._config.EnableDms && e.Channel.IsPrivate)
 				return;
 
 			var mpos = -1;
 			if (this._config.EnableMentionPrefix)
 				mpos = e.Message.GetMentionPrefixLength(this.Client.CurrentUser);
 
 			if (this._config.StringPrefixes?.Any() == true)
 				foreach (var pfix in this._config.StringPrefixes)
 					if (mpos == -1 && !string.IsNullOrWhiteSpace(pfix))
 						mpos = e.Message.GetStringPrefixLength(pfix, this._config.CaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase);
 
 			if (mpos == -1 && this._config.PrefixResolver != null)
 				mpos = await this._config.PrefixResolver(e.Message).ConfigureAwait(false);
 
 			if (mpos == -1)
 				return;
 
 			var pfx = e.Message.Content[..mpos];
 			var cnt = e.Message.Content[mpos..];
 
 			var __ = 0;
 			var fname = cnt.ExtractNextArgument(ref __);
 
 			var cmd = this.FindCommand(cnt, out var args);
 			var ctx = this.CreateContext(e.Message, pfx, cmd, args);
 			if (cmd == null)
 			{
 				await this._error.InvokeAsync(this, new CommandErrorEventArgs(this.Client.ServiceProvider) { Context = ctx, Exception = new CommandNotFoundException(fname) }).ConfigureAwait(false);
 				return;
 			}
 
 			_ = Task.Run(async () => await this.ExecuteCommandAsync(ctx).ConfigureAwait(false));
 		}
 
 		/// <summary>
 		/// Finds a specified command by its qualified name, then separates arguments.
 		/// </summary>
 		/// <param name="commandString">Qualified name of the command, optionally with arguments.</param>
 		/// <param name="rawArguments">Separated arguments.</param>
 		/// <returns>Found command or null if none was found.</returns>
 		public Command FindCommand(string commandString, out string rawArguments)
 		{
 			rawArguments = null;
 
 			var ignoreCase = !this._config.CaseSensitive;
 			var pos = 0;
 			var next = commandString.ExtractNextArgument(ref pos);
 			if (next == null)
 				return null;
 
 			if (!this.RegisteredCommands.TryGetValue(next, out var cmd))
 			{
 				if (!ignoreCase)
 					return null;
 
 				next = next.ToLowerInvariant();
 				var cmdKvp = this.RegisteredCommands.FirstOrDefault(x => x.Key.ToLowerInvariant() == next);
 				if (cmdKvp.Value == null)
 					return null;
 
 				cmd = cmdKvp.Value;
 			}
 
 			if (cmd is not CommandGroup)
 			{
 				rawArguments = commandString[pos..].Trim();
 				return cmd;
 			}
 
 			while (cmd is CommandGroup)
 			{
 				var cm2 = cmd as CommandGroup;
 				var oldPos = pos;
 				next = commandString.ExtractNextArgument(ref pos);
 				if (next == null)
 					break;
 
 				if (ignoreCase)
 				{
 					next = next.ToLowerInvariant();
 					cmd = cm2.Children.FirstOrDefault(x => x.Name.ToLowerInvariant() == next || x.Aliases?.Any(xx => xx.ToLowerInvariant() == next) == true);
 				}
 				else
 				{
 					cmd = cm2.Children.FirstOrDefault(x => x.Name == next || x.Aliases?.Contains(next) == true);
 				}
 
 				if (cmd == null)
 				{
 					cmd = cm2;
 					pos = oldPos;
 					break;
 				}
 			}
 
 			rawArguments = commandString[pos..].Trim();
 			return cmd;
 		}
 
 		/// <summary>
 		/// Creates a command execution context from specified arguments.
 		/// </summary>
 		/// <param name="msg">Message to use for context.</param>
 		/// <param name="prefix">Command prefix, used to execute commands.</param>
 		/// <param name="cmd">Command to execute.</param>
 		/// <param name="rawArguments">Raw arguments to pass to command.</param>
 		/// <returns>Created command execution context.</returns>
 		public CommandContext CreateContext(DiscordMessage msg, string prefix, Command cmd, string rawArguments = null)
 		{
 			var ctx = new CommandContext
 			{
 				Client = this.Client,
 				Command = cmd,
 				Message = msg,
 				Config = this._config,
 				RawArgumentString = rawArguments ?? "",
 				Prefix = prefix,
 				CommandsNext = this,
 				Services = this.Services
 			};
 
 			if (cmd != null && (cmd.Module is TransientCommandModule || cmd.Module == null))
 			{
 				var scope = ctx.Services.CreateScope();
 				ctx.ServiceScopeContext = new CommandContext.ServiceContext(ctx.Services, scope);
 				ctx.Services = scope.ServiceProvider;
 			}
 
 			return ctx;
 		}
 
 		/// <summary>
 		/// Executes specified command from given context.
 		/// </summary>
 		/// <param name="ctx">Context to execute command from.</param>
 		/// <returns></returns>
 		public async Task ExecuteCommandAsync(CommandContext ctx)
 		{
 			try
 			{
 				var cmd = ctx.Command;
 				await this.RunAllChecksAsync(cmd, ctx).ConfigureAwait(false);
 
 				var res = await cmd.ExecuteAsync(ctx).ConfigureAwait(false);
 
 				if (res.IsSuccessful)
 					await this._executed.InvokeAsync(this, new CommandExecutionEventArgs(this.Client.ServiceProvider) { Context = res.Context }).ConfigureAwait(false);
 				else
 					await this._error.InvokeAsync(this, new CommandErrorEventArgs(this.Client.ServiceProvider) { Context = res.Context, Exception = res.Exception }).ConfigureAwait(false);
 			}
 			catch (Exception ex)
 			{
 				await this._error.InvokeAsync(this, new CommandErrorEventArgs(this.Client.ServiceProvider) { Context = ctx, Exception = ex }).ConfigureAwait(false);
 			}
 			finally
 			{
 				if (ctx.ServiceScopeContext.IsInitialized)
 					ctx.ServiceScopeContext.Dispose();
 			}
 		}
 
 		/// <summary>
 		/// Runs the all checks async.
 		/// </summary>
 		/// <param name="cmd">The cmd.</param>
 		/// <param name="ctx">The ctx.</param>
 		/// <returns>A Task.</returns>
 		private async Task RunAllChecksAsync(Command cmd, CommandContext ctx)
 		{
 			if (cmd.Parent != null)
 				await this.RunAllChecksAsync(cmd.Parent, ctx).ConfigureAwait(false);
 
 			var fchecks = await cmd.RunChecksAsync(ctx, false).ConfigureAwait(false);
 			if (fchecks.Any())
 				throw new ChecksFailedException(cmd, ctx, fchecks);
 		}
 		#endregion
 
 		#region Command Registration
 		/// <summary>
 		/// Gets a dictionary of registered top-level commands.
 		/// </summary>
 		public IReadOnlyDictionary<string, Command> RegisteredCommands
 			=> this._registeredCommandsLazy.Value;
 
 		/// <summary>
 		/// Gets or sets the top level commands.
 		/// </summary>
 		private readonly Dictionary<string, Command> _topLevelCommands;
 		private readonly Lazy<IReadOnlyDictionary<string, Command>> _registeredCommandsLazy;
 
 		/// <summary>
 		/// Registers all commands from a given assembly. The command classes need to be public to be considered for registration.
 		/// </summary>
 		/// <param name="assembly">Assembly to register commands from.</param>
 		public void RegisterCommands(Assembly assembly)
 		{
 			var types = assembly.ExportedTypes.Where(xt =>
 			{
 				var xti = xt.GetTypeInfo();
 				return xti.IsModuleCandidateType() && !xti.IsNested;
 			});
 			foreach (var xt in types)
 				this.RegisterCommands(xt);
 		}
 
 		/// <summary>
 		/// Registers all commands from a given command class.
 		/// </summary>
 		/// <typeparam name="T">Class which holds commands to register.</typeparam>
 		public void RegisterCommands<T>() where T : BaseCommandModule
 		{
 			var t = typeof(T);
 			this.RegisterCommands(t);
 		}
 
 		/// <summary>
 		/// Registers all commands from a given command class.
 		/// </summary>
 		/// <param name="t">Type of the class which holds commands to register.</param>
 		public void RegisterCommands(Type t)
 		{
 			if (t == null)
 				throw new ArgumentNullException(nameof(t), "Type cannot be null.");
 
 			if (!t.IsModuleCandidateType())
 				throw new ArgumentNullException(nameof(t), "Type must be a class, which cannot be abstract or static.");
 
 			this.RegisterCommands(t, null, null, out var tempCommands);
 
 			if (tempCommands != null)
 				foreach (var command in tempCommands)
 					this.AddToCommandDictionary(command.Build(null));
 		}
 
 		/// <summary>
 		/// Registers the commands.
 		/// </summary>
 		/// <param name="t">The type.</param>
 		/// <param name="currentParent">The current parent.</param>
 		/// <param name="inheritedChecks">The inherited checks.</param>
 		/// <param name="foundCommands">The found commands.</param>
 		private void RegisterCommands(Type t, CommandGroupBuilder currentParent, IEnumerable<CheckBaseAttribute> inheritedChecks, out List<CommandBuilder> foundCommands)
 		{
 			var ti = t.GetTypeInfo();
 
 			var lifespan = ti.GetCustomAttribute<ModuleLifespanAttribute>();
 			var moduleLifespan = lifespan != null ? lifespan.Lifespan : ModuleLifespan.Singleton;
 
 			var module = new CommandModuleBuilder()
 				.WithType(t)
 				.WithLifespan(moduleLifespan)
 				.Build(this.Services);
 
 			// restrict parent lifespan to more or equally restrictive
 			if (currentParent?.Module is TransientCommandModule && moduleLifespan != ModuleLifespan.Transient)
 				throw new InvalidOperationException("In a transient module, child modules can only be transient.");
 
 			// check if we are anything
 			var groupBuilder = new CommandGroupBuilder(module);
 			var isModule = false;
 			var moduleAttributes = ti.GetCustomAttributes();
 			var moduleHidden = false;
 			var moduleChecks = new List<CheckBaseAttribute>();
 
 			foreach (var xa in moduleAttributes)
 			{
 				switch (xa)
 				{
 					case GroupAttribute g:
 						isModule = true;
 						var moduleName = g.Name;
 						if (moduleName == null)
 						{
 							moduleName = ti.Name;
 
 							if (moduleName.EndsWith("Group") && moduleName != "Group")
 								moduleName = moduleName[0..^5];
 							else if (moduleName.EndsWith("Module") && moduleName != "Module")
 								moduleName = moduleName[0..^6];
 							else if (moduleName.EndsWith("Commands") && moduleName != "Commands")
 								moduleName = moduleName[0..^8];
 						}
 
 						if (!this._config.CaseSensitive)
 							moduleName = moduleName.ToLowerInvariant();
 
 						groupBuilder.WithName(moduleName);
 
 						if (inheritedChecks != null)
 							foreach (var chk in inheritedChecks)
 								groupBuilder.WithExecutionCheck(chk);
 
 						foreach (var mi in ti.DeclaredMethods.Where(x => x.IsCommandCandidate(out _) && x.GetCustomAttribute<GroupCommandAttribute>() != null))
 							groupBuilder.WithOverload(new CommandOverloadBuilder(mi));
 						break;
 
 					case AliasesAttribute a:
 						foreach (var xalias in a.Aliases)
 							groupBuilder.WithAlias(this._config.CaseSensitive ? xalias : xalias.ToLowerInvariant());
 						break;
 
 					case HiddenAttribute h:
 						groupBuilder.WithHiddenStatus(true);
 						moduleHidden = true;
 						break;
 
 					case DescriptionAttribute d:
 						groupBuilder.WithDescription(d.Description);
 						break;
 
 					case CheckBaseAttribute c:
 						moduleChecks.Add(c);
 						groupBuilder.WithExecutionCheck(c);
 						break;
 
 					default:
 						groupBuilder.WithCustomAttribute(xa);
 						break;
 				}
 			}
 
 			if (!isModule)
 			{
 				groupBuilder = null;
 				if (inheritedChecks != null)
 					moduleChecks.AddRange(inheritedChecks);
 			}
 
 			// candidate methods
 			var methods = ti.DeclaredMethods;
 			var commands = new List<CommandBuilder>();
 			var commandBuilders = new Dictionary<string, CommandBuilder>();
 			foreach (var m in methods)
 			{
 				if (!m.IsCommandCandidate(out _))
 					continue;
 
 				var attrs = m.GetCustomAttributes();
 				if (attrs.FirstOrDefault(xa => xa is CommandAttribute) is not CommandAttribute cattr)
 					continue;
 
 				var commandName = cattr.Name;
 				if (commandName == null)
 				{
 					commandName = m.Name;
 					if (commandName.EndsWith("Async") && commandName != "Async")
 						commandName = commandName[0..^5];
 				}
 
 				if (!this._config.CaseSensitive)
 					commandName = commandName.ToLowerInvariant();
 
 				if (!commandBuilders.TryGetValue(commandName, out var commandBuilder))
 				{
 					commandBuilders.Add(commandName, commandBuilder = new CommandBuilder(module).WithName(commandName));
 
 					if (!isModule)
 						if (currentParent != null)
 							currentParent.WithChild(commandBuilder);
 						else
 							commands.Add(commandBuilder);
 					else
 						groupBuilder.WithChild(commandBuilder);
 				}
 
 				commandBuilder.WithOverload(new CommandOverloadBuilder(m));
 
 				if (!isModule && moduleChecks.Any())
 					foreach (var chk in moduleChecks)
 						commandBuilder.WithExecutionCheck(chk);
 
 				foreach (var xa in attrs)
 				{
 					switch (xa)
 					{
 						case AliasesAttribute a:
 							foreach (var xalias in a.Aliases)
 								commandBuilder.WithAlias(this._config.CaseSensitive ? xalias : xalias.ToLowerInvariant());
 							break;
 
 						case CheckBaseAttribute p:
 							commandBuilder.WithExecutionCheck(p);
 							break;
 
 						case DescriptionAttribute d:
 							commandBuilder.WithDescription(d.Description);
 							break;
 
 						case HiddenAttribute h:
 							commandBuilder.WithHiddenStatus(true);
 							break;
 
 						default:
 							commandBuilder.WithCustomAttribute(xa);
 							break;
 					}
 				}
 
 				if (!isModule && moduleHidden)
 					commandBuilder.WithHiddenStatus(true);
 			}
 
 			// candidate types
 			var types = ti.DeclaredNestedTypes
 				.Where(xt => xt.IsModuleCandidateType() && xt.DeclaredConstructors.Any(xc => xc.IsPublic));
 			foreach (var type in types)
 			{
 				this.RegisterCommands(type.AsType(),
 					groupBuilder,
 					!isModule ? moduleChecks : null,
 					out var tempCommands);
 
 				if (isModule)
 					foreach (var chk in moduleChecks)
 						groupBuilder.WithExecutionCheck(chk);
 
 				if (isModule && tempCommands != null)
 					foreach (var xtcmd in tempCommands)
 						groupBuilder.WithChild(xtcmd);
 				else if (tempCommands != null)
 					commands.AddRange(tempCommands);
 			}
 
 			if (isModule && currentParent == null)
 				commands.Add(groupBuilder);
 			else if (isModule)
 				currentParent.WithChild(groupBuilder);
 			foundCommands = commands;
 		}
 
 		/// <summary>
 		/// Builds and registers all supplied commands.
 		/// </summary>
 		/// <param name="cmds">Commands to build and register.</param>
 		public void RegisterCommands(params CommandBuilder[] cmds)
 		{
 			foreach (var cmd in cmds)
 				this.AddToCommandDictionary(cmd.Build(null));
 		}
 
 		/// <summary>
 		/// Unregisters specified commands from CommandsNext.
 		/// </summary>
 		/// <param name="cmds">Commands to unregister.</param>
 		public void UnregisterCommands(params Command[] cmds)
 		{
 			if (cmds.Any(x => x.Parent != null))
 				throw new InvalidOperationException("Cannot unregister nested commands.");
 
 			var keys = this.RegisteredCommands.Where(x => cmds.Contains(x.Value)).Select(x => x.Key).ToList();
 			foreach (var key in keys)
 				this._topLevelCommands.Remove(key);
 		}
 
 		/// <summary>
 		/// Adds the to command dictionary.
 		/// </summary>
 		/// <param name="cmd">The cmd.</param>
 		private void AddToCommandDictionary(Command cmd)
 		{
 			if (cmd.Parent != null)
 				return;
 
 			if (this._topLevelCommands.ContainsKey(cmd.Name) || (cmd.Aliases != null && cmd.Aliases.Any(xs => this._topLevelCommands.ContainsKey(xs))))
 				throw new DuplicateCommandException(cmd.QualifiedName);
 
 			this._topLevelCommands[cmd.Name] = cmd;
 			if (cmd.Aliases != null)
 				foreach (var xs in cmd.Aliases)
 					this._topLevelCommands[xs] = cmd;
 		}
 		#endregion
 
 		#region Default Help
 		/// <summary>
 		/// Represents the default help module.
 		/// </summary>
 		[ModuleLifespan(ModuleLifespan.Transient)]
 		public class DefaultHelpModule : BaseCommandModule
 		{
 			/// <summary>
 			/// Defaults the help async.
 			/// </summary>
 			/// <param name="ctx">The ctx.</param>
 			/// <param name="command">The command.</param>
 			/// <returns>A Task.</returns>
 			[Command("help"), Description("Displays command help.")]
 			public async Task DefaultHelpAsync(CommandContext ctx, [Description("Command to provide help for.")] params string[] command)
 			{
 				var topLevel = ctx.CommandsNext._topLevelCommands.Values.Distinct();
 				var helpBuilder = ctx.CommandsNext._helpFormatter.Create(ctx);
 
 				if (command != null && command.Any())
 				{
 					Command cmd = null;
 					var searchIn = topLevel;
 					foreach (var c in command)
 					{
 						if (searchIn == null)
 						{
 							cmd = null;
 							break;
 						}
 
 						cmd = ctx.Config.CaseSensitive
 							? searchIn.FirstOrDefault(xc => xc.Name == c || (xc.Aliases != null && xc.Aliases.Contains(c)))
 							: searchIn.FirstOrDefault(xc => xc.Name.ToLowerInvariant() == c.ToLowerInvariant() || (xc.Aliases != null && xc.Aliases.Select(xs => xs.ToLowerInvariant()).Contains(c.ToLowerInvariant())));
 
 						if (cmd == null)
 							break;
 
 						var failedChecks = await cmd.RunChecksAsync(ctx, true).ConfigureAwait(false);
 						if (failedChecks.Any())
 							throw new ChecksFailedException(cmd, ctx, failedChecks);
 
 						searchIn = cmd is CommandGroup ? (cmd as CommandGroup).Children : null;
 					}
 
 					if (cmd == null)
 						throw new CommandNotFoundException(string.Join(" ", command));
 
 					helpBuilder.WithCommand(cmd);
 
 					if (cmd is CommandGroup group)
 					{
 						var commandsToSearch = group.Children.Where(xc => !xc.IsHidden);
 						var eligibleCommands = new List<Command>();
 						foreach (var candidateCommand in commandsToSearch)
 						{
 							if (candidateCommand.ExecutionChecks == null || !candidateCommand.ExecutionChecks.Any())
 							{
 								eligibleCommands.Add(candidateCommand);
 								continue;
 							}
 
 							var candidateFailedChecks = await candidateCommand.RunChecksAsync(ctx, true).ConfigureAwait(false);
 							if (!candidateFailedChecks.Any())
 								eligibleCommands.Add(candidateCommand);
 						}
 
 						if (eligibleCommands.Any())
 							helpBuilder.WithSubcommands(eligibleCommands.OrderBy(xc => xc.Name));
 					}
 				}
 				else
 				{
 					var commandsToSearch = topLevel.Where(xc => !xc.IsHidden);
 					var eligibleCommands = new List<Command>();
 					foreach (var sc in commandsToSearch)
 					{
 						if (sc.ExecutionChecks == null || !sc.ExecutionChecks.Any())
 						{
 							eligibleCommands.Add(sc);
 							continue;
 						}
 
 						var candidateFailedChecks = await sc.RunChecksAsync(ctx, true).ConfigureAwait(false);
 						if (!candidateFailedChecks.Any())
 							eligibleCommands.Add(sc);
 					}
 
 					if (eligibleCommands.Any())
 						helpBuilder.WithSubcommands(eligibleCommands.OrderBy(xc => xc.Name));
 				}
 
 				var helpMessage = helpBuilder.Build();
 
 				var builder = new DiscordMessageBuilder().WithContent(helpMessage.Content).WithEmbed(helpMessage.Embed);
 
 				if (!ctx.Config.DmHelp || ctx.Channel is DiscordDmChannel || ctx.Guild == null)
 					await ctx.RespondAsync(builder).ConfigureAwait(false);
 				else
 					await ctx.Member.SendMessageAsync(builder).ConfigureAwait(false);
 
 			}
 		}
 		#endregion
 
 		#region Sudo
 		/// <summary>
 		/// Creates a fake command context to execute commands with.
 		/// </summary>
 		/// <param name="actor">The user or member to use as message author.</param>
 		/// <param name="channel">The channel the message is supposed to appear from.</param>
 		/// <param name="messageContents">Contents of the message.</param>
 		/// <param name="prefix">Command prefix, used to execute commands.</param>
 		/// <param name="cmd">Command to execute.</param>
 		/// <param name="rawArguments">Raw arguments to pass to command.</param>
 		/// <returns>Created fake context.</returns>
 		public CommandContext CreateFakeContext(DiscordUser actor, DiscordChannel channel, string messageContents, string prefix, Command cmd, string rawArguments = null)
 		{
 			var epoch = new DateTimeOffset(2015, 1, 1, 0, 0, 0, TimeSpan.Zero);
 			var now = DateTimeOffset.UtcNow;
 			var timeSpan = (ulong)(now - epoch).TotalMilliseconds;
 
 			// create fake message
 			var msg = new DiscordMessage
 			{
 				Discord = this.Client,
 				Author = actor,
 				ChannelId = channel.Id,
 				Content = messageContents,
 				Id = timeSpan << 22,
 				Pinned = false,
 				MentionEveryone = messageContents.Contains("@everyone"),
 				IsTts = false,
 				AttachmentsInternal = new List<DiscordAttachment>(),
 				EmbedsInternal = new List<DiscordEmbed>(),
 				TimestampRaw = now.ToString("yyyy-MM-ddTHH:mm:sszzz"),
 				ReactionsInternal = new List<DiscordReaction>()
 			};
 
 			var mentionedUsers = new List<DiscordUser>();
 			var mentionedRoles = msg.Channel.Guild != null ? new List<DiscordRole>() : null;
 			var mentionedChannels = msg.Channel.Guild != null ? new List<DiscordChannel>() : null;
 
 			if (!string.IsNullOrWhiteSpace(msg.Content))
 			{
 				if (msg.Channel.Guild != null)
 				{
 					mentionedUsers = Utilities.GetUserMentions(msg).Select(xid => msg.Channel.Guild.MembersInternal.TryGetValue(xid, out var member) ? member : null).Cast<DiscordUser>().ToList();
 					mentionedRoles = Utilities.GetRoleMentions(msg).Select(xid => msg.Channel.Guild.GetRole(xid)).ToList();
 					mentionedChannels = Utilities.GetChannelMentions(msg).Select(xid => msg.Channel.Guild.GetChannel(xid)).ToList();
 				}
 				else
 				{
 					mentionedUsers = Utilities.GetUserMentions(msg).Select(this.Client.GetCachedOrEmptyUserInternal).ToList();
 				}
 			}
 
 			msg.MentionedUsersInternal = mentionedUsers;
 			msg.MentionedRolesInternal = mentionedRoles;
 			msg.MentionedChannelsInternal = mentionedChannels;
 
 			var ctx = new CommandContext
 			{
 				Client = this.Client,
 				Command = cmd,
 				Message = msg,
 				Config = this._config,
 				RawArgumentString = rawArguments ?? "",
 				Prefix = prefix,
 				CommandsNext = this,
 				Services = this.Services
 			};
 
 			if (cmd != null && (cmd.Module is TransientCommandModule || cmd.Module == null))
 			{
 				var scope = ctx.Services.CreateScope();
 				ctx.ServiceScopeContext = new CommandContext.ServiceContext(ctx.Services, scope);
 				ctx.Services = scope.ServiceProvider;
 			}
 
 			return ctx;
 		}
 		#endregion
 
 		#region Type Conversion
 		/// <summary>
 		/// Converts a string to specified type.
 		/// </summary>
 		/// <typeparam name="T">Type to convert to.</typeparam>
 		/// <param name="value">Value to convert.</param>
 		/// <param name="ctx">Context in which to convert to.</param>
 		/// <returns>Converted object.</returns>
 		public async Task<object> ConvertArgument<T>(string value, CommandContext ctx)
 		{
 			var t = typeof(T);
 			if (!this.ArgumentConverters.ContainsKey(t))
 				throw new ArgumentException("There is no converter specified for given type.", nameof(T));
 
 			if (this.ArgumentConverters[t] is not IArgumentConverter<T> cv)
 				throw new ArgumentException("Invalid converter registered for this type.", nameof(T));
 
 			var cvr = await cv.ConvertAsync(value, ctx).ConfigureAwait(false);
 			return !cvr.HasValue ? throw new ArgumentException("Could not convert specified value to given type.", nameof(value)) : cvr.Value;
 		}
 
 		/// <summary>
 		/// Converts a string to specified type.
 		/// </summary>
 		/// <param name="value">Value to convert.</param>
 		/// <param name="ctx">Context in which to convert to.</param>
 		/// <param name="type">Type to convert to.</param>
 		/// <returns>Converted object.</returns>
 		public async Task<object> ConvertArgument(string value, CommandContext ctx, Type type)
 		{
 			var m = this._convertGeneric.MakeGenericMethod(type);
 			try
 			{
 				return await (m.Invoke(this, new object[] { value, ctx }) as Task<object>).ConfigureAwait(false);
 			}
 			catch (TargetInvocationException ex)
 			{
 				throw ex.InnerException;
 			}
 		}
 
 		/// <summary>
 		/// Registers an argument converter for specified type.
 		/// </summary>
 		/// <typeparam name="T">Type for which to register the converter.</typeparam>
 		/// <param name="converter">Converter to register.</param>
 		public void RegisterConverter<T>(IArgumentConverter<T> converter)
 		{
 			if (converter == null)
 				throw new ArgumentNullException(nameof(converter), "Converter cannot be null.");
 
 			var t = typeof(T);
 			var ti = t.GetTypeInfo();
 			this.ArgumentConverters[t] = converter;
 
 			if (!ti.IsValueType)
 				return;
 
 			var nullableConverterType = typeof(NullableConverter<>).MakeGenericType(t);
 			var nullableType = typeof(Nullable<>).MakeGenericType(t);
 			if (this.ArgumentConverters.ContainsKey(nullableType))
 				return;
 
 			var nullableConverter = Activator.CreateInstance(nullableConverterType) as IArgumentConverter;
 			this.ArgumentConverters[nullableType] = nullableConverter;
 		}
 
 		/// <summary>
 		/// Unregisters an argument converter for specified type.
 		/// </summary>
 		/// <typeparam name="T">Type for which to unregister the converter.</typeparam>
 		public void UnregisterConverter<T>()
 		{
 			var t = typeof(T);
 			var ti = t.GetTypeInfo();
 			if (this.ArgumentConverters.ContainsKey(t))
 				this.ArgumentConverters.Remove(t);
 
 			if (this._userFriendlyTypeNames.ContainsKey(t))
 				this._userFriendlyTypeNames.Remove(t);
 
 			if (!ti.IsValueType)
 				return;
 
 			var nullableType = typeof(Nullable<>).MakeGenericType(t);
 			if (!this.ArgumentConverters.ContainsKey(nullableType))
 				return;
 
 			this.ArgumentConverters.Remove(nullableType);
 			this._userFriendlyTypeNames.Remove(nullableType);
 		}
 
 		/// <summary>
 		/// Registers a user-friendly type name.
 		/// </summary>
 		/// <typeparam name="T">Type to register the name for.</typeparam>
 		/// <param name="value">Name to register.</param>
 		public void RegisterUserFriendlyTypeName<T>(string value)
 		{
 			if (string.IsNullOrWhiteSpace(value))
 				throw new ArgumentNullException(nameof(value), "Name cannot be null or empty.");
 
 			var t = typeof(T);
 			var ti = t.GetTypeInfo();
 			if (!this.ArgumentConverters.ContainsKey(t))
 				throw new InvalidOperationException("Cannot register a friendly name for a type which has no associated converter.");
 
 			this._userFriendlyTypeNames[t] = value;
 
 			if (!ti.IsValueType)
 				return;
 
 			var nullableType = typeof(Nullable<>).MakeGenericType(t);
 			this._userFriendlyTypeNames[nullableType] = value;
 		}
 
 		/// <summary>
 		/// Converts a type into user-friendly type name.
 		/// </summary>
 		/// <param name="t">Type to convert.</param>
 		/// <returns>User-friendly type name.</returns>
 		public string GetUserFriendlyTypeName(Type t)
 		{
 			if (this._userFriendlyTypeNames.ContainsKey(t))
 				return this._userFriendlyTypeNames[t];
 
 			var ti = t.GetTypeInfo();
 			if (ti.IsGenericTypeDefinition && t.GetGenericTypeDefinition() == typeof(Nullable<>))
 			{
 				var tn = ti.GenericTypeArguments[0];
 				return this._userFriendlyTypeNames.ContainsKey(tn) ? this._userFriendlyTypeNames[tn] : tn.Name;
 			}
 
 			return t.Name;
 		}
 		#endregion
 
 		#region Helpers
 		/// <summary>
 		/// Gets the configuration-specific string comparer. This returns <see cref="StringComparer.Ordinal"/> or <see cref="StringComparer.OrdinalIgnoreCase"/>,
 		/// depending on whether <see cref="CommandsNextConfiguration.CaseSensitive"/> is set to <see langword="true"/> or <see langword="false"/>.
 		/// </summary>
 		/// <returns>A string comparer.</returns>
 		internal IEqualityComparer<string> GetStringComparer()
 			=> this._config.CaseSensitive
 				? StringComparer.Ordinal
 				: StringComparer.OrdinalIgnoreCase;
 		#endregion
 
 		#region Events
 		/// <summary>
 		/// Triggered whenever a command executes successfully.
 		/// </summary>
 		public event AsyncEventHandler<CommandsNextExtension, CommandExecutionEventArgs> CommandExecuted
 		{
-			add { this._executed.Register(value); }
-			remove { this._executed.Unregister(value); }
+			add => this._executed.Register(value);
+			remove => this._executed.Unregister(value);
 		}
 		private AsyncEvent<CommandsNextExtension, CommandExecutionEventArgs> _executed;
 
 		/// <summary>
 		/// Triggered whenever a command throws an exception during execution.
 		/// </summary>
 		public event AsyncEventHandler<CommandsNextExtension, CommandErrorEventArgs> CommandErrored
 		{
-			add { this._error.Register(value); }
-			remove { this._error.Unregister(value); }
+			add => this._error.Register(value);
+			remove => this._error.Unregister(value);
 		}
 		private AsyncEvent<CommandsNextExtension, CommandErrorEventArgs> _error;
 
 		/// <summary>
 		/// Ons the command executed.
 		/// </summary>
 		/// <param name="e">The e.</param>
 		/// <returns>A Task.</returns>
 		private Task OnCommandExecuted(CommandExecutionEventArgs e)
 			=> this._executed.InvokeAsync(this, e);
 
 		/// <summary>
 		/// Ons the command errored.
 		/// </summary>
 		/// <param name="e">The e.</param>
 		/// <returns>A Task.</returns>
 		private Task OnCommandErrored(CommandErrorEventArgs e)
 			=> this._error.InvokeAsync(this, e);
 		#endregion
 	}
 }
diff --git a/DisCatSharp.CommandsNext/Converters/NumericConverters.cs b/DisCatSharp.CommandsNext/Converters/NumericConverters.cs
index edfcdab83..876b8f969 100644
--- a/DisCatSharp.CommandsNext/Converters/NumericConverters.cs
+++ b/DisCatSharp.CommandsNext/Converters/NumericConverters.cs
@@ -1,244 +1,220 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Globalization;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 
 namespace DisCatSharp.CommandsNext.Converters
 {
 	/// <summary>
 	/// The bool converter.
 	/// </summary>
 	public class BoolConverter : IArgumentConverter<bool>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<bool>> IArgumentConverter<bool>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return bool.TryParse(value, out var result)
+		Task<Optional<bool>> IArgumentConverter<bool>.ConvertAsync(string value, CommandContext ctx) =>
+			bool.TryParse(value, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<bool>());
-		}
 	}
 
 	/// <summary>
 	/// The int8 converter.
 	/// </summary>
 	public class Int8Converter : IArgumentConverter<sbyte>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<sbyte>> IArgumentConverter<sbyte>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return sbyte.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<sbyte>> IArgumentConverter<sbyte>.ConvertAsync(string value, CommandContext ctx) =>
+			sbyte.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<sbyte>());
-		}
 	}
 
 	/// <summary>
 	/// The uint8 converter.
 	/// </summary>
 	public class Uint8Converter : IArgumentConverter<byte>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<byte>> IArgumentConverter<byte>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return byte.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<byte>> IArgumentConverter<byte>.ConvertAsync(string value, CommandContext ctx) =>
+			byte.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<byte>());
-		}
 	}
 
 	/// <summary>
 	/// The int16 converter.
 	/// </summary>
 	public class Int16Converter : IArgumentConverter<short>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<short>> IArgumentConverter<short>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return short.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<short>> IArgumentConverter<short>.ConvertAsync(string value, CommandContext ctx) =>
+			short.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<short>());
-		}
 	}
 
 	/// <summary>
 	/// The uint16 converter.
 	/// </summary>
 	public class Uint16Converter : IArgumentConverter<ushort>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<ushort>> IArgumentConverter<ushort>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return ushort.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<ushort>> IArgumentConverter<ushort>.ConvertAsync(string value, CommandContext ctx) =>
+			ushort.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<ushort>());
-		}
 	}
 
 	/// <summary>
 	/// The int32 converter.
 	/// </summary>
 	public class Int32Converter : IArgumentConverter<int>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<int>> IArgumentConverter<int>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<int>> IArgumentConverter<int>.ConvertAsync(string value, CommandContext ctx) =>
+			int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<int>());
-		}
 	}
 
 	/// <summary>
 	/// The uint32 converter.
 	/// </summary>
 	public class Uint32Converter : IArgumentConverter<uint>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<uint>> IArgumentConverter<uint>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return uint.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<uint>> IArgumentConverter<uint>.ConvertAsync(string value, CommandContext ctx) =>
+			uint.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<uint>());
-		}
 	}
 
 	/// <summary>
 	/// The int64 converter.
 	/// </summary>
 	public class Int64Converter : IArgumentConverter<long>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<long>> IArgumentConverter<long>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<long>> IArgumentConverter<long>.ConvertAsync(string value, CommandContext ctx) =>
+			long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<long>());
-		}
 	}
 
 	/// <summary>
 	/// The uint64 converter.
 	/// </summary>
 	public class Uint64Converter : IArgumentConverter<ulong>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<ulong>> IArgumentConverter<ulong>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<ulong>> IArgumentConverter<ulong>.ConvertAsync(string value, CommandContext ctx) =>
+			ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<ulong>());
-		}
 	}
 
 	/// <summary>
 	/// The float32 converter.
 	/// </summary>
 	public class Float32Converter : IArgumentConverter<float>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<float>> IArgumentConverter<float>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return float.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<float>> IArgumentConverter<float>.ConvertAsync(string value, CommandContext ctx) =>
+			float.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<float>());
-		}
 	}
 
 	/// <summary>
 	/// The float64 converter.
 	/// </summary>
 	public class Float64Converter : IArgumentConverter<double>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<double>> IArgumentConverter<double>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return double.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<double>> IArgumentConverter<double>.ConvertAsync(string value, CommandContext ctx) =>
+			double.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<double>());
-		}
 	}
 
 	/// <summary>
 	/// The float128 converter.
 	/// </summary>
 	public class Float128Converter : IArgumentConverter<decimal>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<decimal>> IArgumentConverter<decimal>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return decimal.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out var result)
+		Task<Optional<decimal>> IArgumentConverter<decimal>.ConvertAsync(string value, CommandContext ctx) =>
+			decimal.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<decimal>());
-		}
 	}
 }
diff --git a/DisCatSharp.CommandsNext/Converters/TimeConverters.cs b/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
index 3d479471f..84f83d8ba 100644
--- a/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
+++ b/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
@@ -1,145 +1,141 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Globalization;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DisCatSharp.Common.RegularExpressions;
 using DisCatSharp.Entities;
 
 namespace DisCatSharp.CommandsNext.Converters
 {
 	/// <summary>
 	/// Represents a date time converter.
 	/// </summary>
 	public class DateTimeConverter : IArgumentConverter<DateTime>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<DateTime>> IArgumentConverter<DateTime>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result)
+		Task<Optional<DateTime>> IArgumentConverter<DateTime>.ConvertAsync(string value, CommandContext ctx) =>
+			DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result)
 				? Task.FromResult(new Optional<DateTime>(result))
 				: Task.FromResult(Optional.FromNoValue<DateTime>());
-		}
 	}
 
 	/// <summary>
 	/// Represents a date time offset converter.
 	/// </summary>
 	public class DateTimeOffsetConverter : IArgumentConverter<DateTimeOffset>
 	{
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
-		Task<Optional<DateTimeOffset>> IArgumentConverter<DateTimeOffset>.ConvertAsync(string value, CommandContext ctx)
-		{
-			return DateTimeOffset.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result)
+		Task<Optional<DateTimeOffset>> IArgumentConverter<DateTimeOffset>.ConvertAsync(string value, CommandContext ctx) =>
+			DateTimeOffset.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result)
 				? Task.FromResult(Optional.FromValue(result))
 				: Task.FromResult(Optional.FromNoValue<DateTimeOffset>());
-		}
 	}
 
 	/// <summary>
 	/// Represents a time span converter.
 	/// </summary>
 	public class TimeSpanConverter : IArgumentConverter<TimeSpan>
 	{
 		/// <summary>
 		/// Gets or sets the time span regex.
 		/// </summary>
 		private static Regex s_timeSpanRegex { get; set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="TimeSpanConverter"/> class.
 		/// </summary>
 		static TimeSpanConverter()
 		{
 			s_timeSpanRegex = CommonRegEx.TimeSpan;
 		}
 
 		/// <summary>
 		/// Converts a string.
 		/// </summary>
 		/// <param name="value">The string to convert.</param>
 		/// <param name="ctx">The command context.</param>
 		Task<Optional<TimeSpan>> IArgumentConverter<TimeSpan>.ConvertAsync(string value, CommandContext ctx)
 		{
 			if (value == "0")
 				return Task.FromResult(Optional.FromValue(TimeSpan.Zero));
 
 			if (int.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out _))
 				return Task.FromResult(Optional.FromNoValue<TimeSpan>());
 
 			if (!ctx.Config.CaseSensitive)
 				value = value.ToLowerInvariant();
 
 			if (TimeSpan.TryParse(value, CultureInfo.InvariantCulture, out var result))
 				return Task.FromResult(Optional.FromValue(result));
 
 			var gps = new string[] { "days", "hours", "minutes", "seconds" };
 			var mtc = s_timeSpanRegex.Match(value);
 			if (!mtc.Success)
 				return Task.FromResult(Optional.FromNoValue<TimeSpan>());
 
 			var d = 0;
 			var h = 0;
 			var m = 0;
 			var s = 0;
 			foreach (var gp in gps)
 			{
 				var gpc = mtc.Groups[gp].Value;
 				if (string.IsNullOrWhiteSpace(gpc))
 					continue;
 
 				var gpt = gpc[^1];
 				int.TryParse(gpc[0..^1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var val);
 				switch (gpt)
 				{
 					case 'd':
 						d = val;
 						break;
 
 					case 'h':
 						h = val;
 						break;
 
 					case 'm':
 						m = val;
 						break;
 
 					case 's':
 						s = val;
 						break;
 				}
 			}
 			result = new TimeSpan(d, h, m, s);
 			return Task.FromResult(Optional.FromValue(result));
 		}
 	}
 }
diff --git a/DisCatSharp.CommandsNext/Entities/Builders/CommandModuleBuilder.cs b/DisCatSharp.CommandsNext/Entities/Builders/CommandModuleBuilder.cs
index 7da8deeba..359a3b3ef 100644
--- a/DisCatSharp.CommandsNext/Entities/Builders/CommandModuleBuilder.cs
+++ b/DisCatSharp.CommandsNext/Entities/Builders/CommandModuleBuilder.cs
@@ -1,89 +1,87 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using DisCatSharp.CommandsNext.Attributes;
 using DisCatSharp.CommandsNext.Entities;
 
 namespace DisCatSharp.CommandsNext.Builders
 {
 	/// <summary>
 	/// Represents an interface to build a command module.
 	/// </summary>
 	public sealed class CommandModuleBuilder
 	{
 		/// <summary>
 		/// Gets the type this build will construct a module out of.
 		/// </summary>
 		public Type Type { get; private set; }
 
 		/// <summary>
 		/// Gets the lifespan for the built module.
 		/// </summary>
 		public ModuleLifespan Lifespan { get; private set; }
 
 		/// <summary>
 		/// Creates a new command module builder.
 		/// </summary>
 		public CommandModuleBuilder()
 		{ }
 
 		/// <summary>
 		/// Sets the type this builder will construct a module out of.
 		/// </summary>
 		/// <param name="t">Type to build a module out of. It has to derive from <see cref="BaseCommandModule"/>.</param>
 		/// <returns>This builder.</returns>
 		public CommandModuleBuilder WithType(Type t)
 		{
 			if (!t.IsModuleCandidateType())
 				throw new ArgumentException("Specified type is not a valid module type.", nameof(t));
 
 			this.Type = t;
 			return this;
 		}
 
 		/// <summary>
 		/// Lifespan to give this module.
 		/// </summary>
 		/// <param name="lifespan">Lifespan for this module.</param>
 		/// <returns>This builder.</returns>
 		public CommandModuleBuilder WithLifespan(ModuleLifespan lifespan)
 		{
 			this.Lifespan = lifespan;
 			return this;
 		}
 
 		/// <summary>
 		/// Builds the command module.
 		/// </summary>
 		/// <param name="services">The services.</param>
-		internal ICommandModule Build(IServiceProvider services)
-		{
-			return this.Lifespan switch
+		internal ICommandModule Build(IServiceProvider services) =>
+			this.Lifespan switch
 			{
 				ModuleLifespan.Singleton => new SingletonCommandModule(this.Type, services),
 				ModuleLifespan.Transient => new TransientCommandModule(this.Type),
 				_ => throw new NotSupportedException("Module lifespans other than transient and singleton are not supported."),
 			};
-		}
 	}
 }
diff --git a/DisCatSharp.CommandsNext/Entities/Command.cs b/DisCatSharp.CommandsNext/Entities/Command.cs
index 8c381acc2..990595bd2 100644
--- a/DisCatSharp.CommandsNext/Entities/Command.cs
+++ b/DisCatSharp.CommandsNext/Entities/Command.cs
@@ -1,234 +1,232 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.CommandsNext.Attributes;
 using DisCatSharp.CommandsNext.Entities;
 
 namespace DisCatSharp.CommandsNext
 {
 	/// <summary>
 	/// Represents a command.
 	/// </summary>
 	public class Command
 	{
 		/// <summary>
 		/// Gets this command's name.
 		/// </summary>
 		public string Name { get; internal set; }
 
 		/// <summary>
 		/// Gets this command's qualified name (i.e. one that includes all module names).
 		/// </summary>
 		public string QualifiedName
 			=> this.Parent != null ? string.Concat(this.Parent.QualifiedName, " ", this.Name) : this.Name;
 
 		/// <summary>
 		/// Gets this command's aliases.
 		/// </summary>
 		public IReadOnlyList<string> Aliases { get; internal set; }
 
 		/// <summary>
 		/// Gets this command's parent module, if any.
 		/// </summary>
 		public CommandGroup Parent { get; internal set; }
 
 		/// <summary>
 		/// Gets this command's description.
 		/// </summary>
 		public string Description { get; internal set; }
 
 		/// <summary>
 		/// Gets whether this command is hidden.
 		/// </summary>
 		public bool IsHidden { get; internal set; }
 
 		/// <summary>
 		/// Gets a collection of pre-execution checks for this command.
 		/// </summary>
 		public IReadOnlyList<CheckBaseAttribute> ExecutionChecks { get; internal set; }
 
 		/// <summary>
 		/// Gets a collection of this command's overloads.
 		/// </summary>
 		public IReadOnlyList<CommandOverload> Overloads { get; internal set; }
 
 		/// <summary>
 		/// Gets the module in which this command is defined.
 		/// </summary>
 		public ICommandModule Module { get; internal set; }
 
 		/// <summary>
 		/// Gets the custom attributes defined on this command.
 		/// </summary>
 		public IReadOnlyList<Attribute> CustomAttributes { get; internal set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="Command"/> class.
 		/// </summary>
 		internal Command() { }
 
 		/// <summary>
 		/// Executes this command with specified context.
 		/// </summary>
 		/// <param name="ctx">Context to execute the command in.</param>
 		/// <returns>Command's execution results.</returns>
 		public virtual async Task<CommandResult> ExecuteAsync(CommandContext ctx)
 		{
 			CommandResult res = default;
 			try
 			{
 				var executed = false;
 				foreach (var ovl in this.Overloads.OrderByDescending(x => x.Priority))
 				{
 					ctx.Overload = ovl;
 					var args = await CommandsNextUtilities.BindArguments(ctx, ctx.Config.IgnoreExtraArguments).ConfigureAwait(false);
 
 					if (!args.IsSuccessful)
 						continue;
 
 					ctx.RawArguments = args.Raw;
 
 					var mdl = ovl.InvocationTarget ?? this.Module?.GetInstance(ctx.Services);
 					if (mdl is BaseCommandModule bcmBefore)
 						await bcmBefore.BeforeExecutionAsync(ctx).ConfigureAwait(false);
 
 					args.Converted[0] = mdl;
 					var ret = (Task)ovl.Callable.DynamicInvoke(args.Converted);
 					await ret.ConfigureAwait(false);
 					executed = true;
 					res = new CommandResult
 					{
 						IsSuccessful = true,
 						Context = ctx
 					};
 
 					if (mdl is BaseCommandModule bcmAfter)
 						await bcmAfter.AfterExecutionAsync(ctx).ConfigureAwait(false);
 					break;
 				}
 
 				if (!executed)
 					throw new ArgumentException("Could not find a suitable overload for the command.");
 			}
 			catch (Exception ex)
 			{
 				res = new CommandResult
 				{
 					IsSuccessful = false,
 					Exception = ex,
 					Context = ctx
 				};
 			}
 
 			return res;
 		}
 
 		/// <summary>
 		/// Runs pre-execution checks for this command and returns any that fail for given context.
 		/// </summary>
 		/// <param name="ctx">Context in which the command is executed.</param>
 		/// <param name="help">Whether this check is being executed from help or not. This can be used to probe whether command can be run without setting off certain fail conditions (such as cooldowns).</param>
 		/// <returns>Pre-execution checks that fail for given context.</returns>
 		public async Task<IEnumerable<CheckBaseAttribute>> RunChecksAsync(CommandContext ctx, bool help)
 		{
 			var fchecks = new List<CheckBaseAttribute>();
 			if (this.ExecutionChecks != null && this.ExecutionChecks.Any())
 				foreach (var ec in this.ExecutionChecks)
 					if (!await ec.ExecuteCheckAsync(ctx, help).ConfigureAwait(false))
 						fchecks.Add(ec);
 
 			return fchecks;
 		}
 
 		/// <summary>
 		/// Checks whether this command is equal to another one.
 		/// </summary>
 		/// <param name="cmd1">Command to compare to.</param>
 		/// <param name="cmd2">Command to compare.</param>
 		/// <returns>Whether the two commands are equal.</returns>
 		public static bool operator ==(Command cmd1, Command cmd2)
 		{
 			var o1 = cmd1 as object;
 			var o2 = cmd2 as object;
 
 			if (o1 == null && o2 != null)
 				return false;
 			else if (o1 != null && o2 == null)
 				return false;
 			else if (o1 == null && o2 == null)
 				return true;
 
 			return cmd1.QualifiedName == cmd2.QualifiedName;
 		}
 
 		/// <summary>
 		/// Checks whether this command is not equal to another one.
 		/// </summary>
 		/// <param name="cmd1">Command to compare to.</param>
 		/// <param name="cmd2">Command to compare.</param>
 		/// <returns>Whether the two commands are not equal.</returns>
 		public static bool operator !=(Command cmd1, Command cmd2)
 			=> !(cmd1 == cmd2);
 
 		/// <summary>
 		/// Checks whether this command equals another object.
 		/// </summary>
 		/// <param name="obj">Object to compare to.</param>
 		/// <returns>Whether this command is equal to another object.</returns>
 		public override bool Equals(object obj)
 		{
 			var o1 = obj as object;
 			var o2 = this as object;
 
 			if (o1 == null && o2 != null)
 				return false;
 			else if (o1 != null && o2 == null)
 				return false;
 			else if (o1 == null && o2 == null)
 				return true;
 
 			return obj is Command cmd
 && cmd.QualifiedName == this.QualifiedName;
 		}
 
 		/// <summary>
 		/// Gets this command's hash code.
 		/// </summary>
 		/// <returns>This command's hash code.</returns>
 		public override int GetHashCode() => this.QualifiedName.GetHashCode();
 
 		/// <summary>
 		/// Returns a string representation of this command.
 		/// </summary>
 		/// <returns>String representation of this command.</returns>
-		public override string ToString()
-		{
-			return this is CommandGroup g
+		public override string ToString() =>
+			this is CommandGroup g
 				? $"Command Group: {this.QualifiedName}, {g.Children.Count} top-level children"
 				: $"Command: {this.QualifiedName}";
-		}
 	}
 }
diff --git a/DisCatSharp.CommandsNext/Exceptions/InvalidOverloadException.cs b/DisCatSharp.CommandsNext/Exceptions/InvalidOverloadException.cs
index dcefab6b6..cad9f92c5 100644
--- a/DisCatSharp.CommandsNext/Exceptions/InvalidOverloadException.cs
+++ b/DisCatSharp.CommandsNext/Exceptions/InvalidOverloadException.cs
@@ -1,77 +1,75 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Reflection;
 
 namespace DisCatSharp.CommandsNext.Exceptions
 {
 	/// <summary>
 	/// Thrown when the command service fails to build a command due to a problem with its overload.
 	/// </summary>
 	public sealed class InvalidOverloadException : Exception
 	{
 		/// <summary>
 		/// Gets the method that caused this exception.
 		/// </summary>
 		public MethodInfo Method { get; }
 
 		/// <summary>
 		/// Gets or sets the argument that caused the problem. This can be null.
 		/// </summary>
 		public ParameterInfo Parameter { get; }
 
 		/// <summary>
 		/// Creates a new <see cref="InvalidOverloadException"/>.
 		/// </summary>
 		/// <param name="message">Exception message.</param>
 		/// <param name="method">Method that caused the problem.</param>
 		/// <param name="parameter">Method argument that caused the problem.</param>
 		public InvalidOverloadException(string message, MethodInfo method, ParameterInfo parameter)
 			: base(message)
 		{
 			this.Method = method;
 			this.Parameter = parameter;
 		}
 
 		/// <summary>
 		/// Creates a new <see cref="InvalidOverloadException"/>.
 		/// </summary>
 		/// <param name="message">Exception message.</param>
 		/// <param name="method">Method that caused the problem.</param>
 		public InvalidOverloadException(string message, MethodInfo method)
 			: this(message, method, null)
 		{ }
 
 		/// <summary>
 		/// Returns a string representation of this <see cref="InvalidOverloadException"/>.
 		/// </summary>
 		/// <returns>A string representation.</returns>
-		public override string ToString()
-		{
+		public override string ToString() =>
 			// much like System.ArgumentNullException works
-			return this.Parameter == null
+			this.Parameter == null
 				? $"{this.GetType()}: {this.Message}\nMethod: {this.Method} (declared in {this.Method.DeclaringType})"
 				: $"{this.GetType()}: {this.Message}\nMethod: {this.Method} (declared in {this.Method.DeclaringType})\nArgument: {this.Parameter.ParameterType} {this.Parameter.Name}";
-		}
 	}
 }
diff --git a/DisCatSharp.Common/Types/CharSpanLookupDictionary.cs b/DisCatSharp.Common/Types/CharSpanLookupDictionary.cs
index 206be380f..ff204e923 100644
--- a/DisCatSharp.Common/Types/CharSpanLookupDictionary.cs
+++ b/DisCatSharp.Common/Types/CharSpanLookupDictionary.cs
@@ -1,832 +1,829 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 
 namespace DisCatSharp.Common
 {
 	/// <summary>
 	/// Represents collection of string keys and <typeparamref name="TValue"/> values, allowing the use of <see cref="System.ReadOnlySpan{T}"/> for dictionary operations.
 	/// </summary>
 	/// <typeparam name="TValue">Type of items in this dictionary.</typeparam>
 	public sealed class CharSpanLookupDictionary<TValue> :
 		IDictionary<string, TValue>,
 		IReadOnlyDictionary<string, TValue>,
 		IDictionary
 	{
 		/// <summary>
 		/// Gets the collection of all keys present in this dictionary.
 		/// </summary>
 		public IEnumerable<string> Keys => this.GetKeysInternal();
 		/// <summary>
 		/// Gets the keys.
 		/// </summary>
 		ICollection<string> IDictionary<string, TValue>.Keys => this.GetKeysInternal();
 		/// <summary>
 		/// Gets the keys.
 		/// </summary>
 		ICollection IDictionary.Keys => this.GetKeysInternal();
 
 		/// <summary>
 		/// Gets the collection of all values present in this dictionary.
 		/// </summary>
 		public IEnumerable<TValue> Values => this.GetValuesInternal();
 		/// <summary>
 		/// Gets the values.
 		/// </summary>
 		ICollection<TValue> IDictionary<string, TValue>.Values => this.GetValuesInternal();
 		/// <summary>
 		/// Gets the values.
 		/// </summary>
 		ICollection IDictionary.Values => this.GetValuesInternal();
 
 		/// <summary>
 		/// Gets the total number of items in this dictionary.
 		/// </summary>
-		public int Count { get; private set; } = 0;
+		public int Count { get; private set; }
 
 		/// <summary>
 		/// Gets whether this dictionary is read-only.
 		/// </summary>
 		public bool IsReadOnly => false;
 
 		/// <summary>
 		/// Gets whether this dictionary has a fixed size.
 		/// </summary>
 		public bool IsFixedSize => false;
 
 		/// <summary>
 		/// Gets whether this dictionary is considered thread-safe.
 		/// </summary>
 		public bool IsSynchronized => false;
 
 		/// <summary>
 		/// Gets the object which allows synchronizing access to this dictionary.
 		/// </summary>
-		public object SyncRoot { get; } = new object();
+		public object SyncRoot { get; } = new();
 
 		/// <summary>
 		/// Gets or sets a value corresponding to given key in this dictionary.
 		/// </summary>
 		/// <param name="key">Key to get or set the value for.</param>
 		/// <returns>Value matching the supplied key, if applicable.</returns>
 		public TValue this[string key]
 		{
 			get
 			{
 				if (key == null)
 					throw new ArgumentNullException(nameof(key));
 
 				if (!this.TryRetrieveInternal(key.AsSpan(), out var value))
 					throw new KeyNotFoundException($"The given key '{key}' was not present in the dictionary.");
 
 				return value;
 			}
 
 			set
 			{
 				if (key == null)
 					throw new ArgumentNullException(nameof(key));
 
 				this.TryInsertInternal(key, value, true);
 			}
 		}
 
 		/// <summary>
 		/// Gets or sets a value corresponding to given key in this dictionary.
 		/// </summary>
 		/// <param name="key">Key to get or set the value for.</param>
 		/// <returns>Value matching the supplied key, if applicable.</returns>
 		public TValue this[ReadOnlySpan<char> key]
 		{
 			get
 			{
 				if (!this.TryRetrieveInternal(key, out var value))
 					throw new KeyNotFoundException($"The given key was not present in the dictionary.");
 
 				return value;
 			}
 
 #if NETCOREAPP
             set => this.TryInsertInternal(new string(key), value, true);
 #else
 			set
 			{
 				unsafe
 				{
 					fixed (char* chars = &key.GetPinnableReference())
 						this.TryInsertInternal(new string(chars, 0, key.Length), value, true);
 				}
 			}
 #endif
 		}
 
 		object IDictionary.this[object key]
 		{
 			get
 			{
 				if (!(key is string tkey))
 					throw new ArgumentException("Key needs to be an instance of a string.");
 
 				if (!this.TryRetrieveInternal(tkey.AsSpan(), out var value))
 					throw new KeyNotFoundException($"The given key '{tkey}' was not present in the dictionary.");
 
 				return value;
 			}
 
 			set
 			{
 				if (!(key is string tkey))
 					throw new ArgumentException("Key needs to be an instance of a string.");
 
 				if (!(value is TValue tvalue))
 				{
 					tvalue = default;
 					if (tvalue != null)
 						throw new ArgumentException($"Value needs to be an instance of {typeof(TValue)}.");
 				}
 
 				this.TryInsertInternal(tkey, tvalue, true);
 			}
 		}
 
 		/// <summary>
 		/// Gets the internal buckets.
 		/// </summary>
 		private readonly Dictionary<ulong, KeyedValue> _internalBuckets;
 
 		/// <summary>
 		/// Creates a new, empty <see cref="CharSpanLookupDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/>.
 		/// </summary>
 		public CharSpanLookupDictionary()
 		{
 			this._internalBuckets = new Dictionary<ulong, KeyedValue>();
 		}
 
 		/// <summary>
 		/// Creates a new, empty <see cref="CharSpanLookupDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and sets its initial capacity to specified value.
 		/// </summary>
 		/// <param name="initialCapacity">Initial capacity of the dictionary.</param>
 		public CharSpanLookupDictionary(int initialCapacity)
 		{
 			this._internalBuckets = new Dictionary<ulong, KeyedValue>(initialCapacity);
 		}
 
 		/// <summary>
 		/// Creates a new <see cref="CharSpanLookupDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied dictionary.
 		/// </summary>
 		/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 		public CharSpanLookupDictionary(IDictionary<string, TValue> values)
 			: this(values.Count)
 		{
 			foreach (var (k, v) in values)
 				this.Add(k, v);
 		}
 
 		/// <summary>
 		/// Creates a new <see cref="CharSpanLookupDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied dictionary.
 		/// </summary>
 		/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 		public CharSpanLookupDictionary(IReadOnlyDictionary<string, TValue> values)
 			 : this(values.Count)
 		{
 			foreach (var (k, v) in values)
 				this.Add(k, v);
 		}
 
 		/// <summary>
 		/// Creates a new <see cref="CharSpanLookupDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied key-value collection.
 		/// </summary>
 		/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 		public CharSpanLookupDictionary(IEnumerable<KeyValuePair<string, TValue>> values)
 			: this()
 		{
 			foreach (var (k, v) in values)
 				this.Add(k, v);
 		}
 
 		/// <summary>
 		/// Inserts a specific key and corresponding value into this dictionary.
 		/// </summary>
 		/// <param name="key">Key to insert.</param>
 		/// <param name="value">Value corresponding to this key.</param>
 		public void Add(string key, TValue value)
 		{
 			if (!this.TryInsertInternal(key, value, false))
 				throw new ArgumentException("Given key is already present in the dictionary.", nameof(key));
 		}
 
 		/// <summary>
 		/// Inserts a specific key and corresponding value into this dictionary.
 		/// </summary>
 		/// <param name="key">Key to insert.</param>
 		/// <param name="value">Value corresponding to this key.</param>
 		public void Add(ReadOnlySpan<char> key, TValue value)
 #if NETCOREAPP
         {
             if (!this.TryInsertInternal(new string(key), value, false))
                 throw new ArgumentException("Given key is already present in the dictionary.", nameof(key));
         }
 #else
 		{
 			unsafe
 			{
 				fixed (char* chars = &key.GetPinnableReference())
 					if (!this.TryInsertInternal(new string(chars, 0, key.Length), value, false))
 						throw new ArgumentException("Given key is already present in the dictionary.", nameof(key));
 			}
 		}
 #endif
 
 		/// <summary>
 		/// Attempts to insert a specific key and corresponding value into this dictionary.
 		/// </summary>
 		/// <param name="key">Key to insert.</param>
 		/// <param name="value">Value corresponding to this key.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public bool TryAdd(string key, TValue value)
 			=> this.TryInsertInternal(key, value, false);
 
 		/// <summary>
 		/// Attempts to insert a specific key and corresponding value into this dictionary.
 		/// </summary>
 		/// <param name="key">Key to insert.</param>
 		/// <param name="value">Value corresponding to this key.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public bool TryAdd(ReadOnlySpan<char> key, TValue value)
 #if NETCOREAPP
             => this.TryInsertInternal(new string(key), value, false);
 #else
 		{
 			unsafe
 			{
 				fixed (char* chars = &key.GetPinnableReference())
 					return this.TryInsertInternal(new string(chars, 0, key.Length), value, false);
 			}
 		}
 #endif
 
 		/// <summary>
 		/// Attempts to retrieve a value corresponding to the supplied key from this dictionary.
 		/// </summary>
 		/// <param name="key">Key to retrieve the value for.</param>
 		/// <param name="value">Retrieved value.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public bool TryGetValue(string key, out TValue value)
 		{
 			if (key == null)
 				throw new ArgumentNullException(nameof(key));
 
 			return this.TryRetrieveInternal(key.AsSpan(), out value);
 		}
 
 		/// <summary>
 		/// Attempts to retrieve a value corresponding to the supplied key from this dictionary.
 		/// </summary>
 		/// <param name="key">Key to retrieve the value for.</param>
 		/// <param name="value">Retrieved value.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public bool TryGetValue(ReadOnlySpan<char> key, out TValue value)
 			=> this.TryRetrieveInternal(key, out value);
 
 		/// <summary>
 		/// Attempts to remove a value corresponding to the supplied key from this dictionary.
 		/// </summary>
 		/// <param name="key">Key to remove the value for.</param>
 		/// <param name="value">Removed value.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public bool TryRemove(string key, out TValue value)
 		{
 			if (key == null)
 				throw new ArgumentNullException(nameof(key));
 
 			return this.TryRemoveInternal(key.AsSpan(), out value);
 		}
 
 		/// <summary>
 		/// Attempts to remove a value corresponding to the supplied key from this dictionary.
 		/// </summary>
 		/// <param name="key">Key to remove the value for.</param>
 		/// <param name="value">Removed value.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public bool TryRemove(ReadOnlySpan<char> key, out TValue value)
 			=> this.TryRemoveInternal(key, out value);
 
 		/// <summary>
 		/// Checks whether this dictionary contains the specified key.
 		/// </summary>
 		/// <param name="key">Key to check for in this dictionary.</param>
 		/// <returns>Whether the key was present in the dictionary.</returns>
 		public bool ContainsKey(string key)
 			=> this.ContainsKeyInternal(key.AsSpan());
 
 		/// <summary>
 		/// Checks whether this dictionary contains the specified key.
 		/// </summary>
 		/// <param name="key">Key to check for in this dictionary.</param>
 		/// <returns>Whether the key was present in the dictionary.</returns>
 		public bool ContainsKey(ReadOnlySpan<char> key)
 			=> this.ContainsKeyInternal(key);
 
 		/// <summary>
 		/// Removes all items from this dictionary.
 		/// </summary>
 		public void Clear()
 		{
 			this._internalBuckets.Clear();
 			this.Count = 0;
 		}
 
 		/// <summary>
 		/// Gets an enumerator over key-value pairs in this dictionary.
 		/// </summary>
 		/// <returns></returns>
 		public IEnumerator<KeyValuePair<string, TValue>> GetEnumerator()
 			=> new Enumerator(this);
 
 		/// <summary>
 		/// Removes the.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <returns>A bool.</returns>
 		bool IDictionary<string, TValue>.Remove(string key)
 			=> this.TryRemove(key.AsSpan(), out _);
 
 		/// <summary>
 		/// Adds the.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <param name="value">The value.</param>
 		void IDictionary.Add(object key, object value)
 		{
 			if (!(key is string tkey))
 				throw new ArgumentException("Key needs to be an instance of a string.");
 
 			if (!(value is TValue tvalue))
 			{
 				tvalue = default;
 				if (tvalue != null)
 					throw new ArgumentException($"Value needs to be an instance of {typeof(TValue)}.");
 			}
 
 			this.Add(tkey, tvalue);
 		}
 
 		/// <summary>
 		/// Removes the.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		void IDictionary.Remove(object key)
 		{
 			if (!(key is string tkey))
 				throw new ArgumentException("Key needs to be an instance of a string.");
 
 			this.TryRemove(tkey, out _);
 		}
 
 		/// <summary>
 		/// Contains the.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <returns>A bool.</returns>
 		bool IDictionary.Contains(object key)
 		{
 			if (!(key is string tkey))
 				throw new ArgumentException("Key needs to be an instance of a string.");
 
 			return this.ContainsKey(tkey);
 		}
 
 		/// <summary>
 		/// Gets the enumerator.
 		/// </summary>
 		/// <returns>An IDictionaryEnumerator.</returns>
 		IDictionaryEnumerator IDictionary.GetEnumerator()
 			=> new Enumerator(this);
 
 		/// <summary>
 		/// Adds the.
 		/// </summary>
 		/// <param name="item">The item.</param>
 		void ICollection<KeyValuePair<string, TValue>>.Add(KeyValuePair<string, TValue> item)
 			=> this.Add(item.Key, item.Value);
 
 		/// <summary>
 		/// Removes the.
 		/// </summary>
 		/// <param name="item">The item.</param>
 		/// <returns>A bool.</returns>
 		bool ICollection<KeyValuePair<string, TValue>>.Remove(KeyValuePair<string, TValue> item)
 			=> this.TryRemove(item.Key, out _);
 
 		/// <summary>
 		/// Contains the.
 		/// </summary>
 		/// <param name="item">The item.</param>
 		/// <returns>A bool.</returns>
 		bool ICollection<KeyValuePair<string, TValue>>.Contains(KeyValuePair<string, TValue> item)
 			=> this.TryGetValue(item.Key, out var value) && EqualityComparer<TValue>.Default.Equals(value, item.Value);
 
 		/// <summary>
 		/// Copies the to.
 		/// </summary>
 		/// <param name="array">The array.</param>
 		/// <param name="arrayIndex">The array index.</param>
 		void ICollection<KeyValuePair<string, TValue>>.CopyTo(KeyValuePair<string, TValue>[] array, int arrayIndex)
 		{
 			if (array.Length - arrayIndex < this.Count)
 				throw new ArgumentException("Target array is too small.", nameof(array));
 
 			var i = arrayIndex;
 			foreach (var (k, v) in this._internalBuckets)
 			{
 				var kdv = v;
 				while (kdv != null)
 				{
 					array[i++] = new KeyValuePair<string, TValue>(kdv.Key, kdv.Value);
 					kdv = kdv.Next;
 				}
 			}
 		}
 
 		/// <summary>
 		/// Copies the to.
 		/// </summary>
 		/// <param name="array">The array.</param>
 		/// <param name="arrayIndex">The array index.</param>
 		void ICollection.CopyTo(Array array, int arrayIndex)
 		{
 			if (array is KeyValuePair<string, TValue>[] tarray)
 			{
 				(this as ICollection<KeyValuePair<string, TValue>>).CopyTo(tarray, arrayIndex);
 				return;
 			}
 
 			if (array is not object[])
 				throw new ArgumentException($"Array needs to be an instance of {typeof(TValue[])} or object[].");
 
 			var i = arrayIndex;
 			foreach (var (k, v) in this._internalBuckets)
 			{
 				var kdv = v;
 				while (kdv != null)
 				{
 					array.SetValue(new KeyValuePair<string, TValue>(kdv.Key, kdv.Value), i++);
 					kdv = kdv.Next;
 				}
 			}
 		}
 
 		/// <summary>
 		/// Gets the enumerator.
 		/// </summary>
 		/// <returns>An IEnumerator.</returns>
 		IEnumerator IEnumerable.GetEnumerator()
 			=> this.GetEnumerator();
 
 		/// <summary>
 		/// Tries the insert internal.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <param name="value">The value.</param>
 		/// <param name="replace">If true, replace.</param>
 		/// <returns>A bool.</returns>
 		private bool TryInsertInternal(string key, TValue value, bool replace)
 		{
 			if (key == null)
 				throw new ArgumentNullException(nameof(key), "Key cannot be null.");
 
 			var hash = key.CalculateKnuthHash();
 			if (!this._internalBuckets.ContainsKey(hash))
 			{
 				this._internalBuckets.Add(hash, new KeyedValue(key, hash, value));
 				this.Count++;
 				return true;
 			}
 
 			var kdv = this._internalBuckets[hash];
 			var kdvLast = kdv;
 			while (kdv != null)
 			{
 				if (kdv.Key == key)
 				{
 					if (!replace)
 						return false;
 
 					kdv.Value = value;
 					return true;
 				}
 
 				kdvLast = kdv;
 				kdv = kdv.Next;
 			}
 
 			kdvLast.Next = new KeyedValue(key, hash, value);
 			this.Count++;
 			return true;
 		}
 
 		/// <summary>
 		/// Tries the retrieve internal.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <param name="value">The value.</param>
 		/// <returns>A bool.</returns>
 		private bool TryRetrieveInternal(ReadOnlySpan<char> key, out TValue value)
 		{
 			value = default;
 
 			var hash = key.CalculateKnuthHash();
 			if (!this._internalBuckets.TryGetValue(hash, out var kdv))
 				return false;
 
 			while (kdv != null)
 			{
 				if (key.SequenceEqual(kdv.Key.AsSpan()))
 				{
 					value = kdv.Value;
 					return true;
 				}
 			}
 
 			return false;
 		}
 
 		/// <summary>
 		/// Tries the remove internal.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <param name="value">The value.</param>
 		/// <returns>A bool.</returns>
 		private bool TryRemoveInternal(ReadOnlySpan<char> key, out TValue value)
 		{
 			value = default;
 
 			var hash = key.CalculateKnuthHash();
 			if (!this._internalBuckets.TryGetValue(hash, out var kdv))
 				return false;
 
 			if (kdv.Next == null && key.SequenceEqual(kdv.Key.AsSpan()))
 			{
 				// Only bucket under this hash and key matches, pop the entire bucket
 
 				value = kdv.Value;
 				this._internalBuckets.Remove(hash);
 				this.Count--;
 				return true;
 			}
 			else if (kdv.Next == null)
 			{
 				// Only bucket under this hash and key does not match, cannot remove
 
 				return false;
 			}
 			else if (key.SequenceEqual(kdv.Key.AsSpan()))
 			{
 				// First key in the bucket matches, pop it and set its child as current bucket
 
 				value = kdv.Value;
 				this._internalBuckets[hash] = kdv.Next;
 				this.Count--;
 				return true;
 			}
 
 			var kdvLast = kdv;
 			kdv = kdv.Next;
 			while (kdv != null)
 			{
 				if (key.SequenceEqual(kdv.Key.AsSpan()))
 				{
 					// Key matched, remove this bucket from the chain
 
 					value = kdv.Value;
 					kdvLast.Next = kdv.Next;
 					this.Count--;
 					return true;
 				}
 
 				kdvLast = kdv;
 				kdv = kdv.Next;
 			}
 
 			return false;
 		}
 
 		/// <summary>
 		/// Contains the key internal.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <returns>A bool.</returns>
 		private bool ContainsKeyInternal(ReadOnlySpan<char> key)
 		{
 			var hash = key.CalculateKnuthHash();
 			if (!this._internalBuckets.TryGetValue(hash, out var kdv))
 				return false;
 
 			while (kdv != null)
 			{
 				if (key.SequenceEqual(kdv.Key.AsSpan()))
 					return true;
 
 				kdv = kdv.Next;
 			}
 
 			return false;
 		}
 
 		/// <summary>
 		/// Gets the keys internal.
 		/// </summary>
 		/// <returns>An ImmutableArray.</returns>
 		private ImmutableArray<string> GetKeysInternal()
 		{
 			var builder = ImmutableArray.CreateBuilder<string>(this.Count);
 			foreach (var value in this._internalBuckets.Values)
 			{
 				var kdv = value;
 				while (kdv != null)
 				{
 					builder.Add(kdv.Key);
 					kdv = kdv.Next;
 				}
 			}
 
 			return builder.MoveToImmutable();
 		}
 
 		/// <summary>
 		/// Gets the values internal.
 		/// </summary>
 		/// <returns>An ImmutableArray.</returns>
 		private ImmutableArray<TValue> GetValuesInternal()
 		{
 			var builder = ImmutableArray.CreateBuilder<TValue>(this.Count);
 			foreach (var value in this._internalBuckets.Values)
 			{
 				var kdv = value;
 				while (kdv != null)
 				{
 					builder.Add(kdv.Value);
 					kdv = kdv.Next;
 				}
 			}
 
 			return builder.MoveToImmutable();
 		}
 
 		/// <summary>
 		/// The keyed value.
 		/// </summary>
 		private class KeyedValue
 		{
 			/// <summary>
 			/// Gets the key hash.
 			/// </summary>
 			public ulong KeyHash { get; }
 			/// <summary>
 			/// Gets the key.
 			/// </summary>
 			public string Key { get; }
 			/// <summary>
 			/// Gets or sets the value.
 			/// </summary>
 			public TValue Value { get; set; }
 
 			/// <summary>
 			/// Gets or sets the next.
 			/// </summary>
 			public KeyedValue Next { get; set; }
 
 			/// <summary>
 			/// Initializes a new instance of the <see cref="KeyedValue"/> class.
 			/// </summary>
 			/// <param name="key">The key.</param>
 			/// <param name="keyHash">The key hash.</param>
 			/// <param name="value">The value.</param>
 			public KeyedValue(string key, ulong keyHash, TValue value)
 			{
 				this.KeyHash = keyHash;
 				this.Key = key;
 				this.Value = value;
 			}
 		}
 
 		/// <summary>
 		/// The enumerator.
 		/// </summary>
 		private class Enumerator :
 			IEnumerator<KeyValuePair<string, TValue>>,
 			IDictionaryEnumerator
 		{
 			/// <summary>
 			/// Gets the current.
 			/// </summary>
 			public KeyValuePair<string, TValue> Current { get; private set; }
 			/// <summary>
 			/// Gets the current.
 			/// </summary>
 			object IEnumerator.Current => this.Current;
 			/// <summary>
 			/// Gets the key.
 			/// </summary>
 			object IDictionaryEnumerator.Key => this.Current.Key;
 			/// <summary>
 			/// Gets the value.
 			/// </summary>
 			object IDictionaryEnumerator.Value => this.Current.Value;
 			/// <summary>
 			/// Gets the entry.
 			/// </summary>
-			DictionaryEntry IDictionaryEnumerator.Entry => new DictionaryEntry(this.Current.Key, this.Current.Value);
+			DictionaryEntry IDictionaryEnumerator.Entry => new(this.Current.Key, this.Current.Value);
 
 			/// <summary>
 			/// Gets the internal dictionary.
 			/// </summary>
 			private readonly CharSpanLookupDictionary<TValue> _internalDictionary;
 
 			/// <summary>
 			/// Gets the internal enumerator.
 			/// </summary>
 			private readonly IEnumerator<KeyValuePair<ulong, KeyedValue>> _internalEnumerator;
 
 			/// <summary>
 			/// Gets or sets the current value.
 			/// </summary>
 			private KeyedValue _currentValue;
 
 			/// <summary>
 			/// Initializes a new instance of the <see cref="Enumerator"/> class.
 			/// </summary>
 			/// <param name="spDict">The sp dict.</param>
 			public Enumerator(CharSpanLookupDictionary<TValue> spDict)
 			{
 				this._internalDictionary = spDict;
 				this._internalEnumerator = this._internalDictionary._internalBuckets.GetEnumerator();
 			}
 
 			/// <summary>
 			/// Moves the next.
 			/// </summary>
 			/// <returns>A bool.</returns>
 			public bool MoveNext()
 			{
 				var kdv = this._currentValue;
 				if (kdv == null)
 				{
 					if (!this._internalEnumerator.MoveNext())
 						return false;
 
 					kdv = this._internalEnumerator.Current.Value;
 					this.Current = new KeyValuePair<string, TValue>(kdv.Key, kdv.Value);
 
 					this._currentValue = kdv.Next;
 					return true;
 				}
 
 				this.Current = new KeyValuePair<string, TValue>(kdv.Key, kdv.Value);
 				this._currentValue = kdv.Next;
 				return true;
 			}
 
 			/// <summary>
 			/// Resets the.
 			/// </summary>
 			public void Reset()
 			{
 				this._internalEnumerator.Reset();
 				this.Current = default;
 				this._currentValue = null;
 			}
 
 			/// <summary>
 			/// Disposes the.
 			/// </summary>
-			public void Dispose()
-			{
-				this.Reset();
-			}
+			public void Dispose() => this.Reset();
 		}
 	}
 }
diff --git a/DisCatSharp.Common/Types/CharSpanLookupReadOnlyDictionary.cs b/DisCatSharp.Common/Types/CharSpanLookupReadOnlyDictionary.cs
index b65618d41..50dc9b79d 100644
--- a/DisCatSharp.Common/Types/CharSpanLookupReadOnlyDictionary.cs
+++ b/DisCatSharp.Common/Types/CharSpanLookupReadOnlyDictionary.cs
@@ -1,419 +1,416 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Collections.ObjectModel;
 
 namespace DisCatSharp.Common
 {
 	/// <summary>
 	/// Represents collection of string keys and <typeparamref name="TValue"/> values, allowing the use of <see cref="System.ReadOnlySpan{T}"/> for dictionary operations.
 	/// </summary>
 	/// <typeparam name="TValue">Type of items in this dictionary.</typeparam>
 	public sealed class CharSpanLookupReadOnlyDictionary<TValue> : IReadOnlyDictionary<string, TValue>
 	{
 		/// <summary>
 		/// Gets the collection of all keys present in this dictionary.
 		/// </summary>
 		public IEnumerable<string> Keys => this.GetKeysInternal();
 
 		/// <summary>
 		/// Gets the collection of all values present in this dictionary.
 		/// </summary>
 		public IEnumerable<TValue> Values => this.GetValuesInternal();
 
 		/// <summary>
 		/// Gets the total number of items in this dictionary.
 		/// </summary>
 		public int Count { get; }
 
 		/// <summary>
 		/// Gets a value corresponding to given key in this dictionary.
 		/// </summary>
 		/// <param name="key">Key to get or set the value for.</param>
 		/// <returns>Value matching the supplied key, if applicable.</returns>
 		public TValue this[string key]
 		{
 			get
 			{
 				if (key == null)
 					throw new ArgumentNullException(nameof(key));
 
 				if (!this.TryRetrieveInternal(key.AsSpan(), out var value))
 					throw new KeyNotFoundException($"The given key '{key}' was not present in the dictionary.");
 
 				return value;
 			}
 		}
 
 		/// <summary>
 		/// Gets a value corresponding to given key in this dictionary.
 		/// </summary>
 		/// <param name="key">Key to get or set the value for.</param>
 		/// <returns>Value matching the supplied key, if applicable.</returns>
 		public TValue this[ReadOnlySpan<char> key]
 		{
 			get
 			{
 				if (!this.TryRetrieveInternal(key, out var value))
 					throw new KeyNotFoundException($"The given key was not present in the dictionary.");
 
 				return value;
 			}
 		}
 
 		/// <summary>
 		/// Gets the internal buckets.
 		/// </summary>
 		private readonly IReadOnlyDictionary<ulong, KeyedValue> _internalBuckets;
 
 		/// <summary>
 		/// Creates a new <see cref="CharSpanLookupReadOnlyDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied dictionary.
 		/// </summary>
 		/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 		public CharSpanLookupReadOnlyDictionary(IDictionary<string, TValue> values)
 			: this(values as IEnumerable<KeyValuePair<string, TValue>>)
 		{ }
 
 		/// <summary>
 		/// Creates a new <see cref="CharSpanLookupReadOnlyDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied dictionary.
 		/// </summary>
 		/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 		public CharSpanLookupReadOnlyDictionary(IReadOnlyDictionary<string, TValue> values)
 			: this(values as IEnumerable<KeyValuePair<string, TValue>>)
 		{ }
 
 		/// <summary>
 		/// Creates a new <see cref="CharSpanLookupReadOnlyDictionary{TValue}"/> with string keys and items of type <typeparamref name="TValue"/> and populates it with key-value pairs from supplied key-value collection.
 		/// </summary>
 		/// <param name="values">Dictionary containing items to populate this dictionary with.</param>
 		public CharSpanLookupReadOnlyDictionary(IEnumerable<KeyValuePair<string, TValue>> values)
 		{
 			this._internalBuckets = PrepareItems(values, out var count);
 			this.Count = count;
 		}
 
 		/// <summary>
 		/// Attempts to retrieve a value corresponding to the supplied key from this dictionary.
 		/// </summary>
 		/// <param name="key">Key to retrieve the value for.</param>
 		/// <param name="value">Retrieved value.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public bool TryGetValue(string key, out TValue value)
 		{
 			if (key == null)
 				throw new ArgumentNullException(nameof(key));
 
 			return this.TryRetrieveInternal(key.AsSpan(), out value);
 		}
 
 		/// <summary>
 		/// Attempts to retrieve a value corresponding to the supplied key from this dictionary.
 		/// </summary>
 		/// <param name="key">Key to retrieve the value for.</param>
 		/// <param name="value">Retrieved value.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public bool TryGetValue(ReadOnlySpan<char> key, out TValue value)
 			=> this.TryRetrieveInternal(key, out value);
 
 		/// <summary>
 		/// Checks whether this dictionary contains the specified key.
 		/// </summary>
 		/// <param name="key">Key to check for in this dictionary.</param>
 		/// <returns>Whether the key was present in the dictionary.</returns>
 		public bool ContainsKey(string key)
 			=> this.ContainsKeyInternal(key.AsSpan());
 
 		/// <summary>
 		/// Checks whether this dictionary contains the specified key.
 		/// </summary>
 		/// <param name="key">Key to check for in this dictionary.</param>
 		/// <returns>Whether the key was present in the dictionary.</returns>
 		public bool ContainsKey(ReadOnlySpan<char> key)
 			=> this.ContainsKeyInternal(key);
 
 		/// <summary>
 		/// Gets an enumerator over key-value pairs in this dictionary.
 		/// </summary>
 		/// <returns></returns>
 		public IEnumerator<KeyValuePair<string, TValue>> GetEnumerator()
 			=> new Enumerator(this);
 
 		/// <summary>
 		/// Gets the enumerator.
 		/// </summary>
 		/// <returns>An IEnumerator.</returns>
 		IEnumerator IEnumerable.GetEnumerator()
 			=> this.GetEnumerator();
 
 		/// <summary>
 		/// Tries the retrieve internal.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <param name="value">The value.</param>
 		/// <returns>A bool.</returns>
 		private bool TryRetrieveInternal(ReadOnlySpan<char> key, out TValue value)
 		{
 			value = default;
 
 			var hash = key.CalculateKnuthHash();
 			if (!this._internalBuckets.TryGetValue(hash, out var kdv))
 				return false;
 
 			while (kdv != null)
 			{
 				if (key.SequenceEqual(kdv.Key.AsSpan()))
 				{
 					value = kdv.Value;
 					return true;
 				}
 			}
 
 			return false;
 		}
 
 		/// <summary>
 		/// Contains the key internal.
 		/// </summary>
 		/// <param name="key">The key.</param>
 		/// <returns>A bool.</returns>
 		private bool ContainsKeyInternal(ReadOnlySpan<char> key)
 		{
 			var hash = key.CalculateKnuthHash();
 			if (!this._internalBuckets.TryGetValue(hash, out var kdv))
 				return false;
 
 			while (kdv != null)
 			{
 				if (key.SequenceEqual(kdv.Key.AsSpan()))
 					return true;
 
 				kdv = kdv.Next;
 			}
 
 			return false;
 		}
 
 		/// <summary>
 		/// Gets the keys internal.
 		/// </summary>
 		/// <returns>An ImmutableArray.</returns>
 		private ImmutableArray<string> GetKeysInternal()
 		{
 			var builder = ImmutableArray.CreateBuilder<string>(this.Count);
 			foreach (var value in this._internalBuckets.Values)
 			{
 				var kdv = value;
 				while (kdv != null)
 				{
 					builder.Add(kdv.Key);
 					kdv = kdv.Next;
 				}
 			}
 
 			return builder.MoveToImmutable();
 		}
 
 		/// <summary>
 		/// Gets the values internal.
 		/// </summary>
 		/// <returns>An ImmutableArray.</returns>
 		private ImmutableArray<TValue> GetValuesInternal()
 		{
 			var builder = ImmutableArray.CreateBuilder<TValue>(this.Count);
 			foreach (var value in this._internalBuckets.Values)
 			{
 				var kdv = value;
 				while (kdv != null)
 				{
 					builder.Add(kdv.Value);
 					kdv = kdv.Next;
 				}
 			}
 
 			return builder.MoveToImmutable();
 		}
 
 		/// <summary>
 		/// Prepares the items.
 		/// </summary>
 		/// <param name="items">The items.</param>
 		/// <param name="count">The count.</param>
 		/// <returns>An IReadOnlyDictionary.</returns>
 		private static IReadOnlyDictionary<ulong, KeyedValue> PrepareItems(IEnumerable<KeyValuePair<string, TValue>> items, out int count)
 		{
 			count = 0;
 			var dict = new Dictionary<ulong, KeyedValue>();
 			foreach (var (k, v) in items)
 			{
 				if (k == null)
 					throw new ArgumentException("Keys cannot be null.", nameof(items));
 
 				var hash = k.CalculateKnuthHash();
 				if (!dict.ContainsKey(hash))
 				{
 					dict.Add(hash, new KeyedValue(k, hash, v));
 					count++;
 					continue;
 				}
 
 				var kdv = dict[hash];
 				var kdvLast = kdv;
 				while (kdv != null)
 				{
 					if (kdv.Key == k)
 						throw new ArgumentException("Given key is already present in the dictionary.", nameof(items));
 
 					kdvLast = kdv;
 					kdv = kdv.Next;
 				}
 
 				kdvLast.Next = new KeyedValue(k, hash, v);
 				count++;
 			}
 
 			return new ReadOnlyDictionary<ulong, KeyedValue>(dict);
 		}
 
 		/// <summary>
 		/// The keyed value.
 		/// </summary>
 		private class KeyedValue
 		{
 			/// <summary>
 			/// Gets the key hash.
 			/// </summary>
 			public ulong KeyHash { get; }
 			/// <summary>
 			/// Gets the key.
 			/// </summary>
 			public string Key { get; }
 			/// <summary>
 			/// Gets or sets the value.
 			/// </summary>
 			public TValue Value { get; set; }
 
 			/// <summary>
 			/// Gets or sets the next.
 			/// </summary>
 			public KeyedValue Next { get; set; }
 
 			/// <summary>
 			/// Initializes a new instance of the <see cref="KeyedValue"/> class.
 			/// </summary>
 			/// <param name="key">The key.</param>
 			/// <param name="keyHash">The key hash.</param>
 			/// <param name="value">The value.</param>
 			public KeyedValue(string key, ulong keyHash, TValue value)
 			{
 				this.KeyHash = keyHash;
 				this.Key = key;
 				this.Value = value;
 			}
 		}
 
 		/// <summary>
 		/// The enumerator.
 		/// </summary>
 		private class Enumerator : IEnumerator<KeyValuePair<string, TValue>>
 		{
 			/// <summary>
 			/// Gets the current.
 			/// </summary>
 			public KeyValuePair<string, TValue> Current { get; private set; }
 			/// <summary>
 			/// Gets the current.
 			/// </summary>
 			object IEnumerator.Current => this.Current;
 
 			/// <summary>
 			/// Gets the internal dictionary.
 			/// </summary>
 			private readonly CharSpanLookupReadOnlyDictionary<TValue> _internalDictionary;
 
 			/// <summary>
 			/// Gets the internal enumerator.
 			/// </summary>
 			private readonly IEnumerator<KeyValuePair<ulong, KeyedValue>> _internalEnumerator;
 
 			/// <summary>
 			/// Gets or sets the current value.
 			/// </summary>
 			private KeyedValue _currentValue;
 
 			/// <summary>
 			/// Initializes a new instance of the <see cref="Enumerator"/> class.
 			/// </summary>
 			/// <param name="spDict">The sp dict.</param>
 			public Enumerator(CharSpanLookupReadOnlyDictionary<TValue> spDict)
 			{
 				this._internalDictionary = spDict;
 				this._internalEnumerator = this._internalDictionary._internalBuckets.GetEnumerator();
 			}
 
 			/// <summary>
 			/// Moves the next.
 			/// </summary>
 			/// <returns>A bool.</returns>
 			public bool MoveNext()
 			{
 				var kdv = this._currentValue;
 				if (kdv == null)
 				{
 					if (!this._internalEnumerator.MoveNext())
 						return false;
 
 					kdv = this._internalEnumerator.Current.Value;
 					this.Current = new KeyValuePair<string, TValue>(kdv.Key, kdv.Value);
 
 					this._currentValue = kdv.Next;
 					return true;
 				}
 
 				this.Current = new KeyValuePair<string, TValue>(kdv.Key, kdv.Value);
 				this._currentValue = kdv.Next;
 				return true;
 			}
 
 			/// <summary>
 			/// Resets the.
 			/// </summary>
 			public void Reset()
 			{
 				this._internalEnumerator.Reset();
 				this.Current = default;
 				this._currentValue = null;
 			}
 
 			/// <summary>
 			/// Disposes the.
 			/// </summary>
-			public void Dispose()
-			{
-				this.Reset();
-			}
+			public void Dispose() => this.Reset();
 		}
 	}
 }
diff --git a/DisCatSharp.Common/Types/ContinuousMemoryBuffer.cs b/DisCatSharp.Common/Types/ContinuousMemoryBuffer.cs
index e17c57268..176953f07 100644
--- a/DisCatSharp.Common/Types/ContinuousMemoryBuffer.cs
+++ b/DisCatSharp.Common/Types/ContinuousMemoryBuffer.cs
@@ -1,274 +1,274 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Buffers;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace DisCatSharp.Common.Types
 {
 	/// <summary>
 	/// Provides a resizable memory buffer analogous to <see cref="MemoryBuffer{T}"/>, using a single continuous memory region instead.
 	/// </summary>
 	/// <typeparam name="T">Type of item to hold in the buffer.</typeparam>
 	public sealed class ContinuousMemoryBuffer<T> : IMemoryBuffer<T> where T : unmanaged
 	{
 		/// <inheritdoc />
 		public ulong Capacity => (ulong)this._buff.Length;
 
 		/// <inheritdoc />
 		public ulong Length => (ulong)this._pos;
 
 		/// <inheritdoc />
 		public ulong Count => (ulong)(this._pos / this._itemSize);
 
 		private readonly MemoryPool<byte> _pool;
 		private IMemoryOwner<byte> _buffOwner;
 		private Memory<byte> _buff;
 		private readonly bool _clear;
 		private int _pos;
 		private readonly int _itemSize;
 		private bool _isDisposed;
 
 		/// <summary>
 		/// Creates a new buffer with a specified segment size, specified number of initially-allocated segments, and supplied memory pool.
 		/// </summary>
 		/// <param name="initialSize">Initial size of the buffer in bytes. Defaults to 64KiB.</param>
 		/// <param name="memPool">Memory pool to use for renting buffers. Defaults to <see cref="System.Buffers.MemoryPool{T}.Shared"/>.</param>
 		/// <param name="clearOnDispose">Determines whether the underlying buffers should be cleared on exit. If dealing with sensitive data, it might be a good idea to set this option to true.</param>
 		public ContinuousMemoryBuffer(int initialSize = 65536, MemoryPool<byte> memPool = default, bool clearOnDispose = false)
 		{
 			this._itemSize = Unsafe.SizeOf<T>();
 			this._pool = memPool ?? MemoryPool<byte>.Shared;
 			this._clear = clearOnDispose;
 
 			this._buffOwner = this._pool.Rent(initialSize);
 			this._buff = this._buffOwner.Memory;
 
 			this._isDisposed = false;
 		}
 
 		/// <inheritdoc />
 		public void Write(ReadOnlySpan<T> data)
 		{
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 			var bytes = MemoryMarshal.AsBytes(data);
 			this.EnsureSize(this._pos + bytes.Length);
 
 			bytes.CopyTo(this._buff[this._pos..].Span);
 			this._pos += bytes.Length;
 		}
 
 		/// <inheritdoc />
 		public void Write(T[] data, int start, int count)
 			=> this.Write(data.AsSpan(start, count));
 
 		/// <inheritdoc />
 		public void Write(ArraySegment<T> data)
 			=> this.Write(data.AsSpan());
 
 		/// <inheritdoc />
 		public void Write(Stream stream)
 		{
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 			if (stream.CanSeek)
 				this.WriteStreamSeekable(stream);
 			else
 				this.WriteStreamUnseekable(stream);
 		}
 
 		/// <summary>
 		/// Writes the stream seekable.
 		/// </summary>
 		/// <param name="stream">The stream.</param>
 		private void WriteStreamSeekable(Stream stream)
 		{
 			if (stream.Length > int.MaxValue)
 				throw new ArgumentException("Stream is too long.", nameof(stream));
 
 			this.EnsureSize(this._pos + (int)stream.Length);
 #if HAS_SPAN_STREAM_OVERLOADS
             stream.Read(this._buff.Slice(this._pos).Span);
 #else
 			var memo = ArrayPool<byte>.Shared.Rent((int)stream.Length);
 			try
 			{
 				var br = stream.Read(memo, 0, memo.Length);
 				memo.AsSpan(0, br).CopyTo(this._buff[this._pos..].Span);
 			}
 			finally
 			{
 				ArrayPool<byte>.Shared.Return(memo);
 			}
 #endif
 
 			this._pos += (int)stream.Length;
 		}
 
 		/// <summary>
 		/// Writes the stream unseekable.
 		/// </summary>
 		/// <param name="stream">The stream.</param>
 		private void WriteStreamUnseekable(Stream stream)
 		{
 #if HAS_SPAN_STREAM_OVERLOADS
             var br = 0;
             do
             {
                 this.EnsureSize(this._pos + 4096);
                 br = stream.Read(this._buff.Slice(this._pos).Span);
                 this._pos += br;
             }
             while (br != 0);
 #else
 			var memo = ArrayPool<byte>.Shared.Rent(4096);
 			try
 			{
 				var br = 0;
 				while ((br = stream.Read(memo, 0, memo.Length)) != 0)
 				{
 					this.EnsureSize(this._pos + br);
 					memo.AsSpan(0, br).CopyTo(this._buff[this._pos..].Span);
 					this._pos += br;
 				}
 			}
 			finally
 			{
 				ArrayPool<byte>.Shared.Return(memo);
 			}
 #endif
 		}
 
 		/// <inheritdoc />
 		public bool Read(Span<T> destination, ulong source, out int itemsWritten)
 		{
 			itemsWritten = 0;
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 			source *= (ulong)this._itemSize;
 			if (source > this.Count)
 				throw new ArgumentOutOfRangeException(nameof(source), "Cannot copy data from beyond the buffer.");
 
 			var start = (int)source;
 			var sbuff = this._buff[start..this._pos ].Span;
 			var dbuff = MemoryMarshal.AsBytes(destination);
 			if (sbuff.Length > dbuff.Length)
 				sbuff = sbuff[..dbuff.Length];
 
 			itemsWritten = sbuff.Length / this._itemSize;
 			sbuff.CopyTo(dbuff);
 
-			return (this.Length - source) != (ulong)itemsWritten;
+			return this.Length - source != (ulong)itemsWritten;
 		}
 
 		/// <inheritdoc />
 		public bool Read(T[] data, int start, int count, ulong source, out int itemsWritten)
 			=> this.Read(data.AsSpan(start, count), source, out itemsWritten);
 
 		/// <inheritdoc />
 		public bool Read(ArraySegment<T> data, ulong source, out int itemsWritten)
 			=> this.Read(data.AsSpan(), source, out itemsWritten);
 
 		/// <inheritdoc />
 		public T[] ToArray()
 		{
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 			return MemoryMarshal.Cast<byte, T>(this._buff[..this._pos].Span).ToArray();
 		}
 
 		/// <inheritdoc />
 		public void CopyTo(Stream destination)
 		{
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 #if HAS_SPAN_STREAM_OVERLOADS
             destination.Write(this._buff.Slice(0, this._pos).Span);
 #else
 			var buff = this._buff[..this._pos].ToArray();
 			destination.Write(buff, 0, buff.Length);
 #endif
 		}
 
 		/// <inheritdoc />
 		public void Clear()
 		{
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 			this._pos = 0;
 		}
 
 		/// <summary>
 		/// Disposes of any resources claimed by this buffer.
 		/// </summary>
 		public void Dispose()
 		{
 			if (this._isDisposed)
 				return;
 
 			this._isDisposed = true;
 			if (this._clear)
 				this._buff.Span.Clear();
 
 			this._buffOwner.Dispose();
 			this._buff = default;
 		}
 
 		/// <summary>
 		/// Ensures the size.
 		/// </summary>
 		/// <param name="newCapacity">The new capacity.</param>
 		private void EnsureSize(int newCapacity)
 		{
 			var cap = this._buff.Length;
 			if (cap >= newCapacity)
 				return;
 
 			var factor = newCapacity / cap;
 			if (newCapacity % cap != 0)
 				++factor;
 
 			var newActualCapacity = cap * factor;
 
 			var newBuffOwner = this._pool.Rent(newActualCapacity);
 			var newBuff = newBuffOwner.Memory;
 
 			this._buff.Span.CopyTo(newBuff.Span);
 			if (this._clear)
 				this._buff.Span.Clear();
 
 			this._buffOwner.Dispose();
 			this._buffOwner = newBuffOwner;
 			this._buff = newBuff;
 		}
 	}
 }
diff --git a/DisCatSharp.Common/Types/MemoryBuffer.cs b/DisCatSharp.Common/Types/MemoryBuffer.cs
index 1d7020230..1b923ad82 100644
--- a/DisCatSharp.Common/Types/MemoryBuffer.cs
+++ b/DisCatSharp.Common/Types/MemoryBuffer.cs
@@ -1,356 +1,356 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Buffers;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace DisCatSharp.Common.Types
 {
 	/// <summary>
 	/// Provides a resizable memory buffer, which can be read from and written to. It will automatically resize whenever required.
 	/// </summary>
 	/// <typeparam name="T">Type of item to hold in the buffer.</typeparam>
 	public sealed class MemoryBuffer<T> : IMemoryBuffer<T> where T : unmanaged
 	{
 		/// <inheritdoc />
 		public ulong Capacity => this._segments.Aggregate(0UL, (a, x) => a + (ulong)x.Memory.Length); // .Sum() does only int
 
 		/// <inheritdoc />
 		public ulong Length { get; private set; }
 
 		/// <inheritdoc />
 		public ulong Count => this.Length / (ulong)this._itemSize;
 
 		private readonly MemoryPool<byte> _pool;
 		private readonly int _segmentSize;
 		private int _lastSegmentLength;
 		private int _segNo;
 		private readonly bool _clear;
 		private readonly List<IMemoryOwner<byte>> _segments;
 		private readonly int _itemSize;
 		private bool _isDisposed;
 
 		/// <summary>
 		/// Creates a new buffer with a specified segment size, specified number of initially-allocated segments, and supplied memory pool.
 		/// </summary>
 		/// <param name="segmentSize">Byte size of an individual segment. Defaults to 64KiB.</param>
 		/// <param name="initialSegmentCount">Number of segments to allocate. Defaults to 0.</param>
 		/// <param name="memPool">Memory pool to use for renting buffers. Defaults to <see cref="System.Buffers.MemoryPool{T}.Shared"/>.</param>
 		/// <param name="clearOnDispose">Determines whether the underlying buffers should be cleared on exit. If dealing with sensitive data, it might be a good idea to set this option to true.</param>
 		public MemoryBuffer(int segmentSize = 65536, int initialSegmentCount = 0, MemoryPool<byte> memPool = default, bool clearOnDispose = false)
 		{
 			this._itemSize = Unsafe.SizeOf<T>();
 			if (segmentSize % this._itemSize != 0)
 				throw new ArgumentException("Segment size must match size of individual item.");
 
 			this._pool = memPool ?? MemoryPool<byte>.Shared;
 
 			this._segmentSize = segmentSize;
 			this._segNo = 0;
 			this._lastSegmentLength = 0;
 			this._clear = clearOnDispose;
 
 			this._segments = new List<IMemoryOwner<byte>>(initialSegmentCount + 1);
 			for (var i = 0; i < initialSegmentCount; i++)
 				this._segments.Add(this._pool.Rent(this._segmentSize));
 
 			this.Length = 0;
 
 			this._isDisposed = false;
 		}
 
 		/// <inheritdoc />
 		public void Write(ReadOnlySpan<T> data)
 		{
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 			var src = MemoryMarshal.AsBytes(data);
 			this.Grow(src.Length);
 
 			while (this._segNo < this._segments.Count && src.Length > 0)
 			{
 				var seg = this._segments[this._segNo];
 				var mem = seg.Memory;
 				var avs = mem.Length - this._lastSegmentLength;
 				avs = avs > src.Length
 					? src.Length
 					: avs;
 				var dmem = mem[this._lastSegmentLength..];
 
 				src[..avs].CopyTo(dmem.Span);
 				src = src[avs..];
 
 				this.Length += (ulong)avs;
 				this._lastSegmentLength += avs;
 
 				if (this._lastSegmentLength == mem.Length)
 				{
 					this._segNo++;
 					this._lastSegmentLength = 0;
 				}
 			}
 		}
 
 		/// <inheritdoc />
 		public void Write(T[] data, int start, int count)
 			=> this.Write(data.AsSpan(start, count));
 
 		/// <inheritdoc />
 		public void Write(ArraySegment<T> data)
 			=> this.Write(data.AsSpan());
 
 		/// <inheritdoc />
 		public void Write(Stream stream)
 		{
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 			if (stream.CanSeek)
 				this.WriteStreamSeekable(stream);
 			else
 				this.WriteStreamUnseekable(stream);
 		}
 
 		/// <summary>
 		/// Writes the stream seekable.
 		/// </summary>
 		/// <param name="stream">The stream.</param>
 		private void WriteStreamSeekable(Stream stream)
 		{
 			var len = (int)(stream.Length - stream.Position);
 			this.Grow(len);
 
 #if !HAS_SPAN_STREAM_OVERLOADS
 			var buff = new byte[this._segmentSize];
 #endif
 
 			while (this._segNo < this._segments.Count && len > 0)
 			{
 				var seg = this._segments[this._segNo];
 				var mem = seg.Memory;
 				var avs = mem.Length - this._lastSegmentLength;
 				avs = avs > len
 					? len
 					: avs;
 				var dmem = mem[this._lastSegmentLength..];
 
 #if HAS_SPAN_STREAM_OVERLOADS
                 stream.Read(dmem.Span);
 #else
 				var lsl = this._lastSegmentLength;
 				var slen = dmem.Span.Length - lsl;
 				stream.Read(buff, 0, slen);
 				buff.AsSpan(0, slen).CopyTo(dmem.Span);
 #endif
 				len -= dmem.Span.Length;
 
 				this.Length += (ulong)avs;
 				this._lastSegmentLength += avs;
 
 				if (this._lastSegmentLength == mem.Length)
 				{
 					this._segNo++;
 					this._lastSegmentLength = 0;
 				}
 			}
 		}
 
 		/// <summary>
 		/// Writes the stream unseekable.
 		/// </summary>
 		/// <param name="stream">The stream.</param>
 		private void WriteStreamUnseekable(Stream stream)
 		{
 			var read = 0;
 #if HAS_SPAN_STREAM_OVERLOADS
             Span<byte> buffs = stackalloc byte[this._segmentSize];
             while ((read = stream.Read(buffs)) != 0)
 #else
 			var buff = new byte[this._segmentSize];
 			var buffs = buff.AsSpan();
 			while ((read = stream.Read(buff, 0, buff.Length - this._lastSegmentLength)) != 0)
 #endif
 				this.Write(MemoryMarshal.Cast<byte, T>(buffs[..read]));
 		}
 
 		/// <inheritdoc />
 		public bool Read(Span<T> destination, ulong source, out int itemsWritten)
 		{
 			itemsWritten = 0;
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 			source *= (ulong)this._itemSize;
 			if (source > this.Count)
 				throw new ArgumentOutOfRangeException(nameof(source), "Cannot copy data from beyond the buffer.");
 
 			// Find where to begin
 			var i = 0;
 			for (; i < this._segments.Count; i++)
 			{
 				var seg = this._segments[i];
 				var mem = seg.Memory;
 				if ((ulong)mem.Length > source)
 					break;
 
 				source -= (ulong)mem.Length;
 			}
 
 			// Do actual copy
 			var dl = (int)(this.Length - source);
 			var sri = (int)source;
 			var dst = MemoryMarshal.AsBytes(destination);
 			for (; i < this._segments.Count && dst.Length > 0; i++)
 			{
 				var seg = this._segments[i];
 				var mem = seg.Memory;
 				var src = mem.Span;
 
 				if (sri != 0)
 				{
 					src = src[sri..];
 					sri = 0;
 				}
 
 				if (itemsWritten + src.Length > dl)
 					src = src[..(dl - itemsWritten)];
 
 				if (src.Length > dst.Length)
 					src = src[..dst.Length];
 
 				src.CopyTo(dst);
 				dst = dst[src.Length..];
 				itemsWritten += src.Length;
 			}
 
 			itemsWritten /= this._itemSize;
-			return (this.Length - source) != (ulong)itemsWritten;
+			return this.Length - source != (ulong)itemsWritten;
 		}
 
 		/// <inheritdoc />
 		public bool Read(T[] data, int start, int count, ulong source, out int itemsWritten)
 			=> this.Read(data.AsSpan(start, count), source, out itemsWritten);
 
 		/// <inheritdoc />
 		public bool Read(ArraySegment<T> data, ulong source, out int itemsWritten)
 			=> this.Read(data.AsSpan(), source, out itemsWritten);
 
 		/// <inheritdoc />
 		public T[] ToArray()
 		{
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 			var bytes = new T[this.Count];
 			this.Read(bytes, 0, out _);
 			return bytes;
 		}
 
 		/// <inheritdoc />
 		public void CopyTo(Stream destination)
 		{
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 #if HAS_SPAN_STREAM_OVERLOADS
             foreach (var seg in this._segments)
                 destination.Write(seg.Memory.Span);
 #else
 			var longest = this._segments.Max(x => x.Memory.Length);
 			var buff = new byte[longest];
 
 			foreach (var seg in this._segments)
 			{
 				var mem = seg.Memory.Span;
 				var spn = buff.AsSpan(0, mem.Length);
 
 				mem.CopyTo(spn);
 				destination.Write(buff, 0, spn.Length);
 			}
 #endif
 		}
 
 		/// <inheritdoc />
 		public void Clear()
 		{
 			if (this._isDisposed)
 				throw new ObjectDisposedException("This buffer is disposed.");
 
 			this._segNo = 0;
 			this._lastSegmentLength = 0;
 			this.Length = 0;
 		}
 
 		/// <summary>
 		/// Disposes of any resources claimed by this buffer.
 		/// </summary>
 		public void Dispose()
 		{
 			if (this._isDisposed)
 				return;
 
 			this._isDisposed = true;
 			foreach (var segment in this._segments)
 			{
 				if (this._clear)
 					segment.Memory.Span.Clear();
 
 				segment.Dispose();
 			}
 		}
 
 		/// <summary>
 		/// Grows the.
 		/// </summary>
 		/// <param name="minAmount">The min amount.</param>
 		private void Grow(int minAmount)
 		{
 			var capacity = this.Capacity;
 			var length = this.Length;
-			var totalAmt = (length + (ulong)minAmount);
+			var totalAmt = length + (ulong)minAmount;
 			if (capacity >= totalAmt)
 				return; // we're good
 
 			var amt = (int)(totalAmt - capacity);
 			var segCount = amt / this._segmentSize;
 			if (amt % this._segmentSize != 0)
 				segCount++;
 
 			// Basically List<T>.EnsureCapacity
 			// Default grow behaviour is minimum current*2
 			var segCap = this._segments.Count + segCount;
 			if (segCap > this._segments.Capacity)
 				this._segments.Capacity = segCap < this._segments.Capacity * 2
 					? this._segments.Capacity * 2
 					: segCap;
 
 			for (var i = 0; i < segCount; i++)
 				this._segments.Add(this._pool.Rent(this._segmentSize));
 		}
 	}
 }
diff --git a/DisCatSharp.Common/Types/Optional.cs b/DisCatSharp.Common/Types/Optional.cs
index 8d537369b..79c671b5d 100644
--- a/DisCatSharp.Common/Types/Optional.cs
+++ b/DisCatSharp.Common/Types/Optional.cs
@@ -1,226 +1,226 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Diagnostics;
 
 namespace DisCatSharp.Common
 {
 	/// <summary>
 	/// Represents a property with an optional value.
 	/// </summary>
 	/// <typeparam name="T">Type of the value.</typeparam>
 	[DebuggerDisplay(@"{DEBUGGER_DISPLAY,nq}")]
 	public struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>
 	{
 		/// <summary>
 		/// Gets an initialized instance of <see cref="Optional{T}"/> which has no value set.
 		/// </summary>
-		public static Optional<T> Default { get; } = new Optional<T>();
+		public static Optional<T> Default { get; } = new();
 
 		/// <summary>
 		/// Gets whether the value of this <see cref="Optional{T}"/> is present.
 		/// </summary>
 		public bool HasValue { get; }
 
 		/// <summary>
 		/// Gets the value of this <see cref="Optional{T}"/>. Will throw if a value is not present.
 		/// </summary>
 		public T Value
 			=> this.HasValue ? this._value : throw new InvalidOperationException("This property has no value set.");
 		private readonly T _value;
 
 		/// <summary>
 		/// Gets the debugger display.
 		/// </summary>
 		private string DEBUGGER_DISPLAY
 			=> this.HasValue ? $"Optional<{typeof(T)}> <has value> {this._value?.ToString() ?? "<null>"}" : $"Optional<{typeof(T)}> <has no value>";
 
 		/// <summary>
 		/// Creates a new <see cref="Optional{T}"/> property with specified value.
 		/// </summary>
 		/// <param name="value">Value of this property.</param>
 		public Optional(T value)
 		{
 			this.HasValue = true;
 			this._value = value;
 		}
 
 		/// <summary>
 		/// Returns hash code of the underlying value.
 		/// </summary>
 		/// <returns>Hash code of the underlying value.</returns>
 		public override int GetHashCode()
 			=> this.HasValue ? this._value?.GetHashCode() ?? 0 : 0;
 
 		/// <summary>
 		/// Checks whether the value of this property is equal to another value.
 		/// </summary>
 		/// <param name="obj">Object to compare against.</param>
 		/// <returns>Whether the supplied object is equal to the value of this property.</returns>
 		public override bool Equals(object obj)
 		{
 			if (obj is Optional<T> opt)
 				return this.Equals(opt);
 
 			if (obj is T val)
 				return this.Equals(val);
 
 			if (!this.HasValue && obj == null)
 				return true;
 
 			if (this.HasValue)
 				return object.Equals(this._value, obj);
 
 			return false;
 		}
 
 		/// <summary>
 		/// Checks whether this property is equal to another property.
 		/// </summary>
 		/// <param name="other">Property to compare against.</param>
 		/// <returns>Whether the supplied property is equal to this property.</returns>
 		public bool Equals(Optional<T> other)
 		{
 			if (!this.HasValue && !other.HasValue)
 				return true;
 			else if (this.HasValue != other.HasValue)
 				return false;
 			else
 				return object.Equals(this._value, other._value);
 		}
 
 		/// <summary>
 		/// Checks whether this proerty's value is equal to another value.
 		/// </summary>
 		/// <param name="other">Value to compare this property's value against.</param>
 		/// <returns>Whether the supplied value is equal to the value of this property.</returns>
 		public bool Equals(T other)
 		{
 			if (!this.HasValue && other == null)
 				return true;
 
 			if (this.HasValue)
 				return object.Equals(this._value, other);
 
 			return false;
 		}
 
 		/// <summary>
 		/// Returns a string representation of the underlying value, if present.
 		/// </summary>
 		/// <returns>String representation of the underlying value, if present.</returns>
 		public override string ToString()
 			=> this.HasValue ? this._value?.ToString() : "<no value>";
 
 		/// <summary>
 		/// Converts a specified value into an optional property of the value's type. The resulting property will have
 		/// its value set to the supplied one.
 		/// </summary>
 		/// <param name="value">Value to convert into an optional property.</param>
 		public static implicit operator Optional<T>(T value)
-			=> new Optional<T>(value);
+			=> new(value);
 
 		/// <summary>
 		/// Compares two properties and returns whether they are equal.
 		/// </summary>
 		/// <param name="left">Property to compare against.</param>
 		/// <param name="right">Property to compare.</param>
 		/// <returns>Whether the two properties are equal.</returns>
 		public static bool operator ==(Optional<T> left, Optional<T> right)
 			=> left.Equals(right);
 
 		/// <summary>
 		/// Compares two properties and returns whether they are not equal.
 		/// </summary>
 		/// <param name="left">Property to compare against.</param>
 		/// <param name="right">Property to compare.</param>
 		/// <returns>Whether the two properties are not equal.</returns>
 		public static bool operator !=(Optional<T> left, Optional<T> right)
 			=> !left.Equals(right);
 
 		/// <summary>
 		/// Compares a property's value against another value, and returns whether they are equal.
 		/// </summary>
 		/// <param name="left">Property to compare against.</param>
 		/// <param name="right">Value to compare.</param>
 		/// <returns>Whether the property's value is equal to the specified value.</returns>
 		public static bool operator ==(Optional<T> left, T right)
 			=> left.Equals(right);
 
 		/// <summary>
 		/// Compares a property's value against another value, and returns whether they are not equal.
 		/// </summary>
 		/// <param name="left">Property to compare against.</param>
 		/// <param name="right">Value to compare.</param>
 		/// <returns>Whether this property's value is not equal to the specified value.</returns>
 		public static bool operator !=(Optional<T> left, T right)
 			=> !left.Equals(right);
 
 		/// <summary>
 		/// Checks whether specified property has a value.
 		/// </summary>
 		/// <param name="opt">Property to check.</param>
 		/// <returns>Whether the property has a value.</returns>
 		public static bool operator true(Optional<T> opt)
 			=> opt.HasValue;
 
 		/// <summary>
 		/// Checks whether specified property has no value.
 		/// </summary>
 		/// <param name="opt">Property to check.</param>
 		/// <returns>Whether the property has no value.</returns>
 		public static bool operator false(Optional<T> opt)
 			=> !opt.HasValue;
 	}
 
 	/// <summary>
 	/// Utilities for creation of optional properties.
 	/// </summary>
 	public static class Optional
 	{
 		/// <summary>
 		/// Creates a new <see cref="Optional{T}"/> from a value of type <typeparamref name="T"/>.
 		/// </summary>
 		/// <typeparam name="T">Type of the value to create an optional property for.</typeparam>
 		/// <param name="value">Value to set the property to.</param>
 		/// <returns>Created optional property, which has a specified value set.</returns>
 		public static Optional<T> FromValue<T>(T value)
-			=> new Optional<T>(value);
+			=> new(value);
 
 		/// <summary>
 		/// Creates a new <see cref="Optional{T}"/> from a default value for type <typeparamref name="T"/>.
 		/// </summary>
 		/// <typeparam name="T">Type of the value to create an optional property for.</typeparam>
 		/// <returns>Created optional property, which has a default value for <typeparamref name="T"/> set.</returns>
 		public static Optional<T> FromDefaultValue<T>()
-			=> new Optional<T>(default);
+			=> new(default);
 
 		/// <summary>
 		/// Creates a new <see cref="Optional{T}"/> which has no value.
 		/// </summary>
 		/// <typeparam name="T">Type of the value to create an optional property for.</typeparam>
 		/// <returns>Created optional property, which has no value set.</returns>
 		public static Optional<T> FromNoValue<T>()
 			=> Optional<T>.Default;
 	}
 }
diff --git a/DisCatSharp.Common/Types/SecureRandom.cs b/DisCatSharp.Common/Types/SecureRandom.cs
index e27526a15..2d6ff778c 100644
--- a/DisCatSharp.Common/Types/SecureRandom.cs
+++ b/DisCatSharp.Common/Types/SecureRandom.cs
@@ -1,348 +1,342 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Buffers;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
 
 namespace DisCatSharp.Common
 {
 	/// <summary>
 	/// Provides a cryptographically-secure pseudorandom number generator (CSPRNG) implementation compatible with <see cref="System.Random"/>.
 	/// </summary>
 	public sealed class SecureRandom : Random, IDisposable
 	{
 		/// <summary>
 		/// Gets the r n g.
 		/// </summary>
 		private readonly RandomNumberGenerator _rng = RandomNumberGenerator.Create();
 
-		private volatile bool _isDisposed = false;
+		private volatile bool _isDisposed;
 
 		/// <summary>
 		/// Creates a new instance of <see cref="SecureRandom"/>.
 		/// </summary>
 		public SecureRandom()
 		{ }
 
 		/// <summary>
 		/// Finalizes this <see cref="SecureRandom"/> instance by disposing it.
 		/// </summary>
 		~SecureRandom()
 		{
 			this.Dispose();
 		}
 
 		/// <summary>
 		/// Fills a supplied buffer with random bytes.
 		/// </summary>
 		/// <param name="buffer">Buffer to fill with random bytes.</param>
-		public void GetBytes(byte[] buffer)
-		{
-			this._rng.GetBytes(buffer);
-		}
+		public void GetBytes(byte[] buffer) => this._rng.GetBytes(buffer);
 
 		/// <summary>
 		/// Fills a supplied buffer with random nonzero bytes.
 		/// </summary>
 		/// <param name="buffer">Buffer to fill with random nonzero bytes.</param>
-		public void GetNonZeroBytes(byte[] buffer)
-		{
-			this._rng.GetNonZeroBytes(buffer);
-		}
+		public void GetNonZeroBytes(byte[] buffer) => this._rng.GetNonZeroBytes(buffer);
 
 		/// <summary>
 		/// Fills a supplied memory region with random bytes.
 		/// </summary>
 		/// <param name="buffer">Memmory region to fill with random bytes.</param>
 		public void GetBytes(Span<byte> buffer)
 		{
 #if NETCOREAPP
             this.RNG.GetBytes(buffer);
 #else
 			var buff = ArrayPool<byte>.Shared.Rent(buffer.Length);
 			try
 			{
 				var buffSpan = buff.AsSpan(0, buffer.Length);
 				this._rng.GetBytes(buff);
 				buffSpan.CopyTo(buffer);
 			}
 			finally
 			{
 				ArrayPool<byte>.Shared.Return(buff);
 			}
 #endif
 		}
 
 		/// <summary>
 		/// Fills a supplied memory region with random nonzero bytes.
 		/// </summary>
 		/// <param name="buffer">Memmory region to fill with random nonzero bytes.</param>
 		public void GetNonZeroBytes(Span<byte> buffer)
 		{
 #if NETCOREAPP
             this.RNG.GetNonZeroBytes(buffer);
 #else
 			var buff = ArrayPool<byte>.Shared.Rent(buffer.Length);
 			try
 			{
 				var buffSpan = buff.AsSpan(0, buffer.Length);
 				this._rng.GetNonZeroBytes(buff);
 				buffSpan.CopyTo(buffer);
 			}
 			finally
 			{
 				ArrayPool<byte>.Shared.Return(buff);
 			}
 #endif
 		}
 
 		/// <summary>
 		/// Generates a signed 8-bit integer within specified range.
 		/// </summary>
 		/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 		/// <param name="max">Maximum value to generate. Defaults to <see cref="sbyte.MaxValue"/>.</param>
 		/// <returns>Generated random value.</returns>
 		public sbyte GetInt8(sbyte min = 0, sbyte max = sbyte.MaxValue)
 		{
 			if (max <= min)
 				throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 			var offset = (sbyte)(min < 0 ? -min : 0);
 			min += offset;
 			max += offset;
 
 			return (sbyte)(Math.Abs(this.Generate<sbyte>()) % (max - min) + min - offset);
 		}
 
 		/// <summary>
 		/// Generates a unsigned 8-bit integer within specified range.
 		/// </summary>
 		/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 		/// <param name="max">Maximum value to generate. Defaults to <see cref="byte.MaxValue"/>.</param>
 		/// <returns>Generated random value.</returns>
 		public byte GetUInt8(byte min = 0, byte max = byte.MaxValue)
 		{
 			if (max <= min)
 				throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 			return (byte)(this.Generate<byte>() % (max - min) + min);
 		}
 
 		/// <summary>
 		/// Generates a signed 16-bit integer within specified range.
 		/// </summary>
 		/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 		/// <param name="max">Maximum value to generate. Defaults to <see cref="short.MaxValue"/>.</param>
 		/// <returns>Generated random value.</returns>
 		public short GetInt16(short min = 0, short max = short.MaxValue)
 		{
 			if (max <= min)
 				throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 			var offset = (short)(min < 0 ? -min : 0);
 			min += offset;
 			max += offset;
 
 			return (short)(Math.Abs(this.Generate<short>()) % (max - min) + min - offset);
 		}
 
 		/// <summary>
 		/// Generates a unsigned 16-bit integer within specified range.
 		/// </summary>
 		/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 		/// <param name="max">Maximum value to generate. Defaults to <see cref="ushort.MaxValue"/>.</param>
 		/// <returns>Generated random value.</returns>
 		public ushort GetUInt16(ushort min = 0, ushort max = ushort.MaxValue)
 		{
 			if (max <= min)
 				throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 			return (ushort)(this.Generate<ushort>() % (max - min) + min);
 		}
 
 		/// <summary>
 		/// Generates a signed 32-bit integer within specified range.
 		/// </summary>
 		/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 		/// <param name="max">Maximum value to generate. Defaults to <see cref="int.MaxValue"/>.</param>
 		/// <returns>Generated random value.</returns>
 		public int GetInt32(int min = 0, int max = int.MaxValue)
 		{
 			if (max <= min)
 				throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 			var offset = min < 0 ? -min : 0;
 			min += offset;
 			max += offset;
 
 			return Math.Abs(this.Generate<int>()) % (max - min) + min - offset;
 		}
 
 		/// <summary>
 		/// Generates a unsigned 32-bit integer within specified range.
 		/// </summary>
 		/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 		/// <param name="max">Maximum value to generate. Defaults to <see cref="uint.MaxValue"/>.</param>
 		/// <returns>Generated random value.</returns>
 		public uint GetUInt32(uint min = 0, uint max = uint.MaxValue)
 		{
 			if (max <= min)
 				throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 			return this.Generate<uint>() % (max - min) + min;
 		}
 
 		/// <summary>
 		/// Generates a signed 64-bit integer within specified range.
 		/// </summary>
 		/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 		/// <param name="max">Maximum value to generate. Defaults to <see cref="long.MaxValue"/>.</param>
 		/// <returns>Generated random value.</returns>
 		public long GetInt64(long min = 0, long max = long.MaxValue)
 		{
 			if (max <= min)
 				throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 			var offset = min < 0 ? -min : 0;
 			min += offset;
 			max += offset;
 
 			return Math.Abs(this.Generate<long>()) % (max - min) + min - offset;
 		}
 
 		/// <summary>
 		/// Generates a unsigned 64-bit integer within specified range.
 		/// </summary>
 		/// <param name="min">Minimum value to generate. Defaults to 0.</param>
 		/// <param name="max">Maximum value to generate. Defaults to <see cref="ulong.MaxValue"/>.</param>
 		/// <returns>Generated random value.</returns>
 		public ulong GetUInt64(ulong min = 0, ulong max = ulong.MaxValue)
 		{
 			if (max <= min)
 				throw new ArgumentException("Maximum needs to be greater than minimum.", nameof(max));
 
 			return this.Generate<ulong>() % (max - min) + min;
 		}
 
 		/// <summary>
 		/// Generates a 32-bit floating-point number between 0.0 and 1.0.
 		/// </summary>
 		/// <returns>Generated 32-bit floating-point number.</returns>
 		public float GetSingle()
 		{
 			var (i1, i2) = ((float)this.GetInt32(), (float)this.GetInt32());
 			return i1 / i2 % 1.0F;
 		}
 
 		/// <summary>
 		/// Generates a 64-bit floating-point number between 0.0 and 1.0.
 		/// </summary>
 		/// <returns>Generated 64-bit floating-point number.</returns>
 		public double GetDouble()
 		{
 			var (i1, i2) = ((double)this.GetInt64(), (double)this.GetInt64());
 			return i1 / i2 % 1.0;
 		}
 
 		/// <summary>
 		/// Generates a 32-bit integer between 0 and <see cref="int.MaxValue"/>. Upper end exclusive.
 		/// </summary>
 		/// <returns>Generated 32-bit integer.</returns>
 		public override int Next()
 			=> this.GetInt32();
 
 		/// <summary>
 		/// Generates a 32-bit integer between 0 and <paramref name="maxValue"/>. Upper end exclusive.
 		/// </summary>
 		/// <param name="maxValue">Maximum value of the generated integer.</param>
 		/// <returns>Generated 32-bit integer.</returns>
 		public override int Next(int maxValue)
 			=> this.GetInt32(0, maxValue);
 
 		/// <summary>
 		/// Generates a 32-bit integer between <paramref name="minValue"/> and <paramref name="maxValue"/>. Upper end exclusive.
 		/// </summary>
 		/// <param name="minValue">Minimum value of the generate integer.</param>
 		/// <param name="maxValue">Maximum value of the generated integer.</param>
 		/// <returns>Generated 32-bit integer.</returns>
 		public override int Next(int minValue, int maxValue)
 			=> this.GetInt32(minValue, maxValue);
 
 		/// <summary>
 		/// Generates a 64-bit floating-point number between 0.0 and 1.0. Upper end exclusive.
 		/// </summary>
 		/// <returns>Generated 64-bit floating-point number.</returns>
 		public override double NextDouble()
 			=> this.GetDouble();
 
 		/// <summary>
 		/// Fills specified buffer with random bytes.
 		/// </summary>
 		/// <param name="buffer">Buffer to fill with bytes.</param>
 		public override void NextBytes(byte[] buffer)
 			=> this.GetBytes(buffer);
 
 		/// <summary>
 		/// Fills specified memory region with random bytes.
 		/// </summary>
 		/// <param name="buffer">Memory region to fill with bytes.</param>
 #if NETCOREAPP
         override
 #endif
 		public new void NextBytes(Span<byte> buffer)
 			=> this.GetBytes(buffer);
 
 		/// <summary>
 		/// Disposes this <see cref="SecureRandom"/> instance and its resources.
 		/// </summary>
 		public void Dispose()
 		{
 			if (this._isDisposed)
 				return;
 
 			this._isDisposed = true;
 			this._rng.Dispose();
 		}
 
 		/// <summary>
 		/// Generates a random 64-bit floating-point number between 0.0 and 1.0. Upper end exclusive.
 		/// </summary>
 		/// <returns>Generated 64-bit floating-point number.</returns>
 		protected override double Sample()
 			=> this.GetDouble();
 
 		/// <summary>
 		/// Generates the.
 		/// </summary>
 		/// <returns>A T.</returns>
 		private T Generate<T>() where T : struct
 		{
 			var size = Unsafe.SizeOf<T>();
 			Span<byte> buff = stackalloc byte[size];
 			this.GetBytes(buff);
 			return MemoryMarshal.Read<T>(buff);
 		}
 	}
 }
diff --git a/DisCatSharp.Common/Utilities/AsyncEvent/AsyncEvent.cs b/DisCatSharp.Common/Utilities/AsyncEvent/AsyncEvent.cs
index ae92f6229..c8a0550db 100644
--- a/DisCatSharp.Common/Utilities/AsyncEvent/AsyncEvent.cs
+++ b/DisCatSharp.Common/Utilities/AsyncEvent/AsyncEvent.cs
@@ -1,204 +1,201 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Common.Utilities
 {
 	/// <summary>
 	/// ABC for <see cref="AsyncEvent{TSender, TArgs}"/>, allowing for using instances thereof without knowing the underlying instance's type parameters.
 	/// </summary>
 	public abstract class AsyncEvent
 	{
 		/// <summary>
 		/// Gets the name of this event.
 		/// </summary>
 		public string Name { get; }
 
 		/// <summary>
 		/// Prevents a default instance of the <see cref="AsyncEvent"/> class from being created.
 		/// </summary>
 		/// <param name="name">The name.</param>
 		private protected AsyncEvent(string name)
 		{
 			this.Name = name;
 		}
 	}
 
 	/// <summary>
 	/// Implementation of asynchronous event. The handlers of such events are executed asynchronously, but sequentially.
 	/// </summary>
 	/// <typeparam name="TSender">Type of the object that dispatches this event.</typeparam>
 	/// <typeparam name="TArgs">Type of event argument object passed to this event's handlers.</typeparam>
 	public sealed class AsyncEvent<TSender, TArgs> : AsyncEvent
 		where TArgs : AsyncEventArgs
 	{
 		/// <summary>
 		/// Gets the maximum alloted execution time for all handlers. Any event which causes the handler to time out 
 		/// will raise a non-fatal <see cref="AsyncEventTimeoutException{TSender, TArgs}"/>.
 		/// </summary>
 		public TimeSpan MaximumExecutionTime { get; }
 
-		private readonly object _lock = new object();
+		private readonly object _lock = new();
 		private ImmutableArray<AsyncEventHandler<TSender, TArgs>> _handlers;
 		private readonly AsyncEventExceptionHandler<TSender, TArgs> _exceptionHandler;
 
 		/// <summary>
 		/// Creates a new asynchronous event with specified name and exception handler.
 		/// </summary>
 		/// <param name="name">Name of this event.</param>
 		/// <param name="maxExecutionTime">Maximum handler execution time. A value of <see cref="System.TimeSpan.Zero"/> means infinite.</param>
 		/// <param name="exceptionHandler">Delegate which handles exceptions caused by this event.</param>
 		public AsyncEvent(string name, TimeSpan maxExecutionTime, AsyncEventExceptionHandler<TSender, TArgs> exceptionHandler)
 			: base(name)
 		{
 			this._handlers = ImmutableArray<AsyncEventHandler<TSender, TArgs>>.Empty;
 			this._exceptionHandler = exceptionHandler;
 
 			this.MaximumExecutionTime = maxExecutionTime;
 		}
 
 		/// <summary>
 		/// Registers a new handler for this event.
 		/// </summary>
 		/// <param name="handler">Handler to register for this event.</param>
 		public void Register(AsyncEventHandler<TSender, TArgs> handler)
 		{
 			if (handler == null)
 				throw new ArgumentNullException(nameof(handler));
 
 			lock (this._lock)
 				this._handlers = this._handlers.Add(handler);
 		}
 
 		/// <summary>
 		/// Unregisters an existing handler from this event.
 		/// </summary>
 		/// <param name="handler">Handler to unregister from the event.</param>
 		public void Unregister(AsyncEventHandler<TSender, TArgs> handler)
 		{
 			if (handler == null)
 				throw new ArgumentNullException(nameof(handler));
 
 			lock (this._lock)
 				this._handlers = this._handlers.Remove(handler);
 		}
 
 		/// <summary>
 		/// Unregisters all existing handlers from this event.
 		/// </summary>
-		public void UnregisterAll()
-		{
-			this._handlers = ImmutableArray<AsyncEventHandler<TSender, TArgs>>.Empty;
-		}
+		public void UnregisterAll() => this._handlers = ImmutableArray<AsyncEventHandler<TSender, TArgs>>.Empty;
 
 		/// <summary>
 		/// <para>Raises this event by invoking all of its registered handlers, in order of registration.</para>
 		/// <para>All exceptions throw during invocation will be handled by the event's registered exception handler.</para>
 		/// </summary>
 		/// <param name="sender">Object which raised this event.</param>
 		/// <param name="e">Arguments for this event.</param>
 		/// <param name="exceptionMode">Defines what to do with exceptions caught from handlers.</param>
 		/// <returns></returns>
 		public async Task InvokeAsync(TSender sender, TArgs e, AsyncEventExceptionMode exceptionMode = AsyncEventExceptionMode.Default)
 		{
 			var handlers = this._handlers;
 			if (handlers.Length == 0)
 				return;
 
 			// Collect exceptions
 			List<Exception> exceptions = null;
 			if ((exceptionMode & AsyncEventExceptionMode.ThrowAll) != 0)
 				exceptions = new List<Exception>(handlers.Length * 2 /* timeout + regular */);
 
 			// If we have a timeout configured, start the timeout task
 			var timeout = this.MaximumExecutionTime > TimeSpan.Zero ? Task.Delay(this.MaximumExecutionTime) : null;
 			for (var i = 0; i < handlers.Length; i++)
 			{
 				var handler = handlers[i];
 				try
 				{
 					// Start the handler execution
 					var handlerTask = handler(sender, e);
 					if (handlerTask != null && timeout != null)
 					{
 						// If timeout is configured, wait for any task to finish
 						// If the timeout task finishes first, the handler is causing a timeout
 
 						var result = await Task.WhenAny(timeout, handlerTask).ConfigureAwait(false);
 						if (result == timeout)
 						{
 							timeout = null;
 							var timeoutEx = new AsyncEventTimeoutException<TSender, TArgs>(this, handler);
 
 							// Notify about the timeout and complete execution
 							if ((exceptionMode & AsyncEventExceptionMode.HandleNonFatal) == AsyncEventExceptionMode.HandleNonFatal)
 								this.HandleException(timeoutEx, handler, sender, e);
 
 							if ((exceptionMode & AsyncEventExceptionMode.ThrowNonFatal) == AsyncEventExceptionMode.ThrowNonFatal)
 								exceptions.Add(timeoutEx);
 
 							await handlerTask.ConfigureAwait(false);
 						}
 					}
 					else if (handlerTask != null)
 					{
 						// No timeout is configured, or timeout already expired, proceed as usual
 						await handlerTask.ConfigureAwait(false);
 					}
 
 					if (e.Handled)
 						break;
 				}
 				catch (Exception ex)
 				{
 					e.Handled = false;
 
 					if ((exceptionMode & AsyncEventExceptionMode.HandleFatal) == AsyncEventExceptionMode.HandleFatal)
 						this.HandleException(ex, handler, sender, e);
 
 					if ((exceptionMode & AsyncEventExceptionMode.ThrowFatal) == AsyncEventExceptionMode.ThrowFatal)
 						exceptions.Add(ex);
 				}
 			}
 
 			if ((exceptionMode & AsyncEventExceptionMode.ThrowAll) != 0 && exceptions.Count > 0)
 				throw new AggregateException("Exceptions were thrown during execution of the event's handlers.", exceptions);
 		}
 
 		/// <summary>
 		/// Handles the exception.
 		/// </summary>
 		/// <param name="ex">The ex.</param>
 		/// <param name="handler">The handler.</param>
 		/// <param name="sender">The sender.</param>
 		/// <param name="args">The args.</param>
 		private void HandleException(Exception ex, AsyncEventHandler<TSender, TArgs> handler, TSender sender, TArgs args)
 		{
 			if (this._exceptionHandler != null)
 				this._exceptionHandler(this, ex, handler, sender, args);
 		}
 	}
 }
diff --git a/DisCatSharp.Common/Utilities/AsyncExecutor.cs b/DisCatSharp.Common/Utilities/AsyncExecutor.cs
index 4e3733d83..f695b980e 100644
--- a/DisCatSharp.Common/Utilities/AsyncExecutor.cs
+++ b/DisCatSharp.Common/Utilities/AsyncExecutor.cs
@@ -1,173 +1,173 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Common.Utilities
 {
 	/// <summary>
 	/// Provides a simplified way of executing asynchronous code synchronously.
 	/// </summary>
 	public class AsyncExecutor
 	{
 		/// <summary>
 		/// Creates a new instance of asynchronous executor.
 		/// </summary>
 		public AsyncExecutor()
 		{ }
 
 		/// <summary>
 		/// Executes a specified task in an asynchronous manner, waiting for its completion.
 		/// </summary>
 		/// <param name="task">Task to execute.</param>
 		public void Execute(Task task)
 		{
 			// create state object
 			var taskState = new StateRef<object>(new AutoResetEvent(false));
 
 			// queue a task and wait for it to finish executing
 			task.ContinueWith(TaskCompletionHandler, taskState);
 			taskState.Lock.WaitOne();
 
 			// check for and rethrow any exceptions
 			if (taskState.Exception != null)
 				throw taskState.Exception;
 
 			// completion method
 			void TaskCompletionHandler(Task t, object state)
 			{
 				// retrieve state data
 				var stateRef = state as StateRef<object>;
 
 				// retrieve any exceptions or cancellation status
 				if (t.IsFaulted)
 				{
 					if (t.Exception.InnerExceptions.Count == 1) // unwrap if 1
 						stateRef.Exception = t.Exception.InnerException;
 					else
 						stateRef.Exception = t.Exception;
 				}
 				else if (t.IsCanceled)
 				{
 					stateRef.Exception = new TaskCanceledException(t);
 				}
 
 				// signal that the execution is done
 				stateRef.Lock.Set();
 			}
 		}
 
 		/// <summary>
 		/// Executes a specified task in an asynchronous manner, waiting for its completion, and returning the result.
 		/// </summary>
 		/// <typeparam name="T">Type of the Task's return value.</typeparam>
 		/// <param name="task">Task to execute.</param>
 		/// <returns>Task's result.</returns>
 		public T Execute<T>(Task<T> task)
 		{
 			// create state object
 			var taskState = new StateRef<T>(new AutoResetEvent(false));
 
 			// queue a task and wait for it to finish executing
 			task.ContinueWith(TaskCompletionHandler, taskState);
 			taskState.Lock.WaitOne();
 
 			// check for and rethrow any exceptions
 			if (taskState.Exception != null)
 				throw taskState.Exception;
 
 			// return the result, if any
 			if (taskState.HasResult)
 				return taskState.Result;
 
 			// throw exception if no result
 			throw new Exception("Task returned no result.");
 
 			// completion method
 			void TaskCompletionHandler(Task<T> t, object state)
 			{
 				// retrieve state data
 				var stateRef = state as StateRef<T>;
 
 				// retrieve any exceptions or cancellation status
 				if (t.IsFaulted)
 				{
 					if (t.Exception.InnerExceptions.Count == 1) // unwrap if 1
 						stateRef.Exception = t.Exception.InnerException;
 					else
 						stateRef.Exception = t.Exception;
 				}
 				else if (t.IsCanceled)
 				{
 					stateRef.Exception = new TaskCanceledException(t);
 				}
 
 				// return the result from the task, if any
 				if (t.IsCompleted && !t.IsFaulted)
 				{
 					stateRef.HasResult = true;
 					stateRef.Result = t.Result;
 				}
 
 				// signal that the execution is done
 				stateRef.Lock.Set();
 			}
 		}
 
 		/// <summary>
 		/// The state ref.
 		/// </summary>
 		private sealed class StateRef<T>
 		{
 			/// <summary>
 			/// Gets the lock used to wait for task's completion.
 			/// </summary>
 			public AutoResetEvent Lock { get; }
 
 			/// <summary>
 			/// Gets the exception that occured during task's execution, if any.
 			/// </summary>
 			public Exception Exception { get; set; }
 
 			/// <summary>
 			/// Gets the result returned by the task.
 			/// </summary>
 			public T Result { get; set; }
 
 			/// <summary>
 			/// Gets whether the task returned a result.
 			/// </summary>
-			public bool HasResult { get; set; } = false;
+			public bool HasResult { get; set; }
 
 			/// <summary>
 			/// Initializes a new instance of the <see cref="StateRef{T}"/> class.
 			/// </summary>
 			/// <param name="lock">The lock.</param>
 			public StateRef(AutoResetEvent @lock)
 			{
 				this.Lock = @lock;
 			}
 		}
 	}
 }
diff --git a/DisCatSharp.Common/Utilities/Extensions.cs b/DisCatSharp.Common/Utilities/Extensions.cs
index d5c946398..32ac6c0bc 100644
--- a/DisCatSharp.Common/Utilities/Extensions.cs
+++ b/DisCatSharp.Common/Utilities/Extensions.cs
@@ -1,490 +1,490 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 
 namespace DisCatSharp.Common
 {
 	/// <summary>
 	/// Assortment of various extension and utility methods, designed to make working with various types a little easier.
 	/// </summary>
 	public static class Extensions
 	{
 		/// <summary>
 		/// <para>Deconstructs a <see cref="System.Collections.Generic.Dictionary{TKey, TValue}"/> key-value pair item (<see cref="System.Collections.Generic.KeyValuePair{TKey, TValue}"/>) into 2 separate variables.</para>
 		/// <para>This allows for enumerating over dictionaries in foreach blocks by using a (k, v) tuple as the enumerator variable, instead of having to use a <see cref="System.Collections.Generic.KeyValuePair{TKey, TValue}"/> directly.</para>
 		/// </summary>
 		/// <typeparam name="TKey">Type of dictionary item key.</typeparam>
 		/// <typeparam name="TValue">Type of dictionary item value.</typeparam>
 		/// <param name="kvp">Key-value pair to deconstruct.</param>
 		/// <param name="key">Deconstructed key.</param>
 		/// <param name="value">Deconstructed value.</param>
 		public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> kvp, out TKey key, out TValue value)
 		{
 			key = kvp.Key;
 			value = kvp.Value;
 		}
 
 		/// <summary>
 		/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 		/// </summary>
 		/// <param name="num">Number to calculate the length of.</param>
 		/// <returns>Calculated number length.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static int CalculateLength(this sbyte num)
 			=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(Math.Abs(num == sbyte.MinValue ? num + 1 : num))) + (num < 0 ? 2 /* include sign */ : 1);
 
 		/// <summary>
 		/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 		/// </summary>
 		/// <param name="num">Number to calculate the length of.</param>
 		/// <returns>Calculated nuembr length.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static int CalculateLength(this byte num)
 			=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(num)) + 1;
 
 		/// <summary>
 		/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 		/// </summary>
 		/// <param name="num">Number to calculate the length of.</param>
 		/// <returns>Calculated number length.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static int CalculateLength(this short num)
 			=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(Math.Abs(num == short.MinValue ? num + 1 : num))) + (num < 0 ? 2 /* include sign */ : 1);
 
 		/// <summary>
 		/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 		/// </summary>
 		/// <param name="num">Number to calculate the length of.</param>
 		/// <returns>Calculated nuembr length.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static int CalculateLength(this ushort num)
 			=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(num)) + 1;
 
 		/// <summary>
 		/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 		/// </summary>
 		/// <param name="num">Number to calculate the length of.</param>
 		/// <returns>Calculated number length.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static int CalculateLength(this int num)
 			=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(Math.Abs(num == int.MinValue ? num + 1 : num))) + (num < 0 ? 2 /* include sign */ : 1);
 
 		/// <summary>
 		/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 		/// </summary>
 		/// <param name="num">Number to calculate the length of.</param>
 		/// <returns>Calculated nuembr length.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static int CalculateLength(this uint num)
 			=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(num)) + 1;
 
 		/// <summary>
 		/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 		/// </summary>
 		/// <param name="num">Number to calculate the length of.</param>
 		/// <returns>Calculated number length.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static int CalculateLength(this long num)
 			=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(Math.Abs(num == long.MinValue ? num + 1 : num))) + (num < 0 ? 2 /* include sign */ : 1);
 
 		/// <summary>
 		/// Calculates the length of string representation of given number in base 10 (including sign, if present).
 		/// </summary>
 		/// <param name="num">Number to calculate the length of.</param>
 		/// <returns>Calculated nuembr length.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static int CalculateLength(this ulong num)
 			=> num == 0 ? 1 : (int)Math.Floor(Math.Log10(num)) + 1;
 
 		/// <summary>
 		/// Tests wheter given value is in supplied range, optionally allowing it to be an exclusive check.
 		/// </summary>
 		/// <param name="num">Number to test.</param>
 		/// <param name="min">Lower bound of the range.</param>
 		/// <param name="max">Upper bound of the range.</param>
 		/// <param name="inclusive">Whether the check is to be inclusive.</param>
 		/// <returns>Whether the value is in range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsInRange(this sbyte num, sbyte min, sbyte max, bool inclusive = true)
 		{
 			if (min > max)
 			{
 				min ^= max;
 				max ^= min;
 				min ^= max;
 			}
 
-			return inclusive ? (num >= min && num <= max) : (num > min && num < max);
+			return inclusive ? num >= min && num <= max : num > min && num < max;
 		}
 
 		/// <summary>
 		/// Tests wheter given value is in supplied range, optionally allowing it to be an exclusive check.
 		/// </summary>
 		/// <param name="num">Number to test.</param>
 		/// <param name="min">Lower bound of the range.</param>
 		/// <param name="max">Upper bound of the range.</param>
 		/// <param name="inclusive">Whether the check is to be inclusive.</param>
 		/// <returns>Whether the value is in range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsInRange(this byte num, byte min, byte max, bool inclusive = true)
 		{
 			if (min > max)
 			{
 				min ^= max;
 				max ^= min;
 				min ^= max;
 			}
 
-			return inclusive ? (num >= min && num <= max) : (num > min && num < max);
+			return inclusive ? num >= min && num <= max : num > min && num < max;
 		}
 
 		/// <summary>
 		/// Tests wheter given value is in supplied range, optionally allowing it to be an exclusive check.
 		/// </summary>
 		/// <param name="num">Number to test.</param>
 		/// <param name="min">Lower bound of the range.</param>
 		/// <param name="max">Upper bound of the range.</param>
 		/// <param name="inclusive">Whether the check is to be inclusive.</param>
 		/// <returns>Whether the value is in range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsInRange(this short num, short min, short max, bool inclusive = true)
 		{
 			if (min > max)
 			{
 				min ^= max;
 				max ^= min;
 				min ^= max;
 			}
 
-			return inclusive ? (num >= min && num <= max) : (num > min && num < max);
+			return inclusive ? num >= min && num <= max : num > min && num < max;
 		}
 
 		/// <summary>
 		/// Tests wheter given value is in supplied range, optionally allowing it to be an exclusive check.
 		/// </summary>
 		/// <param name="num">Number to test.</param>
 		/// <param name="min">Lower bound of the range.</param>
 		/// <param name="max">Upper bound of the range.</param>
 		/// <param name="inclusive">Whether the check is to be inclusive.</param>
 		/// <returns>Whether the value is in range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsInRange(this ushort num, ushort min, ushort max, bool inclusive = true)
 		{
 			if (min > max)
 			{
 				min ^= max;
 				max ^= min;
 				min ^= max;
 			}
 
-			return inclusive ? (num >= min && num <= max) : (num > min && num < max);
+			return inclusive ? num >= min && num <= max : num > min && num < max;
 		}
 
 		/// <summary>
 		/// Tests wheter given value is in supplied range, optionally allowing it to be an exclusive check.
 		/// </summary>
 		/// <param name="num">Number to test.</param>
 		/// <param name="min">Lower bound of the range.</param>
 		/// <param name="max">Upper bound of the range.</param>
 		/// <param name="inclusive">Whether the check is to be inclusive.</param>
 		/// <returns>Whether the value is in range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsInRange(this int num, int min, int max, bool inclusive = true)
 		{
 			if (min > max)
 			{
 				min ^= max;
 				max ^= min;
 				min ^= max;
 			}
 
-			return inclusive ? (num >= min && num <= max) : (num > min && num < max);
+			return inclusive ? num >= min && num <= max : num > min && num < max;
 		}
 
 		/// <summary>
 		/// Tests wheter given value is in supplied range, optionally allowing it to be an exclusive check.
 		/// </summary>
 		/// <param name="num">Number to test.</param>
 		/// <param name="min">Lower bound of the range.</param>
 		/// <param name="max">Upper bound of the range.</param>
 		/// <param name="inclusive">Whether the check is to be inclusive.</param>
 		/// <returns>Whether the value is in range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsInRange(this uint num, uint min, uint max, bool inclusive = true)
 		{
 			if (min > max)
 			{
 				min ^= max;
 				max ^= min;
 				min ^= max;
 			}
 
-			return inclusive ? (num >= min && num <= max) : (num > min && num < max);
+			return inclusive ? num >= min && num <= max : num > min && num < max;
 		}
 
 		/// <summary>
 		/// Tests wheter given value is in supplied range, optionally allowing it to be an exclusive check.
 		/// </summary>
 		/// <param name="num">Number to test.</param>
 		/// <param name="min">Lower bound of the range.</param>
 		/// <param name="max">Upper bound of the range.</param>
 		/// <param name="inclusive">Whether the check is to be inclusive.</param>
 		/// <returns>Whether the value is in range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsInRange(this long num, long min, long max, bool inclusive = true)
 		{
 			if (min > max)
 			{
 				min ^= max;
 				max ^= min;
 				min ^= max;
 			}
 
-			return inclusive ? (num >= min && num <= max) : (num > min && num < max);
+			return inclusive ? num >= min && num <= max : num > min && num < max;
 		}
 
 		/// <summary>
 		/// Tests wheter given value is in supplied range, optionally allowing it to be an exclusive check.
 		/// </summary>
 		/// <param name="num">Number to test.</param>
 		/// <param name="min">Lower bound of the range.</param>
 		/// <param name="max">Upper bound of the range.</param>
 		/// <param name="inclusive">Whether the check is to be inclusive.</param>
 		/// <returns>Whether the value is in range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsInRange(this ulong num, ulong min, ulong max, bool inclusive = true)
 		{
 			if (min > max)
 			{
 				min ^= max;
 				max ^= min;
 				min ^= max;
 			}
 
-			return inclusive ? (num >= min && num <= max) : (num > min && num < max);
+			return inclusive ? num >= min && num <= max : num > min && num < max;
 		}
 
 		/// <summary>
 		/// Tests wheter given value is in supplied range, optionally allowing it to be an exclusive check.
 		/// </summary>
 		/// <param name="num">Number to test.</param>
 		/// <param name="min">Lower bound of the range.</param>
 		/// <param name="max">Upper bound of the range.</param>
 		/// <param name="inclusive">Whether the check is to be inclusive.</param>
 		/// <returns>Whether the value is in range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsInRange(this float num, float min, float max, bool inclusive = true)
 		{
 			if (min > max)
 				return false;
 
-			return inclusive ? (num >= min && num <= max) : (num > min && num < max);
+			return inclusive ? num >= min && num <= max : num > min && num < max;
 		}
 
 		/// <summary>
 		/// Tests wheter given value is in supplied range, optionally allowing it to be an exclusive check.
 		/// </summary>
 		/// <param name="num">Number to test.</param>
 		/// <param name="min">Lower bound of the range.</param>
 		/// <param name="max">Upper bound of the range.</param>
 		/// <param name="inclusive">Whether the check is to be inclusive.</param>
 		/// <returns>Whether the value is in range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsInRange(this double num, double min, double max, bool inclusive = true)
 		{
 			if (min > max)
 				return false;
 
-			return inclusive ? (num >= min && num <= max) : (num > min && num < max);
+			return inclusive ? num >= min && num <= max : num > min && num < max;
 		}
 
 		/// <summary>
 		/// Returns whether supplied character is in any of the following ranges: a-z, A-Z, 0-9.
 		/// </summary>
 		/// <param name="c">Character to test.</param>
 		/// <returns>Whether the character is in basic alphanumeric character range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsBasicAlphanumeric(this char c)
 			=> (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9');
 
 		/// <summary>
 		/// Returns whether supplied character is in the 0-9 range.
 		/// </summary>
 		/// <param name="c">Character to test.</param>
 		/// <returns>Whether the character is in basic numeric digit character range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsBasicDigit(this char c)
 			=> c >= '0' && c <= '9';
 
 		/// <summary>
 		/// Returns whether supplied character is in the a-z or A-Z range.
 		/// </summary>
 		/// <param name="c">Character to test.</param>
 		/// <returns>Whether the character is in basic letter character range.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool IsBasicLetter(this char c)
 			=> (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
 
 		/// <summary>
 		/// Tests whether given string ends with given character.
 		/// </summary>
 		/// <param name="s">String to test.</param>
 		/// <param name="c">Character to test for.</param>
 		/// <returns>Whether the supplied string ends with supplied character.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool EndsWithCharacter(this string s, char c)
 			=> s.Length >= 1 && s[^1] == c;
 
 		/// <summary>
 		/// Tests whether given string starts with given character.
 		/// </summary>
 		/// <param name="s">String to test.</param>
 		/// <param name="c">Character to test for.</param>
 		/// <returns>Whether the supplied string starts with supplied character.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static bool StartsWithCharacter(this string s, char c)
 			=> s.Length >= 1 && s[0] == c;
 
 		// https://stackoverflow.com/questions/9545619/a-fast-hash-function-for-string-in-c-sharp
 		// Calls are inlined to call the underlying method directly
 		/// <summary>
 		/// Computes a 64-bit Knuth hash from supplied characters.
 		/// </summary>
 		/// <param name="chars">Characters to compute the hash value from.</param>
 		/// <returns>Computer 64-bit Knuth hash.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static ulong CalculateKnuthHash(this ReadOnlySpan<char> chars)
 			=> Knuth(chars);
 
 		/// <summary>
 		/// Computes a 64-bit Knuth hash from supplied characters.
 		/// </summary>
 		/// <param name="chars">Characters to compute the hash value from.</param>
 		/// <returns>Computer 64-bit Knuth hash.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static ulong CalculateKnuthHash(this Span<char> chars)
 			=> Knuth(chars);
 
 		/// <summary>
 		/// Computes a 64-bit Knuth hash from supplied characters.
 		/// </summary>
 		/// <param name="chars">Characters to compute the hash value from.</param>
 		/// <returns>Computer 64-bit Knuth hash.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static ulong CalculateKnuthHash(this ReadOnlyMemory<char> chars)
 			=> Knuth(chars.Span);
 
 		/// <summary>
 		/// Computes a 64-bit Knuth hash from supplied characters.
 		/// </summary>
 		/// <param name="chars">Characters to compute the hash value from.</param>
 		/// <returns>Computer 64-bit Knuth hash.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static ulong CalculateKnuthHash(this Memory<char> chars)
 			=> Knuth(chars.Span);
 
 		/// <summary>
 		/// Computes a 64-bit Knuth hash from supplied characters.
 		/// </summary>
 		/// <param name="chars">Characters to compute the hash value from.</param>
 		/// <returns>Computer 64-bit Knuth hash.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static ulong CalculateKnuthHash(this ArraySegment<char> chars)
 			=> Knuth(chars.AsSpan());
 
 		/// <summary>
 		/// Computes a 64-bit Knuth hash from supplied characters.
 		/// </summary>
 		/// <param name="chars">Characters to compute the hash value from.</param>
 		/// <returns>Computer 64-bit Knuth hash.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static ulong CalculateKnuthHash(this char[] chars)
 			=> Knuth(chars.AsSpan());
 
 		/// <summary>
 		/// Computes a 64-bit Knuth hash from supplied characters.
 		/// </summary>
 		/// <param name="chars">Characters to compute the hash value from.</param>
 		/// <param name="start">Offset in the array to start calculating from.</param>
 		/// <param name="count">Number of characters to compute the hash from.</param>
 		/// <returns>Computer 64-bit Knuth hash.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static ulong CalculateKnuthHash(this char[] chars, int start, int count)
 			=> Knuth(chars.AsSpan(start, count));
 
 		/// <summary>
 		/// Computes a 64-bit Knuth hash from supplied characters.
 		/// </summary>
 		/// <param name="chars">Characters to compute the hash value from.</param>
 		/// <returns>Computer 64-bit Knuth hash.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static ulong CalculateKnuthHash(this string chars)
 			=> Knuth(chars.AsSpan());
 
 		/// <summary>
 		/// Computes a 64-bit Knuth hash from supplied characters.
 		/// </summary>
 		/// <param name="chars">Characters to compute the hash value from.</param>
 		/// <param name="start">Offset in the array to start calculating from.</param>
 		/// <param name="count">Number of characters to compute the hash from.</param>
 		/// <returns>Computer 64-bit Knuth hash.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static ulong CalculateKnuthHash(this string chars, int start, int count)
 			=> Knuth(chars.AsSpan(start, count));
 
 		/// <summary>
 		/// Firsts the two or default.
 		/// </summary>
 		/// <param name="enumerable">The enumerable.</param>
 		/// <returns>A (T first, T second) .</returns>
 		internal static (T first, T second) FirstTwoOrDefault<T>(this IEnumerable<T> enumerable)
 		{
 			using var enumerator = enumerable.GetEnumerator();
 
 			if (!enumerator.MoveNext())
 				return (default, default);
 
 			var first = enumerator.Current;
 
 			if (!enumerator.MoveNext())
 				return (first, default);
 
 			return (first, enumerator.Current);
 		}
 
 		/// <summary>
 		/// Knuths the.
 		/// </summary>
 		/// <param name="chars">The chars.</param>
 		/// <returns>An ulong.</returns>
 		private static ulong Knuth(ReadOnlySpan<char> chars)
 		{
 			var hash = 3074457345618258791ul;
 			for (var i = 0; i < chars.Length; i++)
 				hash = (hash + chars[i]) * 3074457345618258799ul;
 			return hash;
 		}
 	}
 }
diff --git a/DisCatSharp.Configuration.Tests/ConfigurationExtensionTests.cs b/DisCatSharp.Configuration.Tests/ConfigurationExtensionTests.cs
index fa9b34c93..0796fd4f8 100644
--- a/DisCatSharp.Configuration.Tests/ConfigurationExtensionTests.cs
+++ b/DisCatSharp.Configuration.Tests/ConfigurationExtensionTests.cs
@@ -1,334 +1,334 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using DisCatSharp.Configuration.Models;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using Xunit;
 
 namespace DisCatSharp.Configuration.Tests
 {
 	public class ConfigurationExtensionTests
 	{
 		#region Test Classes
 		class SampleClass
 		{
 			public int Amount { get; set; }
 			public string? Email { get; set; }
 		}
 
 		class ClassWithArray
 		{
 			public int[] Values { get; set; } = { 1, 2, 3, 4, 5 };
 			public string[] Strings { get; set; } = { "1", "2", "3", "4", "5" };
 		}
 
 		class ClassWithEnumerable
 		{
 			public IEnumerable<int> Values { get; set; } = new[] { 1, 2, 3, 4, 5 };
 			public IEnumerable<string> Strings { get; set; } = new[] { "1", "2", "3", "4", "5" };
 		}
 
 		class ClassWithList
 		{
-			public List<string> Strings { get; set; } = new List<string>
+			public List<string> Strings { get; set; } = new()
 			{
 				"1",
 				"2",
 				"3",
 				"4",
 				"5"
 			};
 
-			public List<int> Values { get; set; } = new List<int>
+			public List<int> Values { get; set; } = new()
 			{
 				1,
 				2,
 				3,
 				4,
 				5
 			};
 		}
 
 		class SampleClass2
 		{
 			public TimeSpan Timeout { get; set; } = TimeSpan.FromMinutes(7);
 			public string Name { get; set; } = "Sample";
 			public string ConstructorValue { get; }
 			public SampleClass2(string value)
 			{
 				this.ConstructorValue = value;
 			}
 		}
 		#endregion
 
 		private IConfiguration EnumerableTestConfiguration() =>
 			new ConfigurationBuilder()
 				.AddJsonFile("enumerable-test.json")
 				.Build();
 
 		private IConfiguration HasSectionWithSuffixConfiguration() =>
 			new ConfigurationBuilder()
 				.AddJsonFile("section-with-suffix.json")
 				.Build();
 
 		private IConfiguration HasSectionNoSuffixConfiguration() =>
 			new ConfigurationBuilder()
 				.AddJsonFile("section-no-suffix.json")
 				.Build();
 
 		private IConfiguration BasicDiscordConfiguration() => new ConfigurationBuilder()
 			.AddJsonFile("default-discord.json")
 			.Build();
 
 		private IConfiguration DiscordIntentsConfig() => new ConfigurationBuilder()
 				.AddJsonFile("intents-discord.json")
 				.Build();
 
 		private IConfiguration DiscordHaphazardConfig() => new ConfigurationBuilder()
 			.AddJsonFile("haphazard-discord.json")
 			.Build();
 
 		private IConfiguration SampleConfig() => new ConfigurationBuilder()
 			.AddInMemoryCollection(new Dictionary<string, string>
 			{
 				{ "Sample:Amount", "200" },
 				{ "Sample:Email", "test@gmail.com" }
 			})
 			.Build();
 
 		private IConfiguration SampleClass2Configuration_Default() => new ConfigurationBuilder()
 			.AddInMemoryCollection(new Dictionary<string, string>
 			{
 				{"Random:Stuff", "Meow"},
 				{"SampleClass2:Name", "Purfection"}
 			})
 			.Build();
 
 		private IConfiguration SampleClass2Configuration_Change() => new ConfigurationBuilder()
 			.AddInMemoryCollection(new Dictionary<string, string>
 			{
 				{ "SampleClass:Timeout", "01:30:00" }, { "SampleClass:NotValid", "Something" }
 			})
 			.Build();
 
 		private IConfiguration SampleClass2EnumerableTest() => new ConfigurationBuilder()
 			.AddInMemoryCollection(new Dictionary<string, string>
 			{
 				{ "SampleClass:EnumerableTest", "[\"10\",\"20\",\"30\"]" }
 			})
 			.Build();
 
 		private IConfiguration SampleClass2ArrayTest() => new ConfigurationBuilder()
 			.AddInMemoryCollection(new Dictionary<string, string>
 			{
 				{ "SampleClass:ArrayTest", "[\"10\",\"20\",\"30\"]" }
 			})
 			.Build();
 
 		private IConfiguration SampleClass2ListTest() => new ConfigurationBuilder()
 			.AddInMemoryCollection(new Dictionary<string, string>
 			{
 				{ "SampleClass:ListTest", "[\"10\",\"20\",\"30\"]" }
 			})
 			.Build();
 
 		[Fact]
 		public void TestExtractDiscordConfig_Intents()
 		{
 			var source = this.DiscordIntentsConfig();
 
 			var config = source.ExtractConfig<DiscordConfiguration>("Discord");
 
 			var expected = DiscordIntents.GuildEmojisAndStickers | DiscordIntents.GuildMembers |
 						   DiscordIntents.GuildInvites | DiscordIntents.GuildMessageReactions;
 
 			Assert.Equal(expected, config.Intents);
 		}
 
 		[Fact]
 		public void TestExtractDiscordConfig_Haphzard()
 		{
 			var source = this.DiscordHaphazardConfig();
 
 			var config = source.ExtractConfig<DiscordConfiguration>("Discord");
 			var expectedIntents = DiscordIntents.GuildEmojisAndStickers | DiscordIntents.GuildMembers |
 								  DiscordIntents.Guilds;
 
 			Assert.Equal(expectedIntents, config.Intents);
 			Assert.True(config.MobileStatus);
 			Assert.Equal(1000, config.LargeThreshold);
 			Assert.Equal(TimeSpan.FromHours(10), config.HttpTimeout);
 		}
 
 		[Fact]
 		public void TestExtractDiscordConfig_Default()
 		{
 			var source = this.BasicDiscordConfiguration();
 			var config = source.ExtractConfig<DiscordConfiguration>("Discord");
 
 			Assert.Equal("1234567890", config.Token);
 			Assert.Equal(TokenType.Bot, config.TokenType);
 			Assert.Equal(LogLevel.Information, config.MinimumLogLevel);
 			Assert.True(config.UseRelativeRatelimit);
 			Assert.Equal("yyyy-MM-dd HH:mm:ss zzz", config.LogTimestampFormat);
 			Assert.Equal(250, config.LargeThreshold);
 			Assert.True(config.AutoReconnect);
 			Assert.Equal(123123, config.ShardId);
 			Assert.Equal(GatewayCompressionLevel.Stream, config.GatewayCompressionLevel);
 			Assert.Equal(1024, config.MessageCacheSize);
 			Assert.Equal(TimeSpan.FromSeconds(20), config.HttpTimeout);
 			Assert.False(config.ReconnectIndefinitely);
 			Assert.True(config.AlwaysCacheMembers);
 			Assert.Equal(DiscordIntents.AllUnprivileged, config.Intents);
 			Assert.False(config.MobileStatus);
 			Assert.False(config.UseCanary);
 			Assert.False(config.AutoRefreshChannelCache);
 		}
 
 		[Fact]
 		public void TestSection()
 		{
 			var source = this.SampleConfig();
 			var config = source.ExtractConfig<SampleClass>("Sample", null);
 
 			Assert.Equal(200, config.Amount);
 			Assert.Equal("test@gmail.com", config.Email);
 		}
 
 		[Fact]
 		public void TestExtractConfig_V2_Default()
 		{
 			var source = this.SampleClass2Configuration_Default();
 			var config = (SampleClass2) source.ExtractConfig("SampleClass", () => new SampleClass2("Test"), null);
 			Assert.Equal(TimeSpan.FromMinutes(7), config.Timeout);
 			Assert.Equal("Test", config.ConstructorValue);
 			Assert.Equal("Sample", config.Name);
 		}
 
 		[Fact]
 		public void TestExtractConfig_V2_Change()
 		{
 			var source = this.SampleClass2Configuration_Change();
 			var config = (SampleClass2) source.ExtractConfig("SampleClass", () => new SampleClass2("Test123"), null);
 			var span = new TimeSpan(0, 1, 30, 0);
 			Assert.Equal(span, config.Timeout);
 			Assert.Equal("Test123", config.ConstructorValue);
 			Assert.Equal("Sample", config.Name);
 		}
 
 		[Fact]
 		public void TestExtractConfig_V3_Default()
 		{
 			var source = this.SampleClass2Configuration_Default();
 			var config =
 				(SampleClass2)new ConfigSection(ref source, "SampleClass", null).ExtractConfig(() =>
 					new SampleClass2("Meow"));
 
 			Assert.Equal("Meow", config.ConstructorValue);
 			Assert.Equal(TimeSpan.FromMinutes(7), config.Timeout);
 			Assert.Equal("Sample", config.Name);
 		}
 
 		[Fact]
 		public void TestExtractConfig_V3_Change()
 		{
 			var source = this.SampleClass2Configuration_Change();
 			var config =
 				(SampleClass2)new ConfigSection(ref source, "SampleClass", null).ExtractConfig(() =>
 					new SampleClass2("Meow"));
 
 			Assert.Equal("Meow", config.ConstructorValue);
 			var span = new TimeSpan(0, 1, 30, 0);
 			Assert.Equal(span, config.Timeout);
 			Assert.Equal("Sample", config.Name);
 		}
 
 		[Fact]
 		public void TestExtractConfig_Enumerable()
 		{
 			var source = this.EnumerableTestConfiguration();
 			var config =
 				(ClassWithEnumerable)new ConfigSection(ref source, "ClassWithEnumerable", null).ExtractConfig(() =>
 					new ClassWithEnumerable());
 
 			Assert.NotNull(config.Values);
 			Assert.Equal(3, config.Values.Count());
 			Assert.NotNull(config.Strings);
 			Assert.Equal(3, config.Values.Count());
 		}
 
 		[Fact]
 		public void TestExtractConfig_Array()
 		{
 			var source = this.EnumerableTestConfiguration();
 			var config =
 				(ClassWithArray)new ConfigSection(ref source, "ClassWithArray", null).ExtractConfig(() =>
 					new ClassWithArray());
 			Assert.NotNull(config.Values);
 			Assert.Equal(3, config.Values.Length);
 			Assert.NotNull(config.Strings);
 			Assert.Equal(3, config.Values.Length);
 		}
 
 		[Fact]
 		public void TestExtractConfig_List()
 		{
 			var source = this.EnumerableTestConfiguration();
 			var config =
 				(ClassWithList)new ConfigSection(ref source, "ClassWithList", null).ExtractConfig(() =>
 					new ClassWithList());
 			Assert.NotNull(config.Values);
 			Assert.Equal(3, config.Values.Count);
 			Assert.NotNull(config.Strings);
 			Assert.Equal(3, config.Values.Count);
 		}
 
 		[Fact]
 		public void TestHasSectionWithSuffix()
 		{
 			var source = this.HasSectionWithSuffixConfiguration();
 
 			Assert.True(source.HasSection("DiscordConfiguration"));
 			Assert.False(source.HasSection("Discord"));
 #pragma warning disable 8625
 			Assert.False(source.HasSection("DiscordConfiguration", null));
 #pragma warning restore 8625
 		}
 
 		[Fact]
 		public void TestHasSectionNoSuffix()
 		{
 			var source = this.HasSectionNoSuffixConfiguration();
 
 			Assert.True(source.HasSection("Discord"));
 			Assert.False(source.HasSection("DiscordConfiguration"));
 #pragma warning disable 8625
 			Assert.False(source.HasSection("Discord", null));
 #pragma warning restore 8625
 		}
 	}
 }
 
diff --git a/DisCatSharp.Configuration/ConfigurationExtensions.cs b/DisCatSharp.Configuration/ConfigurationExtensions.cs
index 845b6942a..528f63fd3 100644
--- a/DisCatSharp.Configuration/ConfigurationExtensions.cs
+++ b/DisCatSharp.Configuration/ConfigurationExtensions.cs
@@ -1,311 +1,311 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections;
 using System.Linq;
 using DisCatSharp.Configuration.Models;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.Configuration
 {
 	/// <summary>
 	/// The configuration extensions.
 	/// </summary>
 	internal static class ConfigurationExtensions
 	{
 		/// <summary>
 		/// The factory error message.
 		/// </summary>
 		private const string FACTORY_ERROR_MESSAGE = "Require a function which provides a default entity to work with";
 		/// <summary>
 		/// The default root lib.
 		/// </summary>
 		public const string DEFAULT_ROOT_LIB = "DisCatSharp";
 		/// <summary>
 		/// The config suffix.
 		/// </summary>
 		private const string CONFIG_SUFFIX = "Configuration";
 
 
 		/// <summary>
 		/// Easily piece together paths that will work within <see cref="IConfiguration"/>
 		/// </summary>
 		/// <param name="config">(not used - only for adding context based functionality)</param>
 		/// <param name="values">The strings to piece together</param>
 		/// <returns>Strings joined together via ':'</returns>
 		public static string ConfigPath(this IConfiguration config, params string[] values) => string.Join(":", values);
 
 		/// <summary>
 		/// Skims over the configuration section and only overrides values that are explicitly defined within the config
 		/// </summary>
 		/// <param name="config">Instance of config</param>
 		/// <param name="section">Section which contains values for <paramref name="config"/></param>
 		private static void HydrateInstance(ref object config, ConfigSection section)
 		{
 			var props = config.GetType().GetProperties();
 
 			foreach (var prop in props)
 			{
 				// Must have a set method for this to work, otherwise continue on
 				if (prop.SetMethod == null)
 					continue;
 
 				var entry = section.GetValue(prop.Name);
 				object? value = null;
 
 				if (typeof(string) == prop.PropertyType)
 				{
 					// We do NOT want to override value if nothing was provided
 					if (!string.IsNullOrEmpty(entry))
 						prop.SetValue(config, entry);
 
 					continue;
 				}
 
 				// We need to address collections a bit differently
 				// They can come in the form of    "root:section:name" with a string representation OR
 				// "root:section:name:0"  <--- this is not detectable when checking the above path
 				if (typeof(IEnumerable).IsAssignableFrom(prop.PropertyType))
 				{
 					value = string.IsNullOrEmpty(section.GetValue(prop.Name))
 						? section.Config
 							.GetSection(section.GetPath(prop.Name)).Get(prop.PropertyType)
 						: Newtonsoft.Json.JsonConvert.DeserializeObject(entry, prop.PropertyType);
 
 					if (value == null)
 						continue;
 
 					prop.SetValue(config, value);
 				}
 
 				// From this point onward we require the 'entry' value to have something useful
 				if (string.IsNullOrEmpty(entry))
 					continue;
 
 				try
 				{
 					// Primitive types are simple to convert
 					if (prop.PropertyType.IsPrimitive)
 						value = Convert.ChangeType(entry, prop.PropertyType);
 					else
 					{
 						// The following types require a different approach
 						if (prop.PropertyType.IsEnum)
 							value = Enum.Parse(prop.PropertyType, entry);
 						else if (typeof(TimeSpan) == prop.PropertyType)
 							value = TimeSpan.Parse(entry);
 						else if (typeof(DateTime) == prop.PropertyType)
 							value = DateTime.Parse(entry);
 						else if (typeof(DateTimeOffset) == prop.PropertyType)
 							value = DateTimeOffset.Parse(entry);
 					}
 
 					// Update value within our config instance
 					prop.SetValue(config, value);
 				}
 				catch (Exception ex)
 				{
 					Console.Error.WriteLine(
 						$"Unable to convert value of '{entry}' to type '{prop.PropertyType.Name}' for prop '{prop.Name}' in config '{config.GetType().Name}'\n\t\t{ex.Message}");
 				}
 			}
 		}
 
 		/// <summary>
 		/// Instantiate an entity using <paramref name="factory"/> then walk through the specified <paramref name="section"/>
 		/// and translate user-defined config values to the instantiated instance from <paramref name="factory"/>
 		/// </summary>
 		/// <param name="section">Section containing values for targeted config</param>
 		/// <param name="factory">Function which generates a default entity</param>
 		/// <returns>Hydrated instance of an entity which contains user-defined values (if any)</returns>
 		/// <exception cref="ArgumentNullException">When <paramref name="factory"/> is null</exception>
 		public static object ExtractConfig(this ConfigSection section, Func<object> factory)
 		{
 			if (factory == null)
 				throw new ArgumentNullException(nameof(factory), FACTORY_ERROR_MESSAGE);
 
 			// Create default instance
 			var config = factory();
 
 			HydrateInstance(ref config, section);
 
 			return config;
 		}
 
 		/// <summary>
 		/// Instantiate an entity using <paramref name="factory"/> then walk through the specified <paramref name="sectionName"/>
 		/// in <paramref name="config"/>. Translate user-defined config values to the instantiated instance from <paramref name="factory"/>
 		/// </summary>
 		/// <param name="config">Loaded App Configuration</param>
 		/// <param name="sectionName">Name of section to load</param>
 		/// <param name="factory">Function which creates a default entity to work with</param>
 		/// <param name="rootSectionName">(Optional) Used when section is nested within another. Default value is <see cref="DEFAULT_ROOT_LIB"/></param>
 		/// <returns>Hydrated instance of an entity which contains user-defined values (if any)</returns>
 		/// <exception cref="ArgumentNullException">When <paramref name="factory"/> is null</exception>
 		public static object ExtractConfig(this IConfiguration config, string sectionName, Func<object> factory,
 			string? rootSectionName = DEFAULT_ROOT_LIB)
 		{
 			if (factory == null)
 				throw new ArgumentNullException(nameof(factory), FACTORY_ERROR_MESSAGE);
 
 			// create default instance
 			var instance = factory();
 
 			HydrateInstance(ref instance, new ConfigSection(ref config, sectionName, rootSectionName));
 
 			return instance;
 		}
 
 		/// <summary>
 		/// Instantiate a new instance of <typeparamref name="TConfig"/>, then walk through the specified <paramref name="sectionName"/>
 		/// in <paramref name="config"/>. Translate user-defined config values to the <typeparamref name="TConfig"/> instance.
 		/// </summary>
 		/// <param name="config">Loaded App Configuration</param>
 		/// <param name="serviceProvider"></param>
 		/// <param name="sectionName">Name of section to load</param>
 		/// <param name="rootSectionName">(Optional) Used when section is nested with another. Default value is <see cref="DEFAULT_ROOT_LIB"/></param>
 		/// <typeparam name="TConfig">Type of instance that <paramref name="sectionName"/> represents</typeparam>
 		/// <returns>Hydrated instance of <typeparamref name="TConfig"/> which contains the user-defined values (if any).</returns>
 		public static TConfig ExtractConfig<TConfig>(this IConfiguration config, IServiceProvider serviceProvider, string sectionName, string? rootSectionName = DEFAULT_ROOT_LIB)
 			where TConfig : new()
 		{
 			// Default values should hopefully be provided from the constructor
 			var configInstance = ActivatorUtilities.CreateInstance(serviceProvider, typeof(TConfig));
 
 			HydrateInstance(ref configInstance, new ConfigSection(ref config, sectionName, rootSectionName));
 
 			return (TConfig)configInstance;
 		}
 
 		/// <summary>
 		/// Instantiate a new instance of <typeparamref name="TConfig"/>, then walk through the specified <paramref name="sectionName"/>
 		/// in <paramref name="config"/>. Translate user-defined config values to the <typeparamref name="TConfig"/> instance.
 		/// </summary>
 		/// <param name="config">Loaded App Configuration</param>
 		/// <param name="sectionName">Name of section to load</param>
 		/// <param name="rootSectionName">(Optional) Used when section is nested with another. Default value is <see cref="DEFAULT_ROOT_LIB"/></param>
 		/// <typeparam name="TConfig">Type of instance that <paramref name="sectionName"/> represents</typeparam>
 		/// <returns>Hydrated instance of <typeparamref name="TConfig"/> which contains the user-defined values (if any).</returns>
 		public static TConfig ExtractConfig<TConfig>(this IConfiguration config, string sectionName, string? rootSectionName = DEFAULT_ROOT_LIB)
 			where TConfig : new()
 		{
 			// Default values should hopefully be provided from the constructor
 			object configInstance = new TConfig();
 
 			HydrateInstance(ref configInstance, new ConfigSection(ref config, sectionName, rootSectionName));
 
 			return (TConfig)configInstance;
 		}
 
 		/// <summary>
 		/// Determines if <paramref name="config"/> contains a particular section/object (not value)
 		/// </summary>
 		/// <remarks>
 		/// <code>
 		/// {
 		///    "Discord": {  // this is a section/object
 		///
 		///    },
 		///    "Value": "something" // this is not a section/object
 		/// }
 		/// </code>
 		/// </remarks>
 		/// <param name="config"></param>
 		/// <param name="values"></param>
 		/// <returns>True if section exists, otherwise false</returns>
 		public static bool HasSection(this IConfiguration config, params string[] values)
 		{
 			if (!values.Any())
 				return false;
 
 			if (values.Length == 1)
 				return config.GetChildren().Any(x => x.Key == values[0]);
 
 			if (config.GetChildren().All(x => x.Key != values[0]))
 				return false;
 
 			var current = config.GetSection(values[0]);
 
 			for (var i = 1; i < values.Length - 1; i++)
 			{
 				if (current.GetChildren().All(x => x.Key != values[i]))
 					return false;
 
 				current = current.GetSection(values[i]);
 			}
 
 			return current.GetChildren().Any(x => x.Key == values[^1]);
 		}
 
 		/// <summary>
 		/// Instantiates an instance of <see cref="DiscordClient"/>, then consumes any custom
 		/// configuration from user/developer from <paramref name="config"/>. <br/>
 		/// View remarks for more info
 		/// </summary>
 		/// <remarks>
 		/// This is an example of how your JSON structure should look if you wish
 		/// to override one or more of the default values from <see cref="DiscordConfiguration"/>
 		/// <code>
 		/// {
 		///   "DisCatSharp": {
 		///      "Discord": { }
 		///   }
 		/// }
 		/// </code>
 		/// <br/>
 		/// Alternatively, you can use the type name itself
 		/// <code>
 		/// {
 		///   "DisCatSharp": {
 		///      "DiscordConfiguration": { }
 		///   }
 		/// }
 		/// </code>
 		/// <code>
 		/// {
 		///   "botSectionName": {
 		///      "DiscordConfiguration": { }
 		///   }
 		/// }
 		/// </code>
 		/// </remarks>
 		/// <param name="config"></param>
 		/// <param name="serviceProvider"></param>
 		/// <param name="botSectionName"></param>
 		/// <returns>Instance of <see cref="DiscordClient"/></returns>
 		public static DiscordClient BuildClient(this IConfiguration config, IServiceProvider serviceProvider,
 			string botSectionName = DEFAULT_ROOT_LIB)
 		{
 			var section = config.HasSection(botSectionName, "Discord")
 				? "Discord"
 				: config.HasSection(botSectionName, $"Discord{CONFIG_SUFFIX}")
 					? $"Discord:{CONFIG_SUFFIX}"
 					: null;
 
 			return string.IsNullOrEmpty(section)
-				? new DiscordClient(new(serviceProvider))
+				? new DiscordClient(new DiscordConfiguration(serviceProvider))
 				: new DiscordClient(config.ExtractConfig<DiscordConfiguration>(serviceProvider, section, botSectionName));
 		}
 	}
 }
diff --git a/DisCatSharp.Configuration/Models/ConfigSection.cs b/DisCatSharp.Configuration/Models/ConfigSection.cs
index 6b32a448a..82bdda9b1 100644
--- a/DisCatSharp.Configuration/Models/ConfigSection.cs
+++ b/DisCatSharp.Configuration/Models/ConfigSection.cs
@@ -1,94 +1,92 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using Microsoft.Extensions.Configuration;
 
 namespace DisCatSharp.Configuration.Models
 {
 	/// <summary>
 	/// Represents an object in <see cref="IConfiguration"/>
 	/// </summary>
 	internal readonly struct ConfigSection
 	{
 		/// <summary>
 		/// Key within <see cref="Config"/> which represents an object containing multiple values
 		/// </summary>
 		public string SectionName { get; }
 
 		/// <summary>
 		/// Optional used to indicate this section is nested within another
 		/// </summary>
 		public string? Root { get; }
 
 		/// <summary>
 		/// Reference to <see cref="IConfiguration"/> used within application
 		/// </summary>
 		public IConfiguration Config { get; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ConfigSection"/> class.
 		/// </summary>
 		/// <param name="config">Reference to config</param>
 		/// <param name="sectionName">Section of interest</param>
 		/// <param name="rootName">(Optional) Indicates <paramref name="sectionName"/> is nested within this name. Default value is DisCatSharp</param>
 		public ConfigSection(ref IConfiguration config, string sectionName, string? rootName = "DisCatSharp")
 		{
 			this.Config = config;
 			this.SectionName = sectionName;
 			this.Root = rootName;
 		}
 
 		/// <summary>
 		/// Checks if key exists in <see cref="Config"/>
 		/// </summary>
 		/// <param name="name">Property / Key to search for in section</param>
 		/// <returns>True if key exists, otherwise false. Outputs path to config regardless</returns>
 		public bool ContainsKey(string name)
 		{
 			var path = string.IsNullOrEmpty(this.Root)
 				? this.Config.ConfigPath(this.SectionName, name)
 				: this.Config.ConfigPath(this.Root, this.SectionName, name);
 
 			return !string.IsNullOrEmpty(this.Config[path]);
 		}
 
 		/// <summary>
 		/// Attempts to get value associated to the config path. <br/> Should be used in unison with <see cref="ContainsKey"/>
 		/// </summary>
 		/// <param name="propName">Config path to value</param>
 		/// <returns>Value found at <paramref name="propName"/></returns>
 		public string GetValue(string propName)
 			=> this.Config[this.GetPath(propName)];
 
 		/// <summary>
 		/// Gets the path.
 		/// </summary>
 		/// <param name="value">The value.</param>
 		/// <returns>A string.</returns>
-		public string GetPath(string value)
-		{
-			return string.IsNullOrEmpty(this.Root)
+		public string GetPath(string value) =>
+			string.IsNullOrEmpty(this.Root)
 				? this.Config.ConfigPath(this.SectionName, value)
 				: this.Config.ConfigPath(this.Root, this.SectionName, value);
-		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/EventHandling/Components/ComponentEventWaiter.cs b/DisCatSharp.Interactivity/EventHandling/Components/ComponentEventWaiter.cs
index a5e5d8280..7dc76de59 100644
--- a/DisCatSharp.Interactivity/EventHandling/Components/ComponentEventWaiter.cs
+++ b/DisCatSharp.Interactivity/EventHandling/Components/ComponentEventWaiter.cs
@@ -1,150 +1,150 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using ConcurrentCollections;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Interactivity.Enums;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Interactivity.EventHandling
 {
 	/// <summary>
 	/// A component-based version of <see cref="EventWaiter{T}"/>
 	/// </summary>
 	internal class ComponentEventWaiter : IDisposable
 	{
 		private readonly DiscordClient _client;
 		private readonly ConcurrentHashSet<ComponentMatchRequest> _matchRequests = new();
 		private readonly ConcurrentHashSet<ComponentCollectRequest> _collectRequests = new();
 
 		private readonly DiscordFollowupMessageBuilder _message;
 		private readonly InteractivityConfiguration _config;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ComponentEventWaiter"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="config">The config.</param>
 		public ComponentEventWaiter(DiscordClient client, InteractivityConfiguration config)
 		{
 			this._client = client;
 			this._client.ComponentInteractionCreated += this.Handle;
 			this._config = config;
 
-			this._message = new() { Content = config.ResponseMessage ?? "This message was not meant for you.", IsEphemeral = true };
+			this._message = new DiscordFollowupMessageBuilder { Content = config.ResponseMessage ?? "This message was not meant for you.", IsEphemeral = true };
 		}
 
 		/// <summary>
 		/// Waits for a specified <see cref="ComponentMatchRequest"/>'s predicate to be fufilled.
 		/// </summary>
 		/// <param name="request">The request to wait for.</param>
 		/// <returns>The returned args, or null if it timed out.</returns>
 		public async Task<ComponentInteractionCreateEventArgs> WaitForMatchAsync(ComponentMatchRequest request)
 		{
 			this._matchRequests.Add(request);
 
 			try
 			{
 				return await request.Tcs.Task.ConfigureAwait(false);
 			}
 			catch (Exception e)
 			{
 				this._client.Logger.LogError(InteractivityEvents.InteractivityWaitError, e, "An exception was thrown while waiting for components.");
 				return null;
 			}
 			finally
 			{
 				this._matchRequests.TryRemove(request);
 			}
 		}
 
 		/// <summary>
 		/// Collects reactions and returns the result when the <see cref="ComponentMatchRequest"/>'s cancellation token is canceled.
 		/// </summary>
 		/// <param name="request">The request to wait on.</param>
 		/// <returns>The result from request's predicate over the period of time leading up to the token's cancellation.</returns>
 		public async Task<IReadOnlyList<ComponentInteractionCreateEventArgs>> CollectMatchesAsync(ComponentCollectRequest request)
 		{
 			this._collectRequests.Add(request);
 			try
 			{
 				await request.Tcs.Task.ConfigureAwait(false);
 			}
 			catch (Exception e)
 			{
 				this._client.Logger.LogError(InteractivityEvents.InteractivityCollectorError, e, "There was an error while collecting component event args.");
 			}
 			finally
 			{
 				this._collectRequests.TryRemove(request);
 			}
 
 			return request.Collected.ToArray();
 		}
 
 		/// <summary>
 		/// Handles the waiter.
 		/// </summary>
 		/// <param name="_">The client.</param>
 		/// <param name="args">The args.</param>
 		private async Task Handle(DiscordClient _, ComponentInteractionCreateEventArgs args)
 		{
 			foreach (var mreq in this._matchRequests.ToArray())
 			{
 				if (mreq.Message == args.Message && mreq.IsMatch(args))
 					mreq.Tcs.TrySetResult(args);
 
 				else if (this._config.ResponseBehavior is InteractionResponseBehavior.Respond)
 					await args.Interaction.CreateFollowupMessageAsync(this._message).ConfigureAwait(false);
 			}
 
 
 			foreach (var creq in this._collectRequests.ToArray())
 			{
 				if (creq.Message == args.Message && creq.IsMatch(args))
 				{
 					await args.Interaction.CreateResponseAsync(InteractionResponseType.DeferredMessageUpdate).ConfigureAwait(false);
 
 					if (creq.IsMatch(args))
 						creq.Collected.Add(args);
 
 					else if (this._config.ResponseBehavior is InteractionResponseBehavior.Respond)
 						await args.Interaction.CreateFollowupMessageAsync(this._message).ConfigureAwait(false);
 				}
 			}
 		}
 		/// <summary>
 		/// Disposes the waiter.
 		/// </summary>
 		public void Dispose()
 		{
 			this._matchRequests.Clear();
 			this._collectRequests.Clear();
 			this._client.ComponentInteractionCreated -= this.Handle;
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/EventHandling/Components/ComponentPaginator.cs b/DisCatSharp.Interactivity/EventHandling/Components/ComponentPaginator.cs
index 6e3aa7b06..c9f65d9e8 100644
--- a/DisCatSharp.Interactivity/EventHandling/Components/ComponentPaginator.cs
+++ b/DisCatSharp.Interactivity/EventHandling/Components/ComponentPaginator.cs
@@ -1,181 +1,181 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Interactivity.Enums;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Interactivity.EventHandling
 {
 	/// <summary>
 	/// The component paginator.
 	/// </summary>
 	internal class ComponentPaginator : IPaginator
 	{
 		private readonly DiscordClient _client;
 		private readonly InteractivityConfiguration _config;
 		private readonly DiscordMessageBuilder _builder = new();
 		private readonly Dictionary<ulong, IPaginationRequest> _requests = new();
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ComponentPaginator"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="config">The config.</param>
 		public ComponentPaginator(DiscordClient client, InteractivityConfiguration config)
 		{
 			this._client = client;
 			this._client.ComponentInteractionCreated += this.Handle;
 			this._config = config;
 		}
 
 		/// <summary>
 		/// Does the pagination async.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		public async Task DoPaginationAsync(IPaginationRequest request)
 		{
 			var id = (await request.GetMessageAsync().ConfigureAwait(false)).Id;
 			this._requests.Add(id, request);
 
 			try
 			{
 				var tcs = await request.GetTaskCompletionSourceAsync().ConfigureAwait(false);
 				await tcs.Task.ConfigureAwait(false);
 			}
 			catch (Exception ex)
 			{
 				this._client.Logger.LogError(InteractivityEvents.InteractivityPaginationError, ex, "There was an exception while paginating.");
 			}
 			finally
 			{
 				this._requests.Remove(id);
 				try
 				{
 					await request.DoCleanupAsync().ConfigureAwait(false);
 				}
 				catch (Exception ex)
 				{
 					this._client.Logger.LogError(InteractivityEvents.InteractivityPaginationError, ex, "There was an exception while cleaning up pagination.");
 				}
 			}
 		}
 
 		/// <summary>
 		/// Disposes the paginator.
 		/// </summary>
 		public void Dispose() => this._client.ComponentInteractionCreated -= this.Handle;
 
 
 		/// <summary>
 		/// Handles the pagination event.
 		/// </summary>
 		/// <param name="_">The client.</param>
 		/// <param name="e">The event arguments.</param>
 		private async Task Handle(DiscordClient _, ComponentInteractionCreateEventArgs e)
 		{
 			if (e.Interaction.Type == InteractionType.ModalSubmit)
 				return;
 
 			if (!this._requests.TryGetValue(e.Message.Id, out var req))
 				return;
 
 			if (this._config.AckPaginationButtons)
 			{
 				e.Handled = true;
 				await e.Interaction.CreateResponseAsync(InteractionResponseType.DeferredMessageUpdate).ConfigureAwait(false);
 			}
 
 			if (await req.GetUserAsync().ConfigureAwait(false) != e.User)
 			{
 				if (this._config.ResponseBehavior is InteractionResponseBehavior.Respond)
-					await e.Interaction.CreateFollowupMessageAsync(new() { Content = this._config.ResponseMessage, IsEphemeral = true }).ConfigureAwait(false);
+					await e.Interaction.CreateFollowupMessageAsync(new DiscordFollowupMessageBuilder { Content = this._config.ResponseMessage, IsEphemeral = true }).ConfigureAwait(false);
 
 				return;
 			}
 
 			if (req is InteractionPaginationRequest ipr)
 				ipr.RegenerateCts(e.Interaction); // Necessary to ensure we don't prematurely yeet the CTS //
 
 			await this.HandlePaginationAsync(req, e).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the pagination async.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		/// <param name="args">The arguments.</param>
 		private async Task HandlePaginationAsync(IPaginationRequest request, ComponentInteractionCreateEventArgs args)
 		{
 			var buttons = this._config.PaginationButtons;
 			var msg = await request.GetMessageAsync().ConfigureAwait(false);
 			var id = args.Id;
 			var tcs = await request.GetTaskCompletionSourceAsync().ConfigureAwait(false);
 
 #pragma warning disable CS8846 // The switch expression does not handle all possible values of its input type (it is not exhaustive).
 			var paginationTask = id switch
 #pragma warning restore CS8846 // The switch expression does not handle all possible values of its input type (it is not exhaustive).
             {
 				_ when id == buttons.SkipLeft.CustomId => request.SkipLeftAsync(),
 				_ when id == buttons.SkipRight.CustomId => request.SkipRightAsync(),
 				_ when id == buttons.Stop.CustomId => Task.FromResult(tcs.TrySetResult(true)),
 				_ when id == buttons.Left.CustomId => request.PreviousPageAsync(),
 				_ when id == buttons.Right.CustomId => request.NextPageAsync(),
 			};
 
 			await paginationTask.ConfigureAwait(false);
 
 			if (id == buttons.Stop.CustomId)
 				return;
 
 			var page = await request.GetPageAsync().ConfigureAwait(false);
 
 
 			var bts = await request.GetButtonsAsync().ConfigureAwait(false);
 
 			if (request is InteractionPaginationRequest ipr)
 			{
 				var builder = new DiscordWebhookBuilder()
 					.WithContent(page.Content)
 					.AddEmbed(page.Embed)
 					.AddComponents(bts);
 
 				await args.Interaction.EditOriginalResponseAsync(builder).ConfigureAwait(false);
 				return;
 			}
 
 			this._builder.Clear();
 
 			this._builder
 				.WithContent(page.Content)
 				.AddEmbed(page.Embed)
 				.AddComponents(bts);
 
 			await this._builder.ModifyAsync(msg).ConfigureAwait(false);
 
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/EventHandling/Components/ModalEventWaiter.cs b/DisCatSharp.Interactivity/EventHandling/Components/ModalEventWaiter.cs
index 02bd1c09a..16dab8bff 100644
--- a/DisCatSharp.Interactivity/EventHandling/Components/ModalEventWaiter.cs
+++ b/DisCatSharp.Interactivity/EventHandling/Components/ModalEventWaiter.cs
@@ -1,109 +1,109 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Linq;
 using System.Threading.Tasks;
 using ConcurrentCollections;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Interactivity.Enums;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Interactivity.EventHandling
 {
 	/// <summary>
 	/// A modal-based version of <see cref="EventWaiter{T}"/>
 	/// </summary>
 	internal class ModalEventWaiter : IDisposable
 	{
 		private readonly DiscordClient _client;
 		private readonly ConcurrentHashSet<ModalMatchRequest> _modalMatchRequests = new();
 
 		private readonly DiscordFollowupMessageBuilder _message;
 		private readonly InteractivityConfiguration _config;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ComponentEventWaiter"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="config">The config.</param>
 		public ModalEventWaiter(DiscordClient client, InteractivityConfiguration config)
 		{
 			this._client = client;
 			this._client.ComponentInteractionCreated += this.Handle;
 			this._config = config;
 
-			this._message = new() { Content = config.ResponseMessage ?? "This modal was not meant for you.", IsEphemeral = true };
+			this._message = new DiscordFollowupMessageBuilder { Content = config.ResponseMessage ?? "This modal was not meant for you.", IsEphemeral = true };
 		}
 
 		/// <summary>
 		/// Waits for a specified <see cref="ModalMatchRequest"/>'s predicate to be fufilled.
 		/// </summary>
 		/// <param name="request">The request to wait for.</param>
 		/// <returns>The returned args, or null if it timed out.</returns>
 		public async Task<ComponentInteractionCreateEventArgs> WaitForModalMatchAsync(ModalMatchRequest request)
 		{
 			this._modalMatchRequests.Add(request);
 
 			try
 			{
 				return await request.Tcs.Task.ConfigureAwait(false);
 			}
 			catch (Exception e)
 			{
 				this._client.Logger.LogError(InteractivityEvents.InteractivityWaitError, e, "An exception was thrown while waiting for modals.");
 				return null;
 			}
 			finally
 			{
 				this._modalMatchRequests.TryRemove(request);
 			}
 		}
 
 		/// <summary>
 		/// Handles the waiter.
 		/// </summary>
 		/// <param name="_">The client.</param>
 		/// <param name="args">The args.</param>
 		private async Task Handle(DiscordClient _, ComponentInteractionCreateEventArgs args)
 		{
 			foreach (var mreq in this._modalMatchRequests.ToArray())
 			{
 				if (mreq.CustomId == args.Interaction.Data.CustomId && mreq.IsMatch(args))
 					mreq.Tcs.TrySetResult(args);
 
 				else if (this._config.ResponseBehavior is InteractionResponseBehavior.Respond)
 					await args.Interaction.CreateFollowupMessageAsync(this._message).ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Disposes the waiter.
 		/// </summary>
 		public void Dispose()
 		{
 			this._modalMatchRequests.Clear();
 			this._client.ComponentInteractionCreated -= this.Handle;
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/EventHandling/Components/PaginationButtons.cs b/DisCatSharp.Interactivity/EventHandling/Components/PaginationButtons.cs
index 80284bdd4..97b2cb88e 100644
--- a/DisCatSharp.Interactivity/EventHandling/Components/PaginationButtons.cs
+++ b/DisCatSharp.Interactivity/EventHandling/Components/PaginationButtons.cs
@@ -1,95 +1,95 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 
 namespace DisCatSharp.Interactivity.EventHandling
 {
 	/// <summary>
 	/// The pagination buttons.
 	/// </summary>
 	public class PaginationButtons
 	{
 		/// <summary>
 		/// Gets or sets the skip left button.
 		/// </summary>
 		public DiscordButtonComponent SkipLeft { internal get; set; }
 
 		/// <summary>
 		/// Gets or sets the left button.
 		/// </summary>
 		public DiscordButtonComponent Left { internal get; set; }
 
 		/// <summary>
 		/// Gets or sets the stop button.
 		/// </summary>
 		public DiscordButtonComponent Stop { internal get; set; }
 
 		/// <summary>
 		/// Gets or sets the right button.
 		/// </summary>
 		public DiscordButtonComponent Right { internal get; set; }
 
 		/// <summary>
 		/// Gets or sets the skip right button.
 		/// </summary>
 		public DiscordButtonComponent SkipRight { internal get; set; }
 
 		/// <summary>
 		/// Gets the button array.
 		/// </summary>
 		internal DiscordButtonComponent[] ButtonArray => new[]
 		{
 			this.SkipLeft,
 			this.Left,
 			this.Stop,
 			this.Right,
 			this.SkipRight
 		};
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="PaginationButtons"/> class.
 		/// </summary>
 		public PaginationButtons()
 		{
-			this.SkipLeft = new(ButtonStyle.Secondary, "leftskip", null, false, new(DiscordEmoji.FromUnicode("⏮")));
-			this.Left = new(ButtonStyle.Secondary, "left", null, false, new(DiscordEmoji.FromUnicode("◀")));
-			this.Stop = new(ButtonStyle.Secondary, "stop", null, false, new(DiscordEmoji.FromUnicode("⏹")));
-			this.Right = new(ButtonStyle.Secondary, "right", null, false, new(DiscordEmoji.FromUnicode("▶")));
-			this.SkipRight = new(ButtonStyle.Secondary, "rightskip", null, false, new(DiscordEmoji.FromUnicode("⏭")));
+			this.SkipLeft = new DiscordButtonComponent(ButtonStyle.Secondary, "leftskip", null, false, new DiscordComponentEmoji(DiscordEmoji.FromUnicode("⏮")));
+			this.Left = new DiscordButtonComponent(ButtonStyle.Secondary, "left", null, false, new DiscordComponentEmoji(DiscordEmoji.FromUnicode("◀")));
+			this.Stop = new DiscordButtonComponent(ButtonStyle.Secondary, "stop", null, false, new DiscordComponentEmoji(DiscordEmoji.FromUnicode("⏹")));
+			this.Right = new DiscordButtonComponent(ButtonStyle.Secondary, "right", null, false, new DiscordComponentEmoji(DiscordEmoji.FromUnicode("▶")));
+			this.SkipRight = new DiscordButtonComponent(ButtonStyle.Secondary, "rightskip", null, false, new DiscordComponentEmoji(DiscordEmoji.FromUnicode("⏭")));
 		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="PaginationButtons"/> class.
 		/// </summary>
 		/// <param name="other">The other <see cref="PaginationButtons"/>.</param>
 		public PaginationButtons(PaginationButtons other)
 		{
-			this.Stop = new(other.Stop);
-			this.Left = new(other.Left);
-			this.Right = new(other.Right);
-			this.SkipLeft = new(other.SkipLeft);
-			this.SkipRight = new(other.SkipRight);
+			this.Stop = new DiscordButtonComponent(other.Stop);
+			this.Left = new DiscordButtonComponent(other.Left);
+			this.Right = new DiscordButtonComponent(other.Right);
+			this.SkipLeft = new DiscordButtonComponent(other.SkipLeft);
+			this.SkipRight = new DiscordButtonComponent(other.SkipRight);
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/EventHandling/Components/Requests/ButtonPaginationRequest.cs b/DisCatSharp.Interactivity/EventHandling/Components/Requests/ButtonPaginationRequest.cs
index 1b9207f81..3774b5ba7 100644
--- a/DisCatSharp.Interactivity/EventHandling/Components/Requests/ButtonPaginationRequest.cs
+++ b/DisCatSharp.Interactivity/EventHandling/Components/Requests/ButtonPaginationRequest.cs
@@ -1,244 +1,244 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.Interactivity.Enums;
 
 namespace DisCatSharp.Interactivity.EventHandling
 {
 	/// <summary>
 	/// The button pagination request.
 	/// </summary>
 	internal class ButtonPaginationRequest : IPaginationRequest
 	{
 		private int _index;
 		private readonly List<Page> _pages = new();
 
 		private readonly TaskCompletionSource<bool> _tcs = new();
 
 		private readonly CancellationToken _token;
 		private readonly DiscordUser _user;
 		private readonly DiscordMessage _message;
 		private readonly PaginationButtons _buttons;
 		private readonly PaginationBehaviour _wrapBehavior;
 		private readonly ButtonPaginationBehavior _behaviorBehavior;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ButtonPaginationRequest"/> class.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <param name="user">The user.</param>
 		/// <param name="behavior">The behavior.</param>
 		/// <param name="buttonBehavior">The button behavior.</param>
 		/// <param name="buttons">The buttons.</param>
 		/// <param name="pages">The pages.</param>
 		/// <param name="token">The token.</param>
 		public ButtonPaginationRequest(DiscordMessage message, DiscordUser user,
 			PaginationBehaviour behavior, ButtonPaginationBehavior buttonBehavior,
 			PaginationButtons buttons, IEnumerable<Page> pages, CancellationToken token)
 		{
 			this._user = user;
 			this._token = token;
-			this._buttons = new(buttons);
+			this._buttons = new PaginationButtons(buttons);
 			this._message = message;
 			this._wrapBehavior = behavior;
 			this._behaviorBehavior = buttonBehavior;
 			this._pages.AddRange(pages);
 
 			this._token.Register(() => this._tcs.TrySetResult(false));
 		}
 
 		/// <summary>
 		/// Gets the page count.
 		/// </summary>
 		public int PageCount => this._pages.Count;
 
 		/// <summary>
 		/// Gets the page.
 		/// </summary>
 		public Task<Page> GetPageAsync()
 		{
 			var page = Task.FromResult(this._pages[this._index]);
 
 			if (this.PageCount is 1)
 			{
 				this._buttons.SkipLeft.Disable();
 				this._buttons.Left.Disable();
 				this._buttons.Right.Disable();
 				this._buttons.SkipRight.Disable();
 				this._buttons.Stop.Enable();
 				return page;
 			}
 
 			if (this._wrapBehavior is PaginationBehaviour.WrapAround)
 				return page;
 
 			this._buttons.SkipLeft.Disabled = this._index < 2;
 
 			this._buttons.Left.Disabled = this._index < 1;
 
 			this._buttons.Right.Disabled = this._index >= this.PageCount - 1;
 
 			this._buttons.SkipRight.Disabled = this._index >= this.PageCount - 2;
 
 			return page;
 		}
 
 		/// <summary>
 		/// Skips the left.
 		/// </summary>
 		public Task SkipLeftAsync()
 		{
 			if (this._wrapBehavior is PaginationBehaviour.WrapAround)
 			{
 				this._index = this._index is 0 ? this._pages.Count - 1 : 0;
 				return Task.CompletedTask;
 			}
 
 			this._index = 0;
 
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Skips the right.
 		/// </summary>
 		public Task SkipRightAsync()
 		{
 			if (this._wrapBehavior is PaginationBehaviour.WrapAround)
 			{
 				this._index = this._index == this.PageCount - 1 ? 0 : this.PageCount - 1;
 				return Task.CompletedTask;
 			}
 
 			this._index = this._pages.Count - 1;
 
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Gets the next page.
 		/// </summary>
 		public Task NextPageAsync()
 		{
 			this._index++;
 
 			if (this._wrapBehavior is PaginationBehaviour.WrapAround)
 			{
 				if (this._index >= this.PageCount)
 					this._index = 0;
 
 				return Task.CompletedTask;
 			}
 
 			this._index = Math.Min(this._index, this.PageCount - 1);
 
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Gets the previous page.
 		/// </summary>
 		public Task PreviousPageAsync()
 		{
 			this._index--;
 
 			if (this._wrapBehavior is PaginationBehaviour.WrapAround)
 			{
 				if (this._index is -1)
 					this._index = this._pages.Count - 1;
 
 				return Task.CompletedTask;
 			}
 
 			this._index = Math.Max(this._index, 0);
 
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Gets the emojis.
 		/// </summary>
 		public Task<PaginationEmojis> GetEmojisAsync() => Task.FromException<PaginationEmojis>(new NotSupportedException("Emojis aren't supported for this request."));
 
 		/// <summary>
 		/// Gets the buttons.
 		/// </summary>
 		public Task<IEnumerable<DiscordButtonComponent>> GetButtonsAsync()
 			=> Task.FromResult((IEnumerable<DiscordButtonComponent>)this._buttons.ButtonArray);
 
 		/// <summary>
 		/// Gets the message.
 		/// </summary>
 		public Task<DiscordMessage> GetMessageAsync() => Task.FromResult(this._message);
 
 		/// <summary>
 		/// Gets the user.
 		/// </summary>
 		public Task<DiscordUser> GetUserAsync() => Task.FromResult(this._user);
 
 		/// <summary>
 		/// Gets the task completion source.
 		/// </summary>
 		public Task<TaskCompletionSource<bool>> GetTaskCompletionSourceAsync() => Task.FromResult(this._tcs);
 
 		/// <summary>
 		/// Does the cleanup.
 		/// </summary>
 		public async Task DoCleanupAsync()
 		{
 			switch (this._behaviorBehavior)
 			{
 				case ButtonPaginationBehavior.Disable:
 					var buttons = this._buttons.ButtonArray.Select(b => b.Disable());
 
 					var builder = new DiscordMessageBuilder()
 						.WithContent(this._pages[this._index].Content)
 						.AddEmbed(this._pages[this._index].Embed)
 						.AddComponents(buttons);
 
 					await builder.ModifyAsync(this._message).ConfigureAwait(false);
 					break;
 
 				case ButtonPaginationBehavior.DeleteButtons:
 					builder = new DiscordMessageBuilder()
 						.WithContent(this._pages[this._index].Content)
 						.AddEmbed(this._pages[this._index].Embed);
 
 					await builder.ModifyAsync(this._message).ConfigureAwait(false);
 					break;
 
 				case ButtonPaginationBehavior.DeleteMessage:
 					await this._message.DeleteAsync().ConfigureAwait(false);
 					break;
 
 				case ButtonPaginationBehavior.Ignore:
 					break;
 			}
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/EventHandling/Components/Requests/InteractionPaginationRequest.cs b/DisCatSharp.Interactivity/EventHandling/Components/Requests/InteractionPaginationRequest.cs
index b524955ed..ab878c81c 100644
--- a/DisCatSharp.Interactivity/EventHandling/Components/Requests/InteractionPaginationRequest.cs
+++ b/DisCatSharp.Interactivity/EventHandling/Components/Requests/InteractionPaginationRequest.cs
@@ -1,264 +1,264 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.Interactivity.Enums;
 
 namespace DisCatSharp.Interactivity.EventHandling
 {
 	/// <summary>
 	/// The interaction pagination request.
 	/// </summary>
 	internal class InteractionPaginationRequest : IPaginationRequest
 	{
 		private int _index;
 		private readonly List<Page> _pages = new();
 
 		private readonly TaskCompletionSource<bool> _tcs = new();
 
 
 		private DiscordInteraction _lastInteraction;
 		private CancellationTokenSource _interactionCts;
 
 		private readonly CancellationToken _token;
 		private readonly DiscordUser _user;
 		private readonly DiscordMessage _message;
 		private readonly PaginationButtons _buttons;
 		private readonly PaginationBehaviour _wrapBehavior;
 		private readonly ButtonPaginationBehavior _behaviorBehavior;
 
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="InteractionPaginationRequest"/> class.
 		/// </summary>
 		/// <param name="interaction">The interaction.</param>
 		/// <param name="message">The message.</param>
 		/// <param name="user">The user.</param>
 		/// <param name="behavior">The behavior.</param>
 		/// <param name="behaviorBehavior">The behavior behavior.</param>
 		/// <param name="buttons">The buttons.</param>
 		/// <param name="pages">The pages.</param>
 		/// <param name="token">The token.</param>
 		public InteractionPaginationRequest(DiscordInteraction interaction, DiscordMessage message, DiscordUser user,
 			PaginationBehaviour behavior, ButtonPaginationBehavior behaviorBehavior,
 			PaginationButtons buttons, IEnumerable<Page> pages, CancellationToken token)
 		{
 			this._user = user;
 			this._token = token;
-			this._buttons = new(buttons);
+			this._buttons = new PaginationButtons(buttons);
 			this._message = message;
 			this._wrapBehavior = behavior;
 			this._behaviorBehavior = behaviorBehavior;
 			this._pages.AddRange(pages);
 
 			this.RegenerateCts(interaction);
 			this._token.Register(() => this._tcs.TrySetResult(false));
 		}
 
 		/// <summary>
 		/// Gets the page count.
 		/// </summary>
 		public int PageCount => this._pages.Count;
 
 		/// <summary>
 		/// Regenerates the cts.
 		/// </summary>
 		/// <param name="interaction">The interaction.</param>
 		internal void RegenerateCts(DiscordInteraction interaction)
 		{
 			this._interactionCts?.Dispose();
 			this._lastInteraction = interaction;
-			this._interactionCts = new(TimeSpan.FromSeconds((60 * 15) - 5));
+			this._interactionCts = new CancellationTokenSource(TimeSpan.FromSeconds((60 * 15) - 5));
 			this._interactionCts.Token.Register(() => this._tcs.TrySetResult(false));
 		}
 
 		/// <summary>
 		/// Gets the page.
 		/// </summary>
 		public Task<Page> GetPageAsync()
 		{
 			var page = Task.FromResult(this._pages[this._index]);
 
 			if (this.PageCount is 1)
 			{
 				this._buttons.ButtonArray.Select(b => b.Disable());
 				this._buttons.Stop.Enable();
 				return page;
 			}
 
 			if (this._wrapBehavior is PaginationBehaviour.WrapAround)
 				return page;
 
 			this._buttons.SkipLeft.Disabled = this._index < 2;
 
 			this._buttons.Left.Disabled = this._index < 1;
 
 			this._buttons.Right.Disabled = this._index == this.PageCount - 1;
 
 			this._buttons.SkipRight.Disabled = this._index >= this.PageCount - 2;
 
 			return page;
 		}
 
 		/// <summary>
 		/// Skips the left page.
 		/// </summary>
 		public Task SkipLeftAsync()
 		{
 			if (this._wrapBehavior is PaginationBehaviour.WrapAround)
 			{
 				this._index = this._index is 0 ? this._pages.Count - 1 : 0;
 				return Task.CompletedTask;
 			}
 
 			this._index = 0;
 
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Skips the right page.
 		/// </summary>
 		public Task SkipRightAsync()
 		{
 			if (this._wrapBehavior is PaginationBehaviour.WrapAround)
 			{
 				this._index = this._index == this.PageCount - 1 ? 0 : this.PageCount - 1;
 				return Task.CompletedTask;
 			}
 
 			this._index = this._pages.Count - 1;
 
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Gets the next page.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public Task NextPageAsync()
 		{
 			this._index++;
 
 			if (this._wrapBehavior is PaginationBehaviour.WrapAround)
 			{
 				if (this._index >= this.PageCount)
 					this._index = 0;
 
 				return Task.CompletedTask;
 			}
 
 			this._index = Math.Min(this._index, this.PageCount - 1);
 
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Gets the previous page.
 		/// </summary>
 		public Task PreviousPageAsync()
 		{
 			this._index--;
 
 			if (this._wrapBehavior is PaginationBehaviour.WrapAround)
 			{
 				if (this._index is -1)
 					this._index = this._pages.Count - 1;
 
 				return Task.CompletedTask;
 			}
 
 			this._index = Math.Max(this._index, 0);
 
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Gets the emojis.
 		/// </summary>
 		public Task<PaginationEmojis> GetEmojisAsync()
 			=> Task.FromException<PaginationEmojis>(new NotSupportedException("Emojis aren't supported for this request."));
 
 		/// <summary>
 		/// Gets the buttons.
 		/// </summary>
 		public Task<IEnumerable<DiscordButtonComponent>> GetButtonsAsync()
 			=> Task.FromResult((IEnumerable<DiscordButtonComponent>)this._buttons.ButtonArray);
 
 		/// <summary>
 		/// Gets the message.
 		/// </summary>
 		public Task<DiscordMessage> GetMessageAsync() => Task.FromResult(this._message);
 
 		/// <summary>
 		/// Gets the user.
 		/// </summary>
 		public Task<DiscordUser> GetUserAsync() => Task.FromResult(this._user);
 
 		/// <summary>
 		/// Gets the task completion source.
 		/// </summary>
 		public Task<TaskCompletionSource<bool>> GetTaskCompletionSourceAsync() => Task.FromResult(this._tcs);
 
 		/// <summary>
 		/// Cleanup.
 		/// </summary>
 		public async Task DoCleanupAsync()
 		{
 			switch (this._behaviorBehavior)
 			{
 				case ButtonPaginationBehavior.Disable:
 					var buttons = this._buttons.ButtonArray
 						.Select(b => new DiscordButtonComponent(b))
 						.Select(b => b.Disable());
 
 					var builder = new DiscordWebhookBuilder()
 						.WithContent(this._pages[this._index].Content)
 						.AddEmbed(this._pages[this._index].Embed)
 						.AddComponents(buttons);
 
 					await this._lastInteraction.EditOriginalResponseAsync(builder).ConfigureAwait(false);
 					break;
 
 				case ButtonPaginationBehavior.DeleteButtons:
 					builder = new DiscordWebhookBuilder()
 						.WithContent(this._pages[this._index].Content)
 						.AddEmbed(this._pages[this._index].Embed);
 
 					await this._lastInteraction.EditOriginalResponseAsync(builder).ConfigureAwait(false);
 					break;
 
 				case ButtonPaginationBehavior.DeleteMessage:
 					await this._lastInteraction.DeleteOriginalResponseAsync().ConfigureAwait(false);
 					break;
 
 				case ButtonPaginationBehavior.Ignore:
 					break;
 			}
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/EventHandling/EventWaiter.cs b/DisCatSharp.Interactivity/EventHandling/EventWaiter.cs
index 663f3e6a0..7cf72f30e 100644
--- a/DisCatSharp.Interactivity/EventHandling/EventWaiter.cs
+++ b/DisCatSharp.Interactivity/EventHandling/EventWaiter.cs
@@ -1,171 +1,171 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using ConcurrentCollections;
 using DisCatSharp.Common.Utilities;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Interactivity.EventHandling
 {
 	/// <summary>
 	/// Eventwaiter is a class that serves as a layer between the InteractivityExtension
 	/// and the DiscordClient to listen to an event and check for matches to a predicate.
 	/// </summary>
 	/// <typeparam name="T"></typeparam>
 	internal class EventWaiter<T> : IDisposable where T : AsyncEventArgs
 	{
 		DiscordClient _client;
 		AsyncEvent<DiscordClient, T> _event;
 		AsyncEventHandler<DiscordClient, T> _handler;
 		ConcurrentHashSet<MatchRequest<T>> _matchrequests;
 		ConcurrentHashSet<CollectRequest<T>> _collectrequests;
-		bool _disposed = false;
+		bool _disposed;
 
 		/// <summary>
 		/// Creates a new Eventwaiter object.
 		/// </summary>
 		/// <param name="client">Your DiscordClient</param>
 		public EventWaiter(DiscordClient client)
 		{
 			this._client = client;
 			var tinfo = this._client.GetType().GetTypeInfo();
 			var handler = tinfo.DeclaredFields.First(x => x.FieldType == typeof(AsyncEvent<DiscordClient, T>));
 			this._matchrequests = new ConcurrentHashSet<MatchRequest<T>>();
 			this._collectrequests = new ConcurrentHashSet<CollectRequest<T>>();
 			this._event = (AsyncEvent<DiscordClient, T>)handler.GetValue(this._client);
 			this._handler = new AsyncEventHandler<DiscordClient, T>(this.HandleEvent);
 			this._event.Register(this._handler);
 		}
 
 		/// <summary>
 		/// Waits for a match to a specific request, else returns null.
 		/// </summary>
 		/// <param name="request">Request to match</param>
 		/// <returns></returns>
 		public async Task<T> WaitForMatchAsync(MatchRequest<T> request)
 		{
 			T result = null;
 			this._matchrequests.Add(request);
 			try
 			{
 				result = await request.Tcs.Task.ConfigureAwait(false);
 			}
 			catch (Exception ex)
 			{
 				this._client.Logger.LogError(InteractivityEvents.InteractivityWaitError, ex, "An exception occurred while waiting for {0}", typeof(T).Name);
 			}
 			finally
 			{
 				request.Dispose();
 				this._matchrequests.TryRemove(request);
 			}
 			return result;
 		}
 
 		/// <summary>
 		/// Collects the matches async.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		public async Task<ReadOnlyCollection<T>> CollectMatchesAsync(CollectRequest<T> request)
 		{
 			ReadOnlyCollection<T> result = null;
 			this._collectrequests.Add(request);
 			try
 			{
 				await request.Tcs.Task.ConfigureAwait(false);
 			}
 			catch (Exception ex)
 			{
 				this._client.Logger.LogError(InteractivityEvents.InteractivityWaitError, ex, "An exception occurred while collecting from {0}", typeof(T).Name);
 			}
 			finally
 			{
 				result = new ReadOnlyCollection<T>(new HashSet<T>(request.Collected).ToList());
 				request.Dispose();
 				this._collectrequests.TryRemove(request);
 			}
 			return result;
 		}
 
 		/// <summary>
 		/// Handles the event.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="eventargs">The event args.</param>
 		private Task HandleEvent(DiscordClient client, T eventargs)
 		{
 			if (!this._disposed)
 			{
 				foreach (var req in this._matchrequests)
 				{
 					if (req.Predicate(eventargs))
 					{
 						req.Tcs.TrySetResult(eventargs);
 					}
 				}
 
 				foreach (var req in this._collectrequests)
 				{
 					if (req.Predicate(eventargs))
 					{
 						req.Collected.Add(eventargs);
 					}
 				}
 			}
 
 			return Task.CompletedTask;
 		}
 
 		~EventWaiter()
 		{
 			this.Dispose();
 		}
 
 		/// <summary>
 		/// Disposes this EventWaiter
 		/// </summary>
 		public void Dispose()
 		{
 			this._disposed = true;
 			if (this._event != null)
 				this._event.Unregister(this._handler);
 
 			this._event = null;
 			this._handler = null;
 			this._client = null;
 
 			if (this._matchrequests != null)
 				this._matchrequests.Clear();
 			if (this._collectrequests != null)
 				this._collectrequests.Clear();
 
 			this._matchrequests = null;
 			this._collectrequests = null;
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/EventHandling/Requests/PaginationRequest.cs b/DisCatSharp.Interactivity/EventHandling/Requests/PaginationRequest.cs
index a8abc561e..f1d3532fb 100644
--- a/DisCatSharp.Interactivity/EventHandling/Requests/PaginationRequest.cs
+++ b/DisCatSharp.Interactivity/EventHandling/Requests/PaginationRequest.cs
@@ -1,319 +1,319 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.Interactivity.Enums;
 
 namespace DisCatSharp.Interactivity.EventHandling
 {
 	/// <summary>
 	/// The pagination request.
 	/// </summary>
 	internal class PaginationRequest : IPaginationRequest
 	{
 		private TaskCompletionSource<bool> _tcs;
 		private readonly CancellationTokenSource _ct;
 		private readonly TimeSpan _timeout;
 		private readonly List<Page> _pages;
 		private readonly PaginationBehaviour _behaviour;
 		private readonly DiscordMessage _message;
 		private readonly PaginationEmojis _emojis;
 		private readonly DiscordUser _user;
-		private int _index = 0;
+		private int _index;
 
 		/// <summary>
 		/// Creates a new Pagination request
 		/// </summary>
 		/// <param name="message">Message to paginate</param>
 		/// <param name="user">User to allow control for</param>
 		/// <param name="behaviour">Behaviour during pagination</param>
 		/// <param name="deletion">Behavior on pagination end</param>
 		/// <param name="emojis">Emojis for this pagination object</param>
 		/// <param name="timeout">Timeout time</param>
 		/// <param name="pages">Pagination pages</param>
 		internal PaginationRequest(DiscordMessage message, DiscordUser user, PaginationBehaviour behaviour, PaginationDeletion deletion,
 			PaginationEmojis emojis, TimeSpan timeout, params Page[] pages)
 		{
-			this._tcs = new();
-			this._ct = new(timeout);
+			this._tcs = new TaskCompletionSource<bool>();
+			this._ct = new CancellationTokenSource(timeout);
 			this._ct.Token.Register(() => this._tcs.TrySetResult(true));
 			this._timeout = timeout;
 
 			this._message = message;
 			this._user = user;
 
 			this.PaginationDeletion = deletion;
 			this._behaviour = behaviour;
 			this._emojis = emojis;
 
 			this._pages = new List<Page>();
 			foreach (var p in pages)
 			{
 				this._pages.Add(p);
 			}
 		}
 
 		/// <summary>
 		/// Gets the page count.
 		/// </summary>
 		public int PageCount => this._pages.Count;
 
 		/// <summary>
 		/// Gets the pagination deletion.
 		/// </summary>
 		public PaginationDeletion PaginationDeletion { get; }
 
 		/// <summary>
 		/// Gets the page async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task<Page> GetPageAsync()
 		{
 			await Task.Yield();
 
 			return this._pages[this._index];
 		}
 
 		/// <summary>
 		/// Skips the left async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task SkipLeftAsync()
 		{
 			await Task.Yield();
 
 			this._index = 0;
 		}
 
 		/// <summary>
 		/// Skips the right async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task SkipRightAsync()
 		{
 			await Task.Yield();
 
 			this._index = this._pages.Count - 1;
 		}
 
 		/// <summary>
 		/// Nexts the page async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task NextPageAsync()
 		{
 			await Task.Yield();
 
 			switch (this._behaviour)
 			{
 				case PaginationBehaviour.Ignore:
 					if (this._index == this._pages.Count - 1)
 						break;
 					else
 						this._index++;
 
 					break;
 
 				case PaginationBehaviour.WrapAround:
 					if (this._index == this._pages.Count - 1)
 						this._index = 0;
 					else
 						this._index++;
 
 					break;
 			}
 		}
 
 		/// <summary>
 		/// Previous the page async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task PreviousPageAsync()
 		{
 			await Task.Yield();
 
 			switch (this._behaviour)
 			{
 				case PaginationBehaviour.Ignore:
 					if (this._index == 0)
 						break;
 					else
 						this._index--;
 
 					break;
 
 				case PaginationBehaviour.WrapAround:
 					if (this._index == 0)
 						this._index = this._pages.Count - 1;
 					else
 						this._index--;
 
 					break;
 			}
 		}
 
 		/// <summary>
 		/// Gets the buttons async.
 		/// </summary>
 		/// <returns><see cref="System.NotSupportedException"/></returns>
 #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
 		public async Task<IEnumerable<DiscordButtonComponent>> GetButtonsAsync()
 #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
 			=> throw new NotSupportedException("This request does not support buttons.");
 
 		/// <summary>
 		/// Gets the emojis async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task<PaginationEmojis> GetEmojisAsync()
 		{
 			await Task.Yield();
 
 			return this._emojis;
 		}
 
 		/// <summary>
 		/// Gets the message async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task<DiscordMessage> GetMessageAsync()
 		{
 			await Task.Yield();
 
 			return this._message;
 		}
 
 		/// <summary>
 		/// Gets the user async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task<DiscordUser> GetUserAsync()
 		{
 			await Task.Yield();
 
 			return this._user;
 		}
 
 		/// <summary>
 		/// Dos the cleanup async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task DoCleanupAsync()
 		{
 			switch (this.PaginationDeletion)
 			{
 				case PaginationDeletion.DeleteEmojis:
 					await this._message.DeleteAllReactionsAsync().ConfigureAwait(false);
 					break;
 
 				case PaginationDeletion.DeleteMessage:
 					await this._message.DeleteAsync().ConfigureAwait(false);
 					break;
 
 				case PaginationDeletion.KeepEmojis:
 					break;
 			}
 		}
 
 		/// <summary>
 		/// Gets the task completion source async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		public async Task<TaskCompletionSource<bool>> GetTaskCompletionSourceAsync()
 		{
 			await Task.Yield();
 
 			return this._tcs;
 		}
 
 		~PaginationRequest()
 		{
 			this.Dispose();
 		}
 
 		/// <summary>
 		/// Disposes this PaginationRequest.
 		/// </summary>
 		public void Dispose()
 		{
 			this._ct.Dispose();
 			this._tcs = null;
 		}
 	}
 }
 
 namespace DisCatSharp.Interactivity
 {
 	/// <summary>
 	/// The pagination emojis.
 	/// </summary>
 	public class PaginationEmojis
 	{
 		public DiscordEmoji SkipLeft;
 		public DiscordEmoji SkipRight;
 		public DiscordEmoji Left;
 		public DiscordEmoji Right;
 		public DiscordEmoji Stop;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="PaginationEmojis"/> class.
 		/// </summary>
 		public PaginationEmojis()
 		{
 			this.Left = DiscordEmoji.FromUnicode("◀");
 			this.Right = DiscordEmoji.FromUnicode("▶");
 			this.SkipLeft = DiscordEmoji.FromUnicode("⏮");
 			this.SkipRight = DiscordEmoji.FromUnicode("⏭");
 			this.Stop = DiscordEmoji.FromUnicode("⏹");
 		}
 	}
 
 	/// <summary>
 	/// The page.
 	/// </summary>
 	public class Page
 	{
 		/// <summary>
 		/// Gets or sets the content.
 		/// </summary>
 		public string Content { get; set; }
 		/// <summary>
 		/// Gets or sets the embed.
 		/// </summary>
 		public DiscordEmbed Embed { get; set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="Page"/> class.
 		/// </summary>
 		/// <param name="content">The content.</param>
 		/// <param name="embed">The embed.</param>
 		public Page(string content = "", DiscordEmbedBuilder embed = null)
 		{
 			this.Content = content;
 			this.Embed = embed?.Build();
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/InteractivityConfiguration.cs b/DisCatSharp.Interactivity/InteractivityConfiguration.cs
index 67c3f7324..58d67df39 100644
--- a/DisCatSharp.Interactivity/InteractivityConfiguration.cs
+++ b/DisCatSharp.Interactivity/InteractivityConfiguration.cs
@@ -1,115 +1,115 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using DisCatSharp.Interactivity.Enums;
 using DisCatSharp.Interactivity.EventHandling;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.Interactivity
 {
 	/// <summary>
 	/// Configuration class for your Interactivity extension
 	/// </summary>
 	public sealed class InteractivityConfiguration
 	{
 		/// <summary>
 		/// <para>Sets the default interactivity action timeout.</para>
 		/// <para>Defaults to 1 minute.</para>
 		/// </summary>
 		public TimeSpan Timeout { internal get; set; } = TimeSpan.FromMinutes(1);
 
 		/// <summary>
 		/// What to do after the poll ends
 		/// </summary>
 		public PollBehaviour PollBehaviour { internal get; set; } = PollBehaviour.DeleteEmojis;
 
 		/// <summary>
 		/// Emojis to use for pagination
 		/// </summary>
 		public PaginationEmojis PaginationEmojis { internal get; set; } = new();
 
 		/// <summary>
 		/// Buttons to use for pagination.
 		/// </summary>
 		public PaginationButtons PaginationButtons { internal get; set; } = new();
 
 		/// <summary>
 		/// Whether interactivity should ACK buttons that are pushed. Setting this to <see langword="true"/> will also prevent subsequent event handlers from running.
 		/// </summary>
 		public bool AckPaginationButtons { internal get; set; }
 
 		/// <summary>
 		/// How to handle buttons after pagination ends.
 		/// </summary>
-		public ButtonPaginationBehavior ButtonBehavior { internal get; set; } = new();
+		public ButtonPaginationBehavior ButtonBehavior { internal get; set; }
 
 		/// <summary>
 		/// How to handle pagination. Defaults to WrapAround.
 		/// </summary>
 		public PaginationBehaviour PaginationBehaviour { internal get; set; } = PaginationBehaviour.WrapAround;
 
 		/// <summary>
 		/// How to handle pagination deletion. Defaults to DeleteEmojis.
 		/// </summary>
 		public PaginationDeletion PaginationDeletion { internal get; set; } = PaginationDeletion.DeleteEmojis;
 
 		/// <summary>
 		/// How to handle invalid interactions. Defaults to Ignore.
 		/// </summary>
 		public InteractionResponseBehavior ResponseBehavior { internal get; set; } = InteractionResponseBehavior.Ignore;
 
 		/// <summary>
 		/// The message to send to the user when processing invalid interactions. Ignored if <see cref="ResponseBehavior"/> is not set to <see cref="DisCatSharp.Interactivity.Enums.InteractionResponseBehavior.Respond"/>.
 		/// </summary>
 		public string ResponseMessage { internal get; set; }
 
 		/// <summary>
 		/// Creates a new instance of <see cref="InteractivityConfiguration"/>.
 		/// </summary>
 		[ActivatorUtilitiesConstructor]
 		public InteractivityConfiguration()
 		{
 		}
 
 		/// <summary>
 		/// Creates a new instance of <see cref="InteractivityConfiguration"/>, copying the properties of another configuration.
 		/// </summary>
 		/// <param name="other">Configuration the properties of which are to be copied.</param>
 		public InteractivityConfiguration(InteractivityConfiguration other)
 		{
 			this.AckPaginationButtons = other.AckPaginationButtons;
 			this.PaginationButtons = other.PaginationButtons;
 			this.ButtonBehavior = other.ButtonBehavior;
 			this.PaginationBehaviour = other.PaginationBehaviour;
 			this.PaginationDeletion = other.PaginationDeletion;
 			this.ResponseBehavior = other.ResponseBehavior;
 			this.PaginationEmojis = other.PaginationEmojis;
 			this.ResponseMessage = other.ResponseMessage;
 			this.PollBehaviour = other.PollBehaviour;
 			this.Timeout = other.Timeout;
 
 			if (this.ResponseBehavior is InteractionResponseBehavior.Respond && string.IsNullOrWhiteSpace(this.ResponseMessage))
 				throw new ArgumentException($"{nameof(this.ResponseMessage)} cannot be null, empty, or whitespace when {nameof(this.ResponseBehavior)} is set to respond.");
 		}
 	}
 }
diff --git a/DisCatSharp.Interactivity/InteractivityEvents.cs b/DisCatSharp.Interactivity/InteractivityEvents.cs
index de5365b96..d20c87cef 100644
--- a/DisCatSharp.Interactivity/InteractivityEvents.cs
+++ b/DisCatSharp.Interactivity/InteractivityEvents.cs
@@ -1,57 +1,57 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Interactivity
 {
 	/// <summary>
 	/// Contains well-defined event IDs used by the Interactivity extension.
 	/// </summary>
 	public static class InteractivityEvents
 	{
 		/// <summary>
 		/// Miscellaneous events, that do not fit in any other category.
 		/// </summary>
-		public static EventId Misc { get; } = new EventId(500, "Interactivity");
+		public static EventId Misc { get; } = new(500, "Interactivity");
 
 		/// <summary>
 		/// Events pertaining to errors that happen during waiting for events.
 		/// </summary>
-		public static EventId InteractivityWaitError { get; } = new EventId(501, nameof(InteractivityWaitError));
+		public static EventId InteractivityWaitError { get; } = new(501, nameof(InteractivityWaitError));
 
 		/// <summary>
 		/// Events pertaining to pagination.
 		/// </summary>
-		public static EventId InteractivityPaginationError { get; } = new EventId(502, nameof(InteractivityPaginationError));
+		public static EventId InteractivityPaginationError { get; } = new(502, nameof(InteractivityPaginationError));
 
 		/// <summary>
 		/// Events pertaining to polling.
 		/// </summary>
-		public static EventId InteractivityPollError { get; } = new EventId(503, nameof(InteractivityPollError));
+		public static EventId InteractivityPollError { get; } = new(503, nameof(InteractivityPollError));
 
 		/// <summary>
 		/// Events pertaining to event collection.
 		/// </summary>
-		public static EventId InteractivityCollectorError { get; } = new EventId(504, nameof(InteractivityCollectorError));
+		public static EventId InteractivityCollectorError { get; } = new(504, nameof(InteractivityCollectorError));
 	}
 }
diff --git a/DisCatSharp.Interactivity/InteractivityExtension.cs b/DisCatSharp.Interactivity/InteractivityExtension.cs
index bff60ea85..79c129736 100644
--- a/DisCatSharp.Interactivity/InteractivityExtension.cs
+++ b/DisCatSharp.Interactivity/InteractivityExtension.cs
@@ -1,958 +1,958 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Interactivity.Enums;
 using DisCatSharp.Interactivity.EventHandling;
 
 namespace DisCatSharp.Interactivity
 {
 	/// <summary>
 	/// Extension class for DisCatSharp.Interactivity
 	/// </summary>
 	public class InteractivityExtension : BaseExtension
 	{
 
 		/// <summary>
 		/// Gets the config.
 		/// </summary>
 		internal InteractivityConfiguration Config { get; }
 
 		private EventWaiter<MessageCreateEventArgs> _messageCreatedWaiter;
 
 		private EventWaiter<MessageReactionAddEventArgs> _messageReactionAddWaiter;
 
 		private EventWaiter<TypingStartEventArgs> _typingStartWaiter;
 
 		private EventWaiter<ComponentInteractionCreateEventArgs> _modalInteractionWaiter;
 
 		private EventWaiter<ComponentInteractionCreateEventArgs> _componentInteractionWaiter;
 
 		private ComponentEventWaiter _componentEventWaiter;
 
 		private ModalEventWaiter _modalEventWaiter;
 
 		private ReactionCollector _reactionCollector;
 
 		private Poller _poller;
 
 		private Paginator _paginator;
 		private  ComponentPaginator _compPaginator;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="InteractivityExtension"/> class.
 		/// </summary>
 		/// <param name="cfg">The configuration.</param>
 		internal InteractivityExtension(InteractivityConfiguration cfg)
 		{
 			this.Config = new InteractivityConfiguration(cfg);
 		}
 
 		/// <summary>
 		/// Setups the Interactivity Extension.
 		/// </summary>
 		/// <param name="client">Discord client.</param>
 		protected internal override void Setup(DiscordClient client)
 		{
 			this.Client = client;
 			this._messageCreatedWaiter = new EventWaiter<MessageCreateEventArgs>(this.Client);
 			this._messageReactionAddWaiter = new EventWaiter<MessageReactionAddEventArgs>(this.Client);
 			this._componentInteractionWaiter = new EventWaiter<ComponentInteractionCreateEventArgs>(this.Client);
 			this._modalInteractionWaiter = new EventWaiter<ComponentInteractionCreateEventArgs>(this.Client);
 			this._typingStartWaiter = new EventWaiter<TypingStartEventArgs>(this.Client);
 			this._poller = new Poller(this.Client);
 			this._reactionCollector = new ReactionCollector(this.Client);
 			this._paginator = new Paginator(this.Client);
-			this._compPaginator = new(this.Client, this.Config);
-			this._componentEventWaiter = new(this.Client, this.Config);
-			this._modalEventWaiter = new(this.Client, this.Config);
+			this._compPaginator = new ComponentPaginator(this.Client, this.Config);
+			this._componentEventWaiter = new ComponentEventWaiter(this.Client, this.Config);
+			this._modalEventWaiter = new ModalEventWaiter(this.Client, this.Config);
 
 		}
 
 		/// <summary>
 		/// Makes a poll and returns poll results.
 		/// </summary>
 		/// <param name="m">Message to create poll on.</param>
 		/// <param name="emojis">Emojis to use for this poll.</param>
 		/// <param name="behaviour">What to do when the poll ends.</param>
 		/// <param name="timeout">override timeout period.</param>
 		/// <returns></returns>
 		public async Task<ReadOnlyCollection<PollEmoji>> DoPollAsync(DiscordMessage m, IEnumerable<DiscordEmoji> emojis, PollBehaviour? behaviour = default, TimeSpan? timeout = null)
 		{
 			if (!Utilities.HasReactionIntents(this.Client.Configuration.Intents))
 				throw new InvalidOperationException("No reaction intents are enabled.");
 
 			if (!emojis.Any())
 				throw new ArgumentException("You need to provide at least one emoji for a poll!");
 
 			foreach (var em in emojis)
 				await m.CreateReactionAsync(em).ConfigureAwait(false);
 
 			var res = await this._poller.DoPollAsync(new PollRequest(m, timeout ?? this.Config.Timeout, emojis)).ConfigureAwait(false);
 
 			var pollbehaviour = behaviour ?? this.Config.PollBehaviour;
 			var thismember = await m.Channel.Guild.GetMemberAsync(this.Client.CurrentUser.Id).ConfigureAwait(false);
 
 			if (pollbehaviour == PollBehaviour.DeleteEmojis && m.Channel.PermissionsFor(thismember).HasPermission(Permissions.ManageMessages))
 				await m.DeleteAllReactionsAsync().ConfigureAwait(false);
 
 			return new ReadOnlyCollection<PollEmoji>(res.ToList());
 		}
 
 		/// <summary>
 		/// Waits for any button in the specified collection to be pressed.
 		/// </summary>
 		/// <param name="message">The message to wait on.</param>
 		/// <param name="buttons">A collection of buttons to listen for.</param>
 		/// <param name="timeoutOverride">Override the timeout period in <see cref="InteractivityConfiguration"/>.</param>
 		/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 		/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 		public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, IEnumerable<DiscordButtonComponent> buttons, TimeSpan? timeoutOverride = null)
 			=> this.WaitForButtonAsync(message, buttons, this.GetCancellationToken(timeoutOverride));
 
 		/// <summary>
 		/// Waits for any button in the specified collection to be pressed.
 		/// </summary>
 		/// <param name="message">The message to wait on.</param>
 		/// <param name="buttons">A collection of buttons to listen for.</param>
 		/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 		/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 		/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 		public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, IEnumerable<DiscordButtonComponent> buttons, CancellationToken token)
 		{
 			if (message.Author != this.Client.CurrentUser)
 				throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 			if (!buttons.Any())
 				throw new ArgumentException("You must specify at least one button to listen for.");
 
 			if (!message.Components.Any())
 				throw new ArgumentException("Provided message does not contain any components.");
 
 			if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 				throw new ArgumentException("Provided Message does not contain any button components.");
 
 			var res = await this._componentEventWaiter
-				.WaitForMatchAsync(new(message,
+				.WaitForMatchAsync(new ComponentMatchRequest(message,
 					c =>
 						c.Interaction.Data.ComponentType == ComponentType.Button &&
 						buttons.Any(b => b.CustomId == c.Id), token)).ConfigureAwait(false);
 
-			return new(res is null, res);
+			return new InteractivityResult<ComponentInteractionCreateEventArgs>(res is null, res);
 		}
 
 		/// <summary>
 		/// Waits for a user modal submit.
 		/// </summary>
 		/// <param name="customId">The custom id of the modal to wait for.</param>
 		/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 		/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the modal.</returns>
 		public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForModalAsync(string customId, TimeSpan? timeoutOverride = null)
 			=> this.WaitForModalAsync(customId, this.GetCancellationToken(timeoutOverride));
 
 		/// <summary>
 		/// Waits for a user modal submit.
 		/// </summary>
 		/// <param name="customId">The custom id of the modal to wait for.</param>
 		/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 		/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the modal.</returns>
 		public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForModalAsync(string customId, CancellationToken token)
 		{
 			var result =
 				await this
 				._modalEventWaiter
-				.WaitForModalMatchAsync(new(customId, c => c.Interaction.Type == InteractionType.ModalSubmit, token))
+				.WaitForModalMatchAsync(new ModalMatchRequest(customId, c => c.Interaction.Type == InteractionType.ModalSubmit, token))
 				.ConfigureAwait(false);
 
-			return new(result is null, result);
+			return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 		}
 
 		/// <summary>
 		/// Waits for any button on the specified message to be pressed.
 		/// </summary>
 		/// <param name="message">The message to wait for the button on.</param>
 		/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 		/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 		/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 		public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, TimeSpan? timeoutOverride = null)
 			=> this.WaitForButtonAsync(message, this.GetCancellationToken(timeoutOverride));
 
 		/// <summary>
 		/// Waits for any button on the specified message to be pressed.
 		/// </summary>
 		/// <param name="message">The message to wait for the button on.</param>
 		/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 		/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 		/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 		public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, CancellationToken token)
 		{
 			if (message.Author != this.Client.CurrentUser)
 				throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 			if (!message.Components.Any())
 				throw new ArgumentException("Provided message does not contain any components.");
 
 			if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 				throw new ArgumentException("Message does not contain any button components.");
 
 			var ids = message.Components.SelectMany(m => m.Components).Select(c => c.CustomId);
 
 			var result =
 				await this
 				._componentEventWaiter
-				.WaitForMatchAsync(new(message, c => c.Interaction.Data.ComponentType == ComponentType.Button && ids.Contains(c.Id), token))
+				.WaitForMatchAsync(new ComponentMatchRequest(message, c => c.Interaction.Data.ComponentType == ComponentType.Button && ids.Contains(c.Id), token))
 				.ConfigureAwait(false);
 
-			return new(result is null, result);
+			return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 		}
 
 		/// <summary>
 		/// Waits for any button on the specified message to be pressed by the specified user.
 		/// </summary>
 		/// <param name="message">The message to wait for the button on.</param>
 		/// <param name="user">The user to wait for the button press from.</param>
 		/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 		/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 		/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 		public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, DiscordUser user, TimeSpan? timeoutOverride = null)
 			=> this.WaitForButtonAsync(message, user, this.GetCancellationToken(timeoutOverride));
 
 		/// <summary>
 		/// Waits for any button on the specified message to be pressed by the specified user.
 		/// </summary>
 		/// <param name="message">The message to wait for the button on.</param>
 		/// <param name="user">The user to wait for the button press from.</param>
 		/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 		/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 		/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 		public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, DiscordUser user, CancellationToken token)
 		{
 			if (message.Author != this.Client.CurrentUser)
 				throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 			if (!message.Components.Any())
 				throw new ArgumentException("Provided message does not contain any components.");
 
 			if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 				throw new ArgumentException("Message does not contain any button components.");
 
 			var result = await this
 				._componentEventWaiter
-				.WaitForMatchAsync(new(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Button && c.User == user, token))
+				.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Button && c.User == user, token))
 				.ConfigureAwait(false);
 
-			return new(result is null, result);
+			return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 
 		}
 
 		/// <summary>
 		/// Waits for a button with the specified Id to be pressed.
 		/// </summary>
 		/// <param name="message">The message to wait for the button on.</param>
 		/// <param name="id">The Id of the button to wait for.</param>
 		/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 		/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the operation.</returns>
 		/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 		public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, string id, TimeSpan? timeoutOverride = null)
 			=> this.WaitForButtonAsync(message, id, this.GetCancellationToken(timeoutOverride));
 
 		/// <summary>
 		/// Waits for a button with the specified Id to be pressed.
 		/// </summary>
 		/// <param name="message">The message to wait for the button on.</param>
 		/// <param name="id">The Id of the button to wait for.</param>
 		/// <param name="token">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 		/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the operation.</returns>
 		/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 		public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, string id, CancellationToken token)
 		{
 			if (message.Author != this.Client.CurrentUser)
 				throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 			if (!message.Components.Any())
 				throw new ArgumentException("Provided message does not contain any components.");
 
 			if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 				throw new ArgumentException("Message does not contain any button components.");
 
 			if (!message.Components.SelectMany(c => c.Components).OfType<DiscordButtonComponent>().Any(c => c.CustomId == id))
 				throw new ArgumentException($"Message does not contain button with Id of '{id}'.");
 			var result = await this
 				._componentEventWaiter
-				.WaitForMatchAsync(new(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Button && c.Id == id, token))
+				.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Button && c.Id == id, token))
 				.ConfigureAwait(false);
 
-			return new(result is null, result);
+			return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 		}
 
 		/// <summary>
 		/// Waits for any button to be interacted with.
 		/// </summary>
 		/// <param name="message">The message to wait on.</param>
 		/// <param name="predicate">The predicate to filter interactions by.</param>
 		/// <param name="timeoutOverride">Override the timeout specified in <see cref="InteractivityConfiguration"/></param>
 		public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, TimeSpan? timeoutOverride = null)
 			=> this.WaitForButtonAsync(message, predicate, this.GetCancellationToken(timeoutOverride));
 
 		/// <summary>
 		/// Waits for any button to be interacted with.
 		/// </summary>
 		/// <param name="message">The message to wait on.</param>
 		/// <param name="predicate">The predicate to filter interactions by.</param>
 		/// <param name="token">A token to cancel interactivity with at any time. Pass <see cref="System.Threading.CancellationToken.None"/> to wait indefinitely.</param>
 		public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, CancellationToken token)
 		{
 			if (message.Author != this.Client.CurrentUser)
 				throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 			if (!message.Components.Any())
 				throw new ArgumentException("Provided message does not contain any components.");
 
 			if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 				throw new ArgumentException("Message does not contain any button components.");
 
 			var result = await this
 				._componentEventWaiter
-				.WaitForMatchAsync(new(message, c => c.Interaction.Data.ComponentType is ComponentType.Button && predicate(c), token))
+				.WaitForMatchAsync(new ComponentMatchRequest(message, c => c.Interaction.Data.ComponentType is ComponentType.Button && predicate(c), token))
 				.ConfigureAwait(false);
 
-			return new(result is null, result);
+			return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 		}
 
 
 		/// <summary>
 		/// Waits for any dropdown to be interacted with.
 		/// </summary>
 		/// <param name="message">The message to wait for.</param>
 		/// <param name="predicate">A filter predicate.</param>
 		/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 		/// <exception cref="System.ArgumentException">Thrown when the Provided message does not contain any dropdowns</exception>
 		public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, TimeSpan? timeoutOverride = null)
 			=> this.WaitForSelectAsync(message, predicate, this.GetCancellationToken(timeoutOverride));
 
 		/// <summary>
 		/// Waits for any dropdown to be interacted with.
 		/// </summary>
 		/// <param name="message">The message to wait for.</param>
 		/// <param name="predicate">A filter predicate.</param>
 		/// <param name="token">A token that can be used to cancel interactivity. Pass <see cref="System.Threading.CancellationToken.None"/> to wait indefinitely.</param>
 		/// <exception cref="System.ArgumentException">Thrown when the Provided message does not contain any dropdowns</exception>
 		public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, CancellationToken token)
 		{
 			if (message.Author != this.Client.CurrentUser)
 				throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 			if (!message.Components.Any())
 				throw new ArgumentException("Provided message does not contain any components.");
 
 			if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Select))
 				throw new ArgumentException("Message does not contain any select components.");
 
 			var result = await this
 				._componentEventWaiter
-				.WaitForMatchAsync(new(message, c => c.Interaction.Data.ComponentType is ComponentType.Select && predicate(c), token))
+				.WaitForMatchAsync(new ComponentMatchRequest(message, c => c.Interaction.Data.ComponentType is ComponentType.Select && predicate(c), token))
 				.ConfigureAwait(false);
 
-			return new(result is null, result);
+			return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 		}
 
 		/// <summary>
 		/// Waits for a dropdown to be interacted with.
 		/// </summary>
 		/// <remarks>This is here for backwards-compatibility and will internally create a cancellation token.</remarks>
 		/// <param name="message">The message to wait on.</param>
 		/// <param name="id">The Id of the dropdown to wait on.</param>
 		/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 		public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, string id, TimeSpan? timeoutOverride = null)
 			=> this.WaitForSelectAsync(message, id, this.GetCancellationToken(timeoutOverride));
 
 		/// <summary>
 		/// Waits for a dropdown to be interacted with.
 		/// </summary>
 		/// <param name="message">The message to wait on.</param>
 		/// <param name="id">The Id of the dropdown to wait on.</param>
 		/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 		public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, string id, CancellationToken token)
 		{
 			if (message.Author != this.Client.CurrentUser)
 				throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 			if (!message.Components.Any())
 				throw new ArgumentException("Provided message does not contain any components.");
 
 			if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Select))
 				throw new ArgumentException("Message does not contain any select components.");
 
 			if (message.Components.SelectMany(c => c.Components).OfType<DiscordSelectComponent>().All(c => c.CustomId != id))
 				throw new ArgumentException($"Message does not contain select component with Id of '{id}'.");
 
 			var result = await this
 				._componentEventWaiter
-				.WaitForMatchAsync(new(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Select && c.Id == id, token))
+				.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Select && c.Id == id, token))
 				.ConfigureAwait(false);
 
-			return new(result is null, result);
+			return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 		}
 
 		/// <summary>
 		/// Waits for a dropdown to be interacted with by a specific user.
 		/// </summary>
 		/// <param name="message">The message to wait on.</param>
 		/// <param name="user">The user to wait on.</param>
 		/// <param name="id">The Id of the dropdown to wait on.</param>
 		/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 		public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, DiscordUser user, string id, TimeSpan? timeoutOverride = null)
 			=> this.WaitForSelectAsync(message, user, id, this.GetCancellationToken(timeoutOverride));
 
 		/// <summary>
 		/// Waits for a dropdown to be interacted with by a specific user.
 		/// </summary>
 		/// <param name="message">The message to wait on.</param>
 		/// <param name="user">The user to wait on.</param>
 		/// <param name="id">The Id of the dropdown to wait on.</param>
 		/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 		/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 		public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, DiscordUser user, string id, CancellationToken token)
 		{
 			if (message.Author != this.Client.CurrentUser)
 				throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 			if (!message.Components.Any())
 				throw new ArgumentException("Provided message does not contain any components.");
 
 			if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Select))
 				throw new ArgumentException("Message does not contain any select components.");
 
 			if (message.Components.SelectMany(c => c.Components).OfType<DiscordSelectComponent>().All(c => c.CustomId != id))
 				throw new ArgumentException($"Message does not contain select with Id of '{id}'.");
 
 			var result = await this
 				._componentEventWaiter
-				.WaitForMatchAsync(new(message, (c) => c.Id == id && c.User == user, token)).ConfigureAwait(false);
+				.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Id == id && c.User == user, token)).ConfigureAwait(false);
 
-			return new(result is null, result);
+			return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 		}
 
 
 		/// <summary>
 		/// Waits for a specific message.
 		/// </summary>
 		/// <param name="predicate">Predicate to match.</param>
 		/// <param name="timeoutoverride">override timeout period.</param>
 		public async Task<InteractivityResult<DiscordMessage>> WaitForMessageAsync(Func<DiscordMessage, bool> predicate,
 			TimeSpan? timeoutoverride = null)
 		{
 			if (!Utilities.HasMessageIntents(this.Client.Configuration.Intents))
 				throw new InvalidOperationException("No message intents are enabled.");
 
 			var timeout = timeoutoverride ?? this.Config.Timeout;
 			var returns = await this._messageCreatedWaiter.WaitForMatchAsync(new MatchRequest<MessageCreateEventArgs>(x => predicate(x.Message), timeout)).ConfigureAwait(false);
 
 			return new InteractivityResult<DiscordMessage>(returns == null, returns?.Message);
 		}
 
 		/// <summary>
 		/// Wait for a specific reaction.
 		/// </summary>
 		/// <param name="predicate">Predicate to match.</param>
 		/// <param name="timeoutoverride">override timeout period.</param>
 		public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(Func<MessageReactionAddEventArgs, bool> predicate,
 			TimeSpan? timeoutoverride = null)
 		{
 			if (!Utilities.HasReactionIntents(this.Client.Configuration.Intents))
 				throw new InvalidOperationException("No reaction intents are enabled.");
 
 			var timeout = timeoutoverride ?? this.Config.Timeout;
 			var returns = await this._messageReactionAddWaiter.WaitForMatchAsync(new MatchRequest<MessageReactionAddEventArgs>(predicate, timeout)).ConfigureAwait(false);
 
 			return new InteractivityResult<MessageReactionAddEventArgs>(returns == null, returns);
 		}
 
 		/// <summary>
 		/// Wait for a specific reaction.
 		/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 		/// </summary>
 		/// <param name="message">Message reaction was added to.</param>
 		/// <param name="user">User that made the reaction.</param>
 		/// <param name="timeoutoverride">override timeout period.</param>
 		public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(DiscordMessage message, DiscordUser user,
 			TimeSpan? timeoutoverride = null)
 			=> await this.WaitForReactionAsync(x => x.User.Id == user.Id && x.Message.Id == message.Id, timeoutoverride).ConfigureAwait(false);
 
 		/// <summary>
 		/// Waits for a specific reaction.
 		/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 		/// </summary>
 		/// <param name="predicate">Predicate to match.</param>
 		/// <param name="message">Message reaction was added to.</param>
 		/// <param name="user">User that made the reaction.</param>
 		/// <param name="timeoutoverride">override timeout period.</param>
 		public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(Func<MessageReactionAddEventArgs, bool> predicate,
 			DiscordMessage message, DiscordUser user, TimeSpan? timeoutoverride = null)
 			=> await this.WaitForReactionAsync(x => predicate(x) && x.User.Id == user.Id && x.Message.Id == message.Id, timeoutoverride).ConfigureAwait(false);
 
 		/// <summary>
 		/// Waits for a specific reaction.
 		/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 		/// </summary>
 		/// <param name="predicate">predicate to match.</param>
 		/// <param name="user">User that made the reaction.</param>
 		/// <param name="timeoutoverride">Override timeout period.</param>
 		public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(Func<MessageReactionAddEventArgs, bool> predicate,
 			DiscordUser user, TimeSpan? timeoutoverride = null)
 			=> await this.WaitForReactionAsync(x => predicate(x) && x.User.Id == user.Id, timeoutoverride).ConfigureAwait(false);
 
 		/// <summary>
 		/// Waits for a user to start typing.
 		/// </summary>
 		/// <param name="user">User that starts typing.</param>
 		/// <param name="channel">Channel the user is typing in.</param>
 		/// <param name="timeoutoverride">Override timeout period.</param>
 		public async Task<InteractivityResult<TypingStartEventArgs>> WaitForUserTypingAsync(DiscordUser user,
 			DiscordChannel channel, TimeSpan? timeoutoverride = null)
 		{
 			if (!Utilities.HasTypingIntents(this.Client.Configuration.Intents))
 				throw new InvalidOperationException("No typing intents are enabled.");
 
 			var timeout = timeoutoverride ?? this.Config.Timeout;
 			var returns = await this._typingStartWaiter.WaitForMatchAsync(
 				new MatchRequest<TypingStartEventArgs>(x => x.User.Id == user.Id && x.Channel.Id == channel.Id, timeout))
 				.ConfigureAwait(false);
 
 			return new InteractivityResult<TypingStartEventArgs>(returns == null, returns);
 		}
 
 		/// <summary>
 		/// Waits for a user to start typing.
 		/// </summary>
 		/// <param name="user">User that starts typing.</param>
 		/// <param name="timeoutoverride">Override timeout period.</param>
 		public async Task<InteractivityResult<TypingStartEventArgs>> WaitForUserTypingAsync(DiscordUser user, TimeSpan? timeoutoverride = null)
 		{
 			if (!Utilities.HasTypingIntents(this.Client.Configuration.Intents))
 				throw new InvalidOperationException("No typing intents are enabled.");
 
 			var timeout = timeoutoverride ?? this.Config.Timeout;
 			var returns = await this._typingStartWaiter.WaitForMatchAsync(
 				new MatchRequest<TypingStartEventArgs>(x => x.User.Id == user.Id, timeout))
 				.ConfigureAwait(false);
 
 			return new InteractivityResult<TypingStartEventArgs>(returns == null, returns);
 		}
 
 		/// <summary>
 		/// Waits for any user to start typing.
 		/// </summary>
 		/// <param name="channel">Channel to type in.</param>
 		/// <param name="timeoutoverride">Override timeout period.</param>
 		public async Task<InteractivityResult<TypingStartEventArgs>> WaitForTypingAsync(DiscordChannel channel, TimeSpan? timeoutoverride = null)
 		{
 			if (!Utilities.HasTypingIntents(this.Client.Configuration.Intents))
 				throw new InvalidOperationException("No typing intents are enabled.");
 
 			var timeout = timeoutoverride ?? this.Config.Timeout;
 			var returns = await this._typingStartWaiter.WaitForMatchAsync(
 				new MatchRequest<TypingStartEventArgs>(x => x.Channel.Id == channel.Id, timeout))
 				.ConfigureAwait(false);
 
 			return new InteractivityResult<TypingStartEventArgs>(returns == null, returns);
 		}
 
 		/// <summary>
 		/// Collects reactions on a specific message.
 		/// </summary>
 		/// <param name="m">Message to collect reactions on.</param>
 		/// <param name="timeoutoverride">Override timeout period.</param>
 		public async Task<ReadOnlyCollection<Reaction>> CollectReactionsAsync(DiscordMessage m, TimeSpan? timeoutoverride = null)
 		{
 			if (!Utilities.HasReactionIntents(this.Client.Configuration.Intents))
 				throw new InvalidOperationException("No reaction intents are enabled.");
 
 			var timeout = timeoutoverride ?? this.Config.Timeout;
 			var collection = await this._reactionCollector.CollectAsync(new ReactionCollectRequest(m, timeout)).ConfigureAwait(false);
 
 			return collection;
 		}
 
 		/// <summary>
 		/// Waits for specific event args to be received. Make sure the appropriate <see cref="DiscordIntents"/> are registered, if needed.
 		/// </summary>
 		/// <typeparam name="T"></typeparam>
 		/// <param name="predicate">The predicate.</param>
 		/// <param name="timeoutoverride">Override timeout period.</param>
 		public async Task<InteractivityResult<T>> WaitForEventArgsAsync<T>(Func<T, bool> predicate, TimeSpan? timeoutoverride = null) where T : AsyncEventArgs
 		{
 			var timeout = timeoutoverride ?? this.Config.Timeout;
 
 			using var waiter = new EventWaiter<T>(this.Client);
 			var res = await waiter.WaitForMatchAsync(new MatchRequest<T>(predicate, timeout)).ConfigureAwait(false);
 			return new InteractivityResult<T>(res == null, res);
 		}
 
 		/// <summary>
 		/// Collects the event arguments.
 		/// </summary>
 		/// <param name="predicate">The predicate.</param>
 		/// <param name="timeoutoverride">Override timeout period.</param>
 		public async Task<ReadOnlyCollection<T>> CollectEventArgsAsync<T>(Func<T, bool> predicate, TimeSpan? timeoutoverride = null) where T : AsyncEventArgs
 		{
 			var timeout = timeoutoverride ?? this.Config.Timeout;
 
 			using var waiter = new EventWaiter<T>(this.Client);
 			var res = await waiter.CollectMatchesAsync(new CollectRequest<T>(predicate, timeout)).ConfigureAwait(false);
 			return res;
 		}
 
 		/// <summary>
 		/// Sends a paginated message with buttons.
 		/// </summary>
 		/// <param name="channel">The channel to send it on.</param>
 		/// <param name="user">User to give control.</param>
 		/// <param name="pages">The pages.</param>
 		/// <param name="buttons">Pagination buttons (pass null to use buttons defined in <see cref="InteractivityConfiguration"/>).</param>
 		/// <param name="behaviour">Pagination behaviour.</param>
 		/// <param name="deletion">Deletion behaviour</param>
 		/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 		public async Task SendPaginatedMessageAsync(
 			DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons,
 			PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 		{
 			var bhv = behaviour ?? this.Config.PaginationBehaviour;
 			var del = deletion ?? this.Config.ButtonBehavior;
 			var bts = buttons ?? this.Config.PaginationButtons;
 
-			bts = new(bts);
+			bts = new PaginationButtons(bts);
 			if (bhv is PaginationBehaviour.Ignore)
 			{
 				bts.SkipLeft.Disable();
 				bts.Left.Disable();
 			}
 
 			var builder = new DiscordMessageBuilder()
 				.WithContent(pages.First().Content)
 				.WithEmbed(pages.First().Embed)
 				.AddComponents(bts.ButtonArray);
 
 			var message = await builder.SendAsync(channel).ConfigureAwait(false);
 
 			var req = new ButtonPaginationRequest(message, user, bhv, del, bts, pages.ToArray(), token == default ? this.GetCancellationToken() : token);
 
 			await this._compPaginator.DoPaginationAsync(req).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Sends a paginated message with buttons.
 		/// </summary>
 		/// <param name="channel">The channel to send it on.</param>
 		/// <param name="user">User to give control.</param>
 		/// <param name="pages">The pages.</param>
 		/// <param name="buttons">Pagination buttons (pass null to use buttons defined in <see cref="InteractivityConfiguration"/>).</param>
 		/// <param name="behaviour">Pagination behaviour.</param>
 		/// <param name="deletion">Deletion behaviour</param>
 		/// <param name="timeoutoverride">Override timeout period.</param>
 		public Task SendPaginatedMessageAsync(
 			DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons, TimeSpan? timeoutoverride,
 			PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default)
 			=> this.SendPaginatedMessageAsync(channel, user, pages, buttons, behaviour, deletion, this.GetCancellationToken(timeoutoverride));
 
 		/// <summary>
 		/// Sends the paginated message.
 		/// </summary>
 		/// <param name="channel">The channel.</param>
 		/// <param name="user">The user.</param>
 		/// <param name="pages">The pages.</param>
 		/// <param name="behaviour">The behaviour.</param>
 		/// <param name="deletion">The deletion.</param>
 		/// <param name="token">The token.</param>
 		/// <returns>A Task.</returns>
 		public Task SendPaginatedMessageAsync(DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 			=> this.SendPaginatedMessageAsync(channel, user, pages, default, behaviour, deletion, token);
 
 		/// <summary>
 		/// Sends the paginated message.
 		/// </summary>
 		/// <param name="channel">The channel.</param>
 		/// <param name="user">The user.</param>
 		/// <param name="pages">The pages.</param>
 		/// <param name="timeoutoverride">The timeoutoverride.</param>
 		/// <param name="behaviour">The behaviour.</param>
 		/// <param name="deletion">The deletion.</param>
 		/// <returns>A Task.</returns>
 		public Task SendPaginatedMessageAsync(DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, TimeSpan? timeoutoverride, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default)
 			=> this.SendPaginatedMessageAsync(channel, user, pages, timeoutoverride, behaviour, deletion);
 
 		/// <summary>
 		/// Sends a paginated message.
 		/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 		/// </summary>
 		/// <param name="channel">Channel to send paginated message in.</param>
 		/// <param name="user">User to give control.</param>
 		/// <param name="pages">Pages.</param>
 		/// <param name="emojis">Pagination emojis.</param>
 		/// <param name="behaviour">Pagination behaviour (when hitting max and min indices).</param>
 		/// <param name="deletion">Deletion behaviour.</param>
 		/// <param name="timeoutoverride">Override timeout period.</param>
 		public async Task SendPaginatedMessageAsync(DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationEmojis emojis,
 			PaginationBehaviour? behaviour = default, PaginationDeletion? deletion = default, TimeSpan? timeoutoverride = null)
 		{
 			var builder = new DiscordMessageBuilder()
 				.WithContent(pages.First().Content)
 				.WithEmbed(pages.First().Embed);
 			var m = await builder.SendAsync(channel).ConfigureAwait(false);
 
 			var timeout = timeoutoverride ?? this.Config.Timeout;
 
 			var bhv = behaviour ?? this.Config.PaginationBehaviour;
 			var del = deletion ?? this.Config.PaginationDeletion;
 			var ems = emojis ?? this.Config.PaginationEmojis;
 
 			var prequest = new PaginationRequest(m, user, bhv, del, ems, timeout, pages.ToArray());
 
 			await this._paginator.DoPaginationAsync(prequest).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Sends a paginated message in response to an interaction.
 		/// <para>
 		/// <b>Pass the interaction directly. Interactivity will ACK it.</b>
 		/// </para>
 		/// </summary>
 		/// <param name="interaction">The interaction to create a response to.</param>
 		/// <param name="ephemeral">Whether the response should be ephemeral.</param>
 		/// <param name="user">The user to listen for button presses from.</param>
 		/// <param name="pages">The pages to paginate.</param>
 		/// <param name="buttons">Optional: custom buttons</param>
 		/// <param name="behaviour">Pagination behaviour.</param>
 		/// <param name="deletion">Deletion behaviour</param>
 		/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 		public async Task SendPaginatedResponseAsync(DiscordInteraction interaction, bool ephemeral, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons = null, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 		{
 			var bhv = behaviour ?? this.Config.PaginationBehaviour;
 			var del = deletion ?? this.Config.ButtonBehavior;
 			var bts = buttons ?? this.Config.PaginationButtons;
 
-			bts = new(bts);
+			bts = new PaginationButtons(bts);
 			if (bhv is PaginationBehaviour.Ignore)
 			{
 				bts.SkipLeft.Disable();
 				bts.Left.Disable();
 			}
 
 			var builder = new DiscordInteractionResponseBuilder()
 				.WithContent(pages.First().Content)
 				.AddEmbed(pages.First().Embed)
 				.AsEphemeral(ephemeral)
 				.AddComponents(bts.ButtonArray);
 
 			await interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder).ConfigureAwait(false);
 			var message = await interaction.GetOriginalResponseAsync().ConfigureAwait(false);
 
 			var req = new InteractionPaginationRequest(interaction, message, user, bhv, del, bts, pages, token);
 
 			await this._compPaginator.DoPaginationAsync(req).ConfigureAwait(false);
 		}
 
 
 		/// <summary>
 		/// Waits for a custom pagination request to finish.
 		/// This does NOT handle removing emojis after finishing for you.
 		/// </summary>
 		/// <param name="request"></param>
 		/// <returns></returns>
 		public async Task WaitForCustomPaginationAsync(IPaginationRequest request) => await this._paginator.DoPaginationAsync(request).ConfigureAwait(false);
 
 		/// <summary>
 		/// Waits for custom button-based pagination request to finish.
 		/// <br/>
 		/// This does <i><b>not</b></i> invoke <see cref="DisCatSharp.Interactivity.EventHandling.IPaginationRequest.DoCleanupAsync"/>.
 		/// </summary>
 		/// <param name="request">The request to wait for.</param>
 		public async Task WaitForCustomComponentPaginationAsync(IPaginationRequest request) => await this._compPaginator.DoPaginationAsync(request).ConfigureAwait(false);
 
 		/// <summary>
 		/// Generates pages from a string, and puts them in message content.
 		/// </summary>
 		/// <param name="input">Input string.</param>
 		/// <param name="splittype">How to split input string.</param>
 		/// <returns></returns>
 		public IEnumerable<Page> GeneratePagesInContent(string input, SplitType splittype = SplitType.Character)
 		{
 			if (string.IsNullOrEmpty(input))
 				throw new ArgumentException("You must provide a string that is not null or empty!");
 
 			var result = new List<Page>();
 			List<string> split;
 
 			switch (splittype)
 			{
 				default:
 				case SplitType.Character:
 					split = this.SplitString(input, 500).ToList();
 					break;
 				case SplitType.Line:
 					var subsplit = input.Split('\n');
 
 					split = new List<string>();
 					var s = "";
 
 					for (var i = 0; i < subsplit.Length; i++)
 					{
 						s += subsplit[i];
 						if (i >= 15 && i % 15 == 0)
 						{
 							split.Add(s);
 							s = "";
 						}
 					}
 					if (split.All(x => x != s))
 						split.Add(s);
 					break;
 			}
 
 			var page = 1;
 			foreach (var s in split)
 			{
 				result.Add(new Page($"Page {page}:\n{s}"));
 				page++;
 			}
 
 			return result;
 		}
 
 		/// <summary>
 		/// Generates pages from a string, and puts them in message embeds.
 		/// </summary>
 		/// <param name="input">Input string.</param>
 		/// <param name="splittype">How to split input string.</param>
 		/// <param name="embedbase">Base embed for output embeds.</param>
 		/// <returns></returns>
 		public IEnumerable<Page> GeneratePagesInEmbed(string input, SplitType splittype = SplitType.Character, DiscordEmbedBuilder embedbase = null)
 		{
 			if (string.IsNullOrEmpty(input))
 				throw new ArgumentException("You must provide a string that is not null or empty!");
 
 			var embed = embedbase ?? new DiscordEmbedBuilder();
 
 			var result = new List<Page>();
 			List<string> split;
 
 			switch (splittype)
 			{
 				default:
 				case SplitType.Character:
 					split = this.SplitString(input, 500).ToList();
 					break;
 				case SplitType.Line:
 					var subsplit = input.Split('\n');
 
 					split = new List<string>();
 					var s = "";
 
 					for (var i = 0; i < subsplit.Length; i++)
 					{
 						s += $"{subsplit[i]}\n";
 						if (i % 15 == 0 && i != 0)
 						{
 							split.Add(s);
 							s = "";
 						}
 					}
 					if (!split.Any(x => x == s))
 						split.Add(s);
 					break;
 			}
 
 			var page = 1;
 			foreach (var s in split)
 			{
 				result.Add(new Page("", new DiscordEmbedBuilder(embed).WithDescription(s).WithFooter($"Page {page}/{split.Count}")));
 				page++;
 			}
 
 			return result;
 		}
 
 		/// <summary>
 		/// Splits the string.
 		/// </summary>
 		/// <param name="str">The string.</param>
 		/// <param name="chunkSize">The chunk size.</param>
 		private List<string> SplitString(string str, int chunkSize)
 		{
 			var res = new List<string>();
 			var len = str.Length;
 			var i = 0;
 
 			while (i < len)
 			{
 				var size = Math.Min(len - i, chunkSize);
 				res.Add(str.Substring(i, size));
 				i += size;
 			}
 
 			return res;
 		}
 
 		/// <summary>
 		/// Gets the cancellation token.
 		/// </summary>
 		/// <param name="timeout">The timeout.</param>
 		private CancellationToken GetCancellationToken(TimeSpan? timeout = null) => new CancellationTokenSource(timeout ?? this.Config.Timeout).Token;
 
 		/// <summary>
 		/// Handles an invalid interaction.
 		/// </summary>
 		/// <param name="interaction">The interaction.</param>
 		private async Task HandleInvalidInteraction(DiscordInteraction interaction)
 		{
 			var at = this.Config.ResponseBehavior switch
 			{
 				InteractionResponseBehavior.Ack => interaction.CreateResponseAsync(InteractionResponseType.DeferredMessageUpdate),
-				InteractionResponseBehavior.Respond => interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new() { Content = this.Config.ResponseMessage, IsEphemeral = true}),
+				InteractionResponseBehavior.Respond => interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder { Content = this.Config.ResponseMessage, IsEphemeral = true}),
 				InteractionResponseBehavior.Ignore => Task.CompletedTask,
 				_ => throw new ArgumentException("Unknown enum value.")
 			};
 
 			await at;
 		}
 	}
 }
diff --git a/DisCatSharp.Lavalink/Entities/LavalinkRouteStatus.cs b/DisCatSharp.Lavalink/Entities/LavalinkRouteStatus.cs
index 4a21121dd..4a58b3399 100644
--- a/DisCatSharp.Lavalink/Entities/LavalinkRouteStatus.cs
+++ b/DisCatSharp.Lavalink/Entities/LavalinkRouteStatus.cs
@@ -1,157 +1,155 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Lavalink.Entities
 {
 	/// <summary>
 	/// The lavalink route status.
 	/// </summary>
 	public class LavalinkRouteStatus
 	{
 		/// <summary>
 		/// Gets the route planner type.
 		/// </summary>
 		[JsonIgnore]
 		public LavalinkRoutePlannerType? Class
 			=> this.GetLavalinkRoutePlannerType(this.PlannerTypeClass);
 
 		/// <summary>
 		/// Gets the details of the route planner.
 		/// </summary>
 		[JsonProperty("details", NullValueHandling = NullValueHandling.Ignore)]
 		public LavalinkRouteStatusDetails Details { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets the class.
 		/// </summary>
 		[JsonProperty("class", NullValueHandling = NullValueHandling.Ignore)]
 		internal string PlannerTypeClass { get; set; }
 
 		/// <summary>
 		/// Gets the lavalink route planner type.
 		/// </summary>
 		/// <param name="type">The type.</param>
-		private LavalinkRoutePlannerType? GetLavalinkRoutePlannerType(string type)
-		{
-			return type switch
+		private LavalinkRoutePlannerType? GetLavalinkRoutePlannerType(string type) =>
+			type switch
 			{
 				"RotatingIpRoutePlanner" => LavalinkRoutePlannerType.RotatingIpRoutePlanner,
 				"BalancingIpRoutePlanner" => LavalinkRoutePlannerType.BalancingIpRoutePlanner,
 				"NanoIpRoutePlanner" => LavalinkRoutePlannerType.NanoIpRoutePlanner,
 				"RotatingNanoIpRoutePlanner" => LavalinkRoutePlannerType.RotatingNanoIpRoutePlanner,
 				_ => null,
 			};
-		}
 	}
 
 	/// <summary>
 	/// The lavalink route status details.
 	/// </summary>
 	public class LavalinkRouteStatusDetails
 	{
 		/// <summary>
 		/// Gets the details for the current IP block.
 		/// </summary>
 		[JsonProperty("ipBlock", NullValueHandling = NullValueHandling.Ignore)]
 		public LavalinkIpBlock IpBlock { get; internal set; }
 
 		/// <summary>
 		/// Gets the collection of failed addresses.
 		/// </summary>
 		[JsonProperty("failingAddresses", NullValueHandling = NullValueHandling.Ignore)]
 		public IEnumerable<LavalinkFailedAddress> FailedAddresses { get; internal set; }
 
 		/// <summary>
 		/// Gets the number of rotations since the restart of Lavalink.
 		/// <para>Only present in the <see cref="LavalinkRoutePlannerType.RotatingIpRoutePlanner"/>.</para>
 		/// </summary>
 		[JsonProperty("rotateIndex", NullValueHandling = NullValueHandling.Ignore)]
 		public string RotateIndex { get; internal set; }
 
 		/// <summary>
 		/// Gets the current offset of the IP block.
 		/// <para>Only present in the <see cref="LavalinkRoutePlannerType.RotatingIpRoutePlanner"/>.</para>
 		/// </summary>
 		[JsonProperty("ipIndex", NullValueHandling = NullValueHandling.Ignore)]
 		public string IpIndex { get; internal set; }
 
 		/// <summary>
 		/// Gets the current IP Address used by the planner.
 		/// <para>Only present in the <see cref="LavalinkRoutePlannerType.RotatingIpRoutePlanner"/>.</para>
 		/// </summary>
 		[JsonProperty("currentAddress", NullValueHandling = NullValueHandling.Ignore)]
 		public string CurrentAddress { get; internal set; }
 
 		/// <summary>
 		/// Gets the current offset of the IP block.
 		/// <para>Only present in the <see cref="LavalinkRoutePlannerType.NanoIpRoutePlanner"/> and the <see cref="LavalinkRoutePlannerType.RotatingNanoIpRoutePlanner"/>.</para>
 		/// </summary>
 		[JsonProperty("currentAddressIndex", NullValueHandling = NullValueHandling.Ignore)]
 		public long CurrentAddressIndex { get; internal set; }
 
 		/// <summary>
 		/// Gets the information in which /64 block ips are chosen. This number increases on each ban.
 		/// <para>Only present in the <see cref="LavalinkRoutePlannerType.RotatingNanoIpRoutePlanner"/>.</para>
 		/// </summary>
 		[JsonProperty("blockIndex", NullValueHandling = NullValueHandling.Ignore)]
 		public string BlockIndex { get; internal set; }
 	}
 
 	public struct LavalinkIpBlock
 	{
 		/// <summary>
 		/// Gets the type of the IP block.
 		/// </summary>
 		[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 		public string Type { get; internal set; }
 
 		/// <summary>
 		/// Gets the size of the IP block.
 		/// </summary>
 		[JsonProperty("size", NullValueHandling = NullValueHandling.Ignore)]
 		public string Size { get; internal set; }
 	}
 
 	public struct LavalinkFailedAddress
 	{
 		/// <summary>
 		/// Gets the failed address IP.
 		/// </summary>
 		[JsonProperty("address", NullValueHandling = NullValueHandling.Ignore)]
 		public string Address { get; internal set; }
 
 		/// <summary>
 		/// Gets the failing timestamp in miliseconds.
 		/// </summary>
 		[JsonProperty("failingTimestamp", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong FailingTimestamp { get; internal set; }
 
 		/// <summary>
 		/// Gets the DateTime format of the failing address.
 		/// </summary>
 		[JsonProperty("failingTime", NullValueHandling = NullValueHandling.Ignore)]
 		public string FailingTime { get; internal set; }
 	}
 }
diff --git a/DisCatSharp.Lavalink/LavalinkConfiguration.cs b/DisCatSharp.Lavalink/LavalinkConfiguration.cs
index 48c701965..aa4e2fc6b 100644
--- a/DisCatSharp.Lavalink/LavalinkConfiguration.cs
+++ b/DisCatSharp.Lavalink/LavalinkConfiguration.cs
@@ -1,115 +1,115 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using DisCatSharp.Entities;
 using DisCatSharp.Net;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.Lavalink
 {
 	/// <summary>
 	/// Lavalink connection configuration.
 	/// </summary>
 	public sealed class LavalinkConfiguration
 	{
 		/// <summary>
 		/// Sets the endpoint for Lavalink REST.
 		/// <para>Defaults to 127.0.0.1 on port 2333.</para>
 		/// </summary>
-		public ConnectionEndpoint RestEndpoint { internal get; set; } = new ConnectionEndpoint("127.0.0.1", 2333);
+		public ConnectionEndpoint RestEndpoint { internal get; set; } = new("127.0.0.1", 2333);
 
 		/// <summary>
 		/// Sets the endpoint for the Lavalink Websocket connection.
 		/// <para>Defaults to 127.0.0.1 on port 2333.</para>
 		/// </summary>
-		public ConnectionEndpoint SocketEndpoint { internal get; set; } = new ConnectionEndpoint("127.0.0.1", 2333);
+		public ConnectionEndpoint SocketEndpoint { internal get; set; } = new("127.0.0.1", 2333);
 
 		/// <summary>
 		/// Sets whether the connection wrapper should attempt automatic reconnects should the connection drop.
 		/// <para>Defaults to true.</para>
 		/// </summary>
 		public bool SocketAutoReconnect { internal get; set; } = true;
 
 		/// <summary>
 		/// Sets the password for the Lavalink connection.
 		/// <para>Defaults to "youshallnotpass".</para>
 		/// </summary>
 		public string Password { internal get; set; } = "youshallnotpass";
 
 		/// <summary>
 		/// Sets the resume key for the Lavalink connection.
 		/// <para>This will allow existing voice sessions to continue for a certain time after the client is disconnected.</para>
 		/// </summary>
 		public string ResumeKey { internal get; set; }
 
 		/// <summary>
 		/// Sets the time in seconds when all voice sessions are closed after the client disconnects.
 		/// <para>Defaults to 60 seconds.</para>
 		/// </summary>
 		public int ResumeTimeout { internal get; set; } = 60;
 
 		/// <summary>
 		/// Sets the time in miliseconds to wait for Lavalink's voice WebSocket to close after leaving a voice channel.
 		/// <para>This will be the delay before the guild connection is removed.</para>
 		/// <para>Defaults to 3000 miliseconds.</para>
 		/// </summary>
 		public int WebSocketCloseTimeout { internal get; set; } = 3000;
 
 		/// <summary>
 		/// Sets the voice region ID for the Lavalink connection.
 		/// <para>This should be used if nodes should be filtered by region with <see cref="LavalinkExtension.GetIdealNodeConnection(DiscordVoiceRegion)"/>.</para>
 		/// </summary>
 		public DiscordVoiceRegion Region { internal get; set; }
 
 		/// <summary>
 		/// Creates a new instance of <see cref="LavalinkConfiguration"/>.
 		/// </summary>
 		[ActivatorUtilitiesConstructor]
 		public LavalinkConfiguration() { }
 
 		/// <summary>
 		/// Creates a new instance of <see cref="LavalinkConfiguration"/>, copying the properties of another configuration.
 		/// </summary>
 		/// <param name="other">Configuration the properties of which are to be copied.</param>
 		public LavalinkConfiguration(LavalinkConfiguration other)
 		{
 			this.RestEndpoint = new ConnectionEndpoint
 			{
 				Hostname = other.RestEndpoint.Hostname,
 				Port = other.RestEndpoint.Port,
 				Secured = other.RestEndpoint.Secured
 			};
 			this.SocketEndpoint = new ConnectionEndpoint
 			{
 				Hostname = other.SocketEndpoint.Hostname,
 				Port = other.SocketEndpoint.Port,
 				Secured = other.SocketEndpoint.Secured
 			};
 			this.Password = other.Password;
 			this.ResumeKey = other.ResumeKey;
 			this.ResumeTimeout = other.ResumeTimeout;
 			this.SocketAutoReconnect = other.SocketAutoReconnect;
 			this.Region = other.Region;
 			this.WebSocketCloseTimeout = other.WebSocketCloseTimeout;
 		}
 	}
 }
diff --git a/DisCatSharp.Lavalink/LavalinkEvents.cs b/DisCatSharp.Lavalink/LavalinkEvents.cs
index d34165d7a..b107377da 100644
--- a/DisCatSharp.Lavalink/LavalinkEvents.cs
+++ b/DisCatSharp.Lavalink/LavalinkEvents.cs
@@ -1,77 +1,77 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Lavalink
 {
 	/// <summary>
 	/// Contains well-defined event IDs used by the Lavalink extension.
 	/// </summary>
 	public static class LavalinkEvents
 	{
 		/// <summary>
 		/// Miscellaneous events, that do not fit in any other category.
 		/// </summary>
-		public static EventId Misc { get; } = new EventId(400, "Lavalink");
+		public static EventId Misc { get; } = new(400, "Lavalink");
 
 		/// <summary>
 		/// Events pertaining to Lavalink node connection errors.
 		/// </summary>
-		public static EventId LavalinkConnectionError { get; } = new EventId(401, nameof(LavalinkConnectionError));
+		public static EventId LavalinkConnectionError { get; } = new(401, nameof(LavalinkConnectionError));
 
 		/// <summary>
 		/// Events emitted for clean disconnects from Lavalink.
 		/// </summary>
-		public static EventId LavalinkConnectionClosed { get; } = new EventId(402, nameof(LavalinkConnectionClosed));
+		public static EventId LavalinkConnectionClosed { get; } = new(402, nameof(LavalinkConnectionClosed));
 
 		/// <summary>
 		/// Events emitted for successful connections made to Lavalink.
 		/// </summary>
-		public static EventId LavalinkConnected { get; } = new EventId(403, nameof(LavalinkConnected));
+		public static EventId LavalinkConnected { get; } = new(403, nameof(LavalinkConnected));
 
 		/// <summary>
 		/// Events pertaining to errors that occur when decoding payloads received from Lavalink nodes.
 		/// </summary>
-		public static EventId LavalinkDecodeError { get; } = new EventId(404, nameof(LavalinkDecodeError));
+		public static EventId LavalinkDecodeError { get; } = new(404, nameof(LavalinkDecodeError));
 
 		/// <summary>
 		/// Events emitted when Lavalink's REST API responds with an error.
 		/// </summary>
-		public static EventId LavalinkRestError { get; } = new EventId(405, nameof(LavalinkRestError));
+		public static EventId LavalinkRestError { get; } = new(405, nameof(LavalinkRestError));
 
 		/// <summary>
 		/// Events containing raw payloads, received from Lavalink nodes.
 		/// </summary>
-		public static EventId LavalinkWsRx { get; } = new EventId(406, "Lavalink ↓");
+		public static EventId LavalinkWsRx { get; } = new(406, "Lavalink ↓");
 
 		/// <summary>
 		/// Events containing raw payloads, as they're being sent to Lavalink nodes.
 		/// </summary>
-		public static EventId LavalinkWsTx { get; } = new EventId(407, "Lavalink ↑");
+		public static EventId LavalinkWsTx { get; } = new(407, "Lavalink ↑");
 
 		/// <summary>
 		/// Events pertaining to Gateway Intents. Typically diagnostic information.
 		/// </summary>
-		public static EventId Intents { get; } = new EventId(408, nameof(Intents));
+		public static EventId Intents { get; } = new(408, nameof(Intents));
 	}
 }
diff --git a/DisCatSharp.Lavalink/LavalinkExtension.cs b/DisCatSharp.Lavalink/LavalinkExtension.cs
index 658ffd766..993613ed4 100644
--- a/DisCatSharp.Lavalink/LavalinkExtension.cs
+++ b/DisCatSharp.Lavalink/LavalinkExtension.cs
@@ -1,215 +1,215 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Lavalink.EventArgs;
 using DisCatSharp.Net;
 
 namespace DisCatSharp.Lavalink
 {
 	/// <summary>
 	/// The lavalink extension.
 	/// </summary>
 	public sealed class LavalinkExtension : BaseExtension
 	{
 		/// <summary>
 		/// Triggered whenever a node disconnects.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkNodeConnection, NodeDisconnectedEventArgs> NodeDisconnected
 		{
-			add { this._nodeDisconnected.Register(value); }
-			remove { this._nodeDisconnected.Unregister(value); }
+			add => this._nodeDisconnected.Register(value);
+			remove => this._nodeDisconnected.Unregister(value);
 		}
 		private AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs> _nodeDisconnected;
 
 		/// <summary>
 		/// Gets a dictionary of connected Lavalink nodes for the extension.
 		/// </summary>
 		public IReadOnlyDictionary<ConnectionEndpoint, LavalinkNodeConnection> ConnectedNodes { get; }
 		private readonly ConcurrentDictionary<ConnectionEndpoint, LavalinkNodeConnection> _connectedNodes = new();
 
 		/// <summary>
 		/// Creates a new instance of this Lavalink extension.
 		/// </summary>
 		internal LavalinkExtension()
 		{
 			this.ConnectedNodes = new ReadOnlyConcurrentDictionary<ConnectionEndpoint, LavalinkNodeConnection>(this._connectedNodes);
 		}
 
 		/// <summary>
 		/// DO NOT USE THIS MANUALLY.
 		/// </summary>
 		/// <param name="client">DO NOT USE THIS MANUALLY.</param>
 		/// <exception cref="System.InvalidOperationException"/>
 		protected internal override void Setup(DiscordClient client)
 		{
 			if (this.Client != null)
 				throw new InvalidOperationException("What did I tell you?");
 
 			this.Client = client;
 
 			this._nodeDisconnected = new AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs>("LAVALINK_NODE_DISCONNECTED", TimeSpan.Zero, this.Client.EventErrorHandler);
 		}
 
 		/// <summary>
 		/// Connect to a Lavalink node.
 		/// </summary>
 		/// <param name="config">Lavalink client configuration.</param>
 		/// <returns>The established Lavalink connection.</returns>
 		public async Task<LavalinkNodeConnection> ConnectAsync(LavalinkConfiguration config)
 		{
 			if (this._connectedNodes.ContainsKey(config.SocketEndpoint))
 				return this._connectedNodes[config.SocketEndpoint];
 
 			var con = new LavalinkNodeConnection(this.Client, this, config);
 			con.NodeDisconnected += this.Con_NodeDisconnected;
 			con.Disconnected += this.Con_Disconnected;
 			this._connectedNodes[con.NodeEndpoint] = con;
 			try
 			{
 				await con.StartAsync().ConfigureAwait(false);
 			}
 			catch
 			{
 				this.Con_NodeDisconnected(con);
 				throw;
 			}
 
 			return con;
 		}
 
 		/// <summary>
 		/// Gets the Lavalink node connection for the specified endpoint.
 		/// </summary>
 		/// <param name="endpoint">Endpoint at which the node resides.</param>
 		/// <returns>Lavalink node connection.</returns>
 		public LavalinkNodeConnection GetNodeConnection(ConnectionEndpoint endpoint)
 			=> this._connectedNodes.ContainsKey(endpoint) ? this._connectedNodes[endpoint] : null;
 
 		/// <summary>
 		/// Gets a Lavalink node connection based on load balancing and an optional voice region.
 		/// </summary>
 		/// <param name="region">The region to compare with the node's <see cref="LavalinkConfiguration.Region"/>, if any.</param>
 		/// <returns>The least load affected node connection, or null if no nodes are present.</returns>
 		public LavalinkNodeConnection GetIdealNodeConnection(DiscordVoiceRegion region = null)
 		{
 			if (this._connectedNodes.Count <= 1)
 				return this._connectedNodes.Values.FirstOrDefault();
 
 			var nodes = this._connectedNodes.Values.ToArray();
 
 			if (region != null)
 			{
 				var regionPredicate = new Func<LavalinkNodeConnection, bool>(x => x.Region == region);
 
 				if (nodes.Any(regionPredicate))
 					nodes = nodes.Where(regionPredicate).ToArray();
 
 				if (nodes.Count() <= 1)
 					return nodes.FirstOrDefault();
 			}
 
 			return this.FilterByLoad(nodes);
 		}
 
 		/// <summary>
 		/// Gets a Lavalink guild connection from a <see cref="DisCatSharp.Entities.DiscordGuild"/>.
 		/// </summary>
 		/// <param name="guild">The guild the connection is on.</param>
 		/// <returns>The found guild connection, or null if one could not be found.</returns>
 		public LavalinkGuildConnection GetGuildConnection(DiscordGuild guild)
 		{
 			var nodes = this._connectedNodes.Values;
 			var node = nodes.FirstOrDefault(x => x.ConnectedGuildsInternal.ContainsKey(guild.Id));
 			return node?.GetGuildConnection(guild);
 		}
 
 		/// <summary>
 		/// Filters the by load.
 		/// </summary>
 		/// <param name="nodes">The nodes.</param>
 		private LavalinkNodeConnection FilterByLoad(LavalinkNodeConnection[] nodes)
 		{
 			Array.Sort(nodes, (a, b) =>
 			{
 				if (!a.Statistics.Updated || !b.Statistics.Updated)
 					return 0;
 
 				//https://github.com/FredBoat/Lavalink-Client/blob/48bc27784f57be5b95d2ff2eff6665451b9366f5/src/main/java/lavalink/client/io/LavalinkLoadBalancer.java#L122
 				//https://github.com/briantanner/eris-lavalink/blob/master/src/PlayerManager.js#L329
 
 				//player count
 				var aPenaltyCount = a.Statistics.ActivePlayers;
 				var bPenaltyCount = b.Statistics.ActivePlayers;
 
 				//cpu load
 				aPenaltyCount += (int)Math.Pow(1.05d, (100 * (a.Statistics.CpuSystemLoad / a.Statistics.CpuCoreCount) * 10) - 10);
 				bPenaltyCount += (int)Math.Pow(1.05d, (100 * (b.Statistics.CpuSystemLoad / a.Statistics.CpuCoreCount) * 10) - 10);
 
 				//frame load
 				if (a.Statistics.AverageDeficitFramesPerMinute > 0)
 				{
 					//deficit frame load
 					aPenaltyCount += (int)((Math.Pow(1.03d, 500f * (a.Statistics.AverageDeficitFramesPerMinute / 3000f)) * 600) - 600);
 
 					//null frame load
 					aPenaltyCount += (int)((Math.Pow(1.03d, 500f * (a.Statistics.AverageNulledFramesPerMinute / 3000f)) * 300) - 300);
 				}
 
 				//frame load
 				if (b.Statistics.AverageDeficitFramesPerMinute > 0)
 				{
 					//deficit frame load
 					bPenaltyCount += (int)((Math.Pow(1.03d, 500f * (b.Statistics.AverageDeficitFramesPerMinute / 3000f)) * 600) - 600);
 
 					//null frame load
 					bPenaltyCount += (int)((Math.Pow(1.03d, 500f * (b.Statistics.AverageNulledFramesPerMinute / 3000f)) * 300) - 300);
 				}
 
 				return aPenaltyCount - bPenaltyCount;
 			});
 
 			return nodes[0];
 		}
 
 		/// <summary>
 		/// Removes a node.
 		/// </summary>
 		/// <param name="node">The node to be removed.</param>
 		private void Con_NodeDisconnected(LavalinkNodeConnection node)
 			=> this._connectedNodes.TryRemove(node.NodeEndpoint, out _);
 
 		/// <summary>
 		/// Disconnects a node.
 		/// </summary>
 		/// <param name="node">The affected node.</param>
 		/// <param name="e">The node disconnected event args.</param>
 		private Task Con_Disconnected(LavalinkNodeConnection node, NodeDisconnectedEventArgs e)
 			=> this._nodeDisconnected.InvokeAsync(node, e);
 	}
 }
diff --git a/DisCatSharp.Lavalink/LavalinkGuildConnection.cs b/DisCatSharp.Lavalink/LavalinkGuildConnection.cs
index 8066e3921..e38a72e48 100644
--- a/DisCatSharp.Lavalink/LavalinkGuildConnection.cs
+++ b/DisCatSharp.Lavalink/LavalinkGuildConnection.cs
@@ -1,439 +1,439 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Lavalink.Entities;
 using DisCatSharp.Lavalink.EventArgs;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Lavalink
 {
 	internal delegate void ChannelDisconnectedEventHandler(LavalinkGuildConnection node);
 
 	/// <summary>
 	/// Represents a Lavalink connection to a channel.
 	/// </summary>
 	public sealed class LavalinkGuildConnection
 	{
 		/// <summary>
 		/// Triggered whenever Lavalink updates player status.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, PlayerUpdateEventArgs> PlayerUpdated
 		{
-			add { this._playerUpdated.Register(value); }
-			remove { this._playerUpdated.Unregister(value); }
+			add => this._playerUpdated.Register(value);
+			remove => this._playerUpdated.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, PlayerUpdateEventArgs> _playerUpdated;
 
 		/// <summary>
 		/// Triggered whenever playback of a track starts.
 		/// <para>This is only available for version 3.3.1 and greater.</para>
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, TrackStartEventArgs> PlaybackStarted
 		{
-			add { this._playbackStarted.Register(value); }
-			remove { this._playbackStarted.Unregister(value); }
+			add => this._playbackStarted.Register(value);
+			remove => this._playbackStarted.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, TrackStartEventArgs> _playbackStarted;
 
 		/// <summary>
 		/// Triggered whenever playback of a track finishes.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, TrackFinishEventArgs> PlaybackFinished
 		{
-			add { this._playbackFinished.Register(value); }
-			remove { this._playbackFinished.Unregister(value); }
+			add => this._playbackFinished.Register(value);
+			remove => this._playbackFinished.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, TrackFinishEventArgs> _playbackFinished;
 
 		/// <summary>
 		/// Triggered whenever playback of a track gets stuck.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, TrackStuckEventArgs> TrackStuck
 		{
-			add { this._trackStuck.Register(value); }
-			remove { this._trackStuck.Unregister(value); }
+			add => this._trackStuck.Register(value);
+			remove => this._trackStuck.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, TrackStuckEventArgs> _trackStuck;
 
 		/// <summary>
 		/// Triggered whenever playback of a track encounters an error.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, TrackExceptionEventArgs> TrackException
 		{
-			add { this._trackException.Register(value); }
-			remove { this._trackException.Unregister(value); }
+			add => this._trackException.Register(value);
+			remove => this._trackException.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, TrackExceptionEventArgs> _trackException;
 
 		/// <summary>
 		/// Triggered whenever Discord Voice WebSocket connection is terminated.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, WebSocketCloseEventArgs> DiscordWebSocketClosed
 		{
-			add { this._webSocketClosed.Register(value); }
-			remove { this._webSocketClosed.Unregister(value); }
+			add => this._webSocketClosed.Register(value);
+			remove => this._webSocketClosed.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, WebSocketCloseEventArgs> _webSocketClosed;
 
 		/// <summary>
 		/// Gets whether this channel is still connected.
 		/// </summary>
 		public bool IsConnected => !Volatile.Read(ref this._isDisposed) && this.Channel != null;
-		private bool _isDisposed = false;
+		private bool _isDisposed;
 
 		/// <summary>
 		/// Gets the current player state.
 		/// </summary>
 		public LavalinkPlayerState CurrentState { get; }
 
 		/// <summary>
 		/// Gets the voice channel associated with this connection.
 		/// </summary>
 		public DiscordChannel Channel => this.VoiceStateUpdate.Channel;
 
 		/// <summary>
 		/// Gets the guild associated with this connection.
 		/// </summary>
 		public DiscordGuild Guild => this.Channel.Guild;
 
 		/// <summary>
 		/// Gets the Lavalink node associated with this connection.
 		/// </summary>
 		public LavalinkNodeConnection Node { get; }
 
 		/// <summary>
 		/// Gets the guild id string.
 		/// </summary>
 		internal string GuildIdString => this.GuildId.ToString(CultureInfo.InvariantCulture);
 		/// <summary>
 		/// Gets the guild id.
 		/// </summary>
 		internal ulong GuildId => this.Channel.Guild.Id;
 		/// <summary>
 		/// Gets or sets the voice state update.
 		/// </summary>
 		internal VoiceStateUpdateEventArgs VoiceStateUpdate { get; set; }
 		/// <summary>
 		/// Gets or sets the voice ws disconnect tcs.
 		/// </summary>
 		internal TaskCompletionSource<bool> VoiceWsDisconnectTcs { get; set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="LavalinkGuildConnection"/> class.
 		/// </summary>
 		/// <param name="node">The node.</param>
 		/// <param name="channel">The channel.</param>
 		/// <param name="vstu">The vstu.</param>
 		internal LavalinkGuildConnection(LavalinkNodeConnection node, DiscordChannel channel, VoiceStateUpdateEventArgs vstu)
 		{
 			this.Node = node;
 			this.VoiceStateUpdate = vstu;
 			this.CurrentState = new LavalinkPlayerState();
 			this.VoiceWsDisconnectTcs = new TaskCompletionSource<bool>();
 
 			Volatile.Write(ref this._isDisposed, false);
 
 			this._playerUpdated = new AsyncEvent<LavalinkGuildConnection, PlayerUpdateEventArgs>("LAVALINK_PLAYER_UPDATE", TimeSpan.Zero, this.Node.Discord.EventErrorHandler);
 			this._playbackStarted = new AsyncEvent<LavalinkGuildConnection, TrackStartEventArgs>("LAVALINK_PLAYBACK_STARTED", TimeSpan.Zero, this.Node.Discord.EventErrorHandler);
 			this._playbackFinished = new AsyncEvent<LavalinkGuildConnection, TrackFinishEventArgs>("LAVALINK_PLAYBACK_FINISHED", TimeSpan.Zero, this.Node.Discord.EventErrorHandler);
 			this._trackStuck = new AsyncEvent<LavalinkGuildConnection, TrackStuckEventArgs>("LAVALINK_TRACK_STUCK", TimeSpan.Zero, this.Node.Discord.EventErrorHandler);
 			this._trackException = new AsyncEvent<LavalinkGuildConnection, TrackExceptionEventArgs>("LAVALINK_TRACK_EXCEPTION", TimeSpan.Zero, this.Node.Discord.EventErrorHandler);
 			this._webSocketClosed = new AsyncEvent<LavalinkGuildConnection, WebSocketCloseEventArgs>("LAVALINK_DISCORD_WEBSOCKET_CLOSED", TimeSpan.Zero, this.Node.Discord.EventErrorHandler);
 		}
 
 		/// <summary>
 		/// Disconnects the connection from the voice channel.
 		/// </summary>
 		/// <param name="shouldDestroy">Whether the connection should be destroyed on the Lavalink server when leaving.</param>
 
 		public Task DisconnectAsync(bool shouldDestroy = true)
 			=> this.DisconnectInternalAsync(shouldDestroy);
 
 		/// <summary>
 		/// Disconnects the internal async.
 		/// </summary>
 		/// <param name="shouldDestroy">If true, should destroy.</param>
 		/// <param name="isManualDisconnection">If true, is manual disconnection.</param>
 
 		internal async Task DisconnectInternalAsync(bool shouldDestroy, bool isManualDisconnection = false)
 		{
 			if (!this.IsConnected && !isManualDisconnection)
 				throw new InvalidOperationException("This connection is not valid.");
 
 			Volatile.Write(ref this._isDisposed, true);
 
 			if (shouldDestroy)
 				await this.Node.SendPayloadAsync(new LavalinkDestroy(this)).ConfigureAwait(false);
 
 			if (!isManualDisconnection)
 			{
 				await this.SendVoiceUpdateAsync().ConfigureAwait(false);
 				this.ChannelDisconnected?.Invoke(this);
 			}
 		}
 
 		/// <summary>
 		/// Sends the voice update async.
 		/// </summary>
 
 		internal async Task SendVoiceUpdateAsync()
 		{
 			var vsd = new VoiceDispatch
 			{
 				OpCode = 4,
 				Payload = new VoiceStateUpdatePayload
 				{
 					GuildId = this.GuildId,
 					ChannelId = null,
 					Deafened = false,
 					Muted = false
 				}
 			};
 			var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
 			await (this.Channel.Discord as DiscordClient).WsSendAsync(vsj).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Searches for specified terms.
 		/// </summary>
 		/// <param name="searchQuery">What to search for.</param>
 		/// <param name="type">What platform will search for.</param>
 		/// <returns>A collection of tracks matching the criteria.</returns>
 		public Task<LavalinkLoadResult> GetTracksAsync(string searchQuery, LavalinkSearchType type = LavalinkSearchType.Youtube)
 			=> this.Node.Rest.GetTracksAsync(searchQuery, type);
 
 		/// <summary>
 		/// Loads tracks from specified URL.
 		/// </summary>
 		/// <param name="uri">URL to load tracks from.</param>
 		/// <returns>A collection of tracks from the URL.</returns>
 		public Task<LavalinkLoadResult> GetTracksAsync(Uri uri)
 			=> this.Node.Rest.GetTracksAsync(uri);
 
 		/// <summary>
 		/// Loads tracks from a local file.
 		/// </summary>
 		/// <param name="file">File to load tracks from.</param>
 		/// <returns>A collection of tracks from the file.</returns>
 		public Task<LavalinkLoadResult> GetTracksAsync(FileInfo file)
 			=> this.Node.Rest.GetTracksAsync(file);
 
 		/// <summary>
 		/// Queues the specified track for playback.
 		/// </summary>
 		/// <param name="track">Track to play.</param>
 		public async Task PlayAsync(LavalinkTrack track)
 		{
 			if (!this.IsConnected)
 				throw new InvalidOperationException("This connection is not valid.");
 
 			this.CurrentState.CurrentTrack = track;
 			await this.Node.SendPayloadAsync(new LavalinkPlay(this, track)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Queues the specified track for playback. The track will be played from specified start timestamp to specified end timestamp.
 		/// </summary>
 		/// <param name="track">Track to play.</param>
 		/// <param name="start">Timestamp to start playback at.</param>
 		/// <param name="end">Timestamp to stop playback at.</param>
 		public async Task PlayPartialAsync(LavalinkTrack track, TimeSpan start, TimeSpan end)
 		{
 			if (!this.IsConnected)
 				throw new InvalidOperationException("This connection is not valid.");
 
 			if (start.TotalMilliseconds < 0 || end <= start)
 				throw new ArgumentException("Both start and end timestamps need to be greater or equal to zero, and the end timestamp needs to be greater than start timestamp.");
 
 			this.CurrentState.CurrentTrack = track;
 			await this.Node.SendPayloadAsync(new LavalinkPlayPartial(this, track, start, end)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Stops the player completely.
 		/// </summary>
 		public async Task StopAsync()
 		{
 			if (!this.IsConnected)
 				throw new InvalidOperationException("This connection is not valid.");
 
 			await this.Node.SendPayloadAsync(new LavalinkStop(this)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Pauses the player.
 		/// </summary>
 		public async Task PauseAsync()
 		{
 			if (!this.IsConnected)
 				throw new InvalidOperationException("This connection is not valid.");
 
 			await this.Node.SendPayloadAsync(new LavalinkPause(this, true)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Resumes playback.
 		/// </summary>
 		public async Task ResumeAsync()
 		{
 			if (!this.IsConnected)
 				throw new InvalidOperationException("This connection is not valid.");
 
 			await this.Node.SendPayloadAsync(new LavalinkPause(this, false)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Seeks the current track to specified position.
 		/// </summary>
 		/// <param name="position">Position to seek to.</param>
 		public async Task SeekAsync(TimeSpan position)
 		{
 			if (!this.IsConnected)
 				throw new InvalidOperationException("This connection is not valid.");
 
 			await this.Node.SendPayloadAsync(new LavalinkSeek(this, position)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Sets the playback volume. This might incur a lot of CPU usage.
 		/// </summary>
 		/// <param name="volume">Volume to set. Needs to be greater or equal to 0, and less than or equal to 100. 100 means 100% and is the default value.</param>
 		public async Task SetVolumeAsync(int volume)
 		{
 			if (!this.IsConnected)
 				throw new InvalidOperationException("This connection is not valid.");
 
 			if (volume < 0 || volume > 1000)
 				throw new ArgumentOutOfRangeException(nameof(volume), "Volume needs to range from 0 to 1000.");
 
 			await this.Node.SendPayloadAsync(new LavalinkVolume(this, volume)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Adjusts the specified bands in the audio equalizer. This will alter the sound output, and might incur a lot of CPU usage.
 		/// </summary>
 		/// <param name="bands">Bands adjustments to make. You must specify one adjustment per band at most.</param>
 		public async Task AdjustEqualizerAsync(params LavalinkBandAdjustment[] bands)
 		{
 			if (!this.IsConnected)
 				throw new InvalidOperationException("This connection is not valid.");
 
 			if (bands?.Any() != true)
 				return;
 
 			if (bands.Distinct(new LavalinkBandAdjustmentComparer()).Count() != bands.Count())
 				throw new InvalidOperationException("You cannot specify multiple modifiers for the same band.");
 
 			await this.Node.SendPayloadAsync(new LavalinkEqualizer(this, bands)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Resets the audio equalizer to default values.
 		/// </summary>
 		public async Task ResetEqualizerAsync()
 		{
 			if (!this.IsConnected)
 				throw new InvalidOperationException("This connection is not valid.");
 
 			await this.Node.SendPayloadAsync(new LavalinkEqualizer(this, Enumerable.Range(0, 15).Select(x => new LavalinkBandAdjustment(x, 0)))).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Internals the update player state async.
 		/// </summary>
 		/// <param name="newState">The new state.</param>
 
 		internal Task InternalUpdatePlayerStateAsync(LavalinkState newState)
 		{
 			this.CurrentState.LastUpdate = newState.Time;
 			this.CurrentState.PlaybackPosition = newState.Position;
 
 			return this._playerUpdated.InvokeAsync(this, new PlayerUpdateEventArgs(this, newState.Time, newState.Position));
 		}
 
 		/// <summary>
 		/// Internals the playback started async.
 		/// </summary>
 		/// <param name="track">The track.</param>
 
 		internal Task InternalPlaybackStartedAsync(string track)
 		{
 			var ea = new TrackStartEventArgs(this, LavalinkUtilities.DecodeTrack(track));
 			return this._playbackStarted.InvokeAsync(this, ea);
 		}
 
 		/// <summary>
 		/// Internals the playback finished async.
 		/// </summary>
 		/// <param name="e">The e.</param>
 
 		internal Task InternalPlaybackFinishedAsync(TrackFinishData e)
 		{
 			if (e.Reason != TrackEndReason.Replaced)
 				this.CurrentState.CurrentTrack = default;
 
 			var ea = new TrackFinishEventArgs(this, LavalinkUtilities.DecodeTrack(e.Track), e.Reason);
 			return this._playbackFinished.InvokeAsync(this, ea);
 		}
 
 		/// <summary>
 		/// Internals the track stuck async.
 		/// </summary>
 		/// <param name="e">The e.</param>
 
 		internal Task InternalTrackStuckAsync(TrackStuckData e)
 		{
 			var ea = new TrackStuckEventArgs(this, e.Threshold, LavalinkUtilities.DecodeTrack(e.Track));
 			return this._trackStuck.InvokeAsync(this, ea);
 		}
 
 		/// <summary>
 		/// Internals the track exception async.
 		/// </summary>
 		/// <param name="e">The e.</param>
 
 		internal Task InternalTrackExceptionAsync(TrackExceptionData e)
 		{
 			var ea = new TrackExceptionEventArgs(this, e.Error, LavalinkUtilities.DecodeTrack(e.Track));
 			return this._trackException.InvokeAsync(this, ea);
 		}
 
 		/// <summary>
 		/// Internals the web socket closed async.
 		/// </summary>
 		/// <param name="e">The e.</param>
 
 		internal Task InternalWebSocketClosedAsync(WebSocketCloseEventArgs e)
 			=> this._webSocketClosed.InvokeAsync(this, e);
 
 		internal event ChannelDisconnectedEventHandler ChannelDisconnected;
 	}
 }
diff --git a/DisCatSharp.Lavalink/LavalinkNodeConnection.cs b/DisCatSharp.Lavalink/LavalinkNodeConnection.cs
index fd18e688d..f704d7db5 100644
--- a/DisCatSharp.Lavalink/LavalinkNodeConnection.cs
+++ b/DisCatSharp.Lavalink/LavalinkNodeConnection.cs
@@ -1,606 +1,606 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Lavalink.Entities;
 using DisCatSharp.Lavalink.EventArgs;
 using DisCatSharp.Net;
 using DisCatSharp.Net.WebSocket;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Lavalink
 {
 	internal delegate void NodeDisconnectedEventHandler(LavalinkNodeConnection node);
 
 	/// <summary>
 	/// Represents a connection to a Lavalink node.
 	/// </summary>
 	public sealed class LavalinkNodeConnection
 	{
 		/// <summary>
 		/// Triggered whenever Lavalink WebSocket throws an exception.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkNodeConnection, SocketErrorEventArgs> LavalinkSocketErrored
 		{
-			add { this._lavalinkSocketError.Register(value); }
-			remove { this._lavalinkSocketError.Unregister(value); }
+			add => this._lavalinkSocketError.Register(value);
+			remove => this._lavalinkSocketError.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkNodeConnection, SocketErrorEventArgs> _lavalinkSocketError;
 
 		/// <summary>
 		/// Triggered when this node disconnects.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkNodeConnection, NodeDisconnectedEventArgs> Disconnected
 		{
-			add { this._disconnected.Register(value); }
-			remove { this._disconnected.Unregister(value); }
+			add => this._disconnected.Register(value);
+			remove => this._disconnected.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs> _disconnected;
 
 		/// <summary>
 		/// Triggered when this node receives a statistics update.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkNodeConnection, StatisticsReceivedEventArgs> StatisticsReceived
 		{
-			add { this._statsReceived.Register(value); }
-			remove { this._statsReceived.Unregister(value); }
+			add => this._statsReceived.Register(value);
+			remove => this._statsReceived.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkNodeConnection, StatisticsReceivedEventArgs> _statsReceived;
 
 		/// <summary>
 		/// Triggered whenever any of the players on this node is updated.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, PlayerUpdateEventArgs> PlayerUpdated
 		{
-			add { this._playerUpdated.Register(value); }
-			remove { this._playerUpdated.Unregister(value); }
+			add => this._playerUpdated.Register(value);
+			remove => this._playerUpdated.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, PlayerUpdateEventArgs> _playerUpdated;
 
 		/// <summary>
 		/// Triggered whenever playback of a track starts.
 		/// <para>This is only available for version 3.3.1 and greater.</para>
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, TrackStartEventArgs> PlaybackStarted
 		{
-			add { this._playbackStarted.Register(value); }
-			remove { this._playbackStarted.Unregister(value); }
+			add => this._playbackStarted.Register(value);
+			remove => this._playbackStarted.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, TrackStartEventArgs> _playbackStarted;
 
 		/// <summary>
 		/// Triggered whenever playback of a track finishes.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, TrackFinishEventArgs> PlaybackFinished
 		{
-			add { this._playbackFinished.Register(value); }
-			remove { this._playbackFinished.Unregister(value); }
+			add => this._playbackFinished.Register(value);
+			remove => this._playbackFinished.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, TrackFinishEventArgs> _playbackFinished;
 
 		/// <summary>
 		/// Triggered whenever playback of a track gets stuck.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, TrackStuckEventArgs> TrackStuck
 		{
-			add { this._trackStuck.Register(value); }
-			remove { this._trackStuck.Unregister(value); }
+			add => this._trackStuck.Register(value);
+			remove => this._trackStuck.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, TrackStuckEventArgs> _trackStuck;
 
 		/// <summary>
 		/// Triggered whenever playback of a track encounters an error.
 		/// </summary>
 		public event AsyncEventHandler<LavalinkGuildConnection, TrackExceptionEventArgs> TrackException
 		{
-			add { this._trackException.Register(value); }
-			remove { this._trackException.Unregister(value); }
+			add => this._trackException.Register(value);
+			remove => this._trackException.Unregister(value);
 		}
 		private readonly AsyncEvent<LavalinkGuildConnection, TrackExceptionEventArgs> _trackException;
 
 		/// <summary>
 		/// Gets the remote endpoint of this Lavalink node connection.
 		/// </summary>
 		public ConnectionEndpoint NodeEndpoint => this.Configuration.SocketEndpoint;
 
 		/// <summary>
 		/// Gets whether the client is connected to Lavalink.
 		/// </summary>
 		public bool IsConnected => !Volatile.Read(ref this._isDisposed);
-		private bool _isDisposed = false;
-		private int _backoff = 0;
+		private bool _isDisposed;
+		private int _backoff;
 		/// <summary>
 		/// The minimum backoff.
 		/// </summary>
 		private const int MINIMUM_BACKOFF = 7500;
 		/// <summary>
 		/// The maximum backoff.
 		/// </summary>
 		private const int MAXIMUM_BACKOFF = 120000;
 
 		/// <summary>
 		/// Gets the current resource usage statistics.
 		/// </summary>
 		public LavalinkStatistics Statistics { get; }
 
 		/// <summary>
 		/// Gets a dictionary of Lavalink guild connections for this node.
 		/// </summary>
 		public IReadOnlyDictionary<ulong, LavalinkGuildConnection> ConnectedGuilds { get; }
 		internal ConcurrentDictionary<ulong, LavalinkGuildConnection> ConnectedGuildsInternal = new();
 
 		/// <summary>
 		/// Gets the REST client for this Lavalink connection.
 		/// </summary>
 		public LavalinkRestClient Rest { get; }
 
 		/// <summary>
 		/// Gets the parent extension which this node connection belongs to.
 		/// </summary>
 		public LavalinkExtension Parent { get; }
 
 		/// <summary>
 		/// Gets the Discord client this node connection belongs to.
 		/// </summary>
 		public DiscordClient Discord { get; }
 
 		/// <summary>
 		/// Gets the configuration.
 		/// </summary>
 		internal LavalinkConfiguration Configuration { get; }
 		/// <summary>
 		/// Gets the region.
 		/// </summary>
 		internal DiscordVoiceRegion Region { get; }
 
 		/// <summary>
 		/// Gets or sets the web socket.
 		/// </summary>
 		private IWebSocketClient _webSocket;
 
 		/// <summary>
 		/// Gets the voice state updates.
 		/// </summary>
 		private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>> _voiceStateUpdates;
 
 		/// <summary>
 		/// Gets the voice server updates.
 		/// </summary>
 		private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>> _voiceServerUpdates;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="LavalinkNodeConnection"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="extension">the event.tension.</param>
 		/// <param name="config">The config.</param>
 		internal LavalinkNodeConnection(DiscordClient client, LavalinkExtension extension, LavalinkConfiguration config)
 		{
 			this.Discord = client;
 			this.Parent = extension;
 			this.Configuration = new LavalinkConfiguration(config);
 
 			if (config.Region != null && this.Discord.VoiceRegions.Values.Contains(config.Region))
 				this.Region = config.Region;
 
 			this.ConnectedGuilds = new ReadOnlyConcurrentDictionary<ulong, LavalinkGuildConnection>(this.ConnectedGuildsInternal);
 			this.Statistics = new LavalinkStatistics();
 
 			this._lavalinkSocketError = new AsyncEvent<LavalinkNodeConnection, SocketErrorEventArgs>("LAVALINK_SOCKET_ERROR", TimeSpan.Zero, this.Discord.EventErrorHandler);
 			this._disconnected = new AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs>("LAVALINK_NODE_DISCONNECTED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 			this._statsReceived = new AsyncEvent<LavalinkNodeConnection, StatisticsReceivedEventArgs>("LAVALINK_STATS_RECEIVED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 			this._playerUpdated = new AsyncEvent<LavalinkGuildConnection, PlayerUpdateEventArgs>("LAVALINK_PLAYER_UPDATED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 			this._playbackStarted = new AsyncEvent<LavalinkGuildConnection, TrackStartEventArgs>("LAVALINK_PLAYBACK_STARTED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 			this._playbackFinished = new AsyncEvent<LavalinkGuildConnection, TrackFinishEventArgs>("LAVALINK_PLAYBACK_FINISHED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 			this._trackStuck = new AsyncEvent<LavalinkGuildConnection, TrackStuckEventArgs>("LAVALINK_TRACK_STUCK", TimeSpan.Zero, this.Discord.EventErrorHandler);
 			this._trackException = new AsyncEvent<LavalinkGuildConnection, TrackExceptionEventArgs>("LAVALINK_TRACK_EXCEPTION", TimeSpan.Zero, this.Discord.EventErrorHandler);
 
 			this._voiceServerUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>>();
 			this._voiceStateUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>>();
 			this.Discord.VoiceStateUpdated += this.Discord_VoiceStateUpdated;
 			this.Discord.VoiceServerUpdated += this.Discord_VoiceServerUpdated;
 
 			this.Rest = new LavalinkRestClient(this.Configuration, this.Discord);
 
 			Volatile.Write(ref this._isDisposed, false);
 		}
 
 		/// <summary>
 		/// Establishes a connection to the Lavalink node.
 		/// </summary>
 		/// <returns></returns>
 		internal async Task StartAsync()
 		{
 			if (this.Discord?.CurrentUser?.Id == null || this.Discord?.ShardCount == null)
 				throw new InvalidOperationException("This operation requires the Discord client to be fully initialized.");
 
 			this._webSocket = this.Discord.Configuration.WebSocketClientFactory(this.Discord.Configuration.Proxy, this.Discord.ServiceProvider);
 			this._webSocket.Connected += this.WebSocket_OnConnect;
 			this._webSocket.Disconnected += this.WebSocket_OnDisconnect;
 			this._webSocket.ExceptionThrown += this.WebSocket_OnException;
 			this._webSocket.MessageReceived += this.WebSocket_OnMessage;
 
 			this._webSocket.AddDefaultHeader("Authorization", this.Configuration.Password);
 			this._webSocket.AddDefaultHeader("Num-Shards", this.Discord.ShardCount.ToString(CultureInfo.InvariantCulture));
 			this._webSocket.AddDefaultHeader("User-Id", this.Discord.CurrentUser.Id.ToString(CultureInfo.InvariantCulture));
 			if (this.Configuration.ResumeKey != null)
 				this._webSocket.AddDefaultHeader("Resume-Key", this.Configuration.ResumeKey);
 
 			do
 			{
 				try
 				{
 					if (this._backoff != 0)
 					{
 						await Task.Delay(this._backoff).ConfigureAwait(false);
 						this._backoff = Math.Min(this._backoff * 2, MAXIMUM_BACKOFF);
 					}
 					else
 					{
 						this._backoff = MINIMUM_BACKOFF;
 					}
 
 					await this._webSocket.ConnectAsync(new Uri(this.Configuration.SocketEndpoint.ToWebSocketString())).ConfigureAwait(false);
 					break;
 				}
 				catch (PlatformNotSupportedException)
 				{ throw; }
 				catch (NotImplementedException)
 				{ throw; }
 				catch (Exception ex)
 				{
 					if (!this.Configuration.SocketAutoReconnect || this._backoff == MAXIMUM_BACKOFF)
 					{
 						this.Discord.Logger.LogCritical(LavalinkEvents.LavalinkConnectionError, ex, "Failed to connect to Lavalink.");
 						throw ex;
 					}
 					else
 					{
 						this.Discord.Logger.LogCritical(LavalinkEvents.LavalinkConnectionError, ex, $"Failed to connect to Lavalink, retrying in {this._backoff} ms.");
 					}
 				}
 			}
 			while (this.Configuration.SocketAutoReconnect);
 
 			Volatile.Write(ref this._isDisposed, false);
 		}
 
 		/// <summary>
 		/// Stops this Lavalink node connection and frees resources.
 		/// </summary>
 		/// <returns></returns>
 		public async Task StopAsync()
 		{
 			foreach (var kvp in this.ConnectedGuildsInternal)
 				await kvp.Value.DisconnectAsync().ConfigureAwait(false);
 
 			this.NodeDisconnected?.Invoke(this);
 
 			Volatile.Write(ref this._isDisposed, true);
 			await this._webSocket.DisconnectAsync().ConfigureAwait(false);
 			// this should not be here, no?
 			//await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Connects this Lavalink node to specified Discord channel.
 		/// </summary>
 		/// <param name="channel">Voice channel to connect to.</param>
 		/// <returns>Channel connection, which allows for playback control.</returns>
 		public async Task<LavalinkGuildConnection> ConnectAsync(DiscordChannel channel)
 		{
 			if (this.ConnectedGuildsInternal.ContainsKey(channel.Guild.Id))
 				return this.ConnectedGuildsInternal[channel.Guild.Id];
 
 			if (channel.Guild == null || (channel.Type != ChannelType.Voice && channel.Type != ChannelType.Stage))
 				throw new ArgumentException("Invalid channel specified.", nameof(channel));
 
 			var vstut = new TaskCompletionSource<VoiceStateUpdateEventArgs>();
 			var vsrut = new TaskCompletionSource<VoiceServerUpdateEventArgs>();
 			this._voiceStateUpdates[channel.Guild.Id] = vstut;
 			this._voiceServerUpdates[channel.Guild.Id] = vsrut;
 
 			var vsd = new VoiceDispatch
 			{
 				OpCode = 4,
 				Payload = new VoiceStateUpdatePayload
 				{
 					GuildId = channel.Guild.Id,
 					ChannelId = channel.Id,
 					Deafened = false,
 					Muted = false
 				}
 			};
 			var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
 			await (channel.Discord as DiscordClient).WsSendAsync(vsj).ConfigureAwait(false);
 			var vstu = await vstut.Task.ConfigureAwait(false);
 			var vsru = await vsrut.Task.ConfigureAwait(false);
 			await this.SendPayloadAsync(new LavalinkVoiceUpdate(vstu, vsru)).ConfigureAwait(false);
 
 			var con = new LavalinkGuildConnection(this, channel, vstu);
 			con.ChannelDisconnected += this.Con_ChannelDisconnected;
 			con.PlayerUpdated += (s, e) => this._playerUpdated.InvokeAsync(s, e);
 			con.PlaybackStarted += (s, e) => this._playbackStarted.InvokeAsync(s, e);
 			con.PlaybackFinished += (s, e) => this._playbackFinished.InvokeAsync(s, e);
 			con.TrackStuck += (s, e) => this._trackStuck.InvokeAsync(s, e);
 			con.TrackException += (s, e) => this._trackException.InvokeAsync(s, e);
 			this.ConnectedGuildsInternal[channel.Guild.Id] = con;
 
 			return con;
 		}
 
 		/// <summary>
 		/// Gets a Lavalink connection to specified Discord channel.
 		/// </summary>
 		/// <param name="guild">Guild to get connection for.</param>
 		/// <returns>Channel connection, which allows for playback control.</returns>
 		public LavalinkGuildConnection GetGuildConnection(DiscordGuild guild)
 			=> this.ConnectedGuildsInternal.TryGetValue(guild.Id, out var lgc) && lgc.IsConnected ? lgc : null;
 
 		/// <summary>
 		/// Sends the payload async.
 		/// </summary>
 		/// <param name="payload">The payload.</param>
 		internal async Task SendPayloadAsync(LavalinkPayload payload)
 			=> await this.WsSendAsync(JsonConvert.SerializeObject(payload, Formatting.None)).ConfigureAwait(false);
 
 		/// <summary>
 		/// Webs the socket_ on message.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">the event.ent.</param>
 		private async Task WebSocket_OnMessage(IWebSocketClient client, SocketMessageEventArgs e)
 		{
 			if (e is not SocketTextMessageEventArgs et)
 			{
 				this.Discord.Logger.LogCritical(LavalinkEvents.LavalinkConnectionError, "Lavalink sent binary data - unable to process");
 				return;
 			}
 
 			this.Discord.Logger.LogTrace(LavalinkEvents.LavalinkWsRx, et.Message);
 
 			var json = et.Message;
 			var jsonData = JObject.Parse(json);
 			switch (jsonData["op"].ToString())
 			{
 				case "playerUpdate":
 					var gid = (ulong)jsonData["guildId"];
 					var state = jsonData["state"].ToObject<LavalinkState>();
 					if (this.ConnectedGuildsInternal.TryGetValue(gid, out var lvl))
 						await lvl.InternalUpdatePlayerStateAsync(state).ConfigureAwait(false);
 					break;
 
 				case "stats":
 					var statsRaw = jsonData.ToObject<LavalinkStats>();
 					this.Statistics.Update(statsRaw);
 					await this._statsReceived.InvokeAsync(this, new StatisticsReceivedEventArgs(this.Discord.ServiceProvider, this.Statistics)).ConfigureAwait(false);
 					break;
 
 				case "event":
 					var evtype = jsonData["type"].ToObject<EventType>();
 					var guildId = (ulong)jsonData["guildId"];
 					switch (evtype)
 					{
 						case EventType.TrackStartEvent:
 							if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvtst))
 								await lvlEvtst.InternalPlaybackStartedAsync(jsonData["track"].ToString()).ConfigureAwait(false);
 							break;
 
 						case EventType.TrackEndEvent:
 							var reason = TrackEndReason.Cleanup;
 							switch (jsonData["reason"].ToString())
 							{
 								case "FINISHED":
 									reason = TrackEndReason.Finished;
 									break;
 								case "LOAD_FAILED":
 									reason = TrackEndReason.LoadFailed;
 									break;
 								case "STOPPED":
 									reason = TrackEndReason.Stopped;
 									break;
 								case "REPLACED":
 									reason = TrackEndReason.Replaced;
 									break;
 								case "CLEANUP":
 									reason = TrackEndReason.Cleanup;
 									break;
 							}
 							if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvtf))
 								await lvlEvtf.InternalPlaybackFinishedAsync(new TrackFinishData { Track = jsonData["track"].ToString(), Reason = reason }).ConfigureAwait(false);
 							break;
 
 						case EventType.TrackStuckEvent:
 							if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvts))
 								await lvlEvts.InternalTrackStuckAsync(new TrackStuckData { Track = jsonData["track"].ToString(), Threshold = (long)jsonData["thresholdMs"] }).ConfigureAwait(false);
 							break;
 
 						case EventType.TrackExceptionEvent:
 							if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvte))
 								await lvlEvte.InternalTrackExceptionAsync(new TrackExceptionData { Track = jsonData["track"].ToString(), Error = jsonData["error"].ToString() }).ConfigureAwait(false);
 							break;
 
 						case EventType.WebSocketClosedEvent:
 							if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEwsce))
 							{
 								lvlEwsce.VoiceWsDisconnectTcs.SetResult(true);
 								await lvlEwsce.InternalWebSocketClosedAsync(new WebSocketCloseEventArgs(jsonData["code"].ToObject<int>(), jsonData["reason"].ToString(), jsonData["byRemote"].ToObject<bool>(), this.Discord.ServiceProvider)).ConfigureAwait(false);
 							}
 							break;
 					}
 					break;
 			}
 		}
 
 		/// <summary>
 		/// Webs the socket_ on exception.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">the event.</param>
 		private Task WebSocket_OnException(IWebSocketClient client, SocketErrorEventArgs e)
 			=> this._lavalinkSocketError.InvokeAsync(this, new SocketErrorEventArgs(client.ServiceProvider) { Exception = e.Exception });
 
 		/// <summary>
 		/// Webs the socket_ on disconnect.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">the event.</param>
 		private async Task WebSocket_OnDisconnect(IWebSocketClient client, SocketCloseEventArgs e)
 		{
 			if (this.IsConnected && e.CloseCode != 1001 && e.CloseCode != -1)
 			{
 				this.Discord.Logger.LogWarning(LavalinkEvents.LavalinkConnectionClosed, "Connection broken ({0}, '{1}'), reconnecting", e.CloseCode, e.CloseMessage);
 				await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, false)).ConfigureAwait(false);
 
 				if (this.Configuration.SocketAutoReconnect)
 					await this.StartAsync().ConfigureAwait(false);
 			}
 			else if (e.CloseCode != 1001 && e.CloseCode != -1)
 			{
 				this.Discord.Logger.LogInformation(LavalinkEvents.LavalinkConnectionClosed, "Connection closed ({0}, '{1}')", e.CloseCode, e.CloseMessage);
 				this.NodeDisconnected?.Invoke(this);
 				await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, true)).ConfigureAwait(false);
 			}
 			else
 			{
 				Volatile.Write(ref this._isDisposed, true);
 				this.Discord.Logger.LogWarning(LavalinkEvents.LavalinkConnectionClosed, "Lavalink died");
 				foreach (var kvp in this.ConnectedGuildsInternal)
 				{
 					await kvp.Value.SendVoiceUpdateAsync().ConfigureAwait(false);
 					_ = this.ConnectedGuildsInternal.TryRemove(kvp.Key, out _);
 				}
 				this.NodeDisconnected?.Invoke(this);
 				await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, false)).ConfigureAwait(false);
 
 				if (this.Configuration.SocketAutoReconnect)
 					await this.StartAsync().ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Webs the socket_ on connect.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="ea">the event..</param>
 		private async Task WebSocket_OnConnect(IWebSocketClient client, SocketEventArgs ea)
 		{
 			this.Discord.Logger.LogDebug(LavalinkEvents.LavalinkConnected, "Connection to Lavalink node established");
 			this._backoff = 0;
 
 			if (this.Configuration.ResumeKey != null)
 				await this.SendPayloadAsync(new LavalinkConfigureResume(this.Configuration.ResumeKey, this.Configuration.ResumeTimeout)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Con_S the channel disconnected.
 		/// </summary>
 		/// <param name="con">The con.</param>
 		private void Con_ChannelDisconnected(LavalinkGuildConnection con)
 			=> this.ConnectedGuildsInternal.TryRemove(con.GuildId, out _);
 
 		/// <summary>
 		/// Discord voice state updated.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">the event.</param>
 		private Task Discord_VoiceStateUpdated(DiscordClient client, VoiceStateUpdateEventArgs e)
 		{
 			var gld = e.Guild;
 			if (gld == null)
 				return Task.CompletedTask;
 
 			if (e.User == null)
 				return Task.CompletedTask;
 
 			if (e.User.Id == this.Discord.CurrentUser.Id)
 			{
 				if (this.ConnectedGuildsInternal.TryGetValue(e.Guild.Id, out var lvlgc))
 					lvlgc.VoiceStateUpdate = e;
 
 				if (e.After.Channel == null && this.IsConnected && this.ConnectedGuildsInternal.ContainsKey(gld.Id))
 				{
 					_ = Task.Run(async () =>
 					{
 						var delayTask = Task.Delay(this.Configuration.WebSocketCloseTimeout);
 						var tcs = lvlgc.VoiceWsDisconnectTcs.Task;
 						_ = await Task.WhenAny(delayTask, tcs).ConfigureAwait(false);
 
 						await lvlgc.DisconnectInternalAsync(false, true).ConfigureAwait(false);
 						_ = this.ConnectedGuildsInternal.TryRemove(gld.Id, out _);
 					});
 				}
 
 				if (!string.IsNullOrWhiteSpace(e.SessionId) && e.Channel != null && this._voiceStateUpdates.TryRemove(gld.Id, out var xe))
 					xe.SetResult(e);
 			}
 
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Discord voice server updated.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">the event.</param>
 		private Task Discord_VoiceServerUpdated(DiscordClient client, VoiceServerUpdateEventArgs e)
 		{
 			var gld = e.Guild;
 			if (gld == null)
 				return Task.CompletedTask;
 
 			if (this.ConnectedGuildsInternal.TryGetValue(e.Guild.Id, out var lvlgc))
 			{
 				var lvlp = new LavalinkVoiceUpdate(lvlgc.VoiceStateUpdate, e);
 				_ = Task.Run(() => this.WsSendAsync(JsonConvert.SerializeObject(lvlp)));
 			}
 
 			if (this._voiceServerUpdates.TryRemove(gld.Id, out var xe))
 				xe.SetResult(e);
 
 			return Task.CompletedTask;
 		}
 		/// <summary>
 		/// Ws the send async.
 		/// </summary>
 		/// <param name="payload">The payload.</param>
 
 		private async Task WsSendAsync(string payload)
 		{
 			this.Discord.Logger.LogTrace(LavalinkEvents.LavalinkWsTx, payload);
 			await this._webSocket.SendMessageAsync(payload).ConfigureAwait(false);
 		}
 
 		internal event NodeDisconnectedEventHandler NodeDisconnected;
 	}
 }
diff --git a/DisCatSharp.Lavalink/LavalinkUtil.cs b/DisCatSharp.Lavalink/LavalinkUtil.cs
index 86aae4fc5..633619545 100644
--- a/DisCatSharp.Lavalink/LavalinkUtil.cs
+++ b/DisCatSharp.Lavalink/LavalinkUtil.cs
@@ -1,285 +1,285 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.IO;
 using System.Text;
 using DisCatSharp.Lavalink.EventArgs;
 
 namespace DisCatSharp.Lavalink
 {
 	/// <summary>
 	/// Various utilities for Lavalink.
 	/// </summary>
 	public static class LavalinkUtilities
 	{
 		/// <summary>
 		/// Indicates whether a new track should be started after reciving this TrackEndReason. If this is false, either this event is
 		/// already triggered because another track started (REPLACED) or because the player is stopped (STOPPED, CLEANUP).
 		/// </summary>
 		public static bool MayStartNext(this TrackEndReason reason)
 			=> reason == TrackEndReason.Finished || reason == TrackEndReason.LoadFailed;
 
 		/// <summary>
 		/// Decodes a Lavalink track string.
 		/// </summary>
 		/// <param name="track">Track string to decode.</param>
 		/// <returns>Decoded Lavalink track.</returns>
 		public static LavalinkTrack DecodeTrack(string track)
 		{
 			// https://github.com/sedmelluq/lavaplayer/blob/804cd1038229230052d9b1dee5e6d1741e30e284/main/src/main/java/com/sedmelluq/discord/lavaplayer/player/DefaultAudioPlayerManager.java#L63-L64
 			const int TRACK_INFO_VERSIONED = 1;
 			//const int TRACK_INFO_VERSION = 2;
 
 			var raw = Convert.FromBase64String(track);
 
 			var decoded = new LavalinkTrack
 			{
 				TrackString = track
 			};
 
 			using (var ms = new MemoryStream(raw))
 			using (var br = new JavaBinaryReader(ms))
 			{
 				// https://github.com/sedmelluq/lavaplayer/blob/b0c536098c4f92e6d03b00f19221021f8f50b19b/main/src/main/java/com/sedmelluq/discord/lavaplayer/tools/io/MessageInput.java#L37-L39
 				var messageHeader = br.ReadInt32();
 				var messageFlags = (int) ((messageHeader & 0xC0000000L) >> 30);
 				var messageSize = messageHeader & 0x3FFFFFFF;
 				//if (messageSize != raw.Length)
 				//    Warn($"Size conflict: {messageSize} but was {raw.Length}");
 
 				// https://github.com/sedmelluq/lavaplayer/blob/804cd1038229230052d9b1dee5e6d1741e30e284/main/src/main/java/com/sedmelluq/discord/lavaplayer/player/DefaultAudioPlayerManager.java#L268
 
 				// java bytes are signed
 				// https://docs.oracle.com/javase/7/docs/api/java/io/DataInput.html#readByte()
-				var version = (messageFlags & TRACK_INFO_VERSIONED) != 0 ? (br.ReadSByte() & 0xFF) : 1;
+				var version = (messageFlags & TRACK_INFO_VERSIONED) != 0 ? br.ReadSByte() & 0xFF : 1;
 				//if (version != TRACK_INFO_VERSION)
 				//    Warn($"Version conflict: Expected {TRACK_INFO_VERSION} but got {version}");
 
 				decoded.Title = br.ReadJavaUtf8();
 
 				decoded.Author = br.ReadJavaUtf8();
 
 				decoded.LengthInternal = br.ReadInt64();
 
 				decoded.Identifier = br.ReadJavaUtf8();
 
 				decoded.IsStream = br.ReadBoolean();
 
 				var uri = br.ReadNullableString();
 				decoded.Uri = uri != null && version >= 2 ? new Uri(uri) : null;
 			}
 
 			return decoded;
 		}
 	}
 
 	/// <inheritdoc />
 	/// <summary>
 	/// Java's DataOutputStream always uses big-endian, while BinaryReader always uses little-endian.
 	/// This class converts a big-endian stream to little-endian, and includes some helper methods
 	/// for interacting with Lavaplayer/Lavalink.
 	/// </summary>
 	internal class JavaBinaryReader : BinaryReader
 	{
 		private static readonly Encoding s_utf8NoBom = new UTF8Encoding();
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="JavaBinaryReader"/> class.
 		/// </summary>
 		/// <param name="ms">The ms.</param>
 		public JavaBinaryReader(Stream ms) : base(ms, s_utf8NoBom)
 		{
 		}
 
 		// https://docs.oracle.com/javase/7/docs/api/java/io/DataInput.html#readUTF()
 		/// <summary>
 		/// Reads the java utf8.
 		/// </summary>
 		/// <returns>A string.</returns>
 		public string ReadJavaUtf8()
 		{
 			var length = this.ReadUInt16(); // string size in bytes
 			var bytes = new byte[length];
 			var amountRead = this.Read(bytes, 0, length);
 			if (amountRead < length)
 				throw new InvalidDataException("EOS unexpected");
 
 			var output = new char[length];
 			var strlen = 0;
 
 			// i'm gonna blindly assume here that the javadocs had the correct endianness
 
 			for (var i = 0; i < length; i++)
 			{
 				var value1 = bytes[i];
 				if ((value1 & 0b10000000) == 0) // highest bit 1 is false
 				{
 					output[strlen++] = (char)value1;
 					continue;
 				}
 
 				// remember to skip one byte for every extra byte
 				var value2 = bytes[++i];
 				if ((value1 & 0b00100000) == 0 && // highest bit 3 is false
 					(value1 & 0b11000000) != 0 && // highest bit 1 and 2 are true
 					(value2 & 0b01000000) == 0 && // highest bit 2 is false
 					(value2 & 0b10000000) != 0) //   highest bit 1 is true
 				{
 					var value1Chop = (value1 & 0b00011111) << 6;
 					var value2Chop = value2 & 0b00111111;
 					output[strlen++] = (char)(value1Chop | value2Chop);
 					continue;
 				}
 
 				var value3 = bytes[++i];
 				if ((value1 & 0b00010000) == 0 && // highest bit 4 is false
 					(value1 & 0b11100000) != 0 && // highest bit 1,2,3 are true
 					(value2 & 0b01000000) == 0 && // highest bit 2 is false
 					(value2 & 0b10000000) != 0 && // highest bit 1 is true
 					(value3 & 0b01000000) == 0 && // highest bit 2 is false
 					(value3 & 0b10000000) != 0) //   highest bit 1 is true
 				{
 					var value1Chop = (value1 & 0b00001111) << 12;
 					var value2Chop = (value2 & 0b00111111) << 6;
 					var value3Chop = value3 & 0b00111111;
 					output[strlen++] = (char)(value1Chop | value2Chop | value3Chop);
 					continue;
 				}
 			}
 
 			return new string(output, 0, strlen);
 		}
 
 		// https://github.com/sedmelluq/lavaplayer/blob/b0c536098c4f92e6d03b00f19221021f8f50b19b/main/src/main/java/com/sedmelluq/discord/lavaplayer/tools/DataFormatTools.java#L114-L125
 		/// <summary>
 		/// Reads the nullable string.
 		/// </summary>
 		/// <returns>A string.</returns>
 		public string ReadNullableString() => this.ReadBoolean() ? this.ReadJavaUtf8() : null;
 
 		// swap endianness
 		/// <summary>
 		/// Reads the decimal.
 		/// </summary>
 		/// <returns>A decimal.</returns>
 		public override decimal ReadDecimal() => throw new MissingMethodException("This method does not have a Java equivalent");
 
 		// from https://github.com/Zoltu/Zoltu.EndianAwareBinaryReaderWriter under CC0
 		/// <summary>
 		/// Reads the single.
 		/// </summary>
 		/// <returns>A float.</returns>
 		public override float ReadSingle() => this.Read(4, BitConverter.ToSingle);
 
 		/// <summary>
 		/// Reads the double.
 		/// </summary>
 		/// <returns>A double.</returns>
 		public override double ReadDouble() => this.Read(8, BitConverter.ToDouble);
 
 		/// <summary>
 		/// Reads the int16.
 		/// </summary>
 		/// <returns>A short.</returns>
 		public override short ReadInt16() => this.Read(2, BitConverter.ToInt16);
 
 		/// <summary>
 		/// Reads the int32.
 		/// </summary>
 		/// <returns>An int.</returns>
 		public override int ReadInt32() => this.Read(4, BitConverter.ToInt32);
 
 		/// <summary>
 		/// Reads the int64.
 		/// </summary>
 		/// <returns>A long.</returns>
 		public override long ReadInt64() => this.Read(8, BitConverter.ToInt64);
 
 		/// <summary>
 		/// Reads the u int16.
 		/// </summary>
 		/// <returns>An ushort.</returns>
 		public override ushort ReadUInt16() => this.Read(2, BitConverter.ToUInt16);
 
 		/// <summary>
 		/// Reads the u int32.
 		/// </summary>
 		/// <returns>An uint.</returns>
 		public override uint ReadUInt32() => this.Read(4, BitConverter.ToUInt32);
 
 		/// <summary>
 		/// Reads the u int64.
 		/// </summary>
 		/// <returns>An ulong.</returns>
 		public override ulong ReadUInt64() => this.Read(8, BitConverter.ToUInt64);
 
 		/// <summary>
 		/// Reads the.
 		/// </summary>
 		/// <param name="size">The size.</param>
 		/// <param name="converter">The converter.</param>
 		/// <returns>A T.</returns>
 		private T Read<T>(int size, Func<byte[], int, T> converter) where T : struct
 		{
 			//Contract.Requires(size >= 0);
 			//Contract.Requires(converter != null);
 
 			var bytes = this.GetNextBytesNativeEndian(size);
 			return converter(bytes, 0);
 		}
 
 		/// <summary>
 		/// Gets the next bytes native endian.
 		/// </summary>
 		/// <param name="count">The count.</param>
 		/// <returns>An array of byte.</returns>
 		private byte[] GetNextBytesNativeEndian(int count)
 		{
 			//Contract.Requires(count >= 0);
 			//Contract.Ensures(Contract.Result<Byte[]>() != null);
 			//Contract.Ensures(Contract.Result<Byte[]>().Length == count);
 
 			var bytes = this.GetNextBytes(count);
 			if (BitConverter.IsLittleEndian)
 				Array.Reverse(bytes);
 			return bytes;
 		}
 
 		/// <summary>
 		/// Gets the next bytes.
 		/// </summary>
 		/// <param name="count">The count.</param>
 		/// <returns>An array of byte.</returns>
 		private byte[] GetNextBytes(int count)
 		{
 			//Contract.Requires(count >= 0);
 			//Contract.Ensures(Contract.Result<Byte[]>() != null);
 			//Contract.Ensures(Contract.Result<Byte[]>().Length == count);
 
 			var buffer = new byte[count];
 			var bytesRead = this.BaseStream.Read(buffer, 0, count);
 
 			return bytesRead != count ? throw new EndOfStreamException() : buffer;
 		}
 	}
 }
diff --git a/DisCatSharp.VoiceNext/AudioFormat.cs b/DisCatSharp.VoiceNext/AudioFormat.cs
index d3f4589bc..8a16677fd 100644
--- a/DisCatSharp.VoiceNext/AudioFormat.cs
+++ b/DisCatSharp.VoiceNext/AudioFormat.cs
@@ -1,164 +1,164 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Runtime.CompilerServices;
 
 namespace DisCatSharp.VoiceNext
 {
 	/// <summary>
 	/// Defines the format of PCM data consumed or produced by Opus.
 	/// </summary>
 	public struct AudioFormat
 	{
 		/// <summary>
 		/// Gets the collection of sampling rates (in Hz) the Opus encoder can use.
 		/// </summary>
 		public static IReadOnlyCollection<int> AllowedSampleRates { get; } = new ReadOnlyCollection<int>(new[] { 8000, 12000, 16000, 24000, 48000 });
 
 		/// <summary>
 		/// Gets the collection of channel counts the Opus encoder can use.
 		/// </summary>
 		public static IReadOnlyCollection<int> AllowedChannelCounts { get; } = new ReadOnlyCollection<int>(new[] { 1, 2 });
 
 		/// <summary>
 		/// Gets the collection of sample durations (in ms) the Opus encoder can use.
 		/// </summary>
 		public static IReadOnlyCollection<int> AllowedSampleDurations { get; } = new ReadOnlyCollection<int>(new[] { 5, 10, 20, 40, 60 });
 
 		/// <summary>
 		/// Gets the default audio format. This is a formt configured for 48kHz sampling rate, 2 channels, with music quality preset.
 		/// </summary>
-		public static AudioFormat Default { get; } = new AudioFormat(48000, 2, VoiceApplication.Music);
+		public static AudioFormat Default { get; } = new(48000, 2, VoiceApplication.Music);
 
 		/// <summary>
 		/// Gets the audio sampling rate in Hz.
 		/// </summary>
 		public int SampleRate { get; }
 
 		/// <summary>
 		/// Gets the audio channel count.
 		/// </summary>
 		public int ChannelCount { get; }
 
 		/// <summary>
 		/// Gets the voice application, which dictates the quality preset.
 		/// </summary>
 		public VoiceApplication VoiceApplication { get; }
 
 		/// <summary>
 		/// Creates a new audio format for use with Opus encoder.
 		/// </summary>
 		/// <param name="sampleRate">Audio sampling rate in Hz.</param>
 		/// <param name="channelCount">Number of audio channels in the data.</param>
 		/// <param name="voiceApplication">Encoder preset to use.</param>
 		public AudioFormat(int sampleRate = 48000, int channelCount = 2, VoiceApplication voiceApplication = VoiceApplication.Music)
 		{
 			if (!AllowedSampleRates.Contains(sampleRate))
 				throw new ArgumentOutOfRangeException(nameof(sampleRate), "Invalid sample rate specified.");
 
 			if (!AllowedChannelCounts.Contains(channelCount))
 				throw new ArgumentOutOfRangeException(nameof(channelCount), "Invalid channel count specified.");
 
 			if (voiceApplication != VoiceApplication.Music && voiceApplication != VoiceApplication.Voice && voiceApplication != VoiceApplication.LowLatency)
 				throw new ArgumentOutOfRangeException(nameof(voiceApplication), "Invalid voice application specified.");
 
 			this.SampleRate = sampleRate;
 			this.ChannelCount = channelCount;
 			this.VoiceApplication = voiceApplication;
 		}
 
 		/// <summary>
 		/// Calculates a sample size in bytes.
 		/// </summary>
 		/// <param name="sampleDuration">Millsecond duration of a sample.</param>
 		/// <returns>Calculated sample size in bytes.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public int CalculateSampleSize(int sampleDuration)
 		{
 			if (!AllowedSampleDurations.Contains(sampleDuration))
 				throw new ArgumentOutOfRangeException(nameof(sampleDuration), "Invalid sample duration specified.");
 
 			// Sample size in bytes is a product of the following:
 			// - duration in milliseconds
 			// - number of channels
 			// - sample rate in kHz
 			// - size of data (in this case, sizeof(int16_t))
 			// which comes down to below:
 			return sampleDuration * this.ChannelCount * (this.SampleRate / 1000) * 2;
 		}
 
 		/// <summary>
 		/// Gets the maximum buffer size for decoding. This method should be called when decoding Opus data to PCM, to ensure sufficient buffer size.
 		/// </summary>
 		/// <returns>Buffer size required to decode data.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public int GetMaximumBufferSize()
 			=> this.CalculateMaximumFrameSize();
 
 		/// <summary>
 		/// Calculates the sample duration.
 		/// </summary>
 		/// <param name="sampleSize">The sample size.</param>
 		/// <returns>An int.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		internal int CalculateSampleDuration(int sampleSize)
 			=> sampleSize / (this.SampleRate / 1000) / this.ChannelCount / 2 /* sizeof(int16_t) */;
 
 		/// <summary>
 		/// Calculates the frame size.
 		/// </summary>
 		/// <param name="sampleDuration">The sample duration.</param>
 		/// <returns>An int.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		internal int CalculateFrameSize(int sampleDuration)
 			=> sampleDuration * (this.SampleRate / 1000);
 
 		/// <summary>
 		/// Calculates the maximum frame size.
 		/// </summary>
 		/// <returns>An int.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		internal int CalculateMaximumFrameSize()
 			=> 120 * (this.SampleRate / 1000);
 
 		/// <summary>
 		/// Samples the count to sample size.
 		/// </summary>
 		/// <param name="sampleCount">The sample count.</param>
 		/// <returns>An int.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		internal int SampleCountToSampleSize(int sampleCount)
 			=> sampleCount * this.ChannelCount * 2 /* sizeof(int16_t) */;
 
 		/// <summary>
 		/// Are the valid.
 		/// </summary>
 		/// <returns>A bool.</returns>
 		internal bool IsValid()
 			=> AllowedSampleRates.Contains(this.SampleRate) && AllowedChannelCounts.Contains(this.ChannelCount) &&
 				(this.VoiceApplication == VoiceApplication.Music || this.VoiceApplication == VoiceApplication.Voice || this.VoiceApplication == VoiceApplication.LowLatency);
 	}
 }
diff --git a/DisCatSharp.VoiceNext/Codec/Opus.cs b/DisCatSharp.VoiceNext/Codec/Opus.cs
index 1d26a4394..621d4665f 100644
--- a/DisCatSharp.VoiceNext/Codec/Opus.cs
+++ b/DisCatSharp.VoiceNext/Codec/Opus.cs
@@ -1,288 +1,288 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 
 namespace DisCatSharp.VoiceNext.Codec
 {
 	/// <summary>
 	/// The opus.
 	/// </summary>
 	internal sealed class Opus : IDisposable
 	{
 		/// <summary>
 		/// Gets the audio format.
 		/// </summary>
 		public AudioFormat AudioFormat { get; }
 
 		/// <summary>
 		/// Gets the encoder.
 		/// </summary>
 		private readonly IntPtr _encoder;
 
 		/// <summary>
 		/// Gets the managed decoders.
 		/// </summary>
 		private readonly List<OpusDecoder> _managedDecoders;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="Opus"/> class.
 		/// </summary>
 		/// <param name="audioFormat">The audio format.</param>
 		public Opus(AudioFormat audioFormat)
 		{
 			if (!audioFormat.IsValid())
 				throw new ArgumentException("Invalid audio format specified.", nameof(audioFormat));
 
 			this.AudioFormat = audioFormat;
 			this._encoder = Interop.OpusCreateEncoder(this.AudioFormat);
 
 			// Set appropriate encoder options
 			var sig = OpusSignal.Auto;
 			switch (this.AudioFormat.VoiceApplication)
 			{
 				case VoiceApplication.Music:
 					sig = OpusSignal.Music;
 					break;
 
 				case VoiceApplication.Voice:
 					sig = OpusSignal.Voice;
 					break;
 			}
 			Interop.OpusSetEncoderOption(this._encoder, OpusControl.SetSignal, (int)sig);
 			Interop.OpusSetEncoderOption(this._encoder, OpusControl.SetPacketLossPercent, 15);
 			Interop.OpusSetEncoderOption(this._encoder, OpusControl.SetInBandFec, 1);
 			Interop.OpusSetEncoderOption(this._encoder, OpusControl.SetBitrate, 131072);
 
 			this._managedDecoders = new List<OpusDecoder>();
 		}
 
 		/// <summary>
 		/// Encodes the Opus.
 		/// </summary>
 		/// <param name="pcm">The pcm.</param>
 		/// <param name="target">The target.</param>
 		public void Encode(ReadOnlySpan<byte> pcm, ref Span<byte> target)
 		{
 			if (pcm.Length != target.Length)
 				throw new ArgumentException("PCM and Opus buffer lengths need to be equal.", nameof(target));
 
 			var duration = this.AudioFormat.CalculateSampleDuration(pcm.Length);
 			var frameSize = this.AudioFormat.CalculateFrameSize(duration);
 			var sampleSize = this.AudioFormat.CalculateSampleSize(duration);
 
 			if (pcm.Length != sampleSize)
 				throw new ArgumentException("Invalid PCM sample size.", nameof(target));
 
 			Interop.OpusEncode(this._encoder, pcm, frameSize, ref target);
 		}
 
 		/// <summary>
 		/// Decodes the Opus.
 		/// </summary>
 		/// <param name="decoder">The decoder.</param>
 		/// <param name="opus">The opus.</param>
 		/// <param name="target">The target.</param>
 		/// <param name="useFec">If true, use fec.</param>
 		/// <param name="outputFormat">The output format.</param>
 		public void Decode(OpusDecoder decoder, ReadOnlySpan<byte> opus, ref Span<byte> target, bool useFec, out AudioFormat outputFormat)
 		{
 			//if (target.Length != this.AudioFormat.CalculateMaximumFrameSize())
 			//    throw new ArgumentException("PCM target buffer size needs to be equal to maximum buffer size for specified audio format.", nameof(target));
 
 			Interop.OpusGetPacketMetrics(opus, this.AudioFormat.SampleRate, out var channels, out var frames, out var samplesPerFrame, out var frameSize);
 			outputFormat = this.AudioFormat.ChannelCount != channels ? new AudioFormat(this.AudioFormat.SampleRate, channels, this.AudioFormat.VoiceApplication) : this.AudioFormat;
 
 			if (decoder.AudioFormat.ChannelCount != channels)
 				decoder.Initialize(outputFormat);
 
 			var sampleCount = Interop.OpusDecode(decoder.Decoder, opus, frameSize, target, useFec);
 
 			var sampleSize = outputFormat.SampleCountToSampleSize(sampleCount);
 			target = target[..sampleSize];
 		}
 
 		/// <summary>
 		/// Processes the packet loss.
 		/// </summary>
 		/// <param name="decoder">The decoder.</param>
 		/// <param name="frameSize">The frame size.</param>
 		/// <param name="target">The target.</param>
 		public void ProcessPacketLoss(OpusDecoder decoder, int frameSize, ref Span<byte> target) => Interop.OpusDecode(decoder.Decoder, frameSize, target);
 
 		/// <summary>
 		/// Gets the last packet sample count.
 		/// </summary>
 		/// <param name="decoder">The decoder.</param>
 		/// <returns>An int.</returns>
 		public int GetLastPacketSampleCount(OpusDecoder decoder)
 		{
 			Interop.OpusGetLastPacketDuration(decoder.Decoder, out var sampleCount);
 			return sampleCount;
 		}
 
 		/// <summary>
 		/// Creates the decoder.
 		/// </summary>
 		/// <returns>An OpusDecoder.</returns>
 		public OpusDecoder CreateDecoder()
 		{
 			lock (this._managedDecoders)
 			{
 				var managedDecoder = new OpusDecoder(this);
 				this._managedDecoders.Add(managedDecoder);
 				return managedDecoder;
 			}
 		}
 
 		/// <summary>
 		/// Destroys the decoder.
 		/// </summary>
 		/// <param name="decoder">The decoder.</param>
 		public void DestroyDecoder(OpusDecoder decoder)
 		{
 			lock (this._managedDecoders)
 			{
 				if (!this._managedDecoders.Contains(decoder))
 					return;
 
 				this._managedDecoders.Remove(decoder);
 				decoder.Dispose();
 			}
 		}
 
 		/// <summary>
 		/// Disposes the Opus.
 		/// </summary>
 		public void Dispose()
 		{
 			Interop.OpusDestroyEncoder(this._encoder);
 
 			lock (this._managedDecoders)
 			{
 				foreach (var decoder in this._managedDecoders)
 					decoder.Dispose();
 			}
 		}
 	}
 
 	/// <summary>
 	/// Represents an Opus decoder.
 	/// </summary>
 	public class OpusDecoder : IDisposable
 	{
 		/// <summary>
 		/// Gets the audio format produced by this decoder.
 		/// </summary>
 		public AudioFormat AudioFormat { get; private set; }
 
 		/// <summary>
 		/// Gets the opus.
 		/// </summary>
 		internal Opus Opus { get; }
 		/// <summary>
 		/// Gets the decoder.
 		/// </summary>
 		internal IntPtr Decoder { get; private set; }
 
-		private volatile bool _isDisposed = false;
+		private volatile bool _isDisposed;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="OpusDecoder"/> class.
 		/// </summary>
 		/// <param name="managedOpus">The managed opus.</param>
 		internal OpusDecoder(Opus managedOpus)
 		{
 			this.Opus = managedOpus;
 		}
 
 		/// <summary>
 		/// Used to lazily initialize the decoder to make sure we're
 		/// using the correct output format, this way we don't end up
 		/// creating more decoders than we need.
 		/// </summary>
 		/// <param name="outputFormat"></param>
 		internal void Initialize(AudioFormat outputFormat)
 		{
 			if (this.Decoder != IntPtr.Zero)
 				Interop.OpusDestroyDecoder(this.Decoder);
 
 			this.AudioFormat = outputFormat;
 
 			this.Decoder = Interop.OpusCreateDecoder(outputFormat);
 		}
 
 		/// <summary>
 		/// Disposes of this Opus decoder.
 		/// </summary>
 		public void Dispose()
 		{
 			if (this._isDisposed)
 				return;
 
 			this._isDisposed = true;
 			if (this.Decoder != IntPtr.Zero)
 				Interop.OpusDestroyDecoder(this.Decoder);
 		}
 	}
 
 	/// <summary>
 	/// The opus error.
 	/// </summary>
 	[Flags]
 	internal enum OpusError
 	{
 		Ok = 0,
 		BadArgument = -1,
 		BufferTooSmall = -2,
 		InternalError = -3,
 		InvalidPacket = -4,
 		Unimplemented = -5,
 		InvalidState = -6,
 		AllocationFailure = -7
 	}
 
 	/// <summary>
 	/// The opus control.
 	/// </summary>
 	internal enum OpusControl : int
 	{
 		SetBitrate = 4002,
 		SetBandwidth = 4008,
 		SetInBandFec = 4012,
 		SetPacketLossPercent = 4014,
 		SetSignal = 4024,
 		ResetState = 4028,
 		GetLastPacketDuration = 4039
 	}
 
 	/// <summary>
 	/// The opus signal.
 	/// </summary>
 	internal enum OpusSignal : int
 	{
 		Auto = -1000,
 		Voice = 3001,
 		Music = 3002,
 	}
 }
diff --git a/DisCatSharp.VoiceNext/Codec/Rtp.cs b/DisCatSharp.VoiceNext/Codec/Rtp.cs
index 4f2f4c638..bf0b2a3be 100644
--- a/DisCatSharp.VoiceNext/Codec/Rtp.cs
+++ b/DisCatSharp.VoiceNext/Codec/Rtp.cs
@@ -1,161 +1,159 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Buffers.Binary;
 
 namespace DisCatSharp.VoiceNext.Codec
 {
 	/// <summary>
 	/// The rtp.
 	/// </summary>
 	internal sealed class Rtp : IDisposable
 	{
 		/// <summary>
 		/// The header size.
 		/// </summary>
 		public const int HEADER_SIZE = 12;
 
 		/// <summary>
 		/// The rtp no extension.
 		/// </summary>
 		private const byte RTP_NO_EXTENSION = 0x80;
 		/// <summary>
 		/// The rtp extension.
 		/// </summary>
 		private const byte RTP_EXTENSION = 0x90;
 		/// <summary>
 		/// The rtp version.
 		/// </summary>
 		private const byte RTP_VERSION = 0x78;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="Rtp"/> class.
 		/// </summary>
 		public Rtp()
 		{ }
 
 		/// <summary>
 		/// Encodes the header.
 		/// </summary>
 		/// <param name="sequence">The sequence.</param>
 		/// <param name="timestamp">The timestamp.</param>
 		/// <param name="ssrc">The ssrc.</param>
 		/// <param name="target">The target.</param>
 		public void EncodeHeader(ushort sequence, uint timestamp, uint ssrc, Span<byte> target)
 		{
 			if (target.Length < HEADER_SIZE)
 				throw new ArgumentException("Header buffer is too short.", nameof(target));
 
 			target[0] = RTP_NO_EXTENSION;
 			target[1] = RTP_VERSION;
 
 			// Write data big endian
 			BinaryPrimitives.WriteUInt16BigEndian(target[2..], sequence);  // header + magic
 			BinaryPrimitives.WriteUInt32BigEndian(target[4..], timestamp); // header + magic + sizeof(sequence)
 			BinaryPrimitives.WriteUInt32BigEndian(target[8..], ssrc);      // header + magic + sizeof(sequence) + sizeof(timestamp)
 		}
 
 		/// <summary>
 		/// Are the rtp header.
 		/// </summary>
 		/// <param name="source">The source.</param>
 		/// <returns>A bool.</returns>
 		public bool IsRtpHeader(ReadOnlySpan<byte> source) => source.Length >= HEADER_SIZE && (source[0] == RTP_NO_EXTENSION || source[0] == RTP_EXTENSION) && source[1] == RTP_VERSION;
 
 		/// <summary>
 		/// Decodes the header.
 		/// </summary>
 		/// <param name="source">The source.</param>
 		/// <param name="sequence">The sequence.</param>
 		/// <param name="timestamp">The timestamp.</param>
 		/// <param name="ssrc">The ssrc.</param>
 		/// <param name="hasExtension">If true, has extension.</param>
 		public void DecodeHeader(ReadOnlySpan<byte> source, out ushort sequence, out uint timestamp, out uint ssrc, out bool hasExtension)
 		{
 			if (source.Length < HEADER_SIZE)
 				throw new ArgumentException("Header buffer is too short.", nameof(source));
 
 			if ((source[0] != RTP_NO_EXTENSION && source[0] != RTP_EXTENSION) || source[1] != RTP_VERSION)
 				throw new ArgumentException("Invalid RTP header.", nameof(source));
 
 			hasExtension = source[0] == RTP_EXTENSION;
 
 			// Read data big endian
 			sequence = BinaryPrimitives.ReadUInt16BigEndian(source[2..]);
 			timestamp = BinaryPrimitives.ReadUInt32BigEndian(source[4..]);
 			ssrc = BinaryPrimitives.ReadUInt32BigEndian(source[8..]);
 		}
 
 		/// <summary>
 		/// Calculates the packet size.
 		/// </summary>
 		/// <param name="encryptedLength">The encrypted length.</param>
 		/// <param name="encryptionMode">The encryption mode.</param>
 		/// <returns>An int.</returns>
-		public int CalculatePacketSize(int encryptedLength, EncryptionMode encryptionMode)
-		{
-			return encryptionMode switch
+		public int CalculatePacketSize(int encryptedLength, EncryptionMode encryptionMode) =>
+			encryptionMode switch
 			{
 				EncryptionMode.XSalsa20Poly1305 => HEADER_SIZE + encryptedLength,
 				EncryptionMode.XSalsa20Poly1305Suffix => HEADER_SIZE + encryptedLength + Interop.SodiumNonceSize,
 				EncryptionMode.XSalsa20Poly1305Lite => HEADER_SIZE + encryptedLength + 4,
 				_ => throw new ArgumentException("Unsupported encryption mode.", nameof(encryptionMode)),
 			};
-		}
 
 		/// <summary>
 		/// Gets the data from packet.
 		/// </summary>
 		/// <param name="packet">The packet.</param>
 		/// <param name="data">The data.</param>
 		/// <param name="encryptionMode">The encryption mode.</param>
 		public void GetDataFromPacket(ReadOnlySpan<byte> packet, out ReadOnlySpan<byte> data, EncryptionMode encryptionMode)
 		{
 			switch (encryptionMode)
 			{
 				case EncryptionMode.XSalsa20Poly1305:
 					data = packet[HEADER_SIZE..];
 					return;
 
 				case EncryptionMode.XSalsa20Poly1305Suffix:
 					data = packet.Slice(HEADER_SIZE, packet.Length - HEADER_SIZE - Interop.SodiumNonceSize);
 					return;
 
 				case EncryptionMode.XSalsa20Poly1305Lite:
 					data = packet.Slice(HEADER_SIZE, packet.Length - HEADER_SIZE - 4);
 					break;
 
 				default:
 					throw new ArgumentException("Unsupported encryption mode.", nameof(encryptionMode));
 			}
 		}
 
 		/// <summary>
 		/// Disposes the Rtp.
 		/// </summary>
 		public void Dispose()
 		{
 
 		}
 	}
 }
diff --git a/DisCatSharp.VoiceNext/VoiceNextConfiguration.cs b/DisCatSharp.VoiceNext/VoiceNextConfiguration.cs
index 540143420..1324c9354 100644
--- a/DisCatSharp.VoiceNext/VoiceNextConfiguration.cs
+++ b/DisCatSharp.VoiceNext/VoiceNextConfiguration.cs
@@ -1,66 +1,66 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.VoiceNext
 {
 	/// <summary>
 	/// VoiceNext client configuration.
 	/// </summary>
 	public sealed class VoiceNextConfiguration
 	{
 		/// <summary>
 		/// <para>Sets the audio format for Opus. This will determine the quality of the audio output.</para>
 		/// <para>Defaults to <see cref="AudioFormat.Default"/>.</para>
 		/// </summary>
 		public AudioFormat AudioFormat { internal get; set; } = AudioFormat.Default;
 
 		/// <summary>
 		/// <para>Sets whether incoming voice receiver should be enabled.</para>
 		/// <para>Defaults to false.</para>
 		/// </summary>
-		public bool EnableIncoming { internal get; set; } = false;
+		public bool EnableIncoming { internal get; set; }
 
 		/// <summary>
 		/// <para>Sets the size of the packet queue.</para>
 		/// <para>Defaults to 25 or ~500ms.</para>
 		/// </summary>
 		public int PacketQueueSize { internal get; set; } = 25;
 
 		/// <summary>
 		/// Creates a new instance of <see cref="VoiceNextConfiguration"/>.
 		/// </summary>
 		[ActivatorUtilitiesConstructor]
 		public VoiceNextConfiguration() { }
 
 		/// <summary>
 		/// Creates a new instance of <see cref="VoiceNextConfiguration"/>, copying the properties of another configuration.
 		/// </summary>
 		/// <param name="other">Configuration the properties of which are to be copied.</param>
 		public VoiceNextConfiguration(VoiceNextConfiguration other)
 		{
 			this.AudioFormat = new AudioFormat(other.AudioFormat.SampleRate, other.AudioFormat.ChannelCount, other.AudioFormat.VoiceApplication);
 			this.EnableIncoming = other.EnableIncoming;
 		}
 	}
 }
diff --git a/DisCatSharp.VoiceNext/VoiceNextConnection.cs b/DisCatSharp.VoiceNext/VoiceNextConnection.cs
index 74d7dc82f..eb8141c70 100644
--- a/DisCatSharp.VoiceNext/VoiceNextConnection.cs
+++ b/DisCatSharp.VoiceNext/VoiceNextConnection.cs
@@ -1,1352 +1,1352 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Buffers;
 using System.Buffers.Binary;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Channels;
 using System.Threading.Tasks;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Udp;
 using DisCatSharp.Net.WebSocket;
 using DisCatSharp.VoiceNext.Codec;
 using DisCatSharp.VoiceNext.Entities;
 using DisCatSharp.VoiceNext.EventArgs;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.VoiceNext
 {
 	internal delegate Task VoiceDisconnectedEventHandler(DiscordGuild guild);
 
 	/// <summary>
 	/// VoiceNext connection to a voice channel.
 	/// </summary>
 	public sealed class VoiceNextConnection : IDisposable
 	{
 		/// <summary>
 		/// Triggered whenever a user speaks in the connected voice channel.
 		/// </summary>
 		public event AsyncEventHandler<VoiceNextConnection, UserSpeakingEventArgs> UserSpeaking
 		{
-			add { this._userSpeaking.Register(value); }
-			remove { this._userSpeaking.Unregister(value); }
+			add => this._userSpeaking.Register(value);
+			remove => this._userSpeaking.Unregister(value);
 		}
 		private readonly AsyncEvent<VoiceNextConnection, UserSpeakingEventArgs> _userSpeaking;
 
 		/// <summary>
 		/// Triggered whenever a user joins voice in the connected guild.
 		/// </summary>
 		public event AsyncEventHandler<VoiceNextConnection, VoiceUserJoinEventArgs> UserJoined
 		{
-			add { this._userJoined.Register(value); }
-			remove { this._userJoined.Unregister(value); }
+			add => this._userJoined.Register(value);
+			remove => this._userJoined.Unregister(value);
 		}
 		private readonly AsyncEvent<VoiceNextConnection, VoiceUserJoinEventArgs> _userJoined;
 
 		/// <summary>
 		/// Triggered whenever a user leaves voice in the connected guild.
 		/// </summary>
 		public event AsyncEventHandler<VoiceNextConnection, VoiceUserLeaveEventArgs> UserLeft
 		{
-			add { this._userLeft.Register(value); }
-			remove { this._userLeft.Unregister(value); }
+			add => this._userLeft.Register(value);
+			remove => this._userLeft.Unregister(value);
 		}
 		private readonly AsyncEvent<VoiceNextConnection, VoiceUserLeaveEventArgs> _userLeft;
 
 		/// <summary>
 		/// Triggered whenever voice data is received from the connected voice channel.
 		/// </summary>
 		public event AsyncEventHandler<VoiceNextConnection, VoiceReceiveEventArgs> VoiceReceived
 		{
-			add { this._voiceReceived.Register(value); }
-			remove { this._voiceReceived.Unregister(value); }
+			add => this._voiceReceived.Register(value);
+			remove => this._voiceReceived.Unregister(value);
 		}
 		private readonly AsyncEvent<VoiceNextConnection, VoiceReceiveEventArgs> _voiceReceived;
 
 		/// <summary>
 		/// Triggered whenever voice WebSocket throws an exception.
 		/// </summary>
 		public event AsyncEventHandler<VoiceNextConnection, SocketErrorEventArgs> VoiceSocketErrored
 		{
-			add { this._voiceSocketError.Register(value); }
-			remove { this._voiceSocketError.Unregister(value); }
+			add => this._voiceSocketError.Register(value);
+			remove => this._voiceSocketError.Unregister(value);
 		}
 		private readonly AsyncEvent<VoiceNextConnection, SocketErrorEventArgs> _voiceSocketError;
 
 		internal event VoiceDisconnectedEventHandler VoiceDisconnected;
 
 		/// <summary>
 		/// Gets the unix epoch.
 		/// </summary>
-		private static DateTimeOffset s_unixEpoch { get; } = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero);
+		private static DateTimeOffset s_unixEpoch { get; } = new(1970, 1, 1, 0, 0, 0, TimeSpan.Zero);
 
 		/// <summary>
 		/// Gets the discord.
 		/// </summary>
 		private readonly DiscordClient _discord;
 
 		/// <summary>
 		/// Gets the guild.
 		/// </summary>
 		private readonly DiscordGuild _guild;
 
 		/// <summary>
 		/// Gets the transmitting s s r cs.
 		/// </summary>
 		private readonly ConcurrentDictionary<uint, AudioSender> _transmittingSsrCs;
 
 		/// <summary>
 		/// Gets the udp client.
 		/// </summary>
 		private readonly BaseUdpClient _udpClient;
 
 		/// <summary>
 		/// Gets or sets the voice ws.
 		/// </summary>
 		private IWebSocketClient _voiceWs;
 
 		/// <summary>
 		/// Gets or sets the heartbeat task.
 		/// </summary>
 		private Task _heartbeatTask;
 
 		/// <summary>
 		/// Gets or sets the heartbeat interval.
 		/// </summary>
 		private int _heartbeatInterval;
 
 		/// <summary>
 		/// Gets or sets the last heartbeat.
 		/// </summary>
 		private DateTimeOffset _lastHeartbeat;
 
 		/// <summary>
 		/// Gets or sets the token source.
 		/// </summary>
 		private CancellationTokenSource _tokenSource;
 		/// <summary>
 		/// Gets the token.
 		/// </summary>
 		private CancellationToken TOKEN
 			=> this._tokenSource.Token;
 
 		/// <summary>
 		/// Gets or sets the server data.
 		/// </summary>
 		internal VoiceServerUpdatePayload ServerData { get; set; }
 		/// <summary>
 		/// Gets or sets the state data.
 		/// </summary>
 		internal VoiceStateUpdatePayload StateData { get; set; }
 		/// <summary>
 		/// Gets or sets a value indicating whether resume.
 		/// </summary>
 		internal bool Resume { get; set; }
 
 		/// <summary>
 		/// Gets the configuration.
 		/// </summary>
 		private readonly VoiceNextConfiguration _configuration;
 
 		/// <summary>
 		/// Gets or sets the opus.
 		/// </summary>
 		private Opus _opus;
 
 		/// <summary>
 		/// Gets or sets the sodium.
 		/// </summary>
 		private Sodium _sodium;
 
 		/// <summary>
 		/// Gets or sets the rtp.
 		/// </summary>
 		private Rtp _rtp;
 
 		/// <summary>
 		/// Gets or sets the selected encryption mode.
 		/// </summary>
 		private EncryptionMode _selectedEncryptionMode;
 		/// <summary>
 		/// Gets or sets the nonce.
 		/// </summary>
-		private uint _nonce = 0;
+		private uint _nonce;
 
 		/// <summary>
 		/// Gets or sets the sequence.
 		/// </summary>
 		private ushort _sequence;
 
 		/// <summary>
 		/// Gets or sets the timestamp.
 		/// </summary>
 		private uint _timestamp;
 
 		/// <summary>
 		/// Gets or sets the s s r c.
 		/// </summary>
 		private uint _ssrc;
 
 		/// <summary>
 		/// Gets or sets the key.
 		/// </summary>
 		private byte[] _key;
 
 		/// <summary>
 		/// Gets or sets the discovered endpoint.
 		/// </summary>
 		private IpEndpoint _discoveredEndpoint;
 		/// <summary>
 		/// Gets or sets the web socket endpoint.
 		/// </summary>
 		internal ConnectionEndpoint WebSocketEndpoint { get; set; }
 		/// <summary>
 		/// Gets or sets the udp endpoint.
 		/// </summary>
 		internal ConnectionEndpoint UdpEndpoint { get; set; }
 
 		/// <summary>
 		/// Gets or sets the ready wait.
 		/// </summary>
 		private readonly TaskCompletionSource<bool> _readyWait;
 
 		/// <summary>
 		/// Gets or sets a value indicating whether is initialized.
 		/// </summary>
 		private bool _isInitialized;
 
 		/// <summary>
 		/// Gets or sets a value indicating whether is disposed.
 		/// </summary>
 		private bool _isDisposed;
 
 		/// <summary>
 		/// Gets or sets the playing wait.
 		/// </summary>
 		private TaskCompletionSource<bool> _playingWait;
 
 		/// <summary>
 		/// Gets the pause event.
 		/// </summary>
 		private readonly AsyncManualResetEvent _pauseEvent;
 
 		/// <summary>
 		/// Gets or sets the transmit stream.
 		/// </summary>
 		private VoiceTransmitSink _transmitStream;
 
 		/// <summary>
 		/// Gets the transmit channel.
 		/// </summary>
 		private readonly Channel<RawVoicePacket> _transmitChannel;
 
 		/// <summary>
 		/// Gets the keepalive timestamps.
 		/// </summary>
 		private readonly ConcurrentDictionary<ulong, long> _keepaliveTimestamps;
-		private ulong _lastKeepalive = 0;
+		private ulong _lastKeepalive;
 
 		/// <summary>
 		/// Gets or sets the sender task.
 		/// </summary>
 		private Task _senderTask;
 
 		/// <summary>
 		/// Gets or sets the sender token source.
 		/// </summary>
 		private CancellationTokenSource _senderTokenSource;
 		/// <summary>
 		/// Gets the sender token.
 		/// </summary>
 		private CancellationToken SENDER_TOKEN
 			=> this._senderTokenSource.Token;
 
 		/// <summary>
 		/// Gets or sets the receiver task.
 		/// </summary>
 		private Task _receiverTask;
 
 		/// <summary>
 		/// Gets or sets the receiver token source.
 		/// </summary>
 		private CancellationTokenSource _receiverTokenSource;
 		/// <summary>
 		/// Gets the receiver token.
 		/// </summary>
 		private CancellationToken RECEIVER_TOKEN
 			=> this._receiverTokenSource.Token;
 
 		/// <summary>
 		/// Gets or sets the keepalive task.
 		/// </summary>
 		private Task _keepaliveTask;
 
 		/// <summary>
 		/// Gets or sets the keepalive token source.
 		/// </summary>
 		private CancellationTokenSource _keepaliveTokenSource;
 		/// <summary>
 		/// Gets the keepalive token.
 		/// </summary>
 		private CancellationToken KEEPALIVE_TOKEN
 			=> this._keepaliveTokenSource.Token;
 
-		private volatile bool _isSpeaking = false;
+		private volatile bool _isSpeaking;
 
 		/// <summary>
 		/// Gets the audio format used by the Opus encoder.
 		/// </summary>
 		public AudioFormat AudioFormat => this._configuration.AudioFormat;
 
 		/// <summary>
 		/// Gets whether this connection is still playing audio.
 		/// </summary>
 		public bool IsPlaying
 			=> this._playingWait != null && !this._playingWait.Task.IsCompleted;
 
 		/// <summary>
 		/// Gets the websocket round-trip time in ms.
 		/// </summary>
 		public int WebSocketPing
 			=> Volatile.Read(ref this._wsPing);
-		private int _wsPing = 0;
+		private int _wsPing;
 
 		/// <summary>
 		/// Gets the UDP round-trip time in ms.
 		/// </summary>
 		public int UdpPing
 			=> Volatile.Read(ref this._udpPing);
-		private int _udpPing = 0;
+		private int _udpPing;
 
 		private int _queueCount;
 
 		/// <summary>
 		/// Gets the channel this voice client is connected to.
 		/// </summary>
 		public DiscordChannel TargetChannel { get; internal set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="VoiceNextConnection"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="guild">The guild.</param>
 		/// <param name="channel">The channel.</param>
 		/// <param name="config">The config.</param>
 		/// <param name="server">The server.</param>
 		/// <param name="state">The state.</param>
 		internal VoiceNextConnection(DiscordClient client, DiscordGuild guild, DiscordChannel channel, VoiceNextConfiguration config, VoiceServerUpdatePayload server, VoiceStateUpdatePayload state)
 		{
 			this._discord = client;
 			this._guild = guild;
 			this.TargetChannel = channel;
 			this._transmittingSsrCs = new ConcurrentDictionary<uint, AudioSender>();
 
 			this._userSpeaking = new AsyncEvent<VoiceNextConnection, UserSpeakingEventArgs>("VNEXT_USER_SPEAKING", TimeSpan.Zero, this._discord.EventErrorHandler);
 			this._userJoined = new AsyncEvent<VoiceNextConnection, VoiceUserJoinEventArgs>("VNEXT_USER_JOINED", TimeSpan.Zero, this._discord.EventErrorHandler);
 			this._userLeft = new AsyncEvent<VoiceNextConnection, VoiceUserLeaveEventArgs>("VNEXT_USER_LEFT", TimeSpan.Zero, this._discord.EventErrorHandler);
 			this._voiceReceived = new AsyncEvent<VoiceNextConnection, VoiceReceiveEventArgs>("VNEXT_VOICE_RECEIVED", TimeSpan.Zero, this._discord.EventErrorHandler);
 			this._voiceSocketError = new AsyncEvent<VoiceNextConnection, SocketErrorEventArgs>("VNEXT_WS_ERROR", TimeSpan.Zero, this._discord.EventErrorHandler);
 			this._tokenSource = new CancellationTokenSource();
 
 			this._configuration = config;
 			this._isInitialized = false;
 			this._isDisposed = false;
 			this._opus = new Opus(this.AudioFormat);
 			//this.Sodium = new Sodium();
 			this._rtp = new Rtp();
 
 			this.ServerData = server;
 			this.StateData = state;
 
 			var eps = this.ServerData.Endpoint;
 			var epi = eps.LastIndexOf(':');
 			var eph = string.Empty;
 			var epp = 443;
 			if (epi != -1)
 			{
 				eph = eps[..epi];
 				epp = int.Parse(eps[(epi + 1)..]);
 			}
 			else
 			{
 				eph = eps;
 			}
 			this.WebSocketEndpoint = new ConnectionEndpoint { Hostname = eph, Port = epp };
 
 			this._readyWait = new TaskCompletionSource<bool>();
 
 			this._playingWait = null;
 			this._transmitChannel = Channel.CreateBounded<RawVoicePacket>(new BoundedChannelOptions(this._configuration.PacketQueueSize));
 			this._keepaliveTimestamps = new ConcurrentDictionary<ulong, long>();
 			this._pauseEvent = new AsyncManualResetEvent(true);
 
 			this._udpClient = this._discord.Configuration.UdpClientFactory();
 			this._voiceWs = this._discord.Configuration.WebSocketClientFactory(this._discord.Configuration.Proxy, this._discord.ServiceProvider);
 			this._voiceWs.Disconnected += this.VoiceWS_SocketClosed;
 			this._voiceWs.MessageReceived += this.VoiceWS_SocketMessage;
 			this._voiceWs.Connected += this.VoiceWS_SocketOpened;
 			this._voiceWs.ExceptionThrown += this.VoiceWs_SocketException;
 		}
 
 		~VoiceNextConnection()
 		{
 			this.Dispose();
 		}
 
 		/// <summary>
 		/// Connects to the specified voice channel.
 		/// </summary>
 		/// <returns>A task representing the connection operation.</returns>
 		internal Task ConnectAsync()
 		{
 			var gwuri = new UriBuilder
 			{
 				Scheme = "wss",
 				Host = this.WebSocketEndpoint.Hostname,
 				Query = "encoding=json&v=4"
 			};
 
 			return this._voiceWs.ConnectAsync(gwuri.Uri);
 		}
 
 		/// <summary>
 		/// Reconnects .
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal Task ReconnectAsync()
 			=> this._voiceWs.DisconnectAsync();
 
 		/// <summary>
 		/// Starts .
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task StartAsync()
 		{
 			// Let's announce our intentions to the server
 			var vdp = new VoiceDispatch();
 
 			if (!this.Resume)
 			{
 				vdp.OpCode = 0;
 				vdp.Payload = new VoiceIdentifyPayload
 				{
 					ServerId = this.ServerData.GuildId,
 					UserId = this.StateData.UserId.Value,
 					SessionId = this.StateData.SessionId,
 					Token = this.ServerData.Token
 				};
 				this.Resume = true;
 			}
 			else
 			{
 				vdp.OpCode = 7;
 				vdp.Payload = new VoiceIdentifyPayload
 				{
 					ServerId = this.ServerData.GuildId,
 					SessionId = this.StateData.SessionId,
 					Token = this.ServerData.Token
 				};
 			}
 			var vdj = JsonConvert.SerializeObject(vdp, Formatting.None);
 			await this.WsSendAsync(vdj).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Waits the for ready async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal Task WaitForReadyAsync()
 			=> this._readyWait.Task;
 
 		/// <summary>
 		/// Enqueues the packet async.
 		/// </summary>
 		/// <param name="packet">The packet.</param>
 		/// <param name="token">The token.</param>
 		/// <returns>A Task.</returns>
 		internal async Task EnqueuePacketAsync(RawVoicePacket packet, CancellationToken token = default)
 		{
 			await this._transmitChannel.Writer.WriteAsync(packet, token).ConfigureAwait(false);
 			this._queueCount++;
 		}
 
 		/// <summary>
 		/// Prepares the packet.
 		/// </summary>
 		/// <param name="pcm">The pcm.</param>
 		/// <param name="target">The target.</param>
 		/// <param name="length">The length.</param>
 		/// <returns>A bool.</returns>
 		internal bool PreparePacket(ReadOnlySpan<byte> pcm, out byte[] target, out int length)
 		{
 			target = null;
 			length = 0;
 
 			if (this._isDisposed)
 				return false;
 
 			var audioFormat = this.AudioFormat;
 
 			var packetArray = ArrayPool<byte>.Shared.Rent(this._rtp.CalculatePacketSize(audioFormat.SampleCountToSampleSize(audioFormat.CalculateMaximumFrameSize()), this._selectedEncryptionMode));
 			var packet = packetArray.AsSpan();
 
 			this._rtp.EncodeHeader(this._sequence, this._timestamp, this._ssrc, packet);
 			var opus = packet.Slice(Rtp.HEADER_SIZE, pcm.Length);
 			this._opus.Encode(pcm, ref opus);
 
 			this._sequence++;
 			this._timestamp += (uint)audioFormat.CalculateFrameSize(audioFormat.CalculateSampleDuration(pcm.Length));
 
 			Span<byte> nonce = stackalloc byte[Sodium.NonceSize];
 			switch (this._selectedEncryptionMode)
 			{
 				case EncryptionMode.XSalsa20Poly1305:
 					this._sodium.GenerateNonce(packet[..Rtp.HEADER_SIZE], nonce);
 					break;
 
 				case EncryptionMode.XSalsa20Poly1305Suffix:
 					this._sodium.GenerateNonce(nonce);
 					break;
 
 				case EncryptionMode.XSalsa20Poly1305Lite:
 					this._sodium.GenerateNonce(this._nonce++, nonce);
 					break;
 
 				default:
 					ArrayPool<byte>.Shared.Return(packetArray);
 					throw new Exception("Unsupported encryption mode.");
 			}
 
 			Span<byte> encrypted = stackalloc byte[Sodium.CalculateTargetSize(opus)];
 			this._sodium.Encrypt(opus, encrypted, nonce);
 			encrypted.CopyTo(packet[Rtp.HEADER_SIZE..]);
 			packet = packet[..this._rtp.CalculatePacketSize(encrypted.Length, this._selectedEncryptionMode)];
 			this._sodium.AppendNonce(nonce, packet, this._selectedEncryptionMode);
 
 			target = packetArray;
 			length = packet.Length;
 			return true;
 		}
 
 		/// <summary>
 		/// Voices the sender task.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		private async Task VoiceSenderTask()
 		{
 			var token = this.SENDER_TOKEN;
 			var client = this._udpClient;
 			var reader = this._transmitChannel.Reader;
 
 			byte[] data = null;
 			var length = 0;
 
 			var synchronizerTicks = (double)Stopwatch.GetTimestamp();
 			var synchronizerResolution = Stopwatch.Frequency * 0.005;
 			var tickResolution = 10_000_000.0 / Stopwatch.Frequency;
 			this._discord.Logger.LogDebug(VoiceNextEvents.Misc, "Timer accuracy: {0}/{1} (high resolution? {2})", Stopwatch.Frequency, synchronizerResolution, Stopwatch.IsHighResolution);
 
 			while (!token.IsCancellationRequested)
 			{
 				await this._pauseEvent.WaitAsync().ConfigureAwait(false);
 
 				var hasPacket = reader.TryRead(out var rawPacket);
 				if (hasPacket)
 				{
 					this._queueCount--;
 
 					if (this._playingWait == null || this._playingWait.Task.IsCompleted)
 						this._playingWait = new TaskCompletionSource<bool>();
 				}
 
 				// Provided by Laura#0090 (214796473689178133); this is Python, but adaptable:
 				//
 				// delay = max(0, self.delay + ((start_time + self.delay * loops) + - time.time()))
 				//
 				// self.delay
 				//   sample size
 				// start_time
 				//   time since streaming started
 				// loops
 				//   number of samples sent
 				// time.time()
 				//   DateTime.Now
 
 				if (hasPacket)
 				{
 					hasPacket = this.PreparePacket(rawPacket.Bytes.Span, out data, out length);
 					if (rawPacket.RentedBuffer != null)
 						ArrayPool<byte>.Shared.Return(rawPacket.RentedBuffer);
 				}
 
 				var durationModifier = hasPacket ? rawPacket.Duration / 5 : 4;
 				var cts = Math.Max(Stopwatch.GetTimestamp() - synchronizerTicks, 0);
 				if (cts < synchronizerResolution * durationModifier)
 					await Task.Delay(TimeSpan.FromTicks((long)(((synchronizerResolution * durationModifier) - cts) * tickResolution))).ConfigureAwait(false);
 
 				synchronizerTicks += synchronizerResolution * durationModifier;
 
 				if (!hasPacket)
 					continue;
 
 				await this.SendSpeakingAsync(true).ConfigureAwait(false);
 				await client.SendAsync(data, length).ConfigureAwait(false);
 				ArrayPool<byte>.Shared.Return(data);
 
 				if (!rawPacket.Silence && this._queueCount == 0)
 				{
 					var nullpcm = new byte[this.AudioFormat.CalculateSampleSize(20)];
 					for (var i = 0; i < 3; i++)
 					{
 						var nullpacket = new byte[nullpcm.Length];
 						var nullpacketmem = nullpacket.AsMemory();
 						await this.EnqueuePacketAsync(new RawVoicePacket(nullpacketmem, 20, true)).ConfigureAwait(false);
 					}
 				}
 				else if (this._queueCount == 0)
 				{
 					await this.SendSpeakingAsync(false).ConfigureAwait(false);
 					this._playingWait?.SetResult(true);
 				}
 			}
 		}
 
 		/// <summary>
 		/// Processes the packet.
 		/// </summary>
 		/// <param name="data">The data.</param>
 		/// <param name="opus">The opus.</param>
 		/// <param name="pcm">The pcm.</param>
 		/// <param name="pcmPackets">The pcm packets.</param>
 		/// <param name="voiceSender">The voice sender.</param>
 		/// <param name="outputFormat">The output format.</param>
 		/// <returns>A bool.</returns>
 		private bool ProcessPacket(ReadOnlySpan<byte> data, ref Memory<byte> opus, ref Memory<byte> pcm, IList<ReadOnlyMemory<byte>> pcmPackets, out AudioSender voiceSender, out AudioFormat outputFormat)
 		{
 			voiceSender = null;
 			outputFormat = default;
 
 			if (!this._rtp.IsRtpHeader(data))
 				return false;
 
 			this._rtp.DecodeHeader(data, out var sequence, out var timestamp, out var ssrc, out var hasExtension);
 
 			if (!this._transmittingSsrCs.TryGetValue(ssrc, out var vtx))
 			{
 				var decoder = this._opus.CreateDecoder();
 
 				vtx = new AudioSender(ssrc, decoder)
 				{
 					// user isn't present as we haven't received a speaking event yet.
 					User = null
 				};
 			}
 
 			voiceSender = vtx;
 			if (sequence <= vtx.LastSequence) // out-of-order packet; discard
 				return false;
 			var gap = vtx.LastSequence != 0 ? sequence - 1 - vtx.LastSequence : 0;
 
 			if (gap >= 5)
 				this._discord.Logger.LogWarning(VoiceNextEvents.VoiceReceiveFailure, "5 or more voice packets were dropped when receiving");
 
 			Span<byte> nonce = stackalloc byte[Sodium.NonceSize];
 			this._sodium.GetNonce(data, nonce, this._selectedEncryptionMode);
 			this._rtp.GetDataFromPacket(data, out var encryptedOpus, this._selectedEncryptionMode);
 
 			var opusSize = Sodium.CalculateSourceSize(encryptedOpus);
 			opus = opus[..opusSize];
 			var opusSpan = opus.Span;
 			try
 			{
 				this._sodium.Decrypt(encryptedOpus, opusSpan, nonce);
 
 				// Strip extensions, if any
 				if (hasExtension)
 				{
 					// RFC 5285, 4.2 One-Byte header
 					// http://www.rfcreader.com/#rfc5285_line186
 					if (opusSpan[0] == 0xBE && opusSpan[1] == 0xDE)
 					{
 						var headerLen = (opusSpan[2] << 8) | opusSpan[3];
 						var i = 4;
 						for (; i < headerLen + 4; i++)
 						{
 							var @byte = opusSpan[i];
 
 							// ID is currently unused since we skip it anyway
 							//var id = (byte)(@byte >> 4);
 							var length = (byte)(@byte & 0x0F) + 1;
 
 							i += length;
 						}
 
 						// Strip extension padding too
 						while (opusSpan[i] == 0)
 							i++;
 
 						opusSpan = opusSpan[i..];
 					}
 
 					// TODO: consider implementing RFC 5285, 4.3. Two-Byte Header
 				}
 
 				if (opusSpan[0] == 0x90)
 				{
 					// I'm not 100% sure what this header is/does, however removing the data causes no
 					// real issues, and has the added benefit of removing a lot of noise.
 					opusSpan = opusSpan[2..];
 				}
 
 				if (gap == 1)
 				{
 					var lastSampleCount = this._opus.GetLastPacketSampleCount(vtx.Decoder);
 					var fecpcm = new byte[this.AudioFormat.SampleCountToSampleSize(lastSampleCount)];
 					var fecpcmMem = fecpcm.AsSpan();
 					this._opus.Decode(vtx.Decoder, opusSpan, ref fecpcmMem, true, out _);
 					pcmPackets.Add(fecpcm.AsMemory(0, fecpcmMem.Length));
 				}
 				else if (gap > 1)
 				{
 					var lastSampleCount = this._opus.GetLastPacketSampleCount(vtx.Decoder);
 					for (var i = 0; i < gap; i++)
 					{
 						var fecpcm = new byte[this.AudioFormat.SampleCountToSampleSize(lastSampleCount)];
 						var fecpcmMem = fecpcm.AsSpan();
 						this._opus.ProcessPacketLoss(vtx.Decoder, lastSampleCount, ref fecpcmMem);
 						pcmPackets.Add(fecpcm.AsMemory(0, fecpcmMem.Length));
 					}
 				}
 
 				var pcmSpan = pcm.Span;
 				this._opus.Decode(vtx.Decoder, opusSpan, ref pcmSpan, false, out outputFormat);
 				pcm = pcm[..pcmSpan.Length];
 			}
 			finally
 			{
 				vtx.LastSequence = sequence;
 			}
 
 			return true;
 		}
 
 		/// <summary>
 		/// Processes the voice packet.
 		/// </summary>
 		/// <param name="data">The data.</param>
 		/// <returns>A Task.</returns>
 		private async Task ProcessVoicePacket(byte[] data)
 		{
 			if (data.Length < 13) // minimum packet length
 				return;
 
 			try
 			{
 				var pcm = new byte[this.AudioFormat.CalculateMaximumFrameSize()];
 				var pcmMem = pcm.AsMemory();
 				var opus = new byte[pcm.Length];
 				var opusMem = opus.AsMemory();
 				var pcmFillers = new List<ReadOnlyMemory<byte>>();
 				if (!this.ProcessPacket(data, ref opusMem, ref pcmMem, pcmFillers, out var vtx, out var audioFormat))
 					return;
 
 				foreach (var pcmFiller in pcmFillers)
 					await this._voiceReceived.InvokeAsync(this, new VoiceReceiveEventArgs(this._discord.ServiceProvider)
 					{
 						Ssrc = vtx.Ssrc,
 						User = vtx.User,
 						PcmData = pcmFiller,
 						OpusData = new byte[0].AsMemory(),
 						AudioFormat = audioFormat,
 						AudioDuration = audioFormat.CalculateSampleDuration(pcmFiller.Length)
 					}).ConfigureAwait(false);
 
 				await this._voiceReceived.InvokeAsync(this, new VoiceReceiveEventArgs(this._discord.ServiceProvider)
 				{
 					Ssrc = vtx.Ssrc,
 					User = vtx.User,
 					PcmData = pcmMem,
 					OpusData = opusMem,
 					AudioFormat = audioFormat,
 					AudioDuration = audioFormat.CalculateSampleDuration(pcmMem.Length)
 				}).ConfigureAwait(false);
 			}
 			catch (Exception ex)
 			{
 				this._discord.Logger.LogError(VoiceNextEvents.VoiceReceiveFailure, ex, "Exception occurred when decoding incoming audio data");
 			}
 		}
 
 		/// <summary>
 		/// Processes the keepalive.
 		/// </summary>
 		/// <param name="data">The data.</param>
 		private void ProcessKeepalive(byte[] data)
 		{
 			try
 			{
 				var keepalive = BinaryPrimitives.ReadUInt64LittleEndian(data);
 
 				if (!this._keepaliveTimestamps.TryRemove(keepalive, out var timestamp))
 					return;
 
 				var tdelta = (int)((Stopwatch.GetTimestamp() - timestamp) / (double)Stopwatch.Frequency * 1000);
 				this._discord.Logger.LogDebug(VoiceNextEvents.VoiceKeepalive, "Received UDP keepalive {0} (ping {1}ms)", keepalive, tdelta);
 				Volatile.Write(ref this._udpPing, tdelta);
 			}
 			catch (Exception ex)
 			{
 				this._discord.Logger.LogError(VoiceNextEvents.VoiceKeepalive, ex, "Exception occurred when handling keepalive");
 			}
 		}
 
 		/// <summary>
 		/// Udps the receiver task.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		private async Task UdpReceiverTask()
 		{
 			var token = this.RECEIVER_TOKEN;
 			var client = this._udpClient;
 
 			while (!token.IsCancellationRequested)
 			{
 				var data = await client.ReceiveAsync().ConfigureAwait(false);
 				if (data.Length == 8)
 					this.ProcessKeepalive(data);
 				else if (this._configuration.EnableIncoming)
 					await this.ProcessVoicePacket(data).ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Sends a speaking status to the connected voice channel.
 		/// </summary>
 		/// <param name="speaking">Whether the current user is speaking or not.</param>
 		/// <returns>A task representing the sending operation.</returns>
 		public async Task SendSpeakingAsync(bool speaking = true)
 		{
 			if (!this._isInitialized)
 				throw new InvalidOperationException("The connection is not initialized");
 
 			if (this._isSpeaking != speaking)
 			{
 				this._isSpeaking = speaking;
 				var pld = new VoiceDispatch
 				{
 					OpCode = 5,
 					Payload = new VoiceSpeakingPayload
 					{
 						Speaking = speaking,
 						Delay = 0
 					}
 				};
 
 				var plj = JsonConvert.SerializeObject(pld, Formatting.None);
 				await this.WsSendAsync(plj).ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Gets a transmit stream for this connection, optionally specifying a packet size to use with the stream. If a stream is already configured, it will return the existing one.
 		/// </summary>
 		/// <param name="sampleDuration">Duration, in ms, to use for audio packets.</param>
 		/// <returns>Transmit stream.</returns>
 		public VoiceTransmitSink GetTransmitSink(int sampleDuration = 20)
 		{
 			if (!AudioFormat.AllowedSampleDurations.Contains(sampleDuration))
 				throw new ArgumentOutOfRangeException(nameof(sampleDuration), "Invalid PCM sample duration specified.");
 
 			if (this._transmitStream == null)
 				this._transmitStream = new VoiceTransmitSink(this, sampleDuration);
 
 			return this._transmitStream;
 		}
 
 		/// <summary>
 		/// Asynchronously waits for playback to be finished. Playback is finished when speaking = false is signalled.
 		/// </summary>
 		/// <returns>A task representing the waiting operation.</returns>
 		public async Task WaitForPlaybackFinishAsync()
 		{
 			if (this._playingWait != null)
 				await this._playingWait.Task.ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Pauses playback.
 		/// </summary>
 		public void Pause()
 			=> this._pauseEvent.Reset();
 
 		/// <summary>
 		/// Asynchronously resumes playback.
 		/// </summary>
 		/// <returns></returns>
 		public async Task ResumeAsync()
 			=> await this._pauseEvent.SetAsync().ConfigureAwait(false);
 
 		/// <summary>
 		/// Disconnects and disposes this voice connection.
 		/// </summary>
 		public void Disconnect()
 			=> this.Dispose();
 
 		/// <summary>
 		/// Disconnects and disposes this voice connection.
 		/// </summary>
 		public void Dispose()
 		{
 			if (this._isDisposed)
 				return;
 
 			try
 			{
 				this._isDisposed = true;
 				this._isInitialized = false;
 				this._tokenSource?.Cancel();
 				this._senderTokenSource?.Cancel();
 				this._receiverTokenSource?.Cancel();
 			}
 			catch (Exception ex)
 			{
 				this._discord.Logger.LogError(ex, ex.Message);
 			}
 
 			try
 			{
 				this._voiceWs.DisconnectAsync().ConfigureAwait(false).GetAwaiter().GetResult();
 				this._udpClient.Close();
 			}
 			catch { }
 
 			try
 			{
 				this._keepaliveTokenSource?.Cancel();
 				this._tokenSource?.Dispose();
 				this._senderTokenSource?.Dispose();
 				this._receiverTokenSource?.Dispose();
 				this._keepaliveTokenSource?.Dispose();
 				this._opus?.Dispose();
 				this._opus = null;
 				this._sodium?.Dispose();
 				this._sodium = null;
 				this._rtp?.Dispose();
 				this._rtp = null;
 			}
 			catch (Exception ex)
 			{
 				this._discord.Logger.LogError(ex, ex.Message);
 			}
 
 			this.VoiceDisconnected?.Invoke(this._guild);
 		}
 
 		/// <summary>
 		/// Heartbeats .
 		/// </summary>
 		/// <returns>A Task.</returns>
 		private async Task HeartbeatAsync()
 		{
 			await Task.Yield();
 
 			var token = this.TOKEN;
 			while (true)
 			{
 				try
 				{
 					token.ThrowIfCancellationRequested();
 
 					var dt = DateTime.Now;
 					this._discord.Logger.LogTrace(VoiceNextEvents.VoiceHeartbeat, "Sent heartbeat");
 
 					var hbd = new VoiceDispatch
 					{
 						OpCode = 3,
 						Payload = UnixTimestamp(dt)
 					};
 					var hbj = JsonConvert.SerializeObject(hbd);
 					await this.WsSendAsync(hbj).ConfigureAwait(false);
 
 					this._lastHeartbeat = dt;
 					await Task.Delay(this._heartbeatInterval).ConfigureAwait(false);
 				}
 				catch (OperationCanceledException)
 				{
 					return;
 				}
 			}
 		}
 
 		/// <summary>
 		/// Keepalives .
 		/// </summary>
 		/// <returns>A Task.</returns>
 		private async Task KeepaliveAsync()
 		{
 			await Task.Yield();
 
 			var token = this.KEEPALIVE_TOKEN;
 			var client = this._udpClient;
 
 			while (!token.IsCancellationRequested)
 			{
 				var timestamp = Stopwatch.GetTimestamp();
 				var keepalive = Volatile.Read(ref this._lastKeepalive);
 				Volatile.Write(ref this._lastKeepalive, keepalive + 1);
 				this._keepaliveTimestamps.TryAdd(keepalive, timestamp);
 
 				var packet = new byte[8];
 				BinaryPrimitives.WriteUInt64LittleEndian(packet, keepalive);
 
 				await client.SendAsync(packet, packet.Length).ConfigureAwait(false);
 
 				await Task.Delay(5000, token).ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Stage1S .
 		/// </summary>
 		/// <param name="voiceReady">The voice ready.</param>
 		/// <returns>A Task.</returns>
 		private async Task Stage1(VoiceReadyPayload voiceReady)
 		{
 			// IP Discovery
 			this._udpClient.Setup(this.UdpEndpoint);
 
 			var pck = new byte[70];
 			PreparePacket(pck);
 			await this._udpClient.SendAsync(pck, pck.Length).ConfigureAwait(false);
 
 			var ipd = await this._udpClient.ReceiveAsync().ConfigureAwait(false);
 			ReadPacket(ipd, out var ip, out var port);
 			this._discoveredEndpoint = new IpEndpoint
 			{
 				Address = ip,
 				Port = port
 			};
 			this._discord.Logger.LogTrace(VoiceNextEvents.VoiceHandshake, "Endpoint dicovery finished - discovered endpoint is {0}:{1}", ip, port);
 
 			void PreparePacket(byte[] packet)
 			{
 				var ssrc = this._ssrc;
 				var packetSpan = packet.AsSpan();
 				MemoryMarshal.Write(packetSpan, ref ssrc);
 				Helpers.ZeroFill(packetSpan);
 			}
 
 			void ReadPacket(byte[] packet, out System.Net.IPAddress decodedIp, out ushort decodedPort)
 			{
 				var packetSpan = packet.AsSpan();
 
 				var ipString = Utilities.UTF8.GetString(packet, 4, 64 /* 70 - 6 */).TrimEnd('\0');
 				decodedIp = System.Net.IPAddress.Parse(ipString);
 
 				decodedPort = BinaryPrimitives.ReadUInt16LittleEndian(packetSpan[68 /* 70 - 2 */..]);
 			}
 
 			// Select voice encryption mode
 			var selectedEncryptionMode = Sodium.SelectMode(voiceReady.Modes);
 			this._selectedEncryptionMode = selectedEncryptionMode.Value;
 
 			// Ready
 			this._discord.Logger.LogTrace(VoiceNextEvents.VoiceHandshake, "Selected encryption mode is {0}", selectedEncryptionMode.Key);
 			var vsp = new VoiceDispatch
 			{
 				OpCode = 1,
 				Payload = new VoiceSelectProtocolPayload
 				{
 					Protocol = "udp",
 					Data = new VoiceSelectProtocolPayloadData
 					{
 						Address = this._discoveredEndpoint.Address.ToString(),
 						Port = (ushort)this._discoveredEndpoint.Port,
 						Mode = selectedEncryptionMode.Key
 					}
 				}
 			};
 			var vsj = JsonConvert.SerializeObject(vsp, Formatting.None);
 			await this.WsSendAsync(vsj).ConfigureAwait(false);
 
 			this._senderTokenSource = new CancellationTokenSource();
 			this._senderTask = Task.Run(this.VoiceSenderTask, this.SENDER_TOKEN);
 
 			this._receiverTokenSource = new CancellationTokenSource();
 			this._receiverTask = Task.Run(this.UdpReceiverTask, this.RECEIVER_TOKEN);
 		}
 
 		/// <summary>
 		/// Stage2S .
 		/// </summary>
 		/// <param name="voiceSessionDescription">The voice session description.</param>
 		/// <returns>A Task.</returns>
 		private async Task Stage2(VoiceSessionDescriptionPayload voiceSessionDescription)
 		{
 			this._selectedEncryptionMode = Sodium.SupportedModes[voiceSessionDescription.Mode.ToLowerInvariant()];
 			this._discord.Logger.LogTrace(VoiceNextEvents.VoiceHandshake, "Discord updated encryption mode - new mode is {0}", this._selectedEncryptionMode);
 
 			// start keepalive
 			this._keepaliveTokenSource = new CancellationTokenSource();
 			this._keepaliveTask = this.KeepaliveAsync();
 
 			// send 3 packets of silence to get things going
 			var nullpcm = new byte[this.AudioFormat.CalculateSampleSize(20)];
 			for (var i = 0; i < 3; i++)
 			{
 				var nullPcm = new byte[nullpcm.Length];
 				var nullpacketmem = nullPcm.AsMemory();
 				await this.EnqueuePacketAsync(new RawVoicePacket(nullpacketmem, 20, true)).ConfigureAwait(false);
 			}
 
 			this._isInitialized = true;
 			this._readyWait.SetResult(true);
 		}
 
 		/// <summary>
 		/// Handles the dispatch.
 		/// </summary>
 		/// <param name="jo">The jo.</param>
 		/// <returns>A Task.</returns>
 		private async Task HandleDispatch(JObject jo)
 		{
 			var opc = (int)jo["op"];
 			var opp = jo["d"] as JObject;
 
 			switch (opc)
 			{
 				case 2: // READY
 					this._discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received READY (OP2)");
 					var vrp = opp.ToObject<VoiceReadyPayload>();
 					this._ssrc = vrp.Ssrc;
 					this.UdpEndpoint = new ConnectionEndpoint(vrp.Address, vrp.Port);
 					// this is not the valid interval
 					// oh, discord
 					//this.HeartbeatInterval = vrp.HeartbeatInterval;
 					this._heartbeatTask = Task.Run(this.HeartbeatAsync);
 					await this.Stage1(vrp).ConfigureAwait(false);
 					break;
 
 				case 4: // SESSION_DESCRIPTION
 					this._discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received SESSION_DESCRIPTION (OP4)");
 					var vsd = opp.ToObject<VoiceSessionDescriptionPayload>();
 					this._key = vsd.SecretKey;
 					this._sodium = new Sodium(this._key.AsMemory());
 					await this.Stage2(vsd).ConfigureAwait(false);
 					break;
 
 				case 5: // SPEAKING
 						// Don't spam OP5
 						// No longer spam, Discord supposedly doesn't send many of these
 					this._discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received SPEAKING (OP5)");
 					var spd = opp.ToObject<VoiceSpeakingPayload>();
 					var foundUserInCache = this._discord.TryGetCachedUserInternal(spd.UserId.Value, out var resolvedUser);
 					var spk = new UserSpeakingEventArgs(this._discord.ServiceProvider)
 					{
 						Speaking = spd.Speaking,
 						Ssrc = spd.Ssrc.Value,
 						User = resolvedUser,
 					};
 
 					if (foundUserInCache && this._transmittingSsrCs.TryGetValue(spk.Ssrc, out var txssrc5) && txssrc5.Id == 0)
 					{
 						txssrc5.User = spk.User;
 					}
 					else
 					{
 						var opus = this._opus.CreateDecoder();
 						var vtx = new AudioSender(spk.Ssrc, opus)
 						{
 							User = await this._discord.GetUserAsync(spd.UserId.Value).ConfigureAwait(false)
 						};
 
 						if (!this._transmittingSsrCs.TryAdd(spk.Ssrc, vtx))
 							this._opus.DestroyDecoder(opus);
 					}
 
 					await this._userSpeaking.InvokeAsync(this, spk).ConfigureAwait(false);
 					break;
 
 				case 6: // HEARTBEAT ACK
 					var dt = DateTime.Now;
 					var ping = (int)(dt - this._lastHeartbeat).TotalMilliseconds;
 					Volatile.Write(ref this._wsPing, ping);
 					this._discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received HEARTBEAT_ACK (OP6, {0}ms)", ping);
 					this._lastHeartbeat = dt;
 					break;
 
 				case 8: // HELLO
 						// this sends a heartbeat interval that we need to use for heartbeating
 					this._discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received HELLO (OP8)");
 					this._heartbeatInterval = opp["heartbeat_interval"].ToObject<int>();
 					break;
 
 				case 9: // RESUMED
 					this._discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received RESUMED (OP9)");
 					this._heartbeatTask = Task.Run(this.HeartbeatAsync);
 					break;
 
 				case 12: // CLIENT_CONNECTED
 					this._discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received CLIENT_CONNECTED (OP12)");
 					var ujpd = opp.ToObject<VoiceUserJoinPayload>();
 					var usrj = await this._discord.GetUserAsync(ujpd.UserId).ConfigureAwait(false);
 					{
 						var opus = this._opus.CreateDecoder();
 						var vtx = new AudioSender(ujpd.Ssrc, opus)
 						{
 							User = usrj
 						};
 
 						if (!this._transmittingSsrCs.TryAdd(vtx.Ssrc, vtx))
 							this._opus.DestroyDecoder(opus);
 					}
 
 					await this._userJoined.InvokeAsync(this, new VoiceUserJoinEventArgs(this._discord.ServiceProvider) { User = usrj, Ssrc = ujpd.Ssrc }).ConfigureAwait(false);
 					break;
 
 				case 13: // CLIENT_DISCONNECTED
 					this._discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received CLIENT_DISCONNECTED (OP13)");
 					var ulpd = opp.ToObject<VoiceUserLeavePayload>();
 					var txssrc = this._transmittingSsrCs.FirstOrDefault(x => x.Value.Id == ulpd.UserId);
 					if (this._transmittingSsrCs.ContainsKey(txssrc.Key))
 					{
 						this._transmittingSsrCs.TryRemove(txssrc.Key, out var txssrc13);
 						this._opus.DestroyDecoder(txssrc13.Decoder);
 					}
 
 					var usrl = await this._discord.GetUserAsync(ulpd.UserId).ConfigureAwait(false);
 					await this._userLeft.InvokeAsync(this, new VoiceUserLeaveEventArgs(this._discord.ServiceProvider)
 					{
 						User = usrl,
 						Ssrc = txssrc.Key
 					}).ConfigureAwait(false);
 					break;
 
 				default:
 					this._discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received unknown voice opcode (OP{0})", opc);
 					break;
 			}
 		}
 
 		/// <summary>
 		/// Voices the w s_ socket closed.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">The e.</param>
 		/// <returns>A Task.</returns>
 		private async Task VoiceWS_SocketClosed(IWebSocketClient client, SocketCloseEventArgs e)
 		{
 			this._discord.Logger.LogDebug(VoiceNextEvents.VoiceConnectionClose, "Voice WebSocket closed ({0}, '{1}')", e.CloseCode, e.CloseMessage);
 
 			// generally this should not be disposed on all disconnects, only on requested ones
 			// or something
 			// otherwise problems happen
 			//this.Dispose();
 
 			if (e.CloseCode == 4006 || e.CloseCode == 4009)
 				this.Resume = false;
 
 			if (!this._isDisposed)
 			{
 				this._tokenSource.Cancel();
 				this._tokenSource = new CancellationTokenSource();
 				this._voiceWs = this._discord.Configuration.WebSocketClientFactory(this._discord.Configuration.Proxy, this._discord.ServiceProvider);
 				this._voiceWs.Disconnected += this.VoiceWS_SocketClosed;
 				this._voiceWs.MessageReceived += this.VoiceWS_SocketMessage;
 				this._voiceWs.Connected += this.VoiceWS_SocketOpened;
 
 				if (this.Resume) // emzi you dipshit
 					await this.ConnectAsync().ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Voices the w s_ socket message.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">The e.</param>
 		/// <returns>A Task.</returns>
 		private Task VoiceWS_SocketMessage(IWebSocketClient client, SocketMessageEventArgs e)
 		{
 			if (e is not SocketTextMessageEventArgs et)
 			{
 				this._discord.Logger.LogCritical(VoiceNextEvents.VoiceGatewayError, "Discord Voice Gateway sent binary data - unable to process");
 				return Task.CompletedTask;
 			}
 
 			this._discord.Logger.LogTrace(VoiceNextEvents.VoiceWsRx, et.Message);
 			return this.HandleDispatch(JObject.Parse(et.Message));
 		}
 
 		/// <summary>
 		/// Voices the w s_ socket opened.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">The e.</param>
 		/// <returns>A Task.</returns>
 		private Task VoiceWS_SocketOpened(IWebSocketClient client, SocketEventArgs e)
 			=> this.StartAsync();
 
 		/// <summary>
 		/// Voices the ws_ socket exception.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="e">The e.</param>
 		/// <returns>A Task.</returns>
 		private Task VoiceWs_SocketException(IWebSocketClient client, SocketErrorEventArgs e)
 			=> this._voiceSocketError.InvokeAsync(this, new SocketErrorEventArgs(this._discord.ServiceProvider) { Exception = e.Exception });
 
 		/// <summary>
 		/// Ws the send async.
 		/// </summary>
 		/// <param name="payload">The payload.</param>
 		/// <returns>A Task.</returns>
 		private async Task WsSendAsync(string payload)
 		{
 			this._discord.Logger.LogTrace(VoiceNextEvents.VoiceWsTx, payload);
 			await this._voiceWs.SendMessageAsync(payload).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Gets the unix timestamp.
 		/// </summary>
 		/// <param name="dt">The datetine.</param>
 		private static uint UnixTimestamp(DateTime dt)
 		{
 			var ts = dt - s_unixEpoch;
 			var sd = ts.TotalSeconds;
 			var si = (uint)sd;
 			return si;
 		}
 	}
 }
diff --git a/DisCatSharp.VoiceNext/VoiceNextEvents.cs b/DisCatSharp.VoiceNext/VoiceNextEvents.cs
index d62714f25..fd412cf00 100644
--- a/DisCatSharp.VoiceNext/VoiceNextEvents.cs
+++ b/DisCatSharp.VoiceNext/VoiceNextEvents.cs
@@ -1,82 +1,82 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.VoiceNext
 {
 	/// <summary>
 	/// Contains well-defined event IDs used by the VoiceNext extension.
 	/// </summary>
 	public static class VoiceNextEvents
 	{
 		/// <summary>
 		/// Miscellaneous events, that do not fit in any other category.
 		/// </summary>
-		public static EventId Misc { get; } = new EventId(300, "VoiceNext");
+		public static EventId Misc { get; } = new(300, "VoiceNext");
 
 		/// <summary>
 		/// Events pertaining to Voice Gateway connection lifespan, specifically, heartbeats.
 		/// </summary>
-		public static EventId VoiceHeartbeat { get; } = new EventId(301, nameof(VoiceHeartbeat));
+		public static EventId VoiceHeartbeat { get; } = new(301, nameof(VoiceHeartbeat));
 
 		/// <summary>
 		/// Events pertaining to Voice Gateway connection early lifespan, specifically, the establishing thereof as well as negotiating various modes.
 		/// </summary>
-		public static EventId VoiceHandshake { get; } = new EventId(302, nameof(VoiceHandshake));
+		public static EventId VoiceHandshake { get; } = new(302, nameof(VoiceHandshake));
 
 		/// <summary>
 		/// Events emitted when incoming voice data is corrupted, or packets are being dropped.
 		/// </summary>
-		public static EventId VoiceReceiveFailure { get; } = new EventId(303, nameof(VoiceReceiveFailure));
+		public static EventId VoiceReceiveFailure { get; } = new(303, nameof(VoiceReceiveFailure));
 
 		/// <summary>
 		/// Events pertaining to UDP connection lifespan, specifically the keepalive (or heartbeats).
 		/// </summary>
-		public static EventId VoiceKeepalive { get; } = new EventId(304, nameof(VoiceKeepalive));
+		public static EventId VoiceKeepalive { get; } = new(304, nameof(VoiceKeepalive));
 
 		/// <summary>
 		/// Events emitted for high-level dispatch receive events.
 		/// </summary>
-		public static EventId VoiceDispatch { get; } = new EventId(305, nameof(VoiceDispatch));
+		public static EventId VoiceDispatch { get; } = new(305, nameof(VoiceDispatch));
 
 		/// <summary>
 		/// Events emitted for Voice Gateway connection closes, clean or otherwise.
 		/// </summary>
-		public static EventId VoiceConnectionClose { get; } = new EventId(306, nameof(VoiceConnectionClose));
+		public static EventId VoiceConnectionClose { get; } = new(306, nameof(VoiceConnectionClose));
 
 		/// <summary>
 		/// Events emitted when decoding data received via Voice Gateway fails for any reason.
 		/// </summary>
-		public static EventId VoiceGatewayError { get; } = new EventId(307, nameof(VoiceGatewayError));
+		public static EventId VoiceGatewayError { get; } = new(307, nameof(VoiceGatewayError));
 
 		/// <summary>
 		/// Events containing raw (but decompressed) payloads, received from Discord Voice Gateway.
 		/// </summary>
-		public static EventId VoiceWsRx { get; } = new EventId(308, "Voice ↓");
+		public static EventId VoiceWsRx { get; } = new(308, "Voice ↓");
 
 		/// <summary>
 		/// Events containing raw payloads, as they're being sent to Discord Voice Gateway.
 		/// </summary>
-		public static EventId VoiceWsTx { get; } = new EventId(309, "Voice ↑");
+		public static EventId VoiceWsTx { get; } = new(309, "Voice ↑");
 	}
 }
diff --git a/DisCatSharp/Clients/DiscordClient.Dispatch.cs b/DisCatSharp/Clients/DiscordClient.Dispatch.cs
index d7db208d2..cbde903be 100644
--- a/DisCatSharp/Clients/DiscordClient.Dispatch.cs
+++ b/DisCatSharp/Clients/DiscordClient.Dispatch.cs
@@ -1,3229 +1,3229 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Serialization;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Represents a discord client.
 	/// </summary>
 	public sealed partial class DiscordClient
 	{
 		#region Private Fields
 
 		private string _sessionId;
-		private bool _guildDownloadCompleted = false;
+		private bool _guildDownloadCompleted;
 
 		#endregion
 
 		#region Dispatch Handler
 
 		/// <summary>
 		/// Handles the dispatch.
 		/// </summary>
 		/// <param name="payload">The payload.</param>
 
 		internal async Task HandleDispatchAsync(GatewayPayload payload)
 		{
 			if (payload.Data is not JObject dat)
 			{
 				this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Invalid payload body (this message is probably safe to ignore); opcode: {0} event: {1}; payload: {2}", payload.OpCode, payload.EventName, payload.Data);
 				return;
 			}
 
-			await this._payloadReceived.InvokeAsync(this, new(this.ServiceProvider)
+			await this._payloadReceived.InvokeAsync(this, new PayloadReceivedEventArgs(this.ServiceProvider)
 			{
 				EventName = payload.EventName,
 				PayloadObject = dat
 			}).ConfigureAwait(false);
 
 			DiscordChannel chn;
 			ulong gid;
 			ulong cid;
 			ulong uid;
 			DiscordStageInstance stg = default;
 			DiscordIntegration itg = default;
 			DiscordThreadChannel trd = default;
 			DiscordThreadChannelMember trdm = default;
 			DiscordScheduledEvent gse = default;
 			TransportUser usr = default;
 			TransportMember mbr = default;
 			TransportUser refUsr = default;
 			TransportMember refMbr = default;
 			JToken rawMbr = default;
 			var rawRefMsg = dat["referenced_message"];
 
 			switch (payload.EventName.ToLowerInvariant())
 			{
 				#region Gateway Status
 
 				case "ready":
 					var glds = (JArray)dat["guilds"];
 					await this.OnReadyEventAsync(dat.ToObject<ReadyPayload>(), glds).ConfigureAwait(false);
 					break;
 
 				case "resumed":
 					await this.OnResumedAsync().ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Channel
 
 				case "channel_create":
 					chn = dat.ToObject<DiscordChannel>();
 					await this.OnChannelCreateEventAsync(chn).ConfigureAwait(false);
 					break;
 
 				case "channel_update":
 					await this.OnChannelUpdateEventAsync(dat.ToObject<DiscordChannel>()).ConfigureAwait(false);
 					break;
 
 				case "channel_delete":
 					chn = dat.ToObject<DiscordChannel>();
 					await this.OnChannelDeleteEventAsync(chn.IsPrivate ? dat.ToObject<DiscordDmChannel>() : chn).ConfigureAwait(false);
 					break;
 
 				case "channel_pins_update":
 					cid = (ulong)dat["channel_id"];
 					var ts = (string)dat["last_pin_timestamp"];
 					await this.OnChannelPinsUpdateAsync((ulong?)dat["guild_id"], cid, ts != null ? DateTimeOffset.Parse(ts, CultureInfo.InvariantCulture) : default(DateTimeOffset?)).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Guild
 
 				case "guild_create":
 					await this.OnGuildCreateEventAsync(dat.ToDiscordObject<DiscordGuild>(), (JArray)dat["members"], dat["presences"].ToDiscordObject<IEnumerable<DiscordPresence>>()).ConfigureAwait(false);
 					break;
 
 				case "guild_update":
 					await this.OnGuildUpdateEventAsync(dat.ToDiscordObject<DiscordGuild>(), (JArray)dat["members"]).ConfigureAwait(false);
 					break;
 
 				case "guild_delete":
 					await this.OnGuildDeleteEventAsync(dat.ToDiscordObject<DiscordGuild>()).ConfigureAwait(false);
 					break;
 
 				case "guild_sync":
 					gid = (ulong)dat["id"];
 					await this.OnGuildSyncEventAsync(this.GuildsInternal[gid], (bool)dat["large"], (JArray)dat["members"], dat["presences"].ToDiscordObject<IEnumerable<DiscordPresence>>()).ConfigureAwait(false);
 					break;
 
 				case "guild_emojis_update":
 					gid = (ulong)dat["guild_id"];
 					var ems = dat["emojis"].ToObject<IEnumerable<DiscordEmoji>>();
 					await this.OnGuildEmojisUpdateEventAsync(this.GuildsInternal[gid], ems).ConfigureAwait(false);
 					break;
 
 				case "guild_stickers_update":
 					var strs = dat["stickers"].ToDiscordObject<IEnumerable<DiscordSticker>>();
 					await this.OnStickersUpdatedAsync(strs, dat).ConfigureAwait(false);
 					break;
 
 				case "guild_integrations_update":
 					gid = (ulong)dat["guild_id"];
 
 					// discord fires this event inconsistently if the current user leaves a guild.
 					if (!this.GuildsInternal.ContainsKey(gid))
 						return;
 
 					await this.OnGuildIntegrationsUpdateEventAsync(this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				/*
                  Ok soooo.. this isn't documented yet
                  It seems to be part of the next version of membership screening (https://discord.com/channels/641574644578648068/689591708962652289/845836910991507486)
 
                  advaith said the following (https://discord.com/channels/641574644578648068/689591708962652289/845838160047112202):
                  > iirc it happens when a user leaves a server where they havent completed screening yet
 
                  We have to wait till it's documented, but the fields are:
                  { "user_id": "snowflake_user", "guild_id": "snowflake_guild" }
 
                  We could handle it rn, but due to the fact that it isn't documented, it's not an good idea.
                  */
 				case "guild_join_request_delete":
 					break;
 
 				#endregion
 
 				#region Guild Ban
 
 				case "guild_ban_add":
 					usr = dat["user"].ToObject<TransportUser>();
 					gid = (ulong)dat["guild_id"];
 					await this.OnGuildBanAddEventAsync(usr, this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				case "guild_ban_remove":
 					usr = dat["user"].ToObject<TransportUser>();
 					gid = (ulong)dat["guild_id"];
 					await this.OnGuildBanRemoveEventAsync(usr, this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Guild Event
 
 				case "guild_scheduled_event_create":
 					gse = dat.ToObject<DiscordScheduledEvent>();
 					gid = (ulong)dat["guild_id"];
 					await this.OnGuildScheduledEventCreateEventAsync(gse, this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				case "guild_scheduled_event_update":
 					gse = dat.ToObject<DiscordScheduledEvent>();
 					gid = (ulong)dat["guild_id"];
 					await this.OnGuildScheduledEventUpdateEventAsync(gse, this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				case "guild_scheduled_event_delete":
 					gse = dat.ToObject<DiscordScheduledEvent>();
 					gid = (ulong)dat["guild_id"];
 					await this.OnGuildScheduledEventDeleteEventAsync(gse, this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				case "guild_scheduled_event_user_add":
 					gid = (ulong)dat["guild_id"];
 					uid = (ulong)dat["user_id"];
 					await this.OnGuildScheduledEventUserAddedEventAsync((ulong)dat["guild_scheduled_event_id"], uid, this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				case "guild_scheduled_event_user_remove":
 					gid = (ulong)dat["guild_id"];
 					uid = (ulong)dat["user_id"];
 					await this.OnGuildScheduledEventUserRemovedEventAsync((ulong)dat["guild_scheduled_event_id"], uid, this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Guild Integration
 
 				case "integration_create":
 					gid = (ulong)dat["guild_id"];
 					itg = dat.ToObject<DiscordIntegration>();
 
 					// discord fires this event inconsistently if the current user leaves a guild.
 					if (!this.GuildsInternal.ContainsKey(gid))
 						return;
 
 					await this.OnGuildIntegrationCreateEventAsync(this.GuildsInternal[gid], itg).ConfigureAwait(false);
 					break;
 
 				case "integration_update":
 					gid = (ulong)dat["guild_id"];
 					itg = dat.ToObject<DiscordIntegration>();
 
 					// discord fires this event inconsistently if the current user leaves a guild.
 					if (!this.GuildsInternal.ContainsKey(gid))
 						return;
 
 					await this.OnGuildIntegrationUpdateEventAsync(this.GuildsInternal[gid], itg).ConfigureAwait(false);
 					break;
 
 				case "integration_delete":
 					gid = (ulong)dat["guild_id"];
 
 					// discord fires this event inconsistently if the current user leaves a guild.
 					if (!this.GuildsInternal.ContainsKey(gid))
 						return;
 
 					await this.OnGuildIntegrationDeleteEventAsync(this.GuildsInternal[gid], (ulong)dat["id"], (ulong?)dat["application_id"]).ConfigureAwait(false);
 					break;
 				#endregion
 
 				#region Guild Member
 
 				case "guild_member_add":
 					gid = (ulong)dat["guild_id"];
 					await this.OnGuildMemberAddEventAsync(dat.ToObject<TransportMember>(), this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				case "guild_member_remove":
 					gid = (ulong)dat["guild_id"];
 					usr = dat["user"].ToObject<TransportUser>();
 
 					if (!this.GuildsInternal.ContainsKey(gid))
 					{
 						// discord fires this event inconsistently if the current user leaves a guild.
 						if (usr.Id != this.CurrentUser.Id)
 							this.Logger.LogError(LoggerEvents.WebSocketReceive, "Could not find {0} in guild cache", gid);
 						return;
 					}
 
 					await this.OnGuildMemberRemoveEventAsync(usr, this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				case "guild_member_update":
 					gid = (ulong)dat["guild_id"];
 					await this.OnGuildMemberUpdateEventAsync(dat.ToDiscordObject<TransportMember>(), this.GuildsInternal[gid], dat["roles"].ToObject<IEnumerable<ulong>>(), (string)dat["nick"], (bool?)dat["pending"]).ConfigureAwait(false);
 					break;
 
 				case "guild_members_chunk":
 					await this.OnGuildMembersChunkEventAsync(dat).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Guild Role
 
 				case "guild_role_create":
 					gid = (ulong)dat["guild_id"];
 					await this.OnGuildRoleCreateEventAsync(dat["role"].ToObject<DiscordRole>(), this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				case "guild_role_update":
 					gid = (ulong)dat["guild_id"];
 					await this.OnGuildRoleUpdateEventAsync(dat["role"].ToObject<DiscordRole>(), this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				case "guild_role_delete":
 					gid = (ulong)dat["guild_id"];
 					await this.OnGuildRoleDeleteEventAsync((ulong)dat["role_id"], this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Invite
 
 				case "invite_create":
 					gid = (ulong)dat["guild_id"];
 					cid = (ulong)dat["channel_id"];
 					await this.OnInviteCreateEventAsync(cid, gid, dat.ToObject<DiscordInvite>()).ConfigureAwait(false);
 					break;
 
 				case "invite_delete":
 					gid = (ulong)dat["guild_id"];
 					cid = (ulong)dat["channel_id"];
 					await this.OnInviteDeleteEventAsync(cid, gid, dat).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Message
 
 				case "message_ack":
 					cid = (ulong)dat["channel_id"];
 					var mid = (ulong)dat["message_id"];
 					await this.OnMessageAckEventAsync(this.InternalGetCachedChannel(cid), mid).ConfigureAwait(false);
 					break;
 
 				case "message_create":
 					rawMbr = dat["member"];
 
 					if (rawMbr != null)
 						mbr = rawMbr.ToObject<TransportMember>();
 
 					if (rawRefMsg != null && rawRefMsg.HasValues)
 					{
 						if (rawRefMsg.SelectToken("author") != null)
 						{
 							refUsr = rawRefMsg.SelectToken("author").ToObject<TransportUser>();
 						}
 
 						if (rawRefMsg.SelectToken("member") != null)
 						{
 							refMbr = rawRefMsg.SelectToken("member").ToObject<TransportMember>();
 						}
 					}
 
 					await this.OnMessageCreateEventAsync(dat.ToDiscordObject<DiscordMessage>(), dat["author"].ToObject<TransportUser>(), mbr, refUsr, refMbr).ConfigureAwait(false);
 					break;
 
 				case "message_update":
 					rawMbr = dat["member"];
 
 					if (rawMbr != null)
 						mbr = rawMbr.ToObject<TransportMember>();
 
 					if (rawRefMsg != null && rawRefMsg.HasValues)
 					{
 						if (rawRefMsg.SelectToken("author") != null)
 						{
 							refUsr = rawRefMsg.SelectToken("author").ToObject<TransportUser>();
 						}
 
 						if (rawRefMsg.SelectToken("member") != null)
 						{
 							refMbr = rawRefMsg.SelectToken("member").ToObject<TransportMember>();
 						}
 					}
 
 					await this.OnMessageUpdateEventAsync(dat.ToDiscordObject<DiscordMessage>(), dat["author"]?.ToObject<TransportUser>(), mbr, refUsr, refMbr).ConfigureAwait(false);
 					break;
 
 				// delete event does *not* include message object
 				case "message_delete":
 					await this.OnMessageDeleteEventAsync((ulong)dat["id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"]).ConfigureAwait(false);
 					break;
 
 				case "message_delete_bulk":
 					await this.OnMessageBulkDeleteEventAsync(dat["ids"].ToObject<ulong[]>(), (ulong)dat["channel_id"], (ulong?)dat["guild_id"]).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Message Reaction
 
 				case "message_reaction_add":
 					rawMbr = dat["member"];
 
 					if (rawMbr != null)
 						mbr = rawMbr.ToObject<TransportMember>();
 
 					await this.OnMessageReactionAddAsync((ulong)dat["user_id"], (ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"], mbr, dat["emoji"].ToObject<DiscordEmoji>()).ConfigureAwait(false);
 					break;
 
 				case "message_reaction_remove":
 					await this.OnMessageReactionRemoveAsync((ulong)dat["user_id"], (ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"], dat["emoji"].ToObject<DiscordEmoji>()).ConfigureAwait(false);
 					break;
 
 				case "message_reaction_remove_all":
 					await this.OnMessageReactionRemoveAllAsync((ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"]).ConfigureAwait(false);
 					break;
 
 				case "message_reaction_remove_emoji":
 					await this.OnMessageReactionRemoveEmojiAsync((ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong)dat["guild_id"], dat["emoji"]).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Stage Instance
 
 				case "stage_instance_create":
 					stg = dat.ToObject<DiscordStageInstance>();
 					await this.OnStageInstanceCreateEventAsync(stg).ConfigureAwait(false);
 					break;
 
 				case "stage_instance_update":
 					stg = dat.ToObject<DiscordStageInstance>();
 					await this.OnStageInstanceUpdateEventAsync(stg).ConfigureAwait(false);
 					break;
 
 				case "stage_instance_delete":
 					stg = dat.ToObject<DiscordStageInstance>();
 					await this.OnStageInstanceDeleteEventAsync(stg).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Thread
 
 				case "thread_create":
 					trd = dat.ToObject<DiscordThreadChannel>();
 					await this.OnThreadCreateEventAsync(trd).ConfigureAwait(false);
 					break;
 
 				case "thread_update":
 					trd = dat.ToObject<DiscordThreadChannel>();
 					await this.OnThreadUpdateEventAsync(trd).ConfigureAwait(false);
 					break;
 
 				case "thread_delete":
 					trd = dat.ToObject<DiscordThreadChannel>();
 					await this.OnThreadDeleteEventAsync(trd).ConfigureAwait(false);
 					break;
 
 				case "thread_list_sync":
 					gid = (ulong)dat["guild_id"]; //get guild
 					await this.OnThreadListSyncEventAsync(this.GuildsInternal[gid], dat["channel_ids"].ToObject<IReadOnlyList<ulong?>>(), dat["threads"].ToObject<IReadOnlyList<DiscordThreadChannel>>(), dat["members"].ToObject<IReadOnlyList<DiscordThreadChannelMember>>()).ConfigureAwait(false);
 					break;
 
 				case "thread_member_update":
 					trdm = dat.ToObject<DiscordThreadChannelMember>();
 					await this.OnThreadMemberUpdateEventAsync(trdm).ConfigureAwait(false);
 					break;
 
 				case "thread_members_update":
 					gid = (ulong)dat["guild_id"];
 
 					await this.OnThreadMembersUpdateEventAsync(this.GuildsInternal[gid], (ulong)dat["id"], (JArray)dat["added_members"], (JArray)dat["removed_member_ids"], (int)dat["member_count"]).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Activities
 				case "embedded_activity_update":
 					gid = (ulong)dat["guild_id"];
 					cid = (ulong)dat["channel_id"];
 					await this.OnEmbeddedActivityUpdateAsync((JObject)dat["embedded_activity"], this.GuildsInternal[gid], cid, (JArray)dat["users"], (ulong)dat["embedded_activity"]["application_id"]).ConfigureAwait(false);
 					break;
 				#endregion
 
 				#region User/Presence Update
 
 				case "presence_update":
 					await this.OnPresenceUpdateEventAsync(dat, (JObject)dat["user"]).ConfigureAwait(false);
 					break;
 
 				case "user_settings_update":
 					await this.OnUserSettingsUpdateEventAsync(dat.ToObject<TransportUser>()).ConfigureAwait(false);
 					break;
 
 				case "user_update":
 					await this.OnUserUpdateEventAsync(dat.ToObject<TransportUser>()).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Voice
 
 				case "voice_state_update":
 					await this.OnVoiceStateUpdateEventAsync(dat).ConfigureAwait(false);
 					break;
 
 				case "voice_server_update":
 					gid = (ulong)dat["guild_id"];
 					await this.OnVoiceServerUpdateEventAsync((string)dat["endpoint"], (string)dat["token"], this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Interaction/Integration/Application
 
 				case "interaction_create":
 					rawMbr = dat["member"];
 
 					if (rawMbr != null)
 					{
 						mbr = dat["member"].ToObject<TransportMember>();
 						usr = mbr.User;
 					}
 					else
 					{
 						usr = dat["user"].ToObject<TransportUser>();
 					}
 
 					cid = (ulong)dat["channel_id"];
 					await this.OnInteractionCreateAsync((ulong?)dat["guild_id"], cid, usr, mbr, dat.ToDiscordObject<DiscordInteraction>()).ConfigureAwait(false);
 					break;
 
 				case "application_command_create":
 					await this.OnApplicationCommandCreateAsync(dat.ToObject<DiscordApplicationCommand>(), (ulong?)dat["guild_id"]).ConfigureAwait(false);
 					break;
 
 				case "application_command_update":
 					await this.OnApplicationCommandUpdateAsync(dat.ToObject<DiscordApplicationCommand>(), (ulong?)dat["guild_id"]).ConfigureAwait(false);
 					break;
 
 				case "application_command_delete":
 					await this.OnApplicationCommandDeleteAsync(dat.ToObject<DiscordApplicationCommand>(), (ulong?)dat["guild_id"]).ConfigureAwait(false);
 					break;
 
 				case "guild_application_command_counts_update":
 					var counts = dat["application_command_counts"];
 					await this.OnGuildApplicationCommandCountsUpdateAsync((int)counts["1"], (int)counts["2"], (int)counts["3"], (ulong)dat["guild_id"]).ConfigureAwait(false);
 					break;
 
 				case "application_command_permissions_update":
 					var aid = (ulong)dat["application_id"];
 					if (aid != this.CurrentApplication.Id)
 						return;
 
 					var pms = dat["permissions"].ToObject<IEnumerable<DiscordApplicationCommandPermission>>();
 					gid = (ulong)dat["guild_id"];
 					await this.OnApplicationCommandPermissionsUpdateAsync(pms, (ulong)dat["id"], gid, aid).ConfigureAwait(false);
 					break;
 
 				#endregion
 
 				#region Misc
 
 				case "gift_code_update": //Not supposed to be dispatched to bots
 					break;
 
 				case "typing_start":
 					cid = (ulong)dat["channel_id"];
 					rawMbr = dat["member"];
 
 					if (rawMbr != null)
 						mbr = rawMbr.ToObject<TransportMember>();
 
 					await this.OnTypingStartEventAsync((ulong)dat["user_id"], cid, this.InternalGetCachedChannel(cid), (ulong?)dat["guild_id"], Utilities.GetDateTimeOffset((long)dat["timestamp"]), mbr).ConfigureAwait(false);
 					break;
 
 				case "webhooks_update":
 					gid = (ulong)dat["guild_id"];
 					cid = (ulong)dat["channel_id"];
 					await this.OnWebhooksUpdateAsync(this.GuildsInternal[gid].GetChannel(cid), this.GuildsInternal[gid]).ConfigureAwait(false);
 					break;
 
 				default:
 					await this.OnUnknownEventAsync(payload).ConfigureAwait(false);
 					this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Unknown event: {0}\npayload: {1}", payload.EventName, payload.Data);
 					break;
 
 					#endregion
 			}
 		}
 
 		#endregion
 
 		#region Events
 
 		#region Gateway
 
 		/// <summary>
 		/// Handles the ready event.
 		/// </summary>
 		/// <param name="ready">The ready.</param>
 		/// <param name="rawGuilds">The raw guilds.</param>
 
 		internal async Task OnReadyEventAsync(ReadyPayload ready, JArray rawGuilds)
 		{
 			//ready.CurrentUser.Discord = this;
 
 			var rusr = ready.CurrentUser;
 			this.CurrentUser.Username = rusr.Username;
 			this.CurrentUser.Discriminator = rusr.Discriminator;
 			this.CurrentUser.AvatarHash = rusr.AvatarHash;
 			this.CurrentUser.MfaEnabled = rusr.MfaEnabled;
 			this.CurrentUser.Verified = rusr.Verified;
 			this.CurrentUser.IsBot = rusr.IsBot;
 
 			this.GatewayVersion = ready.GatewayVersion;
 			this._sessionId = ready.SessionId;
 			var rawGuildIndex = rawGuilds.ToDictionary(xt => (ulong)xt["id"], xt => (JObject)xt);
 
 			this.GuildsInternal.Clear();
 			foreach (var guild in ready.Guilds)
 			{
 				guild.Discord = this;
 
 				if (guild.ChannelsInternal == null)
 					guild.ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>();
 
 				foreach (var xc in guild.Channels.Values)
 				{
 					xc.GuildId = guild.Id;
 					xc.Discord = this;
 					foreach (var xo in xc.PermissionOverwritesInternal)
 					{
 						xo.Discord = this;
 						xo.ChannelId = xc.Id;
 					}
 				}
 
 				if (guild.RolesInternal == null)
 					guild.RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>();
 
 				foreach (var xr in guild.Roles.Values)
 				{
 					xr.Discord = this;
 					xr.GuildId = guild.Id;
 				}
 
 				var rawGuild = rawGuildIndex[guild.Id];
 				var rawMembers = (JArray)rawGuild["members"];
 
 				if (guild.MembersInternal != null)
 					guild.MembersInternal.Clear();
 				else
 					guild.MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>();
 
 				if (rawMembers != null)
 				{
 					foreach (var xj in rawMembers)
 					{
 						var xtm = xj.ToObject<TransportMember>();
 
 						var xu = new DiscordUser(xtm.User) { Discord = this };
 						xu = this.UserCache.AddOrUpdate(xtm.User.Id, xu, (id, old) =>
 						{
 							old.Username = xu.Username;
 							old.Discriminator = xu.Discriminator;
 							old.AvatarHash = xu.AvatarHash;
 							return old;
 						});
 
 						guild.MembersInternal[xtm.User.Id] = new DiscordMember(xtm) { Discord = this, GuildId = guild.Id };
 					}
 				}
 
 				if (guild.EmojisInternal == null)
 					guild.EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>();
 
 				foreach (var xe in guild.Emojis.Values)
 					xe.Discord = this;
 
 				if (guild.VoiceStatesInternal == null)
 					guild.VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>();
 
 				foreach (var xvs in guild.VoiceStates.Values)
 					xvs.Discord = this;
 
 				this.GuildsInternal[guild.Id] = guild;
 			}
 
 			await this._ready.InvokeAsync(this, new ReadyEventArgs(this.ServiceProvider)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the resumed.
 		/// </summary>
 
 		internal Task OnResumedAsync()
 		{
 			this.Logger.LogInformation(LoggerEvents.SessionUpdate, "Session resumed");
 			return this._resumed.InvokeAsync(this, new ReadyEventArgs(this.ServiceProvider));
 		}
 
 		#endregion
 
 		#region Channel
 
 		/// <summary>
 		/// Handles the channel create event.
 		/// </summary>
 		/// <param name="channel">The channel.</param>
 
 		internal async Task OnChannelCreateEventAsync(DiscordChannel channel)
 		{
 			channel.Discord = this;
 			foreach (var xo in channel.PermissionOverwritesInternal)
 			{
 				xo.Discord = this;
 				xo.ChannelId = channel.Id;
 			}
 
 			this.GuildsInternal[channel.GuildId.Value].ChannelsInternal[channel.Id] = channel;
 
 			/*if (this.Configuration.AutoRefreshChannelCache)
             {
                 await this.RefreshChannelsAsync(channel.Guild.Id);
             }*/
 
 			await this._channelCreated.InvokeAsync(this, new ChannelCreateEventArgs(this.ServiceProvider) { Channel = channel, Guild = channel.Guild }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the channel update event.
 		/// </summary>
 		/// <param name="channel">The channel.</param>
 
 		internal async Task OnChannelUpdateEventAsync(DiscordChannel channel)
 		{
 			if (channel == null)
 				return;
 
 			channel.Discord = this;
 
 			var gld = channel.Guild;
 
 			var channelNew = this.InternalGetCachedChannel(channel.Id);
 			DiscordChannel channelOld = null;
 
 			if (channelNew != null)
 			{
 				channelOld = new DiscordChannel
 				{
 					Bitrate = channelNew.Bitrate,
 					Discord = this,
 					GuildId = channelNew.GuildId,
 					Id = channelNew.Id,
 					//IsPrivate = channel_new.IsPrivate,
 					LastMessageId = channelNew.LastMessageId,
 					Name = channelNew.Name,
 					PermissionOverwritesInternal = new List<DiscordOverwrite>(channelNew.PermissionOverwritesInternal),
 					Position = channelNew.Position,
 					Topic = channelNew.Topic,
 					Type = channelNew.Type,
 					UserLimit = channelNew.UserLimit,
 					ParentId = channelNew.ParentId,
 					IsNsfw = channelNew.IsNsfw,
 					PerUserRateLimit = channelNew.PerUserRateLimit,
 					RtcRegionId = channelNew.RtcRegionId,
 					QualityMode = channelNew.QualityMode,
 					DefaultAutoArchiveDuration = channelNew.DefaultAutoArchiveDuration
 				};
 
 				channelNew.Bitrate = channel.Bitrate;
 				channelNew.Name = channel.Name;
 				channelNew.Position = channel.Position;
 				channelNew.Topic = channel.Topic;
 				channelNew.UserLimit = channel.UserLimit;
 				channelNew.ParentId = channel.ParentId;
 				channelNew.IsNsfw = channel.IsNsfw;
 				channelNew.PerUserRateLimit = channel.PerUserRateLimit;
 				channelNew.Type = channel.Type;
 				channelNew.RtcRegionId = channel.RtcRegionId;
 				channelNew.QualityMode = channel.QualityMode;
 				channelNew.DefaultAutoArchiveDuration = channel.DefaultAutoArchiveDuration;
 
 				channelNew.PermissionOverwritesInternal.Clear();
 
 				foreach (var po in channel.PermissionOverwritesInternal)
 				{
 					po.Discord = this;
 					po.ChannelId = channel.Id;
 				}
 
 				channelNew.PermissionOverwritesInternal.AddRange(channel.PermissionOverwritesInternal);
 
 				if (this.Configuration.AutoRefreshChannelCache && gld != null)
 				{
 					await this.RefreshChannelsAsync(channel.Guild.Id);
 				}
 			}
 			else if (gld != null)
 			{
 				gld.ChannelsInternal[channel.Id] = channel;
 
 				if (this.Configuration.AutoRefreshChannelCache)
 				{
 					await this.RefreshChannelsAsync(channel.Guild.Id);
 				}
 			}
 
 			await this._channelUpdated.InvokeAsync(this, new ChannelUpdateEventArgs(this.ServiceProvider) { ChannelAfter = channelNew, Guild = gld, ChannelBefore = channelOld }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the channel delete event.
 		/// </summary>
 		/// <param name="channel">The channel.</param>
 
 		internal async Task OnChannelDeleteEventAsync(DiscordChannel channel)
 		{
 			if (channel == null)
 				return;
 
 			channel.Discord = this;
 
 			//if (channel.IsPrivate)
 			if (channel.Type == ChannelType.Group || channel.Type == ChannelType.Private)
 			{
 				var dmChannel = channel as DiscordDmChannel;
 
 				await this._dmChannelDeleted.InvokeAsync(this, new DmChannelDeleteEventArgs(this.ServiceProvider) { Channel = dmChannel }).ConfigureAwait(false);
 			}
 			else
 			{
 				var gld = channel.Guild;
 
 				if (gld.ChannelsInternal.TryRemove(channel.Id, out var cachedChannel)) channel = cachedChannel;
 
 				if (this.Configuration.AutoRefreshChannelCache)
 				{
 					await this.RefreshChannelsAsync(channel.Guild.Id);
 				}
 
 				await this._channelDeleted.InvokeAsync(this, new ChannelDeleteEventArgs(this.ServiceProvider) { Channel = channel, Guild = gld }).ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Refreshes the channels.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		internal async Task RefreshChannelsAsync(ulong guildId)
 		{
 			var guild = this.InternalGetCachedGuild(guildId);
 			var channels = await this.ApiClient.GetGuildChannelsAsync(guildId);
 			guild.ChannelsInternal.Clear();
 			foreach (var channel in channels.ToList())
 			{
 				channel.Discord = this;
 				foreach (var xo in channel.PermissionOverwritesInternal)
 				{
 					xo.Discord = this;
 					xo.ChannelId = channel.Id;
 				}
 				guild.ChannelsInternal[channel.Id] = channel;
 			}
 		}
 
 		/// <summary>
 		/// Handles the channel pins update.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="lastPinTimestamp">The last pin timestamp.</param>
 
 		internal async Task OnChannelPinsUpdateAsync(ulong? guildId, ulong channelId, DateTimeOffset? lastPinTimestamp)
 		{
 			var guild = this.InternalGetCachedGuild(guildId);
 			var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 			var ea = new ChannelPinsUpdateEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Channel = channel,
 				LastPinTimestamp = lastPinTimestamp
 			};
 			await this._channelPinsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Guild
 
 		/// <summary>
 		/// Handles the guild create event.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <param name="rawMembers">The raw members.</param>
 		/// <param name="presences">The presences.</param>
 
 		internal async Task OnGuildCreateEventAsync(DiscordGuild guild, JArray rawMembers, IEnumerable<DiscordPresence> presences)
 		{
 			if (presences != null)
 			{
 				foreach (var xp in presences)
 				{
 					xp.Discord = this;
 					xp.GuildId = guild.Id;
 					xp.Activity = new DiscordActivity(xp.RawActivity);
 					if (xp.RawActivities != null)
 					{
 						xp.InternalActivities = new DiscordActivity[xp.RawActivities.Length];
 						for (var i = 0; i < xp.RawActivities.Length; i++)
 							xp.InternalActivities[i] = new DiscordActivity(xp.RawActivities[i]);
 					}
 					this.PresencesInternal[xp.InternalUser.Id] = xp;
 				}
 			}
 
 			var exists = this.GuildsInternal.TryGetValue(guild.Id, out var foundGuild);
 
 			guild.Discord = this;
 			guild.IsUnavailable = false;
 			var eventGuild = guild;
 			if (exists)
 				guild = foundGuild;
 
 			if (guild.ChannelsInternal == null)
 				guild.ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>();
 			if (guild.ThreadsInternal == null)
 				guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 			if (guild.RolesInternal == null)
 				guild.RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>();
 			if (guild.ThreadsInternal == null)
 				guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 			if (guild.StickersInternal == null)
 				guild.StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>();
 			if (guild.EmojisInternal == null)
 				guild.EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>();
 			if (guild.VoiceStatesInternal == null)
 				guild.VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>();
 			if (guild.MembersInternal == null)
 				guild.MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>();
 			if (guild.ScheduledEventsInternal == null)
 				guild.ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>();
 
 			this.UpdateCachedGuild(eventGuild, rawMembers);
 
 			guild.JoinedAt = eventGuild.JoinedAt;
 			guild.IsLarge = eventGuild.IsLarge;
 			guild.MemberCount = Math.Max(eventGuild.MemberCount, guild.MembersInternal.Count);
 			guild.IsUnavailable = eventGuild.IsUnavailable;
 			guild.PremiumSubscriptionCount = eventGuild.PremiumSubscriptionCount;
 			guild.PremiumTier = eventGuild.PremiumTier;
 			guild.BannerHash = eventGuild.BannerHash;
 			guild.VanityUrlCode = eventGuild.VanityUrlCode;
 			guild.Description = eventGuild.Description;
 			guild.IsNsfw = eventGuild.IsNsfw;
 
 			foreach (var kvp in eventGuild.VoiceStatesInternal) guild.VoiceStatesInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in eventGuild.ChannelsInternal) guild.ChannelsInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in eventGuild.RolesInternal) guild.RolesInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in eventGuild.EmojisInternal) guild.EmojisInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in eventGuild.ThreadsInternal) guild.ThreadsInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in eventGuild.StickersInternal) guild.StickersInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in eventGuild.StageInstancesInternal) guild.StageInstancesInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in eventGuild.ScheduledEventsInternal) guild.ScheduledEventsInternal[kvp.Key] = kvp.Value;
 
 			foreach (var xc in guild.ChannelsInternal.Values)
 			{
 				xc.GuildId = guild.Id;
 				xc.Discord = this;
 				foreach (var xo in xc.PermissionOverwritesInternal)
 				{
 					xo.Discord = this;
 					xo.ChannelId = xc.Id;
 				}
 			}
 			foreach (var xt in guild.ThreadsInternal.Values)
 			{
 				xt.GuildId = guild.Id;
 				xt.Discord = this;
 			}
 			foreach (var xe in guild.EmojisInternal.Values)
 				xe.Discord = this;
 			foreach (var xs in guild.StickersInternal.Values)
 				xs.Discord = this;
 			foreach (var xvs in guild.VoiceStatesInternal.Values)
 				xvs.Discord = this;
 			foreach (var xsi in guild.StageInstancesInternal.Values)
 			{
 				xsi.Discord = this;
 				xsi.GuildId = guild.Id;
 			}
 			foreach (var xr in guild.RolesInternal.Values)
 			{
 				xr.Discord = this;
 				xr.GuildId = guild.Id;
 			}
 			foreach (var xse in guild.ScheduledEventsInternal.Values)
 			{
 				xse.Discord = this;
 				xse.GuildId = guild.Id;
 				if (xse.Creator != null)
 					xse.Creator.Discord = this;
 			}
 
 			var old = Volatile.Read(ref this._guildDownloadCompleted);
 			var dcompl = this.GuildsInternal.Values.All(xg => !xg.IsUnavailable);
 			Volatile.Write(ref this._guildDownloadCompleted, dcompl);
 
 			if (exists)
 				await this._guildAvailable.InvokeAsync(this, new GuildCreateEventArgs(this.ServiceProvider) { Guild = guild }).ConfigureAwait(false);
 			else
 				await this._guildCreated.InvokeAsync(this, new GuildCreateEventArgs(this.ServiceProvider) { Guild = guild }).ConfigureAwait(false);
 
 			if (dcompl && !old)
 				await this._guildDownloadCompletedEv.InvokeAsync(this, new GuildDownloadCompletedEventArgs(this.Guilds, this.ServiceProvider)).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild update event.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <param name="rawMembers">The raw members.</param>
 
 		internal async Task OnGuildUpdateEventAsync(DiscordGuild guild, JArray rawMembers)
 		{
 			DiscordGuild oldGuild;
 
 			if (!this.GuildsInternal.ContainsKey(guild.Id))
 			{
 				this.GuildsInternal[guild.Id] = guild;
 				oldGuild = null;
 			}
 			else
 			{
 				var gld = this.GuildsInternal[guild.Id];
 
 				oldGuild = new DiscordGuild
 				{
 					Discord = gld.Discord,
 					Name = gld.Name,
 					AfkChannelId = gld.AfkChannelId,
 					AfkTimeout = gld.AfkTimeout,
 					ApplicationId = gld.ApplicationId,
 					DefaultMessageNotifications = gld.DefaultMessageNotifications,
 					ExplicitContentFilter = gld.ExplicitContentFilter,
 					RawFeatures = gld.RawFeatures,
 					IconHash = gld.IconHash,
 					Id = gld.Id,
 					IsLarge = gld.IsLarge,
 					IsSynced = gld.IsSynced,
 					IsUnavailable = gld.IsUnavailable,
 					JoinedAt = gld.JoinedAt,
 					MemberCount = gld.MemberCount,
 					MaxMembers = gld.MaxMembers,
 					MaxPresences = gld.MaxPresences,
 					ApproximateMemberCount = gld.ApproximateMemberCount,
 					ApproximatePresenceCount = gld.ApproximatePresenceCount,
 					MaxVideoChannelUsers = gld.MaxVideoChannelUsers,
 					DiscoverySplashHash = gld.DiscoverySplashHash,
 					PreferredLocale = gld.PreferredLocale,
 					MfaLevel = gld.MfaLevel,
 					OwnerId = gld.OwnerId,
 					SplashHash = gld.SplashHash,
 					SystemChannelId = gld.SystemChannelId,
 					SystemChannelFlags = gld.SystemChannelFlags,
 					Description = gld.Description,
 					WidgetEnabled = gld.WidgetEnabled,
 					WidgetChannelId = gld.WidgetChannelId,
 					VerificationLevel = gld.VerificationLevel,
 					RulesChannelId = gld.RulesChannelId,
 					PublicUpdatesChannelId = gld.PublicUpdatesChannelId,
 					VoiceRegionId = gld.VoiceRegionId,
 					IsNsfw = gld.IsNsfw,
 					PremiumProgressBarEnabled = gld.PremiumProgressBarEnabled,
 					PremiumSubscriptionCount = gld.PremiumSubscriptionCount,
 					PremiumTier = gld.PremiumTier,
 					ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>(),
 					ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>(),
 					EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>(),
 					StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>(),
 					MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>(),
 					RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>(),
 					StageInstancesInternal = new ConcurrentDictionary<ulong, DiscordStageInstance>(),
 					VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>(),
 					ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>()
 				};
 
 				foreach (var kvp in gld.ChannelsInternal) oldGuild.ChannelsInternal[kvp.Key] = kvp.Value;
 				foreach (var kvp in gld.ThreadsInternal) oldGuild.ThreadsInternal[kvp.Key] = kvp.Value;
 				foreach (var kvp in gld.EmojisInternal) oldGuild.EmojisInternal[kvp.Key] = kvp.Value;
 				foreach (var kvp in gld.StickersInternal) oldGuild.StickersInternal[kvp.Key] = kvp.Value;
 				foreach (var kvp in gld.RolesInternal) oldGuild.RolesInternal[kvp.Key] = kvp.Value;
 				foreach (var kvp in gld.VoiceStatesInternal) oldGuild.VoiceStatesInternal[kvp.Key] = kvp.Value;
 				foreach (var kvp in gld.MembersInternal) oldGuild.MembersInternal[kvp.Key] = kvp.Value;
 				foreach (var kvp in gld.StageInstancesInternal) oldGuild.StageInstancesInternal[kvp.Key] = kvp.Value;
 				foreach (var kvp in gld.ScheduledEventsInternal) oldGuild.ScheduledEventsInternal[kvp.Key] = kvp.Value;
 			}
 
 			guild.Discord = this;
 			guild.IsUnavailable = false;
 			var eventGuild = guild;
 			guild = this.GuildsInternal[eventGuild.Id];
 
 			if (guild.ChannelsInternal == null)
 				guild.ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>();
 			if (guild.ThreadsInternal == null)
 				guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 			if (guild.RolesInternal == null)
 				guild.RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>();
 			if (guild.EmojisInternal == null)
 				guild.EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>();
 			if (guild.StickersInternal == null)
 				guild.StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>();
 			if (guild.VoiceStatesInternal == null)
 				guild.VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>();
 			if (guild.StageInstancesInternal == null)
 				guild.StageInstancesInternal = new ConcurrentDictionary<ulong, DiscordStageInstance>();
 			if (guild.MembersInternal == null)
 				guild.MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>();
 			if (guild.ScheduledEventsInternal == null)
 				guild.ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>();
 
 			this.UpdateCachedGuild(eventGuild, rawMembers);
 
 			foreach (var xc in guild.ChannelsInternal.Values)
 			{
 				xc.GuildId = guild.Id;
 				xc.Discord = this;
 				foreach (var xo in xc.PermissionOverwritesInternal)
 				{
 					xo.Discord = this;
 					xo.ChannelId = xc.Id;
 				}
 			}
 			foreach (var xc in guild.ThreadsInternal.Values)
 			{
 				xc.GuildId = guild.Id;
 				xc.Discord = this;
 			}
 			foreach (var xe in guild.EmojisInternal.Values)
 				xe.Discord = this;
 			foreach (var xs in guild.StickersInternal.Values)
 				xs.Discord = this;
 			foreach (var xvs in guild.VoiceStatesInternal.Values)
 				xvs.Discord = this;
 			foreach (var xr in guild.RolesInternal.Values)
 			{
 				xr.Discord = this;
 				xr.GuildId = guild.Id;
 			}
 			foreach (var xsi in guild.StageInstancesInternal.Values)
 			{
 				xsi.Discord = this;
 				xsi.GuildId = guild.Id;
 			}
 			foreach (var xse in guild.ScheduledEventsInternal.Values)
 			{
 				xse.Discord = this;
 				xse.GuildId = guild.Id;
 				if (xse.Creator != null)
 					xse.Creator.Discord = this;
 			}
 
 			await this._guildUpdated.InvokeAsync(this, new GuildUpdateEventArgs(this.ServiceProvider) { GuildBefore = oldGuild, GuildAfter = guild }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild delete event.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnGuildDeleteEventAsync(DiscordGuild guild)
 		{
 			if (guild.IsUnavailable)
 			{
 				if (!this.GuildsInternal.TryGetValue(guild.Id, out var gld))
 					return;
 
 				gld.IsUnavailable = true;
 
 				await this._guildUnavailable.InvokeAsync(this, new GuildDeleteEventArgs(this.ServiceProvider) { Guild = guild, Unavailable = true }).ConfigureAwait(false);
 			}
 			else
 			{
 				if (!this.GuildsInternal.TryRemove(guild.Id, out var gld))
 					return;
 
 				await this._guildDeleted.InvokeAsync(this, new GuildDeleteEventArgs(this.ServiceProvider) { Guild = gld }).ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Handles the guild sync event.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <param name="isLarge">If true, is large.</param>
 		/// <param name="rawMembers">The raw members.</param>
 		/// <param name="presences">The presences.</param>
 
 		internal async Task OnGuildSyncEventAsync(DiscordGuild guild, bool isLarge, JArray rawMembers, IEnumerable<DiscordPresence> presences)
 		{
 			presences = presences.Select(xp => { xp.Discord = this; xp.Activity = new DiscordActivity(xp.RawActivity); return xp; });
 			foreach (var xp in presences)
 				this.PresencesInternal[xp.InternalUser.Id] = xp;
 
 			guild.IsSynced = true;
 			guild.IsLarge = isLarge;
 
 			this.UpdateCachedGuild(guild, rawMembers);
 
 			await this._guildAvailable.InvokeAsync(this, new GuildCreateEventArgs(this.ServiceProvider) { Guild = guild }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild emojis update event.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <param name="newEmojis">The new emojis.</param>
 
 		internal async Task OnGuildEmojisUpdateEventAsync(DiscordGuild guild, IEnumerable<DiscordEmoji> newEmojis)
 		{
 			var oldEmojis = new ConcurrentDictionary<ulong, DiscordEmoji>(guild.EmojisInternal);
 			guild.EmojisInternal.Clear();
 
 			foreach (var emoji in newEmojis)
 			{
 				emoji.Discord = this;
 				guild.EmojisInternal[emoji.Id] = emoji;
 			}
 
 			var ea = new GuildEmojisUpdateEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				EmojisAfter = guild.Emojis,
 				EmojisBefore = new ReadOnlyConcurrentDictionary<ulong, DiscordEmoji>(oldEmojis)
 			};
 			await this._guildEmojisUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the stickers updated.
 		/// </summary>
 		/// <param name="newStickers">The new stickers.</param>
 		/// <param name="raw">The raw.</param>
 
 		internal async Task OnStickersUpdatedAsync(IEnumerable<DiscordSticker> newStickers, JObject raw)
 		{
 			var guild = this.InternalGetCachedGuild((ulong)raw["guild_id"]);
 			var oldStickers = new ConcurrentDictionary<ulong, DiscordSticker>(guild.StickersInternal);
 			guild.StickersInternal.Clear();
 
 			foreach (var nst in newStickers)
 			{
 				if (nst.User is not null)
 				{
 					nst.User.Discord = this;
 					this.UserCache.AddOrUpdate(nst.User.Id, nst.User, (old, @new) => @new);
 				}
 				nst.Discord = this;
 
 				guild.StickersInternal[nst.Id] = nst;
 			}
 
 			var sea = new GuildStickersUpdateEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				StickersBefore = oldStickers,
 				StickersAfter = guild.Stickers
 			};
 
 			await this._guildStickersUpdated.InvokeAsync(this, sea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild integrations update event.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnGuildIntegrationsUpdateEventAsync(DiscordGuild guild)
 		{
 			var ea = new GuildIntegrationsUpdateEventArgs(this.ServiceProvider)
 			{
 				Guild = guild
 			};
 			await this._guildIntegrationsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Guild Ban
 
 		/// <summary>
 		/// Handles the guild ban add event.
 		/// </summary>
 		/// <param name="user">The user.</param>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnGuildBanAddEventAsync(TransportUser user, DiscordGuild guild)
 		{
 			var usr = new DiscordUser(user) { Discord = this };
 			usr = this.UserCache.AddOrUpdate(user.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				return old;
 			});
 
 			if (!guild.Members.TryGetValue(user.Id, out var mbr))
 				mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 			var ea = new GuildBanAddEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Member = mbr
 			};
 			await this._guildBanAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild ban remove event.
 		/// </summary>
 		/// <param name="user">The user.</param>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnGuildBanRemoveEventAsync(TransportUser user, DiscordGuild guild)
 		{
 			var usr = new DiscordUser(user) { Discord = this };
 			usr = this.UserCache.AddOrUpdate(user.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				return old;
 			});
 
 			if (!guild.Members.TryGetValue(user.Id, out var mbr))
 				mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 			var ea = new GuildBanRemoveEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Member = mbr
 			};
 			await this._guildBanRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Guild Scheduled Event
 
 		/// <summary>
 		/// Dispatches the <see cref="GuildScheduledEventCreated"/> event.
 		/// </summary>
 		/// <param name="scheduledEvent">The created event.</param>
 		/// <param name="guild">The target guild.</param>
 		internal async Task OnGuildScheduledEventCreateEventAsync(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 		{
 			scheduledEvent.Discord = this;
 
 			guild.ScheduledEventsInternal.AddOrUpdate(scheduledEvent.Id, scheduledEvent, (old, newScheduledEvent) => newScheduledEvent);
 
 			if (scheduledEvent.Creator != null)
 			{
 				scheduledEvent.Creator.Discord = this;
 				this.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 				{
 					old.Username = scheduledEvent.Creator.Username;
 					old.Discriminator = scheduledEvent.Creator.Discriminator;
 					old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 					old.Flags = scheduledEvent.Creator.Flags;
 					return old;
 				});
 			}
 
 			await this._guildScheduledEventCreated.InvokeAsync(this, new GuildScheduledEventCreateEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = scheduledEvent.Guild }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="GuildScheduledEventUpdated"/> event.
 		/// </summary>
 		/// <param name="scheduledEvent">The updated event.</param>
 		/// <param name="guild">The target guild.</param>
 		internal async Task OnGuildScheduledEventUpdateEventAsync(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 		{
 			if (guild == null)
 				return;
 
 			DiscordScheduledEvent oldEvent;
 			if (!guild.ScheduledEventsInternal.ContainsKey(scheduledEvent.Id))
 			{
 				oldEvent = null;
 			}
 			else
 			{
 				var ev = guild.ScheduledEventsInternal[scheduledEvent.Id];
 				oldEvent = new DiscordScheduledEvent
 				{
 					Id = ev.Id,
 					ChannelId = ev.ChannelId,
 					EntityId = ev.EntityId,
 					EntityMetadata = ev.EntityMetadata,
 					CreatorId = ev.CreatorId,
 					Creator = ev.Creator,
 					Discord = this,
 					Description = ev.Description,
 					EntityType = ev.EntityType,
 					ScheduledStartTimeRaw = ev.ScheduledStartTimeRaw,
 					ScheduledEndTimeRaw = ev.ScheduledEndTimeRaw,
 					GuildId = ev.GuildId,
 					Status = ev.Status,
 					Name = ev.Name,
 					UserCount = ev.UserCount
 				};
 
 			}
 			if (scheduledEvent.Creator != null)
 			{
 				scheduledEvent.Creator.Discord = this;
 				this.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 				{
 					old.Username = scheduledEvent.Creator.Username;
 					old.Discriminator = scheduledEvent.Creator.Discriminator;
 					old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 					old.Flags = scheduledEvent.Creator.Flags;
 					return old;
 				});
 			}
 
 			if (scheduledEvent.Status == ScheduledEventStatus.Completed)
 			{
 				guild.ScheduledEventsInternal.TryRemove(scheduledEvent.Id, out var deletedEvent);
 				await this._guildScheduledEventDeleted.InvokeAsync(this, new GuildScheduledEventDeleteEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, Reason = ScheduledEventStatus.Completed }).ConfigureAwait(false);
 			}
 			else if (scheduledEvent.Status == ScheduledEventStatus.Canceled)
 			{
 				guild.ScheduledEventsInternal.TryRemove(scheduledEvent.Id, out var deletedEvent);
 				scheduledEvent.Status = ScheduledEventStatus.Canceled;
 				await this._guildScheduledEventDeleted.InvokeAsync(this, new GuildScheduledEventDeleteEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, Reason = ScheduledEventStatus.Canceled }).ConfigureAwait(false);
 			}
 			else
 			{
 				this.UpdateScheduledEvent(scheduledEvent, guild);
 				await this._guildScheduledEventUpdated.InvokeAsync(this, new GuildScheduledEventUpdateEventArgs(this.ServiceProvider) { ScheduledEventBefore = oldEvent, ScheduledEventAfter = scheduledEvent, Guild = guild }).ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="GuildScheduledEventDeleted"/> event.
 		/// </summary>
 		/// <param name="scheduledEvent">The deleted event.</param>
 		/// <param name="guild">The target guild.</param>
 		internal async Task OnGuildScheduledEventDeleteEventAsync(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 		{
 			scheduledEvent.Discord = this;
 
 			if (scheduledEvent.Status == ScheduledEventStatus.Scheduled)
 				scheduledEvent.Status = ScheduledEventStatus.Canceled;
 
 			if (scheduledEvent.Creator != null)
 			{
 				scheduledEvent.Creator.Discord = this;
 				this.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 				{
 					old.Username = scheduledEvent.Creator.Username;
 					old.Discriminator = scheduledEvent.Creator.Discriminator;
 					old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 					old.Flags = scheduledEvent.Creator.Flags;
 					return old;
 				});
 			}
 
 			await this._guildScheduledEventDeleted.InvokeAsync(this, new GuildScheduledEventDeleteEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = scheduledEvent.Guild, Reason = scheduledEvent.Status }).ConfigureAwait(false);
 			guild.ScheduledEventsInternal.TryRemove(scheduledEvent.Id, out var deletedEvent);
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="GuildScheduledEventUserAdded"/> event.
 		/// <param name="guildScheduledEventId">The target event.</param>
 		/// <param name="userId">The added user id.</param>
 		/// <param name="guild">The target guild.</param>
 		/// </summary>
 		internal async Task OnGuildScheduledEventUserAddedEventAsync(ulong guildScheduledEventId, ulong userId, DiscordGuild guild)
 		{
 			var scheduledEvent = this.InternalGetCachedScheduledEvent(guildScheduledEventId) ?? this.UpdateScheduledEvent(new DiscordScheduledEvent
 			{
 				Id = guildScheduledEventId,
 				GuildId = guild.Id,
 				Discord = this,
 				UserCount = 0
 			}, guild);
 
 			scheduledEvent.UserCount++;
 			scheduledEvent.Discord = this;
 			guild.Discord = this;
 
 			var user = this.GetUserAsync(userId, true).Result;
 			user.Discord = this;
 			var member = guild.Members.TryGetValue(userId, out var mem) ? mem : guild.GetMemberAsync(userId).Result;
 			member.Discord = this;
 
 			await this._guildScheduledEventUserAdded.InvokeAsync(this, new GuildScheduledEventUserAddEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, User = user, Member = member }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="GuildScheduledEventUserRemoved"/> event.
 		/// <param name="guildScheduledEventId">The target event.</param>
 		/// <param name="userId">The removed user id.</param>
 		/// <param name="guild">The target guild.</param>
 		/// </summary>
 		internal async Task OnGuildScheduledEventUserRemovedEventAsync(ulong guildScheduledEventId, ulong userId, DiscordGuild guild)
 		{
 			var scheduledEvent = this.InternalGetCachedScheduledEvent(guildScheduledEventId) ?? this.UpdateScheduledEvent(new DiscordScheduledEvent
 			{
 				Id = guildScheduledEventId,
 				GuildId = guild.Id,
 				Discord = this,
 				UserCount = 0
 			}, guild);
 
 			scheduledEvent.UserCount = scheduledEvent.UserCount == 0 ? 0 : scheduledEvent.UserCount - 1;
 			scheduledEvent.Discord = this;
 			guild.Discord = this;
 
 			var user = this.GetUserAsync(userId, true).Result;
 			user.Discord = this;
 			var member = guild.Members.TryGetValue(userId, out var mem) ? mem : guild.GetMemberAsync(userId).Result;
 			member.Discord = this;
 
 			await this._guildScheduledEventUserRemoved.InvokeAsync(this, new GuildScheduledEventUserRemoveEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, User = user, Member = member }).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Guild Integration
 
 		/// <summary>
 		/// Handles the guild integration create event.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <param name="integration">The integration.</param>
 
 		internal async Task OnGuildIntegrationCreateEventAsync(DiscordGuild guild, DiscordIntegration integration)
 		{
 			integration.Discord = this;
 
 			await this._guildIntegrationCreated.InvokeAsync(this, new GuildIntegrationCreateEventArgs(this.ServiceProvider) { Integration = integration, Guild = guild }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild integration update event.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <param name="integration">The integration.</param>
 
 		internal async Task OnGuildIntegrationUpdateEventAsync(DiscordGuild guild, DiscordIntegration integration)
 		{
 			integration.Discord = this;
 
 			await this._guildIntegrationUpdated.InvokeAsync(this, new GuildIntegrationUpdateEventArgs(this.ServiceProvider) { Integration = integration, Guild = guild }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild integration delete event.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <param name="integrationId">The integration_id.</param>
 		/// <param name="applicationId">The application_id.</param>
 
 		internal async Task OnGuildIntegrationDeleteEventAsync(DiscordGuild guild, ulong integrationId, ulong? applicationId)
 			=> await this._guildIntegrationDeleted.InvokeAsync(this, new GuildIntegrationDeleteEventArgs(this.ServiceProvider) { Guild = guild, IntegrationId = integrationId, ApplicationId = applicationId }).ConfigureAwait(false);
 
 		#endregion
 
 		#region Guild Member
 
 		/// <summary>
 		/// Handles the guild member add event.
 		/// </summary>
 		/// <param name="member">The member.</param>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnGuildMemberAddEventAsync(TransportMember member, DiscordGuild guild)
 		{
 			var usr = new DiscordUser(member.User) { Discord = this };
 			usr = this.UserCache.AddOrUpdate(member.User.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				return old;
 			});
 
 			var mbr = new DiscordMember(member)
 			{
 				Discord = this,
 				GuildId = guild.Id
 			};
 
 			guild.MembersInternal[mbr.Id] = mbr;
 			guild.MemberCount++;
 
 			var ea = new GuildMemberAddEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Member = mbr
 			};
 			await this._guildMemberAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild member remove event.
 		/// </summary>
 		/// <param name="user">The user.</param>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnGuildMemberRemoveEventAsync(TransportUser user, DiscordGuild guild)
 		{
 			var usr = new DiscordUser(user);
 
 			if (!guild.MembersInternal.TryRemove(user.Id, out var mbr))
 				mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 			guild.MemberCount--;
 
 			_ = this.UserCache.AddOrUpdate(user.Id, usr, (old, @new) => @new);
 
 			var ea = new GuildMemberRemoveEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Member = mbr
 			};
 			await this._guildMemberRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild member update event.
 		/// </summary>
 		/// <param name="member">The member.</param>
 		/// <param name="guild">The guild.</param>
 		/// <param name="roles">The roles.</param>
 		/// <param name="nick">The nick.</param>
 		/// <param name="pending">If true, pending.</param>
 
 		internal async Task OnGuildMemberUpdateEventAsync(TransportMember member, DiscordGuild guild, IEnumerable<ulong> roles, string nick, bool? pending)
 		{
 			var usr = new DiscordUser(member.User) { Discord = this };
 			usr = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				return old;
 			});
 
 			if (!guild.Members.TryGetValue(member.User.Id, out var mbr))
 				mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 
 			var nickOld = mbr.Nickname;
 			var pendingOld = mbr.IsPending;
 			var rolesOld = new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(mbr.Roles));
 			var cduOld = mbr.CommunicationDisabledUntil;
 			mbr.AvatarHashInternal = member.AvatarHash;
 			mbr.GuildAvatarHash = member.GuildAvatarHash;
 			mbr.Nickname = nick;
 			mbr.IsPending = pending;
 			mbr.CommunicationDisabledUntil = member.CommunicationDisabledUntil;
 			mbr.RoleIdsInternal.Clear();
 			mbr.RoleIdsInternal.AddRange(roles);
 
 			var ea = new GuildMemberUpdateEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Member = mbr,
 
 				NicknameAfter = mbr.Nickname,
 				RolesAfter = new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(mbr.Roles)),
 				PendingAfter = mbr.IsPending,
 				TimeoutAfter = mbr.CommunicationDisabledUntil,
 
 				NicknameBefore = nickOld,
 				RolesBefore = rolesOld,
 				PendingBefore = pendingOld,
 				TimeoutBefore = cduOld
 			};
 			await this._guildMemberUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild members chunk event.
 		/// </summary>
 		/// <param name="dat">The dat.</param>
 
 		internal async Task OnGuildMembersChunkEventAsync(JObject dat)
 		{
 			var guild = this.Guilds[(ulong)dat["guild_id"]];
 			var chunkIndex = (int)dat["chunk_index"];
 			var chunkCount = (int)dat["chunk_count"];
 			var nonce = (string)dat["nonce"];
 
 			var mbrs = new HashSet<DiscordMember>();
 			var pres = new HashSet<DiscordPresence>();
 
 			var members = dat["members"].ToObject<TransportMember[]>();
 
 			var memCount = members.Count();
 			for (var i = 0; i < memCount; i++)
 			{
 				var mbr = new DiscordMember(members[i]) { Discord = this, GuildId = guild.Id };
 
 				if (!this.UserCache.ContainsKey(mbr.Id))
 					this.UserCache[mbr.Id] = new DiscordUser(members[i].User) { Discord = this };
 
 				guild.MembersInternal[mbr.Id] = mbr;
 
 				mbrs.Add(mbr);
 			}
 
 			guild.MemberCount = guild.MembersInternal.Count;
 
 			var ea = new GuildMembersChunkEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Members = new ReadOnlySet<DiscordMember>(mbrs),
 				ChunkIndex = chunkIndex,
 				ChunkCount = chunkCount,
 				Nonce = nonce,
 			};
 
 			if (dat["presences"] != null)
 			{
 				var presences = dat["presences"].ToObject<DiscordPresence[]>();
 
 				var presCount = presences.Count();
 				for (var i = 0; i < presCount; i++)
 				{
 					var xp = presences[i];
 					xp.Discord = this;
 					xp.Activity = new DiscordActivity(xp.RawActivity);
 
 					if (xp.RawActivities != null)
 					{
 						xp.InternalActivities = new DiscordActivity[xp.RawActivities.Length];
 						for (var j = 0; j < xp.RawActivities.Length; j++)
 							xp.InternalActivities[j] = new DiscordActivity(xp.RawActivities[j]);
 					}
 
 					pres.Add(xp);
 				}
 
 				ea.Presences = new ReadOnlySet<DiscordPresence>(pres);
 			}
 
 			if (dat["not_found"] != null)
 			{
 				var nf = dat["not_found"].ToObject<ISet<ulong>>();
 				ea.NotFound = new ReadOnlySet<ulong>(nf);
 			}
 
 			await this._guildMembersChunked.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Guild Role
 
 		/// <summary>
 		/// Handles the guild role create event.
 		/// </summary>
 		/// <param name="role">The role.</param>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnGuildRoleCreateEventAsync(DiscordRole role, DiscordGuild guild)
 		{
 			role.Discord = this;
 			role.GuildId = guild.Id;
 
 			guild.RolesInternal[role.Id] = role;
 
 			var ea = new GuildRoleCreateEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Role = role
 			};
 			await this._guildRoleCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild role update event.
 		/// </summary>
 		/// <param name="role">The role.</param>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnGuildRoleUpdateEventAsync(DiscordRole role, DiscordGuild guild)
 		{
 			var newRole = guild.GetRole(role.Id);
 			var oldRole = new DiscordRole
 			{
 				GuildId = guild.Id,
 				ColorInternal = newRole.ColorInternal,
 				Discord = this,
 				IsHoisted = newRole.IsHoisted,
 				Id = newRole.Id,
 				IsManaged = newRole.IsManaged,
 				IsMentionable = newRole.IsMentionable,
 				Name = newRole.Name,
 				Permissions = newRole.Permissions,
 				Position = newRole.Position
 			};
 
 			newRole.GuildId = guild.Id;
 			newRole.ColorInternal = role.ColorInternal;
 			newRole.IsHoisted = role.IsHoisted;
 			newRole.IsManaged = role.IsManaged;
 			newRole.IsMentionable = role.IsMentionable;
 			newRole.Name = role.Name;
 			newRole.Permissions = role.Permissions;
 			newRole.Position = role.Position;
 
 			var ea = new GuildRoleUpdateEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				RoleAfter = newRole,
 				RoleBefore = oldRole
 			};
 			await this._guildRoleUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild role delete event.
 		/// </summary>
 		/// <param name="roleId">The role id.</param>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnGuildRoleDeleteEventAsync(ulong roleId, DiscordGuild guild)
 		{
 			if (!guild.RolesInternal.TryRemove(roleId, out var role))
 				this.Logger.LogWarning($"Attempted to delete a nonexistent role ({roleId}) from guild ({guild}).");
 
 			var ea = new GuildRoleDeleteEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Role = role
 			};
 			await this._guildRoleDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Invite
 
 		/// <summary>
 		/// Handles the invite create event.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="invite">The invite.</param>
 
 		internal async Task OnInviteCreateEventAsync(ulong channelId, ulong guildId, DiscordInvite invite)
 		{
 			var guild = this.InternalGetCachedGuild(guildId);
 			var channel = this.InternalGetCachedChannel(channelId);
 
 			invite.Discord = this;
 
 			if (invite.Inviter is not null)
 			{
 				invite.Inviter.Discord = this;
 				this.UserCache.AddOrUpdate(invite.Inviter.Id, invite.Inviter, (old, @new) => @new);
 			}
 
 			guild.Invites[invite.Code] = invite;
 
 			var ea = new InviteCreateEventArgs(this.ServiceProvider)
 			{
 				Channel = channel,
 				Guild = guild,
 				Invite = invite
 			};
 			await this._inviteCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the invite delete event.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="dat">The dat.</param>
 
 		internal async Task OnInviteDeleteEventAsync(ulong channelId, ulong guildId, JToken dat)
 		{
 			var guild = this.InternalGetCachedGuild(guildId);
 			var channel = this.InternalGetCachedChannel(channelId);
 
 			if (!guild.Invites.TryRemove(dat["code"].ToString(), out var invite))
 			{
 				invite = dat.ToObject<DiscordInvite>();
 				invite.Discord = this;
 			}
 
 			invite.IsRevoked = true;
 
 			var ea = new InviteDeleteEventArgs(this.ServiceProvider)
 			{
 				Channel = channel,
 				Guild = guild,
 				Invite = invite
 			};
 			await this._inviteDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Message
 
 		/// <summary>
 		/// Handles the message ack event.
 		/// </summary>
 		/// <param name="chn">The chn.</param>
 		/// <param name="messageId">The message id.</param>
 
 		internal async Task OnMessageAckEventAsync(DiscordChannel chn, ulong messageId)
 		{
 			if (this.MessageCache == null || !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == chn.Id, out var msg))
 			{
 				msg = new DiscordMessage
 				{
 					Id = messageId,
 					ChannelId = chn.Id,
 					Discord = this,
 				};
 			}
 
 			await this._messageAcknowledged.InvokeAsync(this, new MessageAcknowledgeEventArgs(this.ServiceProvider) { Message = msg }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the message create event.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <param name="author">The author.</param>
 		/// <param name="member">The member.</param>
 		/// <param name="referenceAuthor">The reference author.</param>
 		/// <param name="referenceMember">The reference member.</param>
 
 		internal async Task OnMessageCreateEventAsync(DiscordMessage message, TransportUser author, TransportMember member, TransportUser referenceAuthor, TransportMember referenceMember)
 		{
 			message.Discord = this;
 			this.PopulateMessageReactionsAndCache(message, author, member);
 			message.PopulateMentions();
 
 			if (message.Channel == null && message.ChannelId == default)
 				this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Channel which the last message belongs to is not in cache - cache state might be invalid!");
 
 			if (message.ReferencedMessage != null)
 			{
 				message.ReferencedMessage.Discord = this;
 				this.PopulateMessageReactionsAndCache(message.ReferencedMessage, referenceAuthor, referenceMember);
 				message.ReferencedMessage.PopulateMentions();
 			}
 
 			foreach (var sticker in message.Stickers)
 				sticker.Discord = this;
 
 			var ea = new MessageCreateEventArgs(this.ServiceProvider)
 			{
 				Message = message,
 
 				MentionedUsers = new ReadOnlyCollection<DiscordUser>(message.MentionedUsersInternal),
 				MentionedRoles = message.MentionedRolesInternal != null ? new ReadOnlyCollection<DiscordRole>(message.MentionedRolesInternal) : null,
 				MentionedChannels = message.MentionedChannelsInternal != null ? new ReadOnlyCollection<DiscordChannel>(message.MentionedChannelsInternal) : null
 			};
 			await this._messageCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the message update event.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <param name="author">The author.</param>
 		/// <param name="member">The member.</param>
 		/// <param name="referenceAuthor">The reference author.</param>
 		/// <param name="referenceMember">The reference member.</param>
 
 		internal async Task OnMessageUpdateEventAsync(DiscordMessage message, TransportUser author, TransportMember member, TransportUser referenceAuthor, TransportMember referenceMember)
 		{
 			DiscordGuild guild;
 
 			message.Discord = this;
 			var eventMessage = message;
 
 			DiscordMessage oldmsg = null;
 			if (this.Configuration.MessageCacheSize == 0
 				|| this.MessageCache == null
 				|| !this.MessageCache.TryGet(xm => xm.Id == eventMessage.Id && xm.ChannelId == eventMessage.ChannelId, out message))
 			{
 				message = eventMessage;
 				this.PopulateMessageReactionsAndCache(message, author, member);
 				guild = message.Channel?.Guild;
 
 				if (message.ReferencedMessage != null)
 				{
 					message.ReferencedMessage.Discord = this;
 					this.PopulateMessageReactionsAndCache(message.ReferencedMessage, referenceAuthor, referenceMember);
 					message.ReferencedMessage.PopulateMentions();
 				}
 			}
 			else
 			{
 				oldmsg = new DiscordMessage(message);
 
 				guild = message.Channel?.Guild;
 				message.EditedTimestampRaw = eventMessage.EditedTimestampRaw;
 				if (eventMessage.Content != null)
 					message.Content = eventMessage.Content;
 				message.EmbedsInternal.Clear();
 				message.EmbedsInternal.AddRange(eventMessage.EmbedsInternal);
 				message.Pinned = eventMessage.Pinned;
 				message.IsTts = eventMessage.IsTts;
 			}
 
 			message.PopulateMentions();
 
 			var ea = new MessageUpdateEventArgs(this.ServiceProvider)
 			{
 				Message = message,
 				MessageBefore = oldmsg,
 				MentionedUsers = new ReadOnlyCollection<DiscordUser>(message.MentionedUsersInternal),
 				MentionedRoles = message.MentionedRolesInternal != null ? new ReadOnlyCollection<DiscordRole>(message.MentionedRolesInternal) : null,
 				MentionedChannels = message.MentionedChannelsInternal != null ? new ReadOnlyCollection<DiscordChannel>(message.MentionedChannelsInternal) : null
 			};
 			await this._messageUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the message delete event.
 		/// </summary>
 		/// <param name="messageId">The message id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="guildId">The guild id.</param>
 
 		internal async Task OnMessageDeleteEventAsync(ulong messageId, ulong channelId, ulong? guildId)
 		{
 			var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 			var guild = this.InternalGetCachedGuild(guildId);
 
 			if (channel == null
 				|| this.Configuration.MessageCacheSize == 0
 				|| this.MessageCache == null
 				|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 			{
 				msg = new DiscordMessage
 				{
 
 					Id = messageId,
 					ChannelId = channelId,
 					Discord = this,
 				};
 			}
 
 			if (this.Configuration.MessageCacheSize > 0)
 				this.MessageCache?.Remove(xm => xm.Id == msg.Id && xm.ChannelId == channelId);
 
 			var ea = new MessageDeleteEventArgs(this.ServiceProvider)
 			{
 				Channel = channel,
 				Message = msg,
 				Guild = guild
 			};
 			await this._messageDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the message bulk delete event.
 		/// </summary>
 		/// <param name="messageIds">The message ids.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="guildId">The guild id.</param>
 
 		internal async Task OnMessageBulkDeleteEventAsync(ulong[] messageIds, ulong channelId, ulong? guildId)
 		{
 			var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 			var msgs = new List<DiscordMessage>(messageIds.Length);
 			foreach (var messageId in messageIds)
 			{
 				if (channel == null
 					|| this.Configuration.MessageCacheSize == 0
 					|| this.MessageCache == null
 					|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 				{
 					msg = new DiscordMessage
 					{
 						Id = messageId,
 						ChannelId = channelId,
 						Discord = this,
 					};
 				}
 				if (this.Configuration.MessageCacheSize > 0)
 					this.MessageCache?.Remove(xm => xm.Id == msg.Id && xm.ChannelId == channelId);
 				msgs.Add(msg);
 			}
 
 			var guild = this.InternalGetCachedGuild(guildId);
 
 			var ea = new MessageBulkDeleteEventArgs(this.ServiceProvider)
 			{
 				Channel = channel,
 				Messages = new ReadOnlyCollection<DiscordMessage>(msgs),
 				Guild = guild
 			};
 			await this._messagesBulkDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Message Reaction
 
 		/// <summary>
 		/// Handles the message reaction add.
 		/// </summary>
 		/// <param name="userId">The user id.</param>
 		/// <param name="messageId">The message id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="mbr">The mbr.</param>
 		/// <param name="emoji">The emoji.</param>
 
 		internal async Task OnMessageReactionAddAsync(ulong userId, ulong messageId, ulong channelId, ulong? guildId, TransportMember mbr, DiscordEmoji emoji)
 		{
 			var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 			var guild = this.InternalGetCachedGuild(guildId);
 			emoji.Discord = this;
 
 			var usr = this.UpdateUser(new DiscordUser { Id = userId, Discord = this }, guildId, guild, mbr);
 
 			if (channel == null
 				|| this.Configuration.MessageCacheSize == 0
 				|| this.MessageCache == null
 				|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 			{
 				msg = new DiscordMessage
 				{
 					Id = messageId,
 					ChannelId = channelId,
 					Discord = this,
 					ReactionsInternal = new List<DiscordReaction>()
 				};
 			}
 
 			var react = msg.ReactionsInternal.FirstOrDefault(xr => xr.Emoji == emoji);
 			if (react == null)
 			{
 				msg.ReactionsInternal.Add(react = new DiscordReaction
 				{
 					Count = 1,
 					Emoji = emoji,
 					IsMe = this.CurrentUser.Id == userId
 				});
 			}
 			else
 			{
 				react.Count++;
 				react.IsMe |= this.CurrentUser.Id == userId;
 			}
 
 			var ea = new MessageReactionAddEventArgs(this.ServiceProvider)
 			{
 				Message = msg,
 				User = usr,
 				Guild = guild,
 				Emoji = emoji
 			};
 			await this._messageReactionAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the message reaction remove.
 		/// </summary>
 		/// <param name="userId">The user id.</param>
 		/// <param name="messageId">The message id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="emoji">The emoji.</param>
 
 		internal async Task OnMessageReactionRemoveAsync(ulong userId, ulong messageId, ulong channelId, ulong? guildId, DiscordEmoji emoji)
 		{
 			var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 			emoji.Discord = this;
 
 			if (!this.UserCache.TryGetValue(userId, out var usr))
 				usr = new DiscordUser { Id = userId, Discord = this };
 
 			if (channel?.Guild != null)
 				usr = channel.Guild.Members.TryGetValue(userId, out var member)
 					? member
 					: new DiscordMember(usr) { Discord = this, GuildId = channel.GuildId.Value };
 
 			if (channel == null
 				|| this.Configuration.MessageCacheSize == 0
 				|| this.MessageCache == null
 				|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 			{
 				msg = new DiscordMessage
 				{
 					Id = messageId,
 					ChannelId = channelId,
 					Discord = this
 				};
 			}
 
 			var react = msg.ReactionsInternal?.FirstOrDefault(xr => xr.Emoji == emoji);
 			if (react != null)
 			{
 				react.Count--;
 				react.IsMe &= this.CurrentUser.Id != userId;
 
 				if (msg.ReactionsInternal != null && react.Count <= 0) // shit happens
 					for (var i = 0; i < msg.ReactionsInternal.Count; i++)
 						if (msg.ReactionsInternal[i].Emoji == emoji)
 						{
 							msg.ReactionsInternal.RemoveAt(i);
 							break;
 						}
 			}
 
 			var guild = this.InternalGetCachedGuild(guildId);
 
 			var ea = new MessageReactionRemoveEventArgs(this.ServiceProvider)
 			{
 				Message = msg,
 				User = usr,
 				Guild = guild,
 				Emoji = emoji
 			};
 			await this._messageReactionRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the message reaction remove all.
 		/// </summary>
 		/// <param name="messageId">The message id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="guildId">The guild id.</param>
 
 		internal async Task OnMessageReactionRemoveAllAsync(ulong messageId, ulong channelId, ulong? guildId)
 		{
 			var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 			if (channel == null
 				|| this.Configuration.MessageCacheSize == 0
 				|| this.MessageCache == null
 				|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 			{
 				msg = new DiscordMessage
 				{
 					Id = messageId,
 					ChannelId = channelId,
 					Discord = this
 				};
 			}
 
 			msg.ReactionsInternal?.Clear();
 
 			var guild = this.InternalGetCachedGuild(guildId);
 
 			var ea = new MessageReactionsClearEventArgs(this.ServiceProvider)
 			{
 				Message = msg
 			};
 
 			await this._messageReactionsCleared.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the message reaction remove emoji.
 		/// </summary>
 		/// <param name="messageId">The message id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="dat">The dat.</param>
 
 		internal async Task OnMessageReactionRemoveEmojiAsync(ulong messageId, ulong channelId, ulong guildId, JToken dat)
 		{
 			var guild = this.InternalGetCachedGuild(guildId);
 			var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 			if (channel == null
 				|| this.Configuration.MessageCacheSize == 0
 				|| this.MessageCache == null
 				|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 			{
 				msg = new DiscordMessage
 				{
 					Id = messageId,
 					ChannelId = channelId,
 					Discord = this
 				};
 			}
 
 			var partialEmoji = dat.ToObject<DiscordEmoji>();
 
 			if (!guild.EmojisInternal.TryGetValue(partialEmoji.Id, out var emoji))
 			{
 				emoji = partialEmoji;
 				emoji.Discord = this;
 			}
 
 			msg.ReactionsInternal?.RemoveAll(r => r.Emoji.Equals(emoji));
 
 			var ea = new MessageReactionRemoveEmojiEventArgs(this.ServiceProvider)
 			{
 				Channel = channel,
 				Guild = guild,
 				Message = msg,
 				Emoji = emoji
 			};
 
 			await this._messageReactionRemovedEmoji.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Stage Instance
 
 		/// <summary>
 		/// Dispatches the <see cref="StageInstanceCreated"/> event.
 		/// </summary>
 		/// <param name="stage">The created stage instance.</param>
 		internal async Task OnStageInstanceCreateEventAsync(DiscordStageInstance stage)
 		{
 			stage.Discord = this;
 
 			var guild = this.InternalGetCachedGuild(stage.GuildId);
 			guild.StageInstancesInternal[stage.Id] = stage;
 
 			await this._stageInstanceCreated.InvokeAsync(this, new StageInstanceCreateEventArgs(this.ServiceProvider) { StageInstance = stage, Guild = stage.Guild }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="StageInstanceUpdated"/> event.
 		/// </summary>
 		/// <param name="stage">The updated stage instance.</param>
 		internal async Task OnStageInstanceUpdateEventAsync(DiscordStageInstance stage)
 		{
 			stage.Discord = this;
 			var guild = this.InternalGetCachedGuild(stage.GuildId);
 			guild.StageInstancesInternal[stage.Id] = stage;
 
 			await this._stageInstanceUpdated.InvokeAsync(this, new StageInstanceUpdateEventArgs(this.ServiceProvider) { StageInstance = stage, Guild = stage.Guild }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="StageInstanceDeleted"/> event.
 		/// </summary>
 		/// <param name="stage">The deleted stage instance.</param>
 		internal async Task OnStageInstanceDeleteEventAsync(DiscordStageInstance stage)
 		{
 			stage.Discord = this;
 			var guild = this.InternalGetCachedGuild(stage.GuildId);
 			guild.StageInstancesInternal[stage.Id] = stage;
 
 			await this._stageInstanceDeleted.InvokeAsync(this, new StageInstanceDeleteEventArgs(this.ServiceProvider) { StageInstance = stage, Guild = stage.Guild }).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Thread
 
 		/// <summary>
 		/// Dispatches the <see cref="ThreadCreated"/> event.
 		/// </summary>
 		/// <param name="thread">The created thread.</param>
 		internal async Task OnThreadCreateEventAsync(DiscordThreadChannel thread)
 		{
 			thread.Discord = this;
 			this.InternalGetCachedGuild(thread.GuildId).ThreadsInternal.AddOrUpdate(thread.Id, thread, (oldThread, newThread) => newThread);
 
 			await this._threadCreated.InvokeAsync(this, new ThreadCreateEventArgs(this.ServiceProvider) { Thread = thread, Guild = thread.Guild, Parent = thread.Parent }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="DiscordClient.ThreadUpdated"/> event.
 		/// </summary>
 		/// <param name="thread">The updated thread.</param>
 		internal async Task OnThreadUpdateEventAsync(DiscordThreadChannel thread)
 		{
 			if (thread == null)
 				return;
 
 			thread.Discord = this;
 			var guild = thread.Guild;
 
 			var threadNew = this.InternalGetCachedThread(thread.Id);
 			DiscordThreadChannel threadOld = null;
 			ThreadUpdateEventArgs updateEvent;
 
 			if (threadNew != null)
 			{
 				threadOld = new DiscordThreadChannel
 				{
 					Discord = this,
 					Type = threadNew.Type,
 					ThreadMetadata = thread.ThreadMetadata,
 					ThreadMembersInternal = threadNew.ThreadMembersInternal,
 					ParentId = thread.ParentId,
 					OwnerId = thread.OwnerId,
 					Name = thread.Name,
 					LastMessageId = threadNew.LastMessageId,
 					MessageCount = thread.MessageCount,
 					MemberCount = thread.MemberCount,
 					GuildId = thread.GuildId,
 					LastPinTimestampRaw = threadNew.LastPinTimestampRaw,
 					PerUserRateLimit = threadNew.PerUserRateLimit,
 					CurrentMember = threadNew.CurrentMember
 				};
 
 				threadNew.ThreadMetadata = thread.ThreadMetadata;
 				threadNew.ParentId = thread.ParentId;
 				threadNew.OwnerId = thread.OwnerId;
 				threadNew.Name = thread.Name;
 				threadNew.LastMessageId = thread.LastMessageId.HasValue ? thread.LastMessageId : threadOld.LastMessageId;
 				threadNew.MessageCount = thread.MessageCount;
 				threadNew.MemberCount = thread.MemberCount;
 				threadNew.GuildId = thread.GuildId;
 
 				updateEvent = new ThreadUpdateEventArgs(this.ServiceProvider)
 				{
 					ThreadAfter = thread,
 					ThreadBefore = threadOld,
 					Guild = thread.Guild,
 					Parent = thread.Parent
 				};
 			}
 			else
 			{
 				updateEvent = new ThreadUpdateEventArgs(this.ServiceProvider)
 				{
 					ThreadAfter = thread,
 					Guild = thread.Guild,
 					Parent = thread.Parent
 				};
 				guild.ThreadsInternal[thread.Id] = thread;
 			}
 
 			await this._threadUpdated.InvokeAsync(this, updateEvent).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="ThreadDeleted"/> event.
 		/// </summary>
 		/// <param name="thread">The deleted thread.</param>
 		internal async Task OnThreadDeleteEventAsync(DiscordThreadChannel thread)
 		{
 			if (thread == null)
 				return;
 
 			thread.Discord = this;
 
 			var gld = thread.Guild;
 			if (gld.ThreadsInternal.TryRemove(thread.Id, out var cachedThread))
 				thread = cachedThread;
 
 			await this._threadDeleted.InvokeAsync(this, new ThreadDeleteEventArgs(this.ServiceProvider) { Thread = thread, Guild = thread.Guild, Parent = thread.Parent, Type = thread.Type }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="ThreadListSynced"/> event.
 		/// </summary>
 		/// <param name="guild">The synced guild.</param>
 		/// <param name="channelIds">The synced channel ids.</param>
 		/// <param name="threads">The synced threads.</param>
 		/// <param name="members">The synced members.</param>
 		internal async Task OnThreadListSyncEventAsync(DiscordGuild guild, IReadOnlyList<ulong?> channelIds, IReadOnlyList<DiscordThreadChannel> threads, IReadOnlyList<DiscordThreadChannelMember> members)
 		{
 			guild.Discord = this;
 
 			var channels = channelIds.Select(x => guild.GetChannel(x.Value)); //getting channel objects
 			foreach (var chan in channels)
 			{
 				chan.Discord = this;
 			}
 			threads.Select(x => x.Discord = this);
 
 			await this._threadListSynced.InvokeAsync(this, new ThreadListSyncEventArgs(this.ServiceProvider) { Guild = guild, Channels = channels.ToList().AsReadOnly(), Threads = threads, Members = members.ToList().AsReadOnly() }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="ThreadMemberUpdated"/> event.
 		/// </summary>
 		/// <param name="member">The updated member.</param>
 		internal async Task OnThreadMemberUpdateEventAsync(DiscordThreadChannelMember member)
 		{
 			member.Discord = this;
 			var thread = this.InternalGetCachedThread(member.Id);
 			if (thread == null)
 			{
 				var tempThread = await this.ApiClient.GetThreadAsync(member.Id);
 				thread = this.GuildsInternal[member.GuildId].ThreadsInternal.AddOrUpdate(member.Id, tempThread, (old, newThread) => newThread);
 			}
 
 			thread.CurrentMember = member;
 			thread.Guild.ThreadsInternal.AddOrUpdate(member.Id, thread, (oldThread, newThread) => newThread);
 
 
 			await this._threadMemberUpdated.InvokeAsync(this, new ThreadMemberUpdateEventArgs(this.ServiceProvider) { ThreadMember = member, Thread = thread }).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Dispatches the <see cref="ThreadMembersUpdated"/> event.
 		/// </summary>
 		/// <param name="guild">The target guild.</param>
 		/// <param name="threadId">The thread id of the target thread this update belongs to.</param>
 		/// <param name="membersAdded">The added members.</param>
 		/// <param name="membersRemoved">The ids of the removed members.</param>
 		/// <param name="memberCount">The new member count.</param>
 		internal async Task OnThreadMembersUpdateEventAsync(DiscordGuild guild, ulong threadId, JArray membersAdded, JArray membersRemoved, int memberCount)
 		{
 			var thread = this.InternalGetCachedThread(threadId);
 			if (thread == null)
 			{
 				var tempThread = await this.ApiClient.GetThreadAsync(threadId);
 				thread = guild.ThreadsInternal.AddOrUpdate(threadId, tempThread, (old, newThread) => newThread);
 			}
 
 			thread.Discord = this;
 			guild.Discord = this;
 			List<DiscordThreadChannelMember> addedMembers = new();
 			List<ulong> removedMemberIds = new();
 
 			if (membersAdded != null)
 			{
 				foreach (var xj in membersAdded)
 				{
 					var xtm = xj.ToDiscordObject<DiscordThreadChannelMember>();
 					xtm.Discord = this;
 					xtm.GuildId = guild.Id;
 					if (xtm != null)
 						addedMembers.Add(xtm);
 
 					if (xtm.Id == this.CurrentUser.Id)
 						thread.CurrentMember = xtm;
 				}
 			}
 
 			var removedMembers = new List<DiscordMember>();
 			if (membersRemoved != null)
 			{
 				foreach (var removedId in membersRemoved)
 				{
 					removedMembers.Add(guild.MembersInternal.TryGetValue((ulong)removedId, out var member) ? member : new DiscordMember { Id = (ulong)removedId, GuildId = guild.Id, Discord = this });
 				}
 			}
 
 			if (removedMemberIds.Contains(this.CurrentUser.Id)) //indicates the bot was removed from the thread
 				thread.CurrentMember = null;
 
 			thread.MemberCount = memberCount;
 
 			var threadMembersUpdateArg = new ThreadMembersUpdateEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Thread = thread,
 				AddedMembers = addedMembers,
 				RemovedMembers = removedMembers,
 				MemberCount = memberCount
 			};
 
 			await this._threadMembersUpdated.InvokeAsync(this, threadMembersUpdateArg).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Activities
 		/// <summary>
 		/// Dispatches the <see cref="EmbeddedActivityUpdated"/> event.
 		/// </summary>
 		/// <param name="trActivity">The transport activity.</param>
 		/// <param name="guild">The guild.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="jUsers">The users in the activity.</param>
 		/// <param name="appId">The application id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task OnEmbeddedActivityUpdateAsync(JObject trActivity, DiscordGuild guild, ulong channelId, JArray jUsers, ulong appId)
 			=> await Task.Delay(20);
 
 		/*{
             try
             {
                 var users = j_users?.ToObject<List<ulong>>();
 
                 DiscordActivity old = null;
                 var uid = $"{guild.Id}_{channel_id}_{app_id}";
 
                 if (this._embeddedActivities.TryGetValue(uid, out var activity))
                 {
                     old = new DiscordActivity(activity);
                     DiscordJson.PopulateObject(tr_activity, activity);
                 }
                 else
                 {
                     activity = tr_activity.ToObject<DiscordActivity>();
                     this._embeddedActivities[uid] = activity;
                 }
 
                 var activity_users = new List<DiscordMember>();
 
                 var channel = this.InternalGetCachedChannel(channel_id) ?? await this.ApiClient.GetChannelAsync(channel_id);
 
                 if (users != null)
                 {
                     foreach (var user in users)
                     {
                         var activity_user = guild._members.TryGetValue(user, out var member) ? member : new DiscordMember { Id = user, _guild_id = guild.Id, Discord = this };
                         activity_users.Add(activity_user);
                     }
                 }
                 else
                     activity_users = null;
 
                 var ea = new EmbeddedActivityUpdateEventArgs(this.ServiceProvider)
                 {
                     Guild = guild,
                     Users = activity_users,
                     Channel = channel
 
                 };
                 await this._embeddedActivityUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
             } catch (Exception ex)
             {
                 this.Logger.LogError(ex, ex.Message);
             }
         }*/
 
 		#endregion
 
 		#region User/Presence Update
 
 		/// <summary>
 		/// Handles the presence update event.
 		/// </summary>
 		/// <param name="rawPresence">The raw presence.</param>
 		/// <param name="rawUser">The raw user.</param>
 
 		internal async Task OnPresenceUpdateEventAsync(JObject rawPresence, JObject rawUser)
 		{
 			var uid = (ulong)rawUser["id"];
 			DiscordPresence old = null;
 
 			if (this.PresencesInternal.TryGetValue(uid, out var presence))
 			{
 				old = new DiscordPresence(presence);
 				DiscordJson.PopulateObject(rawPresence, presence);
 			}
 			else
 			{
 				presence = rawPresence.ToObject<DiscordPresence>();
 				presence.Discord = this;
 				presence.Activity = new DiscordActivity(presence.RawActivity);
 				this.PresencesInternal[presence.InternalUser.Id] = presence;
 			}
 
 			// reuse arrays / avoid linq (this is a hot zone)
 			if (presence.Activities == null || rawPresence["activities"] == null)
 			{
 				presence.InternalActivities = Array.Empty<DiscordActivity>();
 			}
 			else
 			{
 				if (presence.InternalActivities.Length != presence.RawActivities.Length)
 					presence.InternalActivities = new DiscordActivity[presence.RawActivities.Length];
 
 				for (var i = 0; i < presence.InternalActivities.Length; i++)
 					presence.InternalActivities[i] = new DiscordActivity(presence.RawActivities[i]);
 
 				if (presence.InternalActivities.Length > 0)
 				{
 					presence.RawActivity = presence.RawActivities[0];
 
 					if (presence.Activity != null)
 						presence.Activity.UpdateWith(presence.RawActivity);
 					else
 						presence.Activity = new DiscordActivity(presence.RawActivity);
 				}
 			}
 
 			if (this.UserCache.TryGetValue(uid, out var usr))
 			{
 				if (old != null)
 				{
 					old.InternalUser.Username = usr.Username;
 					old.InternalUser.Discriminator = usr.Discriminator;
 					old.InternalUser.AvatarHash = usr.AvatarHash;
 				}
 
 				if (rawUser["username"] is object)
 					usr.Username = (string)rawUser["username"];
 				if (rawUser["discriminator"] is object)
 					usr.Discriminator = (string)rawUser["discriminator"];
 				if (rawUser["avatar"] is object)
 					usr.AvatarHash = (string)rawUser["avatar"];
 
 				presence.InternalUser.Username = usr.Username;
 				presence.InternalUser.Discriminator = usr.Discriminator;
 				presence.InternalUser.AvatarHash = usr.AvatarHash;
 			}
 
 			var usrafter = usr ?? new DiscordUser(presence.InternalUser);
 			var ea = new PresenceUpdateEventArgs(this.ServiceProvider)
 			{
 				Status = presence.Status,
 				Activity = presence.Activity,
 				User = usr,
 				PresenceBefore = old,
 				PresenceAfter = presence,
 				UserBefore = old != null ? new DiscordUser(old.InternalUser) : usrafter,
 				UserAfter = usrafter
 			};
 			await this._presenceUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the user settings update event.
 		/// </summary>
 		/// <param name="user">The user.</param>
 
 		internal async Task OnUserSettingsUpdateEventAsync(TransportUser user)
 		{
 			var usr = new DiscordUser(user) { Discord = this };
 
 			var ea = new UserSettingsUpdateEventArgs(this.ServiceProvider)
 			{
 				User = usr
 			};
 			await this._userSettingsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the user update event.
 		/// </summary>
 		/// <param name="user">The user.</param>
 
 		internal async Task OnUserUpdateEventAsync(TransportUser user)
 		{
 			var usrOld = new DiscordUser
 			{
 				AvatarHash = this.CurrentUser.AvatarHash,
 				Discord = this,
 				Discriminator = this.CurrentUser.Discriminator,
 				Email = this.CurrentUser.Email,
 				Id = this.CurrentUser.Id,
 				IsBot = this.CurrentUser.IsBot,
 				MfaEnabled = this.CurrentUser.MfaEnabled,
 				Username = this.CurrentUser.Username,
 				Verified = this.CurrentUser.Verified
 			};
 
 			this.CurrentUser.AvatarHash = user.AvatarHash;
 			this.CurrentUser.Discriminator = user.Discriminator;
 			this.CurrentUser.Email = user.Email;
 			this.CurrentUser.Id = user.Id;
 			this.CurrentUser.IsBot = user.IsBot;
 			this.CurrentUser.MfaEnabled = user.MfaEnabled;
 			this.CurrentUser.Username = user.Username;
 			this.CurrentUser.Verified = user.Verified;
 
 			var ea = new UserUpdateEventArgs(this.ServiceProvider)
 			{
 				UserAfter = this.CurrentUser,
 				UserBefore = usrOld
 			};
 			await this._userUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Voice
 
 		/// <summary>
 		/// Handles the voice state update event.
 		/// </summary>
 		/// <param name="raw">The raw.</param>
 
 		internal async Task OnVoiceStateUpdateEventAsync(JObject raw)
 		{
 			var gid = (ulong)raw["guild_id"];
 			var uid = (ulong)raw["user_id"];
 			var gld = this.GuildsInternal[gid];
 
 			var vstateNew = raw.ToObject<DiscordVoiceState>();
 			vstateNew.Discord = this;
 
 			gld.VoiceStatesInternal.TryRemove(uid, out var vstateOld);
 
 			if (vstateNew.Channel != null)
 			{
 				gld.VoiceStatesInternal[vstateNew.UserId] = vstateNew;
 			}
 
 			if (gld.MembersInternal.TryGetValue(uid, out var mbr))
 			{
 				mbr.IsMuted = vstateNew.IsServerMuted;
 				mbr.IsDeafened = vstateNew.IsServerDeafened;
 			}
 			else
 			{
 				var transportMbr = vstateNew.TransportMember;
 				this.UpdateUser(new DiscordUser(transportMbr.User) { Discord = this }, gid, gld, transportMbr);
 			}
 
 			var ea = new VoiceStateUpdateEventArgs(this.ServiceProvider)
 			{
 				Guild = vstateNew.Guild,
 				Channel = vstateNew.Channel,
 				User = vstateNew.User,
 				SessionId = vstateNew.SessionId,
 
 				Before = vstateOld,
 				After = vstateNew
 			};
 			await this._voiceStateUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the voice server update event.
 		/// </summary>
 		/// <param name="endpoint">The endpoint.</param>
 		/// <param name="token">The token.</param>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnVoiceServerUpdateEventAsync(string endpoint, string token, DiscordGuild guild)
 		{
 			var ea = new VoiceServerUpdateEventArgs(this.ServiceProvider)
 			{
 				Endpoint = endpoint,
 				VoiceToken = token,
 				Guild = guild
 			};
 			await this._voiceServerUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Commands
 
 		/// <summary>
 		/// Handles the application command create.
 		/// </summary>
 		/// <param name="cmd">The cmd.</param>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task OnApplicationCommandCreateAsync(DiscordApplicationCommand cmd, ulong? guildId)
 		{
 			cmd.Discord = this;
 
 			var guild = this.InternalGetCachedGuild(guildId);
 
 			if (guild == null && guildId.HasValue)
 			{
 				guild = new DiscordGuild
 				{
 					Id = guildId.Value,
 					Discord = this
 				};
 			}
 
 			var ea = new ApplicationCommandEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Command = cmd
 			};
 
 			await this._applicationCommandCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the application command update.
 		/// </summary>
 		/// <param name="cmd">The cmd.</param>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task OnApplicationCommandUpdateAsync(DiscordApplicationCommand cmd, ulong? guildId)
 		{
 			cmd.Discord = this;
 
 			var guild = this.InternalGetCachedGuild(guildId);
 
 			if (guild == null && guildId.HasValue)
 			{
 				guild = new DiscordGuild
 				{
 					Id = guildId.Value,
 					Discord = this
 				};
 			}
 
 			var ea = new ApplicationCommandEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Command = cmd
 			};
 
 			await this._applicationCommandUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the application command delete.
 		/// </summary>
 		/// <param name="cmd">The cmd.</param>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task OnApplicationCommandDeleteAsync(DiscordApplicationCommand cmd, ulong? guildId)
 		{
 			cmd.Discord = this;
 
 			var guild = this.InternalGetCachedGuild(guildId);
 
 			if (guild == null && guildId.HasValue)
 			{
 				guild = new DiscordGuild
 				{
 					Id = guildId.Value,
 					Discord = this
 				};
 			}
 
 			var ea = new ApplicationCommandEventArgs(this.ServiceProvider)
 			{
 				Guild = guild,
 				Command = cmd
 			};
 
 			await this._applicationCommandDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the guild application command counts update.
 		/// </summary>
 		/// <param name="sc">The <see cref="ApplicationCommandType.ChatInput"/> count.</param>
 		/// <param name="ucmc">The <see cref="ApplicationCommandType.User"/> count.</param>
 		/// <param name="mcmc">The <see cref="ApplicationCommandType.Message"/> count.</param>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>Count of application commands.</returns>
 		internal async Task OnGuildApplicationCommandCountsUpdateAsync(int sc, int ucmc, int mcmc, ulong guildId)
 		{
 			var guild = this.InternalGetCachedGuild(guildId);
 
 			if (guild == null)
 			{
 				guild = new DiscordGuild
 				{
 					Id = guildId,
 					Discord = this
 				};
 			}
 
 			var ea = new GuildApplicationCommandCountEventArgs(this.ServiceProvider)
 			{
 				SlashCommands = sc,
 				UserContextMenuCommands = ucmc,
 				MessageContextMenuCommands = mcmc,
 				Guild = guild
 			};
 
 			await this._guildApplicationCommandCountUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the application command permissions update.
 		/// </summary>
 		/// <param name="perms">The new permissions.</param>
 		/// <param name="cId">The command id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="aId">The application id.</param>
 		internal async Task OnApplicationCommandPermissionsUpdateAsync(IEnumerable<DiscordApplicationCommandPermission> perms, ulong cId, ulong guildId, ulong aId)
 		{
 			if (aId != this.CurrentApplication.Id)
 				return;
 
 			var guild = this.InternalGetCachedGuild(guildId);
 
 			DiscordApplicationCommand cmd;
 			try
 			{
 				cmd = await this.GetGuildApplicationCommandAsync(guildId, cId);
 			}
 			catch (NotFoundException)
 			{
 				cmd = await this.GetGlobalApplicationCommandAsync(cId);
 			}
 
 			if (guild == null)
 			{
 				guild = new DiscordGuild
 				{
 					Id = guildId,
 					Discord = this
 				};
 			}
 
 			var ea = new ApplicationCommandPermissionsUpdateEventArgs(this.ServiceProvider)
 			{
 				Permissions = perms.ToList(),
 				Command = cmd,
 				ApplicationId = aId,
 				Guild = guild
 			};
 
 			await this._applicationCommandPermissionsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Interaction
 
 		/// <summary>
 		/// Handles the interaction create.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="user">The user.</param>
 		/// <param name="member">The member.</param>
 		/// <param name="interaction">The interaction.</param>
 		internal async Task OnInteractionCreateAsync(ulong? guildId, ulong channelId, TransportUser user, TransportMember member, DiscordInteraction interaction)
 		{
 			var usr = new DiscordUser(user) { Discord = this };
 
 			interaction.ChannelId = channelId;
 			interaction.GuildId = guildId;
 			interaction.Discord = this;
 			interaction.Data.Discord = this;
 
 			if (member != null)
 			{
 				usr = new DiscordMember(member) { GuildId = guildId.Value, Discord = this };
 				this.UpdateUser(usr, guildId, interaction.Guild, member);
 			}
 			else
 			{
 				this.UserCache.AddOrUpdate(usr.Id, usr, (old, @new) => @new);
 			}
 
 			interaction.User = usr;
 
 			var resolved = interaction.Data.Resolved;
 			if (resolved != null)
 			{
 				if (resolved.Users != null)
 				{
 					foreach (var c in resolved.Users)
 					{
 						c.Value.Discord = this;
 						this.UserCache.AddOrUpdate(c.Value.Id, c.Value, (old, @new) => @new);
 					}
 				}
 
 				if (resolved.Members != null)
 				{
 					foreach (var c in resolved.Members)
 					{
 						c.Value.Discord = this;
 						c.Value.Id = c.Key;
 						c.Value.GuildId = guildId.Value;
 						c.Value.User.Discord = this;
 						this.UserCache.AddOrUpdate(c.Value.User.Id, c.Value.User, (old, @new) => @new);
 					}
 				}
 
 				if (resolved.Channels != null)
 				{
 					foreach (var c in resolved.Channels)
 					{
 						c.Value.Discord = this;
 
 						if (guildId.HasValue)
 							c.Value.GuildId = guildId.Value;
 					}
 				}
 
 				if (resolved.Roles != null)
 				{
 					foreach (var c in resolved.Roles)
 					{
 						c.Value.Discord = this;
 
 						if (guildId.HasValue)
 							c.Value.GuildId = guildId.Value;
 					}
 				}
 
 
 				if (resolved.Messages != null)
 				{
 					foreach (var m in resolved.Messages)
 					{
 						m.Value.Discord = this;
 
 						if (guildId.HasValue)
 							m.Value.GuildId = guildId.Value;
 					}
 				}
 			}
 
 			if (interaction.Type is InteractionType.Component || interaction.Type is InteractionType.ModalSubmit)
 			{
 				if (interaction.Message != null)
 				{
 					interaction.Message.Discord = this;
 					interaction.Message.ChannelId = interaction.ChannelId;
 				}
 				var cea = new ComponentInteractionCreateEventArgs(this.ServiceProvider)
 				{
 					Message = interaction.Message,
 					Interaction = interaction
 				};
 
 				await this._componentInteractionCreated.InvokeAsync(this, cea).ConfigureAwait(false);
 			}
 			else
 			{
 				if (interaction.Data.Target.HasValue) // Context-Menu. //
 				{
 					var targetId = interaction.Data.Target.Value;
 					DiscordUser targetUser = null;
 					DiscordMember targetMember = null;
 					DiscordMessage targetMessage = null;
 
 					interaction.Data.Resolved.Messages?.TryGetValue(targetId, out targetMessage);
 					interaction.Data.Resolved.Members?.TryGetValue(targetId, out targetMember);
 					interaction.Data.Resolved.Users?.TryGetValue(targetId, out targetUser);
 
 					var ctea = new ContextMenuInteractionCreateEventArgs(this.ServiceProvider)
 					{
 						Interaction = interaction,
 						TargetUser = targetMember ?? targetUser,
 						TargetMessage = targetMessage,
 						Type = interaction.Data.Type,
 					};
 					await this._contextMenuInteractionCreated.InvokeAsync(this, ctea).ConfigureAwait(false);
 				}
 				else
 				{
 					var ea = new InteractionCreateEventArgs(this.ServiceProvider)
 					{
 						Interaction = interaction
 					};
 
 					await this._interactionCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 				}
 			}
 		}
 
 		#endregion
 
 		#region Misc
 
 		/// <summary>
 		/// Handles the typing start event.
 		/// </summary>
 		/// <param name="userId">The user id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="channel">The channel.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="started">The started.</param>
 		/// <param name="mbr">The mbr.</param>
 
 		internal async Task OnTypingStartEventAsync(ulong userId, ulong channelId, DiscordChannel channel, ulong? guildId, DateTimeOffset started, TransportMember mbr)
 		{
 			if (channel == null)
 			{
 				channel = new DiscordChannel
 				{
 					Discord = this,
 					Id = channelId,
 					GuildId = guildId ?? default,
 				};
 			}
 
 			var guild = this.InternalGetCachedGuild(guildId);
 			var usr = this.UpdateUser(new DiscordUser { Id = userId, Discord = this }, guildId, guild, mbr);
 
 			var ea = new TypingStartEventArgs(this.ServiceProvider)
 			{
 				Channel = channel,
 				User = usr,
 				Guild = guild,
 				StartedAt = started
 			};
 			await this._typingStarted.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the webhooks update.
 		/// </summary>
 		/// <param name="channel">The channel.</param>
 		/// <param name="guild">The guild.</param>
 
 		internal async Task OnWebhooksUpdateAsync(DiscordChannel channel, DiscordGuild guild)
 		{
 			var ea = new WebhooksUpdateEventArgs(this.ServiceProvider)
 			{
 				Channel = channel,
 				Guild = guild
 			};
 			await this._webhooksUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Handles the unknown event.
 		/// </summary>
 		/// <param name="payload">The payload.</param>
 
 		internal async Task OnUnknownEventAsync(GatewayPayload payload)
 		{
 			var ea = new UnknownEventArgs(this.ServiceProvider) { EventName = payload.EventName, Json = (payload.Data as JObject)?.ToString() };
 			await this._unknownEvent.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#endregion
 	}
 }
diff --git a/DisCatSharp/Clients/DiscordClient.WebSocket.cs b/DisCatSharp/Clients/DiscordClient.WebSocket.cs
index 203515a60..25b0c247d 100644
--- a/DisCatSharp/Clients/DiscordClient.WebSocket.cs
+++ b/DisCatSharp/Clients/DiscordClient.WebSocket.cs
@@ -1,601 +1,601 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.WebSocket;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Represents a discord websocket client.
 	/// </summary>
 	public sealed partial class DiscordClient
 	{
 		#region Private Fields
 
 		private int _heartbeatInterval;
 		private DateTimeOffset _lastHeartbeat;
 		[System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "<Pending>")]
 		private Task _heartbeatTask;
 
 		internal static DateTimeOffset DiscordEpoch = new(2015, 1, 1, 0, 0, 0, TimeSpan.Zero);
 
-		private int _skippedHeartbeats = 0;
+		private int _skippedHeartbeats;
 		private long _lastSequence;
 
 		internal IWebSocketClient WebSocketClient;
 		private PayloadDecompressor _payloadDecompressor;
 
 		private CancellationTokenSource _cancelTokenSource;
 		private CancellationToken _cancelToken;
 
 		#endregion
 
 		#region Connection Semaphore
 
 		/// <summary>
 		/// Gets the socket locks.
 		/// </summary>
-		private static ConcurrentDictionary<ulong, SocketLock> s_socketLocks { get; } = new ConcurrentDictionary<ulong, SocketLock>();
+		private static ConcurrentDictionary<ulong, SocketLock> s_socketLocks { get; } = new();
 
 		/// <summary>
 		/// Gets the session lock.
 		/// </summary>
 		private readonly ManualResetEventSlim _sessionLock  = new(true);
 
 		#endregion
 
 		#region Internal Connection Methods
 
 		/// <summary>
 		/// Internals the reconnect async.
 		/// </summary>
 		/// <param name="startNewSession">If true, start new session.</param>
 		/// <param name="code">The code.</param>
 		/// <param name="message">The message.</param>
 		/// <returns>A Task.</returns>
 		private Task InternalReconnectAsync(bool startNewSession = false, int code = 1000, string message = "")
 		{
 			if (startNewSession)
 				this._sessionId = null;
 
 			_ = this.WebSocketClient.DisconnectAsync(code, message);
 			return Task.CompletedTask;
 		}
 
 		/// <summary>
 		/// Internals the connect async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task InternalConnectAsync()
 		{
 			SocketLock socketLock = null;
 			try
 			{
 				if (this.GatewayInfo == null)
 					await this.InternalUpdateGatewayAsync().ConfigureAwait(false);
 				await this.InitializeAsync().ConfigureAwait(false);
 
 				socketLock = this.GetSocketLock();
 				await socketLock.LockAsync().ConfigureAwait(false);
 			}
 			catch
 			{
 				socketLock?.UnlockAfter(TimeSpan.Zero);
 				throw;
 			}
 
 			if (!this.Presences.ContainsKey(this.CurrentUser.Id))
 			{
 				this.PresencesInternal[this.CurrentUser.Id] = new DiscordPresence
 				{
 					Discord = this,
 					RawActivity = new TransportActivity(),
 					Activity = new DiscordActivity(),
 					Status = UserStatus.Online,
 					InternalUser = new TransportUser
 					{
 						Id = this.CurrentUser.Id,
 						Username = this.CurrentUser.Username,
 						Discriminator = this.CurrentUser.Discriminator,
 						AvatarHash = this.CurrentUser.AvatarHash
 					}
 				};
 			}
 			else
 			{
 				var pr = this.PresencesInternal[this.CurrentUser.Id];
 				pr.RawActivity = new TransportActivity();
 				pr.Activity = new DiscordActivity();
 				pr.Status = UserStatus.Online;
 			}
 
 			Volatile.Write(ref this._skippedHeartbeats, 0);
 
 			this.WebSocketClient = this.Configuration.WebSocketClientFactory(this.Configuration.Proxy, this.ServiceProvider);
 			this._payloadDecompressor = this.Configuration.GatewayCompressionLevel != GatewayCompressionLevel.None
 				? new PayloadDecompressor(this.Configuration.GatewayCompressionLevel)
 				: null;
 
 			this._cancelTokenSource = new CancellationTokenSource();
 			this._cancelToken = this._cancelTokenSource.Token;
 
 			this.WebSocketClient.Connected += SocketOnConnect;
 			this.WebSocketClient.Disconnected += SocketOnDisconnect;
 			this.WebSocketClient.MessageReceived += SocketOnMessage;
 			this.WebSocketClient.ExceptionThrown += SocketOnException;
 
 			var gwuri = new QueryUriBuilder(this.GatewayUri)
 				.AddParameter("v", this.Configuration.ApiVersion)
 				.AddParameter("encoding", "json");
 
 			if (this.Configuration.GatewayCompressionLevel == GatewayCompressionLevel.Stream)
 				gwuri.AddParameter("compress", "zlib-stream");
 
 			await this.WebSocketClient.ConnectAsync(gwuri.Build()).ConfigureAwait(false);
 
 			Task SocketOnConnect(IWebSocketClient sender, SocketEventArgs e)
 				=> this._socketOpened.InvokeAsync(this, e);
 
 			async Task SocketOnMessage(IWebSocketClient sender, SocketMessageEventArgs e)
 			{
 				string msg = null;
 				if (e is SocketTextMessageEventArgs etext)
 				{
 					msg = etext.Message;
 				}
 				else if (e is SocketBinaryMessageEventArgs ebin) // :DDDD
 				{
 					using var ms = new MemoryStream();
 					if (!this._payloadDecompressor.TryDecompress(new ArraySegment<byte>(ebin.Message), ms))
 					{
 						this.Logger.LogError(LoggerEvents.WebSocketReceiveFailure, "Payload decompression failed");
 						return;
 					}
 
 					ms.Position = 0;
 					using var sr = new StreamReader(ms, Utilities.UTF8);
 					msg = await sr.ReadToEndAsync().ConfigureAwait(false);
 				}
 
 				try
 				{
 					this.Logger.LogTrace(LoggerEvents.GatewayWsRx, msg);
 					await this.HandleSocketMessageAsync(msg).ConfigureAwait(false);
 				}
 				catch (Exception ex)
 				{
 					this.Logger.LogError(LoggerEvents.WebSocketReceiveFailure, ex, "Socket handler suppressed an exception");
 				}
 			}
 
 			Task SocketOnException(IWebSocketClient sender, SocketErrorEventArgs e)
 				=> this._socketErrored.InvokeAsync(this, e);
 
 			async Task SocketOnDisconnect(IWebSocketClient sender, SocketCloseEventArgs e)
 			{
 				// release session and connection
 				this._connectionLock.Set();
 				this._sessionLock.Set();
 
 				if (!this._disposed)
 					this._cancelTokenSource.Cancel();
 
 				this.Logger.LogDebug(LoggerEvents.ConnectionClose, "Connection closed ({0}, '{1}')", e.CloseCode, e.CloseMessage);
 				await this._socketClosed.InvokeAsync(this, e).ConfigureAwait(false);
 
 
 
 				if (this.Configuration.AutoReconnect && (e.CloseCode < 4001 || e.CloseCode >= 5000))
 				{
 					this.Logger.LogCritical(LoggerEvents.ConnectionClose, "Connection terminated ({0}, '{1}'), reconnecting", e.CloseCode, e.CloseMessage);
 
 					if (this._status == null)
 						await this.ConnectAsync().ConfigureAwait(false);
 					else
 						if (this._status.IdleSince.HasValue)
 						await this.ConnectAsync(this._status.ActivityInternal, this._status.Status, Utilities.GetDateTimeOffsetFromMilliseconds(this._status.IdleSince.Value)).ConfigureAwait(false);
 					else
 						await this.ConnectAsync(this._status.ActivityInternal, this._status.Status).ConfigureAwait(false);
 				}
 				else
 				{
 					this.Logger.LogCritical(LoggerEvents.ConnectionClose, "Connection terminated ({0}, '{1}')", e.CloseCode, e.CloseMessage);
 				}
 			}
 		}
 
 		#endregion
 
 		#region WebSocket (Events)
 
 		/// <summary>
 		/// Handles the socket message async.
 		/// </summary>
 		/// <param name="data">The data.</param>
 		/// <returns>A Task.</returns>
 		internal async Task HandleSocketMessageAsync(string data)
 		{
 			var payload = JsonConvert.DeserializeObject<GatewayPayload>(data);
 			this._lastSequence = payload.Sequence ?? this._lastSequence;
 			switch (payload.OpCode)
 			{
 				case GatewayOpCode.Dispatch:
 					await this.HandleDispatchAsync(payload).ConfigureAwait(false);
 					break;
 
 				case GatewayOpCode.Heartbeat:
 					await this.OnHeartbeatAsync((long)payload.Data).ConfigureAwait(false);
 					break;
 
 				case GatewayOpCode.Reconnect:
 					await this.OnReconnectAsync().ConfigureAwait(false);
 					break;
 
 				case GatewayOpCode.InvalidSession:
 					await this.OnInvalidateSessionAsync((bool)payload.Data).ConfigureAwait(false);
 					break;
 
 				case GatewayOpCode.Hello:
 					await this.OnHelloAsync((payload.Data as JObject).ToObject<GatewayHello>()).ConfigureAwait(false);
 					break;
 
 				case GatewayOpCode.HeartbeatAck:
 					await this.OnHeartbeatAckAsync().ConfigureAwait(false);
 					break;
 
 				default:
 					this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Unknown Discord opcode: {0}\nPayload: {1}", payload.OpCode, payload.Data);
 					break;
 			}
 		}
 
 		/// <summary>
 		/// Ons the heartbeat async.
 		/// </summary>
 		/// <param name="seq">The seq.</param>
 		/// <returns>A Task.</returns>
 		internal async Task OnHeartbeatAsync(long seq)
 		{
 			this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received HEARTBEAT (OP1)");
 			await this.SendHeartbeatAsync(seq).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Ons the reconnect async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task OnReconnectAsync()
 		{
 			this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received RECONNECT (OP7)");
 			await this.InternalReconnectAsync(code: 4000, message: "OP7 acknowledged").ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Ons the invalidate session async.
 		/// </summary>
 		/// <param name="data">If true, data.</param>
 		/// <returns>A Task.</returns>
 		internal async Task OnInvalidateSessionAsync(bool data)
 		{
 			// begin a session if one is not open already
 			if (this._sessionLock.Wait(0))
 				this._sessionLock.Reset();
 
 			// we are sending a fresh resume/identify, so lock the socket
 			var socketLock = this.GetSocketLock();
 			await socketLock.LockAsync().ConfigureAwait(false);
 			socketLock.UnlockAfter(TimeSpan.FromSeconds(5));
 
 			if (data)
 			{
 				this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received INVALID_SESSION (OP9, true)");
 				await Task.Delay(6000).ConfigureAwait(false);
 				await this.SendResumeAsync().ConfigureAwait(false);
 			}
 			else
 			{
 				this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received INVALID_SESSION (OP9, false)");
 				this._sessionId = null;
 				await this.SendIdentifyAsync(this._status).ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Ons the hello async.
 		/// </summary>
 		/// <param name="hello">The hello.</param>
 		/// <returns>A Task.</returns>
 		internal async Task OnHelloAsync(GatewayHello hello)
 		{
 			this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received HELLO (OP10)");
 
 			if (this._sessionLock.Wait(0))
 			{
 				this._sessionLock.Reset();
 				this.GetSocketLock().UnlockAfter(TimeSpan.FromSeconds(5));
 			}
 			else
 			{
 				this.Logger.LogWarning(LoggerEvents.SessionUpdate, "Attempt to start a session while another session is active");
 				return;
 			}
 
 			Interlocked.CompareExchange(ref this._skippedHeartbeats, 0, 0);
 			this._heartbeatInterval = hello.HeartbeatInterval;
 			this._heartbeatTask = Task.Run(this.HeartbeatLoopAsync, this._cancelToken);
 
 			if (string.IsNullOrEmpty(this._sessionId))
 				await this.SendIdentifyAsync(this._status).ConfigureAwait(false);
 			else
 				await this.SendResumeAsync().ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Ons the heartbeat ack async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task OnHeartbeatAckAsync()
 		{
 			Interlocked.Decrement(ref this._skippedHeartbeats);
 
 			var ping = (int)(DateTime.Now - this._lastHeartbeat).TotalMilliseconds;
 
 			this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received HEARTBEAT_ACK (OP11, {0}ms)", ping);
 
 			Volatile.Write(ref this._ping, ping);
 
 			var args = new HeartbeatEventArgs(this.ServiceProvider)
 			{
 				Ping = this.Ping,
 				Timestamp = DateTimeOffset.Now
 			};
 
 			await this._heartbeated.InvokeAsync(this, args).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Heartbeats the loop async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task HeartbeatLoopAsync()
 		{
 			this.Logger.LogDebug(LoggerEvents.Heartbeat, "Heartbeat task started");
 			var token = this._cancelToken;
 			try
 			{
 				while (true)
 				{
 					await this.SendHeartbeatAsync(this._lastSequence).ConfigureAwait(false);
 					await Task.Delay(this._heartbeatInterval, token).ConfigureAwait(false);
 					token.ThrowIfCancellationRequested();
 				}
 			}
 			catch (OperationCanceledException) { }
 		}
 
 		#endregion
 
 		#region Internal Gateway Methods
 
 		/// <summary>
 		/// Internals the update status async.
 		/// </summary>
 		/// <param name="activity">The activity.</param>
 		/// <param name="userStatus">The user status.</param>
 		/// <param name="idleSince">The idle since.</param>
 		/// <returns>A Task.</returns>
 		internal async Task InternalUpdateStatusAsync(DiscordActivity activity, UserStatus? userStatus, DateTimeOffset? idleSince)
 		{
 			if (activity != null && activity.Name != null && activity.Name.Length > 128)
 				throw new Exception("Game name can't be longer than 128 characters!");
 
 			var sinceUnix = idleSince != null ? (long?)Utilities.GetUnixTime(idleSince.Value) : null;
 			var act = activity ?? new DiscordActivity();
 
 			var status = new StatusUpdate
 			{
 				Activity = new TransportActivity(act),
 				IdleSince = sinceUnix,
 				IsAfk = idleSince != null,
 				Status = userStatus ?? UserStatus.Online
 			};
 
 			// Solution to have status persist between sessions
 			this._status = status;
 			var statusUpdate = new GatewayPayload
 			{
 				OpCode = GatewayOpCode.StatusUpdate,
 				Data = status
 			};
 
 			var statusstr = JsonConvert.SerializeObject(statusUpdate);
 
 			await this.WsSendAsync(statusstr).ConfigureAwait(false);
 
 			if (!this.PresencesInternal.ContainsKey(this.CurrentUser.Id))
 			{
 				this.PresencesInternal[this.CurrentUser.Id] = new DiscordPresence
 				{
 					Discord = this,
 					Activity = act,
 					Status = userStatus ?? UserStatus.Online,
 					InternalUser = new TransportUser { Id = this.CurrentUser.Id }
 				};
 			}
 			else
 			{
 				var pr = this.PresencesInternal[this.CurrentUser.Id];
 				pr.Activity = act;
 				pr.Status = userStatus ?? pr.Status;
 			}
 		}
 
 		/// <summary>
 		/// Sends the heartbeat async.
 		/// </summary>
 		/// <param name="seq">The seq.</param>
 		/// <returns>A Task.</returns>
 		internal async Task SendHeartbeatAsync(long seq)
 		{
 			var moreThan5 = Volatile.Read(ref this._skippedHeartbeats) > 5;
 			var guildsComp = Volatile.Read(ref this._guildDownloadCompleted);
 			if (guildsComp && moreThan5)
 			{
 				this.Logger.LogCritical(LoggerEvents.HeartbeatFailure, "Server failed to acknowledge more than 5 heartbeats - connection is zombie");
 
 				var args = new ZombiedEventArgs(this.ServiceProvider)
 				{
 					Failures = Volatile.Read(ref this._skippedHeartbeats),
 					GuildDownloadCompleted = true
 				};
 				await this._zombied.InvokeAsync(this, args).ConfigureAwait(false);
 
 				await this.InternalReconnectAsync(code: 4001, message: "Too many heartbeats missed").ConfigureAwait(false);
 				return;
 			}
 			else if (!guildsComp && moreThan5)
 			{
 				var args = new ZombiedEventArgs(this.ServiceProvider)
 				{
 					Failures = Volatile.Read(ref this._skippedHeartbeats),
 					GuildDownloadCompleted = false
 				};
 				await this._zombied.InvokeAsync(this, args).ConfigureAwait(false);
 
 				this.Logger.LogWarning(LoggerEvents.HeartbeatFailure, "Server failed to acknowledge more than 5 heartbeats, but the guild download is still running - check your connection speed");
 			}
 
 			Volatile.Write(ref this._lastSequence, seq);
 			this.Logger.LogTrace(LoggerEvents.Heartbeat, "Sending heartbeat");
 			var heartbeat = new GatewayPayload
 			{
 				OpCode = GatewayOpCode.Heartbeat,
 				Data = seq
 			};
 			var heartbeatStr = JsonConvert.SerializeObject(heartbeat);
 			await this.WsSendAsync(heartbeatStr).ConfigureAwait(false);
 
 			this._lastHeartbeat = DateTimeOffset.Now;
 
 			Interlocked.Increment(ref this._skippedHeartbeats);
 		}
 
 		/// <summary>
 		/// Sends the identify async.
 		/// </summary>
 		/// <param name="status">The status.</param>
 		/// <returns>A Task.</returns>
 		internal async Task SendIdentifyAsync(StatusUpdate status)
 		{
 			var identify = new GatewayIdentify
 			{
 				Token = Utilities.GetFormattedToken(this),
 				Compress = this.Configuration.GatewayCompressionLevel == GatewayCompressionLevel.Payload,
 				LargeThreshold = this.Configuration.LargeThreshold,
 				ShardInfo = new ShardInfo
 				{
 					ShardId = this.Configuration.ShardId,
 					ShardCount = this.Configuration.ShardCount
 				},
 				Presence = status,
 				Intents = this.Configuration.Intents,
 				Discord = this
 			};
 			var payload = new GatewayPayload
 			{
 				OpCode = GatewayOpCode.Identify,
 				Data = identify
 			};
 			var payloadstr = JsonConvert.SerializeObject(payload);
 			await this.WsSendAsync(payloadstr).ConfigureAwait(false);
 
 			this.Logger.LogDebug(LoggerEvents.Intents, "Registered gateway intents ({0})", this.Configuration.Intents);
 		}
 
 		/// <summary>
 		/// Sends the resume async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task SendResumeAsync()
 		{
 			var resume = new GatewayResume
 			{
 				Token = Utilities.GetFormattedToken(this),
 				SessionId = this._sessionId,
 				SequenceNumber = Volatile.Read(ref this._lastSequence)
 			};
 			var resumePayload = new GatewayPayload
 			{
 				OpCode = GatewayOpCode.Resume,
 				Data = resume
 			};
 			var resumestr = JsonConvert.SerializeObject(resumePayload);
 
 			await this.WsSendAsync(resumestr).ConfigureAwait(false);
 		}
 		/// <summary>
 		/// Internals the update gateway async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task InternalUpdateGatewayAsync()
 		{
 			var info = await this.GetGatewayInfoAsync().ConfigureAwait(false);
 			this.GatewayInfo = info;
 			this.GatewayUri = new Uri(info.Url);
 		}
 
 		/// <summary>
 		/// Ws the send async.
 		/// </summary>
 		/// <param name="payload">The payload.</param>
 		/// <returns>A Task.</returns>
 		internal async Task WsSendAsync(string payload)
 		{
 			this.Logger.LogTrace(LoggerEvents.GatewayWsTx, payload);
 			await this.WebSocketClient.SendMessageAsync(payload).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Semaphore Methods
 
 		/// <summary>
 		/// Gets the socket lock.
 		/// </summary>
 		/// <returns>A SocketLock.</returns>
 		private SocketLock GetSocketLock()
 			=> s_socketLocks.GetOrAdd(this.CurrentApplication.Id, appId => new SocketLock(appId, this.GatewayInfo.SessionBucket.MaxConcurrency));
 
 		#endregion
 	}
 }
diff --git a/DisCatSharp/Clients/DiscordClient.cs b/DisCatSharp/Clients/DiscordClient.cs
index b2e8c0e75..81c7927e7 100644
--- a/DisCatSharp/Clients/DiscordClient.cs
+++ b/DisCatSharp/Clients/DiscordClient.cs
@@ -1,1316 +1,1316 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// A Discord API wrapper.
 	/// </summary>
 	public sealed partial class DiscordClient : BaseDiscordClient
 	{
 		#region Internal Fields/Properties
 
 		internal bool IsShard = false;
 		/// <summary>
 		/// Gets the message cache.
 		/// </summary>
 		internal RingBuffer<DiscordMessage> MessageCache { get; }
 
 		private List<BaseExtension> _extensions = new();
-		private StatusUpdate _status = null;
+		private StatusUpdate _status;
 
 		/// <summary>
 		/// Gets the connection lock.
 		/// </summary>
 		private readonly ManualResetEventSlim _connectionLock = new(true);
 
 		#endregion
 
 		#region Public Fields/Properties
 		/// <summary>
 		/// Gets the gateway protocol version.
 		/// </summary>
 		public int GatewayVersion { get; internal set; }
 
 		/// <summary>
 		/// Gets the gateway session information for this client.
 		/// </summary>
 		public GatewayInfo GatewayInfo { get; internal set; }
 
 		/// <summary>
 		/// Gets the gateway URL.
 		/// </summary>
 		public Uri GatewayUri { get; internal set; }
 
 		/// <summary>
 		/// Gets the total number of shards the bot is connected to.
 		/// </summary>
 		public int ShardCount => this.GatewayInfo != null
 			? this.GatewayInfo.ShardCount
 			: this.Configuration.ShardCount;
 
 		/// <summary>
 		/// Gets the currently connected shard ID.
 		/// </summary>
 		public int ShardId
 			=> this.Configuration.ShardId;
 
 		/// <summary>
 		/// Gets the intents configured for this client.
 		/// </summary>
 		public DiscordIntents Intents
 			=> this.Configuration.Intents;
 
 		/// <summary>
 		/// Gets a dictionary of guilds that this client is in. The dictionary's key is the guild ID. Note that the
 		/// guild objects in this dictionary will not be filled in if the specific guilds aren't available (the
 		/// <see cref="GuildAvailable"/> or <see cref="GuildDownloadCompleted"/> events haven't been fired yet)
 		/// </summary>
 		public override IReadOnlyDictionary<ulong, DiscordGuild> Guilds { get; }
 		internal ConcurrentDictionary<ulong, DiscordGuild> GuildsInternal = new();
 
 		/// <summary>
 		/// Gets the WS latency for this client.
 		/// </summary>
 		public int Ping
 			=> Volatile.Read(ref this._ping);
 
 		private int _ping;
 
 		/// <summary>
 		/// Gets the collection of presences held by this client.
 		/// </summary>
 		public IReadOnlyDictionary<ulong, DiscordPresence> Presences
 			=> this._presencesLazy.Value;
 
 		internal Dictionary<ulong, DiscordPresence> PresencesInternal = new();
 		private Lazy<IReadOnlyDictionary<ulong, DiscordPresence>> _presencesLazy;
 
 		/// <summary>
 		/// Gets the collection of presences held by this client.
 		/// </summary>
 		public IReadOnlyDictionary<string, DiscordActivity> EmbeddedActivities
 			=> this._embeddedActivitiesLazy.Value;
 
 		internal Dictionary<string, DiscordActivity> EmbeddedActivitiesInternal = new();
 		private Lazy<IReadOnlyDictionary<string, DiscordActivity>> _embeddedActivitiesLazy;
 		#endregion
 
 		#region Constructor/Internal Setup
 
 		/// <summary>
 		/// Initializes a new instance of <see cref="DiscordClient"/>.
 		/// </summary>
 		/// <param name="config">Specifies configuration parameters.</param>
 		public DiscordClient(DiscordConfiguration config)
 			: base(config)
 		{
 			if (this.Configuration.MessageCacheSize > 0)
 			{
 				var intents = this.Configuration.Intents;
 				this.MessageCache = intents.HasIntent(DiscordIntents.GuildMessages) || intents.HasIntent(DiscordIntents.DirectMessages)
 						? new RingBuffer<DiscordMessage>(this.Configuration.MessageCacheSize)
 						: null;
 			}
 
 			this.InternalSetup();
 
 			this.Guilds = new ReadOnlyConcurrentDictionary<ulong, DiscordGuild>(this.GuildsInternal);
 		}
 
 		/// <summary>
 		/// Internal setup of the Client.
 		/// </summary>
 		internal void InternalSetup()
 		{
 			this._clientErrored = new AsyncEvent<DiscordClient, ClientErrorEventArgs>("CLIENT_ERRORED", EventExecutionLimit, this.Goof);
 			this._socketErrored = new AsyncEvent<DiscordClient, SocketErrorEventArgs>("SOCKET_ERRORED", EventExecutionLimit, this.Goof);
 			this._socketOpened = new AsyncEvent<DiscordClient, SocketEventArgs>("SOCKET_OPENED", EventExecutionLimit, this.EventErrorHandler);
 			this._socketClosed = new AsyncEvent<DiscordClient, SocketCloseEventArgs>("SOCKET_CLOSED", EventExecutionLimit, this.EventErrorHandler);
 			this._ready = new AsyncEvent<DiscordClient, ReadyEventArgs>("READY", EventExecutionLimit, this.EventErrorHandler);
 			this._resumed = new AsyncEvent<DiscordClient, ReadyEventArgs>("RESUMED", EventExecutionLimit, this.EventErrorHandler);
 			this._channelCreated = new AsyncEvent<DiscordClient, ChannelCreateEventArgs>("CHANNEL_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._channelUpdated = new AsyncEvent<DiscordClient, ChannelUpdateEventArgs>("CHANNEL_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._channelDeleted = new AsyncEvent<DiscordClient, ChannelDeleteEventArgs>("CHANNEL_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._dmChannelDeleted = new AsyncEvent<DiscordClient, DmChannelDeleteEventArgs>("DM_CHANNEL_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._channelPinsUpdated = new AsyncEvent<DiscordClient, ChannelPinsUpdateEventArgs>("CHANNEL_PINS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildCreated = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildAvailable = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_AVAILABLE", EventExecutionLimit, this.EventErrorHandler);
 			this._guildUpdated = new AsyncEvent<DiscordClient, GuildUpdateEventArgs>("GUILD_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildDeleted = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildUnavailable = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_UNAVAILABLE", EventExecutionLimit, this.EventErrorHandler);
 			this._guildDownloadCompletedEv = new AsyncEvent<DiscordClient, GuildDownloadCompletedEventArgs>("GUILD_DOWNLOAD_COMPLETED", EventExecutionLimit, this.EventErrorHandler);
 			this._inviteCreated = new AsyncEvent<DiscordClient, InviteCreateEventArgs>("INVITE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._inviteDeleted = new AsyncEvent<DiscordClient, InviteDeleteEventArgs>("INVITE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageCreated = new AsyncEvent<DiscordClient, MessageCreateEventArgs>("MESSAGE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._presenceUpdated = new AsyncEvent<DiscordClient, PresenceUpdateEventArgs>("PRESENCE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildBanAdded = new AsyncEvent<DiscordClient, GuildBanAddEventArgs>("GUILD_BAN_ADD", EventExecutionLimit, this.EventErrorHandler);
 			this._guildBanRemoved = new AsyncEvent<DiscordClient, GuildBanRemoveEventArgs>("GUILD_BAN_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildEmojisUpdated = new AsyncEvent<DiscordClient, GuildEmojisUpdateEventArgs>("GUILD_EMOJI_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildStickersUpdated = new AsyncEvent<DiscordClient, GuildStickersUpdateEventArgs>("GUILD_STICKER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationsUpdated = new AsyncEvent<DiscordClient, GuildIntegrationsUpdateEventArgs>("GUILD_INTEGRATIONS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberAdded = new AsyncEvent<DiscordClient, GuildMemberAddEventArgs>("GUILD_MEMBER_ADD", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberRemoved = new AsyncEvent<DiscordClient, GuildMemberRemoveEventArgs>("GUILD_MEMBER_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberUpdated = new AsyncEvent<DiscordClient, GuildMemberUpdateEventArgs>("GUILD_MEMBER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildRoleCreated = new AsyncEvent<DiscordClient, GuildRoleCreateEventArgs>("GUILD_ROLE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildRoleUpdated = new AsyncEvent<DiscordClient, GuildRoleUpdateEventArgs>("GUILD_ROLE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildRoleDeleted = new AsyncEvent<DiscordClient, GuildRoleDeleteEventArgs>("GUILD_ROLE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageAcknowledged = new AsyncEvent<DiscordClient, MessageAcknowledgeEventArgs>("MESSAGE_ACKNOWLEDGED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageUpdated = new AsyncEvent<DiscordClient, MessageUpdateEventArgs>("MESSAGE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageDeleted = new AsyncEvent<DiscordClient, MessageDeleteEventArgs>("MESSAGE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._messagesBulkDeleted = new AsyncEvent<DiscordClient, MessageBulkDeleteEventArgs>("MESSAGE_BULK_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._interactionCreated = new AsyncEvent<DiscordClient, InteractionCreateEventArgs>("INTERACTION_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._componentInteractionCreated = new AsyncEvent<DiscordClient, ComponentInteractionCreateEventArgs>("COMPONENT_INTERACTED", EventExecutionLimit, this.EventErrorHandler);
 			this._contextMenuInteractionCreated = new AsyncEvent<DiscordClient, ContextMenuInteractionCreateEventArgs>("CONTEXT_MENU_INTERACTED", EventExecutionLimit, this.EventErrorHandler);
 			this._typingStarted = new AsyncEvent<DiscordClient, TypingStartEventArgs>("TYPING_STARTED", EventExecutionLimit, this.EventErrorHandler);
 			this._userSettingsUpdated = new AsyncEvent<DiscordClient, UserSettingsUpdateEventArgs>("USER_SETTINGS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._userUpdated = new AsyncEvent<DiscordClient, UserUpdateEventArgs>("USER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._voiceStateUpdated = new AsyncEvent<DiscordClient, VoiceStateUpdateEventArgs>("VOICE_STATE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._voiceServerUpdated = new AsyncEvent<DiscordClient, VoiceServerUpdateEventArgs>("VOICE_SERVER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMembersChunked = new AsyncEvent<DiscordClient, GuildMembersChunkEventArgs>("GUILD_MEMBERS_CHUNKED", EventExecutionLimit, this.EventErrorHandler);
 			this._unknownEvent = new AsyncEvent<DiscordClient, UnknownEventArgs>("UNKNOWN_EVENT", EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionAdded = new AsyncEvent<DiscordClient, MessageReactionAddEventArgs>("MESSAGE_REACTION_ADDED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionRemoved = new AsyncEvent<DiscordClient, MessageReactionRemoveEventArgs>("MESSAGE_REACTION_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionsCleared = new AsyncEvent<DiscordClient, MessageReactionsClearEventArgs>("MESSAGE_REACTIONS_CLEARED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionRemovedEmoji = new AsyncEvent<DiscordClient, MessageReactionRemoveEmojiEventArgs>("MESSAGE_REACTION_REMOVED_EMOJI", EventExecutionLimit, this.EventErrorHandler);
 			this._webhooksUpdated = new AsyncEvent<DiscordClient, WebhooksUpdateEventArgs>("WEBHOOKS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._heartbeated = new AsyncEvent<DiscordClient, HeartbeatEventArgs>("HEARTBEATED", EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandCreated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandUpdated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandDeleted = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildApplicationCommandCountUpdated = new AsyncEvent<DiscordClient, GuildApplicationCommandCountEventArgs>("GUILD_APPLICATION_COMMAND_COUNTS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandPermissionsUpdated = new AsyncEvent<DiscordClient, ApplicationCommandPermissionsUpdateEventArgs>("APPLICATION_COMMAND_PERMISSIONS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationCreated = new AsyncEvent<DiscordClient, GuildIntegrationCreateEventArgs>("INTEGRATION_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationUpdated = new AsyncEvent<DiscordClient, GuildIntegrationUpdateEventArgs>("INTEGRATION_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationDeleted = new AsyncEvent<DiscordClient, GuildIntegrationDeleteEventArgs>("INTEGRATION_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._stageInstanceCreated = new AsyncEvent<DiscordClient, StageInstanceCreateEventArgs>("STAGE_INSTANCE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._stageInstanceUpdated = new AsyncEvent<DiscordClient, StageInstanceUpdateEventArgs>("STAGE_INSTANCE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._stageInstanceDeleted = new AsyncEvent<DiscordClient, StageInstanceDeleteEventArgs>("STAGE_INSTANCE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadCreated = new AsyncEvent<DiscordClient, ThreadCreateEventArgs>("THREAD_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadUpdated = new AsyncEvent<DiscordClient, ThreadUpdateEventArgs>("THREAD_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadDeleted = new AsyncEvent<DiscordClient, ThreadDeleteEventArgs>("THREAD_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadListSynced = new AsyncEvent<DiscordClient, ThreadListSyncEventArgs>("THREAD_LIST_SYNCED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadMemberUpdated = new AsyncEvent<DiscordClient, ThreadMemberUpdateEventArgs>("THREAD_MEMBER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadMembersUpdated = new AsyncEvent<DiscordClient, ThreadMembersUpdateEventArgs>("THREAD_MEMBERS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._zombied = new AsyncEvent<DiscordClient, ZombiedEventArgs>("ZOMBIED", EventExecutionLimit, this.EventErrorHandler);
 			this._payloadReceived = new AsyncEvent<DiscordClient, PayloadReceivedEventArgs>("PAYLOAD_RECEIVED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventCreated = new AsyncEvent<DiscordClient, GuildScheduledEventCreateEventArgs>("GUILD_SCHEDULED_EVENT_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventUpdated = new AsyncEvent<DiscordClient, GuildScheduledEventUpdateEventArgs>("GUILD_SCHEDULED_EVENT_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventDeleted = new AsyncEvent<DiscordClient, GuildScheduledEventDeleteEventArgs>("GUILD_SCHEDULED_EVENT_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventUserAdded = new AsyncEvent<DiscordClient, GuildScheduledEventUserAddEventArgs>("GUILD_SCHEDULED_EVENT_USER_ADDED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventUserRemoved = new AsyncEvent<DiscordClient, GuildScheduledEventUserRemoveEventArgs>("GUILD_SCHEDULED_EVENT_USER_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 			this._embeddedActivityUpdated = new AsyncEvent<DiscordClient, EmbeddedActivityUpdateEventArgs>("EMBEDDED_ACTIVITY_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 
 			this.GuildsInternal.Clear();
 
 			this._presencesLazy = new Lazy<IReadOnlyDictionary<ulong, DiscordPresence>>(() => new ReadOnlyDictionary<ulong, DiscordPresence>(this.PresencesInternal));
 			this._embeddedActivitiesLazy = new Lazy<IReadOnlyDictionary<string, DiscordActivity>>(() => new ReadOnlyDictionary<string, DiscordActivity>(this.EmbeddedActivitiesInternal));
 		}
 
 		#endregion
 
 		#region Client Extension Methods
 
 		/// <summary>
 		/// Registers an extension with this client.
 		/// </summary>
 		/// <param name="ext">Extension to register.</param>
 		public void AddExtension(BaseExtension ext)
 		{
 			ext.Setup(this);
 			this._extensions.Add(ext);
 		}
 
 		/// <summary>
 		/// Retrieves a previously-registered extension from this client.
 		/// </summary>
 		/// <typeparam name="T">Type of extension to retrieve.</typeparam>
 		/// <returns>The requested extension.</returns>
 		public T GetExtension<T>() where T : BaseExtension
 			=> this._extensions.FirstOrDefault(x => x.GetType() == typeof(T)) as T;
 
 		#endregion
 
 		#region Public Connection Methods
 
 		/// <summary>
 		/// Connects to the gateway.
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when an invalid token was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task ConnectAsync(DiscordActivity activity = null, UserStatus? status = null, DateTimeOffset? idlesince = null)
 		{
 			// Check if connection lock is already set, and set it if it isn't
 			if (!this._connectionLock.Wait(0))
 				throw new InvalidOperationException("This client is already connected.");
 			this._connectionLock.Set();
 
 			var w = 7500;
 			var i = 5;
 			var s = false;
 			Exception cex = null;
 
 			if (activity == null && status == null && idlesince == null)
 				this._status = null;
 			else
 			{
 				var sinceUnix = idlesince != null ? (long?)Utilities.GetUnixTime(idlesince.Value) : null;
 				this._status = new StatusUpdate()
 				{
 					Activity = new TransportActivity(activity),
 					Status = status ?? UserStatus.Online,
 					IdleSince = sinceUnix,
 					IsAfk = idlesince != null,
 					ActivityInternal = activity
 				};
 			}
 
 			if (!this.IsShard)
 			{
 				if (this.Configuration.TokenType != TokenType.Bot)
 					this.Logger.LogWarning(LoggerEvents.Misc, "You are logging in with a token that is not a bot token. This is not officially supported by Discord, and can result in your account being terminated if you aren't careful.");
 				this.Logger.LogInformation(LoggerEvents.Startup, "Lib {0}, version {1}", this.BotLibrary, this.VersionString);
 			}
 
 			while (i-- > 0 || this.Configuration.ReconnectIndefinitely)
 			{
 				try
 				{
 					await this.InternalConnectAsync().ConfigureAwait(false);
 					s = true;
 					break;
 				}
 				catch (UnauthorizedException e)
 				{
 					FailConnection(this._connectionLock);
 					throw new Exception("Authentication failed. Check your token and try again.", e);
 				}
 				catch (PlatformNotSupportedException)
 				{
 					FailConnection(this._connectionLock);
 					throw;
 				}
 				catch (NotImplementedException)
 				{
 					FailConnection(this._connectionLock);
 					throw;
 				}
 				catch (Exception ex)
 				{
 					FailConnection(null);
 
 					cex = ex;
 					if (i <= 0 && !this.Configuration.ReconnectIndefinitely) break;
 
 					this.Logger.LogError(LoggerEvents.ConnectionFailure, ex, "Connection attempt failed, retrying in {0}s", w / 1000);
 					await Task.Delay(w).ConfigureAwait(false);
 
 					if (i > 0)
 						w *= 2;
 				}
 			}
 
 			if (!s && cex != null)
 			{
 				this._connectionLock.Set();
 				throw new Exception("Could not connect to Discord.", cex);
 			}
 
 			// non-closure, hence args
 			static void FailConnection(ManualResetEventSlim cl) =>
 				// unlock this (if applicable) so we can let others attempt to connect
 				cl?.Set();
 		}
 
 		/// <summary>
 		/// Reconnects to the gateway.
 		/// </summary>
 		/// <param name="startNewSession">If true, start new session.</param>
 		public Task ReconnectAsync(bool startNewSession = false)
 			=> this.InternalReconnectAsync(startNewSession, code: startNewSession ? 1000 : 4002);
 
 		/// <summary>
 		/// Disconnects from the gateway.
 		/// </summary>
 		/// <returns></returns>
 		public async Task DisconnectAsync()
 		{
 			this.Configuration.AutoReconnect = false;
 			if (this.WebSocketClient != null)
 				await this.WebSocketClient.DisconnectAsync().ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Public REST Methods
 		/// <summary>
 		/// Gets a user.
 		/// </summary>
 		/// <param name="userId">Id of the user</param>
 		/// <param name="fetch">Whether to fetch the user again (Defaults to false).</param>
 		/// <returns>The requested user.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordUser> GetUserAsync(ulong userId, bool fetch = true)
 		{
 			if (!fetch)
 			{
 				return this.TryGetCachedUserInternal(userId, out var usr) ? usr : new DiscordUser { Id = userId, Discord = this };
 			}
 			else
 			{
 				var usr = await this.ApiClient.GetUserAsync(userId).ConfigureAwait(false);
 				usr = this.UserCache.AddOrUpdate(userId, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					old.BannerHash = usr.BannerHash;
 					old.BannerColorInternal = usr.BannerColorInternal;
 					return old;
 				});
 
 				return usr;
 			}
 		}
 
 		/// <summary>
 		/// Gets a channel.
 		/// </summary>
 		/// <param name="id">The id of the channel to get.</param>
 		/// <returns>The requested channel.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordChannel> GetChannelAsync(ulong id)
 			=> this.InternalGetCachedChannel(id) ?? await this.ApiClient.GetChannelAsync(id).ConfigureAwait(false);
 
 		/// <summary>
 		/// Gets a thread.
 		/// </summary>
 		/// <param name="id">The id of the thread to get.</param>
 		/// <returns>The requested thread.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordThreadChannel> GetThreadAsync(ulong id)
 			=> this.InternalGetCachedThread(id) ?? await this.ApiClient.GetThreadAsync(id).ConfigureAwait(false);
 
 		/// <summary>
 		/// Sends a normal message.
 		/// </summary>
 		/// <param name="channel">Channel to send to.</param>
 		/// <param name="content">Message content to send.</param>
 		/// <returns>The message that was sent.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content)
 			=> this.ApiClient.CreateMessageAsync(channel.Id, content, embeds: null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 		/// <summary>
 		/// Sends a message with an embed.
 		/// </summary>
 		/// <param name="channel">Channel to send to.</param>
 		/// <param name="embed">Embed to attach to the message.</param>
 		/// <returns>The message that was sent.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordEmbed embed)
 			=> this.ApiClient.CreateMessageAsync(channel.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 		/// <summary>
 		/// Sends a message with content and an embed.
 		/// </summary>
 		/// <param name="channel">Channel to send to.</param>
 		/// <param name="content">Message content to send.</param>
 		/// <param name="embed">Embed to attach to the message.</param>
 		/// <returns>The message that was sent.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content, DiscordEmbed embed)
 			=> this.ApiClient.CreateMessageAsync(channel.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 		/// <summary>
 		/// Sends a message with the <see cref="DisCatSharp.Entities.DiscordMessageBuilder"/>.
 		/// </summary>
 		/// <param name="channel">Channel to send the message to.</param>
 		/// <param name="builder">The message builder.</param>
 		/// <returns>The message that was sent.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordMessageBuilder builder)
 			=> this.ApiClient.CreateMessageAsync(channel.Id, builder);
 
 		/// <summary>
 		/// Sends a message with an <see cref="System.Action{DiscordMessageBuilder}"/>.
 		/// </summary>
 		/// <param name="channel">Channel to send the message to.</param>
 		/// <param name="action">The message builder.</param>
 		/// <returns>The message that was sent.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, Action<DiscordMessageBuilder> action)
 		{
 			var builder = new DiscordMessageBuilder();
 			action(builder);
 
 			return this.ApiClient.CreateMessageAsync(channel.Id, builder);
 		}
 
 		/// <summary>
 		/// Creates a guild. This requires the bot to be in less than 10 guilds total.
 		/// </summary>
 		/// <param name="name">Name of the guild.</param>
 		/// <param name="region">Voice region of the guild.</param>
 		/// <param name="icon">Stream containing the icon for the guild.</param>
 		/// <param name="verificationLevel">Verification level for the guild.</param>
 		/// <param name="defaultMessageNotifications">Default message notification settings for the guild.</param>
 		/// <param name="systemChannelFlags">System channel flags fopr the guild.</param>
 		/// <returns>The created guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuild> CreateGuildAsync(string name, string region = null, Optional<Stream> icon = default, VerificationLevel? verificationLevel = null,
 			DefaultMessageNotifications? defaultMessageNotifications = null, SystemChannelFlags? systemChannelFlags = null)
 		{
 			var iconb64 = Optional.FromNoValue<string>();
 			if (icon.HasValue && icon.Value != null)
 				using (var imgtool = new ImageTool(icon.Value))
 					iconb64 = imgtool.GetBase64();
 			else if (icon.HasValue)
 				iconb64 = null;
 
 			return this.ApiClient.CreateGuildAsync(name, region, iconb64, verificationLevel, defaultMessageNotifications, systemChannelFlags);
 		}
 
 		/// <summary>
 		/// Creates a guild from a template. This requires the bot to be in less than 10 guilds total.
 		/// </summary>
 		/// <param name="code">The template code.</param>
 		/// <param name="name">Name of the guild.</param>
 		/// <param name="icon">Stream containing the icon for the guild.</param>
 		/// <returns>The created guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuild> CreateGuildFromTemplateAsync(string code, string name, Optional<Stream> icon = default)
 		{
 			var iconb64 = Optional.FromNoValue<string>();
 			if (icon.HasValue && icon.Value != null)
 				using (var imgtool = new ImageTool(icon.Value))
 					iconb64 = imgtool.GetBase64();
 			else if (icon.HasValue)
 				iconb64 = null;
 
 			return this.ApiClient.CreateGuildFromTemplateAsync(code, name, iconb64);
 		}
 
 		/// <summary>
 		/// Executes a raw request.
 		/// </summary>
 		/// <example>
 		/// <c>
 		/// var request = await Client.ExecuteRawRequestAsync(RestRequestMethod.GET, $"{Endpoints.CHANNELS}/243184972190742178964/{Endpoints.INVITES}");
 		/// List&lt;DiscordInvite&gt; invites = DiscordJson.ToDiscordObject&lt;List&lt;DiscordInvite&gt;&gt;(request.Response);
 		/// </c>
 		/// </example>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <param name="routeParams">The route parameters.</param>
 		/// <param name="jsonBody">The json body.</param>
 		/// <param name="additionalHeaders">The addditional headers.</param>
 		/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the ressource does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <returns>A awaitable RestResponse</returns>
 		public async Task<RestResponse> ExecuteRawRequestAsync(RestRequestMethod method, string route, object routeParams, string jsonBody = null, Dictionary<string, string> additionalHeaders = null, double? ratelimitWaitOverride = null)
 		{
 
 			var bucket = this.ApiClient.Rest.GetBucket(method, route, routeParams, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Configuration);
 			var res = await this.ApiClient.DoRequestAsync(this, bucket, url, method, route, additionalHeaders, DiscordJson.SerializeObject(jsonBody), ratelimitWaitOverride);
 
 			return res;
 		}
 
 		/// <summary>
 		/// Gets a guild.
 		/// <para>Setting <paramref name="withCounts"/> to true will make a REST request.</para>
 		/// </summary>
 		/// <param name="id">The guild ID to search for.</param>
 		/// <param name="withCounts">Whether to include approximate presence and member counts in the returned guild.</param>
 		/// <returns>The requested Guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordGuild> GetGuildAsync(ulong id, bool? withCounts = null)
 		{
 			if (this.GuildsInternal.TryGetValue(id, out var guild) && (!withCounts.HasValue || !withCounts.Value))
 				return guild;
 
 			guild = await this.ApiClient.GetGuildAsync(id, withCounts).ConfigureAwait(false);
 			var channels = await this.ApiClient.GetGuildChannelsAsync(guild.Id).ConfigureAwait(false);
 			foreach (var channel in channels) guild.ChannelsInternal[channel.Id] = channel;
 
 			return guild;
 		}
 
 		/// <summary>
 		/// Gets a guild preview.
 		/// </summary>
 		/// <param name="id">The guild ID.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong id)
 			=> this.ApiClient.GetGuildPreviewAsync(id);
 
 		/// <summary>
 		/// Gets an invite.
 		/// </summary>
 		/// <param name="code">The invite code.</param>
 		/// <param name="withCounts">Whether to include presence and total member counts in the returned invite.</param>
 		/// <param name="withExpiration">Whether to include the expiration date in the returned invite.</param>
 		/// <param name="scheduledEventId">The scheduled event id.</param>
 		/// <returns>The requested Invite.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the invite does not exists.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordInvite> GetInviteByCodeAsync(string code, bool? withCounts = null, bool? withExpiration = null, ulong? scheduledEventId = null)
 			=> this.ApiClient.GetInviteAsync(code, withCounts, withExpiration, scheduledEventId);
 
 		/// <summary>
 		/// Gets a list of connections.
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordConnection>> GetConnectionsAsync()
 			=> this.ApiClient.GetUsersConnectionsAsync();
 
 		/// <summary>
 		/// Gets a sticker.
 		/// </summary>
 		/// <returns>The requested sticker.</returns>
 		/// <param name="id">The id of the sticker.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the sticker does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordSticker> GetStickerAsync(ulong id)
 			=> this.ApiClient.GetStickerAsync(id);
 
 
 		/// <summary>
 		/// Gets all nitro sticker packs.
 		/// </summary>
 		/// <returns>List of sticker packs.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordStickerPack>> GetStickerPacksAsync()
 			=> this.ApiClient.GetStickerPacksAsync();
 
 
 		/// <summary>
 		/// Gets the In-App OAuth Url.
 		/// </summary>
 		/// <param name="scopes">Defaults to <see cref="DisCatSharp.Enums.OAuthScopes.BOT_DEFAULT"/>.</param>
 		/// <param name="redir">Redirect Uri.</param>
 		/// <param name="permissions">Defaults to <see cref="Permissions.None"/>.</param>
 		/// <returns>The OAuth Url</returns>
 		public Uri GetInAppOAuth(Permissions permissions = Permissions.None, OAuthScopes scopes = OAuthScopes.BOT_DEFAULT, string redir = null)
 		{
 			permissions &= PermissionMethods.FullPerms;
 			// hey look, it's not all annoying and blue :P
 			return new Uri(new QueryUriBuilder($"{DiscordDomain.GetDomain(CoreDomain.Discord).Url}{Endpoints.OAUTH2}{Endpoints.AUTHORIZE}")
 				.AddParameter("client_id", this.CurrentApplication.Id.ToString(CultureInfo.InvariantCulture))
 				.AddParameter("scope", OAuth.ResolveScopes(scopes))
 				.AddParameter("permissions", ((long)permissions).ToString(CultureInfo.InvariantCulture))
 				.AddParameter("state", "")
 				.AddParameter("redirect_uri", redir ?? "")
 				.ToString());
 		}
 
 		/// <summary>
 		/// Gets a webhook.
 		/// </summary>
 		/// <param name="id">The target webhook id.</param>
 		/// <returns>The requested webhook.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordWebhook> GetWebhookAsync(ulong id)
 			=> this.ApiClient.GetWebhookAsync(id);
 
 		/// <summary>
 		/// Gets a webhook.
 		/// </summary>
 		/// <param name="id">The target webhook id.</param>
 		/// <param name="token">The target webhook token.</param>
 		/// <returns>The requested webhook.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong id, string token)
 			=> this.ApiClient.GetWebhookWithTokenAsync(id, token);
 
 		/// <summary>
 		/// Updates current user's activity and status.
 		/// </summary>
 		/// <param name="activity">Activity to set.</param>
 		/// <param name="userStatus">Status of the user.</param>
 		/// <param name="idleSince">Since when is the client performing the specified activity.</param>
 		/// <returns></returns>
 		public Task UpdateStatusAsync(DiscordActivity activity = null, UserStatus? userStatus = null, DateTimeOffset? idleSince = null)
 			=> this.InternalUpdateStatusAsync(activity, userStatus, idleSince);
 
 		/// <summary>
 		/// Edits current user.
 		/// </summary>
 		/// <param name="username">New username.</param>
 		/// <param name="avatar">New avatar.</param>
 		/// <returns>The modified user.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordUser> UpdateCurrentUserAsync(string username = null, Optional<Stream> avatar = default)
 		{
 			var av64 = Optional.FromNoValue<string>();
 			if (avatar.HasValue && avatar.Value != null)
 				using (var imgtool = new ImageTool(avatar.Value))
 					av64 = imgtool.GetBase64();
 			else if (avatar.HasValue)
 				av64 = null;
 
 			var usr = await this.ApiClient.ModifyCurrentUserAsync(username, av64).ConfigureAwait(false);
 
 			this.CurrentUser.Username = usr.Username;
 			this.CurrentUser.Discriminator = usr.Discriminator;
 			this.CurrentUser.AvatarHash = usr.AvatarHash;
 			return this.CurrentUser;
 		}
 
 		/// <summary>
 		/// Gets a guild template by the code.
 		/// </summary>
 		/// <param name="code">The code of the template.</param>
 		/// <returns>The guild template for the code.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildTemplate> GetTemplateAsync(string code)
 			=> this.ApiClient.GetTemplateAsync(code);
 
 		/// <summary>
 		/// Gets all the global application commands for this application.
 		/// </summary>
 		/// <returns>A list of global application commands.</returns>
 		public Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync() =>
 			this.ApiClient.GetGlobalApplicationCommandsAsync(this.CurrentApplication.Id);
 
 		/// <summary>
 		/// Overwrites the existing global application commands. New commands are automatically created and missing commands are automatically deleted.
 		/// </summary>
 		/// <param name="commands">The list of commands to overwrite with.</param>
 		/// <returns>The list of global commands.</returns>
 		public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGlobalApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
 			this.ApiClient.BulkOverwriteGlobalApplicationCommandsAsync(this.CurrentApplication.Id, commands);
 
 		/// <summary>
 		/// Creates or overwrites a global application command.
 		/// </summary>
 		/// <param name="command">The command to create.</param>
 		/// <returns>The created command.</returns>
 		public Task<DiscordApplicationCommand> CreateGlobalApplicationCommandAsync(DiscordApplicationCommand command) =>
 			this.ApiClient.CreateGlobalApplicationCommandAsync(this.CurrentApplication.Id, command);
 
 		/// <summary>
 		/// Gets a global application command by its id.
 		/// </summary>
 		/// <param name="commandId">The id of the command to get.</param>
 		/// <returns>The command with the id.</returns>
 		public Task<DiscordApplicationCommand> GetGlobalApplicationCommandAsync(ulong commandId) =>
 			this.ApiClient.GetGlobalApplicationCommandAsync(this.CurrentApplication.Id, commandId);
 
 		/// <summary>
 		/// Edits a global application command.
 		/// </summary>
 		/// <param name="commandId">The id of the command to edit.</param>
 		/// <param name="action">Action to perform.</param>
 		/// <returns>The edited command.</returns>
 		public async Task<DiscordApplicationCommand> EditGlobalApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
 		{
 			var mdl = new ApplicationCommandEditModel();
 			action(mdl);
 			var applicationId = this.CurrentApplication?.Id ?? (await this.GetCurrentApplicationAsync().ConfigureAwait(false)).Id;
 			return await this.ApiClient.EditGlobalApplicationCommandAsync(applicationId, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.DefaultPermission, mdl.NameLocalizations, mdl.DescriptionLocalizations).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Deletes a global application command.
 		/// </summary>
 		/// <param name="commandId">The id of the command to delete.</param>
 		public Task DeleteGlobalApplicationCommandAsync(ulong commandId) =>
 			this.ApiClient.DeleteGlobalApplicationCommandAsync(this.CurrentApplication.Id, commandId);
 
 		/// <summary>
 		/// Gets all the application commands for a guild.
 		/// </summary>
 		/// <param name="guildId">The id of the guild to get application commands for.</param>
 		/// <returns>A list of application commands in the guild.</returns>
 		public Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong guildId) =>
 			this.ApiClient.GetGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId);
 
 		/// <summary>
 		/// Overwrites the existing application commands in a guild. New commands are automatically created and missing commands are automatically deleted.
 		/// </summary>
 		/// <param name="guildId">The id of the guild.</param>
 		/// <param name="commands">The list of commands to overwrite with.</param>
 		/// <returns>The list of guild commands.</returns>
 		public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGuildApplicationCommandsAsync(ulong guildId, IEnumerable<DiscordApplicationCommand> commands) =>
 			this.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, commands);
 
 		/// <summary>
 		/// Creates or overwrites a guild application command.
 		/// </summary>
 		/// <param name="guildId">The id of the guild to create the application command in.</param>
 		/// <param name="command">The command to create.</param>
 		/// <returns>The created command.</returns>
 		public Task<DiscordApplicationCommand> CreateGuildApplicationCommandAsync(ulong guildId, DiscordApplicationCommand command) =>
 			this.ApiClient.CreateGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, command);
 
 		/// <summary>
 		/// Gets a application command in a guild by its id.
 		/// </summary>
 		/// <param name="guildId">The id of the guild the application command is in.</param>
 		/// <param name="commandId">The id of the command to get.</param>
 		/// <returns>The command with the id.</returns>
 		public Task<DiscordApplicationCommand> GetGuildApplicationCommandAsync(ulong guildId, ulong commandId) =>
 			 this.ApiClient.GetGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, commandId);
 
 		/// <summary>
 		/// Edits a application command in a guild.
 		/// </summary>
 		/// <param name="guildId">The id of the guild the application command is in.</param>
 		/// <param name="commandId">The id of the command to edit.</param>
 		/// <param name="action">Action to perform.</param>
 		/// <returns>The edited command.</returns>
 		public async Task<DiscordApplicationCommand> EditGuildApplicationCommandAsync(ulong guildId, ulong commandId, Action<ApplicationCommandEditModel> action)
 		{
 			var mdl = new ApplicationCommandEditModel();
 			action(mdl);
 			var applicationId = this.CurrentApplication?.Id ?? (await this.GetCurrentApplicationAsync().ConfigureAwait(false)).Id;
 			return await this.ApiClient.EditGuildApplicationCommandAsync(applicationId, guildId, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.DefaultPermission, mdl.NameLocalizations, mdl.DescriptionLocalizations).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Deletes a application command in a guild.
 		/// </summary>
 		/// <param name="guildId">The id of the guild to delete the application command in.</param>
 		/// <param name="commandId">The id of the command.</param>
 		public Task DeleteGuildApplicationCommandAsync(ulong guildId, ulong commandId) =>
 			this.ApiClient.DeleteGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, commandId);
 
 		/// <summary>
 		/// Gets all command permissions for a guild.
 		/// </summary>
 		/// <param name="guildId">The target guild.</param>
 		public Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> GetGuildApplicationCommandPermissionsAsync(ulong guildId) =>
 			this.ApiClient.GetGuildApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId);
 
 		/// <summary>
 		/// Gets the permissions for a guild command.
 		/// </summary>
 		/// <param name="guildId">The target guild.</param>
 		/// <param name="commandId">The target command id.</param>
 		public Task<DiscordGuildApplicationCommandPermission> GetApplicationCommandPermissionAsync(ulong guildId, ulong commandId) =>
 			this.ApiClient.GetApplicationCommandPermissionAsync(this.CurrentApplication.Id, guildId, commandId);
 
 		/// <summary>
 		/// Overwrites the existing permissions for a application command in a guild. New permissions are automatically created and missing permissions are deleted.
 		/// A command takes up to 10 permission overwrites.
 		/// </summary>
 		/// <param name="guildId">The id of the guild.</param>
 		/// <param name="commandId">The id of the command.</param>
 		/// <param name="permissions">List of permissions.</param>
 		public Task<DiscordGuildApplicationCommandPermission> OverwriteGuildApplicationCommandPermissionsAsync(ulong guildId, ulong commandId, IEnumerable<DiscordApplicationCommandPermission> permissions) =>
 			this.ApiClient.OverwriteGuildApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId, commandId, permissions);
 
 		/// <summary>
 		/// Overwrites the existing application command permissions in a guild. New permissions are automatically created and missing permissions are deleted.
 		/// Each command takes up to 10 permission overwrites.
 		/// </summary>
 		/// <param name="guildId">The id of the guild.</param>
 		/// <param name="permissionsOverwrites">The list of permissions to overwrite with.</param>
 		public Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> BulkOverwriteGuildApplicationCommandsAsync(ulong guildId, IEnumerable<DiscordGuildApplicationCommandPermission> permissionsOverwrites) =>
 			this.ApiClient.BulkOverwriteApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId, permissionsOverwrites);
 		#endregion
 
 		#region Internal Caching Methods
 		/// <summary>
 		/// Gets the internal chached threads.
 		/// </summary>
 		/// <param name="threadId">The target thread id.</param>
 		/// <returns>The requested thread.</returns>
 		internal DiscordThreadChannel InternalGetCachedThread(ulong threadId)
 		{
 			foreach (var guild in this.Guilds.Values)
 				if (guild.Threads.TryGetValue(threadId, out var foundThread))
 					return foundThread;
 
 			return null;
 		}
 
 
 		/// <summary>
 		/// Gets the internal chached scheduled event.
 		/// </summary>
 		/// <param name="scheduledEventId">The target scheduled event id.</param>
 		/// <returns>The requested scheduled event.</returns>
 		internal DiscordScheduledEvent InternalGetCachedScheduledEvent(ulong scheduledEventId)
 		{
 			foreach (var guild in this.Guilds.Values)
 				if (guild.ScheduledEvents.TryGetValue(scheduledEventId, out var foundScheduledEvent))
 					return foundScheduledEvent;
 
 			return null;
 		}
 
 		/// <summary>
 		/// Gets the internal chached channel.
 		/// </summary>
 		/// <param name="channelId">The target channel id.</param>
 		/// <returns>The requested channel.</returns>
 		internal DiscordChannel InternalGetCachedChannel(ulong channelId)
 		{
 			foreach (var guild in this.Guilds.Values)
 				if (guild.Channels.TryGetValue(channelId, out var foundChannel))
 					return foundChannel;
 
 			return null;
 		}
 
 		/// <summary>
 		/// Gets the internal chached guild.
 		/// </summary>
 		/// <param name="guildId">The target guild id.</param>
 		/// <returns>The requested guild.</returns>
 		internal DiscordGuild InternalGetCachedGuild(ulong? guildId)
 		{
 			if (this.GuildsInternal != null && guildId.HasValue)
 			{
 				if (this.GuildsInternal.TryGetValue(guildId.Value, out var guild))
 					return guild;
 			}
 
 			return null;
 		}
 
 		/// <summary>
 		/// Updates a message.
 		/// </summary>
 		/// <param name="message">The message to update.</param>
 		/// <param name="author">The author to update.</param>
 		/// <param name="guild">The guild to update.</param>
 		/// <param name="member">The member to update.</param>
 		private void UpdateMessage(DiscordMessage message, TransportUser author, DiscordGuild guild, TransportMember member)
 		{
 			if (author != null)
 			{
 				var usr = new DiscordUser(author) { Discord = this };
 
 				if (member != null)
 					member.User = author;
 
 				message.Author = this.UpdateUser(usr, guild?.Id, guild, member);
 			}
 
 			var channel = this.InternalGetCachedChannel(message.ChannelId);
 
 			if (channel != null) return;
 
 			channel = !message.GuildId.HasValue
 				? new DiscordDmChannel
 				{
 					Id = message.ChannelId,
 					Discord = this,
 					Type = ChannelType.Private
 				}
 				: new DiscordChannel
 				{
 					Id = message.ChannelId,
 					Discord = this
 				};
 
 			message.Channel = channel;
 		}
 
 		/// <summary>
 		/// Updates a scheduled event.
 		/// </summary>
 		/// <param name="scheduledEvent">The scheduled event to update.</param>
 		/// <param name="guild">The guild to update.</param>
 		/// <returns>The updated scheduled event.</returns>
 		private DiscordScheduledEvent UpdateScheduledEvent(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 		{
 			if (scheduledEvent != null)
 			{
 				_ = guild.ScheduledEventsInternal.AddOrUpdate(scheduledEvent.Id, scheduledEvent, (id, old) =>
 				{
 					old.Discord = this;
 					old.Description = scheduledEvent.Description;
 					old.ChannelId = scheduledEvent.ChannelId;
 					old.EntityId = scheduledEvent.EntityId;
 					old.EntityType = scheduledEvent.EntityType;
 					old.EntityMetadata = scheduledEvent.EntityMetadata;
 					old.PrivacyLevel = scheduledEvent.PrivacyLevel;
 					old.Name = scheduledEvent.Name;
 					old.Status = scheduledEvent.Status;
 					old.UserCount = scheduledEvent.UserCount;
 					old.ScheduledStartTimeRaw = scheduledEvent.ScheduledStartTimeRaw;
 					old.ScheduledEndTimeRaw = scheduledEvent.ScheduledEndTimeRaw;
 					return old;
 				});
 			}
 
 			return scheduledEvent;
 		}
 
 		/// <summary>
 		/// Updates a user.
 		/// </summary>
 		/// <param name="usr">The user to update.</param>
 		/// <param name="guildId">The guild id to update.</param>
 		/// <param name="guild">The guild to update.</param>
 		/// <param name="mbr">The member to update.</param>
 		/// <returns>The updated user.</returns>
 		private DiscordUser UpdateUser(DiscordUser usr, ulong? guildId, DiscordGuild guild, TransportMember mbr)
 		{
 			if (mbr != null)
 			{
 				if (mbr.User != null)
 				{
 					usr = new DiscordUser(mbr.User) { Discord = this };
 
 					_ = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 					{
 						old.Username = usr.Username;
 						old.Discriminator = usr.Discriminator;
 						old.AvatarHash = usr.AvatarHash;
 						return old;
 					});
 
 					usr = new DiscordMember(mbr) { Discord = this, GuildId = guildId.Value };
 				}
 
 				var intents = this.Configuration.Intents;
 
 				DiscordMember member = default;
 
 				if (!intents.HasAllPrivilegedIntents() || guild.IsLarge) // we have the necessary privileged intents, no need to worry about caching here unless guild is large.
 				{
 					if (guild?.MembersInternal.TryGetValue(usr.Id, out member) == false)
 					{
 						if (intents.HasIntent(DiscordIntents.GuildMembers) || this.Configuration.AlwaysCacheMembers) // member can be updated by events, so cache it
 						{
 							guild.MembersInternal.TryAdd(usr.Id, (DiscordMember)usr);
 						}
 					}
 					else if (intents.HasIntent(DiscordIntents.GuildPresences) || this.Configuration.AlwaysCacheMembers) // we can attempt to update it if it's already in cache.
 					{
 						if (!intents.HasIntent(DiscordIntents.GuildMembers)) // no need to update if we already have the member events
 						{
 							_ = guild.MembersInternal.TryUpdate(usr.Id, (DiscordMember)usr, member);
 						}
 					}
 				}
 			}
 			else if (usr.Username != null) // check if not a skeleton user
 			{
 				_ = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
 			}
 
 			return usr;
 		}
 
 		/// <summary>
 		/// Updates the cached events in a guild.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <param name="rawEvents">The raw events.</param>
 		private void UpdateCachedScheduledEvent(DiscordGuild guild, JArray rawEvents)
 		{
 			if (this._disposed)
 				return;
 
 			if (rawEvents != null)
 			{
 				guild.ScheduledEventsInternal.Clear();
 
 				foreach (var xj in rawEvents)
 				{
 					var xtm = xj.ToDiscordObject<DiscordScheduledEvent>();
 
 					xtm.Discord = this;
 
 					guild.ScheduledEventsInternal[xtm.Id] = xtm;
 				}
 			}
 		}
 
 		/// <summary>
 		/// Updates the cached guild.
 		/// </summary>
 		/// <param name="newGuild">The new guild.</param>
 		/// <param name="rawMembers">The raw members.</param>
 		private void UpdateCachedGuild(DiscordGuild newGuild, JArray rawMembers)
 		{
 			if (this._disposed)
 				return;
 
 			if (!this.GuildsInternal.ContainsKey(newGuild.Id))
 				this.GuildsInternal[newGuild.Id] = newGuild;
 
 			var guild = this.GuildsInternal[newGuild.Id];
 
 			if (newGuild.ChannelsInternal != null && newGuild.ChannelsInternal.Count > 0)
 			{
 				foreach (var channel in newGuild.ChannelsInternal.Values)
 				{
 					if (guild.ChannelsInternal.TryGetValue(channel.Id, out _)) continue;
 
 					foreach (var overwrite in channel.PermissionOverwritesInternal)
 					{
 						overwrite.Discord = this;
 						overwrite.ChannelId = channel.Id;
 					}
 
 					guild.ChannelsInternal[channel.Id] = channel;
 				}
 			}
 
 			if (newGuild.ThreadsInternal != null && newGuild.ThreadsInternal.Count > 0)
 			{
 				foreach (var thread in newGuild.ThreadsInternal.Values)
 				{
 					if (guild.ThreadsInternal.TryGetValue(thread.Id, out _)) continue;
 
 					guild.ThreadsInternal[thread.Id] = thread;
 				}
 			}
 
 			if (newGuild.ScheduledEventsInternal != null && newGuild.ScheduledEventsInternal.Count > 0)
 			{
 				foreach (var @event in newGuild.ScheduledEventsInternal.Values)
 				{
 					if (guild.ScheduledEventsInternal.TryGetValue(@event.Id, out _)) continue;
 
 					guild.ScheduledEventsInternal[@event.Id] = @event;
 				}
 			}
 
 			foreach (var newEmoji in newGuild.EmojisInternal.Values)
 				_ = guild.EmojisInternal.GetOrAdd(newEmoji.Id, _ => newEmoji);
 
 			foreach (var newSticker in newGuild.StickersInternal.Values)
 				_ = guild.StickersInternal.GetOrAdd(newSticker.Id, _ => newSticker);
 
 			foreach (var newStageInstance in newGuild.StageInstancesInternal.Values)
 				_ = guild.StageInstancesInternal.GetOrAdd(newStageInstance.Id, _ => newStageInstance);
 
 			if (rawMembers != null)
 			{
 				guild.MembersInternal.Clear();
 
 				foreach (var xj in rawMembers)
 				{
 					var xtm = xj.ToDiscordObject<TransportMember>();
 
 					var xu = new DiscordUser(xtm.User) { Discord = this };
 					_ = this.UserCache.AddOrUpdate(xtm.User.Id, xu, (id, old) =>
 					{
 						old.Username = xu.Username;
 						old.Discriminator = xu.Discriminator;
 						old.AvatarHash = xu.AvatarHash;
 						old.PremiumType = xu.PremiumType;
 						return old;
 					});
 
 					guild.MembersInternal[xtm.User.Id] = new DiscordMember(xtm) { Discord = this, GuildId = guild.Id };
 				}
 			}
 
 			foreach (var role in newGuild.RolesInternal.Values)
 			{
 				if (guild.RolesInternal.TryGetValue(role.Id, out _)) continue;
 
 				role.GuildId = guild.Id;
 				guild.RolesInternal[role.Id] = role;
 			}
 
 			guild.Name = newGuild.Name;
 			guild.AfkChannelId = newGuild.AfkChannelId;
 			guild.AfkTimeout = newGuild.AfkTimeout;
 			guild.DefaultMessageNotifications = newGuild.DefaultMessageNotifications;
 			guild.RawFeatures = newGuild.RawFeatures;
 			guild.IconHash = newGuild.IconHash;
 			guild.MfaLevel = newGuild.MfaLevel;
 			guild.OwnerId = newGuild.OwnerId;
 			guild.VoiceRegionId = newGuild.VoiceRegionId;
 			guild.SplashHash = newGuild.SplashHash;
 			guild.VerificationLevel = newGuild.VerificationLevel;
 			guild.WidgetEnabled = newGuild.WidgetEnabled;
 			guild.WidgetChannelId = newGuild.WidgetChannelId;
 			guild.ExplicitContentFilter = newGuild.ExplicitContentFilter;
 			guild.PremiumTier = newGuild.PremiumTier;
 			guild.PremiumSubscriptionCount = newGuild.PremiumSubscriptionCount;
 			guild.PremiumProgressBarEnabled = newGuild.PremiumProgressBarEnabled;
 			guild.BannerHash = newGuild.BannerHash;
 			guild.Description = newGuild.Description;
 			guild.VanityUrlCode = newGuild.VanityUrlCode;
 			guild.SystemChannelId = newGuild.SystemChannelId;
 			guild.SystemChannelFlags = newGuild.SystemChannelFlags;
 			guild.DiscoverySplashHash = newGuild.DiscoverySplashHash;
 			guild.MaxMembers = newGuild.MaxMembers;
 			guild.MaxPresences = newGuild.MaxPresences;
 			guild.ApproximateMemberCount = newGuild.ApproximateMemberCount;
 			guild.ApproximatePresenceCount = newGuild.ApproximatePresenceCount;
 			guild.MaxVideoChannelUsers = newGuild.MaxVideoChannelUsers;
 			guild.PreferredLocale = newGuild.PreferredLocale;
 			guild.RulesChannelId = newGuild.RulesChannelId;
 			guild.PublicUpdatesChannelId = newGuild.PublicUpdatesChannelId;
 			guild.ApplicationId = newGuild.ApplicationId;
 
 			// fields not sent for update:
 			// - guild.Channels
 			// - voice states
 			// - guild.JoinedAt = new_guild.JoinedAt;
 			// - guild.Large = new_guild.Large;
 			// - guild.MemberCount = Math.Max(new_guild.MemberCount, guild._members.Count);
 			// - guild.Unavailable = new_guild.Unavailable;
 		}
 
 		/// <summary>
 		/// Populates the message reactions and cache.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <param name="author">The author.</param>
 		/// <param name="member">The member.</param>
 		private void PopulateMessageReactionsAndCache(DiscordMessage message, TransportUser author, TransportMember member)
 		{
 			var guild = message.Channel?.Guild ?? this.InternalGetCachedGuild(message.GuildId);
 
 			this.UpdateMessage(message, author, guild, member);
 
 			if (message.ReactionsInternal == null)
 				message.ReactionsInternal = new List<DiscordReaction>();
 			foreach (var xr in message.ReactionsInternal)
 				xr.Emoji.Discord = this;
 
 			if (this.Configuration.MessageCacheSize > 0 && message.Channel != null)
 				this.MessageCache?.Add(message);
 		}
 
 
 		#endregion
 
 		#region Disposal
 
 		~DiscordClient()
 		{
 			this.Dispose();
 		}
 
 
 		private bool _disposed;
 		/// <summary>
 		/// Disposes the client.
 		/// </summary>
 		public override void Dispose()
 		{
 			if (this._disposed)
 				return;
 
 			this._disposed = true;
 			GC.SuppressFinalize(this);
 
 			this.DisconnectAsync().ConfigureAwait(false).GetAwaiter().GetResult();
 			this.ApiClient.Rest.Dispose();
 			this.CurrentUser = null;
 
 			var extensions = this._extensions; // prevent _extensions being modified during dispose
 			this._extensions = null;
 			foreach (var extension in extensions)
 				if (extension is IDisposable disposable)
 					disposable.Dispose();
 
 			try
 			{
 				this._cancelTokenSource?.Cancel();
 				this._cancelTokenSource?.Dispose();
 			}
 			catch { }
 
 			this.GuildsInternal = null;
 			this._heartbeatTask = null;
 		}
 
 		#endregion
 	}
 }
diff --git a/DisCatSharp/Clients/DiscordShardedClient.cs b/DisCatSharp/Clients/DiscordShardedClient.cs
index 2849e699f..e46488e3d 100644
--- a/DisCatSharp/Clients/DiscordShardedClient.cs
+++ b/DisCatSharp/Clients/DiscordShardedClient.cs
@@ -1,745 +1,747 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 #pragma warning disable CS0618
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Globalization;
 using System.Linq;
 using System.Net.Http;
 using System.Reflection;
 using System.Threading.Tasks;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Net;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// A Discord client that shards automatically.
 	/// </summary>
 	public sealed partial class DiscordShardedClient
 	{
 		#region Public Properties
 
 		/// <summary>
 		/// Gets the logger for this client.
 		/// </summary>
 		public ILogger<BaseDiscordClient> Logger { get; }
 
 		/// <summary>
 		/// Gets all client shards.
 		/// </summary>
 		public IReadOnlyDictionary<int, DiscordClient> ShardClients { get; }
 
 		/// <summary>
 		/// Gets the gateway info for the client's session.
 		/// </summary>
 		public GatewayInfo GatewayInfo { get; private set; }
 
 		/// <summary>
 		/// Gets the current user.
 		/// </summary>
 		public DiscordUser CurrentUser { get; private set; }
 
 		/// <summary>
 		/// Gets the current application.
 		/// </summary>
 		public DiscordApplication CurrentApplication { get; private set; }
 
 		/// <summary>
 		/// Gets the library team.
 		/// </summary>
 		public DisCatSharpTeam LibraryDeveloperTeam
 			=> this.GetShard(0).LibraryDeveloperTeam;
 
 		/// <summary>
 		/// Gets the list of available voice regions. Note that this property will not contain VIP voice regions.
 		/// </summary>
 		public IReadOnlyDictionary<string, DiscordVoiceRegion> VoiceRegions
 			=> this._voiceRegionsLazy?.Value;
 
 		#endregion
 
 		#region Private Properties/Fields
 
 		/// <summary>
 		/// Gets the configuration.
 		/// </summary>
 		private readonly DiscordConfiguration _configuration;
 
 		/// <summary>
 		/// Gets the list of available voice regions. This property is meant as a way to modify <see cref="VoiceRegions"/>.
 		/// </summary>
 		private ConcurrentDictionary<string, DiscordVoiceRegion> _internalVoiceRegions;
 
 		private readonly ConcurrentDictionary<int, DiscordClient> _shards = new();
 		private Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>> _voiceRegionsLazy;
 		private bool _isStarted;
 		private readonly bool _manuallySharding;
 
 		#endregion
 
 		#region Constructor
 
 		/// <summary>
 		/// Initializes new auto-sharding Discord client.
 		/// </summary>
 		/// <param name="config">Configuration to use.</param>
 		public DiscordShardedClient(DiscordConfiguration config)
 		{
 			this.InternalSetup();
 
 			if (config.ShardCount > 1)
 				this._manuallySharding = true;
 
 			this._configuration = config;
 			this.ShardClients = new ReadOnlyConcurrentDictionary<int, DiscordClient>(this._shards);
 
 			if (this._configuration.LoggerFactory == null)
 			{
 				this._configuration.LoggerFactory = new DefaultLoggerFactory();
 				this._configuration.LoggerFactory.AddProvider(new DefaultLoggerProvider(this._configuration.MinimumLogLevel, this._configuration.LogTimestampFormat));
 			}
 			this.Logger = this._configuration.LoggerFactory.CreateLogger<BaseDiscordClient>();
 		}
 
 		#endregion
 
 		#region Public Methods
 
 		/// <summary>
 		/// Initializes and connects all shards.
 		/// </summary>
 		/// <exception cref="System.AggregateException"></exception>
 		/// <exception cref="System.InvalidOperationException"></exception>
 		/// <returns></returns>
 		public async Task StartAsync()
 		{
 			if (this._isStarted)
 				throw new InvalidOperationException("This client has already been started.");
 
 			this._isStarted = true;
 
 			try
 			{
 				if (this._configuration.TokenType != TokenType.Bot)
 					this.Logger.LogWarning(LoggerEvents.Misc, "You are logging in with a token that is not a bot token. This is not officially supported by Discord, and can result in your account being terminated if you aren't careful.");
 				this.Logger.LogInformation(LoggerEvents.Startup, "Lib {0}, version {1}", this._botLibrary, this._versionString.Value);
 
 				var shardc = await this.InitializeShardsAsync().ConfigureAwait(false);
 				var connectTasks = new List<Task>();
 				this.Logger.LogInformation(LoggerEvents.ShardStartup, "Booting {0} shards.", shardc);
 
 				for (var i = 0; i < shardc; i++)
 				{
 					//This should never happen, but in case it does...
 					if (this.GatewayInfo.SessionBucket.MaxConcurrency < 1)
 						this.GatewayInfo.SessionBucket.MaxConcurrency = 1;
 
 					if (this.GatewayInfo.SessionBucket.MaxConcurrency == 1)
 						await this.ConnectShardAsync(i).ConfigureAwait(false);
 					else
 					{
 						//Concurrent login.
 						connectTasks.Add(this.ConnectShardAsync(i));
 
 						if (connectTasks.Count == this.GatewayInfo.SessionBucket.MaxConcurrency)
 						{
 							await Task.WhenAll(connectTasks).ConfigureAwait(false);
 							connectTasks.Clear();
 						}
 					}
 				}
 			}
 			catch (Exception ex)
 			{
 				await this.InternalStopAsync(false).ConfigureAwait(false);
 
 				var message = $"Shard initialization failed, check inner exceptions for details: ";
 
 				this.Logger.LogCritical(LoggerEvents.ShardClientError, $"{message}\n{ex}");
 				throw new AggregateException(message, ex);
 			}
 		}
 		/// <summary>
 		/// Disconnects and disposes of all shards.
 		/// </summary>
 		/// <returns></returns>
 		/// <exception cref="System.InvalidOperationException"></exception>
 		public Task StopAsync()
 			=> this.InternalStopAsync();
 
 		/// <summary>
 		/// Gets a shard from a guild ID.
 		/// <para>
 		///     If automatically sharding, this will use the <see cref="Utilities.GetShardId(ulong, int)"/> method.
 		///     Otherwise if manually sharding, it will instead iterate through each shard's guild caches.
 		/// </para>
 		/// </summary>
 		/// <param name="guildId">The guild ID for the shard.</param>
 		/// <returns>The found <see cref="DiscordClient"/> shard. Otherwise <see langword="null"/> if the shard was not found for the guild ID.</returns>
 		public DiscordClient GetShard(ulong guildId)
 		{
 			var index = this._manuallySharding ? this.GetShardIdFromGuilds(guildId) : Utilities.GetShardId(guildId, this.ShardClients.Count);
 
 			return index != -1 ? this._shards[index] : null;
 		}
 
 		/// <summary>
 		/// Gets a shard from a guild.
 		/// <para>
 		///     If automatically sharding, this will use the <see cref="Utilities.GetShardId(ulong, int)"/> method.
 		///     Otherwise if manually sharding, it will instead iterate through each shard's guild caches.
 		/// </para>
 		/// </summary>
 		/// <param name="guild">The guild for the shard.</param>
 		/// <returns>The found <see cref="DiscordClient"/> shard. Otherwise <see langword="null"/> if the shard was not found for the guild.</returns>
 		public DiscordClient GetShard(DiscordGuild guild)
 			=> this.GetShard(guild.Id);
 
 		/// <summary>
 		/// Updates playing statuses on all shards.
 		/// </summary>
 		/// <param name="activity">Activity to set.</param>
 		/// <param name="userStatus">Status of the user.</param>
 		/// <param name="idleSince">Since when is the client performing the specified activity.</param>
 		/// <returns>Asynchronous operation.</returns>
 		public async Task UpdateStatusAsync(DiscordActivity activity = null, UserStatus? userStatus = null, DateTimeOffset? idleSince = null)
 		{
 			var tasks = new List<Task>();
 			foreach (var client in this._shards.Values)
 				tasks.Add(client.UpdateStatusAsync(activity, userStatus, idleSince));
 
 			await Task.WhenAll(tasks).ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Internal Methods
 
 		/// <summary>
 		/// Initializes the shards async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task<int> InitializeShardsAsync()
 		{
 			if (this._shards.Count != 0)
 				return this._shards.Count;
 
 			this.GatewayInfo = await this.GetGatewayInfoAsync().ConfigureAwait(false);
 			var shardc = this._configuration.ShardCount == 1 ? this.GatewayInfo.ShardCount : this._configuration.ShardCount;
 			var lf = new ShardedLoggerFactory(this.Logger);
 			for (var i = 0; i < shardc; i++)
 			{
 				var cfg = new DiscordConfiguration(this._configuration)
 				{
 					ShardId = i,
 					ShardCount = shardc,
 					LoggerFactory = lf
 				};
 
 				var client = new DiscordClient(cfg);
 				if (!this._shards.TryAdd(i, client))
 					throw new InvalidOperationException("Could not initialize shards.");
 			}
 
 			return shardc;
 		}
 
 		#endregion
 
 		#region Private Methods/Version Property
 
 		/// <summary>
 		/// Gets the gateway info async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		private async Task<GatewayInfo> GetGatewayInfoAsync()
 		{
 			var url = $"{Utilities.GetApiBaseUri(this._configuration)}{Endpoints.GATEWAY}{Endpoints.BOT}";
 			var http = new HttpClient();
 
 			http.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", Utilities.GetUserAgent());
 			http.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", Utilities.GetFormattedToken(this._configuration));
 			if (this._configuration != null && this._configuration.Override != null)
 			{
 				http.DefaultRequestHeaders.TryAddWithoutValidation("x-super-properties", this._configuration.Override);
 			}
 
 			this.Logger.LogDebug(LoggerEvents.ShardRest, $"Obtaining gateway information from GET {Endpoints.GATEWAY}{Endpoints.BOT}...");
 			var resp = await http.GetAsync(url).ConfigureAwait(false);
 
 			http.Dispose();
 
 			if (!resp.IsSuccessStatusCode)
 			{
 				var ratelimited = await HandleHttpError(url, resp).ConfigureAwait(false);
 
 				if (ratelimited)
 					return await this.GetGatewayInfoAsync().ConfigureAwait(false);
 			}
 
 			var timer = new Stopwatch();
 			timer.Start();
 
 			var jo = JObject.Parse(await resp.Content.ReadAsStringAsync().ConfigureAwait(false));
 			var info = jo.ToObject<GatewayInfo>();
 
 			//There is a delay from parsing here.
 			timer.Stop();
 
 			info.SessionBucket.ResetAfterInternal -= (int)timer.ElapsedMilliseconds;
 			info.SessionBucket.ResetAfter = DateTimeOffset.UtcNow + TimeSpan.FromMilliseconds(info.SessionBucket.ResetAfterInternal);
 
 			return info;
 
 			async Task<bool> HandleHttpError(string reqUrl, HttpResponseMessage msg)
 			{
 				var code = (int)msg.StatusCode;
 
 				if (code == 401 || code == 403)
 				{
 					throw new Exception($"Authentication failed, check your token and try again: {code} {msg.ReasonPhrase}");
 				}
 				else if (code == 429)
 				{
 					this.Logger.LogError(LoggerEvents.ShardClientError, $"Ratelimit hit, requeuing request to {reqUrl}");
 
 					var hs = msg.Headers.ToDictionary(xh => xh.Key, xh => string.Join("\n", xh.Value), StringComparer.OrdinalIgnoreCase);
 					var waitInterval = 0;
 
 					if (hs.TryGetValue("Retry-After", out var retryAfterRaw))
 						waitInterval = int.Parse(retryAfterRaw, CultureInfo.InvariantCulture);
 
 					await Task.Delay(waitInterval).ConfigureAwait(false);
 					return true;
 				}
 				else if (code >= 500)
 				{
 					throw new Exception($"Internal Server Error: {code} {msg.ReasonPhrase}");
 				}
 				else
 				{
 					throw new Exception($"An unsuccessful HTTP status code was encountered: {code} {msg.ReasonPhrase}");
 				}
 			}
 		}
 
 
 		private readonly Lazy<string> _versionString = new(() =>
 		{
 			var a = typeof(DiscordShardedClient).GetTypeInfo().Assembly;
 
 			var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
 			if (iv != null)
 				return iv.InformationalVersion;
 
 			var v = a.GetName().Version;
 			var vs = v.ToString(3);
 
 			if (v.Revision > 0)
 				vs = $"{vs}, CI build {v.Revision}";
 
 			return vs;
 		});
 
 		private readonly string _botLibrary = "DisCatSharp";
 
 		#endregion
 
 		#region Private Connection Methods
 
 		/// <summary>
 		/// Connects the shard async.
 		/// </summary>
 		/// <param name="i">The i.</param>
 		/// <returns>A Task.</returns>
 		private async Task ConnectShardAsync(int i)
 		{
 			if (!this._shards.TryGetValue(i, out var client))
 				throw new Exception($"Could not initialize shard {i}.");
 
 			if (this.GatewayInfo != null)
 			{
 				client.GatewayInfo = this.GatewayInfo;
 				client.GatewayUri = new Uri(client.GatewayInfo.Url);
 			}
 
 			if (this.CurrentUser != null)
 				client.CurrentUser = this.CurrentUser;
 
 			if (this.CurrentApplication != null)
 				client.CurrentApplication = this.CurrentApplication;
 
 			if (this._internalVoiceRegions != null)
 			{
 				client.InternalVoiceRegions = this._internalVoiceRegions;
 				client.VoiceRegionsLazy = new Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>>(() => new ReadOnlyDictionary<string, DiscordVoiceRegion>(client.InternalVoiceRegions));
 			}
 
 			this.HookEventHandlers(client);
 
 			client.IsShard = true;
 			await client.ConnectAsync().ConfigureAwait(false);
 			this.Logger.LogInformation(LoggerEvents.ShardStartup, "Booted shard {0}.", i);
 
 			if (this.CurrentUser == null)
 				this.CurrentUser = client.CurrentUser;
 
 			if (this.CurrentApplication == null)
 				this.CurrentApplication = client.CurrentApplication;
 
 			if (this._internalVoiceRegions == null)
 			{
 				this._internalVoiceRegions = client.InternalVoiceRegions;
 				this._voiceRegionsLazy = new Lazy<IReadOnlyDictionary<string, DiscordVoiceRegion>>(() => new ReadOnlyDictionary<string, DiscordVoiceRegion>(this._internalVoiceRegions));
 			}
 		}
 
 		/// <summary>
 		/// Internals the stop async.
 		/// </summary>
 		/// <param name="enableLogger">If true, enable logger.</param>
 		/// <returns>A Task.</returns>
 		private Task InternalStopAsync(bool enableLogger = true)
 		{
 			if (!this._isStarted)
 				throw new InvalidOperationException("This client has not been started.");
 
 			if (enableLogger)
 				this.Logger.LogInformation(LoggerEvents.ShardShutdown, "Disposing {0} shards.", this._shards.Count);
 
 			this._isStarted = false;
 			this._voiceRegionsLazy = null;
 
 			this.GatewayInfo = null;
 			this.CurrentUser = null;
 			this.CurrentApplication = null;
 
 			for (var i = 0; i < this._shards.Count; i++)
 			{
 				if (this._shards.TryGetValue(i, out var client))
 				{
 					this.UnhookEventHandlers(client);
 
 					client.Dispose();
 
 					if (enableLogger)
 						this.Logger.LogInformation(LoggerEvents.ShardShutdown, "Disconnected shard {0}.", i);
 				}
 			}
 
 			this._shards.Clear();
 
 			return Task.CompletedTask;
 		}
 
 		#endregion
 
 		#region Event Handler Initialization/Registering
 
 		/// <summary>
 		/// Internals the setup.
 		/// </summary>
 		private void InternalSetup()
 		{
 			this._clientErrored = new AsyncEvent<DiscordClient, ClientErrorEventArgs>("CLIENT_ERRORED", DiscordClient.EventExecutionLimit, this.Goof);
 			this._socketErrored = new AsyncEvent<DiscordClient, SocketErrorEventArgs>("SOCKET_ERRORED", DiscordClient.EventExecutionLimit, this.Goof);
 			this._socketOpened = new AsyncEvent<DiscordClient, SocketEventArgs>("SOCKET_OPENED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._socketClosed = new AsyncEvent<DiscordClient, SocketCloseEventArgs>("SOCKET_CLOSED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._ready = new AsyncEvent<DiscordClient, ReadyEventArgs>("READY", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._resumed = new AsyncEvent<DiscordClient, ReadyEventArgs>("RESUMED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._channelCreated = new AsyncEvent<DiscordClient, ChannelCreateEventArgs>("CHANNEL_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._channelUpdated = new AsyncEvent<DiscordClient, ChannelUpdateEventArgs>("CHANNEL_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._channelDeleted = new AsyncEvent<DiscordClient, ChannelDeleteEventArgs>("CHANNEL_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._dmChannelDeleted = new AsyncEvent<DiscordClient, DmChannelDeleteEventArgs>("DM_CHANNEL_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._channelPinsUpdated = new AsyncEvent<DiscordClient, ChannelPinsUpdateEventArgs>("CHANNEL_PINS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildCreated = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildAvailable = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_AVAILABLE", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildUpdated = new AsyncEvent<DiscordClient, GuildUpdateEventArgs>("GUILD_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildDeleted = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildUnavailable = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_UNAVAILABLE", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildDownloadCompleted = new AsyncEvent<DiscordClient, GuildDownloadCompletedEventArgs>("GUILD_DOWNLOAD_COMPLETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._inviteCreated = new AsyncEvent<DiscordClient, InviteCreateEventArgs>("INVITE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._inviteDeleted = new AsyncEvent<DiscordClient, InviteDeleteEventArgs>("INVITE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._messageCreated = new AsyncEvent<DiscordClient, MessageCreateEventArgs>("MESSAGE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._presenceUpdated = new AsyncEvent<DiscordClient, PresenceUpdateEventArgs>("PRESENCE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildBanAdded = new AsyncEvent<DiscordClient, GuildBanAddEventArgs>("GUILD_BAN_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildBanRemoved = new AsyncEvent<DiscordClient, GuildBanRemoveEventArgs>("GUILD_BAN_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildEmojisUpdated = new AsyncEvent<DiscordClient, GuildEmojisUpdateEventArgs>("GUILD_EMOJI_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildStickersUpdated = new AsyncEvent<DiscordClient, GuildStickersUpdateEventArgs>("GUILD_STICKER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationsUpdated = new AsyncEvent<DiscordClient, GuildIntegrationsUpdateEventArgs>("GUILD_INTEGRATIONS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberAdded = new AsyncEvent<DiscordClient, GuildMemberAddEventArgs>("GUILD_MEMBER_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberRemoved = new AsyncEvent<DiscordClient, GuildMemberRemoveEventArgs>("GUILD_MEMBER_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberUpdated = new AsyncEvent<DiscordClient, GuildMemberUpdateEventArgs>("GUILD_MEMBER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildRoleCreated = new AsyncEvent<DiscordClient, GuildRoleCreateEventArgs>("GUILD_ROLE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildRoleUpdated = new AsyncEvent<DiscordClient, GuildRoleUpdateEventArgs>("GUILD_ROLE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildRoleDeleted = new AsyncEvent<DiscordClient, GuildRoleDeleteEventArgs>("GUILD_ROLE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._messageUpdated = new AsyncEvent<DiscordClient, MessageUpdateEventArgs>("MESSAGE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._messageDeleted = new AsyncEvent<DiscordClient, MessageDeleteEventArgs>("MESSAGE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._messageBulkDeleted = new AsyncEvent<DiscordClient, MessageBulkDeleteEventArgs>("MESSAGE_BULK_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._interactionCreated = new AsyncEvent<DiscordClient, InteractionCreateEventArgs>("INTERACTION_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._componentInteractionCreated = new AsyncEvent<DiscordClient, ComponentInteractionCreateEventArgs>("COMPONENT_INTERACTED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._contextMenuInteractionCreated = new AsyncEvent<DiscordClient, ContextMenuInteractionCreateEventArgs>("CONTEXT_MENU_INTERACTED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._typingStarted = new AsyncEvent<DiscordClient, TypingStartEventArgs>("TYPING_STARTED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._userSettingsUpdated = new AsyncEvent<DiscordClient, UserSettingsUpdateEventArgs>("USER_SETTINGS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._userUpdated = new AsyncEvent<DiscordClient, UserUpdateEventArgs>("USER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._voiceStateUpdated = new AsyncEvent<DiscordClient, VoiceStateUpdateEventArgs>("VOICE_STATE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._voiceServerUpdated = new AsyncEvent<DiscordClient, VoiceServerUpdateEventArgs>("VOICE_SERVER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildMembersChunk = new AsyncEvent<DiscordClient, GuildMembersChunkEventArgs>("GUILD_MEMBERS_CHUNKED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._unknownEvent = new AsyncEvent<DiscordClient, UnknownEventArgs>("UNKNOWN_EVENT", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionAdded = new AsyncEvent<DiscordClient, MessageReactionAddEventArgs>("MESSAGE_REACTION_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionRemoved = new AsyncEvent<DiscordClient, MessageReactionRemoveEventArgs>("MESSAGE_REACTION_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionsCleared = new AsyncEvent<DiscordClient, MessageReactionsClearEventArgs>("MESSAGE_REACTIONS_CLEARED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionRemovedEmoji = new AsyncEvent<DiscordClient, MessageReactionRemoveEmojiEventArgs>("MESSAGE_REACTION_REMOVED_EMOJI", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._webhooksUpdated = new AsyncEvent<DiscordClient, WebhooksUpdateEventArgs>("WEBHOOKS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._heartbeated = new AsyncEvent<DiscordClient, HeartbeatEventArgs>("HEARTBEATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandCreated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandUpdated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandDeleted = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildApplicationCommandCountUpdated = new AsyncEvent<DiscordClient, GuildApplicationCommandCountEventArgs>("GUILD_APPLICATION_COMMAND_COUNTS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandPermissionsUpdated = new AsyncEvent<DiscordClient, ApplicationCommandPermissionsUpdateEventArgs>("APPLICATION_COMMAND_PERMISSIONS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationCreated = new AsyncEvent<DiscordClient, GuildIntegrationCreateEventArgs>("INTEGRATION_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationUpdated = new AsyncEvent<DiscordClient, GuildIntegrationUpdateEventArgs>("INTEGRATION_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationDeleted = new AsyncEvent<DiscordClient, GuildIntegrationDeleteEventArgs>("INTEGRATION_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._stageInstanceCreated = new AsyncEvent<DiscordClient, StageInstanceCreateEventArgs>("STAGE_INSTANCE_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._stageInstanceUpdated = new AsyncEvent<DiscordClient, StageInstanceUpdateEventArgs>("STAGE_INSTANCE_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._stageInstanceDeleted = new AsyncEvent<DiscordClient, StageInstanceDeleteEventArgs>("STAGE_INSTANCE_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._threadCreated = new AsyncEvent<DiscordClient, ThreadCreateEventArgs>("THREAD_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._threadUpdated = new AsyncEvent<DiscordClient, ThreadUpdateEventArgs>("THREAD_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._threadDeleted = new AsyncEvent<DiscordClient, ThreadDeleteEventArgs>("THREAD_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._threadListSynced = new AsyncEvent<DiscordClient, ThreadListSyncEventArgs>("THREAD_LIST_SYNCED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._threadMemberUpdated = new AsyncEvent<DiscordClient, ThreadMemberUpdateEventArgs>("THREAD_MEMBER_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._threadMembersUpdated = new AsyncEvent<DiscordClient, ThreadMembersUpdateEventArgs>("THREAD_MEMBERS_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._zombied = new AsyncEvent<DiscordClient, ZombiedEventArgs>("ZOMBIED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._payloadReceived = new AsyncEvent<DiscordClient, PayloadReceivedEventArgs>("PAYLOAD_RECEIVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventCreated = new AsyncEvent<DiscordClient, GuildScheduledEventCreateEventArgs>("GUILD_SCHEDULED_EVENT_CREATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventUpdated = new AsyncEvent<DiscordClient, GuildScheduledEventUpdateEventArgs>("GUILD_SCHEDULED_EVENT_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventDeleted = new AsyncEvent<DiscordClient, GuildScheduledEventDeleteEventArgs>("GUILD_SCHEDULED_EVENT_DELETED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventUserAdded = new AsyncEvent<DiscordClient, GuildScheduledEventUserAddEventArgs>("GUILD_SCHEDULED_EVENT_USER_ADDED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventUserRemoved = new AsyncEvent<DiscordClient, GuildScheduledEventUserRemoveEventArgs>("GUILD_SCHEDULED_EVENT_USER_REMOVED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 			this._embeddedActivityUpdated = new AsyncEvent<DiscordClient, EmbeddedActivityUpdateEventArgs>("EMBEDDED_ACTIVITY_UPDATED", DiscordClient.EventExecutionLimit, this.EventErrorHandler);
 		}
 
 		/// <summary>
 		/// Hooks the event handlers.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		private void HookEventHandlers(DiscordClient client)
 		{
 			client.ClientErrored += this.Client_ClientError;
 			client.SocketErrored += this.Client_SocketError;
 			client.SocketOpened += this.Client_SocketOpened;
 			client.SocketClosed += this.Client_SocketClosed;
 			client.Ready += this.Client_Ready;
 			client.Resumed += this.Client_Resumed;
 			client.ChannelCreated += this.Client_ChannelCreated;
 			client.ChannelUpdated += this.Client_ChannelUpdated;
 			client.ChannelDeleted += this.Client_ChannelDeleted;
 			client.DmChannelDeleted += this.Client_DMChannelDeleted;
 			client.ChannelPinsUpdated += this.Client_ChannelPinsUpdated;
 			client.GuildCreated += this.Client_GuildCreated;
 			client.GuildAvailable += this.Client_GuildAvailable;
 			client.GuildUpdated += this.Client_GuildUpdated;
 			client.GuildDeleted += this.Client_GuildDeleted;
 			client.GuildUnavailable += this.Client_GuildUnavailable;
 			client.GuildDownloadCompleted += this.Client_GuildDownloadCompleted;
 			client.InviteCreated += this.Client_InviteCreated;
 			client.InviteDeleted += this.Client_InviteDeleted;
 			client.MessageCreated += this.Client_MessageCreated;
 			client.PresenceUpdated += this.Client_PresenceUpdate;
 			client.GuildBanAdded += this.Client_GuildBanAdd;
 			client.GuildBanRemoved += this.Client_GuildBanRemove;
 			client.GuildEmojisUpdated += this.Client_GuildEmojisUpdate;
 			client.GuildStickersUpdated += this.Client_GuildStickersUpdate;
 			client.GuildIntegrationsUpdated += this.Client_GuildIntegrationsUpdate;
 			client.GuildMemberAdded += this.Client_GuildMemberAdd;
 			client.GuildMemberRemoved += this.Client_GuildMemberRemove;
 			client.GuildMemberUpdated += this.Client_GuildMemberUpdate;
 			client.GuildRoleCreated += this.Client_GuildRoleCreate;
 			client.GuildRoleUpdated += this.Client_GuildRoleUpdate;
 			client.GuildRoleDeleted += this.Client_GuildRoleDelete;
 			client.MessageUpdated += this.Client_MessageUpdate;
 			client.MessageDeleted += this.Client_MessageDelete;
 			client.MessagesBulkDeleted += this.Client_MessageBulkDelete;
 			client.InteractionCreated += this.Client_InteractionCreate;
 			client.ComponentInteractionCreated += this.Client_ComponentInteractionCreate;
 			client.ContextMenuInteractionCreated += this.Client_ContextMenuInteractionCreate;
 			client.TypingStarted += this.Client_TypingStart;
 			client.UserSettingsUpdated += this.Client_UserSettingsUpdate;
 			client.UserUpdated += this.Client_UserUpdate;
 			client.VoiceStateUpdated += this.Client_VoiceStateUpdate;
 			client.VoiceServerUpdated += this.Client_VoiceServerUpdate;
 			client.GuildMembersChunked += this.Client_GuildMembersChunk;
 			client.UnknownEvent += this.Client_UnknownEvent;
 			client.MessageReactionAdded += this.Client_MessageReactionAdd;
 			client.MessageReactionRemoved += this.Client_MessageReactionRemove;
 			client.MessageReactionsCleared += this.Client_MessageReactionRemoveAll;
 			client.MessageReactionRemovedEmoji += this.Client_MessageReactionRemovedEmoji;
 			client.WebhooksUpdated += this.Client_WebhooksUpdate;
 			client.Heartbeated += this.Client_HeartBeated;
 			client.ApplicationCommandCreated += this.Client_ApplicationCommandCreated;
 			client.ApplicationCommandUpdated += this.Client_ApplicationCommandUpdated;
 			client.ApplicationCommandDeleted += this.Client_ApplicationCommandDeleted;
 			client.GuildApplicationCommandCountUpdated += this.Client_GuildApplicationCommandCountUpdated;
 			client.ApplicationCommandPermissionsUpdated += this.Client_ApplicationCommandPermissionsUpdated;
 			client.GuildIntegrationCreated += this.Client_GuildIntegrationCreated;
 			client.GuildIntegrationUpdated += this.Client_GuildIntegrationUpdated;
 			client.GuildIntegrationDeleted += this.Client_GuildIntegrationDeleted;
 			client.StageInstanceCreated += this.Client_StageInstanceCreated;
 			client.StageInstanceUpdated += this.Client_StageInstanceUpdated;
 			client.StageInstanceDeleted += this.Client_StageInstanceDeleted;
 			client.ThreadCreated += this.Client_ThreadCreated;
 			client.ThreadUpdated += this.Client_ThreadUpdated;
 			client.ThreadDeleted += this.Client_ThreadDeleted;
 			client.ThreadListSynced += this.Client_ThreadListSynced;
 			client.ThreadMemberUpdated += this.Client_ThreadMemberUpdated;
 			client.ThreadMembersUpdated += this.Client_ThreadMembersUpdated;
 			client.Zombied += this.Client_Zombied;
 			client.PayloadReceived += this.Client_PayloadReceived;
 			client.GuildScheduledEventCreated += this.Client_GuildScheduledEventCreated;
 			client.GuildScheduledEventUpdated += this.Client_GuildScheduledEventUpdated;
 			client.GuildScheduledEventDeleted += this.Client_GuildScheduledEventDeleted;
 			client.GuildScheduledEventUserAdded += this.Client_GuildScheduledEventUserAdded; ;
 			client.GuildScheduledEventUserRemoved += this.Client_GuildScheduledEventUserRemoved;
 			client.EmbeddedActivityUpdated += this.Client_EmbeddedActivityUpdated;
 		}
 
 		/// <summary>
 		/// Unhooks the event handlers.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		private void UnhookEventHandlers(DiscordClient client)
 		{
 			client.ClientErrored -= this.Client_ClientError;
 			client.SocketErrored -= this.Client_SocketError;
 			client.SocketOpened -= this.Client_SocketOpened;
 			client.SocketClosed -= this.Client_SocketClosed;
 			client.Ready -= this.Client_Ready;
 			client.Resumed -= this.Client_Resumed;
 			client.ChannelCreated -= this.Client_ChannelCreated;
 			client.ChannelUpdated -= this.Client_ChannelUpdated;
 			client.ChannelDeleted -= this.Client_ChannelDeleted;
 			client.DmChannelDeleted -= this.Client_DMChannelDeleted;
 			client.ChannelPinsUpdated -= this.Client_ChannelPinsUpdated;
 			client.GuildCreated -= this.Client_GuildCreated;
 			client.GuildAvailable -= this.Client_GuildAvailable;
 			client.GuildUpdated -= this.Client_GuildUpdated;
 			client.GuildDeleted -= this.Client_GuildDeleted;
 			client.GuildUnavailable -= this.Client_GuildUnavailable;
 			client.GuildDownloadCompleted -= this.Client_GuildDownloadCompleted;
 			client.InviteCreated -= this.Client_InviteCreated;
 			client.InviteDeleted -= this.Client_InviteDeleted;
 			client.MessageCreated -= this.Client_MessageCreated;
 			client.PresenceUpdated -= this.Client_PresenceUpdate;
 			client.GuildBanAdded -= this.Client_GuildBanAdd;
 			client.GuildBanRemoved -= this.Client_GuildBanRemove;
 			client.GuildEmojisUpdated -= this.Client_GuildEmojisUpdate;
 			client.GuildStickersUpdated -= this.Client_GuildStickersUpdate;
 			client.GuildIntegrationsUpdated -= this.Client_GuildIntegrationsUpdate;
 			client.GuildMemberAdded -= this.Client_GuildMemberAdd;
 			client.GuildMemberRemoved -= this.Client_GuildMemberRemove;
 			client.GuildMemberUpdated -= this.Client_GuildMemberUpdate;
 			client.GuildRoleCreated -= this.Client_GuildRoleCreate;
 			client.GuildRoleUpdated -= this.Client_GuildRoleUpdate;
 			client.GuildRoleDeleted -= this.Client_GuildRoleDelete;
 			client.MessageUpdated -= this.Client_MessageUpdate;
 			client.MessageDeleted -= this.Client_MessageDelete;
 			client.MessagesBulkDeleted -= this.Client_MessageBulkDelete;
 			client.InteractionCreated -= this.Client_InteractionCreate;
 			client.ComponentInteractionCreated -= this.Client_ComponentInteractionCreate;
 			client.ContextMenuInteractionCreated -= this.Client_ContextMenuInteractionCreate;
 			client.TypingStarted -= this.Client_TypingStart;
 			client.UserSettingsUpdated -= this.Client_UserSettingsUpdate;
 			client.UserUpdated -= this.Client_UserUpdate;
 			client.VoiceStateUpdated -= this.Client_VoiceStateUpdate;
 			client.VoiceServerUpdated -= this.Client_VoiceServerUpdate;
 			client.GuildMembersChunked -= this.Client_GuildMembersChunk;
 			client.UnknownEvent -= this.Client_UnknownEvent;
 			client.MessageReactionAdded -= this.Client_MessageReactionAdd;
 			client.MessageReactionRemoved -= this.Client_MessageReactionRemove;
 			client.MessageReactionsCleared -= this.Client_MessageReactionRemoveAll;
 			client.MessageReactionRemovedEmoji -= this.Client_MessageReactionRemovedEmoji;
 			client.WebhooksUpdated -= this.Client_WebhooksUpdate;
 			client.Heartbeated -= this.Client_HeartBeated;
 			client.ApplicationCommandCreated -= this.Client_ApplicationCommandCreated;
 			client.ApplicationCommandUpdated -= this.Client_ApplicationCommandUpdated;
 			client.ApplicationCommandDeleted -= this.Client_ApplicationCommandDeleted;
 			client.GuildApplicationCommandCountUpdated -= this.Client_GuildApplicationCommandCountUpdated;
 			client.ApplicationCommandPermissionsUpdated -= this.Client_ApplicationCommandPermissionsUpdated;
 			client.GuildIntegrationCreated -= this.Client_GuildIntegrationCreated;
 			client.GuildIntegrationUpdated -= this.Client_GuildIntegrationUpdated;
 			client.GuildIntegrationDeleted -= this.Client_GuildIntegrationDeleted;
 			client.StageInstanceCreated -= this.Client_StageInstanceCreated;
 			client.StageInstanceUpdated -= this.Client_StageInstanceUpdated;
 			client.StageInstanceDeleted -= this.Client_StageInstanceDeleted;
 			client.ThreadCreated -= this.Client_ThreadCreated;
 			client.ThreadUpdated -= this.Client_ThreadUpdated;
 			client.ThreadDeleted -= this.Client_ThreadDeleted;
 			client.ThreadListSynced -= this.Client_ThreadListSynced;
 			client.ThreadMemberUpdated -= this.Client_ThreadMemberUpdated;
 			client.ThreadMembersUpdated -= this.Client_ThreadMembersUpdated;
 			client.Zombied -= this.Client_Zombied;
 			client.PayloadReceived -= this.Client_PayloadReceived;
 			client.GuildScheduledEventCreated -= this.Client_GuildScheduledEventCreated;
 			client.GuildScheduledEventUpdated -= this.Client_GuildScheduledEventUpdated;
 			client.GuildScheduledEventDeleted -= this.Client_GuildScheduledEventDeleted;
 			client.GuildScheduledEventUserAdded -= this.Client_GuildScheduledEventUserAdded; ;
 			client.GuildScheduledEventUserRemoved -= this.Client_GuildScheduledEventUserRemoved;
 			client.EmbeddedActivityUpdated -= this.Client_EmbeddedActivityUpdated;
 		}
 
 		/// <summary>
 		/// Gets the shard id from guilds.
 		/// </summary>
 		/// <param name="id">The id.</param>
 		/// <returns>An int.</returns>
 		private int GetShardIdFromGuilds(ulong id)
 		{
 			foreach (var s in this._shards.Values)
 			{
 				if (s.GuildsInternal.TryGetValue(id, out _))
 				{
 					return s.ShardId;
 				}
 			}
 
 			return -1;
 		}
 
 		#endregion
 
 		#region Destructor
 
 		~DiscordShardedClient()
-			=> this.InternalStopAsync(false).GetAwaiter().GetResult();
+		{
+			this.InternalStopAsync(false).GetAwaiter().GetResult();
+		}
 
 		#endregion
 	}
 }
diff --git a/DisCatSharp/Clients/DiscordWebhookClient.cs b/DisCatSharp/Clients/DiscordWebhookClient.cs
index 004d4651e..4069864de 100644
--- a/DisCatSharp/Clients/DiscordWebhookClient.cs
+++ b/DisCatSharp/Clients/DiscordWebhookClient.cs
@@ -1,283 +1,283 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Represents a webhook-only client. This client can be used to execute Discord webhooks.
 	/// </summary>
 	public class DiscordWebhookClient
 	{
 
 		/// <summary>
 		/// Gets the logger for this client.
 		/// </summary>
 		public ILogger<DiscordWebhookClient> Logger { get; }
 
 		/// <summary>
 		/// Gets the webhook regex.
 		/// this regex has 2 named capture groups: "id" and "token".
 		/// </summary>
-		private static Regex s_webhookRegex { get; } = new Regex(@"(?:https?:\/\/)?discord(?:app)?.com\/api\/(?:v\d\/)?webhooks\/(?<id>\d+)\/(?<token>[A-Za-z0-9_\-]+)", RegexOptions.ECMAScript);
+		private static Regex s_webhookRegex { get; } = new(@"(?:https?:\/\/)?discord(?:app)?.com\/api\/(?:v\d\/)?webhooks\/(?<id>\d+)\/(?<token>[A-Za-z0-9_\-]+)", RegexOptions.ECMAScript);
 
 		/// <summary>
 		/// Gets the collection of registered webhooks.
 		/// </summary>
 		public IReadOnlyList<DiscordWebhook> Webhooks { get; }
 
 		/// <summary>
 		/// Gets or sets the username override for registered webhooks. Note that this only takes effect when broadcasting.
 		/// </summary>
 		public string Username { get; set; }
 
 		/// <summary>
 		/// Gets or set the avatar override for registered webhooks. Note that this only takes effect when broadcasting.
 		/// </summary>
 		public string AvatarUrl { get; set; }
 
 		internal List<DiscordWebhook> Hooks;
 		internal DiscordApiClient Apiclient;
 
 		internal LogLevel MinimumLogLevel;
 		internal string LogTimestampFormat;
 
 		/// <summary>
 		/// Creates a new webhook client.
 		/// </summary>
 		public DiscordWebhookClient()
 			: this(null, null)
 		{ }
 
 		/// <summary>
 		/// Creates a new webhook client, with specified HTTP proxy, timeout, and logging settings.
 		/// </summary>
 		/// <param name="proxy">Proxy to use for HTTP connections.</param>
 		/// <param name="timeout">Timeout to use for HTTP requests. Set to <see cref="System.Threading.Timeout.InfiniteTimeSpan"/> to disable timeouts.</param>
 		/// <param name="useRelativeRateLimit">Whether to use the system clock for computing rate limit resets. See <see cref="DiscordConfiguration.UseRelativeRatelimit"/> for more details.</param>
 		/// <param name="loggerFactory">The optional logging factory to use for this client.</param>
 		/// <param name="minimumLogLevel">The minimum logging level for messages.</param>
 		/// <param name="logTimestampFormat">The timestamp format to use for the logger.</param>
 		public DiscordWebhookClient(IWebProxy proxy = null, TimeSpan? timeout = null, bool useRelativeRateLimit = true,
 			ILoggerFactory loggerFactory = null, LogLevel minimumLogLevel = LogLevel.Information, string logTimestampFormat = "yyyy-MM-dd HH:mm:ss zzz")
 		{
 			this.MinimumLogLevel = minimumLogLevel;
 			this.LogTimestampFormat = logTimestampFormat;
 
 			if (loggerFactory == null)
 			{
 				loggerFactory = new DefaultLoggerFactory();
 				loggerFactory.AddProvider(new DefaultLoggerProvider(this));
 			}
 
 			this.Logger = loggerFactory.CreateLogger<DiscordWebhookClient>();
 
 			var parsedTimeout = timeout ?? TimeSpan.FromSeconds(10);
 
 			this.Apiclient = new DiscordApiClient(proxy, parsedTimeout, useRelativeRateLimit, this.Logger);
 			this.Hooks = new List<DiscordWebhook>();
 			this.Webhooks = new ReadOnlyCollection<DiscordWebhook>(this.Hooks);
 		}
 
 		/// <summary>
 		/// Registers a webhook with this client. This retrieves a webhook based on the ID and token supplied.
 		/// </summary>
 		/// <param name="id">The ID of the webhook to add.</param>
 		/// <param name="token">The token of the webhook to add.</param>
 		/// <returns>The registered webhook.</returns>
 		public async Task<DiscordWebhook> AddWebhookAsync(ulong id, string token)
 		{
 			if (string.IsNullOrWhiteSpace(token))
 				throw new ArgumentNullException(nameof(token));
 			token = token.Trim();
 
 			if (this.Hooks.Any(x => x.Id == id))
 				throw new InvalidOperationException("This webhook is registered with this client.");
 
 			var wh = await this.Apiclient.GetWebhookWithTokenAsync(id, token).ConfigureAwait(false);
 			this.Hooks.Add(wh);
 
 			return wh;
 		}
 
 		/// <summary>
 		/// Registers a webhook with this client. This retrieves a webhook from webhook URL.
 		/// </summary>
 		/// <param name="url">URL of the webhook to retrieve. This URL must contain both ID and token.</param>
 		/// <returns>The registered webhook.</returns>
 		public Task<DiscordWebhook> AddWebhookAsync(Uri url)
 		{
 			if (url == null)
 				throw new ArgumentNullException(nameof(url));
 
 			var m = s_webhookRegex.Match(url.ToString());
 			if (!m.Success)
 				throw new ArgumentException("Invalid webhook URL supplied.", nameof(url));
 
 			var idraw = m.Groups["id"];
 			var tokenraw = m.Groups["token"];
 			if (!ulong.TryParse(idraw.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var id))
 				throw new ArgumentException("Invalid webhook URL supplied.", nameof(url));
 
 			var token = tokenraw.Value;
 			return this.AddWebhookAsync(id, token);
 		}
 
 		/// <summary>
 		/// Registers a webhook with this client. This retrieves a webhook using the supplied full discord client.
 		/// </summary>
 		/// <param name="id">ID of the webhook to register.</param>
 		/// <param name="client">Discord client to which the webhook will belong.</param>
 		/// <returns>The registered webhook.</returns>
 		public async Task<DiscordWebhook> AddWebhookAsync(ulong id, BaseDiscordClient client)
 		{
 			if (client == null)
 				throw new ArgumentNullException(nameof(client));
 
 			if (this.Hooks.Any(x => x.Id == id))
 				throw new ArgumentException("This webhook is already registered with this client.");
 
 			var wh = await client.ApiClient.GetWebhookAsync(id).ConfigureAwait(false);
 			// personally I don't think we need to override anything.
 			// it would even make sense to keep the hook as-is, in case
 			// it's returned without a token for some bizarre reason
 			// remember -- discord is not really consistent
 			//var nwh = new DiscordWebhook()
 			//{
 			//    ApiClient = _apiclient,
 			//    AvatarHash = wh.AvatarHash,
 			//    ChannelId = wh.ChannelId,
 			//    GuildId = wh.GuildId,
 			//    Id = wh.Id,
 			//    Name = wh.Name,
 			//    Token = wh.Token,
 			//    User = wh.User,
 			//    Discord = null
 			//};
 			this.Hooks.Add(wh);
 
 			return wh;
 		}
 
 		/// <summary>
 		/// Registers a webhook with this client. This reuses the supplied webhook object.
 		/// </summary>
 		/// <param name="webhook">Webhook to register.</param>
 		/// <returns>The registered webhook.</returns>
 		public DiscordWebhook AddWebhook(DiscordWebhook webhook)
 		{
 			if (webhook == null)
 				throw new ArgumentNullException(nameof(webhook));
 
 			if (this.Hooks.Any(x => x.Id == webhook.Id))
 				throw new ArgumentException("This webhook is already registered with this client.");
 
 			// see line 128-131 for explanation
 			// For christ's sake, update the line numbers if they change.
 			//var nwh = new DiscordWebhook()
 			//{
 			//    ApiClient = _apiclient,
 			//    AvatarHash = webhook.AvatarHash,
 			//    ChannelId = webhook.ChannelId,
 			//    GuildId = webhook.GuildId,
 			//    Id = webhook.Id,
 			//    Name = webhook.Name,
 			//    Token = webhook.Token,
 			//    User = webhook.User,
 			//    Discord = null
 			//};
 			this.Hooks.Add(webhook);
 
 			return webhook;
 		}
 
 		/// <summary>
 		/// Unregisters a webhook with this client.
 		/// </summary>
 		/// <param name="id">ID of the webhook to unregister.</param>
 		/// <returns>The unregistered webhook.</returns>
 		public DiscordWebhook RemoveWebhook(ulong id)
 		{
 			if (!this.Hooks.Any(x => x.Id == id))
 				throw new ArgumentException("This webhook is not registered with this client.");
 
 			var wh = this.GetRegisteredWebhook(id);
 			this.Hooks.Remove(wh);
 			return wh;
 		}
 
 		/// <summary>
 		/// Gets a registered webhook with specified ID.
 		/// </summary>
 		/// <param name="id">ID of the registered webhook to retrieve.</param>
 		/// <returns>The requested webhook.</returns>
 		public DiscordWebhook GetRegisteredWebhook(ulong id)
 			=> this.Hooks.FirstOrDefault(xw => xw.Id == id);
 
 		/// <summary>
 		/// Broadcasts a message to all registered webhooks.
 		/// </summary>
 		/// <param name="builder">Webhook builder filled with data to send.</param>
 		/// <returns></returns>
 		public async Task<Dictionary<DiscordWebhook, DiscordMessage>> BroadcastMessageAsync(DiscordWebhookBuilder builder)
 		{
 			var deadhooks = new List<DiscordWebhook>();
 			var messages = new Dictionary<DiscordWebhook, DiscordMessage>();
 
 			foreach (var hook in this.Hooks)
 			{
 				try
 				{
 					messages.Add(hook, await hook.ExecuteAsync(builder).ConfigureAwait(false));
 				}
 				catch (NotFoundException)
 				{
 					deadhooks.Add(hook);
 				}
 			}
 
 			// Removing dead webhooks from collection
 			foreach (var xwh in deadhooks) this.Hooks.Remove(xwh);
 
 			return messages;
 		}
 
 		~DiscordWebhookClient()
 		{
 			this.Hooks.Clear();
 			this.Hooks = null;
 			this.Apiclient.Rest.Dispose();
 		}
 	}
 }
diff --git a/DisCatSharp/DiscordConfiguration.cs b/DisCatSharp/DiscordConfiguration.cs
index 35016f651..12df820d2 100644
--- a/DisCatSharp/DiscordConfiguration.cs
+++ b/DisCatSharp/DiscordConfiguration.cs
@@ -1,275 +1,275 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Net;
 using DisCatSharp.Net.Udp;
 using DisCatSharp.Net.WebSocket;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Represents configuration for <see cref="DiscordClient"/> and <see cref="DiscordShardedClient"/>.
 	/// </summary>
 	public sealed class DiscordConfiguration
 	{
 		/// <summary>
 		/// Sets the token used to identify the client.
 		/// </summary>
 		public string Token
 		{
 			internal get => this._token;
 			set
 			{
 				if (string.IsNullOrWhiteSpace(value))
 					throw new ArgumentNullException(nameof(value), "Token cannot be null, empty, or all whitespace.");
 
 				this._token = value.Trim();
 			}
 		}
 		private string _token = "";
 
 		/// <summary>
 		/// <para>Sets the type of the token used to identify the client.</para>
 		/// <para>Defaults to <see cref="TokenType.Bot"/>.</para>
 		/// </summary>
 		public TokenType TokenType { internal get; set; } = TokenType.Bot;
 
 		/// <summary>
 		/// <para>Sets the minimum logging level for messages.</para>
 		/// <para>Typically, the default value of <see cref="Microsoft.Extensions.Logging.LogLevel.Information"/> is ok for most uses.</para>
 		/// </summary>
 		public LogLevel MinimumLogLevel { internal get; set; } = LogLevel.Information;
 
 		/// <summary>
 		/// Overwrites the api version.
 		/// Defaults to 9.
 		/// </summary>
 		public string ApiVersion { internal get; set; } = "9";
 
 		/// <summary>
 		/// <para>Sets whether to rely on Discord for NTP (Network Time Protocol) synchronization with the "X-Ratelimit-Reset-After" header.</para>
 		/// <para>If the system clock is unsynced, setting this to true will ensure ratelimits are synced with Discord and reduce the risk of hitting one.</para>
 		/// <para>This should only be set to false if the system clock is synced with NTP.</para>
 		/// <para>Defaults to true.</para>
 		/// </summary>
 		public bool UseRelativeRatelimit { internal get; set; } = true;
 
 		/// <summary>
 		/// <para>Allows you to overwrite the time format used by the internal debug logger.</para>
 		/// <para>Only applicable when <see cref="LoggerFactory"/> is set left at default value. Defaults to ISO 8601-like format.</para>
 		/// </summary>
 		public string LogTimestampFormat { internal get; set; } = "yyyy-MM-dd HH:mm:ss zzz";
 
 		/// <summary>
 		/// <para>Sets the member count threshold at which guilds are considered large.</para>
 		/// <para>Defaults to 250.</para>
 		/// </summary>
 		public int LargeThreshold { internal get; set; } = 250;
 
 		/// <summary>
 		/// <para>Sets whether to automatically reconnect in case a connection is lost.</para>
 		/// <para>Defaults to true.</para>
 		/// </summary>
 		public bool AutoReconnect { internal get; set; } = true;
 
 		/// <summary>
 		/// <para>Sets the ID of the shard to connect to.</para>
 		/// <para>If not sharding, or sharding automatically, this value should be left with the default value of 0.</para>
 		/// </summary>
-		public int ShardId { internal get; set; } = 0;
+		public int ShardId { internal get; set; }
 
 		/// <summary>
 		/// <para>Sets the total number of shards the bot is on. If not sharding, this value should be left with a default value of 1.</para>
 		/// <para>If sharding automatically, this value will indicate how many shards to boot. If left default for automatic sharding, the client will determine the shard count automatically.</para>
 		/// </summary>
 		public int ShardCount { internal get; set; } = 1;
 
 		/// <summary>
 		/// <para>Sets the level of compression for WebSocket traffic.</para>
 		/// <para>Disabling this option will increase the amount of traffic sent via WebSocket. Setting <see cref="GatewayCompressionLevel.Payload"/> will enable compression for READY and GUILD_CREATE payloads. Setting <see cref="GatewayCompressionLevel.Stream"/> will enable compression for the entire WebSocket stream, drastically reducing amount of traffic.</para>
 		/// <para>Defaults to <see cref="GatewayCompressionLevel.Stream"/>.</para>
 		/// </summary>
 		public GatewayCompressionLevel GatewayCompressionLevel { internal get; set; } = GatewayCompressionLevel.Stream;
 
 		/// <summary>
 		/// <para>Sets the size of the global message cache.</para>
 		/// <para>Setting this to 0 will disable message caching entirely. Defaults to 1024.</para>
 		/// </summary>
 		public int MessageCacheSize { internal get; set; } = 1024;
 
 		/// <summary>
 		/// <para>Sets the proxy to use for HTTP and WebSocket connections to Discord.</para>
 		/// <para>Defaults to null.</para>
 		/// </summary>
-		public IWebProxy Proxy { internal get; set; } = null;
+		public IWebProxy Proxy { internal get; set; }
 
 		/// <summary>
 		/// <para>Sets the timeout for HTTP requests.</para>
 		/// <para>Set to <see cref="System.Threading.Timeout.InfiniteTimeSpan"/> to disable timeouts.</para>
 		/// <para>Defaults to 20 seconds.</para>
 		/// </summary>
 		public TimeSpan HttpTimeout { internal get; set; } = TimeSpan.FromSeconds(20);
 
 		/// <summary>
 		/// <para>Defines that the client should attempt to reconnect indefinitely.</para>
 		/// <para>This is typically a very bad idea to set to <c>true</c>, as it will swallow all connection errors.</para>
 		/// <para>Defaults to false.</para>
 		/// </summary>
-		public bool ReconnectIndefinitely { internal get; set; } = false;
+		public bool ReconnectIndefinitely { internal get; set; }
 
 		/// <summary>
 		/// Sets whether the client should attempt to cache members if exclusively using unprivileged intents.
 		/// <para>
 		///     This will only take effect if there are no <see cref="DiscordIntents.GuildMembers"/> or <see cref="DiscordIntents.GuildPresences"/>
 		///     intents specified. Otherwise, this will always be overwritten to true.
 		/// </para>
 		/// <para>Defaults to true.</para>
 		/// </summary>
 		public bool AlwaysCacheMembers { internal get; set; } = true;
 
 		/// <summary>
 		/// <para>Sets the gateway intents for this client.</para>
 		/// <para>If set, the client will only receive events that they specify with intents.</para>
 		/// <para>Defaults to <see cref="DiscordIntents.AllUnprivileged"/>.</para>
 		/// </summary>
 		public DiscordIntents Intents { internal get; set; } = DiscordIntents.AllUnprivileged;
 
 		/// <summary>
 		/// <para>Sets the factory method used to create instances of WebSocket clients.</para>
 		/// <para>Use <see cref="DisCatSharp.Net.WebSocket.WebSocketClient.CreateNew(IWebProxy, IServiceProvider)"/> and equivalents on other implementations to switch out client implementations.</para>
 		/// <para>Defaults to <see cref="DisCatSharp.Net.WebSocket.WebSocketClient.CreateNew(IWebProxy, IServiceProvider)"/>.</para>
 		/// </summary>
 		public WebSocketClientFactoryDelegate WebSocketClientFactory
 		{
 			internal get => this._webSocketClientFactory;
 			set
 			{
 				if (value == null)
 					throw new InvalidOperationException("You need to supply a valid WebSocket client factory method.");
 
 				this._webSocketClientFactory = value;
 			}
 		}
 		private WebSocketClientFactoryDelegate _webSocketClientFactory = WebSocketClient.CreateNew;
 
 		/// <summary>
 		/// <para>Sets the factory method used to create instances of UDP clients.</para>
 		/// <para>Use <see cref="DcsUdpClient.CreateNew"/> and equivalents on other implementations to switch out client implementations.</para>
 		/// <para>Defaults to <see cref="DcsUdpClient.CreateNew"/>.</para>
 		/// </summary>
 		public UdpClientFactoryDelegate UdpClientFactory
 		{
 			internal get => this._udpClientFactory;
 			set => this._udpClientFactory = value ?? throw new InvalidOperationException("You need to supply a valid UDP client factory method.");
 		}
 		private UdpClientFactoryDelegate _udpClientFactory = DcsUdpClient.CreateNew;
 
 		/// <summary>
 		/// <para>Sets the logger implementation to use.</para>
 		/// <para>To create your own logger, implement the <see cref="Microsoft.Extensions.Logging.ILoggerFactory"/> instance.</para>
 		/// <para>Defaults to built-in implementation.</para>
 		/// </summary>
-		public ILoggerFactory LoggerFactory { internal get; set; } = null;
+		public ILoggerFactory LoggerFactory { internal get; set; }
 
 		/// <summary>
 		/// <para>Sets if the bot's status should show the mobile icon.</para>
 		/// <para>Defaults to false.</para>
 		/// </summary>
-		public bool MobileStatus { internal get; set; } = false;
+		public bool MobileStatus { internal get; set; }
 
 		/// <summary>
 		/// <para>Use canary.</para>
 		/// <para>Defaults to false.</para>
 		/// </summary>
-		public bool UseCanary { internal get; set; } = false;
+		public bool UseCanary { internal get; set; }
 
 		/// <summary>
 		/// <para>Refresh full guild channel cache.</para>
 		/// <para>Defaults to false.</para>
 		/// </summary>
-		public bool AutoRefreshChannelCache { internal get; set; } = false;
+		public bool AutoRefreshChannelCache { internal get; set; }
 
 		/// <summary>
 		/// <para>Do not use, this is meant for DisCatSharp Devs.</para>
 		/// <para>Defaults to null.</para>
 		/// </summary>
-		public string Override { internal get; set; } = null;
+		public string Override { internal get; set; }
 
 		/// <summary>
 		/// <para>Sets the service provider.</para>
 		/// <para>This allows passing data around without resorting to static members.</para>
 		/// <para>Defaults to null.</para>
 		/// </summary>
 		public IServiceProvider ServiceProvider { internal get; set; } = new ServiceCollection().BuildServiceProvider(true);
 
 		/// <summary>
 		/// Creates a new configuration with default values.
 		/// </summary>
 		public DiscordConfiguration()
 		{ }
 
 		/// <summary>
 		/// Utilized via Dependency Injection Pipeline
 		/// </summary>
 		/// <param name="provider"></param>
 		[ActivatorUtilitiesConstructor]
 		public DiscordConfiguration(IServiceProvider provider)
 		{
 			this.ServiceProvider = provider;
 		}
 
 		/// <summary>
 		/// Creates a clone of another discord configuration.
 		/// </summary>
 		/// <param name="other">Client configuration to clone.</param>
 		public DiscordConfiguration(DiscordConfiguration other)
 		{
 			this.Token = other.Token;
 			this.TokenType = other.TokenType;
 			this.MinimumLogLevel = other.MinimumLogLevel;
 			this.UseRelativeRatelimit = other.UseRelativeRatelimit;
 			this.LogTimestampFormat = other.LogTimestampFormat;
 			this.LargeThreshold = other.LargeThreshold;
 			this.AutoReconnect = other.AutoReconnect;
 			this.ShardId = other.ShardId;
 			this.ShardCount = other.ShardCount;
 			this.GatewayCompressionLevel = other.GatewayCompressionLevel;
 			this.MessageCacheSize = other.MessageCacheSize;
 			this.WebSocketClientFactory = other.WebSocketClientFactory;
 			this.UdpClientFactory = other.UdpClientFactory;
 			this.Proxy = other.Proxy;
 			this.HttpTimeout = other.HttpTimeout;
 			this.ReconnectIndefinitely = other.ReconnectIndefinitely;
 			this.Intents = other.Intents;
 			this.LoggerFactory = other.LoggerFactory;
 			this.MobileStatus = other.MobileStatus;
 			this.UseCanary = other.UseCanary;
 			this.AutoRefreshChannelCache = other.AutoRefreshChannelCache;
 			this.ApiVersion = other.ApiVersion;
 			this.ServiceProvider = other.ServiceProvider;
 			this.Override = other.Override;
 		}
 	}
 }
diff --git a/DisCatSharp/Entities/Channel/DiscordChannel.cs b/DisCatSharp/Entities/Channel/DiscordChannel.cs
index be1121fef..c5f875b2d 100644
--- a/DisCatSharp/Entities/Channel/DiscordChannel.cs
+++ b/DisCatSharp/Entities/Channel/DiscordChannel.cs
@@ -1,1402 +1,1371 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a discord channel.
 	/// </summary>
 	public class DiscordChannel : SnowflakeObject, IEquatable<DiscordChannel>
 	{
 		/// <summary>
 		/// Gets ID of the guild to which this channel belongs.
 		/// </summary>
 		[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong? GuildId { get; internal set; }
 
 		/// <summary>
 		/// Gets ID of the category that contains this channel.
 		/// </summary>
 		[JsonProperty("parent_id", NullValueHandling = NullValueHandling.Include)]
 		public ulong? ParentId { get; internal set; }
 
 		/// <summary>
 		/// Gets the category that contains this channel.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordChannel Parent
 			=> this.ParentId.HasValue ? this.Guild.GetChannel(this.ParentId.Value) : null;
 
 		/// <summary>
 		/// Gets the name of this channel.
 		/// </summary>
 		[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 		public string Name { get; internal set; }
 
 		/// <summary>
 		/// Gets the type of this channel.
 		/// </summary>
 		[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 		public ChannelType Type { get; internal set; }
 
 		/// <summary>
 		/// Gets this channels's banner hash, when applicable.
 		/// </summary>
 		[JsonProperty("banner")]
 		public string BannerHash { get; internal set; }
 
 		/// <summary>
 		/// Gets this channels's banner in url form.
 		/// </summary>
 		[JsonIgnore]
 		public string BannerUrl
 			=> !string.IsNullOrWhiteSpace(this.BannerHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Uri}{Endpoints.CHANNELS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.BANNERS}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}" : null;
 
 		/// <summary>
 		/// Gets the position of this channel.
 		/// </summary>
 		[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
 		public int Position { get; internal set; }
 
 		/// <summary>
 		/// Gets the maximum available position to move the channel to.
 		/// This can contain outdated informations.
 		/// </summary>
 		public int GetMaxPosition()
 		{
 			var channels = this.Guild.Channels.Values;
 			return this.ParentId != null
 				? this.Type == ChannelType.Text || this.Type == ChannelType.News
 					? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News)).OrderBy(xc => xc.Position).ToArray().Last().Position
 					: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 						? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage)).OrderBy(xc => xc.Position).ToArray().Last().Position
 						: channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().Last().Position
 				: channels.Where(xc => xc.ParentId == null && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().Last().Position;
 		}
 
 		/// <summary>
 		/// Gets the minimum available position to move the channel to.
 		/// </summary>
 		public int GetMinPosition()
 		{
 			var channels = this.Guild.Channels.Values;
 			return this.ParentId != null
 				? this.Type == ChannelType.Text || this.Type == ChannelType.News
 					? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News)).OrderBy(xc => xc.Position).ToArray().First().Position
 					: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 						? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage)).OrderBy(xc => xc.Position).ToArray().First().Position
 						: channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().First().Position
 				: channels.Where(xc => xc.ParentId == null && xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray().First().Position;
 		}
 
 		/// <summary>
 		/// Gets whether this channel is a DM channel.
 		/// </summary>
 		[JsonIgnore]
 		public bool IsPrivate
 			=> this.Type == ChannelType.Private || this.Type == ChannelType.Group;
 
 		/// <summary>
 		/// Gets whether this channel is a channel category.
 		/// </summary>
 		[JsonIgnore]
 		public bool IsCategory
 			=> this.Type == ChannelType.Category;
 
 		/// <summary>
 		/// Gets whether this channel is a stage channel.
 		/// </summary>
 		[JsonIgnore]
 		public bool IsStage
 			=> this.Type == ChannelType.Stage;
 
 		/// <summary>
 		/// Gets the guild to which this channel belongs.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordGuild Guild
 			=> this.GuildId.HasValue && this.Discord.Guilds.TryGetValue(this.GuildId.Value, out var guild) ? guild : null;
 
 		/// <summary>
 		/// Gets a collection of permission overwrites for this channel.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyList<DiscordOverwrite> PermissionOverwrites
 			=> this._permissionOverwritesLazy.Value;
 
 		[JsonProperty("permission_overwrites", NullValueHandling = NullValueHandling.Ignore)]
 		internal List<DiscordOverwrite> PermissionOverwritesInternal = new();
 		[JsonIgnore]
 		private readonly Lazy<IReadOnlyList<DiscordOverwrite>> _permissionOverwritesLazy;
 
 		/// <summary>
 		/// Gets the channel's topic. This is applicable to text channels only.
 		/// </summary>
 		[JsonProperty("topic", NullValueHandling = NullValueHandling.Ignore)]
 		public string Topic { get; internal set; }
 
 		/// <summary>
 		/// Gets the ID of the last message sent in this channel. This is applicable to text channels only.
 		/// </summary>
 		[JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong? LastMessageId { get; internal set; }
 
 		/// <summary>
 		/// Gets this channel's bitrate. This is applicable to voice channels only.
 		/// </summary>
 		[JsonProperty("bitrate", NullValueHandling = NullValueHandling.Ignore)]
 		public int? Bitrate { get; internal set; }
 
 		/// <summary>
 		/// Gets this channel's user limit. This is applicable to voice channels only.
 		/// </summary>
 		[JsonProperty("user_limit", NullValueHandling = NullValueHandling.Ignore)]
 		public int? UserLimit { get; internal set; }
 
 		/// <summary>
 		/// <para>Gets the slow mode delay configured for this channel.</para>
 		/// <para>All bots, as well as users with <see cref="Permissions.ManageChannels"/> or <see cref="Permissions.ManageMessages"/> permissions in the channel are exempt from slow mode.</para>
 		/// </summary>
 		[JsonProperty("rate_limit_per_user")]
 		public int? PerUserRateLimit { get; internal set; }
 
 		/// <summary>
 		/// Gets this channel's video quality mode. This is applicable to voice channels only.
 		/// </summary>
 		[JsonProperty("video_quality_mode", NullValueHandling = NullValueHandling.Ignore)]
 		public VideoQualityMode? QualityMode { get; internal set; }
 
 		/// <summary>
 		/// Gets when the last pinned message was pinned.
 		/// </summary>
 		[JsonIgnore]
 		public DateTimeOffset? LastPinTimestamp
 			=> !string.IsNullOrWhiteSpace(this.LastPinTimestampRaw) && DateTimeOffset.TryParse(this.LastPinTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 				dto : null;
 
 		/// <summary>
 		/// Gets when the last pinned message was pinned as raw string.
 		/// </summary>
 		[JsonProperty("last_pin_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 		internal string LastPinTimestampRaw { get; set; }
 
 		/// <summary>
 		/// Gets this channel's default duration for newly created threads, in minutes, to automatically archive the thread after recent activity.
 		/// </summary>
 		[JsonProperty("default_auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
 		public ThreadAutoArchiveDuration? DefaultAutoArchiveDuration { get; internal set; }
 
 		/// <summary>
 		/// Gets this channel's mention string.
 		/// </summary>
 		[JsonIgnore]
 		public string Mention
 			=> Formatter.Mention(this);
 
 		/// <summary>
 		/// Gets this channel's children. This applies only to channel categories.
 		/// </summary>
 		[JsonIgnore]
-		public IReadOnlyList<DiscordChannel> Children
-		{
-			get
-			{
-				return !this.IsCategory
-					? throw new ArgumentException("Only channel categories contain children.")
-					: this.Guild.ChannelsInternal.Values.Where(e => e.ParentId == this.Id).ToList();
-			}
-		}
+		public IReadOnlyList<DiscordChannel> Children =>
+			!this.IsCategory
+				? throw new ArgumentException("Only channel categories contain children.")
+				: this.Guild.ChannelsInternal.Values.Where(e => e.ParentId == this.Id).ToList();
 
 		/// <summary>
 		/// Gets the list of members currently in the channel (if voice channel), or members who can see the channel (otherwise).
 		/// </summary>
 		[JsonIgnore]
-		public virtual IReadOnlyList<DiscordMember> Users
-		{
-			get
-			{
-				return this.Guild == null
-					? throw new InvalidOperationException("Cannot query users outside of guild channels.")
-					: this.IsVoiceJoinable()
+		public virtual IReadOnlyList<DiscordMember> Users =>
+			this.Guild == null
+				? throw new InvalidOperationException("Cannot query users outside of guild channels.")
+				: this.IsVoiceJoinable()
 					? this.Guild.Members.Values.Where(x => x.VoiceState?.ChannelId == this.Id).ToList()
 					: this.Guild.Members.Values.Where(x => (this.PermissionsFor(x) & Permissions.AccessChannels) == Permissions.AccessChannels).ToList();
-			}
-		}
 
 		/// <summary>
 		/// Gets whether this channel is an NSFW channel.
 		/// </summary>
 		[JsonProperty("nsfw")]
 		public bool IsNsfw { get; internal set; }
 
 		/// <summary>
 		/// Gets this channel's region id (if voice channel).
 		/// </summary>
 		[JsonProperty("rtc_region", NullValueHandling = NullValueHandling.Ignore)]
 		internal string RtcRegionId { get; set; }
 
 		/// <summary>
 		/// Gets this channel's region override (if voice channel).
 		/// </summary>
 		[JsonIgnore]
 		public DiscordVoiceRegion RtcRegion
 			=> this.RtcRegionId != null ? this.Discord.VoiceRegions[this.RtcRegionId] : null;
 
 
 		/// <summary>
 		/// Only sent on the resolved channels of interaction responses for application commands. Gets the permissions of the user in this channel who invoked the command.
 		/// </summary>
 		[JsonProperty("permissions")]
 		public Permissions? UserPermissions { get; internal set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordChannel"/> class.
 		/// </summary>
 		internal DiscordChannel()
 		{
 			this._permissionOverwritesLazy = new Lazy<IReadOnlyList<DiscordOverwrite>>(() => new ReadOnlyCollection<DiscordOverwrite>(this.PermissionOverwritesInternal));
 		}
 
 		#region Methods
 
 		/// <summary>
 		/// Sends a message to this channel.
 		/// </summary>
 		/// <param name="content">Content of the message to send.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public Task<DiscordMessage> SendMessageAsync(string content)
-		{
-			return !this.IsWriteable()
+		public Task<DiscordMessage> SendMessageAsync(string content) =>
+			!this.IsWriteable()
 				? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 				: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
-		}
 
 		/// <summary>
 		/// Sends a message to this channel.
 		/// </summary>
 		/// <param name="embed">Embed to attach to the message.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed)
-		{
-			return !this.IsWriteable()
+		public Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed) =>
+			!this.IsWriteable()
 				? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 				: this.Discord.ApiClient.CreateMessageAsync(this.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
-		}
 
 		/// <summary>
 		/// Sends a message to this channel.
 		/// </summary>
 		/// <param name="embed">Embed to attach to the message.</param>
 		/// <param name="content">Content of the message to send.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed)
-		{
-			return !this.IsWriteable()
+		public Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed) =>
+			!this.IsWriteable()
 				? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 				: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
-		}
 
 		/// <summary>
 		/// Sends a message to this channel.
 		/// </summary>
 		/// <param name="builder">The builder with all the items to send.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder builder)
 			=> this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 
 		/// <summary>
 		/// Sends a message to this channel.
 		/// </summary>
 		/// <param name="action">The builder with all the items to send.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(Action<DiscordMessageBuilder> action)
 		{
 			var builder = new DiscordMessageBuilder();
 			action(builder);
 
 
 			return !this.IsWriteable()
 				? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 				: this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 		}
 
 		/// <summary>
 		/// Deletes a guild channel
 		/// </summary>
 		/// <param name="reason">Reason for audit logs.</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteAsync(string reason = null)
 			=> this.Discord.ApiClient.DeleteChannelAsync(this.Id, reason);
 
 		/// <summary>
 		/// Clones this channel. This operation will create a channel with identical settings to this one. Note that this will not copy messages.
 		/// </summary>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns>Newly-created channel.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordChannel> CloneAsync(string reason = null)
 		{
 			if (this.Guild == null)
 				throw new InvalidOperationException("Non-guild channels cannot be cloned.");
 
 			var ovrs = new List<DiscordOverwriteBuilder>();
 			foreach (var ovr in this.PermissionOverwritesInternal)
 #pragma warning disable CS0618 // Type or member is obsolete
 				ovrs.Add(await new DiscordOverwriteBuilder().FromAsync(ovr).ConfigureAwait(false));
 #pragma warning restore CS0618 // Type or member is obsolete
 
 			var bitrate = this.Bitrate;
 			var userLimit = this.UserLimit;
 			Optional<int?> perUserRateLimit = this.PerUserRateLimit;
 
 			if (!this.IsVoiceJoinable())
 			{
 				bitrate = null;
 				userLimit = null;
 			}
 
 			if (this.Type == ChannelType.Stage)
 			{
 				userLimit = null;
 			}
 			if (!this.IsWriteable())
 			{
 				perUserRateLimit = Optional.FromNoValue<int?>();
 			}
 
 			return await this.Guild.CreateChannelAsync(this.Name, this.Type, this.Parent, this.Topic, bitrate, userLimit, ovrs, this.IsNsfw, perUserRateLimit, this.QualityMode, reason).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Returns a specific message
 		/// </summary>
 		/// <param name="id">The id of the message</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public async Task<DiscordMessage> GetMessageAsync(ulong id)
-		{
-			return this.Discord.Configuration.MessageCacheSize > 0
-				&& this.Discord is DiscordClient dc
-				&& dc.MessageCache != null
-				&& dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
+		public async Task<DiscordMessage> GetMessageAsync(ulong id) =>
+			this.Discord.Configuration.MessageCacheSize > 0
+			&& this.Discord is DiscordClient dc
+			&& dc.MessageCache != null
+			&& dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
 				? msg
 				: await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
-		}
 
 		/// <summary>
 		/// Modifies the current channel.
 		/// </summary>
 		/// <param name="action">Action to perform on this channel</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
 		/// <exception cref="System.NotSupportedException">Thrown when the client does not have the correct <see cref="PremiumTier"/> for modifying the <see cref="ThreadAutoArchiveDuration"/>.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task ModifyAsync(Action<ChannelEditModel> action)
 		{
 			var mdl = new ChannelEditModel();
 			action(mdl);
 
 			if (mdl.DefaultAutoArchiveDuration.HasValue)
 			{
 				if (!Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.DefaultAutoArchiveDuration.Value))
 					throw new NotSupportedException($"Cannot modify DefaultAutoArchiveDuration. Guild needs boost tier {(mdl.DefaultAutoArchiveDuration.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 			}
 			if (mdl.Banner.HasValue)
 			{
 				if (!this.Guild.Features.CanSetChannelBanner)
 					throw new NotSupportedException($"Cannot modify Banner. Guild needs boost tier three.");
 			}
 
 			var bannerb64 = Optional.FromNoValue<string>();
 			if (mdl.Banner.HasValue && mdl.Banner.Value != null)
 				using (var imgtool = new ImageTool(mdl.Banner.Value))
 					bannerb64 = imgtool.GetBase64();
 			else if (mdl.Banner.HasValue)
 				bannerb64 = null;
 
 			return this.Discord.ApiClient.ModifyChannelAsync(this.Id, mdl.Name, mdl.Position, mdl.Topic, mdl.Nsfw,
 				mdl.Parent.HasValue ? mdl.Parent.Value?.Id : default(Optional<ulong?>), mdl.Bitrate, mdl.Userlimit, mdl.PerUserRateLimit, mdl.RtcRegion.IfPresent(r => r?.Id),
 				mdl.QualityMode, mdl.DefaultAutoArchiveDuration, mdl.Type, mdl.PermissionOverwrites, bannerb64, mdl.AuditLogReason);
 		}
 
 		/// <summary>
 		/// Updates the channel position when it doesn't have a category.
 		///
 		/// Use <see cref="ModifyParentAsync"/> for moving to other categories.
 		/// Use <see cref="RemoveParentAsync"/> to move out of a category.
 		/// Use <see cref="ModifyPositionInCategoryAsync"/> for moving within a category.
 		/// </summary>
 		/// <param name="position">Position the channel should be moved to.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task ModifyPositionAsync(int position, string reason = null)
 		{
 			if (this.Guild == null)
 				throw new ArgumentException("Cannot modify order of non-guild channels.");
 			if (!this.IsMovable())
 				throw new NotSupportedException("You can't move this type of channel in categories.");
 			if (this.ParentId != null)
 				throw new ArgumentException("Cannot modify order of channels within a category. Use ModifyPositionInCategoryAsync instead.");
 
 			var chns = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type).OrderBy(xc => xc.Position).ToArray();
 			var pmds = new RestGuildChannelReorderPayload[chns.Length];
 			for (var i = 0; i < chns.Length; i++)
 			{
 				pmds[i] = new RestGuildChannelReorderPayload
 				{
 					ChannelId = chns[i].Id,
 				};
 
 				pmds[i].Position = chns[i].Id == this.Id ? position : chns[i].Position >= position ? chns[i].Position + 1 : chns[i].Position;
 			}
 
 			return this.Discord.ApiClient.ModifyGuildChannelPositionAsync(this.Guild.Id, pmds, reason);
 		}
 
 		/// <summary>
 		/// Updates the channel position within it's own category.
 		///
 		/// Use <see cref="ModifyParentAsync"/> for moving to other categories.
 		/// Use <see cref="RemoveParentAsync"/> to move out of a category.
 		/// Use <see cref="ModifyPositionAsync"/> to move channels outside a category.
 		/// </summary>
 		/// <param name="position">The position.</param>
 		/// <param name="reason">The reason.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
 		/// <exception cref="System.ArgumentException">Thrown when function is called on a channel without a parent channel.</exception>
 		public async Task ModifyPositionInCategoryAsync(int position, string reason = null)
 		{
 			//if (this.ParentId == null)
 			//    throw new ArgumentException("You can call this function only on channels in categories.");
 
 			if (!this.IsMovableInParent())
 				throw new NotSupportedException("You can't move this type of channel in categories.");
 
 			var isUp = position > this.Position;
 
 			var channels = await this.InternalRefreshChannelsAsync();
 
 			var chns = this.ParentId != null
 				? this.Type == ChannelType.Text || this.Type == ChannelType.News
 					? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News))
 					: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 						? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage))
 						: channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type)
 				: this.Type == ChannelType.Text || this.Type == ChannelType.News
 					? channels.Where(xc => xc.ParentId == null && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News))
 					: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 						? channels.Where(xc => xc.ParentId == null && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage))
 						: channels.Where(xc => xc.ParentId == null && xc.Type == this.Type);
 
 			var ochns = chns.OrderBy(xc => xc.Position).ToArray();
 			var min = ochns.First().Position;
 			var max = ochns.Last().Position;
 
 			if (position > max || position < min)
 				throw new IndexOutOfRangeException($"Position is not in range. {position} is {(position > max ? "greater then the maximal" : "lower then the minimal")} position.");
 
 			var pmds = new RestGuildChannelReorderPayload[ochns.Length];
 			for (var i = 0; i < ochns.Length; i++)
 			{
 				pmds[i] = new RestGuildChannelReorderPayload
 				{
 					ChannelId = ochns[i].Id,
 				};
 
 				if (ochns[i].Id == this.Id)
 				{
 					pmds[i].Position = position;
 				}
 				else
 				{
 					if (isUp)
 					{
 						if (ochns[i].Position <= position && ochns[i].Position > this.Position)
 						{
 							pmds[i].Position = ochns[i].Position - 1;
 						}
 						else if (ochns[i].Position < this.Position || ochns[i].Position > position)
 						{
 							pmds[i].Position = ochns[i].Position;
 						}
 					}
 					else
 					{
 						if (ochns[i].Position >= position && ochns[i].Position < this.Position)
 						{
 							pmds[i].Position = ochns[i].Position + 1;
 						}
 						else if (ochns[i].Position > this.Position || ochns[i].Position < position)
 						{
 							pmds[i].Position = ochns[i].Position;
 						}
 					}
 				}
 			}
 
 			await this.Discord.ApiClient.ModifyGuildChannelPositionAsync(this.Guild.Id, pmds, reason).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Internaly refreshes the channel list.
 		/// </summary>
 		private async Task<IReadOnlyList<DiscordChannel>> InternalRefreshChannelsAsync()
 		{
 			await this.RefreshPositionsAsync();
 			return this.Guild.Channels.Values.ToList().AsReadOnly();
 		}
 
 		/// <summary>
 		/// Refreshes the positions.
 		/// </summary>
 		public async Task RefreshPositionsAsync()
 		{
 			var channels = await this.Discord.ApiClient.GetGuildChannelsAsync(this.Guild.Id);
 			this.Guild.ChannelsInternal.Clear();
 			foreach (var channel in channels.ToList())
 			{
 				channel.Discord = this.Discord;
 				foreach (var xo in channel.PermissionOverwritesInternal)
 				{
 					xo.Discord = this.Discord;
 					xo.ChannelId = channel.Id;
 				}
 				this.Guild.ChannelsInternal[channel.Id] = channel;
 			}
 		}
 
 		/// <summary>
 		/// Updates the channel position within it's own category.
 		/// Valid modes: '+' or 'down' to move a channel down | '-' or 'up' to move a channel up.
 		///
 		/// Use <see cref="ModifyParentAsync"/> for moving to other categories.
 		/// Use <see cref="RemoveParentAsync"/> to move out of a category.
 		/// Use <see cref="ModifyPositionAsync"/> to move channels outside a category.
 		/// </summary>
 		/// <param name="mode">The mode. Valid: '+' or 'down' to move a channel down | '-' or 'up' to move a channel up</param>
 		/// <param name="position">The position.</param>
 		/// <param name="reason">The reason.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
 		/// <exception cref="System.ArgumentException">Thrown when function is called on a channel without a parent channel, a wrong mode is givven or given position is zero.</exception>
 		public Task ModifyPositionInCategorySmartAsync(string mode, int position, string reason = null)
 		{
 			if (!this.IsMovableInParent())
 				throw new NotSupportedException("You can't move this type of channel in categories.");
 
 			if (mode != "+" && mode != "-" && mode != "down" && mode != "up")
 				throw new ArgumentException("Error with the selected mode: Valid is '+' or 'down' to move a channel down and '-' or 'up' to move a channel up");
 
 			var positive = mode == "+" || mode == "positive" || mode == "down";
 			var negative = mode == "-" || mode == "negative" || mode == "up";
 			return positive
 				? position < this.GetMaxPosition()
 					? this.ModifyPositionInCategoryAsync(this.Position + position, reason)
 					: throw new IndexOutOfRangeException($"Position is not in range of category.")
 				: negative
 					? position > this.GetMinPosition()
 						? this.ModifyPositionInCategoryAsync(this.Position - position, reason)
 						: throw new IndexOutOfRangeException($"Position is not in range of category.")
 					: throw new ArgumentException("You can only modify with +X or -X. 0 is not valid.");
 		}
 
 		/// <summary>
 		/// Updates the channel parent, moving the channel to the bottom of the new category.
 		/// </summary>
 		/// <param name="newParent">New parent for channel. Will move out of parent if null.</param>
 		/// <param name="lockPermissions">Sync permissions with parent. Defaults to null.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 		public Task ModifyParentAsync(DiscordChannel? newParent = null, bool? lockPermissions = null, string reason = null)
 #pragma warning restore CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 		{
 			if (this.Guild == null)
 				throw new ArgumentException("Cannot modify parent of non-guild channels.");
 			if (!this.IsMovableInParent())
 				throw new NotSupportedException("You can't move this type of channel in categories.");
 			if (newParent.Type is not ChannelType.Category)
 				throw new ArgumentException("Only category type channels can be parents.");
 
 
 			var position = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type && xc.ParentId == newParent.Id) // gets list same type channels in parent
                             .Select(xc => xc.Position).DefaultIfEmpty(-1).Max() + 1; // returns highest position of list +1, default val: 0
 
 			var chns = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type)
 							.OrderBy(xc => xc.Position).ToArray();
 
 			var pmds = new RestGuildChannelNewParentPayload[chns.Length];
 
 			for (var i = 0; i < chns.Length; i++)
 			{
 				pmds[i] = new RestGuildChannelNewParentPayload
 				{
 					ChannelId = chns[i].Id,
 					Position = chns[i].Position >= position ? chns[i].Position + 1 : chns[i].Position,
 				};
 				if (chns[i].Id == this.Id)
 				{
 					pmds[i].Position = position;
 					pmds[i].ParentId = newParent is not null ? newParent.Id : null;
 					pmds[i].LockPermissions = lockPermissions;
 				}
 			}
 
 			return this.Discord.ApiClient.ModifyGuildChannelParentAsync(this.Guild.Id, pmds, reason);
 		}
 
 		/// <summary>
 		/// Moves the channel out of a category.
 		/// </summary>
 		/// <param name="reason">Reason for audit logs.</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task RemoveParentAsync(string reason = null)
 		{
 			if (this.Guild == null)
 				throw new ArgumentException("Cannot modify parent of non-guild channels.");
 			if (!this.IsMovableInParent())
 				throw new NotSupportedException("You can't move this type of channel in categories.");
 
 			var position = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type && xc.Parent is null) //gets list of same type channels with no parent
                             .Select(xc => xc.Position).DefaultIfEmpty(-1).Max() + 1; // returns highest position of list +1, default val: 0
 
 			var chns = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type)
 				.OrderBy(xc => xc.Position).ToArray();
 
 			var pmds = new RestGuildChannelNoParentPayload[chns.Length];
 
 			for (var i = 0; i < chns.Length; i++)
 			{
 				pmds[i] = new RestGuildChannelNoParentPayload
 				{
 					ChannelId = chns[i].Id,
 				};
 				if (chns[i].Id == this.Id)
 				{
 					pmds[i].Position = 1;
 					pmds[i].ParentId = null;
 				}
 				else
 				{
 					pmds[i].Position = chns[i].Position < this.Position ? chns[i].Position + 1 : chns[i].Position;
 				}
 			}
 
 			return this.Discord.ApiClient.DetachGuildChannelParentAsync(this.Guild.Id, pmds, reason);
 		}
 
 		/// <summary>
 		/// Returns a list of messages before a certain message.
 		/// <param name="limit">The amount of messages to fetch.</param>
 		/// <param name="before">Message to fetch before from.</param>
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordMessage>> GetMessagesBeforeAsync(ulong before, int limit = 100)
 			=> this.GetMessagesInternalAsync(limit, before, null, null);
 
 		/// <summary>
 		/// Returns a list of messages after a certain message.
 		/// <param name="limit">The amount of messages to fetch.</param>
 		/// <param name="after">Message to fetch after from.</param>
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordMessage>> GetMessagesAfterAsync(ulong after, int limit = 100)
 			=> this.GetMessagesInternalAsync(limit, null, after, null);
 
 		/// <summary>
 		/// Returns a list of messages around a certain message.
 		/// <param name="limit">The amount of messages to fetch.</param>
 		/// <param name="around">Message to fetch around from.</param>
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordMessage>> GetMessagesAroundAsync(ulong around, int limit = 100)
 			=> this.GetMessagesInternalAsync(limit, null, null, around);
 
 		/// <summary>
 		/// Returns a list of messages from the last message in the channel.
 		/// <param name="limit">The amount of messages to fetch.</param>
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordMessage>> GetMessagesAsync(int limit = 100) =>
 			this.GetMessagesInternalAsync(limit, null, null, null);
 
 		/// <summary>
 		/// Returns a list of messages
 		/// </summary>
 		/// <param name="limit">How many messages should be returned.</param>
 		/// <param name="before">Get messages before snowflake.</param>
 		/// <param name="after">Get messages after snowflake.</param>
 		/// <param name="around">Get messages around snowflake.</param>
 		private async Task<IReadOnlyList<DiscordMessage>> GetMessagesInternalAsync(int limit = 100, ulong? before = null, ulong? after = null, ulong? around = null)
 		{
 			if (!this.IsWriteable())
 				throw new ArgumentException("Cannot get the messages of a non-text channel.");
 
 			if (limit < 0)
 				throw new ArgumentException("Cannot get a negative number of messages.");
 
 			if (limit == 0)
 				return Array.Empty<DiscordMessage>();
 
 			//return this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, limit, before, after, around);
 			if (limit > 100 && around != null)
 				throw new InvalidOperationException("Cannot get more than 100 messages around the specified ID.");
 
 			var msgs = new List<DiscordMessage>(limit);
 			var remaining = limit;
 			ulong? last = null;
 			var isAfter = after != null;
 
 			int lastCount;
 			do
 			{
 				var fetchSize = remaining > 100 ? 100 : remaining;
 				var fetch = await this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, fetchSize, !isAfter ? last ?? before : null, isAfter ? last ?? after : null, around).ConfigureAwait(false);
 
 				lastCount = fetch.Count;
 				remaining -= lastCount;
 
 				if (!isAfter)
 				{
 					msgs.AddRange(fetch);
 					last = fetch.LastOrDefault()?.Id;
 				}
 				else
 				{
 					msgs.InsertRange(0, fetch);
 					last = fetch.FirstOrDefault()?.Id;
 				}
 			}
 			while (remaining > 0 && lastCount > 0);
 
 			return new ReadOnlyCollection<DiscordMessage>(msgs);
 		}
 
 		/// <summary>
 		/// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="DisCatSharp.Exceptions.BadRequestException"/> error.
 		/// </summary>
 		/// <param name="messages">A collection of messages to delete.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task DeleteMessagesAsync(IEnumerable<DiscordMessage> messages, string reason = null)
 		{
 			// don't enumerate more than once
 			var msgs = messages.Where(x => x.Channel.Id == this.Id).Select(x => x.Id).ToArray();
 			if (messages == null || !msgs.Any())
 				throw new ArgumentException("You need to specify at least one message to delete.");
 
 			if (msgs.Count() < 2)
 			{
 				await this.Discord.ApiClient.DeleteMessageAsync(this.Id, msgs.Single(), reason).ConfigureAwait(false);
 				return;
 			}
 
 			for (var i = 0; i < msgs.Count(); i += 100)
 				await this.Discord.ApiClient.DeleteMessagesAsync(this.Id, msgs.Skip(i).Take(100), reason).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Deletes a message
 		/// </summary>
 		/// <param name="message">The message to be deleted.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteMessageAsync(DiscordMessage message, string reason = null)
 			=> this.Discord.ApiClient.DeleteMessageAsync(this.Id, message.Id, reason);
 
 		/// <summary>
 		/// Returns a list of invite objects
 		/// </summary>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync()
-		{
-			return this.Guild == null
+		public Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync() =>
+			this.Guild == null
 				? throw new ArgumentException("Cannot get the invites of a channel that does not belong to a guild.")
 				: this.Discord.ApiClient.GetChannelInvitesAsync(this.Id);
-		}
 
 		/// <summary>
 		/// Create a new invite object
 		/// </summary>
 		/// <param name="maxAge">Duration of invite in seconds before expiry, or 0 for never.  Defaults to 86400.</param>
 		/// <param name="maxUses">Max number of uses or 0 for unlimited. Defaults to 0</param>
 		/// <param name="temporary">Whether this invite should be temporary. Defaults to false.</param>
 		/// <param name="unique">Whether this invite should be unique. Defaults to false.</param>
 		/// <param name="targetType">The target type. Defaults to null.</param>
 		/// <param name="targetApplication">The target activity. Defaults to null.</param>
 		/// <param name="targetUser">The target user id. Defaults to null.</param>
 		/// <param name="reason">The audit log reason.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordInvite> CreateInviteAsync(int maxAge = 86400, int maxUses = 0, bool temporary = false, bool unique = false, TargetType? targetType = null, TargetActivity? targetApplication = null, ulong? targetUser = null, string reason = null)
 			=> this.Discord.ApiClient.CreateChannelInviteAsync(this.Id, maxAge, maxUses, targetType, targetApplication, targetUser, temporary, unique, reason);
 
 		#region Stage
 
 		/// <summary>
 		/// Opens a stage.
 		/// </summary>
 		/// <param name="topic">Topic of the stage.</param>
 		/// <param name="sendStartNotification">Whether @everyone should be notified.</param>
 		/// <param name="privacyLevel">Privacy level of the stage (Defaults to <see cref="StagePrivacyLevel.GuildOnly"/>.</param>
 		/// <param name="reason">Audit log reason.</param>
 		/// <returns>Stage instance</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordStageInstance> OpenStageAsync(string topic, bool sendStartNotification = false, StagePrivacyLevel privacyLevel = StagePrivacyLevel.GuildOnly, string reason = null)
 			=> await this.Discord.ApiClient.CreateStageInstanceAsync(this.Id, topic, sendStartNotification, privacyLevel, reason);
 
 		/// <summary>
 		/// Modifies a stage topic.
 		/// </summary>
 		/// <param name="topic">New topic of the stage.</param>
 		/// <param name="privacyLevel">New privacy level of the stage.</param>
 		/// <param name="reason">Audit log reason.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task ModifyStageAsync(Optional<string> topic, Optional<StagePrivacyLevel> privacyLevel, string reason = null)
 			=> await this.Discord.ApiClient.ModifyStageInstanceAsync(this.Id, topic, privacyLevel, reason);
 
 		/// <summary>
 		/// Closes a stage.
 		/// </summary>
 		/// <param name="reason">Audit log reason.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task CloseStageAsync(string reason = null)
 			=> await this.Discord.ApiClient.DeleteStageInstanceAsync(this.Id, reason);
 
 		/// <summary>
 		/// Gets a stage.
 		/// </summary>
 		/// <returns>The requested stage.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or <see cref="Permissions.UseVoice"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordStageInstance> GetStageAsync()
 			=> await this.Discord.ApiClient.GetStageInstanceAsync(this.Id);
 
 		#endregion
 
 		#region Threads
 
 		/// <summary>
 		/// Creates a thread.
 		/// Depending on whether it is created inside an <see cref="ChannelType.News"/> or an <see cref="ChannelType.Text"/> it is either an <see cref="ChannelType.NewsThread"/> or an <see cref="ChannelType.PublicThread"/>.
 		/// Depending on whether the <see cref="ChannelType"/> is set to <see cref="ChannelType.PrivateThread"/> it is either an <see cref="ChannelType.PrivateThread"/> or an <see cref="ChannelType.PublicThread"/> (default).
 		/// </summary>
 		/// <param name="name">The name of the thread.</param>
 		/// <param name="autoArchiveDuration"><see cref="ThreadAutoArchiveDuration"/> till it gets archived. Defaults to <see cref="ThreadAutoArchiveDuration.OneHour"/>.</param>
 		/// <param name="type">Can be either an <see cref="ChannelType.PrivateThread"/>, <see cref="ChannelType.NewsThread"/> or an <see cref="ChannelType.PublicThread"/>.</param>
 		/// <param name="rateLimitPerUser">The per user ratelimit, aka slowdown.</param>
 		/// <param name="reason">Audit log reason.</param>
 		/// <returns>The created thread.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePublicThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> or if creating a private thread the <see cref="Permissions.CreatePrivateThreads"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild hasn't enabled threads atm.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>. Or if <see cref="GuildFeatures.CanCreatePrivateThreads"/> is not enabled for guild. This happens, if the guild does not have <see cref="PremiumTier.TierTwo"/></exception>
-		public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, ChannelType type = ChannelType.PublicThread, int? rateLimitPerUser = null, string reason = null)
-		{
-			return (type != ChannelType.NewsThread && type != ChannelType.PublicThread && type != ChannelType.PrivateThread)
+		public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, ChannelType type = ChannelType.PublicThread, int? rateLimitPerUser = null, string reason = null) =>
+			type != ChannelType.NewsThread && type != ChannelType.PublicThread && type != ChannelType.PrivateThread
 				? throw new NotSupportedException("Wrong thread type given.")
-				: (!this.IsThreadHolder())
-				? throw new NotSupportedException("Parent channel can't have threads.")
-				: type == ChannelType.PrivateThread
-				? Utilities.CheckThreadPrivateFeature(this.Guild)
-				? Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, autoArchiveDuration)
-					? await this.Discord.ApiClient.CreateThreadWithoutMessageAsync(this.Id, name, autoArchiveDuration, type, rateLimitPerUser, reason)
-					: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.")
-				: throw new NotSupportedException($"Cannot create a private thread. Guild needs to be boost tier two.")
-				: Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, autoArchiveDuration)
-					? await this.Discord.ApiClient.CreateThreadWithoutMessageAsync(this.Id, name, autoArchiveDuration, this.Type == ChannelType.News ? ChannelType.NewsThread : ChannelType.PublicThread, rateLimitPerUser, reason)
-				: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
-		}
+				: !this.IsThreadHolder()
+					? throw new NotSupportedException("Parent channel can't have threads.")
+					: type == ChannelType.PrivateThread
+						? Utilities.CheckThreadPrivateFeature(this.Guild)
+							? Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, autoArchiveDuration)
+								? await this.Discord.ApiClient.CreateThreadWithoutMessageAsync(this.Id, name, autoArchiveDuration, type, rateLimitPerUser, reason)
+								: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.")
+							: throw new NotSupportedException($"Cannot create a private thread. Guild needs to be boost tier two.")
+						: Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, autoArchiveDuration)
+							? await this.Discord.ApiClient.CreateThreadWithoutMessageAsync(this.Id, name, autoArchiveDuration, this.Type == ChannelType.News ? ChannelType.NewsThread : ChannelType.PublicThread, rateLimitPerUser, reason)
+							: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 
 		/// <summary>
 		/// Creates a scheduled event based on the channel type.
 		/// </summary>
 		/// <param name="name">The name.</param>
 		/// <param name="scheduledStartTime">The scheduled start time.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A scheduled event.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the ressource does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordScheduledEvent> CreateScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, string description = null, string reason = null)
 		{
 			if (!this.IsVoiceJoinable())
 				throw new NotSupportedException("Cannot create a scheduled event for this type of channel. Channel type must be either voice or stage.");
 
 			var type = this.Type == ChannelType.Voice ? ScheduledEventEntityType.Voice : ScheduledEventEntityType.StageInstance;
 
 			return await this.Guild.CreateScheduledEventAsync(name, scheduledStartTime, null, this, null, description, type, reason);
 		}
 
 
 		/// <summary>
 		/// Gets joined archived private threads. Can contain more threads.
 		/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 		/// </summary>
 		/// <param name="before">Get threads created before this thread id.</param>
 		/// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordThreadResult> GetJoinedPrivateArchivedThreadsAsync(ulong? before, int? limit)
 			=> await this.Discord.ApiClient.GetJoinedPrivateArchivedThreadsAsync(this.Id, before, limit);
 
 		/// <summary>
 		/// Gets archived public threads. Can contain more threads.
 		/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 		/// </summary>
 		/// <param name="before">Get threads created before this thread id.</param>
 		/// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordThreadResult> GetPublicArchivedThreadsAsync(ulong? before, int? limit)
 			=> await this.Discord.ApiClient.GetPublicArchivedThreadsAsync(this.Id, before, limit);
 
 		/// <summary>
 		/// Gets archived private threads. Can contain more threads.
 		/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 		/// </summary>
 		/// <param name="before">Get threads created before this thread id.</param>
 		/// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> or <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordThreadResult> GetPrivateArchivedThreadsAsync(ulong? before, int? limit)
 			=> await this.Discord.ApiClient.GetPrivateArchivedThreadsAsync(this.Id, before, limit);
 
 		#endregion
 
 		/// <summary>
 		/// Adds a channel permission overwrite for specified role.
 		/// </summary>
 		/// <param name="role">The role to have the permission added.</param>
 		/// <param name="allow">The permissions to allow.</param>
 		/// <param name="deny">The permissions to deny.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task AddOverwriteAsync(DiscordRole role, Permissions allow = Permissions.None, Permissions deny = Permissions.None, string reason = null)
 			=> this.Discord.ApiClient.EditChannelPermissionsAsync(this.Id, role.Id, allow, deny, "role", reason);
 
 
 		/// <summary>
 		/// Adds a channel permission overwrite for specified member.
 		/// </summary>
 		/// <param name="member">The member to have the permission added.</param>
 		/// <param name="allow">The permissions to allow.</param>
 		/// <param name="deny">The permissions to deny.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task AddOverwriteAsync(DiscordMember member, Permissions allow = Permissions.None, Permissions deny = Permissions.None, string reason = null)
 			=> this.Discord.ApiClient.EditChannelPermissionsAsync(this.Id, member.Id, allow, deny, "member", reason);
 
 		/// <summary>
 		/// Deletes a channel permission overwrite for specified member.
 		/// </summary>
 		/// <param name="member">The member to have the permission deleted.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteOverwriteAsync(DiscordMember member, string reason = null)
 			=> this.Discord.ApiClient.DeleteChannelPermissionAsync(this.Id, member.Id, reason);
 
 		/// <summary>
 		/// Deletes a channel permission overwrite for specified role.
 		/// </summary>
 		/// <param name="role">The role to have the permission deleted.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteOverwriteAsync(DiscordRole role, string reason = null)
 			=> this.Discord.ApiClient.DeleteChannelPermissionAsync(this.Id, role.Id, reason);
 
 		/// <summary>
 		/// Post a typing indicator
 		/// </summary>
 
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public Task TriggerTypingAsync()
-		{
-			return !this.IsWriteable()
+		public Task TriggerTypingAsync() =>
+			!this.IsWriteable()
 				? throw new ArgumentException("Cannot start typing in a non-text channel.")
 				: this.Discord.ApiClient.TriggerTypingAsync(this.Id);
-		}
 
 		/// <summary>
 		/// Returns all pinned messages
 		/// </summary>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync()
-		{
-			return !this.IsWriteable()
+		public Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync() =>
+			!this.IsWriteable()
 				? throw new ArgumentException("A non-text channel does not have pinned messages.")
 				: this.Discord.ApiClient.GetPinnedMessagesAsync(this.Id);
-		}
 
 		/// <summary>
 		/// Create a new webhook
 		/// </summary>
 		/// <param name="name">The name of the webhook.</param>
 		/// <param name="avatar">The image for the default webhook avatar.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordWebhook> CreateWebhookAsync(string name, Optional<Stream> avatar = default, string reason = null)
 		{
 			var av64 = Optional.FromNoValue<string>();
 			if (avatar.HasValue && avatar.Value != null)
 				using (var imgtool = new ImageTool(avatar.Value))
 					av64 = imgtool.GetBase64();
 			else if (avatar.HasValue)
 				av64 = null;
 
 			return await this.Discord.ApiClient.CreateWebhookAsync(this.Id, name, av64, reason).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Returns a list of webhooks
 		/// </summary>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
 			=> this.Discord.ApiClient.GetChannelWebhooksAsync(this.Id);
 
 		/// <summary>
 		/// Moves a member to this voice channel
 		/// </summary>
 		/// <param name="member">The member to be moved.</param>
 
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exists or if the Member does not exists.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task PlaceMemberAsync(DiscordMember member)
 		{
 			if (!this.IsVoiceJoinable())
 				throw new ArgumentException("Cannot place a member in a non-voice channel.");
 
 			await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, member.Id, default, default, default,
 				default, this.Id, null).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Follows a news channel
 		/// </summary>
 		/// <param name="targetChannel">Channel to crosspost messages to</param>
 		/// <exception cref="System.ArgumentException">Thrown when trying to follow a non-news channel</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the current user doesn't have <see cref="Permissions.ManageWebhooks"/> on the target channel</exception>
-		public Task<DiscordFollowedChannel> FollowAsync(DiscordChannel targetChannel)
-		{
-			return this.Type != ChannelType.News
+		public Task<DiscordFollowedChannel> FollowAsync(DiscordChannel targetChannel) =>
+			this.Type != ChannelType.News
 				? throw new ArgumentException("Cannot follow a non-news channel.")
 				: this.Discord.ApiClient.FollowChannelAsync(this.Id, targetChannel.Id);
-		}
 
 		/// <summary>
 		/// Publishes a message in a news channel to following channels
 		/// </summary>
 		/// <param name="message">Message to publish</param>
 		/// <exception cref="System.ArgumentException">Thrown when the message has already been crossposted</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">
 		///     Thrown when the current user doesn't have <see cref="Permissions.ManageWebhooks"/> and/or <see cref="Permissions.SendMessages"/>
 		/// </exception>
-		public Task<DiscordMessage> CrosspostMessageAsync(DiscordMessage message)
-		{
-			return (message.Flags & MessageFlags.Crossposted) == MessageFlags.Crossposted
+		public Task<DiscordMessage> CrosspostMessageAsync(DiscordMessage message) =>
+			(message.Flags & MessageFlags.Crossposted) == MessageFlags.Crossposted
 				? throw new ArgumentException("Message is already crossposted.")
 				: this.Discord.ApiClient.CrosspostMessageAsync(this.Id, message.Id);
-		}
 
 		/// <summary>
 		/// Updates the current user's suppress state in this channel, if stage channel.
 		/// </summary>
 		/// <param name="suppress">Toggles the suppress state.</param>
 		/// <param name="requestToSpeakTimestamp">Sets the time the user requested to speak.</param>
 		/// <exception cref="System.ArgumentException">Thrown when the channel is not a stage channel.</exception>
 		public async Task UpdateCurrentUserVoiceStateAsync(bool? suppress, DateTimeOffset? requestToSpeakTimestamp = null)
 		{
 			if (this.Type != ChannelType.Stage)
 				throw new ArgumentException("Voice state can only be updated in a stage channel.");
 
 			await this.Discord.ApiClient.UpdateCurrentUserVoiceStateAsync(this.GuildId.Value, this.Id, suppress, requestToSpeakTimestamp).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Calculates permissions for a given member.
 		/// </summary>
 		/// <param name="mbr">Member to calculate permissions for.</param>
 		/// <returns>Calculated permissions for a given member.</returns>
 		public Permissions PermissionsFor(DiscordMember mbr)
 		{
 			// future note: might be able to simplify @everyone role checks to just check any role ... but I'm not sure
 			// xoxo, ~uwx
 			//
 			// you should use a single tilde
 			// ~emzi
 
 			// user > role > everyone
 			// allow > deny > undefined
 			// =>
 			// user allow > user deny > role allow > role deny > everyone allow > everyone deny
 			// thanks to meew0
 
 			if (this.IsPrivate || this.Guild == null)
 				return Permissions.None;
 
 			if (this.Guild.OwnerId == mbr.Id)
 				return PermissionMethods.FullPerms;
 
 			Permissions perms;
 
 			// assign @everyone permissions
 			var everyoneRole = this.Guild.EveryoneRole;
 			perms = everyoneRole.Permissions;
 
 			// roles that member is in
 			var mbRoles = mbr.Roles.Where(xr => xr.Id != everyoneRole.Id).ToArray();
 
 			// assign permissions from member's roles (in order)
 			perms |= mbRoles.Aggregate(Permissions.None, (c, role) => c | role.Permissions);
 
 			// Adminstrator grants all permissions and cannot be overridden
 			if ((perms & Permissions.Administrator) == Permissions.Administrator)
 				return PermissionMethods.FullPerms;
 
 			// channel overrides for roles that member is in
 			var mbRoleOverrides = mbRoles
 				.Select(xr => this.PermissionOverwritesInternal.FirstOrDefault(xo => xo.Id == xr.Id))
 				.Where(xo => xo != null)
 				.ToList();
 
 			// assign channel permission overwrites for @everyone pseudo-role
 			var everyoneOverwrites = this.PermissionOverwritesInternal.FirstOrDefault(xo => xo.Id == everyoneRole.Id);
 			if (everyoneOverwrites != null)
 			{
 				perms &= ~everyoneOverwrites.Denied;
 				perms |= everyoneOverwrites.Allowed;
 			}
 
 			// assign channel permission overwrites for member's roles (explicit deny)
 			perms &= ~mbRoleOverrides.Aggregate(Permissions.None, (c, overs) => c | overs.Denied);
 			// assign channel permission overwrites for member's roles (explicit allow)
 			perms |= mbRoleOverrides.Aggregate(Permissions.None, (c, overs) => c | overs.Allowed);
 
 			// channel overrides for just this member
 			var mbOverrides = this.PermissionOverwritesInternal.FirstOrDefault(xo => xo.Id == mbr.Id);
 			if (mbOverrides == null) return perms;
 
 			// assign channel permission overwrites for just this member
 			perms &= ~mbOverrides.Denied;
 			perms |= mbOverrides.Allowed;
 
 			return perms;
 		}
 
 		/// <summary>
 		/// Returns a string representation of this channel.
 		/// </summary>
 		/// <returns>String representation of this channel.</returns>
-		public override string ToString()
-		{
-			return this.Type == ChannelType.Category
+		public override string ToString() =>
+			this.Type == ChannelType.Category
 				? $"Channel Category {this.Name} ({this.Id})"
 				: this.Type == ChannelType.Text || this.Type == ChannelType.News || this.IsThread()
-				? $"Channel #{this.Name} ({this.Id})"
-				: this.IsVoiceJoinable()
-				? $"Channel #!{this.Name} ({this.Id})"
-				: !string.IsNullOrWhiteSpace(this.Name) ? $"Channel {this.Name} ({this.Id})" : $"Channel {this.Id}";
-		}
+					? $"Channel #{this.Name} ({this.Id})"
+					: this.IsVoiceJoinable()
+						? $"Channel #!{this.Name} ({this.Id})"
+						: !string.IsNullOrWhiteSpace(this.Name) ? $"Channel {this.Name} ({this.Id})" : $"Channel {this.Id}";
+
 		#endregion
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordChannel"/> is equal to another object.
 		/// </summary>
 		/// <param name="obj">Object to compare to.</param>
 		/// <returns>Whether the object is equal to this <see cref="DiscordChannel"/>.</returns>
 		public override bool Equals(object obj) => this.Equals(obj as DiscordChannel);
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordChannel"/> is equal to another <see cref="DiscordChannel"/>.
 		/// </summary>
 		/// <param name="e"><see cref="DiscordChannel"/> to compare to.</param>
 		/// <returns>Whether the <see cref="DiscordChannel"/> is equal to this <see cref="DiscordChannel"/>.</returns>
 		public bool Equals(DiscordChannel e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 		/// <summary>
 		/// Gets the hash code for this <see cref="DiscordChannel"/>.
 		/// </summary>
 		/// <returns>The hash code for this <see cref="DiscordChannel"/>.</returns>
 		public override int GetHashCode() => this.Id.GetHashCode();
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordChannel"/> objects are equal.
 		/// </summary>
 		/// <param name="e1">First channel to compare.</param>
 		/// <param name="e2">Second channel to compare.</param>
 		/// <returns>Whether the two channels are equal.</returns>
 		public static bool operator ==(DiscordChannel e1, DiscordChannel e2)
 		{
 			var o1 = e1 as object;
 			var o2 = e2 as object;
 
 			return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 		}
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordChannel"/> objects are not equal.
 		/// </summary>
 		/// <param name="e1">First channel to compare.</param>
 		/// <param name="e2">Second channel to compare.</param>
 		/// <returns>Whether the two channels are not equal.</returns>
 		public static bool operator !=(DiscordChannel e1, DiscordChannel e2)
 			=> !(e1 == e2);
 	}
 }
diff --git a/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs b/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs
index 606062e3e..8e6409278 100644
--- a/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs
+++ b/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs
@@ -1,124 +1,118 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a permission overwrite for a channel.
 	/// </summary>
 	public class DiscordOverwrite : SnowflakeObject
 	{
 		/// <summary>
 		/// Gets the type of the overwrite. Either "role" or "member".
 		/// </summary>
 		[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 		public OverwriteType Type { get; internal set; }
 
 		/// <summary>
 		/// Gets the allowed permission set.
 		/// </summary>
 		[JsonProperty("allow", NullValueHandling = NullValueHandling.Ignore)]
 		public Permissions Allowed { get; internal set; }
 
 		/// <summary>
 		/// Gets the denied permission set.
 		/// </summary>
 		[JsonProperty("deny", NullValueHandling = NullValueHandling.Ignore)]
 		public Permissions Denied { get; internal set; }
 
 		[JsonIgnore]
 		internal ulong ChannelId;
 
 		#region Methods
 		/// <summary>
 		/// Deletes this channel overwrite.
 		/// </summary>
 		/// <param name="reason">Reason as to why this overwrite gets deleted.</param>
 		/// <returns></returns>
 		public Task DeleteAsync(string reason = null) => this.Discord.ApiClient.DeleteChannelPermissionAsync(this.ChannelId, this.Id, reason);
 
 		/// <summary>
 		/// Updates this channel overwrite.
 		/// </summary>
 		/// <param name="allow">Permissions that are allowed.</param>
 		/// <param name="deny">Permissions that are denied.</param>
 		/// <param name="reason">Reason as to why you made this change.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the overwrite does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task UpdateAsync(Permissions? allow = null, Permissions? deny = null, string reason = null)
 			=> this.Discord.ApiClient.EditChannelPermissionsAsync(this.ChannelId, this.Id, allow ?? this.Allowed, deny ?? this.Denied, this.Type.ToString().ToLowerInvariant(), reason);
 		#endregion
 
 		/// <summary>
 		/// Gets the DiscordMember that is affected by this overwrite.
 		/// </summary>
 		/// <returns>The DiscordMember that is affected by this overwrite</returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the overwrite does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public async Task<DiscordMember> GetMemberAsync()
-		{
-			return this.Type != OverwriteType.Member
+		public async Task<DiscordMember> GetMemberAsync() =>
+			this.Type != OverwriteType.Member
 				? throw new ArgumentException(nameof(this.Type), "This overwrite is for a role, not a member.")
 				: await (await this.Discord.ApiClient.GetChannelAsync(this.ChannelId).ConfigureAwait(false)).Guild.GetMemberAsync(this.Id).ConfigureAwait(false);
-		}
 
 		/// <summary>
 		/// Gets the DiscordRole that is affected by this overwrite.
 		/// </summary>
 		/// <returns>The DiscordRole that is affected by this overwrite</returns>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public async Task<DiscordRole> GetRoleAsync()
-		{
-			return this.Type != OverwriteType.Role
+		public async Task<DiscordRole> GetRoleAsync() =>
+			this.Type != OverwriteType.Role
 				? throw new ArgumentException(nameof(this.Type), "This overwrite is for a member, not a role.")
 				: (await this.Discord.ApiClient.GetChannelAsync(this.ChannelId).ConfigureAwait(false)).Guild.GetRole(this.Id);
-		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordOverwrite"/> class.
 		/// </summary>
 		internal DiscordOverwrite() { }
 
 		/// <summary>
 		/// Checks whether given permissions are allowed, denied, or not set.
 		/// </summary>
 		/// <param name="permission">Permissions to check.</param>
 		/// <returns>Whether given permissions are allowed, denied, or not set.</returns>
-		public PermissionLevel CheckPermission(Permissions permission)
-		{
-			return (this.Allowed & permission) != 0
+		public PermissionLevel CheckPermission(Permissions permission) =>
+			(this.Allowed & permission) != 0
 				? PermissionLevel.Allowed
 				: (this.Denied & permission) != 0 ? PermissionLevel.Denied : PermissionLevel.Unset;
-		}
 	}
 }
diff --git a/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwriteBuilder.cs b/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwriteBuilder.cs
index 1dd118a0f..37b4e50c1 100644
--- a/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwriteBuilder.cs
+++ b/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwriteBuilder.cs
@@ -1,183 +1,181 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a Discord permission overwrite builder.
 	/// </summary>
 	public sealed class DiscordOverwriteBuilder
 	{
 		/// <summary>
 		/// Gets or sets the allowed permissions for this overwrite.
 		/// </summary>
 		public Permissions Allowed { get; set; }
 
 		/// <summary>
 		/// Gets or sets the denied permissions for this overwrite.
 		/// </summary>
 		public Permissions Denied { get; set; }
 
 		/// <summary>
 		/// Gets the type of this overwrite's target.
 		/// </summary>
 		public OverwriteType Type { get; private set; }
 
 		/// <summary>
 		/// Gets the target for this overwrite.
 		/// </summary>
 		public SnowflakeObject Target { get; private set; }
 
 		/// <summary>
 		/// Creates a new Discord permission overwrite builder for a member. This class can be used to construct permission overwrites for guild channels, used when creating channels.
 		/// </summary>
 		public DiscordOverwriteBuilder(DiscordMember member)
 		{
 			this.Target = member;
 			this.Type = OverwriteType.Member;
 		}
 		/// <summary>
 		/// Creates a new Discord permission overwrite builder for a role. This class can be used to construct permission overwrites for guild channels, used when creating channels.
 		/// </summary>
 		public DiscordOverwriteBuilder(DiscordRole role)
 		{
 			this.Target = role;
 			this.Type = OverwriteType.Role;
 		}
 
 		/// <summary>
 		/// Creates a new Discord permission overwrite builder. This class can be used to construct permission overwrites for guild channels, used when creating channels.
 		/// </summary>
 		[Obsolete("Will be removed in 10.0. Use specialized constructors instead", false)]
 		public DiscordOverwriteBuilder()
 		{
 
 		}
 
 		/// <summary>
 		/// Allows a permission for this overwrite.
 		/// </summary>
 		/// <param name="permission">Permission or permission set to allow for this overwrite.</param>
 		/// <returns>This builder.</returns>
 		public DiscordOverwriteBuilder Allow(Permissions permission)
 		{
 			this.Allowed |= permission;
 			return this;
 		}
 
 		/// <summary>
 		/// Denies a permission for this overwrite.
 		/// </summary>
 		/// <param name="permission">Permission or permission set to deny for this overwrite.</param>
 		/// <returns>This builder.</returns>
 		public DiscordOverwriteBuilder Deny(Permissions permission)
 		{
 			this.Denied |= permission;
 			return this;
 		}
 
 		/// <summary>
 		/// Sets the member to which this overwrite applies.
 		/// </summary>
 		/// <param name="member">Member to which apply this overwrite's permissions.</param>
 		/// <returns>This builder.</returns>
 		public DiscordOverwriteBuilder For(DiscordMember member)
 		{
 			this.Target = member;
 			this.Type = OverwriteType.Member;
 			return this;
 		}
 
 		/// <summary>
 		/// Sets the role to which this overwrite applies.
 		/// </summary>
 		/// <param name="role">Role to which apply this overwrite's permissions.</param>
 		/// <returns>This builder.</returns>
 		public DiscordOverwriteBuilder For(DiscordRole role)
 		{
 			this.Target = role;
 			this.Type = OverwriteType.Role;
 			return this;
 		}
 
 		/// <summary>
 		/// Populates this builder with data from another overwrite object.
 		/// </summary>
 		/// <param name="other">Overwrite from which data will be used.</param>
 		/// <returns>This builder.</returns>
 		public async Task<DiscordOverwriteBuilder> FromAsync(DiscordOverwrite other)
 		{
 			this.Allowed = other.Allowed;
 			this.Denied = other.Denied;
 			this.Type = other.Type;
 			this.Target = this.Type == OverwriteType.Member ? await other.GetMemberAsync().ConfigureAwait(false) as SnowflakeObject : await other.GetRoleAsync().ConfigureAwait(false) as SnowflakeObject;
 
 			return this;
 		}
 
 		/// <summary>
 		/// Builds this DiscordOverwrite.
 		/// </summary>
 		/// <returns>Use this object for creation of new overwrites.</returns>
-		internal DiscordRestOverwrite Build()
-		{
-			return new DiscordRestOverwrite()
+		internal DiscordRestOverwrite Build() =>
+			new DiscordRestOverwrite()
 			{
 				Allow = this.Allowed,
 				Deny = this.Denied,
 				Id = this.Target.Id,
 				Type = this.Type,
 			};
-		}
 	}
 
 	internal struct DiscordRestOverwrite
 	{
 		/// <summary>
 		/// Determines what is allowed.
 		/// </summary>
 		[JsonProperty("allow", NullValueHandling = NullValueHandling.Ignore)]
 		internal Permissions Allow { get; set; }
 
 		/// <summary>
 		/// Determines what is denied.
 		/// </summary>
 		[JsonProperty("deny", NullValueHandling = NullValueHandling.Ignore)]
 		internal Permissions Deny { get; set; }
 
 		/// <summary>
 		/// Gets or sets the id.
 		/// </summary>
 		[JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
 		internal ulong Id { get; set; }
 
 		/// <summary>
 		/// Gets or sets the overwrite type.
 		/// </summary>
 		[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 		internal OverwriteType Type { get; set; }
 	}
 }
diff --git a/DisCatSharp/Entities/Color/DiscordColor.Colors.cs b/DisCatSharp/Entities/Color/DiscordColor.Colors.cs
index f2c735785..375c3124d 100644
--- a/DisCatSharp/Entities/Color/DiscordColor.Colors.cs
+++ b/DisCatSharp/Entities/Color/DiscordColor.Colors.cs
@@ -1,264 +1,264 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 namespace DisCatSharp.Entities
 {
 	public partial struct DiscordColor
 	{
 		#region Black and White
 		/// <summary>
 		/// Represents no color, or integer 0;
 		/// </summary>
-		public static DiscordColor None { get; } = new DiscordColor(0);
+		public static DiscordColor None { get; } = new(0);
 
 		/// <summary>
 		/// A near-black color. Due to API limitations, the color is #010101, rather than #000000, as the latter is treated as no color.
 		/// </summary>
-		public static DiscordColor Black { get; } = new DiscordColor(0x010101);
+		public static DiscordColor Black { get; } = new(0x010101);
 
 		/// <summary>
 		/// White, or #FFFFFF.
 		/// </summary>
-		public static DiscordColor White { get; } = new DiscordColor(0xFFFFFF);
+		public static DiscordColor White { get; } = new(0xFFFFFF);
 
 		/// <summary>
 		/// Gray, or #808080.
 		/// </summary>
-		public static DiscordColor Gray { get; } = new DiscordColor(0x808080);
+		public static DiscordColor Gray { get; } = new(0x808080);
 
 		/// <summary>
 		/// Dark gray, or #A9A9A9.
 		/// </summary>
-		public static DiscordColor DarkGray { get; } = new DiscordColor(0xA9A9A9);
+		public static DiscordColor DarkGray { get; } = new(0xA9A9A9);
 
 		/// <summary>
 		/// Light gray, or #808080.
 		/// </summary>
-		public static DiscordColor LightGray { get; } = new DiscordColor(0xD3D3D3);
+		public static DiscordColor LightGray { get; } = new(0xD3D3D3);
 
 		// dev-approved
 		/// <summary>
 		/// Very dark gray, or #666666.
 		/// </summary>
-		public static DiscordColor VeryDarkGray { get; } = new DiscordColor(0x666666);
+		public static DiscordColor VeryDarkGray { get; } = new(0x666666);
 		#endregion
 
 		#region Discord branding colors
 		// https://discord.com/branding
 
 		/// <summary>
 		/// Discord Blurple, or #5865F2.
 		/// </summary>
-		public static DiscordColor Blurple { get; } = new DiscordColor(0x5865F2);
+		public static DiscordColor Blurple { get; } = new(0x5865F2);
 
 		/// <summary>
 		/// Discord Fuchsia, or #EB459E.
 		/// </summary>
-		public static DiscordColor Fuchsia { get; } = new DiscordColor(0xEB459E);
+		public static DiscordColor Fuchsia { get; } = new(0xEB459E);
 
 		/// <summary>
 		/// Discord Green, or #57F287.
 		/// </summary>
-		public static DiscordColor Green { get; } = new DiscordColor(0x57F287);
+		public static DiscordColor Green { get; } = new(0x57F287);
 
 		/// <summary>
 		/// Discord Yellow, or #FEE75C.
 		/// </summary>
-		public static DiscordColor Yellow { get; } = new DiscordColor(0xFEE75C);
+		public static DiscordColor Yellow { get; } = new(0xFEE75C);
 
 		/// <summary>
 		/// Discord Red, or #ED4245.
 		/// </summary>
-		public static DiscordColor Red { get; } = new DiscordColor(0xED4245);
+		public static DiscordColor Red { get; } = new(0xED4245);
 		#endregion
 
 		#region Other colors
 		/// <summary>
 		/// Dark red, or #7F0000.
 		/// </summary>
-		public static DiscordColor DarkRed { get; } = new DiscordColor(0x7F0000);
+		public static DiscordColor DarkRed { get; } = new(0x7F0000);
 
 		/// <summary>
 		/// Dark green, or #007F00.
 		/// </summary>
-		public static DiscordColor DarkGreen { get; } = new DiscordColor(0x007F00);
+		public static DiscordColor DarkGreen { get; } = new(0x007F00);
 
 		/// <summary>
 		/// Blue, or #0000FF.
 		/// </summary>
-		public static DiscordColor Blue { get; } = new DiscordColor(0x0000FF);
+		public static DiscordColor Blue { get; } = new(0x0000FF);
 
 		/// <summary>
 		/// Dark blue, or #00007F.
 		/// </summary>
-		public static DiscordColor DarkBlue { get; } = new DiscordColor(0x00007F);
+		public static DiscordColor DarkBlue { get; } = new(0x00007F);
 
 		/// <summary>
 		/// Cyan, or #00FFFF.
 		/// </summary>
-		public static DiscordColor Cyan { get; } = new DiscordColor(0x00FFFF);
+		public static DiscordColor Cyan { get; } = new(0x00FFFF);
 
 		/// <summary>
 		/// Magenta, or #FF00FF.
 		/// </summary>
-		public static DiscordColor Magenta { get; } = new DiscordColor(0xFF00FF);
+		public static DiscordColor Magenta { get; } = new(0xFF00FF);
 
 		/// <summary>
 		/// Teal, or #008080.
 		/// </summary>
-		public static DiscordColor Teal { get; } = new DiscordColor(0x008080);
+		public static DiscordColor Teal { get; } = new(0x008080);
 
 		// meme
 		/// <summary>
 		/// Aquamarine, or #00FFBF.
 		/// </summary>
-		public static DiscordColor Aquamarine { get; } = new DiscordColor(0x00FFBF);
+		public static DiscordColor Aquamarine { get; } = new(0x00FFBF);
 
 		/// <summary>
 		/// Gold, or #FFD700.
 		/// </summary>
-		public static DiscordColor Gold { get; } = new DiscordColor(0xFFD700);
+		public static DiscordColor Gold { get; } = new(0xFFD700);
 
 		// To be fair, you have to have a very high IQ to understand Goldenrod .
 		// The tones are extremely subtle, and without a solid grasp of artistic
 		// theory most of the beauty will go over a typical painter's head.
 		// There's also the flower's nihilistic style, which is deftly woven
 		// into its characterization - it's pollinated by the Bombus cryptarum
 		// bumblebee, for instance. The fans understand this stuff; they have
 		// the intellectual capacity to truly appreciate the depth of this
 		// flower, to realize that it's not just a color - it says something
 		// deep about LIFE. As a consequence people who dislike Goldenrod truly
 		// ARE idiots - of course they wouldn't appreciate, for instance, the
 		// beauty in the bumblebee species' complex presence in the British Isles,
 		// which is cryptically explained by Turgenev's Russian epic Fathers and
 		// Sons I'm blushing right now just imagining one of those addlepated
 		// simpletons scratching their heads in confusion as nature's genius
 		// unfolds itself on their computer screens. What fools... how I pity them.
 		// 😂 And yes by the way, I DO have a goldenrod tattoo. And no, you cannot
 		// see it. It's for the ladies' eyes only- And even they have to
 		// demonstrate that they're within 5 IQ points of my own (preferably lower) beforehand.
 		/// <summary>
 		/// Goldenrod, or #DAA520.
 		/// </summary>
-		public static DiscordColor Goldenrod { get; } = new DiscordColor(0xDAA520);
+		public static DiscordColor Goldenrod { get; } = new(0xDAA520);
 
 		// emzi's favourite
 		/// <summary>
 		/// Azure, or #007FFF.
 		/// </summary>
-		public static DiscordColor Azure { get; } = new DiscordColor(0x007FFF);
+		public static DiscordColor Azure { get; } = new(0x007FFF);
 
 		/// <summary>
 		/// Rose, or #FF007F.
 		/// </summary>
-		public static DiscordColor Rose { get; } = new DiscordColor(0xFF007F);
+		public static DiscordColor Rose { get; } = new(0xFF007F);
 
 		/// <summary>
 		/// Spring green, or #00FF7F.
 		/// </summary>
-		public static DiscordColor SpringGreen { get; } = new DiscordColor(0x00FF7F);
+		public static DiscordColor SpringGreen { get; } = new(0x00FF7F);
 
 		/// <summary>
 		/// Chartreuse, or #7FFF00.
 		/// </summary>
-		public static DiscordColor Chartreuse { get; } = new DiscordColor(0x7FFF00);
+		public static DiscordColor Chartreuse { get; } = new(0x7FFF00);
 
 		/// <summary>
 		/// Orange, or #FFA500.
 		/// </summary>
-		public static DiscordColor Orange { get; } = new DiscordColor(0xFFA500);
+		public static DiscordColor Orange { get; } = new(0xFFA500);
 
 		/// <summary>
 		/// Purple, or #800080.
 		/// </summary>
-		public static DiscordColor Purple { get; } = new DiscordColor(0x800080);
+		public static DiscordColor Purple { get; } = new(0x800080);
 
 		/// <summary>
 		/// Violet, or #EE82EE.
 		/// </summary>
-		public static DiscordColor Violet { get; } = new DiscordColor(0xEE82EE);
+		public static DiscordColor Violet { get; } = new(0xEE82EE);
 
 		/// <summary>
 		/// Brown, or #A52A2A.
 		/// </summary>
-		public static DiscordColor Brown { get; } = new DiscordColor(0xA52A2A);
+		public static DiscordColor Brown { get; } = new(0xA52A2A);
 
 		// meme
 		/// <summary>
 		/// Hot pink, or #FF69B4
 		/// </summary>
-		public static DiscordColor HotPink { get; } = new DiscordColor(0xFF69B4);
+		public static DiscordColor HotPink { get; } = new(0xFF69B4);
 
 		/// <summary>
 		/// Lilac, or #C8A2C8.
 		/// </summary>
-		public static DiscordColor Lilac { get; } = new DiscordColor(0xC8A2C8);
+		public static DiscordColor Lilac { get; } = new(0xC8A2C8);
 
 		/// <summary>
 		/// Cornflower blue, or #6495ED.
 		/// </summary>
-		public static DiscordColor CornflowerBlue { get; } = new DiscordColor(0x6495ED);
+		public static DiscordColor CornflowerBlue { get; } = new(0x6495ED);
 
 		/// <summary>
 		/// Midnight blue, or #191970.
 		/// </summary>
-		public static DiscordColor MidnightBlue { get; } = new DiscordColor(0x191970);
+		public static DiscordColor MidnightBlue { get; } = new(0x191970);
 
 		/// <summary>
 		/// Wheat, or #F5DEB3.
 		/// </summary>
-		public static DiscordColor Wheat { get; } = new DiscordColor(0xF5DEB3);
+		public static DiscordColor Wheat { get; } = new(0xF5DEB3);
 
 		/// <summary>
 		/// Indian red, or #CD5C5C.
 		/// </summary>
-		public static DiscordColor IndianRed { get; } = new DiscordColor(0xCD5C5C);
+		public static DiscordColor IndianRed { get; } = new(0xCD5C5C);
 
 		/// <summary>
 		/// Turquoise, or #30D5C8.
 		/// </summary>
-		public static DiscordColor Turquoise { get; } = new DiscordColor(0x30D5C8);
+		public static DiscordColor Turquoise { get; } = new(0x30D5C8);
 
 		/// <summary>
 		/// Sap green, or #507D2A.
 		/// </summary>
-		public static DiscordColor SapGreen { get; } = new DiscordColor(0x507D2A);
+		public static DiscordColor SapGreen { get; } = new(0x507D2A);
 
 		// meme, specifically bob ross
 		/// <summary>
 		/// Phthalo blue, or #000F89.
 		/// </summary>
-		public static DiscordColor PhthaloBlue { get; } = new DiscordColor(0x000F89);
+		public static DiscordColor PhthaloBlue { get; } = new(0x000F89);
 
 		// meme, specifically bob ross
 		/// <summary>
 		/// Phthalo green, or #123524.
 		/// </summary>
-		public static DiscordColor PhthaloGreen { get; } = new DiscordColor(0x123524);
+		public static DiscordColor PhthaloGreen { get; } = new(0x123524);
 
 		/// <summary>
 		/// Sienna, or #882D17.
 		/// </summary>
-		public static DiscordColor Sienna { get; } = new DiscordColor(0x882D17);
+		public static DiscordColor Sienna { get; } = new(0x882D17);
 		#endregion
 	}
 }
diff --git a/DisCatSharp/Entities/Emoji/DiscordEmoji.cs b/DisCatSharp/Entities/Emoji/DiscordEmoji.cs
index 23076792d..325e3bb76 100644
--- a/DisCatSharp/Entities/Emoji/DiscordEmoji.cs
+++ b/DisCatSharp/Entities/Emoji/DiscordEmoji.cs
@@ -1,380 +1,371 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a Discord emoji.
 	/// </summary>
 	public partial class DiscordEmoji : SnowflakeObject, IEquatable<DiscordEmoji>
 	{
 		/// <summary>
 		/// Gets the name of this emoji.
 		/// </summary>
 		[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 		public string Name { get; internal set; }
 
 		/// <summary>
 		/// Gets IDs the roles this emoji is enabled for.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyList<ulong> Roles => this._rolesLazy.Value;
 
 		[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 		public List<ulong> RolesInternal;
 		private readonly Lazy<IReadOnlyList<ulong>> _rolesLazy;
 
 		/// <summary>
 		/// Gets whether this emoji requires colons to use.
 		/// </summary>
 		[JsonProperty("require_colons")]
 		public bool RequiresColons { get; internal set; }
 
 		/// <summary>
 		/// Gets whether this emoji is managed by an integration.
 		/// </summary>
 		[JsonProperty("managed")]
 		public bool IsManaged { get; internal set; }
 
 		/// <summary>
 		/// Gets whether this emoji is animated.
 		/// </summary>
 		[JsonProperty("animated")]
 		public bool IsAnimated { get; internal set; }
 
 		/// <summary>
 		/// Gets whether the emoji is available for use.
 		/// An emoji may not be available due to loss of server boost.
 		/// </summary>
 		[JsonProperty("available", NullValueHandling = NullValueHandling.Ignore)]
 		public bool IsAvailable { get; internal set; }
 
 		/// <summary>
 		/// Gets the image URL of this emoji.
 		/// </summary>
 		[JsonIgnore]
-		public string Url
-		{
-			get
-			{
-				return this.Id == 0
-					? throw new InvalidOperationException("Cannot get URL of unicode emojis.")
-					: this.IsAnimated
+		public string Url =>
+			this.Id == 0
+				? throw new InvalidOperationException("Cannot get URL of unicode emojis.")
+				: this.IsAnimated
 					? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.EMOJIS}/{this.Id.ToString(CultureInfo.InvariantCulture)}.gif"
 					: $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.EMOJIS}/{this.Id.ToString(CultureInfo.InvariantCulture)}.png";
-			}
-		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordEmoji"/> class.
 		/// </summary>
 		internal DiscordEmoji()
 		{
 			this._rolesLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.RolesInternal));
 		}
 
 		/// <summary>
 		/// Gets emoji's name in non-Unicode format (eg. :thinking: instead of the Unicode representation of the emoji).
 		/// </summary>
 		public string GetDiscordName()
 		{
 			s_discordNameLookup.TryGetValue(this.Name, out var name);
 
 			return name ?? $":{ this.Name }:";
 		}
 
 		/// <summary>
 		/// Returns a string representation of this emoji.
 		/// </summary>
 		/// <returns>String representation of this emoji.</returns>
-		public override string ToString()
-		{
-			return this.Id != 0
+		public override string ToString() =>
+			this.Id != 0
 				? this.IsAnimated
 					? $"<a:{this.Name}:{this.Id.ToString(CultureInfo.InvariantCulture)}>"
 					: $"<:{this.Name}:{this.Id.ToString(CultureInfo.InvariantCulture)}>"
 				: this.Name;
-		}
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordEmoji"/> is equal to another object.
 		/// </summary>
 		/// <param name="obj">Object to compare to.</param>
 		/// <returns>Whether the object is equal to this <see cref="DiscordEmoji"/>.</returns>
 		public override bool Equals(object obj) => this.Equals(obj as DiscordEmoji);
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordEmoji"/> is equal to another <see cref="DiscordEmoji"/>.
 		/// </summary>
 		/// <param name="e"><see cref="DiscordEmoji"/> to compare to.</param>
 		/// <returns>Whether the <see cref="DiscordEmoji"/> is equal to this <see cref="DiscordEmoji"/>.</returns>
 		public bool Equals(DiscordEmoji e) => e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.Name == e.Name));
 
 		/// <summary>
 		/// Gets the hash code for this <see cref="DiscordEmoji"/>.
 		/// </summary>
 		/// <returns>The hash code for this <see cref="DiscordEmoji"/>.</returns>
 		public override int GetHashCode()
 		{
 			var hash = 13;
 			hash = (hash * 7) + this.Id.GetHashCode();
 			hash = (hash * 7) + this.Name.GetHashCode();
 
 			return hash;
 		}
 
 		/// <summary>
 		/// Gets the reactions string.
 		/// </summary>
 		internal string ToReactionString() => this.Id != 0 ? $"{this.Name}:{this.Id.ToString(CultureInfo.InvariantCulture)}" : this.Name;
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordEmoji"/> objects are equal.
 		/// </summary>
 		/// <param name="e1">First emoji to compare.</param>
 		/// <param name="e2">Second emoji to compare.</param>
 		/// <returns>Whether the two emoji are equal.</returns>
 		public static bool operator ==(DiscordEmoji e1, DiscordEmoji e2)
 		{
 			var o1 = e1 as object;
 			var o2 = e2 as object;
 
 			return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 		}
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordEmoji"/> objects are not equal.
 		/// </summary>
 		/// <param name="e1">First emoji to compare.</param>
 		/// <param name="e2">Second emoji to compare.</param>
 		/// <returns>Whether the two emoji are not equal.</returns>
 		public static bool operator !=(DiscordEmoji e1, DiscordEmoji e2)
 			=> !(e1 == e2);
 
 		/// <summary>
 		/// Implicitly converts this emoji to its string representation.
 		/// </summary>
 		/// <param name="e1">Emoji to convert.</param>
 		public static implicit operator string(DiscordEmoji e1)
 			=> e1.ToString();
 
 		/// <summary>
 		/// Checks whether specified unicode entity is a valid unicode emoji.
 		/// </summary>
 		/// <param name="unicodeEntity">Entity to check.</param>
 		/// <returns>Whether it's a valid emoji.</returns>
 		public static bool IsValidUnicode(string unicodeEntity)
 			=> s_discordNameLookup.ContainsKey(unicodeEntity);
 
 		/// <summary>
 		/// Creates an emoji object from a unicode entity.
 		/// </summary>
 		/// <param name="client"><see cref="BaseDiscordClient"/> to attach to the object.</param>
 		/// <param name="unicodeEntity">Unicode entity to create the object from.</param>
 		/// <returns>Create <see cref="DiscordEmoji"/> object.</returns>
-		public static DiscordEmoji FromUnicode(BaseDiscordClient client, string unicodeEntity)
-		{
-			return !IsValidUnicode(unicodeEntity)
+		public static DiscordEmoji FromUnicode(BaseDiscordClient client, string unicodeEntity) =>
+			!IsValidUnicode(unicodeEntity)
 				? throw new ArgumentException("Specified unicode entity is not a valid unicode emoji.", nameof(unicodeEntity))
 				: new DiscordEmoji { Name = unicodeEntity, Discord = client };
-		}
 
 		/// <summary>
 		/// Creates an emoji object from a unicode entity.
 		/// </summary>
 		/// <param name="unicodeEntity">Unicode entity to create the object from.</param>
 		/// <returns>Create <see cref="DiscordEmoji"/> object.</returns>
 		public static DiscordEmoji FromUnicode(string unicodeEntity)
 			=> FromUnicode(null, unicodeEntity);
 
 		/// <summary>
 		/// Attempts to create an emoji object from a unicode entity.
 		/// </summary>
 		/// <param name="client"><see cref="BaseDiscordClient"/> to attach to the object.</param>
 		/// <param name="unicodeEntity">Unicode entity to create the object from.</param>
 		/// <param name="emoji">Resulting <see cref="DiscordEmoji"/> object.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public static bool TryFromUnicode(BaseDiscordClient client, string unicodeEntity, out DiscordEmoji emoji)
 		{
 			// this is a round-trip operation because of FE0F inconsistencies.
 			// through this, the inconsistency is normalized.
 
 			emoji = null;
 			if (!s_discordNameLookup.TryGetValue(unicodeEntity, out var discordName))
 				return false;
 
 			if (!s_unicodeEmojis.TryGetValue(discordName, out unicodeEntity))
 				return false;
 
 			emoji = new DiscordEmoji { Name = unicodeEntity, Discord = client };
 			return true;
 		}
 
 		/// <summary>
 		/// Attempts to create an emoji object from a unicode entity.
 		/// </summary>
 		/// <param name="unicodeEntity">Unicode entity to create the object from.</param>
 		/// <param name="emoji">Resulting <see cref="DiscordEmoji"/> object.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public static bool TryFromUnicode(string unicodeEntity, out DiscordEmoji emoji)
 			=> TryFromUnicode(null, unicodeEntity, out emoji);
 
 		/// <summary>
 		/// Creates an emoji object from a guild emote.
 		/// </summary>
 		/// <param name="client"><see cref="BaseDiscordClient"/> to attach to the object.</param>
 		/// <param name="id">Id of the emote.</param>
 		/// <returns>Create <see cref="DiscordEmoji"/> object.</returns>
 		public static DiscordEmoji FromGuildEmote(BaseDiscordClient client, ulong id)
 		{
 			if (client == null)
 				throw new ArgumentNullException(nameof(client), "Client cannot be null.");
 
 			foreach (var guild in client.Guilds.Values)
 			{
 				if (guild.Emojis.TryGetValue(id, out var found))
 					return found;
 			}
 
 			throw new KeyNotFoundException("Given emote was not found.");
 		}
 
 		/// <summary>
 		/// Attempts to create an emoji object from a guild emote.
 		/// </summary>
 		/// <param name="client"><see cref="BaseDiscordClient"/> to attach to the object.</param>
 		/// <param name="id">Id of the emote.</param>
 		/// <param name="emoji">Resulting <see cref="DiscordEmoji"/> object.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public static bool TryFromGuildEmote(BaseDiscordClient client, ulong id, out DiscordEmoji emoji)
 		{
 			if (client == null)
 				throw new ArgumentNullException(nameof(client), "Client cannot be null.");
 
 			foreach (var guild in client.Guilds.Values)
 			{
 				if (guild.Emojis.TryGetValue(id, out emoji))
 					return true;
 			}
 
 			emoji = null;
 			return false;
 		}
 
 		/// <summary>
 		/// Creates an emoji obejct from emote name that includes colons (eg. :thinking:). This method also supports
 		/// skin tone variations (eg. :ok_hand::skin-tone-2:), standard emoticons (eg. :D), as well as guild emoji
 		/// (still specified by :name:).
 		/// </summary>
 		/// <param name="client"><see cref="BaseDiscordClient"/> to attach to the object.</param>
 		/// <param name="name">Name of the emote to find, including colons (eg. :thinking:).</param>
 		/// <param name="includeGuilds">Should guild emojis be included in the search.</param>
 		/// <returns>Create <see cref="DiscordEmoji"/> object.</returns>
 		public static DiscordEmoji FromName(BaseDiscordClient client, string name, bool includeGuilds = true)
 		{
 			if (client == null)
 				throw new ArgumentNullException(nameof(client), "Client cannot be null.");
 
 			if (string.IsNullOrWhiteSpace(name))
 				throw new ArgumentNullException(nameof(name), "Name cannot be empty or null.");
 
 			if (s_unicodeEmojis.TryGetValue(name, out var unicodeEntity))
 				return new DiscordEmoji { Discord = client, Name = unicodeEntity };
 
 			if (includeGuilds)
 			{
 				var allEmojis = client.Guilds.Values
 					.SelectMany(xg => xg.Emojis.Values); // save cycles - don't order
 
 				var ek = name.AsSpan().Slice(1, name.Length - 2);
 				foreach (var emoji in allEmojis)
 					if (emoji.Name.AsSpan().SequenceEqual(ek))
 						return emoji;
 			}
 
 			throw new ArgumentException("Invalid emoji name specified.", nameof(name));
 		}
 
 		/// <summary>
 		/// Attempts to create an emoji object from emote name that includes colons (eg. :thinking:). This method also
 		/// supports skin tone variations (eg. :ok_hand::skin-tone-2:), standard emoticons (eg. :D), as well as guild
 		/// emoji (still specified by :name:).
 		/// </summary>
 		/// <param name="client"><see cref="BaseDiscordClient"/> to attach to the object.</param>
 		/// <param name="name">Name of the emote to find, including colons (eg. :thinking:).</param>
 		/// <param name="emoji">Resulting <see cref="DiscordEmoji"/> object.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public static bool TryFromName(BaseDiscordClient client, string name, out DiscordEmoji emoji)
 			=> TryFromName(client, name, true, out emoji);
 
 		/// <summary>
 		/// Attempts to create an emoji object from emote name that includes colons (eg. :thinking:). This method also
 		/// supports skin tone variations (eg. :ok_hand::skin-tone-2:), standard emoticons (eg. :D), as well as guild
 		/// emoji (still specified by :name:).
 		/// </summary>
 		/// <param name="client"><see cref="BaseDiscordClient"/> to attach to the object.</param>
 		/// <param name="name">Name of the emote to find, including colons (eg. :thinking:).</param>
 		/// <param name="includeGuilds">Should guild emojis be included in the search.</param>
 		/// <param name="emoji">Resulting <see cref="DiscordEmoji"/> object.</param>
 		/// <returns>Whether the operation was successful.</returns>
 		public static bool TryFromName(BaseDiscordClient client, string name, bool includeGuilds, out DiscordEmoji emoji)
 		{
 			if (client == null)
 				throw new ArgumentNullException(nameof(client), "Client cannot be null.");
 
 			if (string.IsNullOrWhiteSpace(name))
 				throw new ArgumentNullException(nameof(name), "Name cannot be empty or null.");
 
 			if (s_unicodeEmojis.TryGetValue(name, out var unicodeEntity))
 			{
 				emoji = new DiscordEmoji { Discord = client, Name = unicodeEntity };
 				return true;
 			}
 
 			if (includeGuilds)
 			{
 				var allEmojis = client.Guilds.Values
 					.SelectMany(xg => xg.Emojis.Values); // save cycles - don't order
 
 				var ek = name.AsSpan().Slice(1, name.Length - 2);
 				foreach (var xemoji in allEmojis)
 					if (xemoji.Name.AsSpan().SequenceEqual(ek))
 					{
 						emoji = xemoji;
 						return true;
 					}
 			}
 
 			emoji = null;
 			return false;
 		}
 	}
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.cs b/DisCatSharp/Entities/Guild/DiscordGuild.cs
index 2282d9cea..ff1ace8a4 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.cs
@@ -1,3574 +1,3566 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 #pragma warning disable CS0618
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a Discord guild.
 	/// </summary>
 	public class DiscordGuild : SnowflakeObject, IEquatable<DiscordGuild>
 	{
 		/// <summary>
 		/// Gets the guild's name.
 		/// </summary>
 		[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 		public string Name { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild icon's hash.
 		/// </summary>
 		[JsonProperty("icon", NullValueHandling = NullValueHandling.Ignore)]
 		public string IconHash { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild icon's url.
 		/// </summary>
 		[JsonIgnore]
 		public string IconUrl
 			=> !string.IsNullOrWhiteSpace(this.IconHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.IconHash}.{(this.IconHash.StartsWith("a_") ? "gif" : "png")}?size=1024" : null;
 
 		/// <summary>
 		/// Gets the guild splash's hash.
 		/// </summary>
 		[JsonProperty("splash", NullValueHandling = NullValueHandling.Ignore)]
 		public string SplashHash { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild splash's url.
 		/// </summary>
 		[JsonIgnore]
 		public string SplashUrl
 		 => !string.IsNullOrWhiteSpace(this.SplashHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.SplashHash}.png?size=1024" : null;
 
 		/// <summary>
 		/// Gets the guild discovery splash's hash.
 		/// </summary>
 		[JsonProperty("discovery_splash", NullValueHandling = NullValueHandling.Ignore)]
 		public string DiscoverySplashHash { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild discovery splash's url.
 		/// </summary>
 		[JsonIgnore]
 		public string DiscoverySplashUrl
 			=> !string.IsNullOrWhiteSpace(this.DiscoverySplashHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILD_DISCOVERY_SPLASHES}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.DiscoverySplashHash}.png?size=1024" : null;
 
 		/// <summary>
 		/// Gets the preferred locale of this guild.
 		/// <para>This is used for server discovery and notices from Discord. Defaults to en-US.</para>
 		/// </summary>
 		[JsonProperty("preferred_locale", NullValueHandling = NullValueHandling.Ignore)]
 		public string PreferredLocale { get; internal set; }
 
 		/// <summary>
 		/// Gets the ID of the guild's owner.
 		/// </summary>
 		[JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong OwnerId { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild's owner.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordMember Owner
 			=> this.Members.TryGetValue(this.OwnerId, out var owner)
 				? owner
 				: this.Discord.ApiClient.GetGuildMemberAsync(this.Id, this.OwnerId).ConfigureAwait(false).GetAwaiter().GetResult();
 
 		/// <summary>
 		/// Gets permissions for the user in the guild (does not include channel overrides)
 		/// </summary>
 		[JsonProperty("permissions", NullValueHandling = NullValueHandling.Ignore)]
 		public Permissions? Permissions { get; set; }
 
 		/// <summary>
 		/// Gets the guild's voice region ID.
 		/// </summary>
 		[JsonProperty("region", NullValueHandling = NullValueHandling.Ignore)]
 		internal string VoiceRegionId { get; set; }
 
 		/// <summary>
 		/// Gets the guild's voice region.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordVoiceRegion VoiceRegion
 			=> this.Discord.VoiceRegions[this.VoiceRegionId];
 
 		/// <summary>
 		/// Gets the guild's AFK voice channel ID.
 		/// </summary>
 		[JsonProperty("afk_channel_id", NullValueHandling = NullValueHandling.Ignore)]
-		internal ulong AfkChannelId { get; set; } = 0;
+		internal ulong AfkChannelId { get; set; }
 
 		/// <summary>
 		/// Gets the guild's AFK voice channel.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordChannel AfkChannel
 			=> this.GetChannel(this.AfkChannelId);
 
 		/// <summary>
 		/// List of <see cref="DisCatSharp.Entities.DiscordApplicationCommand"/>.
 		/// Null if DisCatSharp.ApplicationCommands is not used or no guild commands are registered.
 		/// </summary>
 		[JsonIgnore]
 		public ReadOnlyCollection<DiscordApplicationCommand> RegisteredApplicationCommands
 			=> new(this.InternalRegisteredApplicationCommands);
 		[JsonIgnore]
 		internal List<DiscordApplicationCommand> InternalRegisteredApplicationCommands { get; set; } = null;
 
 		/// <summary>
 		/// Gets the guild's AFK timeout.
 		/// </summary>
 		[JsonProperty("afk_timeout", NullValueHandling = NullValueHandling.Ignore)]
 		public int AfkTimeout { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild's verification level.
 		/// </summary>
 		[JsonProperty("verification_level", NullValueHandling = NullValueHandling.Ignore)]
 		public VerificationLevel VerificationLevel { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild's default notification settings.
 		/// </summary>
 		[JsonProperty("default_message_notifications", NullValueHandling = NullValueHandling.Ignore)]
 		public DefaultMessageNotifications DefaultMessageNotifications { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild's explicit content filter settings.
 		/// </summary>
 		[JsonProperty("explicit_content_filter")]
 		public ExplicitContentFilter ExplicitContentFilter { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild's nsfw level.
 		/// </summary>
 		[JsonProperty("nsfw_level")]
 		public NsfwLevel NsfwLevel { get; internal set; }
 
 		/// <summary>
 		/// Gets the system channel id.
 		/// </summary>
 		[JsonProperty("system_channel_id", NullValueHandling = NullValueHandling.Include)]
 		internal ulong? SystemChannelId { get; set; }
 
 		/// <summary>
 		/// Gets the channel where system messages (such as boost and welcome messages) are sent.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordChannel SystemChannel => this.SystemChannelId.HasValue
 			? this.GetChannel(this.SystemChannelId.Value)
 			: null;
 
 		/// <summary>
 		/// Gets the settings for this guild's system channel.
 		/// </summary>
 		[JsonProperty("system_channel_flags")]
 		public SystemChannelFlags SystemChannelFlags { get; internal set; }
 
 		/// <summary>
 		/// Gets whether this guild's widget is enabled.
 		/// </summary>
 		[JsonProperty("widget_enabled", NullValueHandling = NullValueHandling.Ignore)]
 		public bool? WidgetEnabled { get; internal set; }
 
 		/// <summary>
 		/// Gets the widget channel id.
 		/// </summary>
 		[JsonProperty("widget_channel_id", NullValueHandling = NullValueHandling.Ignore)]
 		internal ulong? WidgetChannelId { get; set; }
 
 		/// <summary>
 		/// Gets the widget channel for this guild.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordChannel WidgetChannel => this.WidgetChannelId.HasValue
 			? this.GetChannel(this.WidgetChannelId.Value)
 			: null;
 
 		/// <summary>
 		/// Gets the rules channel id.
 		/// </summary>
 		[JsonProperty("rules_channel_id")]
 		internal ulong? RulesChannelId { get; set; }
 
 		/// <summary>
 		/// Gets the rules channel for this guild.
 		/// <para>This is only available if the guild is considered "discoverable".</para>
 		/// </summary>
 		[JsonIgnore]
 		public DiscordChannel RulesChannel => this.RulesChannelId.HasValue
 			? this.GetChannel(this.RulesChannelId.Value)
 			: null;
 
 		/// <summary>
 		/// Gets the public updates channel id.
 		/// </summary>
 		[JsonProperty("public_updates_channel_id")]
 		internal ulong? PublicUpdatesChannelId { get; set; }
 
 		/// <summary>
 		/// Gets the public updates channel (where admins and moderators receive messages from Discord) for this guild.
 		/// <para>This is only available if the guild is considered "discoverable".</para>
 		/// </summary>
 		[JsonIgnore]
 		public DiscordChannel PublicUpdatesChannel => this.PublicUpdatesChannelId.HasValue
 			? this.GetChannel(this.PublicUpdatesChannelId.Value)
 			: null;
 
 		/// <summary>
 		/// Gets the application id of this guild if it is bot created.
 		/// </summary>
 		[JsonProperty("application_id")]
 		public ulong? ApplicationId { get; internal set; }
 
 		/// <summary>
 		/// Gets a collection of this guild's roles.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyDictionary<ulong, DiscordRole> Roles => new ReadOnlyConcurrentDictionary<ulong, DiscordRole>(this.RolesInternal);
 
 		[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 		[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 		internal ConcurrentDictionary<ulong, DiscordRole> RolesInternal;
 
 		/// <summary>
 		/// Gets a collection of this guild's stickers.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyDictionary<ulong, DiscordSticker> Stickers => new ReadOnlyConcurrentDictionary<ulong, DiscordSticker>(this.StickersInternal);
 
 		[JsonProperty("stickers", NullValueHandling = NullValueHandling.Ignore)]
 		[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 		internal ConcurrentDictionary<ulong, DiscordSticker> StickersInternal;
 
 		/// <summary>
 		/// Gets a collection of this guild's emojis.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyDictionary<ulong, DiscordEmoji> Emojis => new ReadOnlyConcurrentDictionary<ulong, DiscordEmoji>(this.EmojisInternal);
 
 		[JsonProperty("emojis", NullValueHandling = NullValueHandling.Ignore)]
 		[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 		internal ConcurrentDictionary<ulong, DiscordEmoji> EmojisInternal;
 
 		/// <summary>
 		/// Gets a collection of this guild's features.
 		/// </summary>
 		[JsonProperty("features", NullValueHandling = NullValueHandling.Ignore)]
 		public IReadOnlyList<string> RawFeatures { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild's features.
 		/// </summary>
 		[JsonIgnore]
 		public GuildFeatures Features => new(this);
 
 		/// <summary>
 		/// Gets the required multi-factor authentication level for this guild.
 		/// </summary>
 		[JsonProperty("mfa_level", NullValueHandling = NullValueHandling.Ignore)]
 		public MfaLevel MfaLevel { get; internal set; }
 
 		/// <summary>
 		/// Gets this guild's join date.
 		/// </summary>
 		[JsonProperty("joined_at", NullValueHandling = NullValueHandling.Ignore)]
 		public DateTimeOffset JoinedAt { get; internal set; }
 
 		/// <summary>
 		/// Gets whether this guild is considered to be a large guild.
 		/// </summary>
 		[JsonProperty("large", NullValueHandling = NullValueHandling.Ignore)]
 		public bool IsLarge { get; internal set; }
 
 		/// <summary>
 		/// Gets whether this guild is unavailable.
 		/// </summary>
 		[JsonProperty("unavailable", NullValueHandling = NullValueHandling.Ignore)]
 		public bool IsUnavailable { get; internal set; }
 
 		/// <summary>
 		/// Gets the total number of members in this guild.
 		/// </summary>
 		[JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
 		public int MemberCount { get; internal set; }
 
 		/// <summary>
 		/// Gets the maximum amount of members allowed for this guild.
 		/// </summary>
 		[JsonProperty("max_members")]
 		public int? MaxMembers { get; internal set; }
 
 		/// <summary>
 		/// Gets the maximum amount of presences allowed for this guild.
 		/// </summary>
 		[JsonProperty("max_presences")]
 		public int? MaxPresences { get; internal set; }
 
 #pragma warning disable CS1734
 		/// <summary>
 		/// Gets the approximate number of members in this guild, when using <see cref="DiscordClient.GetGuildAsync(ulong, bool?)"/> and having <paramref name = "withCounts"></paramref> set to true.
 		/// </summary>
 		[JsonProperty("approximate_member_count", NullValueHandling = NullValueHandling.Ignore)]
 		public int? ApproximateMemberCount { get; internal set; }
 
 		/// <summary>
 		/// Gets the approximate number of presences in this guild, when using <see cref="DiscordClient.GetGuildAsync(ulong, bool?)"/> and having <paramref name = "withCounts"></paramref> set to true.
 		/// </summary>
 		[JsonProperty("approximate_presence_count", NullValueHandling = NullValueHandling.Ignore)]
 		public int? ApproximatePresenceCount { get; internal set; }
 
 #pragma warning restore CS1734
 		/// <summary>
 		/// Gets the maximum amount of users allowed per video channel.
 		/// </summary>
 		[JsonProperty("max_video_channel_users", NullValueHandling = NullValueHandling.Ignore)]
 		public int? MaxVideoChannelUsers { get; internal set; }
 
 		/// <summary>
 		/// Gets a dictionary of all the voice states for this guilds. The key for this dictionary is the ID of the user
 		/// the voice state corresponds to.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyDictionary<ulong, DiscordVoiceState> VoiceStates => new ReadOnlyConcurrentDictionary<ulong, DiscordVoiceState>(this.VoiceStatesInternal);
 
 		[JsonProperty("voice_states", NullValueHandling = NullValueHandling.Ignore)]
 		[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 		internal ConcurrentDictionary<ulong, DiscordVoiceState> VoiceStatesInternal;
 
 		/// <summary>
 		/// Gets a dictionary of all the members that belong to this guild. The dictionary's key is the member ID.
 		/// </summary>
 		[JsonIgnore] // TODO overhead of => vs Lazy? it's a struct
 		public IReadOnlyDictionary<ulong, DiscordMember> Members => new ReadOnlyConcurrentDictionary<ulong, DiscordMember>(this.MembersInternal);
 
 		[JsonProperty("members", NullValueHandling = NullValueHandling.Ignore)]
 		[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 		internal ConcurrentDictionary<ulong, DiscordMember> MembersInternal;
 
 		/// <summary>
 		/// Gets a dictionary of all the channels associated with this guild. The dictionary's key is the channel ID.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyDictionary<ulong, DiscordChannel> Channels => new ReadOnlyConcurrentDictionary<ulong, DiscordChannel>(this.ChannelsInternal);
 
 		[JsonProperty("channels", NullValueHandling = NullValueHandling.Ignore)]
 		[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 		internal ConcurrentDictionary<ulong, DiscordChannel> ChannelsInternal;
 
 		internal ConcurrentDictionary<string, DiscordInvite> Invites;
 
 		/// <summary>
 		/// Gets a dictionary of all the active threads associated with this guild the user has permission to view. The dictionary's key is the channel ID.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyDictionary<ulong, DiscordThreadChannel> Threads { get; internal set; }
 
 		[JsonProperty("threads", NullValueHandling = NullValueHandling.Ignore)]
 		[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 		internal ConcurrentDictionary<ulong, DiscordThreadChannel> ThreadsInternal = new();
 
 		/// <summary>
 		/// Gets a dictionary of all active stage instances. The dictionary's key is the stage ID.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyDictionary<ulong, DiscordStageInstance> StageInstances { get; internal set; }
 
 		[JsonProperty("stage_instances", NullValueHandling = NullValueHandling.Ignore)]
 		[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 		internal ConcurrentDictionary<ulong, DiscordStageInstance> StageInstancesInternal = new();
 
 		/// <summary>
 		/// Gets a dictionary of all scheduled events.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyDictionary<ulong, DiscordScheduledEvent> ScheduledEvents { get; internal set; }
 
 		[JsonProperty("guild_scheduled_events", NullValueHandling = NullValueHandling.Ignore)]
 		[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 		internal ConcurrentDictionary<ulong, DiscordScheduledEvent> ScheduledEventsInternal = new();
 
 		/// <summary>
 		/// Gets the guild member for current user.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordMember CurrentMember
 			=> this._currentMemberLazy.Value;
 
 		[JsonIgnore]
 		private readonly Lazy<DiscordMember> _currentMemberLazy;
 
 		/// <summary>
 		/// Gets the @everyone role for this guild.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordRole EveryoneRole
 			=> this.GetRole(this.Id);
 
 		[JsonIgnore]
 		internal bool IsOwnerInternal;
 
 		/// <summary>
 		/// Gets whether the current user is the guild's owner.
 		/// </summary>
 		[JsonProperty("owner", NullValueHandling = NullValueHandling.Ignore)]
 		public bool IsOwner
 		{
 			get => this.IsOwnerInternal || this.OwnerId == this.Discord.CurrentUser.Id;
 			internal set => this.IsOwnerInternal = value;
 		}
 
 		/// <summary>
 		/// Gets the vanity URL code for this guild, when applicable.
 		/// </summary>
 		[JsonProperty("vanity_url_code")]
 		public string VanityUrlCode { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild description, when applicable.
 		/// </summary>
 		[JsonProperty("description")]
 		public string Description { get; internal set; }
 
 		/// <summary>
 		/// Gets this guild's banner hash, when applicable.
 		/// </summary>
 		[JsonProperty("banner")]
 		public string BannerHash { get; internal set; }
 
 		/// <summary>
 		/// Gets this guild's banner in url form.
 		/// </summary>
 		[JsonIgnore]
 		public string BannerUrl
 			=> !string.IsNullOrWhiteSpace(this.BannerHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Uri}{Endpoints.BANNERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}" : null;
 
 		/// <summary>
 		/// Whether this guild has the community feature enabled.
 		/// </summary>
 		[JsonIgnore]
 		public bool IsCommunity => this.Features.HasCommunityEnabled;
 
 		/// <summary>
 		/// Whether this guild has enabled the welcome screen.
 		/// </summary>
 		[JsonIgnore]
 		public bool HasWelcomeScreen => this.Features.HasWelcomeScreenEnabled;
 
 		/// <summary>
 		/// Whether this guild has enabled membership screening.
 		/// </summary>
 		[JsonIgnore]
 		public bool HasMemberVerificationGate => this.Features.HasMembershipScreeningEnabled;
 
 		/// <summary>
 		/// Gets this guild's premium tier (Nitro boosting).
 		/// </summary>
 		[JsonProperty("premium_tier")]
 		public PremiumTier PremiumTier { get; internal set; }
 
 		/// <summary>
 		/// Gets the amount of members that boosted this guild.
 		/// </summary>
 		[JsonProperty("premium_subscription_count", NullValueHandling = NullValueHandling.Ignore)]
 		public int? PremiumSubscriptionCount { get; internal set; }
 
 		/// <summary>
 		/// Whether the premium progress bar is enabled.
 		/// </summary>
 		[JsonProperty("premium_progress_bar_enabled", NullValueHandling = NullValueHandling.Ignore)]
 		public bool PremiumProgressBarEnabled { get; internal set; }
 
 		/// <summary>
 		/// Gets whether this guild is designated as NSFW.
 		/// </summary>
 		[JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
 		public bool IsNsfw { get; internal set; }
 
 		/// <summary>
 		/// Gets this guild's hub type, if applicable.
 		/// </summary>
 		[JsonProperty("hub_type", NullValueHandling = NullValueHandling.Ignore)]
 		public HubType HubType { get; internal set; }
 
 		/// <summary>
 		/// Gets a dictionary of all by position ordered channels associated with this guild. The dictionary's key is the channel ID.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyDictionary<ulong, DiscordChannel> OrderedChannels => new ReadOnlyDictionary<ulong, DiscordChannel>(this.InternalSortChannels());
 
 		/// <summary>
 		/// Sorts the channels.
 		/// </summary>
 		private Dictionary<ulong, DiscordChannel> InternalSortChannels()
 		{
 			Dictionary<ulong, DiscordChannel> keyValuePairs = new();
 			var ochannels = this.GetOrderedChannels();
 			foreach (var ochan in ochannels)
 			{
 				if (ochan.Key != 0)
 					keyValuePairs.Add(ochan.Key, this.GetChannel(ochan.Key));
 				foreach (var chan in ochan.Value)
 					keyValuePairs.Add(chan.Id, chan);
 			}
 			return keyValuePairs;
 		}
 
 		/// <summary>
 		/// Gets an ordered <see cref="DiscordChannel"/> list out of the channel cache.
 		/// Returns a Dictionary where the key is an ulong and can be mapped to <see cref="ChannelType.Category"/> <see cref="DiscordChannel"/>s.
 		/// Ignore the 0 key here, because that indicates that this is the "has no category" list.
 		/// Each value contains a ordered list of text/news and voice/stage channels as <see cref="DiscordChannel"/>.
 		/// </summary>
 		/// <returns>A ordered list of categories with its channels</returns>
 		public Dictionary<ulong, List<DiscordChannel>> GetOrderedChannels()
 		{
 			IReadOnlyList<DiscordChannel> rawChannels = this.ChannelsInternal.Values.ToList();
 
 			Dictionary<ulong, List<DiscordChannel>> orderedChannels = new();
 
 			orderedChannels.Add(0, new List<DiscordChannel>());
 
 			foreach (var channel in rawChannels.Where(c => c.Type == ChannelType.Category).OrderBy(c => c.Position))
 			{
 				orderedChannels.Add(channel.Id, new List<DiscordChannel>());
 			}
 
 			foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
 			{
 				orderedChannels[channel.ParentId.Value].Add(channel);
 			}
 			foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 			{
 				orderedChannels[channel.ParentId.Value].Add(channel);
 			}
 
 			foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
 			{
 				orderedChannels[0].Add(channel);
 			}
 			foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 			{
 				orderedChannels[0].Add(channel);
 			}
 
 			return orderedChannels;
 		}
 
 		/// <summary>
 		/// Gets an ordered <see cref="DiscordChannel"/> list.
 		/// Returns a Dictionary where the key is an ulong and can be mapped to <see cref="ChannelType.Category"/> <see cref="DiscordChannel"/>s.
 		/// Ignore the 0 key here, because that indicates that this is the "has no category" list.
 		/// Each value contains a ordered list of text/news and voice/stage channels as <see cref="DiscordChannel"/>.
 		/// </summary>
 		/// <returns>A ordered list of categories with its channels</returns>
 		public async Task<Dictionary<ulong, List<DiscordChannel>>> GetOrderedChannelsAsync()
 		{
 			var rawChannels = await this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
 			Dictionary<ulong, List<DiscordChannel>> orderedChannels = new();
 
 			orderedChannels.Add(0, new List<DiscordChannel>());
 
 			foreach (var channel in rawChannels.Where(c => c.Type == ChannelType.Category).OrderBy(c => c.Position))
 			{
 				orderedChannels.Add(channel.Id, new List<DiscordChannel>());
 			}
 
 			foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
 			{
 				orderedChannels[channel.ParentId.Value].Add(channel);
 			}
 			foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 			{
 				orderedChannels[channel.ParentId.Value].Add(channel);
 			}
 
 			foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
 			{
 				orderedChannels[0].Add(channel);
 			}
 			foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 			{
 				orderedChannels[0].Add(channel);
 			}
 
 			return orderedChannels;
 		}
 
 		/// <summary>
 		/// Whether it is synced.
 		/// </summary>
 		[JsonIgnore]
 		internal bool IsSynced { get; set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordGuild"/> class.
 		/// </summary>
 		internal DiscordGuild()
 		{
-			this._currentMemberLazy = new Lazy<DiscordMember>(() => (this.MembersInternal != null && this.MembersInternal.TryGetValue(this.Discord.CurrentUser.Id, out var member)) ? member : null);
+			this._currentMemberLazy = new Lazy<DiscordMember>(() => this.MembersInternal != null && this.MembersInternal.TryGetValue(this.Discord.CurrentUser.Id, out var member) ? member : null);
 			this.Invites = new ConcurrentDictionary<string, DiscordInvite>();
 			this.Threads = new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannel>(this.ThreadsInternal);
 			this.StageInstances = new ReadOnlyConcurrentDictionary<ulong, DiscordStageInstance>(this.StageInstancesInternal);
 			this.ScheduledEvents = new ReadOnlyConcurrentDictionary<ulong, DiscordScheduledEvent>(this.ScheduledEventsInternal);
 		}
 
 		#region Guild Methods
 
 		/// <summary>
 		/// Searches the current guild for members who's display name start with the specified name.
 		/// </summary>
 		/// <param name="name">The name to search for.</param>
 		/// <param name="limit">The maximum amount of members to return. Max 1000. Defaults to 1.</param>
 		/// <returns>The members found, if any.</returns>
 		public Task<IReadOnlyList<DiscordMember>> SearchMembersAsync(string name, int? limit = 1)
 			=> this.Discord.ApiClient.SearchMembersAsync(this.Id, name, limit);
 
 		/// <summary>
 		/// Adds a new member to this guild
 		/// </summary>
 		/// <param name="user">User to add</param>
 		/// <param name="accessToken">User's access token (OAuth2)</param>
 		/// <param name="nickname">new nickname</param>
 		/// <param name="roles">new roles</param>
 		/// <param name="muted">whether this user has to be muted</param>
 		/// <param name="deaf">whether this user has to be deafened</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite" /> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the <paramref name="user"/> or <paramref name="accessToken"/> is not found.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task AddMemberAsync(DiscordUser user, string accessToken, string nickname = null, IEnumerable<DiscordRole> roles = null,
 			bool muted = false, bool deaf = false)
 			=> this.Discord.ApiClient.AddGuildMemberAsync(this.Id, user.Id, accessToken, nickname, roles, muted, deaf);
 
 		/// <summary>
 		/// Deletes this guild. Requires the caller to be the owner of the guild.
 		/// </summary>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client is not the owner of the guild.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteAsync()
 			=> this.Discord.ApiClient.DeleteGuildAsync(this.Id);
 
 		/// <summary>
 		/// Modifies this guild.
 		/// </summary>
 		/// <param name="action">Action to perform on this guild..</param>
 		/// <returns>The modified guild object.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordGuild> ModifyAsync(Action<GuildEditModel> action)
 		{
 			var mdl = new GuildEditModel();
 			action(mdl);
 
 			var afkChannelId = Optional.FromNoValue<ulong?>();
 			if (mdl.AfkChannel.HasValue && mdl.AfkChannel.Value.Type != ChannelType.Voice && mdl.AfkChannel.Value != null)
 				throw new ArgumentException("AFK channel needs to be a voice channel.");
 			else if (mdl.AfkChannel.HasValue && mdl.AfkChannel.Value != null)
 				afkChannelId = mdl.AfkChannel.Value.Id;
 			else if (mdl.AfkChannel.HasValue)
 				afkChannelId = null;
 
 			var rulesChannelId = Optional.FromNoValue<ulong?>();
 			if (mdl.RulesChannel.HasValue && mdl.RulesChannel.Value != null && mdl.RulesChannel.Value.Type != ChannelType.Text && mdl.RulesChannel.Value.Type != ChannelType.News)
 				throw new ArgumentException("Rules channel needs to be a text channel.");
 			else if (mdl.RulesChannel.HasValue && mdl.RulesChannel.Value != null)
 				rulesChannelId = mdl.RulesChannel.Value.Id;
 			else if (mdl.RulesChannel.HasValue)
 				rulesChannelId = null;
 
 			var publicUpdatesChannelId = Optional.FromNoValue<ulong?>();
 			if (mdl.PublicUpdatesChannel.HasValue && mdl.PublicUpdatesChannel.Value != null && mdl.PublicUpdatesChannel.Value.Type != ChannelType.Text && mdl.PublicUpdatesChannel.Value.Type != ChannelType.News)
 				throw new ArgumentException("Public updates channel needs to be a text channel.");
 			else if (mdl.PublicUpdatesChannel.HasValue && mdl.PublicUpdatesChannel.Value != null)
 				publicUpdatesChannelId = mdl.PublicUpdatesChannel.Value.Id;
 			else if (mdl.PublicUpdatesChannel.HasValue)
 				publicUpdatesChannelId = null;
 
 			var systemChannelId = Optional.FromNoValue<ulong?>();
 			if (mdl.SystemChannel.HasValue && mdl.SystemChannel.Value != null && mdl.SystemChannel.Value.Type != ChannelType.Text && mdl.SystemChannel.Value.Type != ChannelType.News)
 				throw new ArgumentException("Public updates channel needs to be a text channel.");
 			else if (mdl.SystemChannel.HasValue && mdl.SystemChannel.Value != null)
 				systemChannelId = mdl.SystemChannel.Value.Id;
 			else if (mdl.SystemChannel.HasValue)
 				systemChannelId = null;
 
 			var iconb64 = Optional.FromNoValue<string>();
 			if (mdl.Icon.HasValue && mdl.Icon.Value != null)
 				using (var imgtool = new ImageTool(mdl.Icon.Value))
 					iconb64 = imgtool.GetBase64();
 			else if (mdl.Icon.HasValue)
 				iconb64 = null;
 
 			var splashb64 = Optional.FromNoValue<string>();
 			if (mdl.Splash.HasValue && mdl.Splash.Value != null)
 				using (var imgtool = new ImageTool(mdl.Splash.Value))
 					splashb64 = imgtool.GetBase64();
 			else if (mdl.Splash.HasValue)
 				splashb64 = null;
 
 			var bannerb64 = Optional.FromNoValue<string>();
 			if (mdl.Banner.HasValue && mdl.Banner.Value != null)
 				using (var imgtool = new ImageTool(mdl.Banner.Value))
 					bannerb64 = imgtool.GetBase64();
 			else if (mdl.Banner.HasValue)
 				bannerb64 = null;
 
 			var discoverySplash64 = Optional.FromNoValue<string>();
 			if (mdl.DiscoverySplash.HasValue && mdl.DiscoverySplash.Value != null)
 				using (var imgtool = new ImageTool(mdl.DiscoverySplash.Value))
 					discoverySplash64 = imgtool.GetBase64();
 			else if (mdl.DiscoverySplash.HasValue)
 				discoverySplash64 = null;
 
 			var description = Optional.FromNoValue<string>();
 			if (mdl.Description.HasValue && mdl.Description.Value != null)
 				description = mdl.Description;
 			else if (mdl.Description.HasValue)
 				description = null;
 
 			return await this.Discord.ApiClient.ModifyGuildAsync(this.Id, mdl.Name,
 				mdl.VerificationLevel, mdl.DefaultMessageNotifications, mdl.MfaLevel, mdl.ExplicitContentFilter,
 				afkChannelId, mdl.AfkTimeout, iconb64, mdl.Owner.IfPresent(e => e.Id), splashb64,
 				systemChannelId, mdl.SystemChannelFlags, publicUpdatesChannelId, rulesChannelId,
 				description, bannerb64, discoverySplash64, mdl.PreferredLocale, mdl.PremiumProgressBarEnabled, mdl.AuditLogReason).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Modifies the community settings async.
 		/// This sets <see cref="VerificationLevel.High"/> if not highest and <see cref="ExplicitContentFilter.AllMembers"/>.
 		/// </summary>
 		/// <param name="enabled">If true, enable <see cref="GuildFeatures.HasCommunityEnabled"/>.</param>
 		/// <param name="rulesChannel">The rules channel.</param>
 		/// <param name="publicUpdatesChannel">The public updates channel.</param>
 		/// <param name="preferredLocale">The preferred locale. Defaults to en-US.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="defaultMessageNotifications">The default message notifications. Defaults to <see cref="DefaultMessageNotifications.MentionsOnly"/></param>
 		/// <param name="reason">The auditlog reason.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordGuild> ModifyCommunitySettingsAsync(bool enabled, DiscordChannel rulesChannel = null, DiscordChannel publicUpdatesChannel = null, string preferredLocale = "en-US", string description = null, DefaultMessageNotifications defaultMessageNotifications = DefaultMessageNotifications.MentionsOnly, string reason = null)
 		{
 			var verificationLevel = this.VerificationLevel;
 			if (this.VerificationLevel != VerificationLevel.Highest)
 			{
 				verificationLevel = VerificationLevel.High;
 			}
 
 			var explicitContentFilter = ExplicitContentFilter.AllMembers;
 
 			var rulesChannelId = Optional.FromNoValue<ulong?>();
 			if (rulesChannel != null && rulesChannel.Type != ChannelType.Text && rulesChannel.Type != ChannelType.News)
 				throw new ArgumentException("Rules channel needs to be a text channel.");
 			else if (rulesChannel != null)
 				rulesChannelId = rulesChannel.Id;
 			else if (rulesChannel == null)
 				rulesChannelId = null;
 
 			var publicUpdatesChannelId = Optional.FromNoValue<ulong?>();
 			if (publicUpdatesChannel != null && publicUpdatesChannel.Type != ChannelType.Text && publicUpdatesChannel.Type != ChannelType.News)
 				throw new ArgumentException("Public updates channel needs to be a text channel.");
 			else if (publicUpdatesChannel != null)
 				publicUpdatesChannelId = publicUpdatesChannel.Id;
 			else if (publicUpdatesChannel == null)
 				publicUpdatesChannelId = null;
 
 			List<string> features = new();
 			var rfeatures = this.RawFeatures.ToList();
 			if (this.RawFeatures.Contains("COMMUNITY") && enabled)
 			{
 				features = rfeatures;
 			}
 			else if (!this.RawFeatures.Contains("COMMUNITY") && enabled)
 			{
 				rfeatures.Add("COMMUNITY");
 				features = rfeatures;
 			}
 			else if (this.RawFeatures.Contains("COMMUNITY") && !enabled)
 			{
 				rfeatures.Remove("COMMUNITY");
 				features = rfeatures;
 			}
 			else if (!this.RawFeatures.Contains("COMMUNITY") && !enabled)
 			{
 				features = rfeatures;
 			}
 
 			return await this.Discord.ApiClient.ModifyGuildCommunitySettingsAsync(this.Id, features, rulesChannelId, publicUpdatesChannelId, preferredLocale, description, defaultMessageNotifications, explicitContentFilter, verificationLevel, reason).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Timeout a specified member in this guild.
 		/// </summary>
 		/// <param name="memberId">Member to timeout.</param>
 		/// <param name="until">The datetime offset to time out the user. Up to 28 days.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task TimeoutAsync(ulong memberId, DateTimeOffset until, string reason = null)
 			=> until.Subtract(DateTimeOffset.UtcNow).Days > 28 ? throw new ArgumentException("Timeout can not be longer than 28 days") : this.Discord.ApiClient.ModifyTimeoutAsync(this.Id, memberId, until, reason);
 
 		/// <summary>
 		/// Timeout a specified member in this guild.
 		/// </summary>
 		/// <param name="memberId">Member to timeout.</param>
 		/// <param name="until">The timespan to time out the user. Up to 28 days.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task TimeoutAsync(ulong memberId, TimeSpan until, string reason = null)
 			=> this.TimeoutAsync(memberId, DateTimeOffset.UtcNow + until, reason);
 
 		/// <summary>
 		/// Timeout a specified member in this guild.
 		/// </summary>
 		/// <param name="memberId">Member to timeout.</param>
 		/// <param name="until">The datetime to time out the user. Up to 28 days.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task TimeoutAsync(ulong memberId, DateTime until, string reason = null)
 			=> this.TimeoutAsync(memberId, until.ToUniversalTime() - DateTime.UtcNow, reason);
 
 		/// <summary>
 		/// Removes the timeout from a specified member in this guild.
 		/// </summary>
 		/// <param name="memberId">Member to remove the timeout from.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task RemoveTimeoutAsync(ulong memberId, string reason = null) => this.Discord.ApiClient.ModifyTimeoutAsync(this.Id, memberId, null, reason);
 
 		/// <summary>
 		/// Bans a specified member from this guild.
 		/// </summary>
 		/// <param name="member">Member to ban.</param>
 		/// <param name="deleteMessageDays">How many days to remove messages from.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task BanMemberAsync(DiscordMember member, int deleteMessageDays = 0, string reason = null)
 			=> this.Discord.ApiClient.CreateGuildBanAsync(this.Id, member.Id, deleteMessageDays, reason);
 
 		/// <summary>
 		/// Bans a specified user by ID. This doesn't require the user to be in this guild.
 		/// </summary>
 		/// <param name="userId">ID of the user to ban.</param>
 		/// <param name="deleteMessageDays">How many days to remove messages from.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task BanMemberAsync(ulong userId, int deleteMessageDays = 0, string reason = null)
 			=> this.Discord.ApiClient.CreateGuildBanAsync(this.Id, userId, deleteMessageDays, reason);
 
 		/// <summary>
 		/// Unbans a user from this guild.
 		/// </summary>
 		/// <param name="user">User to unban.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task UnbanMemberAsync(DiscordUser user, string reason = null)
 			=> this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, user.Id, reason);
 
 		/// <summary>
 		/// Unbans a user by ID.
 		/// </summary>
 		/// <param name="userId">ID of the user to unban.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task UnbanMemberAsync(ulong userId, string reason = null)
 			=> this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, userId, reason);
 
 		/// <summary>
 		/// Leaves this guild.
 		/// </summary>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task LeaveAsync()
 			=> this.Discord.ApiClient.LeaveGuildAsync(this.Id);
 
 		/// <summary>
 		/// Gets the bans for this guild.
 		/// </summary>
 		/// <returns>Collection of bans in this guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordBan>> GetBansAsync()
 			=> this.Discord.ApiClient.GetGuildBansAsync(this.Id);
 
 		/// <summary>
 		/// Gets a ban for a specific user.
 		/// </summary>
 		/// <param name="userId">The Id of the user to get the ban for.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the specified user is not banned.</exception>
 		/// <returns>The requested ban object.</returns>
 		public Task<DiscordBan> GetBanAsync(ulong userId)
 			=> this.Discord.ApiClient.GetGuildBanAsync(this.Id, userId);
 
 		/// <summary>
 		/// Gets a ban for a specific user.
 		/// </summary>
 		/// <param name="user">The user to get the ban for.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the specified user is not banned.</exception>
 		/// <returns>The requested ban object.</returns>
 		public Task<DiscordBan> GetBanAsync(DiscordUser user)
 			=> this.GetBanAsync(user.Id);
 
 		#region Sheduled Events
 
 		/// <summary>
 		/// Creates a scheduled event.
 		/// </summary>
 		/// <param name="name">The name.</param>
 		/// <param name="scheduledStartTime">The scheduled start time.</param>
 		/// <param name="scheduledEndTime">The scheduled end time.</param>
 		/// <param name="channel">The channel.</param>
 		/// <param name="metadata">The metadata.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A scheduled event.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordScheduledEvent> CreateScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, DateTimeOffset? scheduledEndTime = null, DiscordChannel channel = null, DiscordScheduledEventEntityMetadata metadata = null, string description = null, ScheduledEventEntityType type = ScheduledEventEntityType.StageInstance, string reason = null)
 			=> await this.Discord.ApiClient.CreateGuildScheduledEventAsync(this.Id, type == ScheduledEventEntityType.External ? null : channel?.Id, type == ScheduledEventEntityType.External ? metadata : null, name, scheduledStartTime, scheduledEndTime.HasValue && type == ScheduledEventEntityType.External ? scheduledEndTime.Value : null, description, type, reason);
 
 		/// <summary>
 		/// Creates a scheduled event with type <see cref="ScheduledEventEntityType.External"/>.
 		/// </summary>
 		/// <param name="name">The name.</param>
 		/// <param name="scheduledStartTime">The scheduled start time.</param>
 		/// <param name="scheduledEndTime">The scheduled end time.</param>
 		/// <param name="location">The location of the external event.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A scheduled event.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordScheduledEvent> CreateExternalScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, DateTimeOffset scheduledEndTime, string location, string description = null, string reason = null)
 			=> await this.Discord.ApiClient.CreateGuildScheduledEventAsync(this.Id, null, new DiscordScheduledEventEntityMetadata(location), name, scheduledStartTime, scheduledEndTime, description, ScheduledEventEntityType.External, reason);
 
 
 		/// <summary>
 		/// Gets a specific scheduled events.
 		/// </summary>
 		/// <param name="scheduledEventId">The Id of the event to get.</param>
 		/// <param name="withUserCount">Whether to include user count.</param>
 		/// <returns>A scheduled event.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordScheduledEvent> GetScheduledEventAsync(ulong scheduledEventId, bool? withUserCount = null)
 			=> this.ScheduledEventsInternal.TryGetValue(scheduledEventId, out var ev) ? ev : await this.Discord.ApiClient.GetGuildScheduledEventAsync(this.Id, scheduledEventId, withUserCount);
 
 		/// <summary>
 		/// Gets a specific scheduled events.
 		/// </summary>
 		/// <param name="scheduledEvent">The event to get.</param>
 		/// <param name="withUserCount">Whether to include user count.</param>
 		/// <returns>A sheduled event.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordScheduledEvent> GetScheduledEventAsync(DiscordScheduledEvent scheduledEvent, bool? withUserCount = null)
 			=> await this.GetScheduledEventAsync(scheduledEvent.Id, withUserCount);
 
 		/// <summary>
 		/// Gets the guilds scheduled events.
 		/// </summary>
 		/// <param name="withUserCount">Whether to include user count.</param>
 		/// <returns>A list of the guilds scheduled events.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<IReadOnlyDictionary<ulong, DiscordScheduledEvent>> GetScheduledEventsAsync(bool? withUserCount = null)
 			=> await this.Discord.ApiClient.ListGuildScheduledEventsAsync(this.Id, withUserCount);
 		#endregion
 
 		/// <summary>
 		/// Creates a new text channel in this guild.
 		/// </summary>
 		/// <param name="name">Name of the new channel.</param>
 		/// <param name="parent">Category to put this channel in.</param>
 		/// <param name="topic">Topic of the channel.</param>
 		/// <param name="overwrites">Permission overwrites for this channel.</param>
 		/// <param name="nsfw">Whether the channel is to be flagged as not safe for work.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <param name="perUserRateLimit">Slow mode timeout for users.</param>
 		/// <returns>The newly-created channel.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordChannel> CreateTextChannelAsync(string name, DiscordChannel parent = null, Optional<string> topic = default, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, string reason = null)
 			=> this.CreateChannelAsync(name, ChannelType.Text, parent, topic, null, null, overwrites, nsfw, perUserRateLimit, null, reason);
 
 		/// <summary>
 		/// Creates a new channel category in this guild.
 		/// </summary>
 		/// <param name="name">Name of the new category.</param>
 		/// <param name="overwrites">Permission overwrites for this category.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns>The newly-created channel category.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordChannel> CreateChannelCategoryAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
 			=> this.CreateChannelAsync(name, ChannelType.Category, null, Optional.FromNoValue<string>(), null, null, overwrites, null, Optional.FromNoValue<int?>(), null, reason);
 
 		/// <summary>
 		/// Creates a new stage channel in this guild.
 		/// </summary>
 		/// <param name="name">Name of the new stage channel.</param>
 		/// <param name="overwrites">Permission overwrites for this stage channel.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns>The newly-created stage channel.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.NotSupportedException">Thrown when the guilds has not enabled community.</exception>
 		public Task<DiscordChannel> CreateStageChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
 			=> this.Features.HasCommunityEnabled ? this.CreateChannelAsync(name, ChannelType.Stage, null, Optional.FromNoValue<string>(), null, null, overwrites, null, Optional.FromNoValue<int?>(), null, reason) : throw new NotSupportedException("Guild has not enabled community. Can not create a stage channel.");
 
 		/// <summary>
 		/// Creates a new news channel in this guild.
 		/// </summary>
 		/// <param name="name">Name of the new stage channel.</param>
 		/// <param name="overwrites">Permission overwrites for this news channel.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns>The newly-created news channel.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.NotSupportedException">Thrown when the guilds has not enabled community.</exception>
 		public Task<DiscordChannel> CreateNewsChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
 			=> this.Features.HasCommunityEnabled ? this.CreateChannelAsync(name, ChannelType.News, null, Optional.FromNoValue<string>(), null, null, overwrites, null, Optional.FromNoValue<int?>(), null, reason) : throw new NotSupportedException("Guild has not enabled community. Can not create a news channel.");
 
 		/// <summary>
 		/// Creates a new voice channel in this guild.
 		/// </summary>
 		/// <param name="name">Name of the new channel.</param>
 		/// <param name="parent">Category to put this channel in.</param>
 		/// <param name="bitrate">Bitrate of the channel.</param>
 		/// <param name="userLimit">Maximum number of users in the channel.</param>
 		/// <param name="overwrites">Permission overwrites for this channel.</param>
 		/// <param name="qualityMode">Video quality mode of the channel.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns>The newly-created channel.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordChannel> CreateVoiceChannelAsync(string name, DiscordChannel parent = null, int? bitrate = null, int? userLimit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, VideoQualityMode? qualityMode = null, string reason = null)
 			=> this.CreateChannelAsync(name, ChannelType.Voice, parent, Optional.FromNoValue<string>(), bitrate, userLimit, overwrites, null, Optional.FromNoValue<int?>(), qualityMode, reason);
 
 		/// <summary>
 		/// Creates a new channel in this guild.
 		/// </summary>
 		/// <param name="name">Name of the new channel.</param>
 		/// <param name="type">Type of the new channel.</param>
 		/// <param name="parent">Category to put this channel in.</param>
 		/// <param name="topic">Topic of the channel.</param>
 		/// <param name="bitrate">Bitrate of the channel. Applies to voice only.</param>
 		/// <param name="userLimit">Maximum number of users in the channel. Applies to voice only.</param>
 		/// <param name="overwrites">Permission overwrites for this channel.</param>
 		/// <param name="nsfw">Whether the channel is to be flagged as not safe for work. Applies to text only.</param>
 		/// <param name="perUserRateLimit">Slow mode timeout for users.</param>
 		/// <param name="qualityMode">Video quality mode of the channel. Applies to voice only.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns>The newly-created channel.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public Task<DiscordChannel> CreateChannelAsync(string name, ChannelType type, DiscordChannel parent = null, Optional<string> topic = default, int? bitrate = null, int? userLimit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, VideoQualityMode? qualityMode = null, string reason = null)
-		{
+		public Task<DiscordChannel> CreateChannelAsync(string name, ChannelType type, DiscordChannel parent = null, Optional<string> topic = default, int? bitrate = null, int? userLimit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, VideoQualityMode? qualityMode = null, string reason = null) =>
 			// technically you can create news/store channels but not always
-			return type != ChannelType.Text && type != ChannelType.Voice && type != ChannelType.Category && type != ChannelType.News && type != ChannelType.Store && type != ChannelType.Stage
+			type != ChannelType.Text && type != ChannelType.Voice && type != ChannelType.Category && type != ChannelType.News && type != ChannelType.Store && type != ChannelType.Stage
 				? throw new ArgumentException("Channel type must be text, voice, stage, or category.", nameof(type))
 				: type == ChannelType.Category && parent != null
-				? throw new ArgumentException("Cannot specify parent of a channel category.", nameof(parent))
-				: this.Discord.ApiClient.CreateGuildChannelAsync(this.Id, name, type, parent?.Id, topic, bitrate, userLimit, overwrites, nsfw, perUserRateLimit, qualityMode, reason);
-		}
+					? throw new ArgumentException("Cannot specify parent of a channel category.", nameof(parent))
+					: this.Discord.ApiClient.CreateGuildChannelAsync(this.Id, name, type, parent?.Id, topic, bitrate, userLimit, overwrites, nsfw, perUserRateLimit, qualityMode, reason);
 
 		/// <summary>
 		/// Gets active threads. Can contain more threads.
 		/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordThreadResult> GetActiveThreadsAsync()
 			=> this.Discord.ApiClient.GetActiveThreadsAsync(this.Id);
 
 		// this is to commemorate the Great DAPI Channel Massacre of 2017-11-19.
 		/// <summary>
 		/// <para>Deletes all channels in this guild.</para>
 		/// <para>Note that this is irreversible. Use carefully!</para>
 		/// </summary>
 		/// <returns></returns>
 		public Task DeleteAllChannelsAsync()
 		{
 			var tasks = this.Channels.Values.Select(xc => xc.DeleteAsync());
 			return Task.WhenAll(tasks);
 		}
 
 		/// <summary>
 		/// Estimates the number of users to be pruned.
 		/// </summary>
 		/// <param name="days">Minimum number of inactivity days required for users to be pruned. Defaults to 7.</param>
 		/// <param name="includedRoles">The roles to be included in the prune.</param>
 		/// <returns>Number of users that will be pruned.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<int> GetPruneCountAsync(int days = 7, IEnumerable<DiscordRole> includedRoles = null)
 		{
 			if (includedRoles != null)
 			{
 				includedRoles = includedRoles.Where(r => r != null);
 				var roleCount = includedRoles.Count();
 				var roleArr = includedRoles.ToArray();
 				var rawRoleIds = new List<ulong>();
 
 				for (var i = 0; i < roleCount; i++)
 				{
 					if (this.RolesInternal.ContainsKey(roleArr[i].Id))
 						rawRoleIds.Add(roleArr[i].Id);
 				}
 
 				return this.Discord.ApiClient.GetGuildPruneCountAsync(this.Id, days, rawRoleIds);
 			}
 
 			return this.Discord.ApiClient.GetGuildPruneCountAsync(this.Id, days, null);
 		}
 
 		/// <summary>
 		/// Prunes inactive users from this guild.
 		/// </summary>
 		/// <param name="days">Minimum number of inactivity days required for users to be pruned. Defaults to 7.</param>
 		/// <param name="computePruneCount">Whether to return the prune count after this method completes. This is discouraged for larger guilds.</param>
 		/// <param name="includedRoles">The roles to be included in the prune.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns>Number of users pruned.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<int?> PruneAsync(int days = 7, bool computePruneCount = true, IEnumerable<DiscordRole> includedRoles = null, string reason = null)
 		{
 			if (includedRoles != null)
 			{
 				includedRoles = includedRoles.Where(r => r != null);
 				var roleCount = includedRoles.Count();
 				var roleArr = includedRoles.ToArray();
 				var rawRoleIds = new List<ulong>();
 
 				for (var i = 0; i < roleCount; i++)
 				{
 					if (this.RolesInternal.ContainsKey(roleArr[i].Id))
 						rawRoleIds.Add(roleArr[i].Id);
 				}
 
 				return this.Discord.ApiClient.BeginGuildPruneAsync(this.Id, days, computePruneCount, rawRoleIds, reason);
 			}
 
 			return this.Discord.ApiClient.BeginGuildPruneAsync(this.Id, days, computePruneCount, null, reason);
 		}
 
 		/// <summary>
 		/// Gets integrations attached to this guild.
 		/// </summary>
 		/// <returns>Collection of integrations attached to this guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordIntegration>> GetIntegrationsAsync()
 			=> this.Discord.ApiClient.GetGuildIntegrationsAsync(this.Id);
 
 		/// <summary>
 		/// Attaches an integration from current user to this guild.
 		/// </summary>
 		/// <param name="integration">Integration to attach.</param>
 		/// <returns>The integration after being attached to the guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordIntegration> AttachUserIntegrationAsync(DiscordIntegration integration)
 			=> this.Discord.ApiClient.CreateGuildIntegrationAsync(this.Id, integration.Type, integration.Id);
 
 		/// <summary>
 		/// Modifies an integration in this guild.
 		/// </summary>
 		/// <param name="integration">Integration to modify.</param>
 		/// <param name="expireBehaviour">Number of days after which the integration expires.</param>
 		/// <param name="expireGracePeriod">Length of grace period which allows for renewing the integration.</param>
 		/// <param name="enableEmoticons">Whether emotes should be synced from this integration.</param>
 		/// <returns>The modified integration.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordIntegration> ModifyIntegrationAsync(DiscordIntegration integration, int expireBehaviour, int expireGracePeriod, bool enableEmoticons)
 			=> this.Discord.ApiClient.ModifyGuildIntegrationAsync(this.Id, integration.Id, expireBehaviour, expireGracePeriod, enableEmoticons);
 
 		/// <summary>
 		/// Removes an integration from this guild.
 		/// </summary>
 		/// <param name="integration">Integration to remove.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteIntegrationAsync(DiscordIntegration integration)
 			=> this.Discord.ApiClient.DeleteGuildIntegrationAsync(this.Id, integration);
 
 		/// <summary>
 		/// Forces re-synchronization of an integration for this guild.
 		/// </summary>
 		/// <param name="integration">Integration to synchronize.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task SyncIntegrationAsync(DiscordIntegration integration)
 			=> this.Discord.ApiClient.SyncGuildIntegrationAsync(this.Id, integration.Id);
 
 		/// <summary>
 		/// Gets the voice regions for this guild.
 		/// </summary>
 		/// <returns>Voice regions available for this guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
 		{
 			var vrs = await this.Discord.ApiClient.GetGuildVoiceRegionsAsync(this.Id).ConfigureAwait(false);
 			foreach (var xvr in vrs)
 				this.Discord.InternalVoiceRegions.TryAdd(xvr.Id, xvr);
 
 			return vrs;
 		}
 
 		/// <summary>
 		/// Gets an invite from this guild from an invite code.
 		/// </summary>
 		/// <param name="code">The invite code</param>
 		/// <returns>An invite, or null if not in cache.</returns>
 		public DiscordInvite GetInvite(string code)
 			=> this.Invites.TryGetValue(code, out var invite) ? invite : null;
 
 		/// <summary>
 		/// Gets all the invites created for all the channels in this guild.
 		/// </summary>
 		/// <returns>A collection of invites.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync()
 		{
 			var res = await this.Discord.ApiClient.GetGuildInvitesAsync(this.Id).ConfigureAwait(false);
 
 			var intents = this.Discord.Configuration.Intents;
 
 			if (!intents.HasIntent(DiscordIntents.GuildInvites))
 			{
 				for (var i = 0; i < res.Count; i++)
 					this.Invites[res[i].Code] = res[i];
 			}
 
 			return res;
 		}
 
 		/// <summary>
 		/// Gets the vanity invite for this guild.
 		/// </summary>
 		/// <returns>A partial vanity invite.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordInvite> GetVanityInviteAsync()
 			=> this.Discord.ApiClient.GetGuildVanityUrlAsync(this.Id);
 
 		/// <summary>
 		/// Gets all the webhooks created for all the channels in this guild.
 		/// </summary>
 		/// <returns>A collection of webhooks this guild has.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
 			=> this.Discord.ApiClient.GetGuildWebhooksAsync(this.Id);
 
 		/// <summary>
 		/// Gets this guild's widget image.
 		/// </summary>
 		/// <param name="bannerType">The format of the widget.</param>
 		/// <returns>The URL of the widget image.</returns>
 		public string GetWidgetImage(WidgetType bannerType = WidgetType.Shield)
 		{
 			var param = bannerType switch
 			{
 				WidgetType.Banner1 => "banner1",
 				WidgetType.Banner2 => "banner2",
 				WidgetType.Banner3 => "banner3",
 				WidgetType.Banner4 => "banner4",
 				_ => "shield",
 			};
 			return $"{Endpoints.BASE_URI}{Endpoints.GUILDS}/{this.Id}{Endpoints.WIDGET_PNG}?style={param}";
 		}
 
 		/// <summary>
 		/// Gets a member of this guild by their user ID.
 		/// </summary>
 		/// <param name="userId">ID of the member to get.</param>
 		/// <returns>The requested member.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordMember> GetMemberAsync(ulong userId)
 		{
 			if (this.MembersInternal != null && this.MembersInternal.TryGetValue(userId, out var mbr))
 				return mbr;
 
 			mbr = await this.Discord.ApiClient.GetGuildMemberAsync(this.Id, userId).ConfigureAwait(false);
 
 			var intents = this.Discord.Configuration.Intents;
 
 			if (intents.HasIntent(DiscordIntents.GuildMembers))
 			{
 				if (this.MembersInternal != null)
 				{
 					this.MembersInternal[userId] = mbr;
 				}
 			}
 
 			return mbr;
 		}
 
 		/// <summary>
 		/// Retrieves a full list of members from Discord. This method will bypass cache.
 		/// </summary>
 		/// <returns>A collection of all members in this guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<IReadOnlyCollection<DiscordMember>> GetAllMembersAsync()
 		{
 			var recmbr = new HashSet<DiscordMember>();
 
 			var recd = 1000;
 			var last = 0ul;
 			while (recd > 0)
 			{
 				var tms = await this.Discord.ApiClient.ListGuildMembersAsync(this.Id, 1000, last == 0 ? null : (ulong?)last).ConfigureAwait(false);
 				recd = tms.Count;
 
 				foreach (var xtm in tms)
 				{
 					var usr = new DiscordUser(xtm.User) { Discord = this.Discord };
 
 					usr = this.Discord.UserCache.AddOrUpdate(xtm.User.Id, usr, (id, old) =>
 					{
 						old.Username = usr.Username;
 						old.Discord = usr.Discord;
 						old.AvatarHash = usr.AvatarHash;
 
 						return old;
 					});
 
 					recmbr.Add(new DiscordMember(xtm) { Discord = this.Discord, GuildId = this.Id });
 				}
 
 				var tm = tms.LastOrDefault();
 				last = tm?.User.Id ?? 0;
 			}
 
 			return new ReadOnlySet<DiscordMember>(recmbr);
 		}
 
 		/// <summary>
 		/// Requests that Discord send a list of guild members based on the specified arguments. This method will fire the <see cref="DiscordClient.GuildMembersChunked"/> event.
 		/// <para>If no arguments aside from <paramref name="presences"/> and <paramref name="nonce"/> are specified, this will request all guild members.</para>
 		/// </summary>
 		/// <param name="query">Filters the returned members based on what the username starts with. Either this or <paramref name="userIds"/> must not be null.
 		/// The <paramref name="limit"/> must also be greater than 0 if this is specified.</param>
 		/// <param name="limit">Total number of members to request. This must be greater than 0 if <paramref name="query"/> is specified.</param>
 		/// <param name="presences">Whether to include the <see cref="DisCatSharp.EventArgs.GuildMembersChunkEventArgs.Presences"/> associated with the fetched members.</param>
 		/// <param name="userIds">Whether to limit the request to the specified user ids. Either this or <paramref name="query"/> must not be null.</param>
 		/// <param name="nonce">The unique string to identify the response.</param>
 		public async Task RequestMembersAsync(string query = "", int limit = 0, bool? presences = null, IEnumerable<ulong> userIds = null, string nonce = null)
 		{
 			if (this.Discord is not DiscordClient client)
 				throw new InvalidOperationException("This operation is only valid for regular Discord clients.");
 
 			if (query == null && userIds == null)
 				throw new ArgumentException("The query and user IDs cannot both be null.");
 
 			if (query != null && userIds != null)
 				query = null;
 
 			var grgm = new GatewayRequestGuildMembers(this)
 			{
 				Query = query,
 				Limit = limit >= 0 ? limit : 0,
 				Presences = presences,
 				UserIds = userIds,
 				Nonce = nonce
 			};
 
 			var payload = new GatewayPayload
 			{
 				OpCode = GatewayOpCode.RequestGuildMembers,
 				Data = grgm
 			};
 
 			var payloadStr = JsonConvert.SerializeObject(payload, Formatting.None);
 			await client.WsSendAsync(payloadStr).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Gets all the channels this guild has.
 		/// </summary>
 		/// <returns>A collection of this guild's channels.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordChannel>> GetChannelsAsync()
 			=> this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
 		/// <summary>
 		/// Creates a new role in this guild.
 		/// </summary>
 		/// <param name="name">Name of the role.</param>
 		/// <param name="permissions">Permissions for the role.</param>
 		/// <param name="color">Color for the role.</param>
 		/// <param name="hoist">Whether the role is to be hoisted.</param>
 		/// <param name="mentionable">Whether the role is to be mentionable.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns>The newly-created role.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordRole> CreateRoleAsync(string name = null, Permissions? permissions = null, DiscordColor? color = null, bool? hoist = null, bool? mentionable = null, string reason = null)
 			=> this.Discord.ApiClient.CreateGuildRoleAsync(this.Id, name, permissions, color?.Value, hoist, mentionable, reason);
 
 		/// <summary>
 		/// Gets a role from this guild by its ID.
 		/// </summary>
 		/// <param name="id">ID of the role to get.</param>
 		/// <returns>Requested role.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public DiscordRole GetRole(ulong id)
 			=> this.RolesInternal.TryGetValue(id, out var role) ? role : null;
 
 		/// <summary>
 		/// Gets a channel from this guild by its ID.
 		/// </summary>
 		/// <param name="id">ID of the channel to get.</param>
 		/// <returns>Requested channel.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public DiscordChannel GetChannel(ulong id)
-			=> (this.ChannelsInternal != null && this.ChannelsInternal.TryGetValue(id, out var channel)) ? channel : null;
+			=> this.ChannelsInternal != null && this.ChannelsInternal.TryGetValue(id, out var channel) ? channel : null;
 
 		/// <summary>
 		/// Gets a thread from this guild by its ID.
 		/// </summary>
 		/// <param name="id">ID of the thread to get.</param>
 		/// <returns>Requested thread.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public DiscordThreadChannel GetThread(ulong id)
-			=> (this.ThreadsInternal != null && this.ThreadsInternal.TryGetValue(id, out var thread)) ? thread : null;
+			=> this.ThreadsInternal != null && this.ThreadsInternal.TryGetValue(id, out var thread) ? thread : null;
 
 		/// <summary>
 		/// Gets audit log entries for this guild.
 		/// </summary>
 		/// <param name="limit">Maximum number of entries to fetch.</param>
 		/// <param name="byMember">Filter by member responsible.</param>
 		/// <param name="actionType">Filter by action type.</param>
 		/// <returns>A collection of requested audit log entries.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ViewAuditLog"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<IReadOnlyList<DiscordAuditLogEntry>> GetAuditLogsAsync(int? limit = null, DiscordMember byMember = null, AuditLogActionType? actionType = null)
 		{
 			var alrs = new List<AuditLog>();
 			int ac = 1, tc = 0, rmn = 100;
 			var last = 0ul;
 			while (ac > 0)
 			{
 				rmn = limit != null ? limit.Value - tc : 100;
 				rmn = Math.Min(100, rmn);
 				if (rmn <= 0) break;
 
 				var alr = await this.Discord.ApiClient.GetAuditLogsAsync(this.Id, rmn, null, last == 0 ? null : (ulong?)last, byMember?.Id, (int?)actionType).ConfigureAwait(false);
 				ac = alr.Entries.Count();
 				tc += ac;
 				if (ac > 0)
 				{
 					last = alr.Entries.Last().Id;
 					alrs.Add(alr);
 				}
 			}
 
 			var amr = alrs.SelectMany(xa => xa.Users)
 				.GroupBy(xu => xu.Id)
 				.Select(xgu => xgu.First());
 
 			foreach (var xau in amr)
 			{
 				if (this.Discord.UserCache.ContainsKey(xau.Id))
 					continue;
 
 				var xtu = new TransportUser
 				{
 					Id = xau.Id,
 					Username = xau.Username,
 					Discriminator = xau.Discriminator,
 					AvatarHash = xau.AvatarHash
 				};
 				var xu = new DiscordUser(xtu) { Discord = this.Discord };
 				xu = this.Discord.UserCache.AddOrUpdate(xu.Id, xu, (id, old) =>
 				{
 					old.Username = xu.Username;
 					old.Discriminator = xu.Discriminator;
 					old.AvatarHash = xu.AvatarHash;
 					return old;
 				});
 			}
 
 			var atgse = alrs.SelectMany(xa => xa.ScheduledEvents)
 				.GroupBy(xse => xse.Id)
 				.Select(xgse => xgse.First());
 
 			var ath = alrs.SelectMany(xa => xa.Threads)
 				.GroupBy(xt => xt.Id)
 				.Select(xgt => xgt.First());
 
 			var aig = alrs.SelectMany(xa => xa.Integrations)
 				.GroupBy(xi => xi.Id)
 				.Select(xgi => xgi.First());
 
 			var ahr = alrs.SelectMany(xa => xa.Webhooks)
 				.GroupBy(xh => xh.Id)
 				.Select(xgh => xgh.First());
 
-			var ams = amr.Select(xau => (this.MembersInternal != null && this.MembersInternal.TryGetValue(xau.Id, out var member)) ? member : new DiscordMember { Discord = this.Discord, Id = xau.Id, GuildId = this.Id });
+			var ams = amr.Select(xau => this.MembersInternal != null && this.MembersInternal.TryGetValue(xau.Id, out var member) ? member : new DiscordMember { Discord = this.Discord, Id = xau.Id, GuildId = this.Id });
 			var amd = ams.ToDictionary(xm => xm.Id, xm => xm);
 
 #pragma warning disable CS0219
 			Dictionary<ulong, DiscordThreadChannel> dtc = null;
 			Dictionary<ulong, DiscordIntegration> di = null;
 			Dictionary<ulong, DiscordScheduledEvent> dse = null;
 #pragma warning restore
 
 			Dictionary<ulong, DiscordWebhook> ahd = null;
 			if (ahr.Any())
 			{
 				var whr = await this.GetWebhooksAsync().ConfigureAwait(false);
 				var whs = whr.ToDictionary(xh => xh.Id, xh => xh);
 
 				var amh = ahr.Select(xah => whs.TryGetValue(xah.Id, out var webhook) ? webhook : new DiscordWebhook { Discord = this.Discord, Name = xah.Name, Id = xah.Id, AvatarHash = xah.AvatarHash, ChannelId = xah.ChannelId, GuildId = xah.GuildId, Token = xah.Token });
 				ahd = amh.ToDictionary(xh => xh.Id, xh => xh);
 			}
 
 			var acs = alrs.SelectMany(xa => xa.Entries).OrderByDescending(xa => xa.Id);
 			var entries = new List<DiscordAuditLogEntry>();
 			foreach (var xac in acs)
 			{
 				DiscordAuditLogEntry entry = null;
 				ulong t1, t2;
 				int t3, t4;
 				long t5, t6;
 				bool p1, p2;
 				switch (xac.ActionType)
 				{
 					case AuditLogActionType.GuildUpdate:
 						entry = new DiscordAuditLogGuildEntry
 						{
 							Target = this
 						};
 
 						var entrygld = entry as DiscordAuditLogGuildEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "name":
 									entrygld.NameChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 
 								case "owner_id":
 									entrygld.OwnerChange = new PropertyChange<DiscordMember>
 									{
-										Before = (this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.OldValueUlong, out var oldMember)) ? oldMember : await this.GetMemberAsync(xc.OldValueUlong).ConfigureAwait(false),
-										After = (this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.NewValueUlong, out var newMember)) ? newMember : await this.GetMemberAsync(xc.NewValueUlong).ConfigureAwait(false)
+										Before = this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.OldValueUlong, out var oldMember) ? oldMember : await this.GetMemberAsync(xc.OldValueUlong).ConfigureAwait(false),
+										After = this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.NewValueUlong, out var newMember) ? newMember : await this.GetMemberAsync(xc.NewValueUlong).ConfigureAwait(false)
 									};
 									break;
 
 								case "icon_hash":
 									entrygld.IconChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.OldValueString}.webp" : null,
 										After = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.NewValueString}.webp" : null
 									};
 									break;
 
 								case "verification_level":
 									entrygld.VerificationLevelChange = new PropertyChange<VerificationLevel>
 									{
 										Before = (VerificationLevel)(long)xc.OldValue,
 										After = (VerificationLevel)(long)xc.NewValue
 									};
 									break;
 
 								case "afk_channel_id":
 									ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entrygld.AfkChannelChange = new PropertyChange<DiscordChannel>
 									{
 										Before = this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id },
 										After = this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id }
 									};
 									break;
 
 								case "widget_channel_id":
 									ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entrygld.EmbedChannelChange = new PropertyChange<DiscordChannel>
 									{
 										Before = this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id },
 										After = this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id }
 									};
 									break;
 
 								case "splash_hash":
 									entrygld.SplashChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.OldValueString}.webp?size=2048" : null,
 										After = xc.NewValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.NewValueString}.webp?size=2048" : null
 									};
 									break;
 
 								case "default_message_notifications":
 									entrygld.NotificationSettingsChange = new PropertyChange<DefaultMessageNotifications>
 									{
 										Before = (DefaultMessageNotifications)(long)xc.OldValue,
 										After = (DefaultMessageNotifications)(long)xc.NewValue
 									};
 									break;
 
 								case "system_channel_id":
 									ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entrygld.SystemChannelChange = new PropertyChange<DiscordChannel>
 									{
 										Before = this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id },
 										After = this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id }
 									};
 									break;
 
 								case "explicit_content_filter":
 									entrygld.ExplicitContentFilterChange = new PropertyChange<ExplicitContentFilter>
 									{
 										Before = (ExplicitContentFilter)(long)xc.OldValue,
 										After = (ExplicitContentFilter)(long)xc.NewValue
 									};
 									break;
 
 								case "mfa_level":
 									entrygld.MfaLevelChange = new PropertyChange<MfaLevel>
 									{
 										Before = (MfaLevel)(long)xc.OldValue,
 										After = (MfaLevel)(long)xc.NewValue
 									};
 									break;
 
 								case "region":
 									entrygld.RegionChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 
 								case "premium_progress_bar_enabled":
 									entrygld.PremiumProgressBarChange = new PropertyChange<bool>
 									{
 										Before = (bool)xc.OldValue,
 										After = (bool)xc.NewValue
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in guild update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 					case AuditLogActionType.ChannelCreate:
 					case AuditLogActionType.ChannelDelete:
 					case AuditLogActionType.ChannelUpdate:
 						entry = new DiscordAuditLogChannelEntry
 						{
 							Target = this.GetChannel(xac.TargetId.Value) ?? new DiscordChannel { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 						};
 
 						var entrychn = entry as DiscordAuditLogChannelEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "name":
 									entrychn.NameChange = new PropertyChange<string>
 									{
 										Before = xc.OldValue != null ? xc.OldValueString : null,
 										After = xc.NewValue != null ? xc.NewValueString : null
 									};
 									break;
 
 								case "type":
 									p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entrychn.TypeChange = new PropertyChange<ChannelType?>
 									{
 										Before = p1 ? (ChannelType?)t1 : null,
 										After = p2 ? (ChannelType?)t2 : null
 									};
 									break;
 
 								case "permission_overwrites":
 									var olds = xc.OldValues?.OfType<JObject>()
 										?.Select(xjo => xjo.ToObject<DiscordOverwrite>())
 										?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 									var news = xc.NewValues?.OfType<JObject>()
 										?.Select(xjo => xjo.ToObject<DiscordOverwrite>())
 										?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 									entrychn.OverwriteChange = new PropertyChange<IReadOnlyList<DiscordOverwrite>>
 									{
 										Before = olds != null ? new ReadOnlyCollection<DiscordOverwrite>(new List<DiscordOverwrite>(olds)) : null,
 										After = news != null ? new ReadOnlyCollection<DiscordOverwrite>(new List<DiscordOverwrite>(news)) : null
 									};
 									break;
 
 								case "topic":
 									entrychn.TopicChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 
 								case "nsfw":
 									entrychn.NsfwChange = new PropertyChange<bool?>
 									{
 										Before = (bool?)xc.OldValue,
 										After = (bool?)xc.NewValue
 									};
 									break;
 
 								case "bitrate":
 									entrychn.BitrateChange = new PropertyChange<int?>
 									{
 										Before = (int?)(long?)xc.OldValue,
 										After = (int?)(long?)xc.NewValue
 									};
 									break;
 
 								case "rate_limit_per_user":
 									entrychn.PerUserRateLimitChange = new PropertyChange<int?>
 									{
 										Before = (int?)(long?)xc.OldValue,
 										After = (int?)(long?)xc.NewValue
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in channel update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 					case AuditLogActionType.OverwriteCreate:
 					case AuditLogActionType.OverwriteDelete:
 					case AuditLogActionType.OverwriteUpdate:
 						entry = new DiscordAuditLogOverwriteEntry
 						{
 							Target = this.GetChannel(xac.TargetId.Value)?.PermissionOverwrites.FirstOrDefault(xo => xo.Id == xac.Options.Id),
 							Channel = this.GetChannel(xac.TargetId.Value)
 						};
 
 						var entryovr = entry as DiscordAuditLogOverwriteEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "deny":
 									p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entryovr.DenyChange = new PropertyChange<Permissions?>
 									{
 										Before = p1 ? (Permissions?)t1 : null,
 										After = p2 ? (Permissions?)t2 : null
 									};
 									break;
 
 								case "allow":
 									p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entryovr.AllowChange = new PropertyChange<Permissions?>
 									{
 										Before = p1 ? (Permissions?)t1 : null,
 										After = p2 ? (Permissions?)t2 : null
 									};
 									break;
 
 								case "type":
 									entryovr.TypeChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 
 								case "id":
 									p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entryovr.TargetIdChange = new PropertyChange<ulong?>
 									{
 										Before = p1 ? (ulong?)t1 : null,
 										After = p2 ? (ulong?)t2 : null
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in overwrite update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 					case AuditLogActionType.Kick:
 						entry = new DiscordAuditLogKickEntry
 						{
 							Target = amd.TryGetValue(xac.TargetId.Value, out var kickMember) ? kickMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 						};
 						break;
 
 					case AuditLogActionType.Prune:
 						entry = new DiscordAuditLogPruneEntry
 						{
 							Days = xac.Options.DeleteMemberDays,
 							Toll = xac.Options.MembersRemoved
 						};
 						break;
 
 					case AuditLogActionType.Ban:
 					case AuditLogActionType.Unban:
 						entry = new DiscordAuditLogBanEntry
 						{
 							Target = amd.TryGetValue(xac.TargetId.Value, out var unbanMember) ? unbanMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 						};
 						break;
 
 					case AuditLogActionType.MemberUpdate:
 					case AuditLogActionType.MemberRoleUpdate:
 						entry = new DiscordAuditLogMemberUpdateEntry
 						{
 							Target = amd.TryGetValue(xac.TargetId.Value, out var roleUpdMember) ? roleUpdMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 						};
 
 						var entrymbu = entry as DiscordAuditLogMemberUpdateEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "nick":
 									entrymbu.NicknameChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 
 								case "deaf":
 									entrymbu.DeafenChange = new PropertyChange<bool?>
 									{
 										Before = (bool?)xc.OldValue,
 										After = (bool?)xc.NewValue
 									};
 									break;
 
 								case "mute":
 									entrymbu.MuteChange = new PropertyChange<bool?>
 									{
 										Before = (bool?)xc.OldValue,
 										After = (bool?)xc.NewValue
 									};
 									break;
 								case "communication_disabled_until":
 									entrymbu.CommunicationDisabledUntilChange = new PropertyChange<DateTime?>
 									{
 										Before = (DateTime?)xc.OldValue,
 										After = (DateTime?)xc.NewValue
 									};
 									break;
 
 								case "$add":
 									entrymbu.AddedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
 									break;
 
 								case "$remove":
 									entrymbu.RemovedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in member update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 					case AuditLogActionType.RoleCreate:
 					case AuditLogActionType.RoleDelete:
 					case AuditLogActionType.RoleUpdate:
 						entry = new DiscordAuditLogRoleUpdateEntry
 						{
 							Target = this.GetRole(xac.TargetId.Value) ?? new DiscordRole { Id = xac.TargetId.Value, Discord = this.Discord }
 						};
 
 						var entryrol = entry as DiscordAuditLogRoleUpdateEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "name":
 									entryrol.NameChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 
 								case "color":
 									p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 									p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 									entryrol.ColorChange = new PropertyChange<int?>
 									{
 										Before = p1 ? (int?)t3 : null,
 										After = p2 ? (int?)t4 : null
 									};
 									break;
 
 								case "permissions":
 									entryrol.PermissionChange = new PropertyChange<Permissions?>
 									{
 										Before = xc.OldValue != null ? (Permissions?)long.Parse((string)xc.OldValue) : null,
 										After = xc.NewValue != null ? (Permissions?)long.Parse((string)xc.NewValue) : null
 									};
 									break;
 
 								case "position":
 									entryrol.PositionChange = new PropertyChange<int?>
 									{
 										Before = xc.OldValue != null ? (int?)(long)xc.OldValue : null,
 										After = xc.NewValue != null ? (int?)(long)xc.NewValue : null,
 									};
 									break;
 
 								case "mentionable":
 									entryrol.MentionableChange = new PropertyChange<bool?>
 									{
 										Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 										After = xc.NewValue != null ? (bool?)xc.NewValue : null
 									};
 									break;
 
 								case "hoist":
 									entryrol.HoistChange = new PropertyChange<bool?>
 									{
 										Before = (bool?)xc.OldValue,
 										After = (bool?)xc.NewValue
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in role update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 					case AuditLogActionType.InviteCreate:
 					case AuditLogActionType.InviteDelete:
 					case AuditLogActionType.InviteUpdate:
 						entry = new DiscordAuditLogInviteEntry();
 
 						var inv = new DiscordInvite
 						{
 							Discord = this.Discord,
 							Guild = new DiscordInviteGuild
 							{
 								Discord = this.Discord,
 								Id = this.Id,
 								Name = this.Name,
 								SplashHash = this.SplashHash
 							}
 						};
 
 						var entryinv = entry as DiscordAuditLogInviteEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "max_age":
 									p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 									p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 									entryinv.MaxAgeChange = new PropertyChange<int?>
 									{
 										Before = p1 ? (int?)t3 : null,
 										After = p2 ? (int?)t4 : null
 									};
 									break;
 
 								case "code":
 									inv.Code = xc.OldValueString ?? xc.NewValueString;
 
 									entryinv.CodeChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 
 								case "temporary":
 									entryinv.TemporaryChange = new PropertyChange<bool?>
 									{
 										Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 										After = xc.NewValue != null ? (bool?)xc.NewValue : null
 									};
 									break;
 
 								case "inviter_id":
 									p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entryinv.InviterChange = new PropertyChange<DiscordMember>
 									{
 										Before = amd.TryGetValue(t1, out var propBeforeMember) ? propBeforeMember : new DiscordMember { Id = t1, Discord = this.Discord, GuildId = this.Id },
 										After = amd.TryGetValue(t2, out var propAfterMember) ? propAfterMember : new DiscordMember { Id = t1, Discord = this.Discord, GuildId = this.Id },
 									};
 									break;
 
 								case "channel_id":
 									p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entryinv.ChannelChange = new PropertyChange<DiscordChannel>
 									{
 										Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
 										After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
 									};
 
 									var ch = entryinv.ChannelChange.Before ?? entryinv.ChannelChange.After;
 									var cht = ch?.Type;
 									inv.Channel = new DiscordInviteChannel
 									{
 										Discord = this.Discord,
 										Id = p1 ? t1 : t2,
 										Name = ch?.Name,
 										Type = cht != null ? cht.Value : ChannelType.Unknown
 									};
 									break;
 
 								case "uses":
 									p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 									p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 									entryinv.UsesChange = new PropertyChange<int?>
 									{
 										Before = p1 ? (int?)t3 : null,
 										After = p2 ? (int?)t4 : null
 									};
 									break;
 
 								case "max_uses":
 									p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 									p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 									entryinv.MaxUsesChange = new PropertyChange<int?>
 									{
 										Before = p1 ? (int?)t3 : null,
 										After = p2 ? (int?)t4 : null
 									};
 									break;
 
 								// TODO: Add changes for target application
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in invite update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 
 						entryinv.Target = inv;
 						break;
 
 					case AuditLogActionType.WebhookCreate:
 					case AuditLogActionType.WebhookDelete:
 					case AuditLogActionType.WebhookUpdate:
 						entry = new DiscordAuditLogWebhookEntry
 						{
 							Target = ahd.TryGetValue(xac.TargetId.Value, out var webhook) ? webhook : new DiscordWebhook { Id = xac.TargetId.Value, Discord = this.Discord }
 						};
 
 						var entrywhk = entry as DiscordAuditLogWebhookEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "name":
 									entrywhk.NameChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 
 								case "channel_id":
 									p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entrywhk.ChannelChange = new PropertyChange<DiscordChannel>
 									{
 										Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
 										After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
 									};
 									break;
 
 								case "type": // ???
 									p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 									p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 									entrywhk.TypeChange = new PropertyChange<int?>
 									{
 										Before = p1 ? (int?)t3 : null,
 										After = p2 ? (int?)t4 : null
 									};
 									break;
 
 								case "avatar_hash":
 									entrywhk.AvatarHashChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in webhook update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 					case AuditLogActionType.EmojiCreate:
 					case AuditLogActionType.EmojiDelete:
 					case AuditLogActionType.EmojiUpdate:
 						entry = new DiscordAuditLogEmojiEntry
 						{
 							Target = this.EmojisInternal.TryGetValue(xac.TargetId.Value, out var target) ? target : new DiscordEmoji { Id = xac.TargetId.Value, Discord = this.Discord }
 						};
 
 						var entryemo = entry as DiscordAuditLogEmojiEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "name":
 									entryemo.NameChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in emote update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 					case AuditLogActionType.StageInstanceCreate:
 					case AuditLogActionType.StageInstanceDelete:
 					case AuditLogActionType.StageInstanceUpdate:
 						entry = new DiscordAuditLogStageEntry
 						{
 							Target = this.StageInstancesInternal.TryGetValue(xac.TargetId.Value, out var stage) ? stage : new DiscordStageInstance { Id = xac.TargetId.Value, Discord = this.Discord }
 						};
 
 						var entrysta = entry as DiscordAuditLogStageEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "topic":
 									entrysta.TopicChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 								case "privacy_level":
 									entrysta.PrivacyLevelChange = new PropertyChange<StagePrivacyLevel?>
 									{
 										Before = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5) ? (StagePrivacyLevel?)t5 : null,
 										After = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6) ? (StagePrivacyLevel?)t6 : null,
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in stage instance update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 					case AuditLogActionType.StickerCreate:
 					case AuditLogActionType.StickerDelete:
 					case AuditLogActionType.StickerUpdate:
 						entry = new DiscordAuditLogStickerEntry
 						{
 							Target = this.StickersInternal.TryGetValue(xac.TargetId.Value, out var sticker) ? sticker : new DiscordSticker { Id = xac.TargetId.Value, Discord = this.Discord }
 						};
 
 						var entrysti = entry as DiscordAuditLogStickerEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "name":
 									entrysti.NameChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 								case "description":
 									entrysti.DescriptionChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 								case "tags":
 									entrysti.TagsChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 								case "guild_id":
 									entrysti.GuildIdChange = new PropertyChange<ulong?>
 									{
 										Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
 										After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
 									};
 									break;
 								case "available":
 									entrysti.AvailabilityChange = new PropertyChange<bool?>
 									{
 										Before = (bool?)xc.OldValue,
 										After = (bool?)xc.NewValue,
 									};
 									break;
 								case "asset":
 									entrysti.AssetChange = new PropertyChange<string>
 									{
 										Before = xc.OldValueString,
 										After = xc.NewValueString
 									};
 									break;
 								case "id":
 									entrysti.IdChange = new PropertyChange<ulong?>
 									{
 										Before = ulong.TryParse(xc.OldValueString, out var oid) ? oid : null,
 										After = ulong.TryParse(xc.NewValueString, out var nid) ? nid : null
 									};
 									break;
 								case "type":
 									p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 									p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 									entrysti.TypeChange = new PropertyChange<StickerType?>
 									{
 										Before = p1 ? (StickerType?)t5 : null,
 										After = p2 ? (StickerType?)t6 : null
 									};
 									break;
 								case "format_type":
 									p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 									p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 									entrysti.FormatChange = new PropertyChange<StickerFormat?>
 									{
 										Before = p1 ? (StickerFormat?)t5 : null,
 										After = p2 ? (StickerFormat?)t6 : null
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in sticker update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 
 
 					case AuditLogActionType.MessageDelete:
 					case AuditLogActionType.MessageBulkDelete:
 					{
 						entry = new DiscordAuditLogMessageEntry();
 
 						var entrymsg = entry as DiscordAuditLogMessageEntry;
 
 						if (xac.Options != null)
 						{
 							entrymsg.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 							entrymsg.MessageCount = xac.Options.Count;
 						}
 
 						if (entrymsg.Channel != null)
 						{
 							entrymsg.Target = this.Discord is DiscordClient dc
 								&& dc.MessageCache != null
 								&& dc.MessageCache.TryGet(xm => xm.Id == xac.TargetId.Value && xm.ChannelId == entrymsg.Channel.Id, out var msg)
 								? msg
 								: new DiscordMessage { Discord = this.Discord, Id = xac.TargetId.Value };
 						}
 						break;
 					}
 
 					case AuditLogActionType.MessagePin:
 					case AuditLogActionType.MessageUnpin:
 					{
 						entry = new DiscordAuditLogMessagePinEntry();
 
 						var entrypin = entry as DiscordAuditLogMessagePinEntry;
 
 						if (this.Discord is not DiscordClient dc)
 						{
 							break;
 						}
 
 						if (xac.Options != null)
 						{
 							DiscordMessage message = default;
 							dc.MessageCache?.TryGet(x => x.Id == xac.Options.MessageId && x.ChannelId == xac.Options.ChannelId, out message);
 
 							entrypin.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 							entrypin.Message = message ?? new DiscordMessage { Id = xac.Options.MessageId, Discord = this.Discord };
 						}
 
 						if (xac.TargetId.HasValue)
 						{
 							dc.UserCache.TryGetValue(xac.TargetId.Value, out var user);
 							entrypin.Target = user ?? new DiscordUser { Id = user.Id, Discord = this.Discord };
 						}
 
 						break;
 					}
 
 					case AuditLogActionType.BotAdd:
 					{
 						entry = new DiscordAuditLogBotAddEntry();
 
 						if (!(this.Discord is DiscordClient dc && xac.TargetId.HasValue))
 						{
 							break;
 						}
 
 						dc.UserCache.TryGetValue(xac.TargetId.Value, out var bot);
 						(entry as DiscordAuditLogBotAddEntry).TargetBot = bot ?? new DiscordUser { Id = xac.TargetId.Value, Discord = this.Discord };
 
 						break;
 					}
 
 					case AuditLogActionType.MemberMove:
 						entry = new DiscordAuditLogMemberMoveEntry();
 
 						if (xac.Options == null)
 						{
 							break;
 						}
 
 						var moveentry = entry as DiscordAuditLogMemberMoveEntry;
 
 						moveentry.UserCount = xac.Options.Count;
 						moveentry.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 						break;
 
 					case AuditLogActionType.MemberDisconnect:
 						entry = new DiscordAuditLogMemberDisconnectEntry
 						{
 							UserCount = xac.Options?.Count ?? 0
 						};
 						break;
 
 					case AuditLogActionType.IntegrationCreate:
 					case AuditLogActionType.IntegrationDelete:
 					case AuditLogActionType.IntegrationUpdate:
 						entry = new DiscordAuditLogIntegrationEntry();
 
 						var integentry = entry as DiscordAuditLogIntegrationEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "enable_emoticons":
 									integentry.EnableEmoticons = new PropertyChange<bool?>
 									{
 										Before = (bool?)xc.OldValue,
 										After = (bool?)xc.NewValue
 									};
 									break;
 								case "expire_behavior":
 									integentry.ExpireBehavior = new PropertyChange<int?>
 									{
 										Before = (int?)xc.OldValue,
 										After = (int?)xc.NewValue
 									};
 									break;
 								case "expire_grace_period":
 									integentry.ExpireBehavior = new PropertyChange<int?>
 									{
 										Before = (int?)xc.OldValue,
 										After = (int?)xc.NewValue
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in integration update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 					case AuditLogActionType.ThreadCreate:
 					case AuditLogActionType.ThreadDelete:
 					case AuditLogActionType.ThreadUpdate:
 						entry = new DiscordAuditLogThreadEntry
 						{
 							Target = this.ThreadsInternal.TryGetValue(xac.TargetId.Value, out var thread) ? thread : new DiscordThreadChannel { Id = xac.TargetId.Value, Discord = this.Discord }
 						};
 
 						var entrythr = entry as DiscordAuditLogThreadEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "name":
 									entrythr.NameChange = new PropertyChange<string>
 									{
 										Before = xc.OldValue != null ? xc.OldValueString : null,
 										After = xc.NewValue != null ? xc.NewValueString : null
 									};
 									break;
 
 								case "type":
 									p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 									p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 									entrythr.TypeChange = new PropertyChange<ChannelType?>
 									{
 										Before = p1 ? (ChannelType?)t1 : null,
 										After = p2 ? (ChannelType?)t2 : null
 									};
 									break;
 
 								case "archived":
 									entrythr.ArchivedChange = new PropertyChange<bool?>
 									{
 										Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 										After = xc.NewValue != null ? (bool?)xc.NewValue : null
 									};
 									break;
 
 								case "locked":
 									entrythr.LockedChange = new PropertyChange<bool?>
 									{
 										Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 										After = xc.NewValue != null ? (bool?)xc.NewValue : null
 									};
 									break;
 
 								case "auto_archive_duration":
 									p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 									p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 									entrythr.AutoArchiveDurationChange = new PropertyChange<ThreadAutoArchiveDuration?>
 									{
 										Before = p1 ? (ThreadAutoArchiveDuration?)t5 : null,
 										After = p2 ? (ThreadAutoArchiveDuration?)t6 : null
 									};
 									break;
 
 								case "rate_limit_per_user":
 									entrythr.PerUserRateLimitChange = new PropertyChange<int?>
 									{
 										Before = (int?)(long?)xc.OldValue,
 										After = (int?)(long?)xc.NewValue
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in thread update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 
 					case AuditLogActionType.GuildScheduledEventCreate:
 					case AuditLogActionType.GuildScheduledEventDelete:
 					case AuditLogActionType.GuildScheduledEventUpdate:
 						entry = new DiscordAuditLogGuildScheduledEventEntry
 						{
 							Target = this.ScheduledEventsInternal.TryGetValue(xac.TargetId.Value, out var scheduledEvent) ? scheduledEvent : new DiscordScheduledEvent { Id = xac.TargetId.Value, Discord = this.Discord }
 						};
 
 						var entryse = entry as DiscordAuditLogGuildScheduledEventEntry;
 						foreach (var xc in xac.Changes)
 						{
 							switch (xc.Key.ToLowerInvariant())
 							{
 								case "channel_id":
 									entryse.ChannelIdChange = new PropertyChange<ulong?>
 									{
 										Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
 										After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
 									};
 									break;
 
 								case "description":
 									entryse.DescriptionChange = new PropertyChange<string>
 									{
 										Before = xc.OldValue != null ? xc.OldValueString : null,
 										After = xc.NewValue != null ? xc.NewValueString : null
 									};
 									break;
 
 								case "location":
 									entryse.LocationChange = new PropertyChange<string>
 									{
 										Before = xc.OldValue != null ? xc.OldValueString : null,
 										After = xc.NewValue != null ? xc.NewValueString : null
 									};
 									break;
 
 								case "privacy_level":
 									p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 									p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 									entryse.PrivacyLevelChange = new PropertyChange<ScheduledEventPrivacyLevel?>
 									{
 										Before = p1 ? (ScheduledEventPrivacyLevel?)t5 : null,
 										After = p2 ? (ScheduledEventPrivacyLevel?)t6 : null
 									};
 									break;
 
 								case "entity_type":
 									p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 									p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 									entryse.EntityTypeChange = new PropertyChange<ScheduledEventEntityType?>
 									{
 										Before = p1 ? (ScheduledEventEntityType?)t5 : null,
 										After = p2 ? (ScheduledEventEntityType?)t6 : null
 									};
 									break;
 
 								case "status":
 									p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 									p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 									entryse.StatusChange = new PropertyChange<ScheduledEventStatus?>
 									{
 										Before = p1 ? (ScheduledEventStatus?)t5 : null,
 										After = p2 ? (ScheduledEventStatus?)t6 : null
 									};
 									break;
 
 								default:
 									this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in scheduled event update: {0} - this should be reported to library developers", xc.Key);
 									break;
 							}
 						}
 						break;
 
 					default:
 						this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown audit log action type: {0} - this should be reported to library developers", (int)xac.ActionType);
 						break;
 				}
 
 				if (entry == null)
 					continue;
 
 				entry.ActionCategory = xac.ActionType switch
 				{
 					AuditLogActionType.ChannelCreate or AuditLogActionType.EmojiCreate or AuditLogActionType.InviteCreate or AuditLogActionType.OverwriteCreate or AuditLogActionType.RoleCreate or AuditLogActionType.WebhookCreate or AuditLogActionType.IntegrationCreate or AuditLogActionType.StickerCreate or AuditLogActionType.StageInstanceCreate or AuditLogActionType.ThreadCreate or AuditLogActionType.GuildScheduledEventCreate => AuditLogActionCategory.Create,
 					AuditLogActionType.ChannelDelete or AuditLogActionType.EmojiDelete or AuditLogActionType.InviteDelete or AuditLogActionType.MessageDelete or AuditLogActionType.MessageBulkDelete or AuditLogActionType.OverwriteDelete or AuditLogActionType.RoleDelete or AuditLogActionType.WebhookDelete or AuditLogActionType.IntegrationDelete or AuditLogActionType.StickerDelete or AuditLogActionType.StageInstanceDelete or AuditLogActionType.ThreadDelete or AuditLogActionType.GuildScheduledEventDelete => AuditLogActionCategory.Delete,
 					AuditLogActionType.ChannelUpdate or AuditLogActionType.EmojiUpdate or AuditLogActionType.InviteUpdate or AuditLogActionType.MemberRoleUpdate or AuditLogActionType.MemberUpdate or AuditLogActionType.OverwriteUpdate or AuditLogActionType.RoleUpdate or AuditLogActionType.WebhookUpdate or AuditLogActionType.IntegrationUpdate or AuditLogActionType.StickerUpdate or AuditLogActionType.StageInstanceUpdate or AuditLogActionType.ThreadUpdate or AuditLogActionType.GuildScheduledEventUpdate => AuditLogActionCategory.Update,
 					_ => AuditLogActionCategory.Other,
 				};
 				entry.Discord = this.Discord;
 				entry.ActionType = xac.ActionType;
 				entry.Id = xac.Id;
 				entry.Reason = xac.Reason;
 				entry.UserResponsible = amd[xac.UserId];
 				entries.Add(entry);
 			}
 
 			return new ReadOnlyCollection<DiscordAuditLogEntry>(entries);
 		}
 
 		/// <summary>
 		/// Gets all of this guild's custom emojis.
 		/// </summary>
 		/// <returns>All of this guild's custom emojis.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordGuildEmoji>> GetEmojisAsync()
 			=> this.Discord.ApiClient.GetGuildEmojisAsync(this.Id);
 
 		/// <summary>
 		/// Gets this guild's specified custom emoji.
 		/// </summary>
 		/// <param name="id">ID of the emoji to get.</param>
 		/// <returns>The requested custom emoji.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildEmoji> GetEmojiAsync(ulong id)
 			=> this.Discord.ApiClient.GetGuildEmojiAsync(this.Id, id);
 
 		/// <summary>
 		/// Creates a new custom emoji for this guild.
 		/// </summary>
 		/// <param name="name">Name of the new emoji.</param>
 		/// <param name="image">Image to use as the emoji.</param>
 		/// <param name="roles">Roles for which the emoji will be available. This works only if your application is whitelisted as integration.</param>
 		/// <param name="reason">Reason for audit log.</param>
 		/// <returns>The newly-created emoji.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildEmoji> CreateEmojiAsync(string name, Stream image, IEnumerable<DiscordRole> roles = null, string reason = null)
 		{
 			if (string.IsNullOrWhiteSpace(name))
 				throw new ArgumentNullException(nameof(name));
 
 			name = name.Trim();
 			if (name.Length < 2 || name.Length > 50)
 				throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.");
 
 			if (image == null)
 				throw new ArgumentNullException(nameof(image));
 
 			string image64 = null;
 			using (var imgtool = new ImageTool(image))
 				image64 = imgtool.GetBase64();
 
 			return this.Discord.ApiClient.CreateGuildEmojiAsync(this.Id, name, image64, roles?.Select(xr => xr.Id), reason);
 		}
 
 		/// <summary>
 		/// Modifies a this guild's custom emoji.
 		/// </summary>
 		/// <param name="emoji">Emoji to modify.</param>
 		/// <param name="name">New name for the emoji.</param>
 		/// <param name="roles">Roles for which the emoji will be available. This works only if your application is whitelisted as integration.</param>
 		/// <param name="reason">Reason for audit log.</param>
 		/// <returns>The modified emoji.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildEmoji> ModifyEmojiAsync(DiscordGuildEmoji emoji, string name, IEnumerable<DiscordRole> roles = null, string reason = null)
 		{
 			if (emoji == null)
 				throw new ArgumentNullException(nameof(emoji));
 
 			if (emoji.Guild.Id != this.Id)
 				throw new ArgumentException("This emoji does not belong to this guild.");
 
 			if (string.IsNullOrWhiteSpace(name))
 				throw new ArgumentNullException(nameof(name));
 
 			name = name.Trim();
 			return name.Length < 2 || name.Length > 50
 				? throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.")
 				: this.Discord.ApiClient.ModifyGuildEmojiAsync(this.Id, emoji.Id, name, roles?.Select(xr => xr.Id), reason);
 		}
 
 		/// <summary>
 		/// Deletes this guild's custom emoji.
 		/// </summary>
 		/// <param name="emoji">Emoji to delete.</param>
 		/// <param name="reason">Reason for audit log.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public Task DeleteEmojiAsync(DiscordGuildEmoji emoji, string reason = null)
-		{
-			return emoji == null
+		public Task DeleteEmojiAsync(DiscordGuildEmoji emoji, string reason = null) =>
+			emoji == null
 				? throw new ArgumentNullException(nameof(emoji))
 				: emoji.Guild.Id != this.Id
-				? throw new ArgumentException("This emoji does not belong to this guild.")
-				: this.Discord.ApiClient.DeleteGuildEmojiAsync(this.Id, emoji.Id, reason);
-		}
+					? throw new ArgumentException("This emoji does not belong to this guild.")
+					: this.Discord.ApiClient.DeleteGuildEmojiAsync(this.Id, emoji.Id, reason);
 
 		/// <summary>
 		/// Gets all of this guild's custom stickers.
 		/// </summary>
 		/// <returns>All of this guild's custom stickers.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<IReadOnlyList<DiscordSticker>> GetStickersAsync()
 		{
 			var stickers = await this.Discord.ApiClient.GetGuildStickersAsync(this.Id);
 
 			foreach (var xstr in stickers)
 			{
 				this.StickersInternal.AddOrUpdate(xstr.Id, xstr, (id, old) =>
 				{
 					old.Name = xstr.Name;
 					old.Description = xstr.Description;
 					old.InternalTags = xstr.InternalTags;
 					return old;
 				});
 			}
 
 			return stickers;
 		}
 
 		/// <summary>
 		/// Gets a sticker
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 		public Task<DiscordSticker> GetStickerAsync(ulong stickerId)
 			=> this.Discord.ApiClient.GetGuildStickerAsync(this.Id, stickerId);
 
 		/// <summary>
 		/// Creates a sticker
 		/// </summary>
 		/// <param name="name">The name of the sticker.</param>
 		/// <param name="description">The optional description of the sticker.</param>
 		/// <param name="emoji">The emoji to associate the sticker with.</param>
 		/// <param name="format">The file format the sticker is written in.</param>
 		/// <param name="file">The sticker.</param>
 		/// <param name="reason">Audit log reason</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordSticker> CreateStickerAsync(string name, string description, DiscordEmoji emoji, Stream file, StickerFormat format, string reason = null)
 		{
 			var fileExt = format switch
 			{
 				StickerFormat.Png => "png",
 				StickerFormat.Apng => "png",
 				StickerFormat.Lottie => "json",
 				_ => throw new InvalidOperationException("This format is not supported.")
 			};
 
 			var contentType = format switch
 			{
 				StickerFormat.Png => "image/png",
 				StickerFormat.Apng => "image/png",
 				StickerFormat.Lottie => "application/json",
 				_ => throw new InvalidOperationException("This format is not supported.")
 			};
 
 			return emoji.Id is not 0
 				? throw new InvalidOperationException("Only unicode emoji can be used for stickers.")
 				: name.Length < 2 || name.Length > 30
 				? throw new ArgumentOutOfRangeException(nameof(name), "Sticker name needs to be between 2 and 30 characters long.")
 				: description.Length < 1 || description.Length > 100
 				? throw new ArgumentOutOfRangeException(nameof(description), "Sticker description needs to be between 1 and 100 characters long.")
-				: this.Discord.ApiClient.CreateGuildStickerAsync(this.Id, name, description, emoji.GetDiscordName().Replace(":", ""), new("sticker", file, null, fileExt, contentType), reason);
+				: this.Discord.ApiClient.CreateGuildStickerAsync(this.Id, name, description, emoji.GetDiscordName().Replace(":", ""), new DiscordMessageFile("sticker", file, null, fileExt, contentType), reason);
 		}
 
 		/// <summary>
 		/// Modifies a sticker
 		/// </summary>
 		/// <param name="sticker">The id of the sticker to modify</param>
 		/// <param name="name">The name of the sticker</param>
 		/// <param name="description">The description of the sticker</param>
 		/// <param name="emoji">The emoji to associate with this sticker.</param>
 		/// <param name="reason">Audit log reason</param>
 		/// <returns>A sticker object</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 		public async Task<DiscordSticker> ModifyStickerAsync(ulong sticker, Optional<string> name, Optional<string> description, Optional<DiscordEmoji> emoji, string reason = null)
 		{
 
 			string uemoji = null;
 
 			if (!this.StickersInternal.TryGetValue(sticker, out var stickerobj) || stickerobj.Guild.Id != this.Id)
 				throw new ArgumentException("This sticker does not belong to this guild.");
 			if (name.HasValue && (name.Value.Length < 2 || name.Value.Length > 30))
 				throw new ArgumentException("Sticker name needs to be between 2 and 30 characters long.");
 			if (description.HasValue && (description.Value.Length < 1 || description.Value.Length > 100))
 				throw new ArgumentException("Sticker description needs to be between 1 and 100 characters long.");
 			if (emoji.HasValue && emoji.Value.Id > 0)
 				throw new ArgumentException("Only unicode emojis can be used with stickers.");
 			else if (emoji.HasValue)
 				uemoji = emoji.Value.GetDiscordName().Replace(":", "");
 
 			var usticker = await this.Discord.ApiClient.ModifyGuildStickerAsync(this.Id, sticker, name, description, uemoji, reason).ConfigureAwait(false);
 
 
 			if (this.StickersInternal.TryGetValue(usticker.Id, out var old))
 				this.StickersInternal.TryUpdate(usticker.Id, usticker, old);
 
 			return usticker;
 		}
 
 		/// <summary>
 		/// Modifies a sticker
 		/// </summary>
 		/// <param name="sticker">The sticker to modify</param>
 		/// <param name="name">The name of the sticker</param>
 		/// <param name="description">The description of the sticker</param>
 		/// <param name="emoji">The emoji to associate with this sticker.</param>
 		/// <param name="reason">Audit log reason</param>
 		/// <returns>A sticker object</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 		public Task<DiscordSticker> ModifyStickerAsync(DiscordSticker sticker, Optional<string> name, Optional<string> description, Optional<DiscordEmoji> emoji, string reason = null)
 			=> this.ModifyStickerAsync(sticker.Id, name, description, emoji, reason);
 
 		/// <summary>
 		/// Deletes a sticker
 		/// </summary>
 		/// <param name="sticker">Id of sticker to delete</param>
 		/// <param name="reason">Audit log reason</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
-		public Task DeleteStickerAsync(ulong sticker, string reason = null)
-		{
-			return !this.StickersInternal.TryGetValue(sticker, out var stickerobj)
+		public Task DeleteStickerAsync(ulong sticker, string reason = null) =>
+			!this.StickersInternal.TryGetValue(sticker, out var stickerobj)
 				? throw new ArgumentNullException(nameof(sticker))
 				: stickerobj.Guild.Id != this.Id
-				? throw new ArgumentException("This sticker does not belong to this guild.")
-				: this.Discord.ApiClient.DeleteGuildStickerAsync(this.Id, sticker, reason);
-		}
+					? throw new ArgumentException("This sticker does not belong to this guild.")
+					: this.Discord.ApiClient.DeleteGuildStickerAsync(this.Id, sticker, reason);
 
 		/// <summary>
 		/// Deletes a sticker
 		/// </summary>
 		/// <param name="sticker">Sticker to delete</param>
 		/// <param name="reason">Audit log reason</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 		public Task DeleteStickerAsync(DiscordSticker sticker, string reason = null)
 			=> this.DeleteStickerAsync(sticker.Id, reason);
 
 		/// <summary>
 		/// <para>Gets the default channel for this guild.</para>
 		/// <para>Default channel is the first channel current member can see.</para>
 		/// </summary>
 		/// <returns>This member's default guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public DiscordChannel GetDefaultChannel()
-		{
-			return this.ChannelsInternal?.Values.Where(xc => xc.Type == ChannelType.Text)
-					.OrderBy(xc => xc.Position)
-					.FirstOrDefault(xc => (xc.PermissionsFor(this.CurrentMember) & DisCatSharp.Permissions.AccessChannels) == DisCatSharp.Permissions.AccessChannels);
-		}
+		public DiscordChannel GetDefaultChannel() =>
+			this.ChannelsInternal?.Values.Where(xc => xc.Type == ChannelType.Text)
+				.OrderBy(xc => xc.Position)
+				.FirstOrDefault(xc => (xc.PermissionsFor(this.CurrentMember) & DisCatSharp.Permissions.AccessChannels) == DisCatSharp.Permissions.AccessChannels);
 
 		/// <summary>
 		/// Gets the guild's widget
 		/// </summary>
 		/// <returns>The guild's widget</returns>
 		public Task<DiscordWidget> GetWidgetAsync()
 			=> this.Discord.ApiClient.GetGuildWidgetAsync(this.Id);
 
 		/// <summary>
 		/// Gets the guild's widget settings
 		/// </summary>
 		/// <returns>The guild's widget settings</returns>
 		public Task<DiscordWidgetSettings> GetWidgetSettingsAsync()
 			=> this.Discord.ApiClient.GetGuildWidgetSettingsAsync(this.Id);
 
 		/// <summary>
 		/// Modifies the guild's widget settings
 		/// </summary>
 		/// <param name="isEnabled">If the widget is enabled or not</param>
 		/// <param name="channel">Widget channel</param>
 		/// <param name="reason">Reason the widget settings were modified</param>
 		/// <returns>The newly modified widget settings</returns>
 		public Task<DiscordWidgetSettings> ModifyWidgetSettingsAsync(bool? isEnabled = null, DiscordChannel channel = null, string reason = null)
 			=> this.Discord.ApiClient.ModifyGuildWidgetSettingsAsync(this.Id, isEnabled, channel?.Id, reason);
 
 		/// <summary>
 		/// Gets all of this guild's templates.
 		/// </summary>
 		/// <returns>All of the guild's templates.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordGuildTemplate>> GetTemplatesAsync()
 			=> this.Discord.ApiClient.GetGuildTemplatesAsync(this.Id);
 
 		/// <summary>
 		/// Creates a guild template.
 		/// </summary>
 		/// <param name="name">Name of the template.</param>
 		/// <param name="description">Description of the template.</param>
 		/// <returns>The template created.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Throws when a template already exists for the guild or a null parameter is provided for the name.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildTemplate> CreateTemplateAsync(string name, string description = null)
 			=> this.Discord.ApiClient.CreateGuildTemplateAsync(this.Id, name, description);
 
 		/// <summary>
 		/// Syncs the template to the current guild's state.
 		/// </summary>
 		/// <param name="code">The code of the template to sync.</param>
 		/// <returns>The template synced.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildTemplate> SyncTemplateAsync(string code)
 			=> this.Discord.ApiClient.SyncGuildTemplateAsync(this.Id, code);
 
 		/// <summary>
 		/// Modifies the template's metadata.
 		/// </summary>
 		/// <param name="code">The template's code.</param>
 		/// <param name="name">Name of the template.</param>
 		/// <param name="description">Description of the template.</param>
 		/// <returns>The template modified.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildTemplate> ModifyTemplateAsync(string code, string name = null, string description = null)
 			=> this.Discord.ApiClient.ModifyGuildTemplateAsync(this.Id, code, name, description);
 
 		/// <summary>
 		/// Deletes the template.
 		/// </summary>
 		/// <param name="code">The code of the template to delete.</param>
 		/// <returns>The deleted template.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildTemplate> DeleteTemplateAsync(string code)
 			=> this.Discord.ApiClient.DeleteGuildTemplateAsync(this.Id, code);
 
 		/// <summary>
 		/// Gets this guild's membership screening form.
 		/// </summary>
 		/// <returns>This guild's membership screening form.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildMembershipScreening> GetMembershipScreeningFormAsync()
 			=> this.Discord.ApiClient.GetGuildMembershipScreeningFormAsync(this.Id);
 
 		/// <summary>
 		/// Modifies this guild's membership screening form.
 		/// </summary>
 		/// <param name="action">Action to perform</param>
 		/// <returns>The modified screening form.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordGuildMembershipScreening> ModifyMembershipScreeningFormAsync(Action<MembershipScreeningEditModel> action)
 		{
 			var mdl = new MembershipScreeningEditModel();
 			action(mdl);
 			return await this.Discord.ApiClient.ModifyGuildMembershipScreeningFormAsync(this.Id, mdl.Enabled, mdl.Fields, mdl.Description);
 		}
 
 		/// <summary>
 		/// Gets all the application commands in this guild.
 		/// </summary>
 		/// <returns>A list of application commands in this guild.</returns>
 		public Task<IReadOnlyList<DiscordApplicationCommand>> GetApplicationCommandsAsync() =>
 			this.Discord.ApiClient.GetGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id);
 
 		/// <summary>
 		/// Overwrites the existing application commands in this guild. New commands are automatically created and missing commands are automatically delete
 		/// </summary>
 		/// <param name="commands">The list of commands to overwrite with.</param>
 		/// <returns>The list of guild commands</returns>
 		public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
 			this.Discord.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id, commands);
 
 		/// <summary>
 		/// Creates or overwrites a application command in this guild.
 		/// </summary>
 		/// <param name="command">The command to create.</param>
 		/// <returns>The created command.</returns>
 		public Task<DiscordApplicationCommand> CreateApplicationCommandAsync(DiscordApplicationCommand command) =>
 			this.Discord.ApiClient.CreateGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, command);
 
 		/// <summary>
 		/// Edits a application command in this guild.
 		/// </summary>
 		/// <param name="commandId">The id of the command to edit.</param>
 		/// <param name="action">Action to perform.</param>
 		/// <returns>The edit command.</returns>
 		public async Task<DiscordApplicationCommand> EditApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
 		{
 			var mdl = new ApplicationCommandEditModel();
 			action(mdl);
 			return await this.Discord.ApiClient.EditGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.DefaultPermission, mdl.NameLocalizations, mdl.DescriptionLocalizations).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Gets this guild's welcome screen.
 		/// </summary>
 		/// <returns>This guild's welcome screen object.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildWelcomeScreen> GetWelcomeScreenAsync() =>
 			this.Discord.ApiClient.GetGuildWelcomeScreenAsync(this.Id);
 
 		/// <summary>
 		/// Modifies this guild's welcome screen.
 		/// </summary>
 		/// <param name="action">Action to perform.</param>
 		/// <returns>The modified welcome screen.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordGuildWelcomeScreen> ModifyWelcomeScreenAsync(Action<WelcomeScreenEditModel> action)
 		{
 			var mdl = new WelcomeScreenEditModel();
 			action(mdl);
 			return await this.Discord.ApiClient.ModifyGuildWelcomeScreenAsync(this.Id, mdl.Enabled, mdl.WelcomeChannels, mdl.Description).ConfigureAwait(false);
 		}
 		#endregion
 
 		/// <summary>
 		/// Returns a string representation of this guild.
 		/// </summary>
 		/// <returns>String representation of this guild.</returns>
 		public override string ToString() => $"Guild {this.Id}; {this.Name}";
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordGuild"/> is equal to another object.
 		/// </summary>
 		/// <param name="obj">Object to compare to.</param>
 		/// <returns>Whether the object is equal to this <see cref="DiscordGuild"/>.</returns>
 		public override bool Equals(object obj) => this.Equals(obj as DiscordGuild);
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordGuild"/> is equal to another <see cref="DiscordGuild"/>.
 		/// </summary>
 		/// <param name="e"><see cref="DiscordGuild"/> to compare to.</param>
 		/// <returns>Whether the <see cref="DiscordGuild"/> is equal to this <see cref="DiscordGuild"/>.</returns>
 		public bool Equals(DiscordGuild e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 		/// <summary>
 		/// Gets the hash code for this <see cref="DiscordGuild"/>.
 		/// </summary>
 		/// <returns>The hash code for this <see cref="DiscordGuild"/>.</returns>
 		public override int GetHashCode() => this.Id.GetHashCode();
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordGuild"/> objects are equal.
 		/// </summary>
 		/// <param name="e1">First guild to compare.</param>
 		/// <param name="e2">Second guild to compare.</param>
 		/// <returns>Whether the two guilds are equal.</returns>
 		public static bool operator ==(DiscordGuild e1, DiscordGuild e2)
 		{
 			var o1 = e1 as object;
 			var o2 = e2 as object;
 
 			return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 		}
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordGuild"/> objects are not equal.
 		/// </summary>
 		/// <param name="e1">First guild to compare.</param>
 		/// <param name="e2">Second guild to compare.</param>
 		/// <returns>Whether the two guilds are not equal.</returns>
 		public static bool operator !=(DiscordGuild e1, DiscordGuild e2)
 			=> !(e1 == e2);
 
 	}
 
 	/// <summary>
 	/// Represents guild verification level.
 	/// </summary>
 	public enum VerificationLevel : int
 	{
 		/// <summary>
 		/// No verification. Anyone can join and chat right away.
 		/// </summary>
 		None = 0,
 
 		/// <summary>
 		/// Low verification level. Users are required to have a verified email attached to their account in order to be able to chat.
 		/// </summary>
 		Low = 1,
 
 		/// <summary>
 		/// Medium verification level. Users are required to have a verified email attached to their account, and account age need to be at least 5 minutes in order to be able to chat.
 		/// </summary>
 		Medium = 2,
 
 		/// <summary>
 		/// High verification level. Users are required to have a verified email attached to their account, account age need to be at least 5 minutes, and they need to be in the server for at least 10 minutes in order to be able to chat.
 		/// </summary>
 		High = 3,
 
 		/// <summary>
 		/// Highest verification level. Users are required to have a verified phone number attached to their account.
 		/// </summary>
 		Highest = 4
 	}
 
 	/// <summary>
 	/// Represents default notification level for a guild.
 	/// </summary>
 	public enum DefaultMessageNotifications : int
 	{
 		/// <summary>
 		/// All messages will trigger push notifications.
 		/// </summary>
 		AllMessages = 0,
 
 		/// <summary>
 		/// Only messages that mention the user (or a role he's in) will trigger push notifications.
 		/// </summary>
 		MentionsOnly = 1
 	}
 
 	/// <summary>
 	/// Represents multi-factor authentication level required by a guild to use administrator functionality.
 	/// </summary>
 	public enum MfaLevel : int
 	{
 		/// <summary>
 		/// Multi-factor authentication is not required to use administrator functionality.
 		/// </summary>
 		Disabled = 0,
 
 		/// <summary>
 		/// Multi-factor authentication is required to use administrator functionality.
 		/// </summary>
 		Enabled = 1
 	}
 
 	/// <summary>
 	/// Represents the value of explicit content filter in a guild.
 	/// </summary>
 	public enum ExplicitContentFilter : int
 	{
 		/// <summary>
 		/// Explicit content filter is disabled.
 		/// </summary>
 		Disabled = 0,
 
 		/// <summary>
 		/// Only messages from members without any roles are scanned.
 		/// </summary>
 		MembersWithoutRoles = 1,
 
 		/// <summary>
 		/// Messages from all members are scanned.
 		/// </summary>
 		AllMembers = 2
 	}
 
 	/// <summary>
 	/// Represents the formats for a guild widget.
 	/// </summary>
 	public enum WidgetType : int
 	{
 		/// <summary>
 		/// The widget is represented in shield format.
 		/// <para>This is the default widget type.</para>
 		/// </summary>
 		Shield = 0,
 
 		/// <summary>
 		/// The widget is represented as the first banner type.
 		/// </summary>
 		Banner1 = 1,
 
 		/// <summary>
 		/// The widget is represented as the second banner type.
 		/// </summary>
 		Banner2 = 2,
 
 		/// <summary>
 		/// The widget is represented as the third banner type.
 		/// </summary>
 		Banner3 = 3,
 
 		/// <summary>
 		/// The widget is represented in the fourth banner type.
 		/// </summary>
 		Banner4 = 4
 	}
 
 	/// <summary>
 	/// Represents the guild features.
 	/// </summary>
 	public class GuildFeatures
 	{
 		/// <summary>
 		/// Guild has access to set an animated guild icon.
 		/// </summary>
 		public bool CanSetAnimatedIcon { get; }
 
 		/// <summary>
 		/// Guild has access to set a guild banner image.
 		/// </summary>
 		public bool CanSetBanner { get; }
 
 		/// <summary>
 		/// Guild has access to use commerce features (i.e. create store channels)
 		/// </summary>
 		public bool CanCreateStoreChannels { get; }
 
 		/// <summary>
 		/// Guild can enable Welcome Screen, Membership Screening, Stage Channels, News Channels and receives community updates.
 		/// Furthermore the guild can apply as a partner and for the discovery (if the prerequisites are given).
 		/// <see cref="ChannelType.Stage"/> and <see cref="ChannelType.News"/> is usable.
 		/// </summary>
 		public bool HasCommunityEnabled { get; }
 
 		/// <summary>
 		/// Guild is able to be discovered in the discovery.
 		/// </summary>
 		public bool IsDiscoverable { get; }
 
 		/// <summary>
 		/// Guild is able to be featured in the discovery.
 		/// </summary>
 		public bool IsFeatureable { get; }
 
 		/// <summary>
 		/// Guild has access to set an invite splash background.
 		/// </summary>
 		public bool CanSetInviteSplash { get; }
 
 		/// <summary>
 		/// Guild has enabled Membership Screening.
 		/// </summary>
 		public bool HasMembershipScreeningEnabled { get; }
 
 		/// <summary>
 		/// Guild has access to create news channels.
 		/// <see cref="ChannelType.News"/> is usable.
 		/// </summary>
 		public bool CanCreateNewsChannels { get; }
 
 		/// <summary>
 		/// Guild is partnered.
 		/// </summary>
 		public bool IsPartnered { get; }
 
 		/// <summary>
 		/// Guild has increased custom emoji slots.
 		/// </summary>
 		public bool CanUploadMoreEmojis { get; }
 
 		/// <summary>
 		/// Guild can be previewed before joining via Membership Screening or the discovery.
 		/// </summary>
 		public bool HasPreviewEnabled { get; }
 
 		/// <summary>
 		/// Guild has access to set a vanity URL.
 		/// </summary>
 		public bool CanSetVanityUrl { get; }
 
 		/// <summary>
 		/// Guild is verified.
 		/// </summary>
 		public bool IsVerified { get; }
 
 		/// <summary>
 		/// Guild has access to set 384kbps bitrate in voice (previously VIP voice servers).
 		/// </summary>
 		public bool CanAccessVipRegions { get; }
 
 		/// <summary>
 		/// Guild has enabled the welcome screen.
 		/// </summary>
 		public bool HasWelcomeScreenEnabled { get; }
 
 		/// <summary>
 		/// Guild has enabled ticketed events.
 		/// </summary>
 		public bool HasTicketedEventsEnabled { get; }
 
 		/// <summary>
 		/// Guild has enabled monetization.
 		/// </summary>
 		public bool HasMonetizationEnabled { get; }
 
 		/// <summary>
 		/// Guild has increased custom sticker slots.
 		/// </summary>
 		public bool CanUploadMoreStickers { get; }
 
 		/// <summary>
 		/// Guild has access to the three day archive time for threads.
 		/// Needs Premium Tier 1 (<see cref="PremiumTier.TierOne"/>).
 		/// </summary>
 		public bool CanSetThreadArchiveDurationThreeDays { get; }
 
 		/// <summary>
 		/// Guild has access to the seven day archive time for threads.
 		/// Needs Premium Tier 2 (<see cref="PremiumTier.TierTwo"/>).
 		/// </summary>
 		public bool CanSetThreadArchiveDurationSevenDays { get; }
 
 		/// <summary>
 		/// Guild has access to create private threads.
 		/// Needs Premium Tier 2 (<see cref="PremiumTier.TierTwo"/>).
 		/// </summary>
 		public bool CanCreatePrivateThreads { get; }
 
 		/// <summary>
 		/// Guild is a hub.
 		/// <see cref="ChannelType.GuildDirectory"/> is usable.
 		/// </summary>
 		public bool IsHub { get; }
 
 		/// <summary>
 		/// Guild is in a hub.
 		/// https://github.com/discord/discord-api-docs/pull/3757/commits/4932d92c9d0c783861bc715bf7ebbabb15114e34
 		/// </summary>
 		public bool HasDirectoryEntry { get; }
 
 		/// <summary>
 		/// Guild is linked to a hub.
 		/// </summary>
 		public bool IsLinkedToHub { get; }
 
 		/// <summary>
 		/// Guild has full access to threads.
 		/// Old Feature.
 		/// </summary>
 		public bool HasThreadTestingEnabled { get; }
 
 		/// <summary>
 		/// Guild has access to threads.
 		/// </summary>
 		public bool HasThreadsEnabled { get; }
 
 		/// <summary>
 		/// Guild can set role icons.
 		/// </summary>
 		public bool CanSetRoleIcons { get; }
 
 		/// <summary>
 		/// Guild has the new thread permissions.
 		/// Old Feature.
 		/// </summary>
 		public bool HasNewThreadPermissions { get; }
 
 		/// <summary>
 		/// Guild can set thread default auto archive duration.
 		/// Old Feature.
 		/// </summary>
 		public bool CanSetThreadDefaultAutoArchiveDuration { get; }
 
 		/// <summary>
 		/// Guild has enabled role subsriptions.
 		/// </summary>
 		public bool HasRoleSubscriptionsEnabled { get; }
 
 		/// <summary>
 		/// Guild role subsriptions as purchaseable.
 		/// </summary>
 		public bool RoleSubscriptionsIsAvaiableForPurchase { get; }
 
 		/// <summary>
 		/// Guild has premium tier 3 override.
 		/// </summary>
 		public bool PremiumTierThreeOverride { get; }
 
 		/// <summary>
 		/// Guild has access to text in voice.
 		/// Restricted to <see cref="IsStaffOnly"/>.
 		/// </summary>
 		public bool TextInVoiceEnabled { get; }
 
 		/// <summary>
 		/// Guild can set an animated banner.
 		/// Needs Premium Tier 3 (<see cref="PremiumTier.TierThree"/>).
 		/// </summary>
 		public bool CanSetAnimatedBanner { get; }
 
 		/// <summary>
 		/// Guild can set an animated banner.
 		/// Needs Premium Tier 3 (<see cref="PremiumTier.TierThree"/>).
 		/// </summary>
 		public bool CanSetChannelBanner { get; }
 
 		/// <summary>
 		/// Allows members to customize their avatar, banner and bio for that server.
 		/// </summary>
 		public bool HasMemberProfiles { get; }
 
 		/// <summary>
 		/// Guild is restricted to users with the <see cref="UserFlags.Staff"/> badge.
 		/// </summary>
 		public bool IsStaffOnly { get; }
 
 		/// <summary>
 		/// String of guild features.
 		/// </summary>
 		public string FeatureString { get; }
 
 		/// <summary>
 		/// Checks the guild features and constructs a new <see cref="GuildFeatures"/> object.
 		/// </summary>
 		/// <param name="guild">Guild to check</param>
 		public GuildFeatures(DiscordGuild guild)
 		{
 			this.CanSetAnimatedIcon = guild.RawFeatures.Contains("ANIMATED_ICON");
 			this.CanSetAnimatedBanner = guild.RawFeatures.Contains("ANIMATED_BANNER");
 			this.CanSetBanner = guild.RawFeatures.Contains("BANNER");
 			this.CanSetChannelBanner = guild.RawFeatures.Contains("CHANNEL_BANNER");
 			this.CanCreateStoreChannels = guild.RawFeatures.Contains("COMMERCE");
 			this.HasCommunityEnabled = guild.RawFeatures.Contains("COMMUNITY");
 			this.IsDiscoverable = !guild.RawFeatures.Contains("DISCOVERABLE_DISABLED") && guild.RawFeatures.Contains("DISCOVERABLE");
 			this.IsFeatureable = guild.RawFeatures.Contains("FEATURABLE");
 			this.CanSetInviteSplash = guild.RawFeatures.Contains("INVITE_SPLASH");
 			this.HasMembershipScreeningEnabled = guild.RawFeatures.Contains("MEMBER_VERIFICATION_GATE_ENABLED");
 			this.CanCreateNewsChannels = guild.RawFeatures.Contains("NEWS");
 			this.IsPartnered = guild.RawFeatures.Contains("PARTNERED");
 			this.CanUploadMoreEmojis = guild.RawFeatures.Contains("MORE_EMOJI");
 			this.HasPreviewEnabled = guild.RawFeatures.Contains("PREVIEW_ENABLED");
 			this.CanSetVanityUrl = guild.RawFeatures.Contains("VANITY_URL");
 			this.IsVerified = guild.RawFeatures.Contains("VERIFIED");
 			this.CanAccessVipRegions = guild.RawFeatures.Contains("VIP_REGIONS");
 			this.HasWelcomeScreenEnabled = guild.RawFeatures.Contains("WELCOME_SCREEN_ENABLED");
 			this.HasTicketedEventsEnabled = guild.RawFeatures.Contains("TICKETED_EVENTS_ENABLED");
 			this.HasMonetizationEnabled = guild.RawFeatures.Contains("MONETIZATION_ENABLED");
 			this.CanUploadMoreStickers = guild.RawFeatures.Contains("MORE_STICKERS");
 			this.CanSetThreadArchiveDurationThreeDays = guild.RawFeatures.Contains("THREE_DAY_THREAD_ARCHIVE");
 			this.CanSetThreadArchiveDurationSevenDays = guild.RawFeatures.Contains("SEVEN_DAY_THREAD_ARCHIVE");
 			this.CanCreatePrivateThreads = guild.RawFeatures.Contains("PRIVATE_THREADS");
 			this.IsHub = guild.RawFeatures.Contains("HUB");
 			this.HasThreadTestingEnabled = guild.RawFeatures.Contains("THREADS_ENABLED_TESTING");
 			this.HasThreadsEnabled = guild.RawFeatures.Contains("THREADS_ENABLED");
 			this.CanSetRoleIcons = guild.RawFeatures.Contains("ROLE_ICONS");
 			this.HasNewThreadPermissions = guild.RawFeatures.Contains("NEW_THREAD_PERMISSIONS");
 			this.HasRoleSubscriptionsEnabled = guild.RawFeatures.Contains("ROLE_SUBSCRIPTIONS_ENABLED");
 			this.PremiumTierThreeOverride = guild.RawFeatures.Contains("PREMIUM_TIER_3_OVERRIDE");
 			this.CanSetThreadDefaultAutoArchiveDuration = guild.RawFeatures.Contains("THREAD_DEFAULT_AUTO_ARCHIVE_DURATION");
 			this.TextInVoiceEnabled = guild.RawFeatures.Contains("TEXT_IN_VOICE_ENABLED");
 			this.HasDirectoryEntry = guild.RawFeatures.Contains("HAS_DIRECTORY_ENTRY");
 			this.IsLinkedToHub = guild.RawFeatures.Contains("LINKED_TO_HUB");
 			this.HasMemberProfiles = guild.RawFeatures.Contains("MEMBER_PROFILES");
 			this.IsStaffOnly = guild.RawFeatures.Contains("INTERNAL_EMPLOYEE_ONLY");
 			this.RoleSubscriptionsIsAvaiableForPurchase = guild.RawFeatures.Contains("ROLE_SUBSCRIPTIONS_AVAILABLE_FOR_PURCHASE");
 
 			var features = guild.RawFeatures.Any() ? "" : "None";
 			foreach (var feature in guild.RawFeatures)
 			{
 				features += feature + " ";
 			}
 			this.FeatureString = features;
 
 		}
 	}
 }
diff --git a/DisCatSharp/Entities/Interaction/DiscordInteractionDataOption.cs b/DisCatSharp/Entities/Interaction/DiscordInteractionDataOption.cs
index f6ae1e3b3..5ddcd3746 100644
--- a/DisCatSharp/Entities/Interaction/DiscordInteractionDataOption.cs
+++ b/DisCatSharp/Entities/Interaction/DiscordInteractionDataOption.cs
@@ -1,92 +1,87 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents parameters for interaction commands.
 	/// </summary>
 	public sealed class DiscordInteractionDataOption
 	{
 		/// <summary>
 		/// Gets the name of this interaction parameter.
 		/// </summary>
 		[JsonProperty("name")]
 		public string Name { get; internal set; }
 
 		/// <summary>
 		/// Gets the type of this interaction parameter.
 		/// </summary>
 		[JsonProperty("type")]
 		public ApplicationCommandOptionType Type { get; internal set; }
 
 		/// <summary>
 		/// Whether this option is currently focused by the user.
 		/// Only applicable for autocomplete option choices.
 		/// </summary>
 		[JsonProperty("focused")]
 		public bool Focused { get; internal set; }
 
 		/// <summary>
 		/// Gets the value of this interaction parameter.
 		/// </summary>
 		[JsonProperty("value")]
 		internal string RawValue { get; set; }
 
 		/// <summary>
 		/// Gets the value of this interaction parameter.
 		/// <para>This can be cast to a <see langword="long"/>, <see langword="bool"></see>, <see langword="string"></see>, <see langword="double"></see> or <see langword="ulong"/> depending on the <see cref="System.Type"/></para>
 		/// </summary>
 		[JsonIgnore]
-		public object Value
-		{
-			get
-			{
-				return this.Type == ApplicationCommandOptionType.Integer && int.TryParse(this.RawValue, out var raw)
-					? raw
-					: this.Type == ApplicationCommandOptionType.Integer
-						? long.Parse(this.RawValue)
-						: this.Type switch
-						{
-							ApplicationCommandOptionType.Boolean => bool.Parse(this.RawValue),
-							ApplicationCommandOptionType.String => this.RawValue,
-							ApplicationCommandOptionType.Channel => ulong.Parse(this.RawValue),
-							ApplicationCommandOptionType.User => ulong.Parse(this.RawValue),
-							ApplicationCommandOptionType.Role => ulong.Parse(this.RawValue),
-							ApplicationCommandOptionType.Mentionable => ulong.Parse(this.RawValue),
-							ApplicationCommandOptionType.Number => double.Parse(this.RawValue),
-							ApplicationCommandOptionType.Attachment => int.Parse(this.RawValue),
-							_ => this.RawValue,
-						};
-			}
-		}
+		public object Value =>
+			this.Type == ApplicationCommandOptionType.Integer && int.TryParse(this.RawValue, out var raw)
+				? raw
+				: this.Type == ApplicationCommandOptionType.Integer
+					? long.Parse(this.RawValue)
+					: this.Type switch
+					{
+						ApplicationCommandOptionType.Boolean => bool.Parse(this.RawValue),
+						ApplicationCommandOptionType.String => this.RawValue,
+						ApplicationCommandOptionType.Channel => ulong.Parse(this.RawValue),
+						ApplicationCommandOptionType.User => ulong.Parse(this.RawValue),
+						ApplicationCommandOptionType.Role => ulong.Parse(this.RawValue),
+						ApplicationCommandOptionType.Mentionable => ulong.Parse(this.RawValue),
+						ApplicationCommandOptionType.Number => double.Parse(this.RawValue),
+						ApplicationCommandOptionType.Attachment => int.Parse(this.RawValue),
+						_ => this.RawValue,
+					};
 
 		/// <summary>
 		/// Gets the additional parameters if this parameter is a subcommand.
 		/// </summary>
 		[JsonProperty("options", NullValueHandling = NullValueHandling.Ignore)]
 		public IEnumerable<DiscordInteractionDataOption> Options { get; internal set; }
 	}
 }
diff --git a/DisCatSharp/Entities/Message/DiscordMessage.cs b/DisCatSharp/Entities/Message/DiscordMessage.cs
index cc67e59dc..cb5acb60e 100644
--- a/DisCatSharp/Entities/Message/DiscordMessage.cs
+++ b/DisCatSharp/Entities/Message/DiscordMessage.cs
@@ -1,888 +1,886 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a Discord text message.
 	/// </summary>
 	public class DiscordMessage : SnowflakeObject, IEquatable<DiscordMessage>
 	{
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordMessage"/> class.
 		/// </summary>
 		internal DiscordMessage()
 		{
 			this._attachmentsLazy = new Lazy<IReadOnlyList<DiscordAttachment>>(() => new ReadOnlyCollection<DiscordAttachment>(this.AttachmentsInternal));
 			this._embedsLazy = new Lazy<IReadOnlyList<DiscordEmbed>>(() => new ReadOnlyCollection<DiscordEmbed>(this.EmbedsInternal));
 			this._mentionedChannelsLazy = new Lazy<IReadOnlyList<DiscordChannel>>(() => this.MentionedChannelsInternal != null
 					? new ReadOnlyCollection<DiscordChannel>(this.MentionedChannelsInternal)
 					: Array.Empty<DiscordChannel>());
 			this._mentionedRolesLazy = new Lazy<IReadOnlyList<DiscordRole>>(() => this.MentionedRolesInternal != null ? new ReadOnlyCollection<DiscordRole>(this.MentionedRolesInternal) : Array.Empty<DiscordRole>());
 			this.MentionedUsersLazy = new Lazy<IReadOnlyList<DiscordUser>>(() => new ReadOnlyCollection<DiscordUser>(this.MentionedUsersInternal));
 			this._reactionsLazy = new Lazy<IReadOnlyList<DiscordReaction>>(() => new ReadOnlyCollection<DiscordReaction>(this.ReactionsInternal));
 			this._stickersLazy = new Lazy<IReadOnlyList<DiscordSticker>>(() => new ReadOnlyCollection<DiscordSticker>(this.StickersInternal));
 			this._jumpLink = new Lazy<Uri>(() =>
 			{
 				var gid = this.Channel != null
 					? this.Channel is DiscordDmChannel ? "@me" : this.Channel.GuildId.Value.ToString(CultureInfo.InvariantCulture)
 					: this.INTERNAL_THREAD.GuildId.Value.ToString(CultureInfo.InvariantCulture);
 				var cid = this.ChannelId.ToString(CultureInfo.InvariantCulture);
 				var mid = this.Id.ToString(CultureInfo.InvariantCulture);
 
 				return new Uri($"https://{(this.Discord.Configuration.UseCanary ? "canary.discord.com" : "discord.com")}/channels/{gid}/{cid}/{mid}");
 			});
 		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordMessage"/> class.
 		/// </summary>
 		/// <param name="other">The other.</param>
 		internal DiscordMessage(DiscordMessage other)
 			: this()
 		{
 			this.Discord = other.Discord;
 
 			this.AttachmentsInternal = other.AttachmentsInternal; // the attachments cannot change, thus no need to copy and reallocate.
 			this.EmbedsInternal = new List<DiscordEmbed>(other.EmbedsInternal);
 
 			if (other.MentionedChannelsInternal != null)
 				this.MentionedChannelsInternal = new List<DiscordChannel>(other.MentionedChannelsInternal);
 			if (other.MentionedRolesInternal != null)
 				this.MentionedRolesInternal = new List<DiscordRole>(other.MentionedRolesInternal);
 			if (other.MentionedRoleIds != null)
 				this.MentionedRoleIds = new List<ulong>(other.MentionedRoleIds);
 			this.MentionedUsersInternal = new List<DiscordUser>(other.MentionedUsersInternal);
 			this.ReactionsInternal = new List<DiscordReaction>(other.ReactionsInternal);
 			this.StickersInternal = new List<DiscordSticker>(other.StickersInternal);
 
 			this.Author = other.Author;
 			this.ChannelId = other.ChannelId;
 			this.Content = other.Content;
 			this.EditedTimestampRaw = other.EditedTimestampRaw;
 			this.Id = other.Id;
 			this.IsTts = other.IsTts;
 			this.MessageType = other.MessageType;
 			this.Pinned = other.Pinned;
 			this.TimestampRaw = other.TimestampRaw;
 			this.WebhookId = other.WebhookId;
 		}
 
 		/// <summary>
 		/// Gets the channel in which the message was sent.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordChannel Channel
 		{
 			get => (this.Discord as DiscordClient)?.InternalGetCachedChannel(this.ChannelId) ?? this._channel;
 			internal set => this._channel = value;
 		}
 
 		private DiscordChannel _channel;
 
 		/// <summary>
 		/// Gets the thread in which the message was sent.
 		/// </summary>
 		[JsonIgnore]
 		private DiscordThreadChannel INTERNAL_THREAD
 		{
 			get => (this.Discord as DiscordClient)?.InternalGetCachedThread(this.ChannelId) ?? this._thread;
 			set => this._thread = value;
 		}
 
 		private DiscordThreadChannel _thread;
 
 		/// <summary>
 		/// Gets the ID of the channel in which the message was sent.
 		/// </summary>
 		[JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong ChannelId { get; internal set; }
 
 
 		/// <summary>
 		/// Gets the components this message was sent with.
 		/// </summary>
 		[JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
 		public IReadOnlyCollection<DiscordActionRowComponent> Components { get; internal set; }
 
 		/// <summary>
 		/// Gets the user or member that sent the message.
 		/// </summary>
 		[JsonProperty("author", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordUser Author { get; internal set; }
 
 		/// <summary>
 		/// Gets the message's content.
 		/// </summary>
 		[JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
 		public string Content { get; internal set; }
 
 		/// <summary>
 		/// Gets the message's creation timestamp.
 		/// </summary>
 		[JsonIgnore]
 		public DateTimeOffset Timestamp
 			=> !string.IsNullOrWhiteSpace(this.TimestampRaw) && DateTimeOffset.TryParse(this.TimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 				dto : this.CreationTimestamp;
 
 		/// <summary>
 		/// Gets the message's creation timestamp as raw string.
 		/// </summary>
 		[JsonProperty("timestamp", NullValueHandling = NullValueHandling.Ignore)]
 		internal string TimestampRaw { get; set; }
 
 		/// <summary>
 		/// Gets the message's edit timestamp. Will be null if the message was not edited.
 		/// </summary>
 		[JsonIgnore]
 		public DateTimeOffset? EditedTimestamp
 			=> !string.IsNullOrWhiteSpace(this.EditedTimestampRaw) && DateTimeOffset.TryParse(this.EditedTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 				(DateTimeOffset?)dto : null;
 
 		/// <summary>
 		/// Gets the message's edit timestamp as raw string. Will be null if the message was not edited.
 		/// </summary>
 		[JsonProperty("edited_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 		internal string EditedTimestampRaw { get; set; }
 
 		/// <summary>
 		/// Gets whether this message was edited.
 		/// </summary>
 		[JsonIgnore]
 		public bool IsEdited
 			=> !string.IsNullOrWhiteSpace(this.EditedTimestampRaw);
 
 		/// <summary>
 		/// Gets whether the message is a text-to-speech message.
 		/// </summary>
 		[JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
 		public bool IsTts { get; internal set; }
 
 		/// <summary>
 		/// Gets whether the message mentions everyone.
 		/// </summary>
 		[JsonProperty("mention_everyone", NullValueHandling = NullValueHandling.Ignore)]
 		public bool MentionEveryone { get; internal set; }
 
 		/// <summary>
 		/// Gets users or members mentioned by this message.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyList<DiscordUser> MentionedUsers
 			=> this.MentionedUsersLazy.Value;
 
 		[JsonProperty("mentions", NullValueHandling = NullValueHandling.Ignore)]
 		internal List<DiscordUser> MentionedUsersInternal;
 		[JsonIgnore]
 		internal readonly Lazy<IReadOnlyList<DiscordUser>> MentionedUsersLazy;
 
 		// TODO this will probably throw an exception in DMs since it tries to wrap around a null List...
 		// this is probably low priority but need to find out a clean way to solve it...
 		/// <summary>
 		/// Gets roles mentioned by this message.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyList<DiscordRole> MentionedRoles
 			=> this._mentionedRolesLazy.Value;
 
 		[JsonIgnore]
 		internal List<DiscordRole> MentionedRolesInternal;
 
 		[JsonProperty("mention_roles")]
 		internal List<ulong> MentionedRoleIds;
 
 		[JsonIgnore]
 		private readonly Lazy<IReadOnlyList<DiscordRole>> _mentionedRolesLazy;
 
 		/// <summary>
 		/// Gets channels mentioned by this message.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyList<DiscordChannel> MentionedChannels
 			=> this._mentionedChannelsLazy.Value;
 
 		[JsonIgnore]
 		internal List<DiscordChannel> MentionedChannelsInternal;
 		[JsonIgnore]
 		private readonly Lazy<IReadOnlyList<DiscordChannel>> _mentionedChannelsLazy;
 
 		/// <summary>
 		/// Gets files attached to this message.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyList<DiscordAttachment> Attachments
 			=> this._attachmentsLazy.Value;
 
 		[JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
 		internal List<DiscordAttachment> AttachmentsInternal = new();
 		[JsonIgnore]
 		private readonly Lazy<IReadOnlyList<DiscordAttachment>> _attachmentsLazy;
 
 		/// <summary>
 		/// Gets embeds attached to this message.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyList<DiscordEmbed> Embeds
 			=> this._embedsLazy.Value;
 
 		[JsonProperty("embeds", NullValueHandling = NullValueHandling.Ignore)]
 		internal List<DiscordEmbed> EmbedsInternal = new();
 		[JsonIgnore]
 		private readonly Lazy<IReadOnlyList<DiscordEmbed>> _embedsLazy;
 
 		/// <summary>
 		/// Gets reactions used on this message.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyList<DiscordReaction> Reactions
 			=> this._reactionsLazy.Value;
 
 		[JsonProperty("reactions", NullValueHandling = NullValueHandling.Ignore)]
 		internal List<DiscordReaction> ReactionsInternal = new();
 		[JsonIgnore]
 		private readonly Lazy<IReadOnlyList<DiscordReaction>> _reactionsLazy;
 
 		/*
         /// <summary>
         /// Gets the nonce sent with the message, if the message was sent by the client.
         /// </summary>
         [JsonProperty("nonce", NullValueHandling = NullValueHandling.Ignore)]
         public ulong? Nonce { get; internal set; }
         */
 
 		/// <summary>
 		/// Gets whether the message is pinned.
 		/// </summary>
 		[JsonProperty("pinned", NullValueHandling = NullValueHandling.Ignore)]
 		public bool Pinned { get; internal set; }
 
 		/// <summary>
 		/// Gets the id of the webhook that generated this message.
 		/// </summary>
 		[JsonProperty("webhook_id", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong? WebhookId { get; internal set; }
 
 		/// <summary>
 		/// Gets the type of the message.
 		/// </summary>
 		[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 		public MessageType? MessageType { get; internal set; }
 
 		/// <summary>
 		/// Gets the message activity in the Rich Presence embed.
 		/// </summary>
 		[JsonProperty("activity", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordMessageActivity Activity { get; internal set; }
 
 		/// <summary>
 		/// Gets the message application in the Rich Presence embed.
 		/// </summary>
 		[JsonProperty("application", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordMessageApplication Application { get; internal set; }
 
 		/// <summary>
 		/// Gets the message application id in the Rich Presence embed.
 		/// </summary>
 		[JsonProperty("application_id", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong ApplicationId { get; internal set; }
 
 
 		/// <summary>
 		/// Gets the internal reference.
 		/// </summary>
 		[JsonProperty("message_reference", NullValueHandling = NullValueHandling.Ignore)]
 		internal InternalDiscordMessageReference? InternalReference { get; set; }
 
 		/// <summary>
 		/// Gets the original message reference from the crossposted message.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordMessageReference Reference
 			=> this.InternalReference.HasValue ? this?.InternalBuildMessageReference() : null;
 
 		/// <summary>
 		/// Gets the bitwise flags for this message.
 		/// </summary>
 		[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 		public MessageFlags? Flags { get; internal set; }
 
 		/// <summary>
 		/// Gets whether the message originated from a webhook.
 		/// </summary>
 		[JsonIgnore]
 		public bool WebhookMessage
 			=> this.WebhookId != null;
 
 		/// <summary>
 		/// Gets the jump link to this message.
 		/// </summary>
 		[JsonIgnore]
 		public Uri JumpLink => this._jumpLink.Value;
 		private readonly Lazy<Uri> _jumpLink;
 
 		/// <summary>
 		/// Gets stickers for this message.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyList<DiscordSticker> Stickers
 			=> this._stickersLazy.Value;
 
 		[JsonProperty("sticker_items", NullValueHandling = NullValueHandling.Ignore)]
 		internal List<DiscordSticker> StickersInternal = new();
 		[JsonIgnore]
 		private readonly Lazy<IReadOnlyList<DiscordSticker>> _stickersLazy;
 
 		/// <summary>
 		/// Gets the guild id.
 		/// </summary>
 		[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 		internal ulong? GuildId { get; set; }
 
 		/// <summary>
 		/// Gets the message object for the referenced message
 		/// </summary>
 		[JsonProperty("referenced_message", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordMessage ReferencedMessage { get; internal set; }
 
 		/// <summary>
 		/// Gets whether the message is a response to an interaction.
 		/// </summary>
 		[JsonProperty("interaction", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordMessageInteraction Interaction { get; internal set; }
 
 		/// <summary>
 		/// Gets the thread that was started from this message.
 		/// </summary>
 		[JsonProperty("thread", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordThreadChannel Thread { get; internal set; }
 
 		/// <summary>
 		/// Build the message reference.
 		/// </summary>
 		internal DiscordMessageReference InternalBuildMessageReference()
 		{
 			var client = this.Discord as DiscordClient;
 			var guildId = this.InternalReference.Value.GuildId;
 			var channelId = this.InternalReference.Value.ChannelId;
 			var messageId = this.InternalReference.Value.MessageId;
 
 			var reference = new DiscordMessageReference();
 
 			if (guildId.HasValue)
 				reference.Guild = client.GuildsInternal.TryGetValue(guildId.Value, out var g)
 					? g
 					: new DiscordGuild
 					{
 						Id = guildId.Value,
 						Discord = client
 					};
 
 			var channel = client.InternalGetCachedChannel(channelId.Value);
 
 			if (channel == null)
 			{
 				reference.Channel = new DiscordChannel
 				{
 					Id = channelId.Value,
 					Discord = client
 				};
 
 				if (guildId.HasValue)
 					reference.Channel.GuildId = guildId.Value;
 			}
 
 			else reference.Channel = channel;
 
 			if (client.MessageCache != null && client.MessageCache.TryGet(m => m.Id == messageId.Value && m.ChannelId == channelId, out var msg))
 				reference.Message = msg;
 
 			else
 			{
 				reference.Message = new DiscordMessage
 				{
 					ChannelId = this.ChannelId,
 					Discord = client
 				};
 
 				if (messageId.HasValue)
 					reference.Message.Id = messageId.Value;
 			}
 
 			return reference;
 		}
 
 
 		/// <summary>
 		/// Gets the mentions.
 		/// </summary>
 		/// <returns>An array of IMentions.</returns>
 		private IMention[] GetMentions()
 		{
 			var mentions = new List<IMention>();
 
 			if (this.ReferencedMessage != null && this.MentionedUsersInternal.Contains(this.ReferencedMessage.Author))
 				mentions.Add(new RepliedUserMention()); // Return null to allow all mentions
 
 			if (this.MentionedUsersInternal.Any())
 				mentions.AddRange(this.MentionedUsersInternal.Select(m => (IMention)new UserMention(m)));
 
 			if (this.MentionedRoleIds.Any())
 				mentions.AddRange(this.MentionedRoleIds.Select(r => (IMention)new RoleMention(r)));
 
 			return mentions.ToArray();
 		}
 
 		/// <summary>
 		/// Populates the mentions.
 		/// </summary>
 		internal void PopulateMentions()
 		{
 			var guild = this.Channel?.Guild;
 			this.MentionedUsersInternal ??= new List<DiscordUser>();
 			this.MentionedRolesInternal ??= new List<DiscordRole>();
 			this.MentionedChannelsInternal ??= new List<DiscordChannel>();
 
 			var mentionedUsers = new HashSet<DiscordUser>(new DiscordUserComparer());
 			if (guild != null)
 			{
 				foreach (var usr in this.MentionedUsersInternal)
 				{
 					usr.Discord = this.Discord;
 					this.Discord.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 					{
 						old.Username = usr.Username;
 						old.Discriminator = usr.Discriminator;
 						old.AvatarHash = usr.AvatarHash;
 						return old;
 					});
 
 					mentionedUsers.Add(guild.MembersInternal.TryGetValue(usr.Id, out var member) ? member : usr);
 				}
 			}
 			if (!string.IsNullOrWhiteSpace(this.Content))
 			{
 				//mentionedUsers.UnionWith(Utilities.GetUserMentions(this).Select(this.Discord.GetCachedOrEmptyUserInternal));
 				if (guild != null)
 				{
 					//this._mentionedRoles = this._mentionedRoles.Union(Utilities.GetRoleMentions(this).Select(xid => guild.GetRole(xid))).ToList();
 					this.MentionedRolesInternal = this.MentionedRolesInternal.Union(this.MentionedRoleIds.Select(xid => guild.GetRole(xid))).ToList();
 					this.MentionedChannelsInternal = this.MentionedChannelsInternal.Union(Utilities.GetChannelMentions(this).Select(xid => guild.GetChannel(xid))).ToList();
 				}
 			}
 
 			this.MentionedUsersInternal = mentionedUsers.ToList();
 		}
 
 		/// <summary>
 		/// Edits the message.
 		/// </summary>
 		/// <param name="content">New content.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> ModifyAsync(Optional<string> content)
 			=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, default, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 		/// <summary>
 		/// Edits the message.
 		/// </summary>
 		/// <param name="embed">New embed.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> ModifyAsync(Optional<DiscordEmbed> embed = default)
 			=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, embed.HasValue ? new[] { embed.Value } : Array.Empty<DiscordEmbed>(), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 		/// <summary>
 		/// Edits the message.
 		/// </summary>
 		/// <param name="content">New content.</param>
 		/// <param name="embed">New embed.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> ModifyAsync(Optional<string> content, Optional<DiscordEmbed> embed = default)
 			=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embed.HasValue ? new[] { embed.Value } : Array.Empty<DiscordEmbed>(), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 		/// <summary>
 		/// Edits the message.
 		/// </summary>
 		/// <param name="content">New content.</param>
 		/// <param name="embeds">New embeds.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> ModifyAsync(Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds = default)
 			=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embeds, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 		/// <summary>
 		/// Edits the message.
 		/// </summary>
 		/// <param name="builder">The builder of the message to edit.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordMessage> ModifyAsync(DiscordMessageBuilder builder)
 		{
 			builder.Validate(true);
 			return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, new Optional<IEnumerable<DiscordEmbed>>(builder.Embeds), builder.Mentions, builder.Components, builder.Suppressed, builder.Files, builder.Attachments.Count > 0 ? new Optional<IEnumerable<DiscordAttachment>>(builder.Attachments) : builder.KeepAttachmentsInternal.HasValue ? builder.KeepAttachmentsInternal.Value ? new Optional<IEnumerable<DiscordAttachment>>(this.Attachments) : Array.Empty<DiscordAttachment>() : null);
 		}
 
 		/// <summary>
 		/// Edits the message embed suppression.
 		/// </summary>
 		/// <param name="suppress">Suppress embeds.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> ModifySuppressionAsync(bool suppress = false)
 			=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, this.GetMentions(), default, suppress, default, default);
 
 		/// <summary>
 		/// Clears all attachments from the message.
 		/// </summary>
 		/// <returns></returns>
 		public Task<DiscordMessage> ClearAttachmentsAsync()
 			=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, this.GetMentions(), default, default, default, Array.Empty<DiscordAttachment>());
 
 		/// <summary>
 		/// Edits the message.
 		/// </summary>
 		/// <param name="action">The builder of the message to edit.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordMessage> ModifyAsync(Action<DiscordMessageBuilder> action)
 		{
 			var builder = new DiscordMessageBuilder();
 			action(builder);
 			builder.Validate(true);
 			return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, new Optional<IEnumerable<DiscordEmbed>>(builder.Embeds), builder.Mentions, builder.Components, builder.Suppressed, builder.Files, builder.Attachments.Count > 0 ? new Optional<IEnumerable<DiscordAttachment>>(builder.Attachments) : builder.KeepAttachmentsInternal.HasValue ? builder.KeepAttachmentsInternal.Value ? new Optional<IEnumerable<DiscordAttachment>>(this.Attachments) : Array.Empty<DiscordAttachment>() : null);
 		}
 
 		/// <summary>
 		/// Deletes the message.
 		/// </summary>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteAsync(string reason = null)
 			=> this.Discord.ApiClient.DeleteMessageAsync(this.ChannelId, this.Id, reason);
 
 		/// <summary>
 		/// Creates a thread.
 		/// Depending on the <see cref="ChannelType"/> of the parent channel it's either a <see cref="ChannelType.PublicThread"/> or a <see cref="ChannelType.NewsThread"/>.
 		/// </summary>
 		/// <param name="name">The name of the thread.</param>
 		/// <param name="autoArchiveDuration"><see cref="ThreadAutoArchiveDuration"/> till it gets archived. Defaults to <see cref="ThreadAutoArchiveDuration.OneHour"/></param>
 		/// <param name="rateLimitPerUser">The per user ratelimit, aka slowdown.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePrivateThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified.</exception>
-		public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, int? rateLimitPerUser = null, string reason = null)
-		{
-			return Utilities.CheckThreadAutoArchiveDurationFeature(this.Channel.Guild, autoArchiveDuration)
-					? await this.Discord.ApiClient.CreateThreadWithMessageAsync(this.ChannelId, this.Id, name, autoArchiveDuration, rateLimitPerUser, reason)
-					: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
-		}
+		public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, int? rateLimitPerUser = null, string reason = null) =>
+			Utilities.CheckThreadAutoArchiveDurationFeature(this.Channel.Guild, autoArchiveDuration)
+				? await this.Discord.ApiClient.CreateThreadWithMessageAsync(this.ChannelId, this.Id, name, autoArchiveDuration, rateLimitPerUser, reason)
+				: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 
 		/// <summary>
 		/// Pins the message in its channel.
 		/// </summary>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task PinAsync()
 			=> this.Discord.ApiClient.PinMessageAsync(this.ChannelId, this.Id);
 
 		/// <summary>
 		/// Unpins the message in its channel.
 		/// </summary>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task UnpinAsync()
 			=> this.Discord.ApiClient.UnpinMessageAsync(this.ChannelId, this.Id);
 
 		/// <summary>
 		/// Responds to the message. This produces a reply.
 		/// </summary>
 		/// <param name="content">Message content to respond with.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> RespondAsync(string content)
 			=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 		/// <summary>
 		/// Responds to the message. This produces a reply.
 		/// </summary>
 		/// <param name="embed">Embed to attach to the message.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> RespondAsync(DiscordEmbed embed)
 			=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 		/// <summary>
 		/// Responds to the message. This produces a reply.
 		/// </summary>
 		/// <param name="content">Message content to respond with.</param>
 		/// <param name="embed">Embed to attach to the message.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> RespondAsync(string content, DiscordEmbed embed)
 			=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 		/// <summary>
 		/// Responds to the message. This produces a reply.
 		/// </summary>
 		/// <param name="builder">The Discord message builder.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> RespondAsync(DiscordMessageBuilder builder)
 			=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 
 		/// <summary>
 		/// Responds to the message. This produces a reply.
 		/// </summary>
 		/// <param name="action">The Discord message builder.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> RespondAsync(Action<DiscordMessageBuilder> action)
 		{
 			var builder = new DiscordMessageBuilder();
 			action(builder);
 			return this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 		}
 
 		/// <summary>
 		/// Creates a reaction to this message.
 		/// </summary>
 		/// <param name="emoji">The emoji you want to react with, either an emoji or name:id</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AddReactions"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task CreateReactionAsync(DiscordEmoji emoji)
 			=> this.Discord.ApiClient.CreateReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 		/// <summary>
 		/// Deletes your own reaction
 		/// </summary>
 		/// <param name="emoji">Emoji for the reaction you want to remove, either an emoji or name:id</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteOwnReactionAsync(DiscordEmoji emoji)
 			=> this.Discord.ApiClient.DeleteOwnReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 		/// <summary>
 		/// Deletes another user's reaction.
 		/// </summary>
 		/// <param name="emoji">Emoji for the reaction you want to remove, either an emoji or name:id.</param>
 		/// <param name="user">Member you want to remove the reaction for</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteReactionAsync(DiscordEmoji emoji, DiscordUser user, string reason = null)
 			=> this.Discord.ApiClient.DeleteUserReactionAsync(this.ChannelId, this.Id, user.Id, emoji.ToReactionString(), reason);
 
 		/// <summary>
 		/// Gets users that reacted with this emoji.
 		/// </summary>
 		/// <param name="emoji">Emoji to react with.</param>
 		/// <param name="limit">Limit of users to fetch.</param>
 		/// <param name="after">Fetch users after this user's id.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordUser>> GetReactionsAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
 			=> this.GetReactionsInternalAsync(emoji, limit, after);
 
 		/// <summary>
 		/// Deletes all reactions for this message.
 		/// </summary>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteAllReactionsAsync(string reason = null)
 			=> this.Discord.ApiClient.DeleteAllReactionsAsync(this.ChannelId, this.Id, reason);
 
 		/// <summary>
 		/// Deletes all reactions of a specific reaction for this message.
 		/// </summary>
 		/// <param name="emoji">The emoji to clear, either an emoji or name:id.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task DeleteReactionsEmojiAsync(DiscordEmoji emoji)
 			=> this.Discord.ApiClient.DeleteReactionsEmojiAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 		/// <summary>
 		/// Gets the reactions.
 		/// </summary>
 		/// <param name="emoji">The emoji to search for.</param>
 		/// <param name="limit">The limit of results.</param>
 		/// <param name="after">Get the reasctions after snowflake.</param>
 		private async Task<IReadOnlyList<DiscordUser>> GetReactionsInternalAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
 		{
 			if (limit < 0)
 				throw new ArgumentException("Cannot get a negative number of reactions' users.");
 
 			if (limit == 0)
 				return Array.Empty<DiscordUser>();
 
 			var users = new List<DiscordUser>(limit);
 			var remaining = limit;
 			var last = after;
 
 			int lastCount;
 			do
 			{
 				var fetchSize = remaining > 100 ? 100 : remaining;
 				var fetch = await this.Discord.ApiClient.GetReactionsAsync(this.Channel.Id, this.Id, emoji.ToReactionString(), last, fetchSize).ConfigureAwait(false);
 
 				lastCount = fetch.Count;
 				remaining -= lastCount;
 
 				users.AddRange(fetch);
 				last = fetch.LastOrDefault()?.Id;
 			} while (remaining > 0 && lastCount > 0);
 
 			return new ReadOnlyCollection<DiscordUser>(users);
 		}
 
 		/// <summary>
 		/// Returns a string representation of this message.
 		/// </summary>
 		/// <returns>String representation of this message.</returns>
 		public override string ToString() => $"Message {this.Id}; Attachment count: {this.AttachmentsInternal.Count}; Embed count: {this.EmbedsInternal.Count}; Contents: {this.Content}";
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordMessage"/> is equal to another object.
 		/// </summary>
 		/// <param name="obj">Object to compare to.</param>
 		/// <returns>Whether the object is equal to this <see cref="DiscordMessage"/>.</returns>
 		public override bool Equals(object obj) => this.Equals(obj as DiscordMessage);
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordMessage"/> is equal to another <see cref="DiscordMessage"/>.
 		/// </summary>
 		/// <param name="e"><see cref="DiscordMessage"/> to compare to.</param>
 		/// <returns>Whether the <see cref="DiscordMessage"/> is equal to this <see cref="DiscordMessage"/>.</returns>
 		public bool Equals(DiscordMessage e) => e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.ChannelId == e.ChannelId));
 
 		/// <summary>
 		/// Gets the hash code for this <see cref="DiscordMessage"/>.
 		/// </summary>
 		/// <returns>The hash code for this <see cref="DiscordMessage"/>.</returns>
 		public override int GetHashCode()
 		{
 			var hash = 13;
 
 			hash = (hash * 7) + this.Id.GetHashCode();
 			hash = (hash * 7) + this.ChannelId.GetHashCode();
 
 			return hash;
 		}
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordMessage"/> objects are equal.
 		/// </summary>
 		/// <param name="e1">First message to compare.</param>
 		/// <param name="e2">Second message to compare.</param>
 		/// <returns>Whether the two messages are equal.</returns>
 		public static bool operator ==(DiscordMessage e1, DiscordMessage e2)
 		{
 			var o1 = e1 as object;
 			var o2 = e2 as object;
 
 			return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1.ChannelId == e2.ChannelId));
 		}
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordMessage"/> objects are not equal.
 		/// </summary>
 		/// <param name="e1">First message to compare.</param>
 		/// <param name="e2">Second message to compare.</param>
 		/// <returns>Whether the two messages are not equal.</returns>
 		public static bool operator !=(DiscordMessage e1, DiscordMessage e2)
 			=> !(e1 == e2);
 	}
 }
diff --git a/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs b/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
index 74a202877..7820f76a4 100644
--- a/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
+++ b/DisCatSharp/Entities/Message/DiscordMessageBuilder.cs
@@ -1,460 +1,460 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Constructs a Message to be sent.
 	/// </summary>
 	public sealed class DiscordMessageBuilder
 	{
 		/// <summary>
 		/// Gets or Sets the Message to be sent.
 		/// </summary>
 		public string Content
 		{
 			get => this._content;
 			set
 			{
 				if (value != null && value.Length > 2000)
 					throw new ArgumentException("Content cannot exceed 2000 characters.", nameof(value));
 				this._content = value;
 			}
 		}
 		private string _content;
 
 		/// <summary>
 		/// Gets or sets the embed for the builder. This will always set the builder to have one embed.
 		/// </summary>
 		public DiscordEmbed Embed
 		{
 			get => this._embeds.Count > 0 ? this._embeds[0] : null;
 			set
 			{
 				this._embeds.Clear();
 				this._embeds.Add(value);
 			}
 		}
 
 		/// <summary>
 		/// Gets the Sticker to be send.
 		/// </summary>
 		public DiscordSticker Sticker { get; set; }
 
 		/// <summary>
 		/// Gets the Embeds to be sent.
 		/// </summary>
 		public IReadOnlyList<DiscordEmbed> Embeds => this._embeds;
 		private readonly List<DiscordEmbed> _embeds = new();
 
 		/// <summary>
 		/// Gets or Sets if the message should be TTS.
 		/// </summary>
-		public bool IsTts { get; set; } = false;
+		public bool IsTts { get; set; }
 
 		/// <summary>
 		/// Whether to keep previous attachments.
 		/// </summary>
-		internal bool? KeepAttachmentsInternal = null;
+		internal bool? KeepAttachmentsInternal;
 
 		/// <summary>
 		/// Gets the Allowed Mentions for the message to be sent.
 		/// </summary>
-		public List<IMention> Mentions { get; private set; } = null;
+		public List<IMention> Mentions { get; private set; }
 
 		/// <summary>
 		/// Gets the Files to be sent in the Message.
 		/// </summary>
 		public IReadOnlyCollection<DiscordMessageFile> Files => this.FilesInternal;
 		internal readonly List<DiscordMessageFile> FilesInternal = new();
 
 		/// <summary>
 		/// Gets the components that will be attached to the message.
 		/// </summary>
 		public IReadOnlyList<DiscordActionRowComponent> Components => this.ComponentsInternal;
 		internal readonly List<DiscordActionRowComponent> ComponentsInternal = new(5);
 
 		/// <summary>
 		/// Gets the Attachments to be sent in the Message.
 		/// </summary>
 		public IReadOnlyList<DiscordAttachment> Attachments => this.AttachmentsInternal;
 		internal readonly List<DiscordAttachment> AttachmentsInternal = new();
 
 		/// <summary>
 		/// Gets the Reply Message ID.
 		/// </summary>
-		public ulong? ReplyId { get; private set; } = null;
+		public ulong? ReplyId { get; private set; }
 
 		/// <summary>
 		/// Gets if the Reply should mention the user.
 		/// </summary>
-		public bool MentionOnReply { get; private set; } = false;
+		public bool MentionOnReply { get; private set; }
 
 		/// <summary>
 		/// Gets if the embeds should be suppressed.
 		/// </summary>
-		public bool Suppressed { get; private set; } = false;
+		public bool Suppressed { get; private set; }
 
 		/// <summary>
 		/// Gets if the Reply will error if the Reply Message Id does not reference a valid message.
 		/// <para>If set to false, invalid replies are send as a regular message.</para>
 		/// <para>Defaults to false.</para>
 		/// </summary>
 		public bool FailOnInvalidReply { get; set; }
 
 		/// <summary>
 		/// Sets the Content of the Message.
 		/// </summary>
 		/// <param name="content">The content to be set.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder WithContent(string content)
 		{
 			this.Content = content;
 			return this;
 		}
 
 		/// <summary>
 		/// Adds a sticker to the message. Sticker must be from current guild.
 		/// </summary>
 		/// <param name="sticker">The sticker to add.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder WithSticker(DiscordSticker sticker)
 		{
 			this.Sticker = sticker;
 			return this;
 		}
 
 		/// <summary>
 		/// Adds a row of components to a message, up to 5 components per row, and up to 5 rows per message.
 		/// </summary>
 		/// <param name="components">The components to add to the message.</param>
 		/// <returns>The current builder to be chained.</returns>
 		/// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
 		public DiscordMessageBuilder AddComponents(params DiscordComponent[] components)
 			=> this.AddComponents((IEnumerable<DiscordComponent>)components);
 
 
 		/// <summary>
 		/// Appends several rows of components to the message
 		/// </summary>
 		/// <param name="components">The rows of components to add, holding up to five each.</param>
 		/// <returns></returns>
 		public DiscordMessageBuilder AddComponents(IEnumerable<DiscordActionRowComponent> components)
 		{
 			var ara = components.ToArray();
 
 			if (ara.Length + this.ComponentsInternal.Count > 5)
 				throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
 			foreach (var ar in ara)
 				this.ComponentsInternal.Add(ar);
 
 			return this;
 		}
 
 		/// <summary>
 		/// Adds a row of components to a message, up to 5 components per row, and up to 5 rows per message.
 		/// </summary>
 		/// <param name="components">The components to add to the message.</param>
 		/// <returns>The current builder to be chained.</returns>
 		/// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
 		public DiscordMessageBuilder AddComponents(IEnumerable<DiscordComponent> components)
 		{
 			var cmpArr = components.ToArray();
 			var count = cmpArr.Length;
 
 			if (!cmpArr.Any())
 				throw new ArgumentOutOfRangeException(nameof(components), "You must provide at least one component");
 
 			if (count > 5)
 				throw new ArgumentException("Cannot add more than 5 components per action row!");
 
 			var comp = new DiscordActionRowComponent(cmpArr);
 			this.ComponentsInternal.Add(comp);
 
 			return this;
 		}
 
 		/// <summary>
 		/// Sets if the message should be TTS.
 		/// </summary>
 		/// <param name="isTts">If TTS should be set.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder HasTts(bool isTts)
 		{
 			this.IsTts = isTts;
 			return this;
 		}
 
 		/// <summary>
 		/// Sets the embed for the current builder.
 		/// </summary>
 		/// <param name="embed">The embed that should be set.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder WithEmbed(DiscordEmbed embed)
 		{
 			if (embed == null)
 				return this;
 
 			this.Embed = embed;
 			return this;
 		}
 
 		/// <summary>
 		/// Appends an embed to the current builder.
 		/// </summary>
 		/// <param name="embed">The embed that should be appended.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder AddEmbed(DiscordEmbed embed)
 		{
 			if (embed == null)
 				return this; //Providing null embeds will produce a 400 response from Discord.//
 			this._embeds.Add(embed);
 			return this;
 		}
 
 		/// <summary>
 		/// Appends several embeds to the current builder.
 		/// </summary>
 		/// <param name="embeds">The embeds that should be appended.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder AddEmbeds(IEnumerable<DiscordEmbed> embeds)
 		{
 			this._embeds.AddRange(embeds);
 			return this;
 		}
 
 		/// <summary>
 		/// Sets if the message has allowed mentions.
 		/// </summary>
 		/// <param name="allowedMention">The allowed Mention that should be sent.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder WithAllowedMention(IMention allowedMention)
 		{
 			if (this.Mentions != null)
 				this.Mentions.Add(allowedMention);
 			else
 				this.Mentions = new List<IMention> { allowedMention };
 
 			return this;
 		}
 
 		/// <summary>
 		/// Sets if the message has allowed mentions.
 		/// </summary>
 		/// <param name="allowedMentions">The allowed Mentions that should be sent.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder WithAllowedMentions(IEnumerable<IMention> allowedMentions)
 		{
 			if (this.Mentions != null)
 				this.Mentions.AddRange(allowedMentions);
 			else
 				this.Mentions = allowedMentions.ToList();
 
 			return this;
 		}
 
 		/// <summary>
 		/// Sets if the message has files to be sent.
 		/// </summary>
 		/// <param name="fileName">The fileName that the file should be sent as.</param>
 		/// <param name="stream">The Stream to the file.</param>
 		/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 		/// <param name="description">Description of the file.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder WithFile(string fileName, Stream stream, bool resetStreamPosition = false, string description = null)
 		{
 			if (this.Files.Count > 10)
 				throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 			if (this.FilesInternal.Any(x => x.FileName == fileName))
 				throw new ArgumentException("A File with that filename already exists");
 
 			if (resetStreamPosition)
 				this.FilesInternal.Add(new DiscordMessageFile(fileName, stream, stream.Position, description: description));
 			else
 				this.FilesInternal.Add(new DiscordMessageFile(fileName, stream, null, description: description));
 
 			return this;
 		}
 
 		/// <summary>
 		/// Sets if the message has files to be sent.
 		/// </summary>
 		/// <param name="stream">The Stream to the file.</param>
 		/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 		/// <param name="description">Description of the file.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder WithFile(FileStream stream, bool resetStreamPosition = false, string description = null)
 		{
 			if (this.Files.Count > 10)
 				throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 			if (this.FilesInternal.Any(x => x.FileName == stream.Name))
 				throw new ArgumentException("A File with that filename already exists");
 
 			if (resetStreamPosition)
 				this.FilesInternal.Add(new DiscordMessageFile(stream.Name, stream, stream.Position, description: description));
 			else
 				this.FilesInternal.Add(new DiscordMessageFile(stream.Name, stream, null, description: description));
 
 			return this;
 		}
 
 		/// <summary>
 		/// Sets if the message has files to be sent.
 		/// </summary>
 		/// <param name="files">The Files that should be sent.</param>
 		/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder WithFiles(Dictionary<string, Stream> files, bool resetStreamPosition = false)
 		{
 			if (this.Files.Count + files.Count > 10)
 				throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 			foreach (var file in files)
 			{
 				if (this.FilesInternal.Any(x => x.FileName == file.Key))
 					throw new ArgumentException("A File with that filename already exists");
 
 				if (resetStreamPosition)
 					this.FilesInternal.Add(new DiscordMessageFile(file.Key, file.Value, file.Value.Position));
 				else
 					this.FilesInternal.Add(new DiscordMessageFile(file.Key, file.Value, null));
 			}
 
 			return this;
 		}
 
 		/// <summary>
 		/// Modifies the given attachments on edit.
 		/// </summary>
 		/// <param name="attachments">Attachments to edit.</param>
 		/// <returns></returns>
 		public DiscordMessageBuilder ModifyAttachments(IEnumerable<DiscordAttachment> attachments)
 		{
 			this.AttachmentsInternal.AddRange(attachments);
 			return this;
 		}
 
 		/// <summary>
 		/// Whether to keep the message attachments, if new ones are added.
 		/// </summary>
 		/// <returns></returns>
 		public DiscordMessageBuilder KeepAttachments(bool keep)
 		{
 			this.KeepAttachmentsInternal = keep;
 			return this;
 		}
 
 		/// <summary>
 		/// Sets if the message is a reply
 		/// </summary>
 		/// <param name="messageId">The ID of the message to reply to.</param>
 		/// <param name="mention">If we should mention the user in the reply.</param>
 		/// <param name="failOnInvalidReply">Whether sending a reply that references an invalid message should be </param>
 		/// <returns>The current builder to be chained.</returns>
 		public DiscordMessageBuilder WithReply(ulong messageId, bool mention = false, bool failOnInvalidReply = false)
 		{
 			this.ReplyId = messageId;
 			this.MentionOnReply = mention;
 			this.FailOnInvalidReply = failOnInvalidReply;
 
 			if (mention)
 			{
 				this.Mentions ??= new List<IMention>();
 				this.Mentions.Add(new RepliedUserMention());
 			}
 
 			return this;
 		}
 
 
 		/// <summary>
 		/// Sends the Message to a specific channel
 		/// </summary>
 		/// <param name="channel">The channel the message should be sent to.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public Task<DiscordMessage> SendAsync(DiscordChannel channel) => channel.SendMessageAsync(this);
 
 		/// <summary>
 		/// Sends the modified message.
 		/// <para>Note: Message replies cannot be modified. To clear the reply, simply pass <see langword="null"/> to <see cref="WithReply"/>.</para>
 		/// </summary>
 		/// <param name="msg">The original Message to modify.</param>
 		/// <returns>The current builder to be chained.</returns>
 		public Task<DiscordMessage> ModifyAsync(DiscordMessage msg) => msg.ModifyAsync(this);
 
 		/// <summary>
 		/// Clears all message components on this builder.
 		/// </summary>
 		public void ClearComponents()
 			=> this.ComponentsInternal.Clear();
 
 		/// <summary>
 		/// Allows for clearing the Message Builder so that it can be used again to send a new message.
 		/// </summary>
 		public void Clear()
 		{
 			this.Content = "";
 			this._embeds.Clear();
 			this.IsTts = false;
 			this.Mentions = null;
 			this.FilesInternal.Clear();
 			this.ReplyId = null;
 			this.MentionOnReply = false;
 			this.ComponentsInternal.Clear();
 			this.Suppressed = false;
 			this.Sticker = null;
 			this.AttachmentsInternal.Clear();
 			this.KeepAttachmentsInternal = false;
 		}
 
 		/// <summary>
 		/// Does the validation before we send a the Create/Modify request.
 		/// </summary>
 		/// <param name="isModify">Tells the method to perform the Modify Validation or Create Validation.</param>
 		internal void Validate(bool isModify = false)
 		{
 			if (this._embeds.Count > 10)
 				throw new ArgumentException("A message can only have up to 10 embeds.");
 
 			if (!isModify)
 			{
 				if (this.Files?.Count == 0 && string.IsNullOrEmpty(this.Content) && (!this.Embeds?.Any() ?? true) && this.Sticker is null)
 					throw new ArgumentException("You must specify content, an embed, a sticker or at least one file.");
 
 				if (this.Components.Count > 5)
 					throw new InvalidOperationException("You can only have 5 action rows per message.");
 
 				if (this.Components.Any(c => c.Components.Count > 5))
 					throw new InvalidOperationException("Action rows can only have 5 components");
 			}
 		}
 	}
 }
diff --git a/DisCatSharp/Entities/Optional.cs b/DisCatSharp/Entities/Optional.cs
index a23cc654f..34d2a7b0a 100644
--- a/DisCatSharp/Entities/Optional.cs
+++ b/DisCatSharp/Entities/Optional.cs
@@ -1,291 +1,289 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Linq;
 using System.Reflection;
 using DisCatSharp.Net.Serialization;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Helper methods for instantiating an <see cref="Optional{T}"/>.
 	/// </summary>
 	/// <remarks>
 	/// This class only serves to allow type parameter inference on calls to <see cref="FromValue{T}"/> or
 	/// <see cref="FromNoValue{T}"/>.
 	/// </remarks>
 	public static class Optional
 	{
 		/// <summary>
 		/// Creates a new <see cref="Optional{T}"/> with specified value and valid state.
 		/// </summary>
 		/// <param name="value">Value to populate the optional with.</param>
 		/// <typeparam name="T">Type of the value.</typeparam>
 		/// <returns>Created optional.</returns>
 		public static Optional<T> FromValue<T>(T value)
 			=> new(value);
 
 		/// <summary>
 		/// Creates a new empty <see cref="Optional{T}"/> with no value and invalid state.
 		/// </summary>
 		/// <typeparam name="T">The type that the created instance is wrapping around.</typeparam>
 		/// <returns>Created optional.</returns>
 		public static Optional<T> FromNoValue<T>()
 			=> default;
 	}
 
 	// used internally to make serialization more convenient, do NOT change this, do NOT implement this yourself
 	/// <summary>
 	/// Represents a IOptional interface.
 	/// </summary>
 	internal interface IOptional
 	{
 		/// <summary>
 		/// Gets a whether it has a value.
 		/// </summary>
 		bool HasValue { get; }
 
 		/// <summary>
 		/// Gets the raw value.
 		/// </summary>
 		object RawValue { get; } // must NOT throw InvalidOperationException
 	}
 
 	/// <summary>
 	/// Represents a wrapper which may or may not have a value.
 	/// </summary>
 	/// <typeparam name="T">Type of the value.</typeparam>
 	[JsonConverter(typeof(OptionalJsonConverter))]
 	public readonly struct Optional<T> : IEquatable<Optional<T>>, IEquatable<T>, IOptional
 	{
 		/// <summary>
 		/// Gets whether this <see cref="Optional{T}"/> has a value.
 		/// </summary>
 		public bool HasValue { get; }
 
 		/// <summary>
 		/// Gets the value of this <see cref="Optional{T}"/>.
 		/// </summary>
 		/// <exception cref="System.InvalidOperationException">If this <see cref="Optional{T}"/> has no value.</exception>
 		public T Value => this.HasValue ? this._val : throw new InvalidOperationException("Value is not set.");
 
 		/// <summary>
 		/// Gets the raw value.
 		/// </summary>
 		object IOptional.RawValue => this._val;
 
 		private readonly T _val;
 
 		/// <summary>
 		/// Creates a new <see cref="Optional{T}"/> with specified value.
 		/// </summary>
 		/// <param name="value">Value of this option.</param>
 		public Optional(T value)
 		{
 			this._val = value;
 			this.HasValue = true;
 		}
 
 		/// <summary>
 		/// Returns a string representation of this optional value.
 		/// </summary>
 		/// <returns>String representation of this optional value.</returns>
 		public override string ToString() => $"Optional<{typeof(T)}> ({(this.HasValue ? this.Value.ToString() : "<no value>")})";
 
 		/// <summary>
 		/// Checks whether this <see cref="Optional{T}"/> (or its value) are equal to another object.
 		/// </summary>
 		/// <param name="obj">Object to compare to.</param>
 		/// <returns>Whether the object is equal to this <see cref="Optional{T}"/> or its value.</returns>
-		public override bool Equals(object obj)
-		{
-			return obj switch
+		public override bool Equals(object obj) =>
+			obj switch
 			{
 				T t => this.Equals(t),
 				Optional<T> opt => this.Equals(opt),
 				_ => false,
 			};
-		}
 
 		/// <summary>
 		/// Checks whether this <see cref="Optional{T}"/> is equal to another <see cref="Optional{T}"/>.
 		/// </summary>
 		/// <param name="e"><see cref="Optional{T}"/> to compare to.</param>
 		/// <returns>Whether the <see cref="Optional{T}"/> is equal to this <see cref="Optional{T}"/>.</returns>
 		public bool Equals(Optional<T> e) => (!this.HasValue && !e.HasValue) || (this.HasValue == e.HasValue && this.Value.Equals(e.Value));
 
 		/// <summary>
 		/// Checks whether the value of this <see cref="Optional{T}"/> is equal to specified object.
 		/// </summary>
 		/// <param name="e">Object to compare to.</param>
 		/// <returns>Whether the object is equal to the value of this <see cref="Optional{T}"/>.</returns>
 		public bool Equals(T e)
 			=> this.HasValue && ReferenceEquals(this.Value, e);
 
 		/// <summary>
 		/// Gets the hash code for this <see cref="Optional{T}"/>.
 		/// </summary>
 		/// <returns>The hash code for this <see cref="Optional{T}"/>.</returns>
 		public override int GetHashCode()
 			=> this.HasValue ? this.Value.GetHashCode() : 0;
 
 		public static implicit operator Optional<T>(T val)
 			=> new(val);
 
 		public static explicit operator T(Optional<T> opt)
 			=> opt.Value;
 
 		public static bool operator ==(Optional<T> opt1, Optional<T> opt2)
 			=> opt1.Equals(opt2);
 
 		public static bool operator !=(Optional<T> opt1, Optional<T> opt2)
 			=> !opt1.Equals(opt2);
 
 		public static bool operator ==(Optional<T> opt, T t)
 			=> opt.Equals(t);
 
 		public static bool operator !=(Optional<T> opt, T t)
 			=> !opt.Equals(t);
 
 		/// <summary>
 		/// Performs a mapping operation on the current <see cref="Optional{T}"/>, turning it into an Optional holding a
 		/// <typeparamref name="TTarget"/> instance if the source optional contains a value; otherwise, returns an
 		/// <see cref="Optional{T}"/> of that same type with no value.
 		/// </summary>
 		/// <param name="mapper">The mapping function to apply on the current value if it exists</param>
 		/// <typeparam name="TTarget">The type of the target value returned by <paramref name="mapper"/></typeparam>
 		/// <returns>
 		/// An <see cref="Optional{T}"/> containing a value denoted by calling <paramref name="mapper"/> if the current
 		/// <see cref="Optional{T}"/> contains a value; otherwise, an empty <see cref="Optional{T}"/> of the target
 		/// type.
 		/// </returns>
 		public Optional<TTarget> IfPresent<TTarget>(Func<T, TTarget> mapper) => this.HasValue ? new Optional<TTarget>(mapper(this.Value)) : default;
 	}
 
 	/// <summary>
 	/// Represents an optional json contract resolver.
 	/// <seealso cref="DiscordJson.s_serializer"/>
 	/// </summary>
 	internal sealed class OptionalJsonContractResolver : DefaultContractResolver
 	{
 		/// <summary>
 		/// Creates the property.
 		/// </summary>
 		/// <param name="member">The member.</param>
 		/// <param name="memberSerialization">The member serialization.</param>
 		protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
 		{
 			var property = base.CreateProperty(member, memberSerialization);
 
 			var type = property.PropertyType;
 
 			if (!type.GetTypeInfo().ImplementedInterfaces.Contains(typeof(IOptional)))
 				return property;
 
 			// we cache the PropertyInfo object here (it's captured in closure). we don't have direct
 			// access to the property value so we have to reflect into it from the parent instance
 			// we use UnderlyingName instead of PropertyName in case the C# name is different from the Json name.
 			var declaringMember = property.DeclaringType.GetTypeInfo().DeclaredMembers
 				.FirstOrDefault(e => e.Name == property.UnderlyingName);
 
 			switch (declaringMember)
 			{
 				case PropertyInfo declaringProp:
 					property.ShouldSerialize = instance => // instance here is the declaring (parent) type
 					{
 						var optionalValue = declaringProp.GetValue(instance);
 						return (optionalValue as IOptional).HasValue;
 					};
 					return property;
 				case FieldInfo declaringField:
 					property.ShouldSerialize = instance => // instance here is the declaring (parent) type
 					{
 						var optionalValue = declaringField.GetValue(instance);
 						return (optionalValue as IOptional).HasValue;
 					};
 					return property;
 				default:
 					throw new InvalidOperationException(
 						"Can only serialize Optional<T> members that are fields or properties");
 			}
 		}
 	}
 
 	/// <summary>
 	/// Represents an optional json converter.
 	/// </summary>
 	internal sealed class OptionalJsonConverter : JsonConverter
 	{
 		/// <summary>
 		/// Writes the json.
 		/// </summary>
 		/// <param name="writer">The writer.</param>
 		/// <param name="value">The value.</param>
 		/// <param name="serializer">The serializer.</param>
 		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 		{
 			// we don't check for HasValue here since it's checked in OptionalJsonContractResolver
 			var val = (value as IOptional).RawValue;
 			// JToken.FromObject will throw if `null` so we manually write a null value.
 			if (val == null)
 			{
 				// you can read serializer.NullValueHandling here, but unfortunately you can **not** skip serialization
 				// here, or else you will get a nasty JsonWriterException, so we just ignore its value and manually
 				// write the null.
 				writer.WriteToken(JsonToken.Null);
 			}
 			else
 			{
 				// convert the value to a JSON object and write it to the property value.
 				JToken.FromObject(val).WriteTo(writer);
 			}
 		}
 
 		/// <summary>
 		/// Reads the json.
 		/// </summary>
 		/// <param name="reader">The reader.</param>
 		/// <param name="objectType">The object type.</param>
 		/// <param name="existingValue">The existing value.</param>
 		/// <param name="serializer">The serializer.</param>
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
 			JsonSerializer serializer)
 		{
 			var genericType = objectType.GenericTypeArguments[0];
 
 			var constructor = objectType.GetTypeInfo().DeclaredConstructors
 				.FirstOrDefault(e => e.GetParameters()[0].ParameterType == genericType);
 
 			return constructor.Invoke(new[] { serializer.Deserialize(reader, genericType) });
 		}
 
 		/// <summary>
 		/// Whether it can convert.
 		/// </summary>
 		/// <param name="objectType">The object type.</param>
 		public override bool CanConvert(Type objectType) => objectType.GetTypeInfo().ImplementedInterfaces.Contains(typeof(IOptional));
 	}
 }
diff --git a/DisCatSharp/Entities/Sticker/DiscordSticker.cs b/DisCatSharp/Entities/Sticker/DiscordSticker.cs
index 07fe85d55..e834eec68 100644
--- a/DisCatSharp/Entities/Sticker/DiscordSticker.cs
+++ b/DisCatSharp/Entities/Sticker/DiscordSticker.cs
@@ -1,215 +1,213 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a Discord Sticker.
 	/// </summary>
 	public class DiscordSticker : SnowflakeObject, IEquatable<DiscordSticker>
 	{
 		/// <summary>
 		/// Gets the Pack ID of this sticker.
 		/// </summary>
 		[JsonProperty("pack_id", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong? PackId { get; internal set; }
 
 		/// <summary>
 		/// Gets the Name of the sticker.
 		/// </summary>
 		[JsonProperty("name")]
 		public string Name { get; internal set; }
 
 		/// <summary>
 		/// Gets the Description of the sticker.
 		/// </summary>
 		[JsonProperty("description", NullValueHandling = NullValueHandling.Ignore)]
 		public string Description { get; internal set; }
 
 		/// <summary>
 		/// Gets the type of sticker.
 		/// </summary>
 		[JsonProperty("type")]
 		public StickerType Type { get; internal set; }
 
 		/// <summary>
 		/// For guild stickers, gets the user that made the sticker.
 		/// </summary>
 		[JsonProperty("user", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordUser User { get; internal set; }
 
 		/// <summary>
 		/// Gets the guild associated with this sticker, if any.
 		/// </summary>
 		public DiscordGuild Guild => (this.Discord as DiscordClient).InternalGetCachedGuild(this.GuildId);
 
 		/// <summary>
 		/// Gets the guild id the sticker belongs too.
 		/// </summary>
 		[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong? GuildId { get; internal set; }
 
 		/// <summary>
 		/// Gets whether this sticker is available. Only applicable to guild stickers.
 		/// </summary>
 		[JsonProperty("available", NullValueHandling = NullValueHandling.Ignore)]
 		public bool Available { get; internal set; }
 
 		/// <summary>
 		/// Gets the sticker's sort order, if it's in a pack.
 		/// </summary>
 		[JsonProperty("sort_value", NullValueHandling = NullValueHandling.Ignore)]
 		public int? SortValue { get; internal set; }
 
 		/// <summary>
 		/// Gets the list of tags for the sticker.
 		/// </summary>
 		[JsonIgnore]
 		public IEnumerable<string> Tags
 			=> this.InternalTags != null ? this.InternalTags.Split(',') : Array.Empty<string>();
 
 		/// <summary>
 		/// Gets the asset hash of the sticker.
 		/// </summary>
 		[JsonProperty("asset", NullValueHandling = NullValueHandling.Ignore)]
 		public string Asset { get; internal set; }
 
 		/// <summary>
 		/// Gets the preview asset hash of the sticker.
 		/// </summary>
 		[JsonProperty("preview_asset", NullValueHandling = NullValueHandling.Ignore)]
 		public string PreviewAsset { get; internal set; }
 
 		/// <summary>
 		/// Gets the Format type of the sticker.
 		/// </summary>
 		[JsonProperty("format_type")]
 		public StickerFormat FormatType { get; internal set; }
 
 		/// <summary>
 		/// Gets the tags of the sticker.
 		/// </summary>
 		[JsonProperty("tags", NullValueHandling = NullValueHandling.Ignore)]
 		[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>")]
 		internal string InternalTags { get; set; }
 
 		/// <summary>
 		/// Gets the url of the sticker.
 		/// </summary>
 		[JsonIgnore]
 		public string Url => $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.STICKERS}/{this.Id}.{(this.FormatType == StickerFormat.Lottie ? "json" : "png")}";
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordSticker"/> class.
 		/// </summary>
 		internal DiscordSticker() { }
 
 		/// <summary>
 		/// Whether to stickers are equal.
 		/// </summary>
 		/// <param name="other">DiscordSticker</param>
 		/// <returns></returns>
 		public bool Equals(DiscordSticker other) => this.Id == other.Id;
 
 		/// <summary>
 		/// Gets the sticker in readable format.
 		/// </summary>
 		public override string ToString() => $"Sticker {this.Id}; {this.Name}; {this.FormatType}";
 
 		/// <summary>
 		/// Modifies the sticker
 		/// </summary>
 		/// <param name="name">The name of the sticker</param>
 		/// <param name="description">The description of the sticker</param>
 		/// <param name="tags">The name of a unicode emoji representing the sticker's expression</param>
 		/// <param name="reason">Audit log reason</param>
 		/// <returns>A sticker object</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
-		public Task<DiscordSticker> ModifyAsync(Optional<string> name, Optional<string> description, Optional<string> tags, string reason = null)
-		{
-			return !this.GuildId.HasValue
+		public Task<DiscordSticker> ModifyAsync(Optional<string> name, Optional<string> description, Optional<string> tags, string reason = null) =>
+			!this.GuildId.HasValue
 				? throw new ArgumentException("This sticker does not belong to a guild.")
 				: name.HasValue && (name.Value.Length < 2 || name.Value.Length > 30)
-				? throw new ArgumentException("Sticker name needs to be between 2 and 30 characters long.")
-				: description.HasValue && (description.Value.Length < 1 || description.Value.Length > 100)
-				? throw new ArgumentException("Sticker description needs to be between 1 and 100 characters long.")
-				: tags.HasValue && !DiscordEmoji.TryFromUnicode(this.Discord, tags.Value, out var emoji)
-				? throw new ArgumentException("Sticker tags needs to be a unicode emoji.")
-				: this.Discord.ApiClient.ModifyGuildStickerAsync(this.GuildId.Value, this.Id, name, description, tags, reason);
-		}
+					? throw new ArgumentException("Sticker name needs to be between 2 and 30 characters long.")
+					: description.HasValue && (description.Value.Length < 1 || description.Value.Length > 100)
+						? throw new ArgumentException("Sticker description needs to be between 1 and 100 characters long.")
+						: tags.HasValue && !DiscordEmoji.TryFromUnicode(this.Discord, tags.Value, out var emoji)
+							? throw new ArgumentException("Sticker tags needs to be a unicode emoji.")
+							: this.Discord.ApiClient.ModifyGuildStickerAsync(this.GuildId.Value, this.Id, name, description, tags, reason);
 
 		/// <summary>
 		/// Deletes the sticker
 		/// </summary>
 		/// <param name="reason">Audit log reason</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 		public Task DeleteAsync(string reason = null)
 			=> this.GuildId.HasValue ? this.Discord.ApiClient.DeleteGuildStickerAsync(this.GuildId.Value, this.Id, reason) : throw new ArgumentException("The requested sticker is no guild sticker.");
 	}
 
 	/// <summary>
 	/// The sticker type
 	/// </summary>
 	public enum StickerType : long
 	{
 		/// <summary>
 		/// Standard nitro sticker
 		/// </summary>
 		Standard = 1,
 		/// <summary>
 		/// Custom guild sticker
 		/// </summary>
 		Guild = 2
 	}
 
 	/// <summary>
 	/// The sticker type
 	/// </summary>
 	public enum StickerFormat : long
 	{
 		/// <summary>
 		/// Sticker is a png
 		/// </summary>
 		Png = 1,
 		/// <summary>
 		/// Sticker is a animated png
 		/// </summary>
 		Apng = 2,
 		/// <summary>
 		/// Sticker is lottie
 		/// </summary>
 		Lottie = 3
 	}
 }
diff --git a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs b/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
index 6691d1631..c8c2f9089 100644
--- a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
+++ b/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
@@ -1,660 +1,648 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a discord thread channel.
 	/// </summary>
 	public class DiscordThreadChannel : DiscordChannel, IEquatable<DiscordThreadChannel>
 	{
 		/// <summary>
 		/// Gets ID of the owner that started this thread.
 		/// </summary>
 		[JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong OwnerId { get; internal set; }
 
 		/// <summary>
 		/// Gets the name of this thread.
 		/// </summary>
 		[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 		public new string Name { get; internal set; }
 
 		/// <summary>
 		/// Gets the type of this thread.
 		/// </summary>
 		[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 		public new ChannelType Type { get; internal set; }
 
 		/// <summary>
 		/// Gets whether this thread is private.
 		/// </summary>
 		[JsonIgnore]
 		public new bool IsPrivate
 			=> this.Type == ChannelType.PrivateThread;
 
 		/// <summary>
 		/// Gets the ID of the last message sent in this thread.
 		/// </summary>
 		[JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
 		public new ulong? LastMessageId { get; internal set; }
 
 		/// <summary>
 		/// <para>Gets the slowmode delay configured for this thread.</para>
 		/// <para>All bots, as well as users with <see cref="Permissions.ManageChannels"/> or <see cref="Permissions.ManageMessages"/> permissions in the channel are exempt from slowmode.</para>
 		/// </summary>
 		[JsonProperty("rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
 		public new int? PerUserRateLimit { get; internal set; }
 
 		/// <summary>
 		/// Gets an approximate count of messages in a thread, stops counting at 50.
 		/// </summary>
 		[JsonProperty("message_count", NullValueHandling = NullValueHandling.Ignore)]
 		public int? MessageCount { get; internal set; }
 
 		/// <summary>
 		/// Gets an approximate count of users in a thread, stops counting at 50.
 		/// </summary>
 		[JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
 		public int? MemberCount { get; internal set; }
 
 		/// <summary>
 		/// Represents the current member for this thread. This will have a value if the user has joined the thread.
 		/// </summary>
 		[JsonProperty("member", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordThreadChannelMember CurrentMember { get; internal set; }
 
 
 		/// <summary>
 		/// Gets when the last pinned message was pinned in this thread.
 		/// </summary>
 		[JsonIgnore]
 		public new DateTimeOffset? LastPinTimestamp
 			=> !string.IsNullOrWhiteSpace(this.LastPinTimestampRaw) && DateTimeOffset.TryParse(this.LastPinTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 				dto : null;
 
 		/// <summary>
 		/// Gets when the last pinned message was pinned in this thread as raw string.
 		/// </summary>
 		[JsonProperty("last_pin_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 		internal new string LastPinTimestampRaw { get; set; }
 
 		/// <summary>
 		/// Gets the threads metadata.
 		/// </summary>
 		[JsonProperty("thread_metadata", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordThreadChannelMetadata ThreadMetadata { get; internal set; }
 
 		/// <summary>
 		/// Gets the thread members object.
 		/// </summary>
 		[JsonIgnore]
 		public IReadOnlyDictionary<ulong, DiscordThreadChannelMember> ThreadMembers => new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannelMember>(this.ThreadMembersInternal);
 
 		[JsonProperty("thread_member", NullValueHandling = NullValueHandling.Ignore)]
 		[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 		internal ConcurrentDictionary<ulong, DiscordThreadChannelMember> ThreadMembersInternal;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordThreadChannel"/> class.
 		/// </summary>
 		internal DiscordThreadChannel() { }
 
 		#region Methods
 
 		/// <summary>
 		/// Deletes a thread.
 		/// </summary>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public new Task DeleteAsync(string reason = null)
 			=> this.Discord.ApiClient.DeleteThreadAsync(this.Id, reason);
 
 
 		/// <summary>
 		/// Modifies the current thread.
 		/// </summary>
 		/// <param name="action">Action to perform on this thread</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>.</exception>
 		public Task ModifyAsync(Action<ThreadEditModel> action)
 		{
 			var mdl = new ThreadEditModel();
 			action(mdl);
 
 			var canContinue = !mdl.AutoArchiveDuration.HasValue || !mdl.AutoArchiveDuration.Value.HasValue || Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.AutoArchiveDuration.Value.Value);
 			if (mdl.Invitable.HasValue)
 			{
 				canContinue = this.Guild.Features.CanCreatePrivateThreads;
 			}
 			return canContinue ? this.Discord.ApiClient.ModifyThreadAsync(this.Id, mdl.Name, mdl.Locked, mdl.Archived, mdl.AutoArchiveDuration, mdl.PerUserRateLimit, mdl.Invitable, mdl.AuditLogReason) : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(mdl.AutoArchiveDuration.Value.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 		}
 
 		/// <summary>
 		/// Archives a thread.
 		/// </summary>
 		/// <param name="locked">Whether the thread should be locked.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task ArchiveAsync(bool locked = true, string reason = null)
 			=> this.Discord.ApiClient.ModifyThreadAsync(this.Id, null, locked, true, null, null, null, reason: reason);
 
 		/// <summary>
 		/// Unarchives a thread.
 		/// </summary>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task UnarchiveAsync(string reason = null)
 			=> this.Discord.ApiClient.ModifyThreadAsync(this.Id, null, null, false, null, null, null, reason: reason);
 
 		/// <summary>
 		/// Gets the members of a thread. Needs the <see cref="DiscordIntents.GuildMembers"/> intent.
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<IReadOnlyList<DiscordThreadChannelMember>> GetMembersAsync()
 			=> await this.Discord.ApiClient.GetThreadMembersAsync(this.Id);
 
 		/// <summary>
 		/// Adds a member to this thread.
 		/// </summary>
 		/// <param name="memberId">The member id to be added.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task AddMemberAsync(ulong memberId)
 			=> this.Discord.ApiClient.AddThreadMemberAsync(this.Id, memberId);
 
 		/// <summary>
 		/// Adds a member to this thread.
 		/// </summary>
 		/// <param name="member">The member to be added.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task AddMemberAsync(DiscordMember member)
 			=> this.AddMemberAsync(member.Id);
 
 		/// <summary>
 		/// Gets a member in this thread.
 		/// </summary>
 		/// <param name="memberId">The member to be added.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member is not part of the thread.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordThreadChannelMember> GetMemberAsync(ulong memberId)
 			=> this.Discord.ApiClient.GetThreadMemberAsync(this.Id, memberId);
 
 		/// <summary>
 		/// Gets a member in this thread.
 		/// </summary>
 		/// <param name="member">The member to be added.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member is not part of the thread.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordThreadChannelMember> GetMemberAsync(DiscordMember member)
 			=> this.Discord.ApiClient.GetThreadMemberAsync(this.Id, member.Id);
 
 		/// <summary>
 		/// Removes a member from this thread.
 		/// </summary>
 		/// <param name="memberId">The member id to be removed.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task RemoveMemberAsync(ulong memberId)
 			=> this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, memberId);
 
 		/// <summary>
 		/// Removes a member from this thread. Only applicable to private threads.
 		/// </summary>
 		/// <param name="member">The member to be removed.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task RemoveMemberAsync(DiscordMember member)
 			=> this.RemoveMemberAsync(member.Id);
 
 		/// <summary>
 		/// Adds a role to this thread. Only applicable to private threads.
 		/// </summary>
 		/// <param name="roleId">The role id to be added.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task AddRoleAsync(ulong roleId)
 		{
 			var role = this.Guild.GetRole(roleId);
 			var members = await this.Guild.GetAllMembersAsync();
 			var roleMembers = members.Where(m => m.Roles.Contains(role));
 			foreach (var member in roleMembers)
 			{
 				await this.Discord.ApiClient.AddThreadMemberAsync(this.Id, member.Id);
 			}
 		}
 
 		/// <summary>
 		/// Adds a role to this thread. Only applicable to private threads.
 		/// </summary>
 		/// <param name="role">The role to be added.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task AddRoleAsync(DiscordRole role)
 			=> this.AddRoleAsync(role.Id);
 
 		/// <summary>
 		/// Removes a role from this thread. Only applicable to private threads.
 		/// </summary>
 		/// <param name="roleId">The role id to be removed.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task RemoveRoleAsync(ulong roleId)
 		{
 			var role = this.Guild.GetRole(roleId);
 			var members = await this.Guild.GetAllMembersAsync();
 			var roleMembers = members.Where(m => m.Roles.Contains(role));
 			foreach (var member in roleMembers)
 			{
 				await this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, member.Id);
 			}
 		}
 
 		/// <summary>
 		/// Removes a role to from thread. Only applicable to private threads.
 		/// </summary>
 		/// <param name="role">The role to be removed.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task RemoveRoleAsync(DiscordRole role)
 			=> this.RemoveRoleAsync(role.Id);
 
 		/// <summary>
 		/// Joins a thread.
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client has no access to this thread.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task JoinAsync()
 			=> this.Discord.ApiClient.JoinThreadAsync(this.Id);
 
 		/// <summary>
 		/// Leaves a thread.
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client has no access to this thread.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task LeaveAsync()
 			=> this.Discord.ApiClient.LeaveThreadAsync(this.Id);
 
 
 		/// <summary>
 		/// Sends a message to this thread.
 		/// </summary>
 		/// <param name="content">Content of the message to send.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public new Task<DiscordMessage> SendMessageAsync(string content)
-		{
-			return !this.IsWriteable()
+		public new Task<DiscordMessage> SendMessageAsync(string content) =>
+			!this.IsWriteable()
 				? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
 				: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
-		}
 
 		/// <summary>
 		/// Sends a message to this thread.
 		/// </summary>
 		/// <param name="embed">Embed to attach to the message.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public new Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed)
-		{
-			return !this.IsWriteable()
+		public new Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed) =>
+			!this.IsWriteable()
 				? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
 				: this.Discord.ApiClient.CreateMessageAsync(this.Id, null, new[] { embed }, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
-		}
 
 		/// <summary>
 		/// Sends a message to this thread.
 		/// </summary>
 		/// <param name="content">Content of the message to send.</param>
 		/// <param name="embed">Embed to attach to the message.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public new Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed)
-		{
-			return !this.IsWriteable()
+		public new Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed) =>
+			!this.IsWriteable()
 				? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
 				: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, new[] { embed }, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
-		}
 
 		/// <summary>
 		/// Sends a message to this thread.
 		/// </summary>
 		/// <param name="builder">The builder with all the items to thread.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public new Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder builder)
 			=> this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 
 		/// <summary>
 		/// Sends a message to this channel.
 		/// </summary>
 		/// <param name="action">The builder with all the items to send.</param>
 		/// <returns>The sent message.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public new Task<DiscordMessage> SendMessageAsync(Action<DiscordMessageBuilder> action)
 		{
 			var builder = new DiscordMessageBuilder();
 			action(builder);
 
 			return !this.IsWriteable()
 				? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 				: this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 		}
 
 		/// <summary>
 		/// Returns a specific message
 		/// </summary>
 		/// <param name="id">The id of the message</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public new async Task<DiscordMessage> GetMessageAsync(ulong id)
-		{
-			return this.Discord.Configuration.MessageCacheSize > 0
-				&& this.Discord is DiscordClient dc
-				&& dc.MessageCache != null
-				&& dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
+		public new async Task<DiscordMessage> GetMessageAsync(ulong id) =>
+			this.Discord.Configuration.MessageCacheSize > 0
+			&& this.Discord is DiscordClient dc
+			&& dc.MessageCache != null
+			&& dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
 				? msg
 				: await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
-		}
 
 		/// <summary>
 		/// Returns a list of messages before a certain message.
 		/// <param name="limit">The amount of messages to fetch.</param>
 		/// <param name="before">Message to fetch before from.</param>
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public new Task<IReadOnlyList<DiscordMessage>> GetMessagesBeforeAsync(ulong before, int limit = 100)
 			=> this.GetMessagesInternalAsync(limit, before, null, null);
 
 		/// <summary>
 		/// Returns a list of messages after a certain message.
 		/// <param name="limit">The amount of messages to fetch.</param>
 		/// <param name="after">Message to fetch after from.</param>
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAfterAsync(ulong after, int limit = 100)
 			=> this.GetMessagesInternalAsync(limit, null, after, null);
 
 		/// <summary>
 		/// Returns a list of messages around a certain message.
 		/// <param name="limit">The amount of messages to fetch.</param>
 		/// <param name="around">Message to fetch around from.</param>
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAroundAsync(ulong around, int limit = 100)
 			=> this.GetMessagesInternalAsync(limit, null, null, around);
 
 		/// <summary>
 		/// Returns a list of messages from the last message in the thread.
 		/// <param name="limit">The amount of messages to fetch.</param>
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAsync(int limit = 100) =>
 			this.GetMessagesInternalAsync(limit, null, null, null);
 
 		/// <summary>
 		/// Returns a list of messages
 		/// </summary>
 		/// <param name="limit">How many messages should be returned.</param>
 		/// <param name="before">Get messages before snowflake.</param>
 		/// <param name="after">Get messages after snowflake.</param>
 		/// <param name="around">Get messages around snowflake.</param>
 		private async Task<IReadOnlyList<DiscordMessage>> GetMessagesInternalAsync(int limit = 100, ulong? before = null, ulong? after = null, ulong? around = null)
 		{
 			if (this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread)
 				throw new ArgumentException("Cannot get the messages of a non-thread channel.");
 
 			if (limit < 0)
 				throw new ArgumentException("Cannot get a negative number of messages.");
 
 			if (limit == 0)
 				return Array.Empty<DiscordMessage>();
 
 			//return this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, limit, before, after, around);
 			if (limit > 100 && around != null)
 				throw new InvalidOperationException("Cannot get more than 100 messages around the specified ID.");
 
 			var msgs = new List<DiscordMessage>(limit);
 			var remaining = limit;
 			ulong? last = null;
 			var isAfter = after != null;
 
 			int lastCount;
 			do
 			{
 				var fetchSize = remaining > 100 ? 100 : remaining;
 				var fetch = await this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, fetchSize, !isAfter ? last ?? before : null, isAfter ? last ?? after : null, around).ConfigureAwait(false);
 
 				lastCount = fetch.Count;
 				remaining -= lastCount;
 
 				if (!isAfter)
 				{
 					msgs.AddRange(fetch);
 					last = fetch.LastOrDefault()?.Id;
 				}
 				else
 				{
 					msgs.InsertRange(0, fetch);
 					last = fetch.FirstOrDefault()?.Id;
 				}
 			}
 			while (remaining > 0 && lastCount > 0);
 
 			return new ReadOnlyCollection<DiscordMessage>(msgs);
 		}
 
 		/// <summary>
 		/// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="DisCatSharp.Exceptions.BadRequestException"/> error.
 		/// </summary>
 		/// <param name="messages">A collection of messages to delete.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public new async Task DeleteMessagesAsync(IEnumerable<DiscordMessage> messages, string reason = null)
 		{
 			// don't enumerate more than once
 			var msgs = messages.Where(x => x.Channel.Id == this.Id).Select(x => x.Id).ToArray();
 			if (messages == null || !msgs.Any())
 				throw new ArgumentException("You need to specify at least one message to delete.");
 
 			if (msgs.Count() < 2)
 			{
 				await this.Discord.ApiClient.DeleteMessageAsync(this.Id, msgs.Single(), reason).ConfigureAwait(false);
 				return;
 			}
 
 			for (var i = 0; i < msgs.Count(); i += 100)
 				await this.Discord.ApiClient.DeleteMessagesAsync(this.Id, msgs.Skip(i).Take(100), reason).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Deletes a message
 		/// </summary>
 		/// <param name="message">The message to be deleted.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public new Task DeleteMessageAsync(DiscordMessage message, string reason = null)
 			=> this.Discord.ApiClient.DeleteMessageAsync(this.Id, message.Id, reason);
 
 
 		/// <summary>
 		/// Post a typing indicator
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public new Task TriggerTypingAsync()
-		{
-			return this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread
+		public new Task TriggerTypingAsync() =>
+			this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread
 				? throw new ArgumentException("Cannot start typing in a non-text channel.")
 				: this.Discord.ApiClient.TriggerTypingAsync(this.Id);
-		}
 
 		/// <summary>
 		/// Returns all pinned messages
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission or the client is missing <see cref="Permissions.ReadMessageHistory"/>.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-		public new Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync()
-		{
-			return this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.News
+		public new Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync() =>
+			this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.News
 				? throw new ArgumentException("A non-thread channel does not have pinned messages.")
 				: this.Discord.ApiClient.GetPinnedMessagesAsync(this.Id);
-		}
 
 		/// <summary>
 		/// Returns a string representation of this thread.
 		/// </summary>
 		/// <returns>String representation of this thread.</returns>
 		public override string ToString()
 		{
 			var threadchannel = (object)this.Type switch
 			{
 				ChannelType.NewsThread => $"News thread {this.Name} ({this.Id})",
 				ChannelType.PublicThread => $"Thread {this.Name} ({this.Id})",
 				ChannelType.PrivateThread => $"Private thread {this.Name} ({this.Id})",
 				_ => $"Thread {this.Name} ({this.Id})",
 			};
 			return threadchannel;
 		}
 		#endregion
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another object.
 		/// </summary>
 		/// <param name="obj">Object to compare to.</param>
 		/// <returns>Whether the object is equal to this <see cref="DiscordThreadChannel"/>.</returns>
 		public override bool Equals(object obj) => this.Equals(obj as DiscordThreadChannel);
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another <see cref="DiscordThreadChannel"/>.
 		/// </summary>
 		/// <param name="e"><see cref="DiscordThreadChannel"/> to compare to.</param>
 		/// <returns>Whether the <see cref="DiscordThreadChannel"/> is equal to this <see cref="DiscordThreadChannel"/>.</returns>
 		public bool Equals(DiscordThreadChannel e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 		/// <summary>
 		/// Gets the hash code for this <see cref="DiscordThreadChannel"/>.
 		/// </summary>
 		/// <returns>The hash code for this <see cref="DiscordThreadChannel"/>.</returns>
 		public override int GetHashCode() => this.Id.GetHashCode();
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordThreadChannel"/> objects are equal.
 		/// </summary>
 		/// <param name="e1">First channel to compare.</param>
 		/// <param name="e2">Second channel to compare.</param>
 		/// <returns>Whether the two channels are equal.</returns>
 		public static bool operator ==(DiscordThreadChannel e1, DiscordThreadChannel e2)
 		{
 			var o1 = e1 as object;
 			var o2 = e2 as object;
 
 			return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 		}
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordThreadChannel"/> objects are not equal.
 		/// </summary>
 		/// <param name="e1">First channel to compare.</param>
 		/// <param name="e2">Second channel to compare.</param>
 		/// <returns>Whether the two channels are not equal.</returns>
 		public static bool operator !=(DiscordThreadChannel e1, DiscordThreadChannel e2)
 			=> !(e1 == e2);
 	}
 }
diff --git a/DisCatSharp/Entities/Thread/DiscordThreadChannelMember.cs b/DisCatSharp/Entities/Thread/DiscordThreadChannelMember.cs
index 8ca671212..d4c0bc959 100644
--- a/DisCatSharp/Entities/Thread/DiscordThreadChannelMember.cs
+++ b/DisCatSharp/Entities/Thread/DiscordThreadChannelMember.cs
@@ -1,137 +1,137 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Globalization;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a discord thread member object.
 	/// </summary>
 	public class DiscordThreadChannelMember : SnowflakeObject, IEquatable<DiscordThreadChannelMember>
 	{
 		/// <summary>
 		/// Gets the id of the user.
 		/// </summary>
 		[JsonProperty("user_id", NullValueHandling = NullValueHandling.Ignore)]
 		public ulong UserId { get; internal set; }
 
 		/// <summary>
 		/// Gets the member object of the user.
 		/// </summary>
 		[JsonProperty("member", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordMember Member { get; internal set; }
 
 		/// <summary>
 		/// Gets the presence of the user.
 		/// </summary>
 		[JsonProperty("presence", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordPresence Presence { get; internal set; }
 
 		/// <summary>
 		/// Gets the timestamp when the user joined the thread.
 		/// </summary>
 		[JsonIgnore]
 		public DateTimeOffset? JoinTimeStamp
 			=> !string.IsNullOrWhiteSpace(this.JoinTimeStampRaw) && DateTimeOffset.TryParse(this.JoinTimeStampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 				dto : null;
 
 		/// <summary>
 		/// Gets the timestamp when the user joined the thread as raw string.
 		/// </summary>
 		[JsonProperty("join_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 		internal string JoinTimeStampRaw { get; set; }
 
 		/// <summary>
 		/// Gets the thread member flags.
 		/// </summary>
 		[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 		public ThreadMemberFlags Flags { get; internal set; }
 
 		/// <summary>
 		/// Gets the category that contains this channel. For threads, gets the channel this thread was created in.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordChannel Thread
-			=> this.Guild != null ? (this.Guild.ThreadsInternal.TryGetValue(this.Id, out var thread) ? thread : null) : null;
+			=> this.Guild != null ? this.Guild.ThreadsInternal.TryGetValue(this.Id, out var thread) ? thread : null : null;
 
 		/// <summary>
 		/// Gets the guild to which this channel belongs.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordGuild Guild
 			=> this.Discord.Guilds.TryGetValue(this.GuildId, out var guild) ? guild : null;
 
 		[JsonIgnore]
 		internal ulong GuildId;
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordThreadChannelMember"/> is equal to another object.
 		/// </summary>
 		/// <param name="obj">Object to compare to.</param>
 		/// <returns>Whether the object is equal to this <see cref="DiscordThreadChannelMember"/>.</returns>
 		public override bool Equals(object obj) => this.Equals(obj as DiscordThreadChannelMember);
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another <see cref="DiscordThreadChannelMember"/>.
 		/// </summary>
 		/// <param name="e"><see cref="DiscordThreadChannel"/> to compare to.</param>
 		/// <returns>Whether the <see cref="DiscordThreadChannel"/> is equal to this <see cref="DiscordThreadChannelMember"/>.</returns>
 		public bool Equals(DiscordThreadChannelMember e) => e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.UserId == e.UserId));
 
 		/// <summary>
 		/// Gets the hash code for this <see cref="DiscordThreadChannelMember"/>.
 		/// </summary>
 		/// <returns>The hash code for this <see cref="DiscordThreadChannelMember"/>.</returns>
 		public override int GetHashCode() => HashCode.Combine(this.Id.GetHashCode(), this.UserId.GetHashCode());
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordThreadChannel"/> objects are equal.
 		/// </summary>
 		/// <param name="e1">First channel to compare.</param>
 		/// <param name="e2">Second channel to compare.</param>
 		/// <returns>Whether the two channels are equal.</returns>
 		public static bool operator ==(DiscordThreadChannelMember e1, DiscordThreadChannelMember e2)
 		{
 			var o1 = e1 as object;
 			var o2 = e2 as object;
 
 			return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1.UserId == e2.UserId));
 		}
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordThreadChannelMember"/> objects are not equal.
 		/// </summary>
 		/// <param name="e1">First channel to compare.</param>
 		/// <param name="e2">Second channel to compare.</param>
 		/// <returns>Whether the two channels are not equal.</returns>
 		public static bool operator !=(DiscordThreadChannelMember e1, DiscordThreadChannelMember e2)
 			=> !(e1 == e2);
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordThreadChannelMember"/> class.
 		/// </summary>
 		internal DiscordThreadChannelMember() { }
 	}
 }
diff --git a/DisCatSharp/Entities/User/DiscordActivity.cs b/DisCatSharp/Entities/User/DiscordActivity.cs
index 59888101e..0560cefb7 100644
--- a/DisCatSharp/Entities/User/DiscordActivity.cs
+++ b/DisCatSharp/Entities/User/DiscordActivity.cs
@@ -1,528 +1,526 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using DisCatSharp.Net.Abstractions;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents user status.
 	/// </summary>
 	[JsonConverter(typeof(UserStatusConverter))]
 	public enum UserStatus
 	{
 		/// <summary>
 		/// User is offline.
 		/// </summary>
 		Offline = 0,
 
 		/// <summary>
 		/// User is online.
 		/// </summary>
 		Online = 1,
 
 		/// <summary>
 		/// User is idle.
 		/// </summary>
 		Idle = 2,
 
 		/// <summary>
 		/// User asked not to be disturbed.
 		/// </summary>
 		DoNotDisturb = 4,
 
 		/// <summary>
 		/// User is invisible. They will appear as Offline to anyone but themselves.
 		/// </summary>
 		Invisible = 5,
 
 		/// <summary>
 		/// User is streaming.
 		/// </summary>
 		Streaming = 6
 	}
 
 	/// <summary>
 	/// Represents a user status converter.
 	/// </summary>
 	internal sealed class UserStatusConverter : JsonConverter
 	{
 		/// <summary>
 		/// Writes the json.
 		/// </summary>
 		/// <param name="writer">The writer.</param>
 		/// <param name="value">The value.</param>
 		/// <param name="serializer">The serializer.</param>
 		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 		{
 			if (value is UserStatus status)
 			{
 				switch (status) // reader.Value can be a string, DateTime or DateTimeOffset (yes, it's weird)
 				{
 					case UserStatus.Online:
 						writer.WriteValue("online");
 						return;
 
 					case UserStatus.Idle:
 						writer.WriteValue("idle");
 						return;
 
 					case UserStatus.DoNotDisturb:
 						writer.WriteValue("dnd");
 						return;
 
 					case UserStatus.Invisible:
 						writer.WriteValue("invisible");
 						return;
 
 					case UserStatus.Streaming:
 						writer.WriteValue("streaming");
 						return;
 
 					case UserStatus.Offline:
 					default:
 						writer.WriteValue("offline");
 						return;
 				}
 			}
 		}
 
 		/// <summary>
 		/// Reads the json.
 		/// </summary>
 		/// <param name="reader">The reader.</param>
 		/// <param name="objectType">The object type.</param>
 		/// <param name="existingValue">The existing value.</param>
 		/// <param name="serializer">The serializer.</param>
-		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-		{
+		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) =>
 			// Active sessions are indicated with an "online", "idle", or "dnd" string per platform. If a user is
 			// offline or invisible, the corresponding field is not present.
-			return (reader.Value?.ToString().ToLowerInvariant()) switch // reader.Value can be a string, DateTime or DateTimeOffset (yes, it's weird)
+			reader.Value?.ToString().ToLowerInvariant() switch // reader.Value can be a string, DateTime or DateTimeOffset (yes, it's weird)
 			{
 				"online" => UserStatus.Online,
 				"idle" => UserStatus.Idle,
 				"dnd" => UserStatus.DoNotDisturb,
 				"invisible" => UserStatus.Invisible,
 				"streaming" => UserStatus.Streaming,
 				_ => UserStatus.Offline,
 			};
-		}
 
 		/// <summary>
 		/// Whether this user5 status can be converted.
 		/// </summary>
 		/// <param name="objectType">The object type.</param>
 		/// <returns>A bool.</returns>
 		public override bool CanConvert(Type objectType) => objectType == typeof(UserStatus);
 	}
 
 	/// <summary>
 	/// Represents a game that a user is playing.
 	/// </summary>
 	public sealed class DiscordActivity
 	{
 		/// <summary>
 		/// Gets or sets the id of user's activity.
 		/// </summary>
 		public string Id { get; set; }
 
 		/// <summary>
 		/// Gets or sets the name of user's activity.
 		/// </summary>
 		public string Name { get; set; }
 
 		/// <summary>
 		/// Gets or sets the stream URL, if applicable.
 		/// </summary>
 		public string StreamUrl { get; set; }
 
 		/// <summary>
 		/// Gets or sets platform in this rich presence.
 		/// </summary>
 		public string Platform { get; set; }
 
 		/// <summary>
 		/// Gets or sets sync_id in this rich presence.
 		/// </summary>
 		public string SyncId { get; set; }
 
 		/// <summary>
 		/// Gets or sets session_id in this rich presence.
 		/// </summary>
 		public string SessionId { get; set; }
 
 		/// <summary>
 		/// Gets or sets the activity type.
 		/// </summary>
 		public ActivityType ActivityType { get; set; }
 
 		/// <summary>
 		/// Gets the rich presence details, if present.
 		/// </summary>
 		public DiscordRichPresence RichPresence { get; internal set; }
 
 		/// <summary>
 		/// Gets the custom status of this activity, if present.
 		/// </summary>
 		public DiscordCustomStatus CustomStatus { get; internal set; }
 
 		/// <summary>
 		/// Creates a new, empty instance of a <see cref="DiscordActivity"/>.
 		/// </summary>
 		public DiscordActivity()
 		{
 			this.ActivityType = ActivityType.Playing;
 		}
 
 		/// <summary>
 		/// Creates a new instance of a <see cref="DiscordActivity"/> with specified name.
 		/// </summary>
 		/// <param name="name">Name of the activity.</param>
 		public DiscordActivity(string name)
 		{
 			this.Name = name;
 			this.ActivityType = ActivityType.Playing;
 		}
 
 		/// <summary>
 		/// Creates a new instance of a <see cref="DiscordActivity"/> with specified name.
 		/// </summary>
 		/// <param name="name">Name of the activity.</param>
 		/// <param name="type">Type of the activity.</param>
 		public DiscordActivity(string name, ActivityType type)
 		{
 			if (type == ActivityType.Custom)
 				throw new InvalidOperationException("Bots cannot use a custom status.");
 
 			this.Name = name;
 			this.ActivityType = type;
 		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordActivity"/> class.
 		/// </summary>
 		/// <param name="rawActivity">The raw activity.</param>
 		internal DiscordActivity(TransportActivity rawActivity)
 		{
 			this.UpdateWith(rawActivity);
 		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordActivity"/> class.
 		/// </summary>
 		/// <param name="other">The other.</param>
 		internal DiscordActivity(DiscordActivity other)
 		{
 			this.Name = other.Name;
 			this.ActivityType = other.ActivityType;
 			this.StreamUrl = other.StreamUrl;
 			this.SessionId = other.SessionId;
 			this.SyncId = other.SyncId;
 			this.Platform = other.Platform;
 			this.RichPresence = new DiscordRichPresence(other.RichPresence);
 			this.CustomStatus = new DiscordCustomStatus(other.CustomStatus);
 		}
 
 		/// <summary>
 		/// Updates a activity with an transport activity.
 		/// </summary>
 		/// <param name="rawActivity">The raw activity.</param>
 		internal void UpdateWith(TransportActivity rawActivity)
 		{
 			this.Name = rawActivity?.Name;
 			this.ActivityType = rawActivity != null ? rawActivity.ActivityType : ActivityType.Playing;
 			this.StreamUrl = rawActivity?.StreamUrl;
 			this.SessionId = rawActivity?.SessionId;
 			this.SyncId = rawActivity?.SyncId;
 			this.Platform = rawActivity?.Platform;
 
 			if (rawActivity?.IsRichPresence() == true && this.RichPresence != null)
 				this.RichPresence.UpdateWith(rawActivity);
 			else this.RichPresence = rawActivity?.IsRichPresence() == true ? new DiscordRichPresence(rawActivity) : null;
 
 			if (rawActivity?.IsCustomStatus() == true && this.CustomStatus != null)
 				this.CustomStatus.UpdateWith(rawActivity.State, rawActivity.Emoji);
 			else this.CustomStatus = rawActivity?.IsCustomStatus() == true
 				? new DiscordCustomStatus
 				{
 					Name = rawActivity.State,
 					Emoji = rawActivity.Emoji
 				}
 				: null;
 		}
 	}
 
 	/// <summary>
 	/// Represents details for a custom status activity, attached to a <see cref="DiscordActivity"/>.
 	/// </summary>
 	public sealed class DiscordCustomStatus
 	{
 		/// <summary>
 		/// Gets the name of this custom status.
 		/// </summary>
 		public string Name { get; internal set; }
 
 		/// <summary>
 		/// Gets the emoji of this custom status, if any.
 		/// </summary>
 		public DiscordEmoji Emoji { get; internal set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordCustomStatus"/> class.
 		/// </summary>
 		internal DiscordCustomStatus() { }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordCustomStatus"/> class.
 		/// </summary>
 		/// <param name="other">The other.</param>
 		internal DiscordCustomStatus(DiscordCustomStatus other)
 		{
 			this.Name = other.Name;
 			this.Emoji = other.Emoji;
 		}
 
 		/// <summary>
 		/// Updates a discord status.
 		/// </summary>
 		/// <param name="state">The state.</param>
 		/// <param name="emoji">The emoji.</param>
 		internal void UpdateWith(string state, DiscordEmoji emoji)
 		{
 			this.Name = state;
 			this.Emoji = emoji;
 		}
 	}
 
 	/// <summary>
 	/// Represents details for Discord rich presence, attached to a <see cref="DiscordActivity"/>.
 	/// </summary>
 	public sealed class DiscordRichPresence
 	{
 		/// <summary>
 		/// Gets the details of this presence.
 		/// </summary>
 		public string Details { get; internal set; }
 
 		/// <summary>
 		/// Gets the game state.
 		/// </summary>
 		public string State { get; internal set; }
 
 		/// <summary>
 		/// Gets the application for which the rich presence is for.
 		/// </summary>
 		public DiscordApplication Application { get; internal set; }
 
 		/// <summary>
 		/// Gets the instance status.
 		/// </summary>
 		public bool? Instance { get; internal set; }
 
 		/// <summary>
 		/// Gets the large image for the rich presence.
 		/// </summary>
 		public DiscordAsset LargeImage { get; internal set; }
 
 		/// <summary>
 		/// Gets the hovertext for large image.
 		/// </summary>
 		public string LargeImageText { get; internal set; }
 
 		/// <summary>
 		/// Gets the small image for the rich presence.
 		/// </summary>
 		public DiscordAsset SmallImage { get; internal set; }
 
 		/// <summary>
 		/// Gets the hovertext for small image.
 		/// </summary>
 		public string SmallImageText { get; internal set; }
 
 		/// <summary>
 		/// Gets the current party size.
 		/// </summary>
 		public long? CurrentPartySize { get; internal set; }
 
 		/// <summary>
 		/// Gets the maximum party size.
 		/// </summary>
 		public long? MaximumPartySize { get; internal set; }
 
 		/// <summary>
 		/// Gets the party ID.
 		/// </summary>
 		public ulong? PartyId { get; internal set; }
 
 		/// <summary>
 		/// Gets the buttons.
 		/// </summary>
 		public IReadOnlyList<string> Buttons { get; internal set; }
 
 		/// <summary>
 		/// Gets the game start timestamp.
 		/// </summary>
 		public DateTimeOffset? StartTimestamp { get; internal set; }
 
 		/// <summary>
 		/// Gets the game end timestamp.
 		/// </summary>
 		public DateTimeOffset? EndTimestamp { get; internal set; }
 
 		/// <summary>
 		/// Gets the secret value enabling users to join your game.
 		/// </summary>
 		public string JoinSecret { get; internal set; }
 
 		/// <summary>
 		/// Gets the secret value enabling users to receive notifications whenever your game state changes.
 		/// </summary>
 		public string MatchSecret { get; internal set; }
 
 		/// <summary>
 		/// Gets the secret value enabling users to spectate your game.
 		/// </summary>
 		public string SpectateSecret { get; internal set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordRichPresence"/> class.
 		/// </summary>
 		internal DiscordRichPresence() { }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordRichPresence"/> class.
 		/// </summary>
 		/// <param name="rawGame">The raw game.</param>
 		internal DiscordRichPresence(TransportActivity rawGame)
 		{
 			this.UpdateWith(rawGame);
 		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordRichPresence"/> class.
 		/// </summary>
 		/// <param name="other">The other.</param>
 		internal DiscordRichPresence(DiscordRichPresence other)
 		{
 			this.Details = other.Details;
 			this.State = other.State;
 			this.Application = other.Application;
 			this.Instance = other.Instance;
 			this.LargeImageText = other.LargeImageText;
 			this.SmallImageText = other.SmallImageText;
 			this.LargeImage = other.LargeImage;
 			this.SmallImage = other.SmallImage;
 			this.CurrentPartySize = other.CurrentPartySize;
 			this.MaximumPartySize = other.MaximumPartySize;
 			this.PartyId = other.PartyId;
 			this.Buttons = other.Buttons;
 			this.StartTimestamp = other.StartTimestamp;
 			this.EndTimestamp = other.EndTimestamp;
 			this.JoinSecret = other.JoinSecret;
 			this.MatchSecret = other.MatchSecret;
 			this.SpectateSecret = other.SpectateSecret;
 		}
 
 		/// <summary>
 		/// Updates a game activity with an transport activity.
 		/// </summary>
 		/// <param name="rawGame">The raw game.</param>
 		internal void UpdateWith(TransportActivity rawGame)
 		{
 			this.Details = rawGame?.Details;
 			this.State = rawGame?.State;
 			this.Application = rawGame?.ApplicationId != null ? new DiscordApplication { Id = rawGame.ApplicationId.Value } : null;
 			this.Instance = rawGame?.Instance;
 			this.LargeImageText = rawGame?.Assets?.LargeImageText;
 			this.SmallImageText = rawGame?.Assets?.SmallImageText;
 			this.CurrentPartySize = rawGame?.Party?.Size?.Current;
 			this.MaximumPartySize = rawGame?.Party?.Size?.Maximum;
 			if (rawGame?.Party != null && ulong.TryParse(rawGame.Party.Id, NumberStyles.Number, CultureInfo.InvariantCulture, out var partyId))
 				this.PartyId = partyId;
 			this.Buttons = rawGame?.Buttons;
 			this.StartTimestamp = rawGame?.Timestamps?.Start;
 			this.EndTimestamp = rawGame?.Timestamps?.End;
 			this.JoinSecret = rawGame?.Secrets?.Join;
 			this.MatchSecret = rawGame?.Secrets?.Match;
 			this.SpectateSecret = rawGame?.Secrets?.Spectate;
 
 			var lid = rawGame?.Assets?.LargeImage;
 			if (lid != null)
 			{
 				if (lid.StartsWith("spotify:"))
 					this.LargeImage = new DiscordSpotifyAsset { Id = lid };
 				else if (ulong.TryParse(lid, NumberStyles.Number, CultureInfo.InvariantCulture, out var ulid))
 					this.LargeImage = new DiscordApplicationAsset { Id = lid, Application = this.Application, Type = ApplicationAssetType.LargeImage };
 			}
 
 			var sid = rawGame?.Assets?.SmallImage;
 			if (sid != null)
 			{
 				if (sid.StartsWith("spotify:"))
 					this.SmallImage = new DiscordSpotifyAsset { Id = sid };
 				else if (ulong.TryParse(sid, NumberStyles.Number, CultureInfo.InvariantCulture, out var usid))
 					this.SmallImage = new DiscordApplicationAsset { Id = sid, Application = this.Application, Type = ApplicationAssetType.LargeImage };
 			}
 		}
 	}
 
 	/// <summary>
 	/// Determines the type of a user activity.
 	/// </summary>
 	public enum ActivityType
 	{
 		/// <summary>
 		/// Indicates the user is playing a game.
 		/// </summary>
 		Playing = 0,
 
 		/// <summary>
 		/// Indicates the user is streaming a game.
 		/// </summary>
 		Streaming = 1,
 
 		/// <summary>
 		/// Indicates the user is listening to something.
 		/// </summary>
 		ListeningTo = 2,
 
 		/// <summary>
 		/// Indicates the user is watching something.
 		/// </summary>
 		Watching = 3,
 
 		/// <summary>
 		/// Indicates the current activity is a custom status.
 		/// </summary>
 		Custom = 4,
 
 		/// <summary>
 		/// Indicates the user is competing in something.
 		/// </summary>
 		Competing = 5
 	}
 }
diff --git a/DisCatSharp/Entities/User/DiscordUser.cs b/DisCatSharp/Entities/User/DiscordUser.cs
index 661a7b1b2..cbdd1307f 100644
--- a/DisCatSharp/Entities/User/DiscordUser.cs
+++ b/DisCatSharp/Entities/User/DiscordUser.cs
@@ -1,433 +1,433 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Threading.Tasks;
 using DisCatSharp.Enums;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a Discord user.
 	/// </summary>
 	public class DiscordUser : SnowflakeObject, IEquatable<DiscordUser>
 	{
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordUser"/> class.
 		/// </summary>
 		internal DiscordUser() { }
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordUser"/> class.
 		/// </summary>
 		/// <param name="transport">The transport.</param>
 		internal DiscordUser(TransportUser transport)
 		{
 			this.Id = transport.Id;
 			this.Username = transport.Username;
 			this.Discriminator = transport.Discriminator;
 			this.AvatarHash = transport.AvatarHash;
 			this.BannerHash = transport.BannerHash;
 			this.BannerColorInternal = transport.BannerColor;
 			this.IsBot = transport.IsBot;
 			this.MfaEnabled = transport.MfaEnabled;
 			this.Verified = transport.Verified;
 			this.Email = transport.Email;
 			this.PremiumType = transport.PremiumType;
 			this.Locale = transport.Locale;
 			this.Flags = transport.Flags;
 			this.OAuthFlags = transport.OAuthFlags;
 			this.Bio = transport.Bio;
 		}
 
 		/// <summary>
 		/// Gets this user's username.
 		/// </summary>
 		[JsonProperty("username", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual string Username { get; internal set; }
 
 		/// <summary>
 		/// Gets this user's username with the discriminator.
 		/// Example: Discord#0000
 		/// </summary>
 		[JsonIgnore]
 		public virtual string UsernameWithDiscriminator
 			=> $"{this.Username}#{this.Discriminator}";
 
 		/// <summary>
 		/// Gets the user's 4-digit discriminator.
 		/// </summary>
 		[JsonProperty("discriminator", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual string Discriminator { get; internal set; }
 
 		/// <summary>
 		/// Gets the discriminator integer.
 		/// </summary>
 		[JsonIgnore]
 		internal int DiscriminatorInt
 			=> int.Parse(this.Discriminator, NumberStyles.Integer, CultureInfo.InvariantCulture);
 
 		/// <summary>
 		/// Gets the user's banner color, if set. Mutually exclusive with <see cref="BannerHash"/>.
 		/// </summary>
 		public virtual DiscordColor? BannerColor
 			=> !this.BannerColorInternal.HasValue ? null : new DiscordColor(this.BannerColorInternal.Value);
 
 		[JsonProperty("accent_color")]
 		internal int? BannerColorInternal;
 
 		/// <summary>
 		/// Gets the user's banner url
 		/// </summary>
 		[JsonIgnore]
 		public string BannerUrl
 			=> string.IsNullOrWhiteSpace(this.BannerHash) ? null : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.BANNERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}?size=4096";
 
 		/// <summary>
 		/// Gets the user's profile banner hash. Mutually exclusive with <see cref="BannerColor"/>.
 		/// </summary>
 		[JsonProperty("banner", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual string BannerHash { get; internal set; }
 
 		/// <summary>
 		/// Gets the users bio.
 		/// This is not available to bots tho.
 		/// </summary>
 		[JsonProperty("bio", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual string Bio { get; internal set; }
 
 		/// <summary>
 		/// Gets the user's avatar hash.
 		/// </summary>
 		[JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual string AvatarHash { get; internal set; }
 
 		/// <summary>
 		/// Returns a uri to this users profile.
 		/// </summary>
 		public Uri ProfileUri => new($"{DiscordDomain.GetDomain(CoreDomain.Discord).Url}{Endpoints.USERS}/{this.Id}");
 
 		/// <summary>
 		/// Returns a string representing the direct URL to this users profile.
 		/// </summary>
 		/// <returns>The URL of this users profile.</returns>
 		public string ProfileUrl => this.ProfileUri.AbsoluteUri;
 
 		/// <summary>
 		/// Gets the user's avatar URL.s
 		/// </summary>
 		[JsonIgnore]
 		public string AvatarUrl
 			=> string.IsNullOrWhiteSpace(this.AvatarHash) ? this.DefaultAvatarUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.AvatarHash}.{(this.AvatarHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 		/// <summary>
 		/// Gets the URL of default avatar for this user.
 		/// </summary>
 		[JsonIgnore]
 		public string DefaultAvatarUrl
 			=> $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.EMBED}{Endpoints.AVATARS}/{(this.DiscriminatorInt % 5).ToString(CultureInfo.InvariantCulture)}.png?size=1024";
 
 		/// <summary>
 		/// Gets whether the user is a bot.
 		/// </summary>
 		[JsonProperty("bot", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual bool IsBot { get; internal set; }
 
 		/// <summary>
 		/// Gets whether the user has multi-factor authentication enabled.
 		/// </summary>
 		[JsonProperty("mfa_enabled", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual bool? MfaEnabled { get; internal set; }
 
 		/// <summary>
 		/// Gets whether the user is an official Discord system user.
 		/// </summary>
 		[JsonProperty("system", NullValueHandling = NullValueHandling.Ignore)]
 		public bool? IsSystem { get; internal set; }
 
 		/// <summary>
 		/// Gets whether the user is verified.
 		/// <para>This is only present in OAuth.</para>
 		/// </summary>
 		[JsonProperty("verified", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual bool? Verified { get; internal set; }
 
 		/// <summary>
 		/// Gets the user's email address.
 		/// <para>This is only present in OAuth.</para>
 		/// </summary>
 		[JsonProperty("email", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual string Email { get; internal set; }
 
 		/// <summary>
 		/// Gets the user's premium type.
 		/// </summary>
 		[JsonProperty("premium_type", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual PremiumType? PremiumType { get; internal set; }
 
 		/// <summary>
 		/// Gets the user's chosen language
 		/// </summary>
 		[JsonProperty("locale", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual string Locale { get; internal set; }
 
 		/// <summary>
 		/// Gets the user's flags for OAuth.
 		/// </summary>
 		[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual UserFlags? OAuthFlags { get; internal set; }
 
 		/// <summary>
 		/// Gets the user's flags.
 		/// </summary>
 		[JsonProperty("public_flags", NullValueHandling = NullValueHandling.Ignore)]
 		public virtual UserFlags? Flags { get; internal set; }
 
 		/// <summary>
 		/// Gets the user's mention string.
 		/// </summary>
 		[JsonIgnore]
 		public string Mention
 			=> Formatter.Mention(this, this is DiscordMember);
 
 		/// <summary>
 		/// Gets whether this user is the Client which created this object.
 		/// </summary>
 		[JsonIgnore]
 		public bool IsCurrent
 			=> this.Id == this.Discord.CurrentUser.Id;
 
 		#region Extension of DiscordUser
 
 		/// <summary>
 		/// Whether this member is a <see cref="UserFlags.CertifiedModerator"/>
 		/// </summary>
 		/// <returns><see cref="bool"/></returns>
 		[JsonIgnore]
 		public bool IsMod
 				=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.CertifiedModerator);
 
 		/// <summary>
 		/// Whether this member is a <see cref="UserFlags.Partner"/>
 		/// </summary>
 		/// <returns><see cref="bool"/></returns>
 		[JsonIgnore]
 		public bool IsPartner
 				=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.Partner);
 
 		/// <summary>
 		/// Whether this member is a <see cref="UserFlags.VerifiedBot"/>
 		/// </summary>
 		/// <returns><see cref="bool"/></returns>
 		[JsonIgnore]
 		public bool IsVerifiedBot
 				=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.VerifiedBot);
 
 		/// <summary>
 		/// Whether this member is a <see cref="UserFlags.VerifiedDeveloper"/>
 		/// </summary>
 		/// <returns><see cref="bool"/></returns>
 		[JsonIgnore]
 		public bool IsBotDev
 				=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.VerifiedDeveloper);
 
 		/// <summary>
 		/// Whether this member is a <see cref="UserFlags.Staff"/>
 		/// </summary>
 		/// <returns><see cref="bool"/></returns>
 		[JsonIgnore]
 		public bool IsStaff
 				=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.Staff);
 
 		#endregion
 
 		/// <summary>
 		/// Whether this user is in a <see cref="DiscordGuild"/>
 		/// </summary>
 		/// <example>
 		/// <code>
 		/// DiscordGuild guild = await Client.GetGuildAsync(806675511555915806);
 		/// DiscordUser user = await Client.GetUserAsync(469957180968271873);
 		/// Console.WriteLine($"{user.Username} {(user.IsInGuild(guild) ? "is a" : "is not a")} member of {guild.Name}");
 		/// </code>
 		/// results to <c>J_M_Lutra is a member of Project Nyaw~</c>.
 		/// </example>
 		/// <param name="guild"><see cref="DiscordGuild"/></param>
 		/// <returns><see cref="bool"/></returns>
 		[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>")]
 		public async Task<bool> IsInGuild(DiscordGuild guild)
 		{
 			try
 			{
 				var member = await guild.GetMemberAsync(this.Id);
 				return member is not null;
 
 			}
 			catch (NotFoundException)
 			{
 				return false;
 			}
 		}
 
 		/// <summary>
 		/// Whether this user is not in a <see cref="DiscordGuild"/>
 		/// </summary>
 		/// <param name="guild"><see cref="DiscordGuild"/></param>
 		/// <returns><see cref="bool"/></returns>
 		[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>")]
 		public async Task<bool> IsNotInGuild(DiscordGuild guild) => !await this.IsInGuild(guild);
 
 		/// <summary>
 		/// Unbans this user from a guild.
 		/// </summary>
 		/// <param name="guild">Guild to unban this user from.</param>
 		/// <param name="reason">Reason for audit logs.</param>
 		/// <returns></returns>
 		/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 		/// <exception cref="Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
 		/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task UnbanAsync(DiscordGuild guild, string reason = null)
 			=> guild.UnbanMemberAsync(this, reason);
 
 		/// <summary>
 		/// Gets this user's presence.
 		/// </summary>
 		[JsonIgnore]
 		public DiscordPresence Presence
 			=> this.Discord is DiscordClient dc ? dc.Presences.TryGetValue(this.Id, out var presence) ? presence : null : null;
 
 		/// <summary>
 		/// Gets the user's avatar URL, in requested format and size.
 		/// </summary>
 		/// <param name="fmt">Format of the avatar to get.</param>
 		/// <param name="size">Maximum size of the avatar. Must be a power of two, minimum 16, maximum 2048.</param>
 		/// <returns>URL of the user's avatar.</returns>
 		public string GetAvatarUrl(ImageFormat fmt, ushort size = 1024)
 		{
 			if (fmt == ImageFormat.Unknown)
 				throw new ArgumentException("You must specify valid image format.", nameof(fmt));
 
 			if (size < 16 || size > 2048)
 				throw new ArgumentOutOfRangeException(nameof(size));
 
 			var log = Math.Log(size, 2);
 			if (log < 4 || log > 11 || log % 1 != 0)
 				throw new ArgumentOutOfRangeException(nameof(size));
 
 			var sfmt = "";
 			sfmt = fmt switch
 			{
 				ImageFormat.Gif => "gif",
 				ImageFormat.Jpeg => "jpg",
 				ImageFormat.Png => "png",
 				ImageFormat.WebP => "webp",
-				ImageFormat.Auto => !string.IsNullOrWhiteSpace(this.AvatarHash) ? (this.AvatarHash.StartsWith("a_") ? "gif" : "png") : "png",
+				ImageFormat.Auto => !string.IsNullOrWhiteSpace(this.AvatarHash) ? this.AvatarHash.StartsWith("a_") ? "gif" : "png" : "png",
 				_ => throw new ArgumentOutOfRangeException(nameof(fmt)),
 			};
 			var ssize = size.ToString(CultureInfo.InvariantCulture);
 			if (!string.IsNullOrWhiteSpace(this.AvatarHash))
 			{
 				var id = this.Id.ToString(CultureInfo.InvariantCulture);
 				return $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS}/{id}/{this.AvatarHash}.{sfmt}?size={ssize}";
 			}
 			else
 			{
 				var type = (this.DiscriminatorInt % 5).ToString(CultureInfo.InvariantCulture);
 				return $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.EMBED}{Endpoints.AVATARS}/{type}.{sfmt}?size={ssize}";
 			}
 		}
 
 		/// <summary>
 		/// Returns a string representation of this user.
 		/// </summary>
 		/// <returns>String representation of this user.</returns>
 		public override string ToString() => $"User {this.Id}; {this.Username}#{this.Discriminator}";
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordUser"/> is equal to another object.
 		/// </summary>
 		/// <param name="obj">Object to compare to.</param>
 		/// <returns>Whether the object is equal to this <see cref="DiscordUser"/>.</returns>
 		public override bool Equals(object obj) => this.Equals(obj as DiscordUser);
 
 		/// <summary>
 		/// Checks whether this <see cref="DiscordUser"/> is equal to another <see cref="DiscordUser"/>.
 		/// </summary>
 		/// <param name="e"><see cref="DiscordUser"/> to compare to.</param>
 		/// <returns>Whether the <see cref="DiscordUser"/> is equal to this <see cref="DiscordUser"/>.</returns>
 		public bool Equals(DiscordUser e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 		/// <summary>
 		/// Gets the hash code for this <see cref="DiscordUser"/>.
 		/// </summary>
 		/// <returns>The hash code for this <see cref="DiscordUser"/>.</returns>
 		public override int GetHashCode() => this.Id.GetHashCode();
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordUser"/> objects are equal.
 		/// </summary>
 		/// <param name="e1">First user to compare.</param>
 		/// <param name="e2">Second user to compare.</param>
 		/// <returns>Whether the two users are equal.</returns>
 		public static bool operator ==(DiscordUser e1, DiscordUser e2)
 		{
 			var o1 = e1 as object;
 			var o2 = e2 as object;
 
 			return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 		}
 
 		/// <summary>
 		/// Gets whether the two <see cref="DiscordUser"/> objects are not equal.
 		/// </summary>
 		/// <param name="e1">First user to compare.</param>
 		/// <param name="e2">Second user to compare.</param>
 		/// <returns>Whether the two users are not equal.</returns>
 		public static bool operator !=(DiscordUser e1, DiscordUser e2)
 			=> !(e1 == e2);
 	}
 
 	/// <summary>
 	/// Represents a user comparer.
 	/// </summary>
 	internal class DiscordUserComparer : IEqualityComparer<DiscordUser>
 	{
 		/// <summary>
 		/// Whether the users are equal.
 		/// </summary>
 		/// <param name="x">The first user</param>
 		/// <param name="y">The second user.</param>
 		public bool Equals(DiscordUser x, DiscordUser y) => x.Equals(y);
 
 		/// <summary>
 		/// Gets the hash code.
 		/// </summary>
 		/// <param name="obj">The user.</param>
 		public int GetHashCode(DiscordUser obj) => obj.Id.GetHashCode();
 	}
 }
diff --git a/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs b/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
index f2170ef18..c3f49ed87 100644
--- a/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
+++ b/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
@@ -1,442 +1,442 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Constructs ready-to-send webhook requests.
 	/// </summary>
 	public sealed class DiscordWebhookBuilder
 	{
 		/// <summary>
 		/// Username to use for this webhook request.
 		/// </summary>
 		public Optional<string> Username { get; set; }
 
 		/// <summary>
 		/// Avatar url to use for this webhook request.
 		/// </summary>
 		public Optional<string> AvatarUrl { get; set; }
 
 		/// <summary>
 		/// Whether this webhook request is text-to-speech.
 		/// </summary>
 		public bool IsTts { get; set; }
 
 		/// <summary>
 		/// Message to send on this webhook request.
 		/// </summary>
 		public string Content
 		{
 			get => this._content;
 			set
 			{
 				if (value != null && value.Length > 2000)
 					throw new ArgumentException("Content length cannot exceed 2000 characters.", nameof(value));
 				this._content = value;
 			}
 		}
 		private string _content;
 
 		/// <summary>
 		/// Whether to keep previous attachments.
 		/// </summary>
-		internal bool? KeepAttachmentsInternal = null;
+		internal bool? KeepAttachmentsInternal;
 
 		/// <summary>
 		/// Embeds to send on this webhook request.
 		/// </summary>
 		public IReadOnlyList<DiscordEmbed> Embeds => this._embeds;
 		private readonly List<DiscordEmbed> _embeds = new();
 
 		/// <summary>
 		/// Files to send on this webhook request.
 		/// </summary>
 		public IReadOnlyList<DiscordMessageFile> Files => this._files;
 		private readonly List<DiscordMessageFile> _files = new();
 
 		/// <summary>
 		/// Mentions to send on this webhook request.
 		/// </summary>
 		public IReadOnlyList<IMention> Mentions => this._mentions;
 		private readonly List<IMention> _mentions = new();
 
 		/// <summary>
 		/// Gets the components.
 		/// </summary>
 		public IReadOnlyList<DiscordActionRowComponent> Components => this._components;
 		private readonly List<DiscordActionRowComponent> _components = new();
 
 
 		/// <summary>
 		/// Attachments to keep on this webhook request.
 		/// </summary>
 		public IEnumerable<DiscordAttachment> Attachments => this.AttachmentsInternal;
 		internal readonly List<DiscordAttachment> AttachmentsInternal = new();
 
 		/// <summary>
 		/// Constructs a new empty webhook request builder.
 		/// </summary>
 		public DiscordWebhookBuilder() { } // I still see no point in initializing collections with empty collections. //
 
 
 		/// <summary>
 		/// Adds a row of components to the builder, up to 5 components per row, and up to 5 rows per message.
 		/// </summary>
 		/// <param name="components">The components to add to the builder.</param>
 		/// <returns>The current builder to be chained.</returns>
 		/// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
 		public DiscordWebhookBuilder AddComponents(params DiscordComponent[] components)
 			=> this.AddComponents((IEnumerable<DiscordComponent>)components);
 
 
 		/// <summary>
 		/// Appends several rows of components to the builder
 		/// </summary>
 		/// <param name="components">The rows of components to add, holding up to five each.</param>
 		/// <returns></returns>
 		public DiscordWebhookBuilder AddComponents(IEnumerable<DiscordActionRowComponent> components)
 		{
 			var ara = components.ToArray();
 
 			if (ara.Length + this._components.Count > 5)
 				throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
 			foreach (var ar in ara)
 				this._components.Add(ar);
 
 			return this;
 		}
 
 		/// <summary>
 		/// Adds a row of components to the builder, up to 5 components per row, and up to 5 rows per message.
 		/// </summary>
 		/// <param name="components">The components to add to the builder.</param>
 		/// <returns>The current builder to be chained.</returns>
 		/// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
 		public DiscordWebhookBuilder AddComponents(IEnumerable<DiscordComponent> components)
 		{
 			var cmpArr = components.ToArray();
 			var count = cmpArr.Length;
 
 			if (!cmpArr.Any())
 				throw new ArgumentOutOfRangeException(nameof(components), "You must provide at least one component");
 
 			if (count > 5)
 				throw new ArgumentException("Cannot add more than 5 components per action row!");
 
 			var comp = new DiscordActionRowComponent(cmpArr);
 			this._components.Add(comp);
 
 			return this;
 		}
 
 		/// <summary>
 		/// Sets the username for this webhook builder.
 		/// </summary>
 		/// <param name="username">Username of the webhook</param>
 		public DiscordWebhookBuilder WithUsername(string username)
 		{
 			this.Username = username;
 			return this;
 		}
 
 		/// <summary>
 		/// Sets the avatar of this webhook builder from its url.
 		/// </summary>
 		/// <param name="avatarUrl">Avatar url of the webhook</param>
 		public DiscordWebhookBuilder WithAvatarUrl(string avatarUrl)
 		{
 			this.AvatarUrl = avatarUrl;
 			return this;
 		}
 
 		/// <summary>
 		/// Indicates if the webhook must use text-to-speech.
 		/// </summary>
 		/// <param name="tts">Text-to-speech</param>
 		public DiscordWebhookBuilder WithTts(bool tts)
 		{
 			this.IsTts = tts;
 			return this;
 		}
 
 		/// <summary>
 		/// Sets the message to send at the execution of the webhook.
 		/// </summary>
 		/// <param name="content">Message to send.</param>
 		public DiscordWebhookBuilder WithContent(string content)
 		{
 			this.Content = content;
 			return this;
 		}
 
 		/// <summary>
 		/// Adds an embed to send at the execution of the webhook.
 		/// </summary>
 		/// <param name="embed">Embed to add.</param>
 		public DiscordWebhookBuilder AddEmbed(DiscordEmbed embed)
 		{
 			if (embed != null)
 				this._embeds.Add(embed);
 
 			return this;
 		}
 
 		/// <summary>
 		/// Adds the given embeds to send at the execution of the webhook.
 		/// </summary>
 		/// <param name="embeds">Embeds to add.</param>
 		public DiscordWebhookBuilder AddEmbeds(IEnumerable<DiscordEmbed> embeds)
 		{
 			this._embeds.AddRange(embeds);
 			return this;
 		}
 
 		/// <summary>
 		/// Adds a file to send at the execution of the webhook.
 		/// </summary>
 		/// <param name="filename">Name of the file.</param>
 		/// <param name="data">File data.</param>
 		/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 		/// <param name="description">Description of the file.</param>
 		public DiscordWebhookBuilder AddFile(string filename, Stream data, bool resetStreamPosition = false, string description = null)
 		{
 			if (this.Files.Count() > 10)
 				throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 			if (this._files.Any(x => x.FileName == filename))
 				throw new ArgumentException("A File with that filename already exists");
 
 			if (resetStreamPosition)
 				this._files.Add(new DiscordMessageFile(filename, data, data.Position, description: description));
 			else
 				this._files.Add(new DiscordMessageFile(filename, data, null, description: description));
 
 			return this;
 		}
 
 		/// <summary>
 		/// Sets if the message has files to be sent.
 		/// </summary>
 		/// <param name="stream">The Stream to the file.</param>
 		/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 		/// <param name="description">Description of the file.</param>
 		/// <returns></returns>
 		public DiscordWebhookBuilder AddFile(FileStream stream, bool resetStreamPosition = false, string description = null)
 		{
 			if (this.Files.Count() > 10)
 				throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 			if (this._files.Any(x => x.FileName == stream.Name))
 				throw new ArgumentException("A File with that filename already exists");
 
 			if (resetStreamPosition)
 				this._files.Add(new DiscordMessageFile(stream.Name, stream, stream.Position, description: description));
 			else
 				this._files.Add(new DiscordMessageFile(stream.Name, stream, null, description: description));
 
 			return this;
 		}
 
 		/// <summary>
 		/// Adds the given files to send at the execution of the webhook.
 		/// </summary>
 		/// <param name="files">Dictionary of file name and file data.</param>
 		/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 		public DiscordWebhookBuilder AddFiles(Dictionary<string, Stream> files, bool resetStreamPosition = false)
 		{
 			if (this.Files.Count() + files.Count() > 10)
 				throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 			foreach (var file in files)
 			{
 				if (this._files.Any(x => x.FileName == file.Key))
 					throw new ArgumentException("A File with that filename already exists");
 
 				if (resetStreamPosition)
 					this._files.Add(new DiscordMessageFile(file.Key, file.Value, file.Value.Position));
 				else
 					this._files.Add(new DiscordMessageFile(file.Key, file.Value, null));
 			}
 
 
 			return this;
 		}
 
 		/// <summary>
 		/// Modifies the given attachments on edit.
 		/// </summary>
 		/// <param name="attachments">Attachments to edit.</param>
 		/// <returns></returns>
 		public DiscordWebhookBuilder ModifyAttachments(IEnumerable<DiscordAttachment> attachments)
 		{
 			this.AttachmentsInternal.AddRange(attachments);
 			return this;
 		}
 
 		/// <summary>
 		/// Whether to keep the message attachments, if new ones are added.
 		/// </summary>
 		/// <returns></returns>
 		public DiscordWebhookBuilder KeepAttachments(bool keep)
 		{
 			this.KeepAttachmentsInternal = keep;
 			return this;
 		}
 
 		/// <summary>
 		/// Adds the mention to the mentions to parse, etc. at the execution of the webhook.
 		/// </summary>
 		/// <param name="mention">Mention to add.</param>
 		public DiscordWebhookBuilder AddMention(IMention mention)
 		{
 			this._mentions.Add(mention);
 			return this;
 		}
 
 		/// <summary>
 		/// Adds the mentions to the mentions to parse, etc. at the execution of the webhook.
 		/// </summary>
 		/// <param name="mentions">Mentions to add.</param>
 		public DiscordWebhookBuilder AddMentions(IEnumerable<IMention> mentions)
 		{
 			this._mentions.AddRange(mentions);
 			return this;
 		}
 
 		/// <summary>
 		/// Executes a webhook.
 		/// </summary>
 		/// <param name="webhook">The webhook that should be executed.</param>
 		/// <returns>The message sent</returns>
 		public async Task<DiscordMessage> SendAsync(DiscordWebhook webhook) => await webhook.ExecuteAsync(this).ConfigureAwait(false);
 
 		/// <summary>
 		/// Executes a webhook.
 		/// </summary>
 		/// <param name="webhook">The webhook that should be executed.</param>
 		/// <param name="threadId">Target thread id.</param>
 		/// <returns>The message sent</returns>
 		public async Task<DiscordMessage> SendAsync(DiscordWebhook webhook, ulong threadId) => await webhook.ExecuteAsync(this, threadId.ToString()).ConfigureAwait(false);
 
 		/// <summary>
 		/// Sends the modified webhook message.
 		/// </summary>
 		/// <param name="webhook">The webhook that should be executed.</param>
 		/// <param name="message">The message to modify.</param>
 		/// <returns>The modified message</returns>
 		public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, DiscordMessage message) => await this.ModifyAsync(webhook, message.Id).ConfigureAwait(false);
 
 		/// <summary>
 		/// Sends the modified webhook message.
 		/// </summary>
 		/// <param name="webhook">The webhook that should be executed.</param>
 		/// <param name="messageId">The id of the message to modify.</param>
 		/// <returns>The modified message</returns>
 		public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, ulong messageId) => await webhook.EditMessageAsync(messageId, this).ConfigureAwait(false);
 
 		/// <summary>
 		/// Sends the modified webhook message.
 		/// </summary>
 		/// <param name="webhook">The webhook that should be executed.</param>
 		/// <param name="message">The message to modify.</param>
 		/// <param name="thread">Target thread.</param>
 		/// <returns>The modified message</returns>
 		public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, DiscordMessage message, DiscordThreadChannel thread) => await this.ModifyAsync(webhook, message.Id, thread.Id).ConfigureAwait(false);
 
 		/// <summary>
 		/// Sends the modified webhook message.
 		/// </summary>
 		/// <param name="webhook">The webhook that should be executed.</param>
 		/// <param name="messageId">The id of the message to modify.</param>
 		/// <param name="threadId">Target thread id.</param>
 		/// <returns>The modified message</returns>
 		public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, ulong messageId, ulong threadId) => await webhook.EditMessageAsync(messageId, this, threadId.ToString()).ConfigureAwait(false);
 
 		/// <summary>
 		/// Clears all message components on this builder.
 		/// </summary>
 		public void ClearComponents()
 			=> this._components.Clear();
 
 		/// <summary>
 		/// Allows for clearing the Webhook Builder so that it can be used again to send a new message.
 		/// </summary>
 		public void Clear()
 		{
 			this.Content = "";
 			this._embeds.Clear();
 			this.IsTts = false;
 			this._mentions.Clear();
 			this._files.Clear();
 			this.AttachmentsInternal.Clear();
 			this._components.Clear();
 			this.KeepAttachmentsInternal = false;
 		}
 
 		/// <summary>
 		/// Does the validation before we send a the Create/Modify request.
 		/// </summary>
 		/// <param name="isModify">Tells the method to perform the Modify Validation or Create Validation.</param>
 		/// <param name="isFollowup">Tells the method to perform the follow up message validation.</param>
 		/// <param name="isInteractionResponse">Tells the method to perform the interaction response validation.</param>
 		internal void Validate(bool isModify = false, bool isFollowup = false, bool isInteractionResponse = false)
 		{
 			if (isModify)
 			{
 				if (this.Username.HasValue)
 					throw new ArgumentException("You cannot change the username of a message.");
 
 				if (this.AvatarUrl.HasValue)
 					throw new ArgumentException("You cannot change the avatar of a message.");
 			}
 			else if (isFollowup)
 			{
 				if (this.Username.HasValue)
 					throw new ArgumentException("You cannot change the username of a follow up message.");
 
 				if (this.AvatarUrl.HasValue)
 					throw new ArgumentException("You cannot change the avatar of a follow up message.");
 			}
 			else if (isInteractionResponse)
 			{
 				if (this.Username.HasValue)
 					throw new ArgumentException("You cannot change the username of an interaction response.");
 
 				if (this.AvatarUrl.HasValue)
 					throw new ArgumentException("You cannot change the avatar of an interaction response.");
 			}
 			else
 			{
 				if (this.Files?.Count == 0 && string.IsNullOrEmpty(this.Content) && !this.Embeds.Any())
 					throw new ArgumentException("You must specify content, an embed, or at least one file.");
 			}
 		}
 	}
 }
diff --git a/DisCatSharp/Enums/Discord/DiscordDomain.cs b/DisCatSharp/Enums/Discord/DiscordDomain.cs
index 50263b720..104e22fad 100644
--- a/DisCatSharp/Enums/Discord/DiscordDomain.cs
+++ b/DisCatSharp/Enums/Discord/DiscordDomain.cs
@@ -1,269 +1,269 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Linq;
 
 namespace DisCatSharp.Enums
 {
 	/// <summary>
 	/// Core Domains
 	/// </summary>
 	public enum CoreDomain
 	{
 		/// <summary>
 		/// dis.gd
 		/// </summary>
 		[DomainHelp("Marketing URL shortner", "dis.gd")]
 		DiscordMarketing = 1,
 
 		/// <summary>
 		/// discord.co
 		/// </summary>
 		[DomainHelp("Admin panel, internal tools", "discord.co")]
 		DiscordAdmin = 2,
 
 		/// <summary>
 		/// discord.com
 		/// </summary>
 		[DomainHelp("New app, marketing website, API host", "discord.com")]
 		Discord = 3,
 
 		/// <summary>
 		/// discord.design
 		/// </summary>
 		[DomainHelp("Dribbble profile shortlink", "discord.design")]
 		DiscordDesign = 4,
 
 		/// <summary>
 		/// discord.dev
 		/// </summary>
 		[DomainHelp("Developer site shortlinks", "discord.dev")]
 		DiscordDev = 5,
 
 		/// <summary>
 		/// discord.gg
 		/// </summary>
 		[DomainHelp("Invite shortlinks", "discord.gg")]
 		DiscordShortlink = 6,
 
 		/// <summary>
 		/// discord.gift
 		/// </summary>
 		[DomainHelp("Gift shortlinks", "discord.gift")]
 		DiscordGift = 7,
 
 		/// <summary>
 		/// discord.media
 		/// </summary>
 		[DomainHelp("Voice servers", "discord.media")]
 		DiscordMedia = 8,
 
 		/// <summary>
 		/// discord.new
 		/// </summary>
 		[DomainHelp("Template shortlinks", "discord.new")]
 		DiscordTemplate = 9,
 
 		/// <summary>
 		/// discord.store
 		/// </summary>
 		[DomainHelp("Merch store", "discord.store")]
 		DiscordMerch = 10,
 
 		/// <summary>
 		/// discord.tools
 		/// </summary>
 		[DomainHelp("Internal tools", "discord.tools")]
 		DiscordTools = 11,
 
 		/// <summary>
 		/// discordapp.com
 		/// </summary>
 		[DomainHelp("Old app, marketing website, and API; CDN", "discordapp.com")]
 		DiscordAppOld = 12,
 
 		/// <summary>
 		/// discordapp.net
 		/// </summary>
 		[DomainHelp("Media Proxy", "discordapp.net")]
 		DiscordAppMediaProxy = 13,
 
 		/// <summary>
 		/// discordmerch.com
 		/// </summary>
 		[DomainHelp("Merch store", "discordmerch.com")]
 		DiscordMerchOld = 14,
 
 		/// <summary>
 		/// discordpartygames.com
 		/// </summary>
 		[DomainHelp("Voice channel activity API host", "discordpartygames.com")]
 		DiscordActivityAlt = 15,
 
 		/// <summary>
 		/// discord-activities.com
 		/// </summary>
 		[DomainHelp("Voice channel activity API host", "discord-activities.com")]
 		DiscordActivityAlt2 = 16,
 
 		/// <summary>
 		/// discordsays.com
 		/// </summary>
 		[DomainHelp("Voice channel activity host", "discordsays.com")]
 		DiscordActivity = 17,
 
 		/// <summary>
 		/// discordstatus.com
 		/// </summary>
 		[DomainHelp("Status page", "discordstatus.com")]
 		DiscordStatus = 18,
 
 		/// <summary>
 		/// cdn.discordapp.com
 		/// </summary>
 		[DomainHelp("CDN", "cdn.discordapp.com")]
 		DiscordCdn = 19,
 
 	}
 
 	/// <summary>
 	/// Other Domains
 	/// </summary>
 	public enum OtherDomain
 	{
 		/// <summary>
 		/// airhorn.solutions
 		/// </summary>
 		[DomainHelp("API implementation example", "airhorn.solutions")]
 		Airhorn = 1,
 
 		/// <summary>
 		/// airhornbot.com
 		/// </summary>
 		[DomainHelp("API implementation example", "airhornbot.com")]
 		AirhornAlt = 2,
 
 		/// <summary>
 		/// bigbeans.solutions
 		/// </summary>
 		[DomainHelp("April Fools 2017", "bigbeans.solutions")]
 		AprilFools = 3,
 
 		/// <summary>
 		/// watchanimeattheoffice.com
 		/// </summary>
 		[DomainHelp("HypeSquad form placeholder/meme", "watchanimeattheoffice.com")]
 		HypeSquadMeme = 4
 	}
 
 	/// <summary>
 	/// Core Domains
 	/// </summary>
 	public enum UnusedDomain
 	{
 		/// <summary>
 		/// discordapp.io
 		/// </summary>
 		[Obsolete("Not in use", false)]
 		[DomainHelp("IO domain for discord", "discordapp.io")]
 		DiscordAppIo = 1,
 
 		/// <summary>
 		/// discordcdn.com
 		/// </summary>
 		[Obsolete("Not in use", false)]
 		[DomainHelp("Alternative CDN domain", "discordcdn.com")]
 		DiscordCdnCom = 2
 	}
 
 	/// <summary>
 	/// Represents a discord domain.
 	/// </summary>
 	public static class DiscordDomain
 	{
 		/// <summary>
 		/// Gets a domain.
 		/// Valid types: <see cref="CoreDomain"/>, <see cref="OtherDomain"/> and <see cref="UnusedDomain"/>.
 		/// </summary>
 		/// <param name="domainEnum">The domain type.</param>
 		/// <returns>A DomainHelpAttribute.</returns>
 		public static DomainHelpAttribute GetDomain(Enum domainEnum)
 		{
 			if (domainEnum is not CoreDomain && domainEnum is not OtherDomain && domainEnum is not UnusedDomain)
 				throw new NotSupportedException($"Invalid type. Found: {domainEnum.GetType()} Expected: CoreDomain or OtherDomain or UnusedDomain");
 
 			if (domainEnum is CoreDomain domain && (domain == CoreDomain.DiscordAdmin || domain == CoreDomain.DiscordTools))
 				throw new UnauthorizedAccessException("You don't have access to this domains");
 
 			var memberInfo = domainEnum.GetType().GetMember(domainEnum.ToString()).FirstOrDefault();
 			if (memberInfo != null)
 			{
 				var attribute = (DomainHelpAttribute)memberInfo.GetCustomAttributes(typeof(DomainHelpAttribute), false).FirstOrDefault();
 				return attribute;
 			}
 
 			return null;
 		}
 	}
 
 	/// <summary>
 	/// Defines a description and url for this domain.
 	/// </summary>
 	[AttributeUsage(AttributeTargets.All, AllowMultiple = false)]
 	public class DomainHelpAttribute : Attribute
 	{
 		/// <summary>
 		/// Gets the Description for this domain.
 		/// </summary>
 		public string Description { get; }
 
 		/// <summary>
 		/// Gets the Uri for this domain.
 		/// </summary>
 		public Uri Uri { get; }
 
 		/// <summary>
 		/// Gets the Domain for this domain.
 		/// </summary>
 		public string Domain { get; }
 
 		/// <summary>
 		/// Gets the Url for this domain.
 		/// </summary>
 		public string Url { get; }
 
 		/// <summary>
 		/// Defines a description and URIs for this domain.
 		/// </summary>
 		/// <param name="desc">Description for this domain.</param>
 		/// <param name="domain">Url for this domain.</param>
 		public DomainHelpAttribute(string desc, string domain)
 		{
 			this.Description = desc;
 			this.Domain = domain;
 			var url = $"https://{domain}";
 			this.Url = url;
-			this.Uri = new(url);
+			this.Uri = new Uri(url);
 		}
 	}
 }
diff --git a/DisCatSharp/Enums/OAuth.cs b/DisCatSharp/Enums/OAuth.cs
index f0606566f..8642c175f 100644
--- a/DisCatSharp/Enums/OAuth.cs
+++ b/DisCatSharp/Enums/OAuth.cs
@@ -1,120 +1,118 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 // ReSharper disable InconsistentNaming
 namespace DisCatSharp.Enums
 {
 	/// <summary>
 	/// The oauth scopes.
 	/// </summary>
 	public static class OAuth
 	{
 		/// <summary>
 		/// The default scopes for bots.
 		/// </summary>
 		private const string BOT_DEFAULT = "bot applications.commands applications.commands.permissions.update";
 
 		/// <summary>
 		/// The bot minimal scopes.
 		/// </summary>
 		private const string BOT_MINIMAL = "bot applications.commands";
 
 		/// <summary>
 		/// The bot only scope.
 		/// </summary>
 		private const string BOT_ONLY = "bot";
 
 		/// <summary>
 		/// The basic identify scopes.
 		/// </summary>
 		private const string IDENTIFY_BASIC = "identify email";
 
 		/// <summary>
 		/// The extended identify scopes.
 		/// </summary>
 		private const string IDENTIFY_EXTENDED = "identify email guilds connections";
 
 		/// <summary>
 		/// All scopes for bots and identify.
 		/// </summary>
 		private const string ALL = BOT_DEFAULT + " " + IDENTIFY_EXTENDED;
 
 		/// <summary>
 		/// The oauth scope.
 		/// </summary>
 
 
 		/// <summary>
 		/// Resolves the scopes.
 		/// </summary>
 		/// <param name="scope">The scope.</param>
 		/// <returns>A string representing the scopes.</returns>
-		public static string ResolveScopes(OAuthScopes scope)
-		{
-			return scope switch
+		public static string ResolveScopes(OAuthScopes scope) =>
+			scope switch
 			{
 				OAuthScopes.BOT_DEFAULT => BOT_DEFAULT,
 				OAuthScopes.BOT_MINIMAL => BOT_MINIMAL,
 				OAuthScopes.BOT_ONLY => BOT_ONLY,
 				OAuthScopes.IDENTIFY_BASIC => IDENTIFY_BASIC,
 				OAuthScopes.IDENTIFY_EXTENDED => IDENTIFY_EXTENDED,
 				OAuthScopes.ALL => ALL,
 				_ => BOT_DEFAULT,
 			};
-		}
 	}
 	/// <summary>
 	/// The oauth scopes.
 	/// </summary>
 	public enum OAuthScopes
 	{
 		/// <summary>
 		/// Scopes: bot applications.commands applications.commands.permissions.update
 		/// </summary>
 		BOT_DEFAULT = 0,
 
 		/// <summary>
 		/// Scopes: bot applications.commands
 		/// </summary>
 		BOT_MINIMAL = 1,
 
 		/// <summary>
 		/// Scopes: bot
 		/// </summary>
 		BOT_ONLY = 2,
 
 		/// <summary>
 		/// Scopes: identify email
 		/// </summary>
 		IDENTIFY_BASIC = 3,
 
 		/// <summary>
 		/// Scopes: identify email guilds connections
 		/// </summary>
 		IDENTIFY_EXTENDED = 4,
 
 		/// <summary>
 		/// Scopes: bot applications.commands applications.commands.permissions.update identify email guilds connections
 		/// </summary>
 		ALL = 5
 	}
 }
diff --git a/DisCatSharp/Formatter.cs b/DisCatSharp/Formatter.cs
index 9efca18d2..398adba10 100644
--- a/DisCatSharp/Formatter.cs
+++ b/DisCatSharp/Formatter.cs
@@ -1,205 +1,205 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Globalization;
 using System.Text.RegularExpressions;
 using DisCatSharp.Entities;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Contains markdown formatting helpers.
 	/// </summary>
 	public static class Formatter
 	{
 		/// <summary>
 		/// Gets the md sanitize regex.
 		/// </summary>
-		private static Regex s_mdSanitizeRegex { get; } = new Regex(@"([`\*_~<>\[\]\(\)""@\!\&#:\|])", RegexOptions.ECMAScript);
+		private static Regex s_mdSanitizeRegex { get; } = new(@"([`\*_~<>\[\]\(\)""@\!\&#:\|])", RegexOptions.ECMAScript);
 		/// <summary>
 		/// Gets the md strip regex.
 		/// </summary>
-		private static Regex s_mdStripRegex { get; } = new Regex(@"([`\*_~\[\]\(\)""\|]|<@\!?\d+>|<#\d+>|<@\&\d+>|<:[a-zA-Z0-9_\-]:\d+>)", RegexOptions.ECMAScript);
+		private static Regex s_mdStripRegex { get; } = new(@"([`\*_~\[\]\(\)""\|]|<@\!?\d+>|<#\d+>|<@\&\d+>|<:[a-zA-Z0-9_\-]:\d+>)", RegexOptions.ECMAScript);
 
 		/// <summary>
 		/// Creates a block of code.
 		/// </summary>
 		/// <param name="content">Contents of the block.</param>
 		/// <param name="language">Language to use for highlighting.</param>
 		/// <returns>Formatted block of code.</returns>
 		public static string BlockCode(string content, string language = "")
 			=> $"```{language}\n{content}\n```";
 
 		/// <summary>
 		/// Creates inline code snippet.
 		/// </summary>
 		/// <param name="content">Contents of the snippet.</param>
 		/// <returns>Formatted inline code snippet.</returns>
 		public static string InlineCode(string content)
 			=> $"`{content}`";
 
 		/// <summary>
 		/// Creates a rendered timestamp.
 		/// </summary>
 		/// <param name="time">The time from now.</param>
 		/// <param name="format">The format to render the timestamp in. Defaults to relative.</param>
 		/// <returns>A formatted timestamp.</returns>
 		public static string Timestamp(TimeSpan time, TimestampFormat format = TimestampFormat.RelativeTime)
 			=> Timestamp(DateTimeOffset.UtcNow + time, format);
 
 		/// <summary>
 		/// Creates a rendered timestamp.
 		/// </summary>
 		/// <param name="time">Timestamp to format.</param>
 		/// <param name="format">The format to render the timestamp in. Defaults to relative.</param>
 		/// <returns>A formatted timestamp.</returns>
 		public static string Timestamp(DateTimeOffset time, TimestampFormat format = TimestampFormat.RelativeTime)
 			=> $"<t:{time.ToUnixTimeSeconds()}:{(char)format}>";
 
 		/// <summary>
 		/// Creates a rendered timestamp.
 		/// </summary>
 		/// <param name="time">The time from now.</param>
 		/// <param name="format">The format to render the timestamp in. Defaults to relative.</param>
 		/// <returns>A formatted timestamp relative to now.</returns>
 		public static string Timestamp(DateTime time, TimestampFormat format = TimestampFormat.RelativeTime)
 			=> Timestamp(time.ToUniversalTime() - DateTime.UtcNow, format);
 
 		/// <summary>
 		/// Creates bold text.
 		/// </summary>
 		/// <param name="content">Text to bolden.</param>
 		/// <returns>Formatted text.</returns>
 		public static string Bold(string content)
 			=> $"**{content}**";
 
 		/// <summary>
 		/// Creates italicized text.
 		/// </summary>
 		/// <param name="content">Text to italicize.</param>
 		/// <returns>Formatted text.</returns>
 		public static string Italic(string content)
 			=> $"*{content}*";
 
 		/// <summary>
 		/// Creates spoiler from text.
 		/// </summary>
 		/// <param name="content">Text to spoilerize.</param>
 		/// <returns>Formatted text.</returns>
 		public static string Spoiler(string content)
 			=> $"||{content}||";
 
 		/// <summary>
 		/// Creates underlined text.
 		/// </summary>
 		/// <param name="content">Text to underline.</param>
 		/// <returns>Formatted text.</returns>
 		public static string Underline(string content)
 			=> $"__{content}__";
 
 		/// <summary>
 		/// Creates strikethrough text.
 		/// </summary>
 		/// <param name="content">Text to strikethrough.</param>
 		/// <returns>Formatted text.</returns>
 		public static string Strike(string content)
 			=> $"~~{content}~~";
 
 		/// <summary>
 		/// Creates a URL that won't create a link preview.
 		/// </summary>
 		/// <param name="url">Url to prevent from being previewed.</param>
 		/// <returns>Formatted url.</returns>
 		public static string EmbedlessUrl(Uri url)
 			=> $"<{url}>";
 
 		/// <summary>
 		/// Creates a masked link. This link will display as specified text, and alternatively provided alt text. This can only be used in embeds.
 		/// </summary>
 		/// <param name="text">Text to display the link as.</param>
 		/// <param name="url">Url that the link will lead to.</param>
 		/// <param name="altText">Alt text to display on hover.</param>
 		/// <returns>Formatted url.</returns>
 		public static string MaskedUrl(string text, Uri url, string altText = "")
 			=> $"[{text}]({url}{(!string.IsNullOrWhiteSpace(altText) ? $" \"{altText}\"" : "")})";
 
 		/// <summary>
 		/// Escapes all markdown formatting from specified text.
 		/// </summary>
 		/// <param name="text">Text to sanitize.</param>
 		/// <returns>Sanitized text.</returns>
 		public static string Sanitize(string text)
 			=> s_mdSanitizeRegex.Replace(text, m => $"\\{m.Groups[1].Value}");
 
 		/// <summary>
 		/// Removes all markdown formatting from specified text.
 		/// </summary>
 		/// <param name="text">Text to strip of formatting.</param>
 		/// <returns>Formatting-stripped text.</returns>
 		public static string Strip(string text)
 			=> s_mdStripRegex.Replace(text, m => string.Empty);
 
 		/// <summary>
 		/// Creates a mention for specified user or member. Can optionally specify to resolve nicknames.
 		/// </summary>
 		/// <param name="user">User to create mention for.</param>
 		/// <param name="nickname">Whether the mention should resolve nicknames or not.</param>
 		/// <returns>Formatted mention.</returns>
 		public static string Mention(DiscordUser user, bool nickname = false)
 			=> nickname
 			? $"<@!{user.Id.ToString(CultureInfo.InvariantCulture)}>"
 			: $"<@{user.Id.ToString(CultureInfo.InvariantCulture)}>";
 
 		/// <summary>
 		/// Creates a mention for specified channel.
 		/// </summary>
 		/// <param name="channel">Channel to mention.</param>
 		/// <returns>Formatted mention.</returns>
 		public static string Mention(DiscordChannel channel)
 			=> $"<#{channel.Id.ToString(CultureInfo.InvariantCulture)}>";
 
 		/// <summary>
 		/// Creates a mention for specified role.
 		/// </summary>
 		/// <param name="role">Role to mention.</param>
 		/// <returns>Formatted mention.</returns>
 		public static string Mention(DiscordRole role)
 			=> $"<@&{role.Id.ToString(CultureInfo.InvariantCulture)}>";
 
 		/// <summary>
 		/// Creates a custom emoji string.
 		/// </summary>
 		/// <param name="emoji">Emoji to display.</param>
 		/// <returns>Formatted emoji.</returns>
 		public static string Emoji(DiscordEmoji emoji)
 			=> $"<:{emoji.Name}:{emoji.Id.ToString(CultureInfo.InvariantCulture)}>";
 
 		/// <summary>
 		/// Creates a url for using attachments in embeds. This can only be used as an Image URL, Thumbnail URL, Author icon URL or Footer icon URL.
 		/// </summary>
 		/// <param name="filename">Name of attached image to display</param>
 		/// <returns></returns>
 		public static string AttachedImageUrl(string filename)
 			=> $"attachment://{filename}";
 	}
 }
diff --git a/DisCatSharp/Logging/DefaultLoggerFactory.cs b/DisCatSharp/Logging/DefaultLoggerFactory.cs
index 222e7fc30..b616c9d7b 100644
--- a/DisCatSharp/Logging/DefaultLoggerFactory.cs
+++ b/DisCatSharp/Logging/DefaultLoggerFactory.cs
@@ -1,74 +1,72 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Represents a default logger factory.
 	/// </summary>
 	internal class DefaultLoggerFactory : ILoggerFactory
 	{
 		/// <summary>
 		/// Gets the providers.
 		/// </summary>
 		private readonly List<ILoggerProvider> _providers = new();
-		private bool _isDisposed = false;
+		private bool _isDisposed;
 
 		/// <summary>
 		/// Adds a provider.
 		/// </summary>
 		/// <param name="provider">The provider to be added.</param>
 		public void AddProvider(ILoggerProvider provider) => this._providers.Add(provider);
 
 		/// <summary>
 		/// Creates the logger.
 		/// </summary>
 		/// <param name="categoryName">The category name.</param>
-		public ILogger CreateLogger(string categoryName)
-		{
-			return this._isDisposed
+		public ILogger CreateLogger(string categoryName) =>
+			this._isDisposed
 				? throw new InvalidOperationException("This logger factory is already disposed.")
 				: categoryName != typeof(BaseDiscordClient).FullName && categoryName != typeof(DiscordWebhookClient).FullName
-				? throw new ArgumentException($"This factory can only provide instances of loggers for {typeof(BaseDiscordClient).FullName} or {typeof(DiscordWebhookClient).FullName}.", nameof(categoryName))
-				: new CompositeDefaultLogger(this._providers);
-		}
+					? throw new ArgumentException($"This factory can only provide instances of loggers for {typeof(BaseDiscordClient).FullName} or {typeof(DiscordWebhookClient).FullName}.", nameof(categoryName))
+					: new CompositeDefaultLogger(this._providers);
 
 		/// <summary>
 		/// Disposes the logger.
 		/// </summary>
 		public void Dispose()
 		{
 			if (this._isDisposed)
 				return;
 			this._isDisposed = true;
 
 			foreach (var provider in this._providers)
 				provider.Dispose();
 
 			this._providers.Clear();
 		}
 	}
 }
diff --git a/DisCatSharp/Logging/DefaultLoggerProvider.cs b/DisCatSharp/Logging/DefaultLoggerProvider.cs
index 94ccb120d..08dc086fb 100644
--- a/DisCatSharp/Logging/DefaultLoggerProvider.cs
+++ b/DisCatSharp/Logging/DefaultLoggerProvider.cs
@@ -1,90 +1,88 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Represents a default logger provider.
 	/// </summary>
 	internal class DefaultLoggerProvider : ILoggerProvider
 	{
 		/// <summary>
 		/// Gets the minimum log level.
 		/// </summary>
 		private readonly LogLevel _minimumLevel;
 
 		/// <summary>
 		/// Gets the timestamp format.
 		/// </summary>
 		private readonly string _timestampFormat;
 
-		private bool _isDisposed = false;
+		private bool _isDisposed;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DefaultLoggerProvider"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		internal DefaultLoggerProvider(BaseDiscordClient client)
 			: this(client.Configuration.MinimumLogLevel, client.Configuration.LogTimestampFormat)
 		{ }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DefaultLoggerProvider"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		internal DefaultLoggerProvider(DiscordWebhookClient client)
 			: this(client.MinimumLogLevel, client.LogTimestampFormat)
 		{ }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DefaultLoggerProvider"/> class.
 		/// </summary>
 		/// <param name="minLevel">The min level.</param>
 		/// <param name="timestampFormat">The timestamp format.</param>
 		internal DefaultLoggerProvider(LogLevel minLevel = LogLevel.Information, string timestampFormat = "yyyy-MM-dd HH:mm:ss zzz")
 		{
 			this._minimumLevel = minLevel;
 			this._timestampFormat = timestampFormat;
 		}
 
 		/// <summary>
 		/// Creates the logger.
 		/// </summary>
 		/// <param name="categoryName">The category name.</param>
-		public ILogger CreateLogger(string categoryName)
-		{
-			return this._isDisposed
+		public ILogger CreateLogger(string categoryName) =>
+			this._isDisposed
 				? throw new InvalidOperationException("This logger provider is already disposed.")
 				: categoryName != typeof(BaseDiscordClient).FullName && categoryName != typeof(DiscordWebhookClient).FullName
-				? throw new ArgumentException($"This provider can only provide instances of loggers for {typeof(BaseDiscordClient).FullName} or {typeof(DiscordWebhookClient).FullName}.", nameof(categoryName))
-				: new DefaultLogger(this._minimumLevel, this._timestampFormat);
-		}
+					? throw new ArgumentException($"This provider can only provide instances of loggers for {typeof(BaseDiscordClient).FullName} or {typeof(DiscordWebhookClient).FullName}.", nameof(categoryName))
+					: new DefaultLogger(this._minimumLevel, this._timestampFormat);
 
 		/// <summary>
 		/// Disposes the logger.
 		/// </summary>
 		public void Dispose() => this._isDisposed = true;
 	}
 }
diff --git a/DisCatSharp/Logging/LoggerEvents.cs b/DisCatSharp/Logging/LoggerEvents.cs
index ea9420b0a..5d940a8f8 100644
--- a/DisCatSharp/Logging/LoggerEvents.cs
+++ b/DisCatSharp/Logging/LoggerEvents.cs
@@ -1,172 +1,172 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Contains well-defined event IDs used by core of DisCatSharp.
 	/// </summary>
 	public static class LoggerEvents
 	{
 		/// <summary>
 		/// Miscellaneous events, that do not fit in any other category.
 		/// </summary>
-		public static EventId Misc { get; } = new EventId(100, "DisCatSharp");
+		public static EventId Misc { get; } = new(100, "DisCatSharp");
 
 		/// <summary>
 		/// Events pertaining to startup tasks.
 		/// </summary>
-		public static EventId Startup { get; } = new EventId(101, nameof(Startup));
+		public static EventId Startup { get; } = new(101, nameof(Startup));
 
 		/// <summary>
 		/// Events typically emitted whenever WebSocket connections fail or are terminated.
 		/// </summary>
-		public static EventId ConnectionFailure { get; } = new EventId(102, nameof(ConnectionFailure));
+		public static EventId ConnectionFailure { get; } = new(102, nameof(ConnectionFailure));
 
 		/// <summary>
 		/// Events pertaining to Discord-issued session state updates.
 		/// </summary>
-		public static EventId SessionUpdate { get; } = new EventId(103, nameof(SessionUpdate));
+		public static EventId SessionUpdate { get; } = new(103, nameof(SessionUpdate));
 
 		/// <summary>
 		/// Events emitted when exceptions are thrown in handlers attached to async events.
 		/// </summary>
-		public static EventId EventHandlerException { get; } = new EventId(104, nameof(EventHandlerException));
+		public static EventId EventHandlerException { get; } = new(104, nameof(EventHandlerException));
 
 		/// <summary>
 		/// Events emitted for various high-level WebSocket receive events.
 		/// </summary>
-		public static EventId WebSocketReceive { get; } = new EventId(105, nameof(WebSocketReceive));
+		public static EventId WebSocketReceive { get; } = new(105, nameof(WebSocketReceive));
 
 		/// <summary>
 		/// Events emitted for various low-level WebSocket receive events.
 		/// </summary>
-		public static EventId WebSocketReceiveRaw { get; } = new EventId(106, nameof(WebSocketReceiveRaw));
+		public static EventId WebSocketReceiveRaw { get; } = new(106, nameof(WebSocketReceiveRaw));
 
 		/// <summary>
 		/// Events emitted for various low-level WebSocket send events.
 		/// </summary>
-		public static EventId WebSocketSendRaw { get; } = new EventId(107, nameof(WebSocketSendRaw));
+		public static EventId WebSocketSendRaw { get; } = new(107, nameof(WebSocketSendRaw));
 
 		/// <summary>
 		/// Events emitted for various WebSocket payload processing failures, typically when deserialization or decoding fails.
 		/// </summary>
-		public static EventId WebSocketReceiveFailure { get; } = new EventId(108, nameof(WebSocketReceiveFailure));
+		public static EventId WebSocketReceiveFailure { get; } = new(108, nameof(WebSocketReceiveFailure));
 
 		/// <summary>
 		/// Events pertaining to connection lifecycle, specifically, heartbeats.
 		/// </summary>
-		public static EventId Heartbeat { get; } = new EventId(109, nameof(Heartbeat));
+		public static EventId Heartbeat { get; } = new(109, nameof(Heartbeat));
 
 		/// <summary>
 		/// Events pertaining to various heartbeat failures, typically fatal.
 		/// </summary>
-		public static EventId HeartbeatFailure { get; } = new EventId(110, nameof(HeartbeatFailure));
+		public static EventId HeartbeatFailure { get; } = new(110, nameof(HeartbeatFailure));
 
 		/// <summary>
 		/// Events pertaining to clean connection closes.
 		/// </summary>
-		public static EventId ConnectionClose { get; } = new EventId(111, nameof(ConnectionClose));
+		public static EventId ConnectionClose { get; } = new(111, nameof(ConnectionClose));
 
 		/// <summary>
 		/// Events emitted when REST processing fails for any reason.
 		/// </summary>
-		public static EventId RestError { get; } = new EventId(112, nameof(RestError));
+		public static EventId RestError { get; } = new(112, nameof(RestError));
 
 		/// <summary>
 		/// Events pertaining to the <see cref="DiscordShardedClient"/> shard startup.
 		/// </summary>
-		public static EventId ShardStartup { get; } = new EventId(113, nameof(ShardStartup));
+		public static EventId ShardStartup { get; } = new(113, nameof(ShardStartup));
 
 		/// <summary>
 		/// Events pertaining to ratelimit exhaustion.
 		/// </summary>
-		public static EventId RatelimitHit { get; } = new EventId(114, nameof(RatelimitHit));
+		public static EventId RatelimitHit { get; } = new(114, nameof(RatelimitHit));
 
 		/// <summary>
 		/// Events pertaining to ratelimit diagnostics. Typically contain raw bucket info.
 		/// </summary>
-		public static EventId RatelimitDiag { get; } = new EventId(115, nameof(RatelimitDiag));
+		public static EventId RatelimitDiag { get; } = new(115, nameof(RatelimitDiag));
 
 		/// <summary>
 		/// Events emitted when a ratelimit is exhausted and a request is preemtively blocked.
 		/// </summary>
-		public static EventId RatelimitPreemptive { get; } = new EventId(116, nameof(RatelimitPreemptive));
+		public static EventId RatelimitPreemptive { get; } = new(116, nameof(RatelimitPreemptive));
 
 		/// <summary>
 		/// Events pertaining to audit log processing.
 		/// </summary>
-		public static EventId AuditLog { get; } = new EventId(117, nameof(AuditLog));
+		public static EventId AuditLog { get; } = new(117, nameof(AuditLog));
 
 		/// <summary>
 		/// Events containing raw (but decompressed) payloads, received from Discord Gateway.
 		/// </summary>
-		public static EventId GatewayWsRx { get; } = new EventId(118, "Gateway ↓");
+		public static EventId GatewayWsRx { get; } = new(118, "Gateway ↓");
 
 		/// <summary>
 		/// Events containing raw payloads, as they're being sent to Discord Gateway.
 		/// </summary>
-		public static EventId GatewayWsTx { get; } = new EventId(119, "Gateway ↑");
+		public static EventId GatewayWsTx { get; } = new(119, "Gateway ↑");
 
 		/// <summary>
 		/// Events pertaining to Gateway Intents. Typically diagnostic information.
 		/// </summary>
-		public static EventId Intents { get; } = new EventId(120, nameof(Intents));
+		public static EventId Intents { get; } = new(120, nameof(Intents));
 
 		/// <summary>
 		/// Events pertaining to autosharded client shard shutdown, clean or otherwise.
 		/// </summary>
-		public static EventId ShardShutdown { get; } = new EventId(121, nameof(ShardShutdown));
+		public static EventId ShardShutdown { get; } = new(121, nameof(ShardShutdown));
 
 		/// <summary>
 		/// Events pertaining to the <see cref="DiscordShardedClient"/>'s shards not initializing correctly.
 		/// </summary>
-		public static EventId ShardClientError { get; } = new EventId(122, nameof(ShardClientError));
+		public static EventId ShardClientError { get; } = new(122, nameof(ShardClientError));
 
 		/// <summary>
 		/// Events containing raw payloads, as they're received from Discord's REST API.
 		/// </summary>
-		public static EventId RestRx { get; } = new EventId(123, "REST ↓");
+		public static EventId RestRx { get; } = new(123, "REST ↓");
 
 		/// <summary>
 		/// Events containing raw payloads, as they're sent to Discord's REST API.
 		/// </summary>
-		public static EventId RestTx { get; } = new EventId(124, "REST ↑");
+		public static EventId RestTx { get; } = new(124, "REST ↑");
 
 		/// <summary>
 		/// Event is rest cleaner.
 		/// </summary>
-		public static EventId RestCleaner { get; } = new EventId(125, nameof(RestCleaner));
+		public static EventId RestCleaner { get; } = new(125, nameof(RestCleaner));
 
 		/// <summary>
 		/// Event is rest hash mover.
 		/// </summary>
-		public static EventId RestHashMover { get; } = new EventId(126, nameof(RestHashMover));
+		public static EventId RestHashMover { get; } = new(126, nameof(RestHashMover));
 
 		/// <summary>
 		/// Events pertaining to Discord API requests from the <see cref="DiscordShardedClient"/>.
 		/// </summary>
-		public static EventId ShardRest { get; } = new EventId(127, nameof(ShardRest));
+		public static EventId ShardRest { get; } = new(127, nameof(ShardRest));
 	}
 }
diff --git a/DisCatSharp/Logging/ShardedLoggerFactory.cs b/DisCatSharp/Logging/ShardedLoggerFactory.cs
index 162d402c8..14db9db60 100644
--- a/DisCatSharp/Logging/ShardedLoggerFactory.cs
+++ b/DisCatSharp/Logging/ShardedLoggerFactory.cs
@@ -1,70 +1,68 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Represents a sharded logger factory.
 	/// </summary>
 	internal class ShardedLoggerFactory : ILoggerFactory
 	{
 		/// <summary>
 		/// Gets the logger.
 		/// </summary>
 		private readonly ILogger<BaseDiscordClient> _logger;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ShardedLoggerFactory"/> class.
 		/// </summary>
 		/// <param name="instance">The instance.</param>
 		public ShardedLoggerFactory(ILogger<BaseDiscordClient> instance)
 		{
 			this._logger = instance;
 		}
 
 		/// <summary>
 		/// Adds a provider.
 		/// </summary>
 		/// <param name="provider">The provider to be added.</param>
 		public void AddProvider(ILoggerProvider provider) => throw new InvalidOperationException("This is a passthrough logger container, it cannot register new providers.");
 
 		/// <summary>
 		/// Creates a logger.
 		/// </summary>
 		/// <param name="categoryName">The category name.</param>
-		public ILogger CreateLogger(string categoryName)
-		{
-			return categoryName != typeof(BaseDiscordClient).FullName
+		public ILogger CreateLogger(string categoryName) =>
+			categoryName != typeof(BaseDiscordClient).FullName
 				? throw new ArgumentException($"This factory can only provide instances of loggers for {typeof(BaseDiscordClient).FullName}.", nameof(categoryName))
 				: this._logger;
-		}
 
 		/// <summary>
 		/// Disposes the logger.
 		/// </summary>
 		public void Dispose()
 		{ }
 	}
 }
diff --git a/DisCatSharp/Net/Abstractions/Gateway/GatewayIdentifyResume.cs b/DisCatSharp/Net/Abstractions/Gateway/GatewayIdentifyResume.cs
index 0b88b2a5d..70d6636ec 100644
--- a/DisCatSharp/Net/Abstractions/Gateway/GatewayIdentifyResume.cs
+++ b/DisCatSharp/Net/Abstractions/Gateway/GatewayIdentifyResume.cs
@@ -1,105 +1,105 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions
 {
 	/// <summary>
 	/// Represents data for websocket identify payload.
 	/// </summary>
 	internal sealed class GatewayIdentify
 	{
 		/// <summary>
 		/// Gets or sets the discord client.
 		/// </summary>
 		[JsonIgnore]
 		public BaseDiscordClient Discord { get; set; }
 
 		/// <summary>
 		/// Gets or sets the token used to identify the client to Discord.
 		/// </summary>
 		[JsonProperty("token")]
 		public string Token { get; set; }
 
 		/// <summary>
 		/// Gets or sets the client's properties.
 		/// </summary>
 		[JsonProperty("properties")]
 		public ClientProperties ClientProperties =>
 			new() { Discord = this.Discord };
 
 		/// <summary>
 		/// Gets or sets whether to encrypt websocket traffic.
 		/// </summary>
 		[JsonProperty("compress")]
 		public bool Compress { get; set; }
 
 		/// <summary>
 		/// Gets or sets the member count at which the guild is to be considered large.
 		/// </summary>
 		[JsonProperty("large_threshold")]
 		public int LargeThreshold { get; set; }
 
 		/// <summary>
 		/// Gets or sets the shard info for this connection.
 		/// </summary>
 		[JsonProperty("shard")]
 		public ShardInfo ShardInfo { get; set; }
 
 		/// <summary>
 		/// Gets or sets the presence for this connection.
 		/// </summary>
 		[JsonProperty("presence", NullValueHandling = NullValueHandling.Ignore)]
-		public StatusUpdate Presence { get; set; } = null;
+		public StatusUpdate Presence { get; set; }
 
 		/// <summary>
 		/// Gets or sets the intent flags for this connection.
 		/// </summary>
 		[JsonProperty("intents")]
 		public DiscordIntents Intents { get; set; }
 	}
 
 	/// <summary>
 	/// Represents data for websocket identify payload.
 	/// </summary>
 	internal sealed class GatewayResume
 	{
 		/// <summary>
 		/// Gets or sets the token used to identify the client to Discord.
 		/// </summary>
 		[JsonProperty("token")]
 		public string Token { get; set; }
 
 		/// <summary>
 		/// Gets or sets the session id used to resume last session.
 		/// </summary>
 		[JsonProperty("session_id")]
 		public string SessionId { get; set; }
 
 		/// <summary>
 		/// Gets or sets the last received sequence number.
 		/// </summary>
 		[JsonProperty("seq")]
 		public long SequenceNumber { get; set; }
 	}
 }
diff --git a/DisCatSharp/Net/Abstractions/Gateway/GatewayRequestGuildMembers.cs b/DisCatSharp/Net/Abstractions/Gateway/GatewayRequestGuildMembers.cs
index c32972b33..f779b423f 100644
--- a/DisCatSharp/Net/Abstractions/Gateway/GatewayRequestGuildMembers.cs
+++ b/DisCatSharp/Net/Abstractions/Gateway/GatewayRequestGuildMembers.cs
@@ -1,79 +1,79 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 using DisCatSharp.Entities;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions
 {
 	/// <summary>
 	/// Request guild members.
 	/// </summary>
 	internal sealed class GatewayRequestGuildMembers
 	{
 		/// <summary>
 		/// Gets the guild id.
 		/// </summary>
 		[JsonProperty("guild_id")]
 		public ulong GuildId { get; }
 
 		/// <summary>
 		/// Gets the query.
 		/// </summary>
 		[JsonProperty("query", NullValueHandling = NullValueHandling.Ignore)]
-		public string Query { get; set; } = null;
+		public string Query { get; set; }
 
 		/// <summary>
 		/// Gets the limit.
 		/// </summary>
 		[JsonProperty("limit")]
-		public int Limit { get; set; } = 0;
+		public int Limit { get; set; }
 
 		/// <summary>
 		/// Gets whether presences should be returned.
 		/// </summary>
 		[JsonProperty("presences", NullValueHandling = NullValueHandling.Ignore)]
-		public bool? Presences { get; set; } = null;
+		public bool? Presences { get; set; }
 
 		/// <summary>
 		/// Gets the user ids.
 		/// </summary>
 		[JsonProperty("user_ids", NullValueHandling = NullValueHandling.Ignore)]
-		public IEnumerable<ulong> UserIds { get; set; } = null;
+		public IEnumerable<ulong> UserIds { get; set; }
 
 		/// <summary>
 		/// Gets the nonce.
 		/// </summary>
 		[JsonProperty("nonce", NullValueHandling = NullValueHandling.Ignore)]
 		public string Nonce { get; internal set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="GatewayRequestGuildMembers"/> class.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		public GatewayRequestGuildMembers(DiscordGuild guild)
 		{
 			this.GuildId = guild.Id;
 		}
 	}
 }
diff --git a/DisCatSharp/Net/Abstractions/ShardInfo.cs b/DisCatSharp/Net/Abstractions/ShardInfo.cs
index fc666f1fa..f7af67fa2 100644
--- a/DisCatSharp/Net/Abstractions/ShardInfo.cs
+++ b/DisCatSharp/Net/Abstractions/ShardInfo.cs
@@ -1,99 +1,97 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Net.Abstractions
 {
 	/// <summary>
 	/// Represents data for identify payload's shard info.
 	/// </summary>
 	[JsonConverter(typeof(ShardInfoConverter))]
 	internal sealed class ShardInfo
 	{
 		/// <summary>
 		/// Gets or sets this client's shard id.
 		/// </summary>
 		public int ShardId { get; set; }
 
 		/// <summary>
 		/// Gets or sets the total shard count for this token.
 		/// </summary>
 		public int ShardCount { get; set; }
 	}
 
 	/// <summary>
 	/// Represents a shard info converter.
 	/// </summary>
 	internal sealed class ShardInfoConverter : JsonConverter
 	{
 		/// <summary>
 		/// Writes the json.
 		/// </summary>
 		/// <param name="writer">The writer.</param>
 		/// <param name="value">The value.</param>
 		/// <param name="serializer">The serializer.</param>
 		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 		{
 			var sinfo = value as ShardInfo;
 			var obj = new object[] { sinfo.ShardId, sinfo.ShardCount };
 			serializer.Serialize(writer, obj);
 		}
 
 		/// <summary>
 		/// Reads the json.
 		/// </summary>
 		/// <param name="reader">The reader.</param>
 		/// <param name="objectType">The object type.</param>
 		/// <param name="existingValue">The existing value.</param>
 		/// <param name="serializer">The serializer.</param>
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 		{
 			var arr = this.ReadArrayObject(reader, serializer);
 			return new ShardInfo
 			{
 				ShardId = (int)arr[0],
 				ShardCount = (int)arr[1],
 			};
 		}
 
 		/// <summary>
 		/// Reads the array object.
 		/// </summary>
 		/// <param name="reader">The reader.</param>
 		/// <param name="serializer">The serializer.</param>
-		private JArray ReadArrayObject(JsonReader reader, JsonSerializer serializer)
-		{
-			return serializer.Deserialize<JToken>(reader) is not JArray arr || arr.Count != 2
+		private JArray ReadArrayObject(JsonReader reader, JsonSerializer serializer) =>
+			serializer.Deserialize<JToken>(reader) is not JArray arr || arr.Count != 2
 				? throw new JsonSerializationException("Expected array of length 2")
 				: arr;
-		}
 
 		/// <summary>
 		/// Whether this can be converted.
 		/// </summary>
 		/// <param name="objectType">The object type.</param>
 		public override bool CanConvert(Type objectType) => objectType == typeof(ShardInfo);
 	}
 }
diff --git a/DisCatSharp/Net/Abstractions/StatusUpdate.cs b/DisCatSharp/Net/Abstractions/StatusUpdate.cs
index ac86d3100..288e12ac8 100644
--- a/DisCatSharp/Net/Abstractions/StatusUpdate.cs
+++ b/DisCatSharp/Net/Abstractions/StatusUpdate.cs
@@ -1,79 +1,74 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using DisCatSharp.Entities;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions
 {
 	/// <summary>
 	/// Represents data for websocket status update payload.
 	/// </summary>
 	internal sealed class StatusUpdate
 	{
 		/// <summary>
 		/// Gets or sets the unix millisecond timestamp of when the user went idle.
 		/// </summary>
 		[JsonProperty("since", NullValueHandling = NullValueHandling.Include)]
 		public long? IdleSince { get; set; }
 
 		/// <summary>
 		/// Gets or sets whether the user is AFK.
 		/// </summary>
 		[JsonProperty("afk")]
 		public bool IsAfk { get; set; }
 
 		/// <summary>
 		/// Gets or sets the status of the user.
 		/// </summary>
 		[JsonIgnore]
 		public UserStatus Status { get; set; } = UserStatus.Online;
 
 		/// <summary>
 		/// Gets the status string of the user.
 		/// </summary>
 		[JsonProperty("status")]
-		internal string StatusString
-		{
-			get
+		internal string StatusString =>
+			this.Status switch
 			{
-				return this.Status switch
-				{
-					UserStatus.Online => "online",
-					UserStatus.Idle => "idle",
-					UserStatus.DoNotDisturb => "dnd",
-					UserStatus.Invisible or UserStatus.Offline => "invisible",
-					UserStatus.Streaming => "streaming",
-					_ => "online",
-				};
-			}
-		}
+				UserStatus.Online => "online",
+				UserStatus.Idle => "idle",
+				UserStatus.DoNotDisturb => "dnd",
+				UserStatus.Invisible or UserStatus.Offline => "invisible",
+				UserStatus.Streaming => "streaming",
+				_ => "online",
+			};
 
 		/// <summary>
 		/// Gets or sets the game the user is playing.
 		/// </summary>
 		[JsonProperty("game", NullValueHandling = NullValueHandling.Ignore)]
 		public TransportActivity Activity { get; set; }
 
 		internal DiscordActivity ActivityInternal;
 	}
 }
diff --git a/DisCatSharp/Net/Abstractions/Transport/TransportActivity.cs b/DisCatSharp/Net/Abstractions/Transport/TransportActivity.cs
index d7357f0fc..4443c7b27 100644
--- a/DisCatSharp/Net/Abstractions/Transport/TransportActivity.cs
+++ b/DisCatSharp/Net/Abstractions/Transport/TransportActivity.cs
@@ -1,374 +1,372 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using DisCatSharp.Entities;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Net.Abstractions
 {
 	/// <summary>
 	/// Represents a game a user is playing.
 	/// </summary>
 	internal sealed class TransportActivity
 	{
 		/// <summary>
 		/// Gets or sets the id of user's activity.
 		/// </summary>
 		[JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
 		public string Id { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets the name of the game the user is playing.
 		/// </summary>
 		[JsonProperty("name", NullValueHandling = NullValueHandling.Include)]
 		public string Name { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets the stream URI, if applicable.
 		/// </summary>
 		[JsonProperty("url", NullValueHandling = NullValueHandling.Ignore)]
 		public string StreamUrl { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets the livesteam type.
 		/// </summary>
 		[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 		public ActivityType ActivityType { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets the details.
 		///
 		/// <para>This is a component of the rich presence, and, as such, can only be used by regular users.</para>
 		/// </summary>
 		[JsonProperty("details", NullValueHandling = NullValueHandling.Ignore)]
 		public string Details { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets game state.
 		///
 		/// <para>This is a component of the rich presence, and, as such, can only be used by regular users.</para>
 		/// </summary>
 		[JsonProperty("state", NullValueHandling = NullValueHandling.Ignore)]
 		public string State { get; internal set; }
 
 		/// <summary>
 		/// Gets the emoji details for a custom status, if any.
 		/// </summary>
 		[JsonProperty("emoji", NullValueHandling = NullValueHandling.Ignore)]
 		public DiscordEmoji Emoji { get; internal set; }
 
 		/// <summary>
 		/// Gets ID of the application for which this rich presence is for.
 		///
 		/// This is a component of the rich presence, and, as such, can only be used by regular users.
 		/// </summary>
 		[JsonIgnore]
 		public ulong? ApplicationId
 		{
 			get => this.ApplicationIdStr != null ? (ulong?)ulong.Parse(this.ApplicationIdStr, CultureInfo.InvariantCulture) : null;
 			internal set => this.ApplicationIdStr = value?.ToString(CultureInfo.InvariantCulture);
 		}
 
 		/// <summary>
 		/// Gets or sets the application id string.
 		/// </summary>
 		[JsonProperty("application_id", NullValueHandling = NullValueHandling.Ignore)]
 		internal string ApplicationIdStr { get; set; }
 
 		/// <summary>
 		/// Gets or sets instance status.
 		///
 		/// This is a component of the rich presence, and, as such, can only be used by regular users.
 		/// </summary>
 		[JsonProperty("instance", NullValueHandling = NullValueHandling.Ignore)]
 		public bool? Instance { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets information about the current game's party.
 		///
 		/// This is a component of the rich presence, and, as such, can only be used by regular users.
 		/// </summary>
 		[JsonProperty("party", NullValueHandling = NullValueHandling.Ignore)]
 		public GameParty Party { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets information about assets related to this rich presence.
 		///
 		/// This is a component of the rich presence, and, as such, can only be used by regular users.
 		/// </summary>
 		[JsonProperty("assets", NullValueHandling = NullValueHandling.Ignore)]
 		public PresenceAssets Assets { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets information about buttons in this rich presence.
 		///
 		/// This is a component of the rich presence, and, as such, can only be used by regular users.
 		/// </summary>
 		[JsonProperty("buttons", NullValueHandling = NullValueHandling.Ignore)]
 		public IReadOnlyList<string> Buttons { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets platform in this rich presence.
 		///
 		/// This is a component of the rich presence, and, as such, can only be used by regular users.
 		/// </summary>
 		[JsonProperty("platform", NullValueHandling = NullValueHandling.Ignore)]
 		public string Platform { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets sync_id in this rich presence.
 		///
 		/// This is a component of the rich presence, and, as such, can only be used by regular users.
 		/// </summary>
 		[JsonProperty("sync_id", NullValueHandling = NullValueHandling.Ignore)]
 		public string SyncId { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets session_id in this rich presence.
 		///
 		/// This is a component of the rich presence, and, as such, can only be used by regular users.
 		/// </summary>
 		[JsonProperty("session_id", NullValueHandling = NullValueHandling.Ignore)]
 		public string SessionId { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets infromation about current game's timestamps.
 		///
 		/// This is a component of the rich presence, and, as such, can only be used by regular users.
 		/// </summary>
 		[JsonProperty("timestamps", NullValueHandling = NullValueHandling.Ignore)]
 		public GameTimestamps Timestamps { get; internal set; }
 
 		/// <summary>
 		/// Gets or sets information about current game's secret values.
 		///
 		/// This is a component of the rich presence, and, as such, can only be used by regular users.
 		/// </summary>
 		[JsonProperty("secrets", NullValueHandling = NullValueHandling.Ignore)]
 		public GameSecrets Secrets { get; internal set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="TransportActivity"/> class.
 		/// </summary>
 		internal TransportActivity() { }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="TransportActivity"/> class.
 		/// </summary>
 		/// <param name="game">The game.</param>
 		internal TransportActivity(DiscordActivity game)
 		{
 			if (game == null)
 				return;
 
 			this.Name = game.Name;
 			this.ActivityType = game.ActivityType;
 			this.StreamUrl = game.StreamUrl;
 		}
 
 		/// <summary>
 		/// Whether this activity is a rich presence.
 		/// </summary>
 		public bool IsRichPresence()
 			=> this.Details != null || this.State != null || this.ApplicationId != null || this.Instance != null || this.Party != null || this.Assets != null || this.Secrets != null || this.Timestamps != null || this.Buttons != null;
 
 		/// <summary>
 		/// Whether this activity is a custom status.
 		/// </summary>
 		public bool IsCustomStatus()
 			=> this.Name == "Custom Status";
 
 		/// <summary>
 		/// Represents information about assets attached to a rich presence.
 		/// </summary>
 		public class PresenceAssets
 		{
 			/// <summary>
 			/// Gets the large image asset ID.
 			/// </summary>
 			[JsonProperty("large_image")]
 			public string LargeImage { get; set; }
 
 			/// <summary>
 			/// Gets the large image text.
 			/// </summary>
 			[JsonProperty("large_text", NullValueHandling = NullValueHandling.Ignore)]
 			public string LargeImageText { get; internal set; }
 
 			/// <summary>
 			/// Gets the small image asset ID.
 			/// </summary>
 			[JsonProperty("small_image")]
 			internal string SmallImage { get; set; }
 
 			/// <summary>
 			/// Gets the small image text.
 			/// </summary>
 			[JsonProperty("small_text", NullValueHandling = NullValueHandling.Ignore)]
 			public string SmallImageText { get; internal set; }
 		}
 
 		/// <summary>
 		/// Represents information about rich presence game party.
 		/// </summary>
 		public class GameParty
 		{
 			/// <summary>
 			/// Gets the game party ID.
 			/// </summary>
 			[JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
 			public string Id { get; internal set; }
 
 			/// <summary>
 			/// Gets the size of the party.
 			/// </summary>
 			[JsonProperty("size", NullValueHandling = NullValueHandling.Ignore)]
 			public GamePartySize Size { get; internal set; }
 
 			/// <summary>
 			/// Represents information about party size.
 			/// </summary>
 			[JsonConverter(typeof(GamePartySizeConverter))]
 			public class GamePartySize
 			{
 				/// <summary>
 				/// Gets the current number of players in the party.
 				/// </summary>
 				public long Current { get; internal set; }
 
 				/// <summary>
 				/// Gets the maximum party size.
 				/// </summary>
 				public long Maximum { get; internal set; }
 			}
 		}
 
 		/// <summary>
 		/// Represents information about the game state's timestamps.
 		/// </summary>
 		public class GameTimestamps
 		{
 			/// <summary>
 			/// Gets the time the game has started.
 			/// </summary>
 			[JsonIgnore]
 			public DateTimeOffset? Start
 				=> this.StartInternal != null ? (DateTimeOffset?)Utilities.GetDateTimeOffsetFromMilliseconds(this.StartInternal.Value, false) : null;
 
 			[JsonProperty("start", NullValueHandling = NullValueHandling.Ignore)]
 			internal long? StartInternal;
 
 			/// <summary>
 			/// Gets the time the game is going to end.
 			/// </summary>
 			[JsonIgnore]
 			public DateTimeOffset? End
 				=> this.EndInternal != null ? (DateTimeOffset?)Utilities.GetDateTimeOffsetFromMilliseconds(this.EndInternal.Value, false) : null;
 
 			[JsonProperty("end", NullValueHandling = NullValueHandling.Ignore)]
 			internal long? EndInternal;
 		}
 
 		/// <summary>
 		/// Represents information about secret values for the Join, Spectate, and Match actions.
 		/// </summary>
 		public class GameSecrets
 		{
 			/// <summary>
 			/// Gets the secret value for join action.
 			/// </summary>
 			[JsonProperty("join", NullValueHandling = NullValueHandling.Ignore)]
 			public string Join { get; internal set; }
 
 			/// <summary>
 			/// Gets the secret value for match action.
 			/// </summary>
 			[JsonProperty("match", NullValueHandling = NullValueHandling.Ignore)]
 			public string Match { get; internal set; }
 
 			/// <summary>
 			/// Gets the secret value for spectate action.
 			/// </summary>
 			[JsonProperty("spectate", NullValueHandling = NullValueHandling.Ignore)]
 			public string Spectate { get; internal set; }
 		}
 	}
 
 	/// <summary>
 	/// Represents a game party size converter.
 	/// </summary>
 	internal sealed class GamePartySizeConverter : JsonConverter
 	{
 		/// <summary>
 		/// Writes the json.
 		/// </summary>
 		/// <param name="writer">The writer.</param>
 		/// <param name="value">The value.</param>
 		/// <param name="serializer">The serializer.</param>
 		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 		{
 			var obj = value is TransportActivity.GameParty.GamePartySize sinfo
 				? new object[] { sinfo.Current, sinfo.Maximum }
 				: null;
 			serializer.Serialize(writer, obj);
 		}
 
 		/// <summary>
 		/// Reads the json.
 		/// </summary>
 		/// <param name="reader">The reader.</param>
 		/// <param name="objectType">The object type.</param>
 		/// <param name="existingValue">The existing value.</param>
 		/// <param name="serializer">The serializer.</param>
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 		{
 			var arr = this.ReadArrayObject(reader, serializer);
 			return new TransportActivity.GameParty.GamePartySize
 			{
 				Current = (long)arr[0],
 				Maximum = (long)arr[1],
 			};
 		}
 
 		/// <summary>
 		/// Reads the array object.
 		/// </summary>
 		/// <param name="reader">The reader.</param>
 		/// <param name="serializer">The serializer.</param>
-		private JArray ReadArrayObject(JsonReader reader, JsonSerializer serializer)
-		{
-			return serializer.Deserialize<JToken>(reader) is not JArray arr || arr.Count != 2
+		private JArray ReadArrayObject(JsonReader reader, JsonSerializer serializer) =>
+			serializer.Deserialize<JToken>(reader) is not JArray arr || arr.Count != 2
 				? throw new JsonSerializationException("Expected array of length 2")
 				: arr;
-		}
 
 		/// <summary>
 		/// Whether it can convert.
 		/// </summary>
 		/// <param name="objectType">The object type.</param>
 		public override bool CanConvert(Type objectType) => objectType == typeof(TransportActivity.GameParty.GamePartySize);
 	}
 }
diff --git a/DisCatSharp/Net/Rest/BaseRestRequest.cs b/DisCatSharp/Net/Rest/BaseRestRequest.cs
index b663dda39..37e52d558 100644
--- a/DisCatSharp/Net/Rest/BaseRestRequest.cs
+++ b/DisCatSharp/Net/Rest/BaseRestRequest.cs
@@ -1,132 +1,132 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Net
 {
 	/// <summary>
 	/// Represents a request sent over HTTP.
 	/// </summary>
 	public abstract class BaseRestRequest
 	{
 		/// <summary>
 		/// Gets the discord client.
 		/// </summary>
 		protected internal BaseDiscordClient Discord { get; }
 
 		/// <summary>
 		/// Gets the request task source.
 		/// </summary>
 		protected internal TaskCompletionSource<RestResponse> RequestTaskSource { get; }
 
 		/// <summary>
 		/// Gets the url to which this request is going to be made.
 		/// </summary>
 		public Uri Url { get; }
 
 		/// <summary>
 		/// Gets the HTTP method used for this request.
 		/// </summary>
 		public RestRequestMethod Method { get; }
 
 		/// <summary>
 		/// Gets the generic path (no parameters) for this request.
 		/// </summary>
 		public string Route { get; }
 
 		/// <summary>
 		/// Gets the headers sent with this request.
 		/// </summary>
-		public IReadOnlyDictionary<string, string> Headers { get; } = null;
+		public IReadOnlyDictionary<string, string> Headers { get; }
 
 		/// <summary>
 		/// Gets the override for the rate limit bucket wait time.
 		/// </summary>
 		public double? RateLimitWaitOverride { get; }
 
 		/// <summary>
 		/// Gets the rate limit bucket this request is in.
 		/// </summary>
 		internal RateLimitBucket RateLimitBucket { get; }
 
 		/// <summary>
 		/// Creates a new <see cref="BaseRestRequest"/> with specified parameters.
 		/// </summary>
 		/// <param name="client"><see cref="DiscordClient"/> from which this request originated.</param>
 		/// <param name="bucket">Rate limit bucket to place this request in.</param>
 		/// <param name="url">Uri to which this request is going to be sent to.</param>
 		/// <param name="method">Method to use for this request,</param>
 		/// <param name="route">The generic route the request url will use.</param>
 		/// <param name="headers">Additional headers for this request.</param>
 		/// <param name="ratelimitWaitOverride">Override for ratelimit bucket wait time.</param>
 		internal BaseRestRequest(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null, double? ratelimitWaitOverride = null)
 		{
 			this.Discord = client;
 			this.RateLimitBucket = bucket;
 			this.RequestTaskSource = new TaskCompletionSource<RestResponse>();
 			this.Url = url;
 			this.Method = method;
 			this.Route = route;
 			this.RateLimitWaitOverride = ratelimitWaitOverride;
 
 			if (headers != null)
 			{
 				headers = headers.Select(x => new KeyValuePair<string, string>(x.Key, Uri.EscapeDataString(x.Value)))
 					.ToDictionary(x => x.Key, x => x.Value);
 				this.Headers = headers;
 			}
 		}
 
 		/// <summary>
 		/// Asynchronously waits for this request to complete.
 		/// </summary>
 		/// <returns>HTTP response to this request.</returns>
 		public Task<RestResponse> WaitForCompletionAsync()
 			=> this.RequestTaskSource.Task;
 
 		/// <summary>
 		/// Sets as completed.
 		/// </summary>
 		/// <param name="response">The response to set.</param>
 		protected internal void SetCompleted(RestResponse response)
 			=> this.RequestTaskSource.SetResult(response);
 
 		/// <summary>
 		/// Sets as faulted.
 		/// </summary>
 		/// <param name="ex">The exception to set.</param>
 		protected internal void SetFaulted(Exception ex)
 			=> this.RequestTaskSource.SetException(ex);
 
 		/// <summary>
 		/// Tries to set as faulted.
 		/// </summary>
 		/// <param name="ex">The exception to set.</param>
 		protected internal bool TrySetFaulted(Exception ex)
 			=> this.RequestTaskSource.TrySetException(ex);
 
 	}
 }
diff --git a/DisCatSharp/Net/Rest/DiscordApiClient.cs b/DisCatSharp/Net/Rest/DiscordApiClient.cs
index bdc43d6e1..6a78babad 100644
--- a/DisCatSharp/Net/Rest/DiscordApiClient.cs
+++ b/DisCatSharp/Net/Rest/DiscordApiClient.cs
@@ -1,5411 +1,5411 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Text;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Serialization;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Net
 {
 	/// <summary>
 	/// Represents a discord api client.
 	/// </summary>
 	public sealed class DiscordApiClient
 	{
 		/// <summary>
 		/// The audit log reason header name.
 		/// </summary>
 		private const string REASON_HEADER_NAME = "X-Audit-Log-Reason";
 
 		/// <summary>
 		/// Gets the discord client.
 		/// </summary>
 		internal BaseDiscordClient Discord { get; }
 		/// <summary>
 		/// Gets the rest client.
 		/// </summary>
 		internal RestClient Rest { get; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordApiClient"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		internal DiscordApiClient(BaseDiscordClient client)
 		{
 			this.Discord = client;
 			this.Rest = new RestClient(client);
 		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordApiClient"/> class.
 		/// </summary>
 		/// <param name="proxy">The proxy.</param>
 		/// <param name="timeout">The timeout.</param>
 		/// <param name="useRelativeRateLimit">If true, use relative rate limit.</param>
 		/// <param name="logger">The logger.</param>
 		internal DiscordApiClient(IWebProxy proxy, TimeSpan timeout, bool useRelativeRateLimit, ILogger logger) // This is for meta-clients, such as the webhook client
 		{
 			this.Rest = new RestClient(proxy, timeout, useRelativeRateLimit, logger);
 		}
 
 		/// <summary>
 		/// Builds the query string.
 		/// </summary>
 		/// <param name="values">The values.</param>
 		/// <param name="post">If true, post.</param>
 		/// <returns>A string.</returns>
 		private static string BuildQueryString(IDictionary<string, string> values, bool post = false)
 		{
 			if (values == null || values.Count == 0)
 				return string.Empty;
 
 			var valsCollection = values.Select(xkvp =>
 				$"{WebUtility.UrlEncode(xkvp.Key)}={WebUtility.UrlEncode(xkvp.Value)}");
 			var vals = string.Join("&", valsCollection);
 
 			return !post ? $"?{vals}" : vals;
 		}
 
 		/// <summary>
 		/// Prepares the message.
 		/// </summary>
 		/// <param name="msgRaw">The msg_raw.</param>
 		/// <returns>A DiscordMessage.</returns>
 		private DiscordMessage PrepareMessage(JToken msgRaw)
 		{
 			var author = msgRaw["author"].ToObject<TransportUser>();
 			var ret = msgRaw.ToDiscordObject<DiscordMessage>();
 			ret.Discord = this.Discord;
 
 			this.PopulateMessage(author, ret);
 
 			var referencedMsg = msgRaw["referenced_message"];
 			if (ret.MessageType == MessageType.Reply && !string.IsNullOrWhiteSpace(referencedMsg?.ToString()))
 			{
 				author = referencedMsg["author"].ToObject<TransportUser>();
 				ret.ReferencedMessage.Discord = this.Discord;
 				this.PopulateMessage(author, ret.ReferencedMessage);
 			}
 
 			if (ret.Channel != null)
 				return ret;
 
 			var channel = !ret.GuildId.HasValue
 				? new DiscordDmChannel
 				{
 					Id = ret.ChannelId,
 					Discord = this.Discord,
 					Type = ChannelType.Private
 				}
 				: new DiscordChannel
 				{
 					Id = ret.ChannelId,
 					GuildId = ret.GuildId,
 					Discord = this.Discord
 				};
 
 			ret.Channel = channel;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Populates the message.
 		/// </summary>
 		/// <param name="author">The author.</param>
 		/// <param name="ret">The ret.</param>
 		private void PopulateMessage(TransportUser author, DiscordMessage ret)
 		{
 			var guild = ret.Channel?.Guild;
 
 			//If this is a webhook, it shouldn't be in the user cache.
 			if (author.IsBot && int.Parse(author.Discriminator) == 0)
 			{
 				ret.Author = new DiscordUser(author) { Discord = this.Discord };
 			}
 			else
 			{
 				if (!this.Discord.UserCache.TryGetValue(author.Id, out var usr))
 				{
 					this.Discord.UserCache[author.Id] = usr = new DiscordUser(author) { Discord = this.Discord };
 				}
 
 				if (guild != null)
 				{
 					if (!guild.Members.TryGetValue(author.Id, out var mbr))
 						mbr = new DiscordMember(usr) { Discord = this.Discord, GuildId = guild.Id };
 					ret.Author = mbr;
 				}
 				else
 				{
 					ret.Author = usr;
 				}
 			}
 
 			ret.PopulateMentions();
 
 			if (ret.ReactionsInternal == null)
 				ret.ReactionsInternal = new List<DiscordReaction>();
 			foreach (var xr in ret.ReactionsInternal)
 				xr.Emoji.Discord = this.Discord;
 		}
 
 		/// <summary>
 		/// Executes a rest request.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="bucket">The bucket.</param>
 		/// <param name="url">The url.</param>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <param name="headers">The headers.</param>
 		/// <param name="payload">The payload.</param>
 		/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 		internal Task<RestResponse> DoRequestAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null, string payload = null, double? ratelimitWaitOverride = null)
 		{
 			var req = new RestRequest(client, bucket, url, method, route, headers, payload, ratelimitWaitOverride);
 
 			if (this.Discord != null)
 				this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 			else
 				_ = this.Rest.ExecuteRequestAsync(req);
 
 			return req.WaitForCompletionAsync();
 		}
 
 		/// <summary>
 		/// Executes a multipart rest request for stickers.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="bucket">The bucket.</param>
 		/// <param name="url">The url.</param>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <param name="headers">The headers.</param>
 		/// <param name="file">The file.</param>
 		/// <param name="name">The sticker name.</param>
 		/// <param name="tags">The sticker tag.</param>
 		/// <param name="description">The sticker description.</param>
 		/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 		private Task<RestResponse> DoStickerMultipartAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null,
 			DiscordMessageFile file = null, string name = "", string tags = "", string description = "", double? ratelimitWaitOverride = null)
 		{
 			var req = new MultipartStickerWebRequest(client, bucket, url, method, route, headers, file, name, tags, description, ratelimitWaitOverride);
 
 			if (this.Discord != null)
 				this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 			else
 				_ = this.Rest.ExecuteRequestAsync(req);
 
 			return req.WaitForCompletionAsync();
 		}
 
 		/// <summary>
 		/// Executes a multipart request.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="bucket">The bucket.</param>
 		/// <param name="url">The url.</param>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <param name="headers">The headers.</param>
 		/// <param name="values">The values.</param>
 		/// <param name="files">The files.</param>
 		/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 		private Task<RestResponse> DoMultipartAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null, IReadOnlyDictionary<string, string> values = null,
 			IReadOnlyCollection<DiscordMessageFile> files = null, double? ratelimitWaitOverride = null)
 		{
 			var req = new MultipartWebRequest(client, bucket, url, method, route, headers, values, files, ratelimitWaitOverride);
 
 			if (this.Discord != null)
 				this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 			else
 				_ = this.Rest.ExecuteRequestAsync(req);
 
 			return req.WaitForCompletionAsync();
 		}
 
 		#region Guild
 
 		/// <summary>
 		/// Searches the members async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="limit">The limit.</param>
 		internal async Task<IReadOnlyList<DiscordMember>> SearchMembersAsync(ulong guildId, string name, int? limit)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}{Endpoints.SEARCH}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 			var querydict = new Dictionary<string, string>
 			{
 				["query"] = name,
 				["limit"] = limit.ToString()
 			};
 			var url = Utilities.GetApiUriFor(path, BuildQueryString(querydict), this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 			var json = JArray.Parse(res.Response);
 			var tms = json.ToObject<IReadOnlyList<TransportMember>>();
 
 			var mbrs = new List<DiscordMember>();
 			foreach (var xtm in tms)
 			{
 				var usr = new DiscordUser(xtm.User) { Discord = this.Discord };
 
 				this.Discord.UserCache.AddOrUpdate(xtm.User.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discord = usr.Discord;
 					old.AvatarHash = usr.AvatarHash;
 
 					return old;
 				});
 
 				mbrs.Add(new DiscordMember(xtm) { Discord = this.Discord, GuildId = guildId });
 			}
 
 			return mbrs;
 		}
 
 		/// <summary>
 		/// Gets the guild ban async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		internal async Task<DiscordBan> GetGuildBanAsync(ulong guildId, ulong userId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, user_id = userId}, out var path);
 			var uri = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, uri, RestRequestMethod.GET, route).ConfigureAwait(false);
 			var json = JObject.Parse(res.Response);
 
 			var ban = json.ToObject<DiscordBan>();
 
 			return ban;
 		}
 
 		/// <summary>
 		/// Creates the guild async.
 		/// </summary>
 		/// <param name="name">The name.</param>
 		/// <param name="regionId">The region_id.</param>
 		/// <param name="iconb64">The iconb64.</param>
 		/// <param name="verificationLevel">The verification_level.</param>
 		/// <param name="defaultMessageNotifications">The default_message_notifications.</param>
 		/// <param name="systemChannelFlags">The system_channel_flags.</param>
 		internal async Task<DiscordGuild> CreateGuildAsync(string name, string regionId, Optional<string> iconb64, VerificationLevel? verificationLevel,
 			DefaultMessageNotifications? defaultMessageNotifications, SystemChannelFlags? systemChannelFlags)
 		{
 			var pld = new RestGuildCreatePayload
 			{
 				Name = name,
 				RegionId = regionId,
 				DefaultMessageNotifications = defaultMessageNotifications,
 				VerificationLevel = verificationLevel,
 				IconBase64 = iconb64,
 				SystemChannelFlags = systemChannelFlags
 
 			};
 
 			var route = $"{Endpoints.GUILDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawMembers = (JArray)json["members"];
 			var guild = json.ToDiscordObject<DiscordGuild>();
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildCreateEventAsync(guild, rawMembers, null).ConfigureAwait(false);
 			return guild;
 		}
 
 		/// <summary>
 		/// Creates the guild from template async.
 		/// </summary>
 		/// <param name="templateCode">The template_code.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="iconb64">The iconb64.</param>
 		internal async Task<DiscordGuild> CreateGuildFromTemplateAsync(string templateCode, string name, Optional<string> iconb64)
 		{
 			var pld = new RestGuildCreateFromTemplatePayload
 			{
 				Name = name,
 				IconBase64 = iconb64
 			};
 
 			var route = $"{Endpoints.GUILDS}{Endpoints.TEMPLATES}/:template_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {template_code = templateCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawMembers = (JArray)json["members"];
 			var guild = json.ToDiscordObject<DiscordGuild>();
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildCreateEventAsync(guild, rawMembers, null).ConfigureAwait(false);
 			return guild;
 		}
 
 		/// <summary>
 		/// Deletes the guild async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		internal async Task DeleteGuildAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route).ConfigureAwait(false);
 
 			if (this.Discord is DiscordClient dc)
 			{
 				var gld = dc.GuildsInternal[guildId];
 				await dc.OnGuildDeleteEventAsync(gld).ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Modifies the guild.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="verificationLevel">The verification level.</param>
 		/// <param name="defaultMessageNotifications">The default message notifications.</param>
 		/// <param name="mfaLevel">The mfa level.</param>
 		/// <param name="explicitContentFilter">The explicit content filter.</param>
 		/// <param name="afkChannelId">The afk channel id.</param>
 		/// <param name="afkTimeout">The afk timeout.</param>
 		/// <param name="iconb64">The iconb64.</param>
 		/// <param name="ownerId">The owner id.</param>
 		/// <param name="splashb64">The splashb64.</param>
 		/// <param name="systemChannelId">The system channel id.</param>
 		/// <param name="systemChannelFlags">The system channel flags.</param>
 		/// <param name="publicUpdatesChannelId">The public updates channel id.</param>
 		/// <param name="rulesChannelId">The rules channel id.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="bannerb64">The banner base64.</param>
 		/// <param name="discorverySplashb64">The discovery base64.</param>
 		/// <param name="preferredLocale">The preferred locale.</param>
 		/// <param name="premiumProgressBarEnabled">Whether the premium progress bar should be enabled.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordGuild> ModifyGuildAsync(ulong guildId, Optional<string> name, Optional<VerificationLevel> verificationLevel,
 			Optional<DefaultMessageNotifications> defaultMessageNotifications, Optional<MfaLevel> mfaLevel,
 			Optional<ExplicitContentFilter> explicitContentFilter, Optional<ulong?> afkChannelId,
 			Optional<int> afkTimeout, Optional<string> iconb64, Optional<ulong> ownerId, Optional<string> splashb64,
 			Optional<ulong?> systemChannelId, Optional<SystemChannelFlags> systemChannelFlags,
 			Optional<ulong?> publicUpdatesChannelId, Optional<ulong?> rulesChannelId, Optional<string> description,
 			Optional<string> bannerb64, Optional<string> discorverySplashb64, Optional<string> preferredLocale, Optional<bool> premiumProgressBarEnabled, string reason)
 		{
 			var pld = new RestGuildModifyPayload
 			{
 				Name = name,
 				VerificationLevel = verificationLevel,
 				DefaultMessageNotifications = defaultMessageNotifications,
 				MfaLevel = mfaLevel,
 				ExplicitContentFilter = explicitContentFilter,
 				AfkChannelId = afkChannelId,
 				AfkTimeout = afkTimeout,
 				IconBase64 = iconb64,
 				SplashBase64 = splashb64,
 				BannerBase64 = bannerb64,
 				DiscoverySplashBase64 = discorverySplashb64,
 				OwnerId = ownerId,
 				SystemChannelId = systemChannelId,
 				SystemChannelFlags = systemChannelFlags,
 				RulesChannelId = rulesChannelId,
 				PublicUpdatesChannelId = publicUpdatesChannelId,
 				PreferredLocale = preferredLocale,
 				Description = description,
 				PremiumProgressBarEnabled = premiumProgressBarEnabled
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawMembers = (JArray)json["members"];
 			var guild = json.ToDiscordObject<DiscordGuild>();
 			foreach (var r in guild.RolesInternal.Values)
 				r.GuildId = guild.Id;
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildUpdateEventAsync(guild, rawMembers).ConfigureAwait(false);
 			return guild;
 		}
 
 
 
 		/// <summary>
 		/// Modifies the guild community settings.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="features">The guild features.</param>
 		/// <param name="rulesChannelId">The rules channel id.</param>
 		/// <param name="publicUpdatesChannelId">The public updates channel id.</param>
 		/// <param name="preferredLocale">The preferred locale.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="defaultMessageNotifications">The default message notifications.</param>
 		/// <param name="explicitContentFilter">The explicit content filter.</param>
 		/// <param name="verificationLevel">The verification level.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordGuild> ModifyGuildCommunitySettingsAsync(ulong guildId, List<string> features, Optional<ulong?> rulesChannelId, Optional<ulong?> publicUpdatesChannelId, string preferredLocale, string description, DefaultMessageNotifications defaultMessageNotifications, ExplicitContentFilter explicitContentFilter, VerificationLevel verificationLevel, string reason)
 		{
 			var pld = new RestGuildCommunityModifyPayload
 			{
 				VerificationLevel = verificationLevel,
 				DefaultMessageNotifications = defaultMessageNotifications,
 				ExplicitContentFilter = explicitContentFilter,
 				RulesChannelId = rulesChannelId,
 				PublicUpdatesChannelId = publicUpdatesChannelId,
 				PreferredLocale = preferredLocale,
 				Description = description ?? Optional.FromNoValue<string>(),
 				Features = features
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawMembers = (JArray)json["members"];
 			var guild = json.ToDiscordObject<DiscordGuild>();
 			foreach (var r in guild.RolesInternal.Values)
 				r.GuildId = guild.Id;
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildUpdateEventAsync(guild, rawMembers).ConfigureAwait(false);
 			return guild;
 		}
 
 		/// <summary>
 		/// Gets the guild bans async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordBan>> GetGuildBansAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var bansRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordBan>>(res.Response).Select(xb =>
 			{
 				if (!this.Discord.TryGetCachedUserInternal(xb.RawUser.Id, out var usr))
 				{
 					usr = new DiscordUser(xb.RawUser) { Discord = this.Discord };
 					usr = this.Discord.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 					{
 						old.Username = usr.Username;
 						old.Discriminator = usr.Discriminator;
 						old.AvatarHash = usr.AvatarHash;
 						return old;
 					});
 				}
 
 				xb.User = usr;
 				return xb;
 			});
 			var bans = new ReadOnlyCollection<DiscordBan>(new List<DiscordBan>(bansRaw));
 
 			return bans;
 		}
 
 		/// <summary>
 		/// Creates the guild ban async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="deleteMessageDays">The delete_message_days.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task CreateGuildBanAsync(ulong guildId, ulong userId, int deleteMessageDays, string reason)
 		{
 			if (deleteMessageDays < 0 || deleteMessageDays > 7)
 				throw new ArgumentException("Delete message days must be a number between 0 and 7.", nameof(deleteMessageDays));
 
 			var urlparams = new Dictionary<string, string>
 			{
 				["delete_message_days"] = deleteMessageDays.ToString(CultureInfo.InvariantCulture)
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, BuildQueryString(urlparams), this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers);
 		}
 
 		/// <summary>
 		/// Removes the guild ban async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task RemoveGuildBanAsync(ulong guildId, ulong userId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Leaves the guild async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task LeaveGuildAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.GUILDS}/:guild_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Adds the guild member async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="accessToken">The access_token.</param>
 		/// <param name="nick">The nick.</param>
 		/// <param name="roles">The roles.</param>
 		/// <param name="muted">If true, muted.</param>
 		/// <param name="deafened">If true, deafened.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMember> AddGuildMemberAsync(ulong guildId, ulong userId, string accessToken, string nick, IEnumerable<DiscordRole> roles, bool muted, bool deafened)
 		{
 			var pld = new RestGuildMemberAddPayload
 			{
 				AccessToken = accessToken,
 				Nickname = nick ?? "",
 				Roles = roles ?? new List<DiscordRole>(),
 				Deaf = deafened,
 				Mute = muted
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var tm = JsonConvert.DeserializeObject<TransportMember>(res.Response);
 
 			return new DiscordMember(tm) { Discord = this.Discord, GuildId = guildId };
 		}
 
 		/// <summary>
 		/// Lists the guild members async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="limit">The limit.</param>
 		/// <param name="after">The after.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<TransportMember>> ListGuildMembersAsync(ulong guildId, int? limit, ulong? after)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (limit != null && limit > 0)
 				urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 			if (after != null)
 				urlparams["after"] = after.Value.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var membersRaw = JsonConvert.DeserializeObject<List<TransportMember>>(res.Response);
 			return new ReadOnlyCollection<TransportMember>(membersRaw);
 		}
 
 		/// <summary>
 		/// Adds the guild member role async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="roleId">The role_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task AddGuildMemberRoleAsync(ulong guildId, ulong userId, ulong roleId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id{Endpoints.ROLES}/:role_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, user_id = userId, role_id = roleId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers);
 		}
 
 		/// <summary>
 		/// Removes the guild member role async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="roleId">The role_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task RemoveGuildMemberRoleAsync(ulong guildId, ulong userId, ulong roleId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id{Endpoints.ROLES}/:role_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, user_id = userId, role_id = roleId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Modifies the guild channel position async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="pld">The pld.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task ModifyGuildChannelPositionAsync(ulong guildId, IEnumerable<RestGuildChannelReorderPayload> pld, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Modifies the guild channel parent async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="pld">The pld.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task ModifyGuildChannelParentAsync(ulong guildId, IEnumerable<RestGuildChannelNewParentPayload> pld, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Detaches the guild channel parent async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="pld">The pld.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DetachGuildChannelParentAsync(ulong guildId, IEnumerable<RestGuildChannelNoParentPayload> pld, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Modifies the guild role position async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="pld">The pld.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task ModifyGuildRolePositionAsync(ulong guildId, IEnumerable<RestGuildRoleReorderPayload> pld, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Gets the audit logs async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="limit">The limit.</param>
 		/// <param name="after">The after.</param>
 		/// <param name="before">The before.</param>
 		/// <param name="responsible">The responsible.</param>
 		/// <param name="actionType">The action_type.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<AuditLog> GetAuditLogsAsync(ulong guildId, int limit, ulong? after, ulong? before, ulong? responsible, int? actionType)
 		{
 			var urlparams = new Dictionary<string, string>
 			{
 				["limit"] = limit.ToString(CultureInfo.InvariantCulture)
 			};
 			if (after != null)
 				urlparams["after"] = after?.ToString(CultureInfo.InvariantCulture);
 			if (before != null)
 				urlparams["before"] = before?.ToString(CultureInfo.InvariantCulture);
 			if (responsible != null)
 				urlparams["user_id"] = responsible?.ToString(CultureInfo.InvariantCulture);
 			if (actionType != null)
 				urlparams["action_type"] = actionType?.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.AUDIT_LOGS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var auditLogDataRaw = JsonConvert.DeserializeObject<AuditLog>(res.Response);
 
 			return auditLogDataRaw;
 		}
 
 		/// <summary>
 		/// Gets the guild vanity url async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordInvite> GetGuildVanityUrlAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VANITY_URL}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var invite = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 
 			return invite;
 		}
 
 		/// <summary>
 		/// Gets the guild widget async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordWidget> GetGuildWidgetAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET_JSON}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawChannels = (JArray)json["channels"];
 
 			var ret = json.ToDiscordObject<DiscordWidget>();
 			ret.Discord = this.Discord;
 			ret.Guild = this.Discord.Guilds[guildId];
 
 			ret.Channels = ret.Guild == null
 				? rawChannels.Select(r => new DiscordChannel
 				{
 					Id = (ulong)r["id"],
 					Name = r["name"].ToString(),
 					Position = (int)r["position"]
 				}).ToList()
 				: rawChannels.Select(r =>
 				{
 					var c = ret.Guild.GetChannel((ulong)r["id"]);
 					c.Position = (int)r["position"];
 					return c;
 				}).ToList();
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the guild widget settings async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordWidgetSettings> GetGuildWidgetSettingsAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWidgetSettings>(res.Response);
 			ret.Guild = this.Discord.Guilds[guildId];
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the guild widget settings async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="isEnabled">If true, is enabled.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordWidgetSettings> ModifyGuildWidgetSettingsAsync(ulong guildId, bool? isEnabled, ulong? channelId, string reason)
 		{
 			var pld = new RestGuildWidgetSettingsPayload
 			{
 				Enabled = isEnabled,
 				ChannelId = channelId
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWidgetSettings>(res.Response);
 			ret.Guild = this.Discord.Guilds[guildId];
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the guild templates async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordGuildTemplate>> GetGuildTemplatesAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var templatesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildTemplate>>(res.Response);
 
 			return new ReadOnlyCollection<DiscordGuildTemplate>(new List<DiscordGuildTemplate>(templatesRaw));
 		}
 
 		/// <summary>
 		/// Creates the guild template async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildTemplate> CreateGuildTemplateAsync(ulong guildId, string name, string description)
 		{
 			var pld = new RestGuildTemplateCreateOrModifyPayload
 			{
 				Name = name,
 				Description = description
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Syncs the guild template async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="templateCode">The template_code.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildTemplate> SyncGuildTemplateAsync(ulong guildId, string templateCode)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, template_code = templateCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route).ConfigureAwait(false);
 
 			var templateRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 			return templateRaw;
 		}
 
 		/// <summary>
 		/// Modifies the guild template async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="templateCode">The template_code.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildTemplate> ModifyGuildTemplateAsync(ulong guildId, string templateCode, string name, string description)
 		{
 			var pld = new RestGuildTemplateCreateOrModifyPayload
 			{
 				Name = name,
 				Description = description
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, template_code = templateCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var templateRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 			return templateRaw;
 		}
 
 		/// <summary>
 		/// Deletes the guild template async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="templateCode">The template_code.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildTemplate> DeleteGuildTemplateAsync(ulong guildId, string templateCode)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, template_code = templateCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route).ConfigureAwait(false);
 
 			var templateRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 			return templateRaw;
 		}
 
 		/// <summary>
 		/// Gets the guild membership screening form async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildMembershipScreening> GetGuildMembershipScreeningFormAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBER_VERIFICATION}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var screeningRaw = JsonConvert.DeserializeObject<DiscordGuildMembershipScreening>(res.Response);
 
 			return screeningRaw;
 		}
 
 		/// <summary>
 		/// Modifies the guild membership screening form async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="enabled">The enabled.</param>
 		/// <param name="fields">The fields.</param>
 		/// <param name="description">The description.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildMembershipScreening> ModifyGuildMembershipScreeningFormAsync(ulong guildId, Optional<bool> enabled, Optional<DiscordGuildMembershipScreeningField[]> fields, Optional<string> description)
 		{
 			var pld = new RestGuildMembershipScreeningFormModifyPayload
 			{
 				Enabled = enabled,
 				Description = description,
 				Fields = fields
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBER_VERIFICATION}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var screeningRaw = JsonConvert.DeserializeObject<DiscordGuildMembershipScreening>(res.Response);
 
 			return screeningRaw;
 		}
 
 		/// <summary>
 		/// Gets the guild welcome screen async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildWelcomeScreen> GetGuildWelcomeScreenAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WELCOME_SCREEN}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildWelcomeScreen>(res.Response);
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the guild welcome screen async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="enabled">The enabled.</param>
 		/// <param name="welcomeChannels">The welcome channels.</param>
 		/// <param name="description">The description.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildWelcomeScreen> ModifyGuildWelcomeScreenAsync(ulong guildId, Optional<bool> enabled, Optional<IEnumerable<DiscordGuildWelcomeScreenChannel>> welcomeChannels, Optional<string> description)
 		{
 			var pld = new RestGuildWelcomeScreenModifyPayload
 			{
 				Enabled = enabled,
 				WelcomeChannels = welcomeChannels,
 				Description = description
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WELCOME_SCREEN}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildWelcomeScreen>(res.Response);
 			return ret;
 		}
 
 		/// <summary>
 		/// Updates the current user voice state async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="suppress">If true, suppress.</param>
 		/// <param name="requestToSpeakTimestamp">The request to speak timestamp.</param>
 		/// <returns>A Task.</returns>
 		internal async Task UpdateCurrentUserVoiceStateAsync(ulong guildId, ulong channelId, bool? suppress, DateTimeOffset? requestToSpeakTimestamp)
 		{
 			var pld = new RestGuildUpdateCurrentUserVoiceStatePayload
 			{
 				ChannelId = channelId,
 				Suppress = suppress,
 				RequestToSpeakTimestamp = requestToSpeakTimestamp
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VOICE_STATES}/@me";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Updates the user voice state async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="suppress">If true, suppress.</param>
 		/// <returns>A Task.</returns>
 		internal async Task UpdateUserVoiceStateAsync(ulong guildId, ulong userId, ulong channelId, bool? suppress)
 		{
 			var pld = new RestGuildUpdateUserVoiceStatePayload
 			{
 				ChannelId = channelId,
 				Suppress = suppress
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VOICE_STATES}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 		}
 		#endregion
 
 		#region Guild Scheduled Events
 
 		/// <summary>
 		/// Creates a scheduled event.
 		/// </summary>
 		internal async Task<DiscordScheduledEvent> CreateGuildScheduledEventAsync(ulong guildId, ulong? channelId, DiscordScheduledEventEntityMetadata metadata, string name, DateTimeOffset scheduledStartTime, DateTimeOffset? scheduledEndTime, string description, ScheduledEventEntityType type, string reason = null)
 		{
 			var pld = new RestGuildScheduledEventCreatePayload
 			{
 				ChannelId = channelId,
 				EntityMetadata = metadata,
 				Name = name,
 				ScheduledStartTime = scheduledStartTime,
 				ScheduledEndTime = scheduledEndTime,
 				Description = description,
 				EntityType = type
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
 			var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 			var guild = this.Discord.Guilds[guildId];
 
 			scheduledEvent.Discord = this.Discord;
 
 			if (scheduledEvent.Creator != null)
 				scheduledEvent.Creator.Discord = this.Discord;
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildScheduledEventCreateEventAsync(scheduledEvent, guild);
 
 			return scheduledEvent;
 		}
 
 		/// <summary>
 		/// Modifies a scheduled event.
 		/// </summary>
 		internal async Task<DiscordScheduledEvent> ModifyGuildScheduledEventAsync(ulong guildId, ulong scheduledEventId, Optional<ulong?> channelId, Optional<DiscordScheduledEventEntityMetadata> metadata, Optional<string> name, Optional<DateTimeOffset> scheduledStartTime, Optional<DateTimeOffset> scheduledEndTime, Optional<string> description, Optional<ScheduledEventEntityType> type, Optional<ScheduledEventStatus> status, string reason = null)
 		{
 			var pld = new RestGuildSheduledEventModifyPayload
 			{
 				ChannelId = channelId,
 				EntityMetadata = metadata,
 				Name = name,
 				ScheduledStartTime = scheduledStartTime,
 				ScheduledEndTime = scheduledEndTime,
 				Description = description,
 				EntityType = type,
 				Status = status
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 
 			var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 			var guild = this.Discord.Guilds[guildId];
 
 			scheduledEvent.Discord = this.Discord;
 
 			if (scheduledEvent.Creator != null)
 			{
 				scheduledEvent.Creator.Discord = this.Discord;
 				this.Discord.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 				{
 					old.Username = scheduledEvent.Creator.Username;
 					old.Discriminator = scheduledEvent.Creator.Discriminator;
 					old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 					old.Flags = scheduledEvent.Creator.Flags;
 					return old;
 				});
 			}
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildScheduledEventUpdateEventAsync(scheduledEvent, guild);
 
 			return scheduledEvent;
 		}
 
 		/// <summary>
 		/// Modifies a scheduled event.
 		/// </summary>
 		internal async Task<DiscordScheduledEvent> ModifyGuildScheduledEventStatusAsync(ulong guildId, ulong scheduledEventId, ScheduledEventStatus status, string reason = null)
 		{
 			var pld = new RestGuildSheduledEventModifyPayload
 			{
 				Status = status
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 
 			var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 			var guild = this.Discord.Guilds[guildId];
 
 			scheduledEvent.Discord = this.Discord;
 
 			if (scheduledEvent.Creator != null)
 			{
 				scheduledEvent.Creator.Discord = this.Discord;
 				this.Discord.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 				{
 					old.Username = scheduledEvent.Creator.Username;
 					old.Discriminator = scheduledEvent.Creator.Discriminator;
 					old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 					old.Flags = scheduledEvent.Creator.Flags;
 					return old;
 				});
 			}
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildScheduledEventUpdateEventAsync(scheduledEvent, guild);
 
 			return scheduledEvent;
 		}
 
 		/// <summary>
 		/// Gets a scheduled event.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="scheduledEventId">The event id.</param>
 		/// <param name="withUserCount">Whether to include user count.</param>
 		internal async Task<DiscordScheduledEvent> GetGuildScheduledEventAsync(ulong guildId, ulong scheduledEventId, bool? withUserCount)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (withUserCount.HasValue)
 				urlparams["with_user_count"] = withUserCount?.ToString();
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 			var guild = this.Discord.Guilds[guildId];
 
 			scheduledEvent.Discord = this.Discord;
 
 			if (scheduledEvent.Creator != null)
 			{
 				scheduledEvent.Creator.Discord = this.Discord;
 				this.Discord.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 				{
 					old.Username = scheduledEvent.Creator.Username;
 					old.Discriminator = scheduledEvent.Creator.Discriminator;
 					old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 					old.Flags = scheduledEvent.Creator.Flags;
 					return old;
 				});
 			}
 
 			return scheduledEvent;
 		}
 
 		/// <summary>
 		/// Gets the guilds scheduled events.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="withUserCount">Whether to include the count of users subscribed to the scheduled event.</param>
 		internal async Task<IReadOnlyDictionary<ulong, DiscordScheduledEvent>> ListGuildScheduledEventsAsync(ulong guildId, bool? withUserCount)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (withUserCount.HasValue)
 				urlparams["with_user_count"] = withUserCount?.ToString();
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var events = new Dictionary<ulong, DiscordScheduledEvent>();
 			var eventsRaw = JsonConvert.DeserializeObject<List<DiscordScheduledEvent>>(res.Response);
 			var guild = this.Discord.Guilds[guildId];
 
 			foreach (var ev in eventsRaw)
 			{
 				ev.Discord = this.Discord;
 				if (ev.Creator != null)
 				{
 					ev.Creator.Discord = this.Discord;
 					this.Discord.UserCache.AddOrUpdate(ev.Creator.Id, ev.Creator, (id, old) =>
 					{
 						old.Username = ev.Creator.Username;
 						old.Discriminator = ev.Creator.Discriminator;
 						old.AvatarHash = ev.Creator.AvatarHash;
 						old.Flags = ev.Creator.Flags;
 						return old;
 					});
 				}
 
 				events.Add(ev.Id, ev);
 			}
 
 			return new ReadOnlyDictionary<ulong, DiscordScheduledEvent>(new Dictionary<ulong, DiscordScheduledEvent>(events));
 		}
 
 		/// <summary>
 		/// Deletes a guild sheduled event.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="scheduledEventId">The sheduled event id.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task DeleteGuildScheduledEventAsync(ulong guildId, ulong scheduledEventId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Gets the users who RSVP'd to a sheduled event.
 		/// Optional with member objects.
 		/// This endpoint is paginated.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="scheduledEventId">The sheduled event id.</param>
 		/// <param name="limit">The limit how many users to receive from the event.</param>
 		/// <param name="before">Get results before the given id.</param>
 		/// <param name="after">Get results after the given id.</param>
 		/// <param name="withMember">Wether to include guild member data. attaches guild_member property to the user object.</param>
 		internal async Task<IReadOnlyDictionary<ulong, DiscordScheduledEventUser>> GetGuildScheduledEventRspvUsersAsync(ulong guildId, ulong scheduledEventId, int? limit, ulong? before, ulong? after, bool? withMember)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (limit != null && limit > 0)
 				urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 			if (before != null)
 				urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 			if (after != null)
 				urlparams["after"] = after.Value.ToString(CultureInfo.InvariantCulture);
 			if (withMember != null)
 				urlparams["with_member"] = withMember.Value.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id{Endpoints.USERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var rspvUsers = JsonConvert.DeserializeObject<IEnumerable<DiscordScheduledEventUser>>(res.Response);
 			Dictionary<ulong, DiscordScheduledEventUser> rspv = new();
 
 			foreach (var rspvUser in rspvUsers)
 			{
 
 				rspvUser.Discord = this.Discord;
 				rspvUser.GuildId = guildId;
 
 				rspvUser.User.Discord = this.Discord;
 				rspvUser.User = this.Discord.UserCache.AddOrUpdate(rspvUser.User.Id, rspvUser.User, (id, old) =>
 				{
 					old.Username = rspvUser.User.Username;
 					old.Discriminator = rspvUser.User.Discriminator;
 					old.AvatarHash = rspvUser.User.AvatarHash;
 					old.BannerHash = rspvUser.User.BannerHash;
 					old.BannerColorInternal = rspvUser.User.BannerColorInternal;
 					return old;
 				});
 
 				/*if (with_member.HasValue && with_member.Value && rspv_user.Member != null)
                 {
                     rspv_user.Member.Discord = this.Discord;
                 }*/
 
 				rspv.Add(rspvUser.User.Id, rspvUser);
 			}
 
 			return new ReadOnlyDictionary<ulong, DiscordScheduledEventUser>(new Dictionary<ulong, DiscordScheduledEventUser>(rspv));
 		}
 		#endregion
 
 		#region Channel
 		/// <summary>
 		/// Creates the guild channel async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="parent">The parent.</param>
 		/// <param name="topic">The topic.</param>
 		/// <param name="bitrate">The bitrate.</param>
 		/// <param name="userLimit">The user_limit.</param>
 		/// <param name="overwrites">The overwrites.</param>
 		/// <param name="nsfw">If true, nsfw.</param>
 		/// <param name="perUserRateLimit">The per user rate limit.</param>
 		/// <param name="qualityMode">The quality mode.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordChannel> CreateGuildChannelAsync(ulong guildId, string name, ChannelType type, ulong? parent, Optional<string> topic, int? bitrate, int? userLimit, IEnumerable<DiscordOverwriteBuilder> overwrites, bool? nsfw, Optional<int?> perUserRateLimit, VideoQualityMode? qualityMode, string reason)
 		{
 			var restoverwrites = new List<DiscordRestOverwrite>();
 			if (overwrites != null)
 				foreach (var ow in overwrites)
 					restoverwrites.Add(ow.Build());
 
 			var pld = new RestChannelCreatePayload
 			{
 				Name = name,
 				Type = type,
 				Parent = parent,
 				Topic = topic,
 				Bitrate = bitrate,
 				UserLimit = userLimit,
 				PermissionOverwrites = restoverwrites,
 				Nsfw = nsfw,
 				PerUserRateLimit = perUserRateLimit,
 				QualityMode = qualityMode
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
 			ret.Discord = this.Discord;
 			foreach (var xo in ret.PermissionOverwritesInternal)
 			{
 				xo.Discord = this.Discord;
 				xo.ChannelId = ret.Id;
 			}
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the channel async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="position">The position.</param>
 		/// <param name="topic">The topic.</param>
 		/// <param name="nsfw">If true, nsfw.</param>
 		/// <param name="parent">The parent.</param>
 		/// <param name="bitrate">The bitrate.</param>
 		/// <param name="userLimit">The user_limit.</param>
 		/// <param name="perUserRateLimit">The per user rate limit.</param>
 		/// <param name="rtcRegion">The rtc region.</param>
 		/// <param name="qualityMode">The quality mode.</param>
 		/// <param name="autoArchiveDuration">The default auto archive duration.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="permissionOverwrites">The permission overwrites.</param>
 		/// <param name="bannerb64">The banner.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task ModifyChannelAsync(ulong channelId, string name, int? position, Optional<string> topic, bool? nsfw, Optional<ulong?> parent, int? bitrate, int? userLimit, Optional<int?> perUserRateLimit, Optional<string> rtcRegion, VideoQualityMode? qualityMode, ThreadAutoArchiveDuration? autoArchiveDuration, Optional<ChannelType> type, IEnumerable<DiscordOverwriteBuilder> permissionOverwrites, Optional<string> bannerb64, string reason)
 		{
 
 			List<DiscordRestOverwrite> restoverwrites = null;
 			if (permissionOverwrites != null)
 			{
 				restoverwrites = new List<DiscordRestOverwrite>();
 				foreach (var ow in permissionOverwrites)
 					restoverwrites.Add(ow.Build());
 			}
 
 			var pld = new RestChannelModifyPayload
 			{
 				Name = name,
 				Position = position,
 				Topic = topic,
 				Nsfw = nsfw,
 				Parent = parent,
 				Bitrate = bitrate,
 				UserLimit = userLimit,
 				PerUserRateLimit = perUserRateLimit,
 				RtcRegion = rtcRegion,
 				QualityMode = qualityMode,
 				DefaultAutoArchiveDuration = autoArchiveDuration,
 				Type = type,
 				PermissionOverwrites = restoverwrites,
 				BannerBase64 = bannerb64
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Gets the channel async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordChannel> GetChannelAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
 			ret.Discord = this.Discord;
 			foreach (var xo in ret.PermissionOverwritesInternal)
 			{
 				xo.Discord = this.Discord;
 				xo.ChannelId = ret.Id;
 			}
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the channel async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteChannelAsync(ulong channelId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Gets the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> GetMessageAsync(ulong channelId, ulong messageId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Creates the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="content">The content.</param>
 		/// <param name="embeds">The embeds.</param>
 		/// <param name="sticker">The sticker.</param>
 		/// <param name="replyMessageId">The reply message id.</param>
 		/// <param name="mentionReply">If true, mention reply.</param>
 		/// <param name="failOnInvalidReply">If true, fail on invalid reply.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> CreateMessageAsync(ulong channelId, string content, IEnumerable<DiscordEmbed> embeds, DiscordSticker sticker, ulong? replyMessageId, bool mentionReply, bool failOnInvalidReply)
 		{
 			if (content != null && content.Length > 2000)
 				throw new ArgumentException("Message content length cannot exceed 2000 characters.");
 
 			if (!embeds?.Any() ?? true)
 			{
 				if (content == null && sticker == null)
 					throw new ArgumentException("You must specify message content, a sticker or an embed.");
 				if (content.Length == 0)
 					throw new ArgumentException("Message content must not be empty.");
 			}
 
 			if (embeds != null)
 				foreach (var embed in embeds)
 					if (embed.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			var pld = new RestChannelMessageCreatePayload
 			{
 				HasContent = content != null,
 				Content = content,
 				StickersIds = sticker is null ? Array.Empty<ulong>() : new[] {sticker.Id},
 				IsTts = false,
 				HasEmbed = embeds?.Any() ?? false,
 				Embeds = embeds
 			};
 
 			if (replyMessageId != null)
 				pld.MessageReference = new InternalDiscordMessageReference { MessageId = replyMessageId, FailIfNotExists = failOnInvalidReply };
 
 			if (replyMessageId != null)
 				pld.Mentions = new DiscordMentions(Mentions.All, true, mentionReply);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Creates the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="builder">The builder.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> CreateMessageAsync(ulong channelId, DiscordMessageBuilder builder)
 		{
 			builder.Validate();
 
 			if (builder.Embeds != null)
 				foreach (var embed in builder.Embeds)
 					if (embed?.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			var pld = new RestChannelMessageCreatePayload
 			{
 				HasContent = builder.Content != null,
 				Content = builder.Content,
 				StickersIds = builder.Sticker is null ? Array.Empty<ulong>() : new[] {builder.Sticker.Id},
 				IsTts = builder.IsTts,
 				HasEmbed = builder.Embeds != null,
 				Embeds = builder.Embeds,
 				Components = builder.Components
 			};
 
 			if (builder.ReplyId != null)
 				pld.MessageReference = new InternalDiscordMessageReference { MessageId = builder.ReplyId, FailIfNotExists = builder.FailOnInvalidReply };
 
 			pld.Mentions = new DiscordMentions(builder.Mentions ?? Mentions.All, builder.Mentions?.Any() ?? false, builder.MentionOnReply);
 
 			if (builder.Files.Count == 0)
 			{
 				var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 				var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 				var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 				var ret = this.PrepareMessage(JObject.Parse(res.Response));
 				return ret;
 			}
 			else
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachments = new(builder.Files.Count);
 				foreach (var file in builder.Files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName
 					};
 					attachments.Add(att);
 					fileId++;
 				}
 				pld.Attachments = attachments;
 
 				var values = new Dictionary<string, string>
 				{
 					["payload_json"] = DiscordJson.SerializeObject(pld)
 				};
 
 				var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 				var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 				var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 
 				var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 				foreach (var file in builder.FilesInternal.Where(x => x.ResetPositionTo.HasValue))
 				{
 					file.Stream.Position = file.ResetPositionTo.Value;
 				}
 
 				return ret;
 			}
 		}
 
 		/// <summary>
 		/// Gets the guild channels async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordChannel>> GetGuildChannelsAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var channelsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordChannel>>(res.Response).Select(xc => { xc.Discord = this.Discord; return xc; });
 
 			foreach (var ret in channelsRaw)
 				foreach (var xo in ret.PermissionOverwritesInternal)
 				{
 					xo.Discord = this.Discord;
 					xo.ChannelId = ret.Id;
 				}
 
 			return new ReadOnlyCollection<DiscordChannel>(new List<DiscordChannel>(channelsRaw));
 		}
 
 		/// <summary>
 		/// Creates the stage instance async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="topic">The topic.</param>
 		/// <param name="sendStartNotification">Whether everyone should be notified about the stage.</param>
 		/// <param name="privacyLevel">The privacy_level.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordStageInstance> CreateStageInstanceAsync(ulong channelId, string topic, bool sendStartNotification, StagePrivacyLevel privacyLevel, string reason)
 		{
 			var pld = new RestStageInstanceCreatePayload
 			{
 				ChannelId = channelId,
 				Topic = topic,
 				PrivacyLevel = privacyLevel,
 				SendStartNotification = sendStartNotification
 			};
 
 			var route = $"{Endpoints.STAGE_INSTANCES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var stageInstance = JsonConvert.DeserializeObject<DiscordStageInstance>(res.Response);
 
 			return stageInstance;
 		}
 
 		/// <summary>
 		/// Gets the stage instance async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		internal async Task<DiscordStageInstance> GetStageInstanceAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var stageInstance = JsonConvert.DeserializeObject<DiscordStageInstance>(res.Response);
 
 			return stageInstance;
 		}
 
 		/// <summary>
 		/// Modifies the stage instance async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="topic">The topic.</param>
 		/// <param name="privacyLevel">The privacy_level.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task ModifyStageInstanceAsync(ulong channelId, Optional<string> topic, Optional<StagePrivacyLevel> privacyLevel, string reason)
 		{
 			var pld = new RestStageInstanceModifyPayload
 			{
 				Topic = topic,
 				PrivacyLevel = privacyLevel
 			};
 
 			var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId }, out var path);
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Deletes the stage instance async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task DeleteStageInstanceAsync(ulong channelId, string reason)
 		{
 			var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId }, out var path);
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Gets the channel messages async.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="limit">The limit.</param>
 		/// <param name="before">The before.</param>
 		/// <param name="after">The after.</param>
 		/// <param name="around">The around.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordMessage>> GetChannelMessagesAsync(ulong channelId, int limit, ulong? before, ulong? after, ulong? around)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (around != null)
 				urlparams["around"] = around?.ToString(CultureInfo.InvariantCulture);
 			if (before != null)
 				urlparams["before"] = before?.ToString(CultureInfo.InvariantCulture);
 			if (after != null)
 				urlparams["after"] = after?.ToString(CultureInfo.InvariantCulture);
 			if (limit > 0)
 				urlparams["limit"] = limit.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var msgsRaw = JArray.Parse(res.Response);
 			var msgs = new List<DiscordMessage>();
 			foreach (var xj in msgsRaw)
 				msgs.Add(this.PrepareMessage(xj));
 
 			return new ReadOnlyCollection<DiscordMessage>(new List<DiscordMessage>(msgs));
 		}
 
 		/// <summary>
 		/// Gets the channel message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> GetChannelMessageAsync(ulong channelId, ulong messageId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Edits the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="content">The content.</param>
 		/// <param name="embeds">The embeds.</param>
 		/// <param name="mentions">The mentions.</param>
 		/// <param name="components">The components.</param>
 		/// <param name="suppressEmbed">The suppress_embed.</param>
 		/// <param name="files">The files.</param>
 		/// <param name="attachments">The attachments to keep.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> EditMessageAsync(ulong channelId, ulong messageId, Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds, IEnumerable<IMention> mentions, IReadOnlyList<DiscordActionRowComponent> components, Optional<bool> suppressEmbed, IReadOnlyCollection<DiscordMessageFile> files, Optional<IEnumerable<DiscordAttachment>> attachments)
 		{
 			if (embeds.HasValue && embeds.Value != null)
 				foreach (var embed in embeds.Value)
 					if (embed.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			var pld = new RestChannelMessageEditPayload
 			{
 				HasContent = content.HasValue,
 				Content = content.HasValue ? (string)content : null,
 				HasEmbed = embeds.HasValue && (embeds.Value?.Any() ?? false),
 				Embeds = embeds.HasValue && (embeds.Value?.Any() ?? false) ? embeds.Value : null,
 				Components = components ?? null,
 				Flags = suppressEmbed.HasValue ? (bool)suppressEmbed ? MessageFlags.SuppressedEmbeds : null : null
 			};
 
 			pld.Mentions = new DiscordMentions(mentions ?? Mentions.None, false, mentions?.OfType<RepliedUserMention>().Any() ?? false);
 
 			if (files?.Count > 0)
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachmentsNew = new();
 				foreach (var file in files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName
 					};
 					attachmentsNew.Add(att);
 					fileId++;
 				}
 				if (attachments.HasValue && attachments.Value.Any())
 					attachmentsNew.AddRange(attachments.Value);
 
 				pld.Attachments = attachmentsNew;
 
 				var values = new Dictionary<string, string>
 				{
 					["payload_json"] = DiscordJson.SerializeObject(pld)
 				};
 
 				var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 				var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 				var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: files).ConfigureAwait(false);
 
 				var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 				foreach (var file in files.Where(x => x.ResetPositionTo.HasValue))
 				{
 					file.Stream.Position = file.ResetPositionTo.Value;
 				}
 
 				return ret;
 			}
 			else
 			{
 				pld.Attachments = attachments.HasValue ? attachments.Value : null;
 
 				var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 				var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 				var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 				var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 				return ret;
 			}
 		}
 
 		/// <summary>
 		/// Deletes the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteMessageAsync(ulong channelId, ulong messageId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Deletes the messages async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageIds">The message_ids.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteMessagesAsync(ulong channelId, IEnumerable<ulong> messageIds, string reason)
 		{
 			var pld = new RestChannelMessageBulkDeletePayload
 			{
 				Messages = messageIds
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}{Endpoints.BULK_DELETE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Gets the channel invites async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordInvite>> GetChannelInvitesAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.INVITES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var invitesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordInvite>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 			return new ReadOnlyCollection<DiscordInvite>(new List<DiscordInvite>(invitesRaw));
 		}
 
 		/// <summary>
 		/// Creates the channel invite async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="maxAge">The max_age.</param>
 		/// <param name="maxUses">The max_uses.</param>
 		/// <param name="targetType">The target_type.</param>
 		/// <param name="targetApplication">The target_application.</param>
 		/// <param name="targetUser">The target_user.</param>
 		/// <param name="temporary">If true, temporary.</param>
 		/// <param name="unique">If true, unique.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordInvite> CreateChannelInviteAsync(ulong channelId, int maxAge, int maxUses, TargetType? targetType, TargetActivity? targetApplication, ulong? targetUser, bool temporary, bool unique, string reason)
 		{
 			var pld = new RestChannelInviteCreatePayload
 			{
 				MaxAge = maxAge,
 				MaxUses = maxUses,
 				TargetType = targetType,
 				TargetApplication = targetApplication,
 				TargetUserId = targetUser,
 				Temporary = temporary,
 				Unique = unique
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.INVITES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the channel permission async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="overwriteId">The overwrite_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteChannelPermissionAsync(ulong channelId, ulong overwriteId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PERMISSIONS}/:overwrite_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, overwrite_id = overwriteId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Edits the channel permissions async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="overwriteId">The overwrite_id.</param>
 		/// <param name="allow">The allow.</param>
 		/// <param name="deny">The deny.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task EditChannelPermissionsAsync(ulong channelId, ulong overwriteId, Permissions allow, Permissions deny, string type, string reason)
 		{
 			var pld = new RestChannelPermissionEditPayload
 			{
 				Type = type,
 				Allow = allow & PermissionMethods.FullPerms,
 				Deny = deny & PermissionMethods.FullPerms
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PERMISSIONS}/:overwrite_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, overwrite_id = overwriteId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Triggers the typing async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task TriggerTypingAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.TYPING}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route);
 		}
 
 		/// <summary>
 		/// Gets the pinned messages async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var msgsRaw = JArray.Parse(res.Response);
 			var msgs = new List<DiscordMessage>();
 			foreach (var xj in msgsRaw)
 				msgs.Add(this.PrepareMessage(xj));
 
 			return new ReadOnlyCollection<DiscordMessage>(new List<DiscordMessage>(msgs));
 		}
 
 		/// <summary>
 		/// Pins the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task PinMessageAsync(ulong channelId, ulong messageId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
 		}
 
 		/// <summary>
 		/// Unpins the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task UnpinMessageAsync(ulong channelId, ulong messageId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Adds the group dm recipient async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="accessToken">The access_token.</param>
 		/// <param name="nickname">The nickname.</param>
 		/// <returns>A Task.</returns>
 		internal Task AddGroupDmRecipientAsync(ulong channelId, ulong userId, string accessToken, string nickname)
 		{
 			var pld = new RestChannelGroupDmRecipientAddPayload
 			{
 				AccessToken = accessToken,
 				Nickname = nickname
 			};
 
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}/:channel_id{Endpoints.RECIPIENTS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Removes the group dm recipient async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task RemoveGroupDmRecipientAsync(ulong channelId, ulong userId)
 		{
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}/:channel_id{Endpoints.RECIPIENTS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Creates the group dm async.
 		/// </summary>
 		/// <param name="accessTokens">The access_tokens.</param>
 		/// <param name="nicks">The nicks.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordDmChannel> CreateGroupDmAsync(IEnumerable<string> accessTokens, IDictionary<ulong, string> nicks)
 		{
 			var pld = new RestUserGroupDmCreatePayload
 			{
 				AccessTokens = accessTokens,
 				Nicknames = nicks
 			};
 
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordDmChannel>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Creates the dm async.
 		/// </summary>
 		/// <param name="recipientId">The recipient_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordDmChannel> CreateDmAsync(ulong recipientId)
 		{
 			var pld = new RestUserDmCreatePayload
 			{
 				Recipient = recipientId
 			};
 
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordDmChannel>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Follows the channel async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="webhookChannelId">The webhook_channel_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordFollowedChannel> FollowChannelAsync(ulong channelId, ulong webhookChannelId)
 		{
 			var pld = new FollowedChannelAddPayload
 			{
 				WebhookChannelId = webhookChannelId
 			};
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.FOLLOWERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var response = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			return JsonConvert.DeserializeObject<DiscordFollowedChannel>(response.Response);
 		}
 
 		/// <summary>
 		/// Crossposts the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> CrosspostMessageAsync(ulong channelId, ulong messageId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.CROSSPOST}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var response = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route).ConfigureAwait(false);
 			return JsonConvert.DeserializeObject<DiscordMessage>(response.Response);
 		}
 
 		#endregion
 
 		#region Member
 		/// <summary>
 		/// Gets the current user async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal Task<DiscordUser> GetCurrentUserAsync()
 			=> this.GetUserAsync("@me");
 
 		/// <summary>
 		/// Gets the user async.
 		/// </summary>
 		/// <param name="userId">The user_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task<DiscordUser> GetUserAsync(ulong userId)
 			=> this.GetUserAsync(userId.ToString(CultureInfo.InvariantCulture));
 
 		/// <summary>
 		/// Gets the user async.
 		/// </summary>
 		/// <param name="userId">The user_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordUser> GetUserAsync(string userId)
 		{
 			var route = $"{Endpoints.USERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var userRaw = JsonConvert.DeserializeObject<TransportUser>(res.Response);
 			var duser = new DiscordUser(userRaw) { Discord = this.Discord };
 
 			return duser;
 		}
 
 		/// <summary>
 		/// Gets the guild member async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMember> GetGuildMemberAsync(ulong guildId, ulong userId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var tm = JsonConvert.DeserializeObject<TransportMember>(res.Response);
 
 			var usr = new DiscordUser(tm.User) { Discord = this.Discord };
 			usr = this.Discord.UserCache.AddOrUpdate(tm.User.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				return old;
 			});
 
 			return new DiscordMember(tm)
 			{
 				Discord = this.Discord,
 				GuildId = guildId
 			};
 		}
 
 		/// <summary>
 		/// Removes the guild member async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task RemoveGuildMemberAsync(ulong guildId, ulong userId, string reason)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (reason != null)
 				urlparams["reason"] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, BuildQueryString(urlparams), this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Modifies the current user async.
 		/// </summary>
 		/// <param name="username">The username.</param>
 		/// <param name="base64Avatar">The base64_avatar.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<TransportUser> ModifyCurrentUserAsync(string username, Optional<string> base64Avatar)
 		{
 			var pld = new RestUserUpdateCurrentPayload
 			{
 				Username = username,
 				AvatarBase64 = base64Avatar.HasValue ? base64Avatar.Value : null,
 				AvatarSet = base64Avatar.HasValue
 			};
 
 			var route = $"{Endpoints.USERS}{Endpoints.ME}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var userRaw = JsonConvert.DeserializeObject<TransportUser>(res.Response);
 
 			return userRaw;
 		}
 
 		/// <summary>
 		/// Gets the current user guilds async.
 		/// </summary>
 		/// <param name="limit">The limit.</param>
 		/// <param name="before">The before.</param>
 		/// <param name="after">The after.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordGuild>> GetCurrentUserGuildsAsync(int limit = 100, ulong? before = null, ulong? after = null)
 		{
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.GUILDS}";
 
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration)
 				.AddParameter($"limit", limit.ToString(CultureInfo.InvariantCulture));
 
 			if (before != null)
 				url.AddParameter("before", before.Value.ToString(CultureInfo.InvariantCulture));
 			if (after != null)
 				url.AddParameter("after", after.Value.ToString(CultureInfo.InvariantCulture));
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url.Build(), RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			if (this.Discord is DiscordClient)
 			{
 				var guildsRaw = JsonConvert.DeserializeObject<IEnumerable<RestUserGuild>>(res.Response);
 				var glds = guildsRaw.Select(xug => (this.Discord as DiscordClient)?.GuildsInternal[xug.Id]);
 				return new ReadOnlyCollection<DiscordGuild>(new List<DiscordGuild>(glds));
 			}
 			else
 			{
 				return new ReadOnlyCollection<DiscordGuild>(JsonConvert.DeserializeObject<List<DiscordGuild>>(res.Response));
 			}
 		}
 
 		/// <summary>
 		/// Modifies the guild member async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="nick">The nick.</param>
 		/// <param name="roleIds">The role_ids.</param>
 		/// <param name="mute">The mute.</param>
 		/// <param name="deaf">The deaf.</param>
 		/// <param name="voiceChannelId">The voice_channel_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task ModifyGuildMemberAsync(ulong guildId, ulong userId, Optional<string> nick,
 			Optional<IEnumerable<ulong>> roleIds, Optional<bool> mute, Optional<bool> deaf,
 			Optional<ulong?> voiceChannelId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var pld = new RestGuildMemberModifyPayload
 			{
 				Nickname = nick,
 				RoleIds = roleIds,
 				Deafen = deaf,
 				Mute = mute,
 				VoiceChannelId = voiceChannelId
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Modifies the time out of a guild member.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="until">Datetime offset.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task ModifyTimeoutAsync(ulong guildId, ulong userId, DateTimeOffset? until, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var pld = new RestGuildMemberTimeoutModifyPayload
 			{
 				CommunicationDisabledUntil = until
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Modifies the current member nickname async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="nick">The nick.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task ModifyCurrentMemberNicknameAsync(ulong guildId, string nick, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var pld = new RestGuildMemberModifyPayload
 			{
 				Nickname = nick
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}{Endpoints.ME}{Endpoints.NICK}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 		}
 		#endregion
 
 		#region Roles
 		/// <summary>
 		/// Gets the guild roles async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordRole>> GetGuildRolesAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var rolesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordRole>>(res.Response).Select(xr => { xr.Discord = this.Discord; xr.GuildId = guildId; return xr; });
 
 			return new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(rolesRaw));
 		}
 
 		/// <summary>
 		/// Gets the guild async.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="withCounts">If true, with_counts.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuild> GetGuildAsync(ulong guildId, bool? withCounts)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (withCounts.HasValue)
 				urlparams["with_counts"] = withCounts?.ToString();
 
 			var route = $"{Endpoints.GUILDS}/:guild_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route, urlparams).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawMembers = (JArray)json["members"];
 			var guildRest = json.ToDiscordObject<DiscordGuild>();
 			foreach (var r in guildRest.RolesInternal.Values)
 				r.GuildId = guildRest.Id;
 
 			if (this.Discord is DiscordClient dc)
 			{
 				await dc.OnGuildUpdateEventAsync(guildRest, rawMembers).ConfigureAwait(false);
 				return dc.GuildsInternal[guildRest.Id];
 			}
 			else
 			{
 				guildRest.Discord = this.Discord;
 				return guildRest;
 			}
 		}
 
 		/// <summary>
 		/// Modifies the guild role async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="roleId">The role_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="permissions">The permissions.</param>
 		/// <param name="color">The color.</param>
 		/// <param name="hoist">If true, hoist.</param>
 		/// <param name="mentionable">If true, mentionable.</param>
 		/// <param name="iconb64">The icon.</param>
 		/// <param name="emoji">The unicode emoji icon.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordRole> ModifyGuildRoleAsync(ulong guildId, ulong roleId, string name, Permissions? permissions, int? color, bool? hoist, bool? mentionable, Optional<string> iconb64, Optional<string> emoji, string reason)
 		{
 			var pld = new RestGuildRolePayload
 			{
 				Name = name,
 				Permissions = permissions & PermissionMethods.FullPerms,
 				Color = color,
 				Hoist = hoist,
 				Mentionable = mentionable,
 			};
 
 			if (emoji.HasValue && !iconb64.HasValue)
 				pld.UnicodeEmoji = emoji;
 
 			if (emoji.HasValue && iconb64.HasValue)
 			{
 				pld.IconBase64 = null;
 				pld.UnicodeEmoji = emoji;
 			}
 
 			if (iconb64.HasValue)
 				pld.IconBase64 = iconb64;
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}/:role_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, role_id = roleId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordRole>(res.Response);
 			ret.Discord = this.Discord;
 			ret.GuildId = guildId;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the role async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="roleId">The role_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteRoleAsync(ulong guildId, ulong roleId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}/:role_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, role_id = roleId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Creates the guild role async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="permissions">The permissions.</param>
 		/// <param name="color">The color.</param>
 		/// <param name="hoist">If true, hoist.</param>
 		/// <param name="mentionable">If true, mentionable.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordRole> CreateGuildRoleAsync(ulong guildId, string name, Permissions? permissions, int? color, bool? hoist, bool? mentionable, string reason)
 		{
 			var pld = new RestGuildRolePayload
 			{
 				Name = name,
 				Permissions = permissions & PermissionMethods.FullPerms,
 				Color = color,
 				Hoist = hoist,
 				Mentionable = mentionable
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordRole>(res.Response);
 			ret.Discord = this.Discord;
 			ret.GuildId = guildId;
 
 			return ret;
 		}
 		#endregion
 
 		#region Prune
 		/// <summary>
 		/// Gets the guild prune count async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="days">The days.</param>
 		/// <param name="includeRoles">The include_roles.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<int> GetGuildPruneCountAsync(ulong guildId, int days, IEnumerable<ulong> includeRoles)
 		{
 			if (days < 0 || days > 30)
 				throw new ArgumentException("Prune inactivity days must be a number between 0 and 30.", nameof(days));
 
 			var urlparams = new Dictionary<string, string>
 			{
 				["days"] = days.ToString(CultureInfo.InvariantCulture)
 			};
 
 			var sb = new StringBuilder();
 
 			if (includeRoles != null)
 			{
 				var roleArray = includeRoles.ToArray();
 				var roleArrayCount = roleArray.Count();
 
 				for (var i = 0; i < roleArrayCount; i++)
 					sb.Append($"&include_roles={roleArray[i]}");
 			}
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PRUNE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 			var url = Utilities.GetApiUriFor(path, $"{BuildQueryString(urlparams)}{sb}", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var pruned = JsonConvert.DeserializeObject<RestGuildPruneResultPayload>(res.Response);
 
 			return pruned.Pruned.Value;
 		}
 
 		/// <summary>
 		/// Begins the guild prune async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="days">The days.</param>
 		/// <param name="computePruneCount">If true, compute_prune_count.</param>
 		/// <param name="includeRoles">The include_roles.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<int?> BeginGuildPruneAsync(ulong guildId, int days, bool computePruneCount, IEnumerable<ulong> includeRoles, string reason)
 		{
 			if (days < 0 || days > 30)
 				throw new ArgumentException("Prune inactivity days must be a number between 0 and 30.", nameof(days));
 
 			var urlparams = new Dictionary<string, string>
 			{
 				["days"] = days.ToString(CultureInfo.InvariantCulture),
 				["compute_prune_count"] = computePruneCount.ToString()
 			};
 
 			var sb = new StringBuilder();
 
 			if (includeRoles != null)
 			{
 				var roleArray = includeRoles.ToArray();
 				var roleArrayCount = roleArray.Count();
 
 				for (var i = 0; i < roleArrayCount; i++)
 					sb.Append($"&include_roles={roleArray[i]}");
 			}
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PRUNE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, $"{BuildQueryString(urlparams)}{sb}", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers).ConfigureAwait(false);
 
 			var pruned = JsonConvert.DeserializeObject<RestGuildPruneResultPayload>(res.Response);
 
 			return pruned.Pruned;
 		}
 		#endregion
 
 		#region GuildVarious
 		/// <summary>
 		/// Gets the template async.
 		/// </summary>
 		/// <param name="code">The code.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildTemplate> GetTemplateAsync(string code)
 		{
 			var route = $"{Endpoints.GUILDS}{Endpoints.TEMPLATES}/:code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { code }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var templatesRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 			return templatesRaw;
 		}
 
 		/// <summary>
 		/// Gets the guild integrations async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordIntegration>> GetGuildIntegrationsAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var integrationsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordIntegration>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 			return new ReadOnlyCollection<DiscordIntegration>(new List<DiscordIntegration>(integrationsRaw));
 		}
 
 		/// <summary>
 		/// Gets the guild preview async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PREVIEW}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildPreview>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Creates the guild integration async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="id">The id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordIntegration> CreateGuildIntegrationAsync(ulong guildId, string type, ulong id)
 		{
 			var pld = new RestGuildIntegrationAttachPayload
 			{
 				Type = type,
 				Id = id
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordIntegration>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the guild integration async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="integrationId">The integration_id.</param>
 		/// <param name="expireBehaviour">The expire_behaviour.</param>
 		/// <param name="expireGracePeriod">The expire_grace_period.</param>
 		/// <param name="enableEmoticons">If true, enable_emoticons.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordIntegration> ModifyGuildIntegrationAsync(ulong guildId, ulong integrationId, int expireBehaviour, int expireGracePeriod, bool enableEmoticons)
 		{
 			var pld = new RestGuildIntegrationModifyPayload
 			{
 				ExpireBehavior = expireBehaviour,
 				ExpireGracePeriod = expireGracePeriod,
 				EnableEmoticons = enableEmoticons
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, integration_id = integrationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordIntegration>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the guild integration async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="integration">The integration.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteGuildIntegrationAsync(ulong guildId, DiscordIntegration integration)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, integration_id = integration.Id }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, payload: DiscordJson.SerializeObject(integration));
 		}
 
 		/// <summary>
 		/// Syncs the guild integration async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="integrationId">The integration_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task SyncGuildIntegrationAsync(ulong guildId, ulong integrationId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id{Endpoints.SYNC}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId, integration_id = integrationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route);
 		}
 
 		/// <summary>
 		/// Gets the guild voice regions async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordVoiceRegion>> GetGuildVoiceRegionsAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.REGIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var regionsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordVoiceRegion>>(res.Response);
 
 			return new ReadOnlyCollection<DiscordVoiceRegion>(new List<DiscordVoiceRegion>(regionsRaw));
 		}
 
 		/// <summary>
 		/// Gets the guild invites async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordInvite>> GetGuildInvitesAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INVITES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var invitesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordInvite>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 			return new ReadOnlyCollection<DiscordInvite>(new List<DiscordInvite>(invitesRaw));
 		}
 		#endregion
 
 		#region Invite
 		/// <summary>
 		/// Gets the invite async.
 		/// </summary>
 		/// <param name="inviteCode">The invite_code.</param>
 		/// <param name="withCounts">If true, with_counts.</param>
 		/// <param name="withExpiration">If true, with_expiration.</param>
 		/// <param name="guildScheduledEventId">The scheduled event id to get.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordInvite> GetInviteAsync(string inviteCode, bool? withCounts, bool? withExpiration, ulong? guildScheduledEventId)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (withCounts.HasValue)
 				urlparams["with_counts"] = withCounts?.ToString();
 			if (withExpiration.HasValue)
 				urlparams["with_expiration"] = withExpiration?.ToString();
 			if (guildScheduledEventId.HasValue)
 				urlparams["guild_scheduled_event_id"] = guildScheduledEventId?.ToString();
 
 			var route = $"{Endpoints.INVITES}/:invite_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {invite_code = inviteCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the invite async.
 		/// </summary>
 		/// <param name="inviteCode">The invite_code.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordInvite> DeleteInviteAsync(string inviteCode, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.INVITES}/:invite_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {invite_code = inviteCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/*
          * Disabled due to API restrictions
          *
          * internal async Task<DiscordInvite> InternalAcceptInvite(string invite_code)
          * {
          *     this.Discord.DebugLogger.LogMessage(LogLevel.Warning, "REST API", "Invite accept endpoint was used; this account is now likely unverified", DateTime.Now);
          *
          *     var url = new Uri($"{Utils.GetApiBaseUri(this.Configuration), Endpoints.INVITES}/{invite_code));
          *     var bucket = this.Rest.GetBucket(0, MajorParameterType.Unbucketed, url, HttpRequestMethod.POST);
          *     var res = await this.DoRequestAsync(this.Discord, bucket, url, HttpRequestMethod.POST).ConfigureAwait(false);
          *
          *     var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
          *     ret.Discord = this.Discord;
          *
          *     return ret;
          * }
          */
 		#endregion
 
 		#region Connections
 		/// <summary>
 		/// Gets the users connections async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordConnection>> GetUsersConnectionsAsync()
 		{
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CONNECTIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var connectionsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordConnection>>(res.Response).Select(xc => { xc.Discord = this.Discord; return xc; });
 
 			return new ReadOnlyCollection<DiscordConnection>(new List<DiscordConnection>(connectionsRaw));
 		}
 		#endregion
 
 		#region Voice
 		/// <summary>
 		/// Lists the voice regions async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
 		{
 			var route = $"{Endpoints.VOICE}{Endpoints.REGIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var regions = JsonConvert.DeserializeObject<IEnumerable<DiscordVoiceRegion>>(res.Response);
 
 			return new ReadOnlyCollection<DiscordVoiceRegion>(new List<DiscordVoiceRegion>(regions));
 		}
 		#endregion
 
 		#region Webhooks
 		/// <summary>
 		/// Creates the webhook async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="base64Avatar">The base64_avatar.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordWebhook> CreateWebhookAsync(ulong channelId, string name, Optional<string> base64Avatar, string reason)
 		{
 			var pld = new RestWebhookPayload
 			{
 				Name = name,
 				AvatarBase64 = base64Avatar.HasValue ? base64Avatar.Value : null,
 				AvatarSet = base64Avatar.HasValue
 			};
 
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.WEBHOOKS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 			ret.Discord = this.Discord;
 			ret.ApiClient = this;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the channel webhooks async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordWebhook>> GetChannelWebhooksAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.WEBHOOKS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var webhooksRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordWebhook>>(res.Response).Select(xw => { xw.Discord = this.Discord; xw.ApiClient = this; return xw; });
 
 			return new ReadOnlyCollection<DiscordWebhook>(new List<DiscordWebhook>(webhooksRaw));
 		}
 
 		/// <summary>
 		/// Gets the guild webhooks async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordWebhook>> GetGuildWebhooksAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WEBHOOKS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var webhooksRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordWebhook>>(res.Response).Select(xw => { xw.Discord = this.Discord; xw.ApiClient = this; return xw; });
 
 			return new ReadOnlyCollection<DiscordWebhook>(new List<DiscordWebhook>(webhooksRaw));
 		}
 
 		/// <summary>
 		/// Gets the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordWebhook> GetWebhookAsync(ulong webhookId)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 			ret.Discord = this.Discord;
 			ret.ApiClient = this;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the webhook with token async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong webhookId, string webhookToken)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 			ret.Token = webhookToken;
 			ret.Id = webhookId;
 			ret.Discord = this.Discord;
 			ret.ApiClient = this;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="base64Avatar">The base64_avatar.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordWebhook> ModifyWebhookAsync(ulong webhookId, ulong channelId, string name, Optional<string> base64Avatar, string reason)
 		{
 			var pld = new RestWebhookPayload
 			{
 				Name = name,
 				AvatarBase64 = base64Avatar.HasValue ? base64Avatar.Value : null,
 				AvatarSet = base64Avatar.HasValue,
 				ChannelId = channelId
 			};
 
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 			ret.Discord = this.Discord;
 			ret.ApiClient = this;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="base64Avatar">The base64_avatar.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordWebhook> ModifyWebhookAsync(ulong webhookId, string name, string base64Avatar, string webhookToken, string reason)
 		{
 			var pld = new RestWebhookPayload
 			{
 				Name = name,
 				AvatarBase64 = base64Avatar
 			};
 
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 			ret.Discord = this.Discord;
 			ret.ApiClient = this;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteWebhookAsync(ulong webhookId, string reason)
 		{
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Deletes the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteWebhookAsync(ulong webhookId, string webhookToken, string reason)
 		{
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Executes the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="builder">The builder.</param>
 		/// <param name="threadId">The thread_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> ExecuteWebhookAsync(ulong webhookId, string webhookToken, DiscordWebhookBuilder builder, string threadId)
 		{
 			builder.Validate();
 
 			if (builder.Embeds != null)
 				foreach (var embed in builder.Embeds)
 					if (embed.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			var values = new Dictionary<string, string>();
 			var pld = new RestWebhookExecutePayload
 			{
 				Content = builder.Content,
 				Username = builder.Username.HasValue ? builder.Username.Value : null,
 				AvatarUrl = builder.AvatarUrl.HasValue ? builder.AvatarUrl.Value : null,
 				IsTts = builder.IsTts,
 				Embeds = builder.Embeds,
 				Components = builder.Components
 			};
 
 			if (builder.Mentions != null)
 				pld.Mentions = new DiscordMentions(builder.Mentions, builder.Mentions.Any());
 
 			if (builder.Files?.Count > 0)
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachments = new();
 				foreach (var file in builder.Files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName,
 						FileSize = null
 					};
 					attachments.Add(att);
 					fileId++;
 				}
 				pld.Attachments = attachments;
 			}
 
 			if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count() > 0 || builder.Files?.Count > 0 || builder.IsTts == true || builder.Mentions != null)
 				values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 
 			var url = qub.Build();
 
 			var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 			foreach (var att in ret.Attachments)
 				att.Discord = this.Discord;
 
 			foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 			{
 				file.Stream.Position = file.ResetPositionTo.Value;
 			}
 
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Executes the webhook slack async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="jsonPayload">The json_payload.</param>
 		/// <param name="threadId">The thread_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> ExecuteWebhookSlackAsync(ulong webhookId, string webhookToken, string jsonPayload, string threadId)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.SLACK}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 			var url = qub.Build();
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: jsonPayload).ConfigureAwait(false);
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Executes the webhook github async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="jsonPayload">The json_payload.</param>
 		/// <param name="threadId">The thread_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> ExecuteWebhookGithubAsync(ulong webhookId, string webhookToken, string jsonPayload, string threadId)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.GITHUB}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 			var url = qub.Build();
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: jsonPayload).ConfigureAwait(false);
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Edits the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="builder">The builder.</param>
 		/// <param name="threadId">The thread_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> EditWebhookMessageAsync(ulong webhookId, string webhookToken, string messageId, DiscordWebhookBuilder builder, string threadId)
 		{
 			builder.Validate(true);
 
 			var pld = new RestWebhookMessageEditPayload
 			{
 				Content = builder.Content,
 				Embeds = builder.Embeds,
 				Mentions = builder.Mentions,
 				Components = builder.Components,
 			};
 
 			if (builder.Files?.Count > 0)
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachments = new();
 				foreach (var file in builder.Files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName,
 						FileSize = null
 					};
 					attachments.Add(att);
 					fileId++;
 				}
 				if (builder.Attachments != null && builder.Attachments?.Count() > 0)
 					attachments.AddRange(builder.Attachments);
 
 				pld.Attachments = attachments;
 
 				var values = new Dictionary<string, string>
 				{
 					["payload_json"] = DiscordJson.SerializeObject(pld)
 				};
 				var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 				var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 				if (threadId != null)
 					qub.AddParameter("thread_id", threadId);
 
 				var url = qub.Build();
 				var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: builder.Files);
 
 				var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 				ret.Discord = this.Discord;
 
 				foreach (var att in ret.AttachmentsInternal)
 					att.Discord = this.Discord;
 
 				foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 				{
 					file.Stream.Position = file.ResetPositionTo.Value;
 				}
 
 				return ret;
 			}
 			else
 			{
 				pld.Attachments = builder.Attachments;
 
 				var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 				var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 				if (threadId != null)
 					qub.AddParameter("thread_id", threadId);
 
 				var url = qub.Build();
 				var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 				var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 				ret.Discord = this.Discord;
 
 				foreach (var att in ret.AttachmentsInternal)
 					att.Discord = this.Discord;
 
 				return ret;
 			}
 		}
 
 		/// <summary>
 		/// Edits the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="builder">The builder.</param>
 		/// <param name="threadId">The thread_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task<DiscordMessage> EditWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId, DiscordWebhookBuilder builder, ulong threadId) =>
 			this.EditWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), builder, threadId.ToString());
 
 		/// <summary>
 		/// Gets the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="threadId">The thread_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> GetWebhookMessageAsync(ulong webhookId, string webhookToken, string messageId, string threadId)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 			var url = qub.Build();
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task<DiscordMessage> GetWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId) =>
 			this.GetWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), null);
 
 		/// <summary>
 		/// Gets the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="threadId">The thread_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task<DiscordMessage> GetWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId, ulong threadId) =>
 			this.GetWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), threadId.ToString());
 
 		/// <summary>
 		/// Deletes the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="threadId">The thread_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task DeleteWebhookMessageAsync(ulong webhookId, string webhookToken, string messageId, string threadId)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 			var url = qub.Build();
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Deletes the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId) =>
 			this.DeleteWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), null);
 
 		/// <summary>
 		/// Deletes the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="threadId">The thread_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId, ulong threadId) =>
 			this.DeleteWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), threadId.ToString());
 		#endregion
 
 		#region Reactions
 		/// <summary>
 		/// Creates the reaction async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="emoji">The emoji.</param>
 		/// <returns>A Task.</returns>
 		internal Task CreateReactionAsync(ulong channelId, ulong messageId, string emoji)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji{Endpoints.ME}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 		}
 
 		/// <summary>
 		/// Deletes the own reaction async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="emoji">The emoji.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteOwnReactionAsync(ulong channelId, ulong messageId, string emoji)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji{Endpoints.ME}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 		}
 
 		/// <summary>
 		/// Deletes the user reaction async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="emoji">The emoji.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteUserReactionAsync(ulong channelId, ulong messageId, ulong userId, string emoji, string reason)
 		{
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId, emoji, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 		}
 
 		/// <summary>
 		/// Gets the reactions async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="emoji">The emoji.</param>
 		/// <param name="afterId">The after_id.</param>
 		/// <param name="limit">The limit.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordUser>> GetReactionsAsync(ulong channelId, ulong messageId, string emoji, ulong? afterId = null, int limit = 25)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (afterId.HasValue)
 				urlparams["after"] = afterId.Value.ToString(CultureInfo.InvariantCulture);
 
 			urlparams["limit"] = limit.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, BuildQueryString(urlparams), this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var reactersRaw = JsonConvert.DeserializeObject<IEnumerable<TransportUser>>(res.Response);
 			var reacters = new List<DiscordUser>();
 			foreach (var xr in reactersRaw)
 			{
 				var usr = new DiscordUser(xr) { Discord = this.Discord };
 				usr = this.Discord.UserCache.AddOrUpdate(xr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
 
 				reacters.Add(usr);
 			}
 
 			return new ReadOnlyCollection<DiscordUser>(new List<DiscordUser>(reacters));
 		}
 
 		/// <summary>
 		/// Deletes the all reactions async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteAllReactionsAsync(ulong channelId, ulong messageId, string reason)
 		{
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 		}
 
 		/// <summary>
 		/// Deletes the reactions emoji async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="emoji">The emoji.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteReactionsEmojiAsync(ulong channelId, ulong messageId, string emoji)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 		}
 		#endregion
 
 		#region Threads
 
 		/// <summary>
 		/// Creates the thread with message.
 		/// </summary>
 		/// <param name="channelId">The channel id to create the thread in.</param>
 		/// <param name="messageId">The message id to create the thread from.</param>
 		/// <param name="name">The name of the thread.</param>
 		/// <param name="autoArchiveDuration">The auto_archive_duration for the thread.</param>
 		/// <param name="rateLimitPerUser">The rate limit per user.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordThreadChannel> CreateThreadWithMessageAsync(ulong channelId, ulong messageId, string name, ThreadAutoArchiveDuration autoArchiveDuration, int? rateLimitPerUser, string reason = null)
 		{
 			var pld = new RestThreadChannelCreatePayload
 			{
 				Name = name,
 				AutoArchiveDuration = autoArchiveDuration,
 				PerUserRateLimit = rateLimitPerUser
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.THREADS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
 			var threadChannel = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
 
 			return threadChannel;
 		}
 
 		/// <summary>
 		/// Creates the thread without a message.
 		/// </summary>
 		/// <param name="channelId">The channel id to create the thread in.</param>
 		/// <param name="name">The name of the thread.</param>
 		/// <param name="autoArchiveDuration">The auto_archive_duration for the thread.</param>
 		/// <param name="type">Can be either <see cref="ChannelType.PublicThread"/> or <see cref="ChannelType.PrivateThread"/>.</param>
 		/// <param name="rateLimitPerUser">The rate limit per user.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordThreadChannel> CreateThreadWithoutMessageAsync(ulong channelId, string name, ThreadAutoArchiveDuration autoArchiveDuration, ChannelType type = ChannelType.PublicThread, int? rateLimitPerUser = null, string reason = null)
 		{
 			var pld = new RestThreadChannelCreatePayload
 			{
 				Name = name,
 				AutoArchiveDuration = autoArchiveDuration,
 				PerUserRateLimit = rateLimitPerUser,
 				Type = type
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
 			var threadChannel = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
 
 			return threadChannel;
 		}
 
 		/// <summary>
 		/// Gets the thread.
 		/// </summary>
 		/// <param name="threadId">The thread id.</param>
 		internal async Task<DiscordThreadChannel> GetThreadAsync(ulong threadId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {thread_id = threadId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Joins the thread.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		internal async Task JoinThreadAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}{Endpoints.ME}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
 		}
 
 		/// <summary>
 		/// Leaves the thread.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		internal async Task LeaveThreadAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}{Endpoints.ME}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Adds a thread member.
 		/// </summary>
 		/// <param name="channelId">The channel id to add the member to.</param>
 		/// <param name="userId">The user id to add.</param>
 		internal async Task AddThreadMemberAsync(ulong channelId, ulong userId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
 		}
 
 		/// <summary>
 		/// Gets a thread member.
 		/// </summary>
 		/// <param name="channelId">The channel id to get the member from.</param>
 		/// <param name="userId">The user id to get.</param>
 		internal async Task<DiscordThreadChannelMember> GetThreadMemberAsync(ulong channelId, ulong userId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadMember = JsonConvert.DeserializeObject<DiscordThreadChannelMember>(res.Response);
 
 			return threadMember;
 		}
 
 		/// <summary>
 		/// Removes a thread member.
 		/// </summary>
 		/// <param name="channelId">The channel id to remove the member from.</param>
 		/// <param name="userId">The user id to remove.</param>
 		internal async Task RemoveThreadMemberAsync(ulong channelId, ulong userId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Gets the thread members.
 		/// </summary>
 		/// <param name="threadId">The thread id.</param>
 		internal async Task<IReadOnlyList<DiscordThreadChannelMember>> GetThreadMembersAsync(ulong threadId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:thread_id{Endpoints.THREAD_MEMBERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {thread_id = threadId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadMembersRaw = JsonConvert.DeserializeObject<List<DiscordThreadChannelMember>>(res.Response);
 
 			return new ReadOnlyCollection<DiscordThreadChannelMember>(threadMembersRaw);
 		}
 
 		/// <summary>
 		/// Gets the active threads in a guild.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		internal async Task<DiscordThreadResult> GetActiveThreadsAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.THREADS}{Endpoints.THREAD_ACTIVE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 			return threadReturn;
 		}
 
 		/// <summary>
 		/// Gets the joined private archived threads in a channel.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="before">Get threads before snowflake.</param>
 		/// <param name="limit">Limit the results.</param>
 		internal async Task<DiscordThreadResult> GetJoinedPrivateArchivedThreadsAsync(ulong channelId, ulong? before, int? limit)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (before != null)
 				urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 			if (limit != null && limit > 0)
 				urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.USERS}{Endpoints.ME}{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PRIVATE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 			return threadReturn;
 		}
 
 		/// <summary>
 		/// Gets the public archived threads in a channel.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="before">Get threads before snowflake.</param>
 		/// <param name="limit">Limit the results.</param>
 		internal async Task<DiscordThreadResult> GetPublicArchivedThreadsAsync(ulong channelId, ulong? before, int? limit)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (before != null)
 				urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 			if (limit != null && limit > 0)
 				urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PUBLIC}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 			return threadReturn;
 		}
 
 		/// <summary>
 		/// Gets the private archived threads in a channel.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="before">Get threads before snowflake.</param>
 		/// <param name="limit">Limit the results.</param>
 		internal async Task<DiscordThreadResult> GetPrivateArchivedThreadsAsync(ulong channelId, ulong? before, int? limit)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (before != null)
 				urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 			if (limit != null && limit > 0)
 				urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PRIVATE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 			return threadReturn;
 		}
 
 		/// <summary>
 		/// Modifies a thread.
 		/// </summary>
 		/// <param name="threadId">The thread to modify.</param>
 		/// <param name="name">The new name.</param>
 		/// <param name="locked">The new locked state.</param>
 		/// <param name="archived">The new archived state.</param>
 		/// <param name="autoArchiveDuration">The new auto archive duration.</param>
 		/// <param name="perUserRateLimit">The new per user rate limit.</param>
 		/// <param name="invitable">The new user invitable state.</param>
 		/// <param name="reason">The reason for the modification.</param>
 		internal Task ModifyThreadAsync(ulong threadId, string name, Optional<bool?> locked, Optional<bool?> archived, Optional<ThreadAutoArchiveDuration?> autoArchiveDuration, Optional<int?> perUserRateLimit, Optional<bool?> invitable, string reason)
 		{
 			var pld = new RestThreadChannelModifyPayload
 			{
 				Name = name,
 				Archived = archived,
 				AutoArchiveDuration = autoArchiveDuration,
 				Locked = locked,
 				PerUserRateLimit = perUserRateLimit,
 				Invitable = invitable
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:thread_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {thread_id = threadId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Deletes a thread.
 		/// </summary>
 		/// <param name="threadId">The thread to delete.</param>
 		/// <param name="reason">The reason for deletion.</param>
 		internal Task DeleteThreadAsync(ulong threadId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:thread_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {thread_id = threadId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		#endregion
 
 		#region Emoji
 		/// <summary>
 		/// Gets the guild emojis async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordGuildEmoji>> GetGuildEmojisAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var emojisRaw = JsonConvert.DeserializeObject<IEnumerable<JObject>>(res.Response);
 
 			this.Discord.Guilds.TryGetValue(guildId, out var gld);
 			var users = new Dictionary<ulong, DiscordUser>();
 			var emojis = new List<DiscordGuildEmoji>();
 			foreach (var rawEmoji in emojisRaw)
 			{
 				var xge = rawEmoji.ToObject<DiscordGuildEmoji>();
 				xge.Guild = gld;
 
 				var xtu = rawEmoji["user"]?.ToObject<TransportUser>();
 				if (xtu != null)
 				{
 					if (!users.ContainsKey(xtu.Id))
 					{
 						var user = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 						users[user.Id] = user;
 					}
 
 					xge.User = users[xtu.Id];
 				}
 
 				emojis.Add(xge);
 			}
 
 			return new ReadOnlyCollection<DiscordGuildEmoji>(emojis);
 		}
 
 		/// <summary>
 		/// Gets the guild emoji async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="emojiId">The emoji_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildEmoji> GetGuildEmojiAsync(ulong guildId, ulong emojiId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, emoji_id = emojiId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			this.Discord.Guilds.TryGetValue(guildId, out var gld);
 
 			var emojiRaw = JObject.Parse(res.Response);
 			var emoji = emojiRaw.ToObject<DiscordGuildEmoji>();
 			emoji.Guild = gld;
 
 			var xtu = emojiRaw["user"]?.ToObject<TransportUser>();
 			if (xtu != null)
 				emoji.User = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 
 			return emoji;
 		}
 
 		/// <summary>
 		/// Creates the guild emoji async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="imageb64">The imageb64.</param>
 		/// <param name="roles">The roles.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildEmoji> CreateGuildEmojiAsync(ulong guildId, string name, string imageb64, IEnumerable<ulong> roles, string reason)
 		{
 			var pld = new RestGuildEmojiCreatePayload
 			{
 				Name = name,
 				ImageB64 = imageb64,
 				Roles = roles?.ToArray()
 			};
 
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			this.Discord.Guilds.TryGetValue(guildId, out var gld);
 
 			var emojiRaw = JObject.Parse(res.Response);
 			var emoji = emojiRaw.ToObject<DiscordGuildEmoji>();
 			emoji.Guild = gld;
 
 			var xtu = emojiRaw["user"]?.ToObject<TransportUser>();
 			emoji.User = xtu != null
 				? gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu)
 				: this.Discord.CurrentUser;
 
 			return emoji;
 		}
 
 		/// <summary>
 		/// Modifies the guild emoji async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="emojiId">The emoji_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="roles">The roles.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordGuildEmoji> ModifyGuildEmojiAsync(ulong guildId, ulong emojiId, string name, IEnumerable<ulong> roles, string reason)
 		{
 			var pld = new RestGuildEmojiModifyPayload
 			{
 				Name = name,
 				Roles = roles?.ToArray()
 			};
 
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, emoji_id = emojiId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			this.Discord.Guilds.TryGetValue(guildId, out var gld);
 
 			var emojiRaw = JObject.Parse(res.Response);
 			var emoji = emojiRaw.ToObject<DiscordGuildEmoji>();
 			emoji.Guild = gld;
 
 			var xtu = emojiRaw["user"]?.ToObject<TransportUser>();
 			if (xtu != null)
 				emoji.User = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 
 			return emoji;
 		}
 
 		/// <summary>
 		/// Deletes the guild emoji async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="emojiId">The emoji_id.</param>
 		/// <param name="reason">The reason.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteGuildEmojiAsync(ulong guildId, ulong emojiId, string reason)
 		{
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, emoji_id = emojiId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 		#endregion
 
 		#region Stickers
 
 		/// <summary>
 		/// Gets a sticker.
 		/// </summary>
 		/// <param name="stickerId">The sticker id.</param>
 		internal async Task<DiscordSticker> GetStickerAsync(ulong stickerId)
 		{
 			var route = $"{Endpoints.STICKERS}/:sticker_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {sticker_id = stickerId}, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 			var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the sticker packs.
 		/// </summary>
 		internal async Task<IReadOnlyList<DiscordStickerPack>> GetStickerPacksAsync()
 		{
 			var route = $"{Endpoints.STICKERPACKS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response)["sticker_packs"] as JArray;
 			var ret = json.ToDiscordObject<DiscordStickerPack[]>();
 
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Gets the guild stickers.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		internal async Task<IReadOnlyList<DiscordSticker>> GetGuildStickersAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId}, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 			var json = JArray.Parse(res.Response);
 			var ret = json.ToDiscordObject<DiscordSticker[]>();
 
 			for (var i = 0; i < ret.Length; i++)
 			{
 				var stkr = ret[i];
 				stkr.Discord = this.Discord;
 
 				if (json[i]["user"] is JObject obj) // Null = Missing stickers perm //
 				{
 					var tsr = obj.ToDiscordObject<TransportUser>();
 					var usr = new DiscordUser(tsr) {Discord = this.Discord};
 					usr = this.Discord.UserCache.AddOrUpdate(tsr.Id, usr, (id, old) =>
 					{
 						old.Username = usr.Username;
 						old.Discriminator = usr.Discriminator;
 						old.AvatarHash = usr.AvatarHash;
 						return old;
 					});
 					stkr.User = usr;
 				}
 			}
 
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Gets a guild sticker.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="stickerId">The sticker id.</param>
 		internal async Task<DiscordSticker> GetGuildStickerAsync(ulong guildId, ulong stickerId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, sticker_id = stickerId}, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var ret = json.ToDiscordObject<DiscordSticker>();
 			if (json["user"] is not null) // Null = Missing stickers perm //
 			{
 				var tsr = json["user"].ToDiscordObject<TransportUser>();
 				var usr = new DiscordUser(tsr) {Discord = this.Discord};
 				usr = this.Discord.UserCache.AddOrUpdate(tsr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
 				ret.User = usr;
 			}
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Creates the guild sticker.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="tags">The tags.</param>
 		/// <param name="file">The file.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordSticker> CreateGuildStickerAsync(ulong guildId, string name, string description, string tags, DiscordMessageFile file, string reason)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId}, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var res = await this.DoStickerMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, file, name, tags, description);
 
 			var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the guild sticker.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="stickerId">The sticker id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="tags">The tags.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordSticker> ModifyGuildStickerAsync(ulong guildId, ulong stickerId, Optional<string> name, Optional<string> description, Optional<string> tags, string reason)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, sticker_id = stickerId}, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var pld = new RestStickerModifyPayload()
 			{
 				Name = name,
 				Description = description,
 				Tags = tags
 			};
 
 			var values = new Dictionary<string, string>
 			{
 				["payload_json"] = DiscordJson.SerializeObject(pld)
 			};
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route);
 			var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 			ret.Discord = this.Discord;
 
 			return null;
 		}
 
 		/// <summary>
 		/// Deletes the guild sticker async.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="stickerId">The sticker id.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task DeleteGuildStickerAsync(ulong guildId, ulong stickerId, string reason)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, sticker_id = stickerId }, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 		#endregion
 
 		#region Application Commands
 		/// <summary>
 		/// Gets the global application commands async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync(ulong applicationId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Bulks the overwrite global application commands async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="commands">The commands.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGlobalApplicationCommandsAsync(ulong applicationId, IEnumerable<DiscordApplicationCommand> commands)
 		{
 			var pld = new List<RestApplicationCommandCreatePayload>();
 			foreach (var command in commands)
 			{
 				pld.Add(new RestApplicationCommandCreatePayload
 				{
 					Type = command.Type,
 					Name = command.Name,
 					Description = command.Description,
 					Options = command.Options,
 					DefaultPermission = command.DefaultPermission,
 					NameLocalizations = command.NameLocalizations?.GetKeyValuePairs(),
 					DescriptionLocalizations = command.DescriptionLocalizations?.GetKeyValuePairs()
 				});
 			}
 
 			this.Discord.Logger.LogDebug(DiscordJson.SerializeObject(pld));
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {application_id = applicationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Creates the global application command async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="command">The command.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordApplicationCommand> CreateGlobalApplicationCommandAsync(ulong applicationId, DiscordApplicationCommand command)
 		{
 			var pld = new RestApplicationCommandCreatePayload
 			{
 				Type = command.Type,
 				Name = command.Name,
 				Description = command.Description,
 				Options = command.Options,
 				DefaultPermission = command.DefaultPermission,
 				NameLocalizations = command.NameLocalizations.GetKeyValuePairs(),
 				DescriptionLocalizations = command.DescriptionLocalizations.GetKeyValuePairs()
 			};
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {application_id = applicationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the global application command async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="commandId">The command_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordApplicationCommand> GetGlobalApplicationCommandAsync(ulong applicationId, ulong commandId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Edits the global application command async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="commandId">The command_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="options">The options.</param>
 		/// <param name="defaultPermission">The default_permission.</param>
 		/// <param name="nameLocalization">The localizations of the name.</param>
 		/// <param name="descriptionLocalization">The localizations of the description.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordApplicationCommand> EditGlobalApplicationCommandAsync(ulong applicationId, ulong commandId, Optional<string> name, Optional<string> description, Optional<IReadOnlyCollection<DiscordApplicationCommandOption>> options, Optional<bool> defaultPermission, Optional<DiscordApplicationCommandLocalization> nameLocalization, Optional<DiscordApplicationCommandLocalization> descriptionLocalization)
 		{
 			var pld = new RestApplicationCommandEditPayload
 			{
 				Name = name,
 				Description = description,
 				Options = options,
 				DefaultPermission = defaultPermission,
 				NameLocalizations = nameLocalization.HasValue ? nameLocalization.Value.GetKeyValuePairs() : null,
 				DescriptionLocalizations = descriptionLocalization.HasValue ? descriptionLocalization.Value.GetKeyValuePairs() : null
 			};
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {application_id = applicationId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the global application command async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="commandId">The command_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task DeleteGlobalApplicationCommandAsync(ulong applicationId, ulong commandId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {application_id = applicationId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Gets the guild application commands async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="guildId">The guild_id.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong applicationId, ulong guildId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Bulks the overwrite guild application commands async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="commands">The commands.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGuildApplicationCommandsAsync(ulong applicationId, ulong guildId, IEnumerable<DiscordApplicationCommand> commands)
 		{
 			var pld = new List<RestApplicationCommandCreatePayload>();
 			foreach (var command in commands)
 			{
 				pld.Add(new RestApplicationCommandCreatePayload
 				{
 					Type = command.Type,
 					Name = command.Name,
 					Description = command.Description,
 					Options = command.Options,
 					DefaultPermission = command.DefaultPermission,
 					NameLocalizations = command.NameLocalizations?.GetKeyValuePairs(),
 					DescriptionLocalizations = command.DescriptionLocalizations?.GetKeyValuePairs()
 				});
 			}
 			this.Discord.Logger.LogDebug(DiscordJson.SerializeObject(pld));
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Creates the guild application command async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="command">The command.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordApplicationCommand> CreateGuildApplicationCommandAsync(ulong applicationId, ulong guildId, DiscordApplicationCommand command)
 		{
 			var pld = new RestApplicationCommandCreatePayload
 			{
 				Type = command.Type,
 				Name = command.Name,
 				Description = command.Description,
 				Options = command.Options,
 				DefaultPermission = command.DefaultPermission,
 				NameLocalizations = command.NameLocalizations.GetKeyValuePairs(),
 				DescriptionLocalizations = command.DescriptionLocalizations.GetKeyValuePairs()
 
 			};
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the guild application command async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="commandId">The command_id.</param>
 		internal async Task<DiscordApplicationCommand> GetGuildApplicationCommandAsync(ulong applicationId, ulong guildId, ulong commandId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Edits the guild application command async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="commandId">The command_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="options">The options.</param>
 		/// <param name="defaultPermission">The default_permission.</param>
 		/// <param name="nameLocalization">The localizations of the name.</param>
 		/// <param name="descriptionLocalization">The localizations of the description.</param>
 		internal async Task<DiscordApplicationCommand> EditGuildApplicationCommandAsync(ulong applicationId, ulong guildId, ulong commandId, Optional<string> name, Optional<string> description, Optional<IReadOnlyCollection<DiscordApplicationCommandOption>> options, Optional<bool> defaultPermission, Optional<DiscordApplicationCommandLocalization> nameLocalization, Optional<DiscordApplicationCommandLocalization> descriptionLocalization)
 		{
 			var pld = new RestApplicationCommandEditPayload
 			{
 				Name = name,
 				Description = description,
 				Options = options,
 				DefaultPermission = defaultPermission,
 				NameLocalizations = nameLocalization.HasValue ? nameLocalization.Value.GetKeyValuePairs() : null,
 				DescriptionLocalizations = descriptionLocalization.HasValue ? descriptionLocalization.Value.GetKeyValuePairs() : null
 			};
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the guild application command async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="commandId">The command_id.</param>
 		internal async Task DeleteGuildApplicationCommandAsync(ulong applicationId, ulong guildId, ulong commandId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Gets the guild application command permissions.
 		/// </summary>
 		/// <param name="applicationId">The target application id.</param>
 		/// <param name="guildId">The target guild id.</param>
 		internal async Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> GetGuildApplicationCommandPermissionsAsync(ulong applicationId, ulong guildId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}{Endpoints.PERMISSIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildApplicationCommandPermission>>(res.Response);
 
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Gets the application command permission.
 		/// </summary>
 		/// <param name="applicationId">The target application id.</param>
 		/// <param name="guildId">The target guild id.</param>
 		/// <param name="commandId">The target command id.</param>
 		internal async Task<DiscordGuildApplicationCommandPermission> GetApplicationCommandPermissionAsync(ulong applicationId, ulong guildId, ulong commandId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id{Endpoints.PERMISSIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildApplicationCommandPermission>(res.Response);
 
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Overwrites the guild application command permissions.
 		/// </summary>
 		/// <param name="applicationId">The target application id.</param>
 		/// <param name="guildId">The target guild id.</param>
 		/// <param name="commandId">The target command id.</param>
 		/// <param name="permissions">Array of permissions.</param>
 		internal async Task<DiscordGuildApplicationCommandPermission> OverwriteGuildApplicationCommandPermissionsAsync(ulong applicationId, ulong guildId, ulong commandId, IEnumerable<DiscordApplicationCommandPermission> permissions)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id{Endpoints.PERMISSIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 			if (permissions.ToArray().Length > 10)
 				throw new NotSupportedException("You can add only up to 10 permission overwrites per command.");
 
 			var pld = new RestApplicationCommandPermissionEditPayload
 			{
 				Permissions = permissions
 			};
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildApplicationCommandPermission>(res.Response);
 
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Bulks overwrite the application command permissions.
 		/// </summary>
 		/// <param name="applicationId">The target application id.</param>
 		/// <param name="guildId">The target guild id.</param>
 		/// <param name="permissionOverwrites"></param>
 		internal async Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> BulkOverwriteApplicationCommandPermissionsAsync(ulong applicationId, ulong guildId, IEnumerable<DiscordGuildApplicationCommandPermission> permissionOverwrites)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}{Endpoints.PERMISSIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 			var pld = new List<RestGuildApplicationCommandPermissionEditPayload>();
 			foreach (var overwrite in permissionOverwrites)
 			{
 				if (overwrite.Permissions.Count > 10)
 					throw new NotSupportedException("You can add only up to 10 permission overwrites per command.");
 
 				pld.Add(new RestGuildApplicationCommandPermissionEditPayload
 				{
 					CommandId = overwrite.Id,
 					Permissions = overwrite.Permissions
 				});
 			}
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld.ToArray()));
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildApplicationCommandPermission>>(res.Response);
 
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Creates the interaction response async.
 		/// </summary>
 		/// <param name="interactionId">The interaction_id.</param>
 		/// <param name="interactionToken">The interaction_token.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="builder">The builder.</param>
 		/// <returns>A Task.</returns>
 		internal async Task CreateInteractionResponseAsync(ulong interactionId, string interactionToken, InteractionResponseType type, DiscordInteractionResponseBuilder builder)
 		{
 			if (builder?.Embeds != null)
 				foreach (var embed in builder.Embeds)
 					if (embed.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			RestInteractionResponsePayload pld;
 
 			if (type != InteractionResponseType.AutoCompleteResult)
 			{
 				var data = builder != null ? new DiscordInteractionApplicationCommandCallbackData
 				{
 					Content = builder.Content ?? null,
 					Embeds = builder.Embeds ?? null,
 					IsTts = builder.IsTts,
 					Mentions = builder.Mentions ?? null,
 					Flags = builder.IsEphemeral ? MessageFlags.Ephemeral : null,
 					Components = builder.Components ?? null,
 					Choices = null
 				} : null;
 
 
 				pld = new RestInteractionResponsePayload
 				{
 					Type = type,
 					Data = data
 				};
 
 
 				if (builder != null && builder.Files != null && builder.Files.Count > 0)
 				{
 					ulong fileId = 0;
 					List<DiscordAttachment> attachments = new();
 					foreach (var file in builder.Files)
 					{
 						DiscordAttachment att = new()
 						{
 							Id = fileId,
 							Discord = this.Discord,
 							Description = file.Description,
 							FileName = file.FileName,
 							FileSize = null
 						};
 						attachments.Add(att);
 						fileId++;
 					}
 					pld.Attachments = attachments;
 					pld.Data.Attachments = attachments;
 				}
 			}
 			else
 			{
 				pld = new RestInteractionResponsePayload
 				{
 					Type = type,
 					Data = new DiscordInteractionApplicationCommandCallbackData
 					{
 						Content = null,
 						Embeds = null,
 						IsTts = null,
 						Mentions = null,
 						Flags = null,
 						Components = null,
 						Choices = builder.Choices,
 						Attachments = null
 					},
 					Attachments = null
 				};
 			}
 
 			var values = new Dictionary<string, string>();
 
 			if (builder != null)
 				if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count() > 0 || builder.IsTts == true || builder.Mentions != null || builder.Files?.Count > 0)
 					values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 			var route = $"{Endpoints.INTERACTIONS}/:interaction_id/:interaction_token{Endpoints.CALLBACK}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {interaction_id = interactionId, interaction_token = interactionToken }, out var path);
 
 			var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "false").Build();
 			if (builder != null)
 			{
 				await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files);
 
 				foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 				{
 					file.Stream.Position = file.ResetPositionTo.Value;
 				}
 			}
 			else
 			{
 				await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 			}
 		}
 
 		/// <summary>
 		/// Creates the interaction response async.
 		/// </summary>
 		/// <param name="interactionId">The interaction_id.</param>
 		/// <param name="interactionToken">The interaction_token.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="builder">The builder.</param>
 		/// <returns>A Task.</returns>
 		internal async Task CreateInteractionModalResponseAsync(ulong interactionId, string interactionToken, InteractionResponseType type, DiscordInteractionModalBuilder builder)
 		{
 			if (builder.ModalComponents.Any(mc => mc.Components.Any(c => c.Type != Enums.ComponentType.InputText)))
 				throw new NotSupportedException("Can't send any other type then Input Text as Modal Component.");
 
 			var pld = new RestInteractionModalResponsePayload
 			{
 				Type = type,
 				Data = new DiscordInteractionApplicationCommandModalCallbackData
 				{
 					Title = builder.Title,
 					CustomId = builder.CustomId,
 					ModalComponents = builder.ModalComponents
 				}
 			};
 
 			var values = new Dictionary<string, string>();
 
 			var route = $"{Endpoints.INTERACTIONS}/:interaction_id/:interaction_token{Endpoints.CALLBACK}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {interaction_id = interactionId, interaction_token = interactionToken }, out var path);
 
 			var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Gets the original interaction response async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="interactionToken">The interaction_token.</param>
 		/// <returns>A Task.</returns>
 		internal Task<DiscordMessage> GetOriginalInteractionResponseAsync(ulong applicationId, string interactionToken) =>
 			this.GetWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, null);
 
 		/// <summary>
 		/// Edits the original interaction response async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="interactionToken">The interaction_token.</param>
 		/// <param name="builder">The builder.</param>
 		/// <returns>A Task.</returns>
 		internal Task<DiscordMessage> EditOriginalInteractionResponseAsync(ulong applicationId, string interactionToken, DiscordWebhookBuilder builder) =>
 			this.EditWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, builder, null);
 
 		/// <summary>
 		/// Deletes the original interaction response async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="interactionToken">The interaction_token.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteOriginalInteractionResponseAsync(ulong applicationId, string interactionToken) =>
 			this.DeleteWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, null);
 
 		/// <summary>
 		/// Creates the followup message async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="interactionToken">The interaction_token.</param>
 		/// <param name="builder">The builder.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<DiscordMessage> CreateFollowupMessageAsync(ulong applicationId, string interactionToken, DiscordFollowupMessageBuilder builder)
 		{
 			builder.Validate();
 
 			if (builder.Embeds != null)
 				foreach (var embed in builder.Embeds)
 					if (embed.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			var values = new Dictionary<string, string>();
 			var pld = new RestFollowupMessageCreatePayload
 			{
 				Content = builder.Content,
 				IsTts = builder.IsTts,
 				Embeds = builder.Embeds,
 				Flags = builder.Flags,
 				Components = builder.Components
 			};
 
 
 			if (builder.Files != null && builder.Files.Count > 0)
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachments = new();
 				foreach (var file in builder.Files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName,
 						FileSize = null
 					};
 					attachments.Add(att);
 					fileId++;
 				}
 				pld.Attachments = attachments;
 			}
 
 			if (builder.Mentions != null)
 				pld.Mentions = new DiscordMentions(builder.Mentions, builder.Mentions.Any());
 
 			if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count() > 0 || builder.IsTts == true || builder.Mentions != null || builder.Files?.Count > 0)
 				values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 			var route = $"{Endpoints.WEBHOOKS}/:application_id/:interaction_token";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {application_id = applicationId, interaction_token = interactionToken }, out var path);
 
 			var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
 			var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 			foreach (var att in ret.AttachmentsInternal)
 			{
 				att.Discord = this.Discord;
 			}
 
 			foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 			{
 				file.Stream.Position = file.ResetPositionTo.Value;
 			}
 
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the followup message async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="interactionToken">The interaction_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task<DiscordMessage> GetFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId) =>
 			this.GetWebhookMessageAsync(applicationId, interactionToken, messageId);
 
 		/// <summary>
 		/// Edits the followup message async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="interactionToken">The interaction_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="builder">The builder.</param>
 		/// <returns>A Task.</returns>
 		internal Task<DiscordMessage> EditFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId, DiscordWebhookBuilder builder) =>
 			this.EditWebhookMessageAsync(applicationId, interactionToken, messageId.ToString(), builder, null);
 
 		/// <summary>
 		/// Deletes the followup message async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="interactionToken">The interaction_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task DeleteFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId) =>
 			this.DeleteWebhookMessageAsync(applicationId, interactionToken, messageId);
 		#endregion
 
 		#region Misc
 		/// <summary>
 		/// Gets the current application info async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal Task<TransportApplication> GetCurrentApplicationInfoAsync()
 			=> this.GetApplicationInfoAsync("@me");
 
 		/// <summary>
 		/// Gets the application info async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <returns>A Task.</returns>
 		internal Task<TransportApplication> GetApplicationInfoAsync(ulong applicationId)
 			=> this.GetApplicationInfoAsync(applicationId.ToString(CultureInfo.InvariantCulture));
 
 		/// <summary>
 		/// Gets the application info async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <returns>A Task.</returns>
 		private async Task<TransportApplication> GetApplicationInfoAsync(string applicationId)
 		{
 			var route = $"{Endpoints.OAUTH2}{Endpoints.APPLICATIONS}/:application_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			return JsonConvert.DeserializeObject<TransportApplication>(res.Response);
 		}
 
 		/// <summary>
 		/// Gets the application assets async.
 		/// </summary>
 		/// <param name="application">The application.</param>
 		/// <returns>A Task.</returns>
 		internal async Task<IReadOnlyList<DiscordApplicationAsset>> GetApplicationAssetsAsync(DiscordApplication application)
 		{
 			var route = $"{Endpoints.OAUTH2}{Endpoints.APPLICATIONS}/:application_id{Endpoints.ASSETS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id = application.Id }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var assets = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationAsset>>(res.Response);
 			foreach (var asset in assets)
 			{
 				asset.Discord = application.Discord;
 				asset.Application = application;
 			}
 
 			return new ReadOnlyCollection<DiscordApplicationAsset>(new List<DiscordApplicationAsset>(assets));
 		}
 
 		/// <summary>
 		/// Gets the gateway info async.
 		/// </summary>
 		/// <returns>A Task.</returns>
 		internal async Task<GatewayInfo> GetGatewayInfoAsync()
 		{
 			var headers = Utilities.GetBaseHeaders();
 			var route = Endpoints.GATEWAY;
 			if (this.Discord.Configuration.TokenType == TokenType.Bot)
 				route += Endpoints.BOT;
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route, headers).ConfigureAwait(false);
 
 			var info = JObject.Parse(res.Response).ToObject<GatewayInfo>();
 			info.SessionBucket.ResetAfter = DateTimeOffset.UtcNow + TimeSpan.FromMilliseconds(info.SessionBucket.ResetAfterInternal);
 			return info;
 		}
 		#endregion
 
 		#region DCS Internals
 		/// <summary>
 		/// Gets the DisCatSharp team.
 		/// </summary>>
 		internal async Task<DisCatSharpTeam> GetDisCatSharpTeamAsync()
 		{
 			try
 			{
 				var wc = new WebClient();
 				var dcs = await wc.DownloadStringTaskAsync(new Uri("https://dcs.aitsys.dev/api/devs/"));
 				var dcsGuild = await wc.DownloadStringTaskAsync(new Uri("https://dcs.aitsys.dev/api/guild/"));
 
 				var app = JsonConvert.DeserializeObject<TransportApplication>(dcs);
 				var guild = JsonConvert.DeserializeObject<DiscordGuild>(dcsGuild);
 
 				var dcst = new DisCatSharpTeam
 				{
 					IconHash = app.Team.IconHash,
 					TeamName = app.Team.Name,
 					PrivacyPolicyUrl = app.PrivacyPolicyUrl,
 					TermsOfServiceUrl = app.TermsOfServiceUrl,
 					RepoUrl = "https://github.com/Aiko-IT-Systems/DisCatSharp",
 					DocsUrl = "https://docs.dcs.aitsys.dev",
 					Id = app.Team.Id,
 					BannerHash = guild.BannerHash,
 					LogoHash = guild.IconHash,
 					GuildId = guild.Id,
 					Guild = guild,
 					SupportInvite = await this.GetInviteAsync("discatsharp", true, true, null)
 				};
 				List<DisCatSharpTeamMember> team = new();
 				DisCatSharpTeamMember owner = new();
 				foreach (var mb in app.Team.Members.OrderBy(m => m.User.Username))
 				{
 					var tuser = await this.GetUserAsync(mb.User.Id);
 					var user = mb.User;
 					if (mb.User.Id == 856780995629154305)
 					{
 						owner.Id = user.Id;
 						owner.Username = user.Username;
 						owner.Discriminator = user.Discriminator;
 						owner.AvatarHash = user.AvatarHash;
 						owner.BannerHash = tuser.BannerHash;
 						owner.BannerColorInternal = tuser.BannerColorInternal;
 						team.Add(owner);
 					}
 					else
 					{
-						team.Add(new()
+						team.Add(new DisCatSharpTeamMember
 						{
 							Id = user.Id,
 							Username = user.Username,
 							Discriminator = user.Discriminator,
 							AvatarHash = user.AvatarHash,
 							BannerHash = tuser.BannerHash,
 							BannerColorInternal = tuser.BannerColorInternal
 						});
 					}
 				}
 				dcst.Owner = owner;
 				dcst.Developers = team;
 
 				return dcst;
 			}
 			catch (Exception ex)
 			{
 				this.Discord.Logger.LogDebug(ex.Message);
 				this.Discord.Logger.LogDebug(ex.StackTrace);
 				return null;
 			}
 		}
 		#endregion
 	}
 }
diff --git a/DisCatSharp/Net/Rest/RateLimitBucket.cs b/DisCatSharp/Net/Rest/RateLimitBucket.cs
index d3027623d..9468d560f 100644
--- a/DisCatSharp/Net/Rest/RateLimitBucket.cs
+++ b/DisCatSharp/Net/Rest/RateLimitBucket.cs
@@ -1,291 +1,291 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Net
 {
 	/// <summary>
 	/// Represents a rate limit bucket.
 	/// </summary>
 	internal class RateLimitBucket : IEquatable<RateLimitBucket>
 	{
 		/// <summary>
 		/// Gets the Id of the guild bucket.
 		/// </summary>
 		public string GuildId { get; internal set; }
 
 		/// <summary>
 		/// Gets the Id of the channel bucket.
 		/// </summary>
 		public string ChannelId { get; internal set; }
 
 		/// <summary>
 		/// Gets the ID of the webhook bucket.
 		/// </summary>
 		public string WebhookId { get; internal set; }
 
 		/// <summary>
 		/// Gets the Id of the ratelimit bucket.
 		/// </summary>
 		public volatile string BucketId;
 
 		/// <summary>
 		/// Gets or sets the ratelimit hash of this bucket.
 		/// </summary>
 		public string Hash
 		{
 			get => Volatile.Read(ref this.HashInternal);
 
 			internal set
 			{
 				this.IsUnlimited = value.Contains(s_unlimitedHash);
 
 				if (this.BucketId != null && !this.BucketId.StartsWith(value))
 				{
 					var id = GenerateBucketId(value, this.GuildId, this.ChannelId, this.WebhookId);
 					this.BucketId = id;
 					this.RouteHashes.Add(id);
 				}
 
 				Volatile.Write(ref this.HashInternal, value);
 			}
 		}
 
 		internal string HashInternal;
 
 		/// <summary>
 		/// Gets the past route hashes associated with this bucket.
 		/// </summary>
 		public ConcurrentBag<string> RouteHashes { get; }
 
 		/// <summary>
 		/// Gets when this bucket was last called in a request.
 		/// </summary>
 		public DateTimeOffset LastAttemptAt { get; internal set; }
 
 		/// <summary>
 		/// Gets the number of uses left before pre-emptive rate limit is triggered.
 		/// </summary>
 		public int Remaining
 			=> this.RemainingInternal;
 
 		/// <summary>
 		/// Gets the maximum number of uses within a single bucket.
 		/// </summary>
 		public int Maximum { get; set; }
 
 		/// <summary>
 		/// Gets the timestamp at which the rate limit resets.
 		/// </summary>
 		public DateTimeOffset Reset { get; internal set; }
 
 		/// <summary>
 		/// Gets the time interval to wait before the rate limit resets.
 		/// </summary>
-		public TimeSpan? ResetAfter { get; internal set; } = null;
+		public TimeSpan? ResetAfter { get; internal set; }
 
 		/// <summary>
 		/// Gets a value indicating whether the ratelimit global.
 		/// </summary>
 		public bool IsGlobal { get; internal set; } = false;
 
 		/// <summary>
 		/// Gets the ratelimit scope.
 		/// </summary>
 		public string Scope { get; internal set; } = "user";
 
 		/// <summary>
 		/// Gets the time interval to wait before the rate limit resets as offset
 		/// </summary>
 		internal DateTimeOffset ResetAfterOffset { get; set; }
 
 		internal volatile int RemainingInternal;
 
 		/// <summary>
 		/// Gets whether this bucket has it's ratelimit determined.
 		/// <para>This will be <see langword="false"/> if the ratelimit is determined.</para>
 		/// </summary>
 		internal volatile bool IsUnlimited;
 
 		/// <summary>
 		/// If the initial request for this bucket that is deterternining the rate limits is currently executing
 		/// This is a int because booleans can't be accessed atomically
 		/// 0 => False, all other values => True
 		/// </summary>
 		internal volatile int LimitTesting;
 
 		/// <summary>
 		/// Task to wait for the rate limit test to finish
 		/// </summary>
 		internal volatile Task LimitTestFinished;
 
 		/// <summary>
 		/// If the rate limits have been determined
 		/// </summary>
 		internal volatile bool LimitValid;
 
 		/// <summary>
 		/// Rate limit reset in ticks, UTC on the next response after the rate limit has been reset
 		/// </summary>
 		internal long NextReset;
 
 		/// <summary>
 		/// If the rate limit is currently being reset.
 		/// This is a int because booleans can't be accessed atomically.
 		/// 0 => False, all other values => True
 		/// </summary>
 		internal volatile int LimitResetting;
 
 		private static readonly string s_unlimitedHash = "unlimited";
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="RateLimitBucket"/> class.
 		/// </summary>
 		/// <param name="hash">The hash.</param>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="webhookId">The webhook_id.</param>
 		internal RateLimitBucket(string hash, string guildId, string channelId, string webhookId)
 		{
 			this.Hash = hash;
 			this.ChannelId = channelId;
 			this.GuildId = guildId;
 			this.WebhookId = webhookId;
 
 			this.BucketId = GenerateBucketId(hash, guildId, channelId, webhookId);
 			this.RouteHashes = new ConcurrentBag<string>();
 		}
 
 		/// <summary>
 		/// Generates an ID for this request bucket.
 		/// </summary>
 		/// <param name="hash">Hash for this bucket.</param>
 		/// <param name="guildId">Guild Id for this bucket.</param>
 		/// <param name="channelId">Channel Id for this bucket.</param>
 		/// <param name="webhookId">Webhook Id for this bucket.</param>
 		/// <returns>Bucket Id.</returns>
 		public static string GenerateBucketId(string hash, string guildId, string channelId, string webhookId)
 			=> $"{hash}:{guildId}:{channelId}:{webhookId}";
 
 		/// <summary>
 		/// Generates the hash key.
 		/// </summary>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <returns>A string.</returns>
 		public static string GenerateHashKey(RestRequestMethod method, string route)
 			=> $"{method}:{route}";
 
 		/// <summary>
 		/// Generates the unlimited hash.
 		/// </summary>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <returns>A string.</returns>
 		public static string GenerateUnlimitedHash(RestRequestMethod method, string route)
 			=> $"{GenerateHashKey(method, route)}:{s_unlimitedHash}";
 
 		/// <summary>
 		/// Returns a string representation of this bucket.
 		/// </summary>
 		/// <returns>String representation of this bucket.</returns>
 		public override string ToString()
 		{
 			var guildId = this.GuildId != string.Empty ? this.GuildId : "guild_id";
 			var channelId = this.ChannelId != string.Empty ? this.ChannelId : "channel_id";
 			var webhookId = this.WebhookId != string.Empty ? this.WebhookId : "webhook_id";
 
 			return $"{this.Scope} rate limit bucket [{this.Hash}:{guildId}:{channelId}:{webhookId}] [{this.Remaining}/{this.Maximum}] {(this.ResetAfter.HasValue ? this.ResetAfterOffset : this.Reset)}";
 		}
 
 		/// <summary>
 		/// Checks whether this <see cref="RateLimitBucket"/> is equal to another object.
 		/// </summary>
 		/// <param name="obj">Object to compare to.</param>
 		/// <returns>Whether the object is equal to this <see cref="RateLimitBucket"/>.</returns>
 		public override bool Equals(object obj)
 			=> this.Equals(obj as RateLimitBucket);
 
 		/// <summary>
 		/// Checks whether this <see cref="RateLimitBucket"/> is equal to another <see cref="RateLimitBucket"/>.
 		/// </summary>
 		/// <param name="e"><see cref="RateLimitBucket"/> to compare to.</param>
 		/// <returns>Whether the <see cref="RateLimitBucket"/> is equal to this <see cref="RateLimitBucket"/>.</returns>
 		public bool Equals(RateLimitBucket e) => e is not null && (ReferenceEquals(this, e) || this.BucketId == e.BucketId);
 
 		/// <summary>
 		/// Gets the hash code for this <see cref="RateLimitBucket"/>.
 		/// </summary>
 		/// <returns>The hash code for this <see cref="RateLimitBucket"/>.</returns>
 		public override int GetHashCode()
 			=> this.BucketId.GetHashCode();
 
 		/// <summary>
 		/// Sets remaining number of requests to the maximum when the ratelimit is reset
 		/// </summary>
 		/// <param name="now"></param>
 		internal async Task TryResetLimitAsync(DateTimeOffset now)
 		{
 			if (this.ResetAfter.HasValue)
 				this.ResetAfter = this.ResetAfterOffset - now;
 
 			if (this.NextReset == 0)
 				return;
 
 			if (this.NextReset > now.UtcTicks)
 				return;
 
 			while (Interlocked.CompareExchange(ref this.LimitResetting, 1, 0) != 0)
 #pragma warning restore 420
 				await Task.Yield();
 
 			if (this.NextReset != 0)
 			{
 				this.RemainingInternal = this.Maximum;
 				this.NextReset = 0;
 			}
 
 			this.LimitResetting = 0;
 		}
 
 		/// <summary>
 		/// Sets the initial values.
 		/// </summary>
 		/// <param name="max">The max.</param>
 		/// <param name="usesLeft">The uses left.</param>
 		/// <param name="newReset">The new reset.</param>
 		internal void SetInitialValues(int max, int usesLeft, DateTimeOffset newReset)
 		{
 			this.Maximum = max;
 			this.RemainingInternal = usesLeft;
 			this.NextReset = newReset.UtcTicks;
 
 			this.LimitValid = true;
 			this.LimitTestFinished = null;
 			this.LimitTesting = 0;
 		}
 	}
 }
diff --git a/DisCatSharp/Net/Rest/RestClient.cs b/DisCatSharp/Net/Rest/RestClient.cs
index 5a30e885b..3a4d1f302 100644
--- a/DisCatSharp/Net/Rest/RestClient.cs
+++ b/DisCatSharp/Net/Rest/RestClient.cs
@@ -1,860 +1,862 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Exceptions;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Net
 {
 	/// <summary>
 	/// Represents a client used to make REST requests.
 	/// </summary>
 	internal sealed class RestClient : IDisposable
 	{
 		/// <summary>
 		/// Gets the route argument regex.
 		/// </summary>
-		private static Regex s_routeArgumentRegex { get; } = new Regex(@":([a-z_]+)");
+		private static Regex s_routeArgumentRegex { get; } = new(@":([a-z_]+)");
 
 		/// <summary>
 		/// Gets the http client.
 		/// </summary>
 		internal HttpClient HttpClient { get; }
 
 		/// <summary>
 		/// Gets the discord client.
 		/// </summary>
 		private readonly BaseDiscordClient _discord;
 
 		/// <summary>
 		/// Gets a value indicating whether debug is enabled.
 		/// </summary>
 		internal bool Debug { get; set; }
 
 		/// <summary>
 		/// Gets the logger.
 		/// </summary>
 		private readonly ILogger _logger;
 
 		/// <summary>
 		/// Gets the routes to hashes.
 		/// </summary>
 		private readonly ConcurrentDictionary<string, string> _routesToHashes;
 
 		/// <summary>
 		/// Gets the hashes to buckets.
 		/// </summary>
 		private readonly ConcurrentDictionary<string, RateLimitBucket> _hashesToBuckets;
 
 		/// <summary>
 		/// Gets the request queue.
 		/// </summary>
 		private readonly ConcurrentDictionary<string, int> _requestQueue;
 
 		/// <summary>
 		/// Gets the global rate limit event.
 		/// </summary>
 		private readonly AsyncManualResetEvent _globalRateLimitEvent;
 
 		/// <summary>
 		/// Gets a value indicating whether use reset after.
 		/// </summary>
 		private readonly bool _useResetAfter;
 
 		private CancellationTokenSource _bucketCleanerTokenSource;
 		private readonly TimeSpan _bucketCleanupDelay = TimeSpan.FromSeconds(60);
 		private volatile bool _cleanerRunning;
 		private Task _cleanerTask;
 		private volatile bool _disposed;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="RestClient"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		internal RestClient(BaseDiscordClient client)
 			: this(client.Configuration.Proxy, client.Configuration.HttpTimeout, client.Configuration.UseRelativeRatelimit, client.Logger)
 		{
 			this._discord = client;
 			this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", Utilities.GetFormattedToken(client));
 			if (client.Configuration.Override != null)
 			{
 				this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("x-super-properties", client.Configuration.Override);
 			}
 		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="RestClient"/> class.
 		/// </summary>
 		/// <param name="proxy">The proxy.</param>
 		/// <param name="timeout">The timeout.</param>
 		/// <param name="useRelativeRatelimit">If true, use relative ratelimit.</param>
 		/// <param name="logger">The logger.</param>
 		internal RestClient(IWebProxy proxy, TimeSpan timeout, bool useRelativeRatelimit,
 			ILogger logger) // This is for meta-clients, such as the webhook client
 		{
 			this._logger = logger;
 
 			var httphandler = new HttpClientHandler
 			{
 				UseCookies = false,
 				AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip,
 				UseProxy = proxy != null,
 				Proxy = proxy
 			};
 
 			this.HttpClient = new HttpClient(httphandler)
 			{
 				BaseAddress = new Uri(Utilities.GetApiBaseUri(this._discord?.Configuration)),
 				Timeout = timeout
 			};
 
 			this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", Utilities.GetUserAgent());
 			if (this._discord != null && this._discord.Configuration != null && this._discord.Configuration.Override != null)
 			{
 				this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("x-super-properties", this._discord.Configuration.Override);
 			}
 
 			this._routesToHashes = new ConcurrentDictionary<string, string>();
 			this._hashesToBuckets = new ConcurrentDictionary<string, RateLimitBucket>();
 			this._requestQueue = new ConcurrentDictionary<string, int>();
 
 			this._globalRateLimitEvent = new AsyncManualResetEvent(true);
 			this._useResetAfter = useRelativeRatelimit;
 		}
 
 		/// <summary>
 		/// Gets a bucket.
 		/// </summary>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <param name="routeParams">The route paramaters.</param>
 		/// <param name="url">The url.</param>
 		/// <returns>A ratelimit bucket.</returns>
 		public RateLimitBucket GetBucket(RestRequestMethod method, string route, object routeParams, out string url)
 		{
 			var rparamsProps = routeParams.GetType()
 				.GetTypeInfo()
 				.DeclaredProperties;
 			var rparams = new Dictionary<string, string>();
 			foreach (var xp in rparamsProps)
 			{
 				var val = xp.GetValue(routeParams);
 				rparams[xp.Name] = val is string xs
 					? xs
 					: val is DateTime dt
 					? dt.ToString("yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture)
 					: val is DateTimeOffset dto
 					? dto.ToString("yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture)
 					: val is IFormattable xf ? xf.ToString(null, CultureInfo.InvariantCulture) : val.ToString();
 			}
 
 			var guildId = rparams.ContainsKey("guild_id") ? rparams["guild_id"] : "";
 			var channelId = rparams.ContainsKey("channel_id") ? rparams["channel_id"] : "";
 			var webhookId = rparams.ContainsKey("webhook_id") ? rparams["webhook_id"] : "";
 
 			// Create a generic route (minus major params) key
 			// ex: POST:/channels/channel_id/messages
 			var hashKey = RateLimitBucket.GenerateHashKey(method, route);
 
 			// We check if the hash is present, using our generic route (without major params)
 			// ex: in POST:/channels/channel_id/messages, out 80c17d2f203122d936070c88c8d10f33
 			// If it doesn't exist, we create an unlimited hash as our initial key in the form of the hash key + the unlimited constant
 			// and assign this to the route to hash cache
 			// ex: this.RoutesToHashes[POST:/channels/channel_id/messages] = POST:/channels/channel_id/messages:unlimited
 			var hash = this._routesToHashes.GetOrAdd(hashKey, RateLimitBucket.GenerateUnlimitedHash(method, route));
 
 			// Next we use the hash to generate the key to obtain the bucket.
 			// ex: 80c17d2f203122d936070c88c8d10f33:guild_id:506128773926879242:webhook_id
 			// or if unlimited: POST:/channels/channel_id/messages:unlimited:guild_id:506128773926879242:webhook_id
 			var bucketId = RateLimitBucket.GenerateBucketId(hash, guildId, channelId, webhookId);
 
 			// If it's not in cache, create a new bucket and index it by its bucket id.
 			var bucket = this._hashesToBuckets.GetOrAdd(bucketId, new RateLimitBucket(hash, guildId, channelId, webhookId));
 
 			bucket.LastAttemptAt = DateTimeOffset.UtcNow;
 
 			// Cache the routes for each bucket so it can be used for GC later.
 			if (!bucket.RouteHashes.Contains(bucketId))
 				bucket.RouteHashes.Add(bucketId);
 
 			// Add the current route to the request queue, which indexes the amount
 			// of requests occurring to the bucket id.
 			_ = this._requestQueue.TryGetValue(bucketId, out var count);
 
 			// Increment by one atomically due to concurrency
 			this._requestQueue[bucketId] = Interlocked.Increment(ref count);
 
 			// Start bucket cleaner if not already running.
 			if (!this._cleanerRunning)
 			{
 				this._cleanerRunning = true;
 				this._bucketCleanerTokenSource = new CancellationTokenSource();
 				this._cleanerTask = Task.Run(this.CleanupBucketsAsync, this._bucketCleanerTokenSource.Token);
 				this._logger.LogDebug(LoggerEvents.RestCleaner, "Bucket cleaner task started.");
 			}
 
 			url = s_routeArgumentRegex.Replace(route, xm => rparams[xm.Groups[1].Value]);
 			return bucket;
 		}
 
 		/// <summary>
 		/// Executes the request async.
 		/// </summary>
 		/// <param name="request">The request to be executed.</param>
 		public Task ExecuteRequestAsync(BaseRestRequest request)
 			=> request == null ? throw new ArgumentNullException(nameof(request)) : this.ExecuteRequestAsync(request, null, null);
 
 		/// <summary>
 		/// Executes the request async.
 		/// This is to allow proper rescheduling of the first request from a bucket.
 		/// </summary>
 		/// <param name="request">The request to be executed.</param>
 		/// <param name="bucket">The bucket.</param>
 		/// <param name="ratelimitTcs">The ratelimit task completion source.</param>
 		private async Task ExecuteRequestAsync(BaseRestRequest request, RateLimitBucket bucket, TaskCompletionSource<bool> ratelimitTcs)
 		{
 			if (this._disposed)
 				return;
 
 			HttpResponseMessage res = default;
 
 			try
 			{
 				await this._globalRateLimitEvent.WaitAsync().ConfigureAwait(false);
 
 				if (bucket == null)
 					bucket = request.RateLimitBucket;
 
 				if (ratelimitTcs == null)
 					ratelimitTcs = await this.WaitForInitialRateLimit(bucket).ConfigureAwait(false);
 
 				if (ratelimitTcs == null) // ckeck rate limit only if we are not the probe request
 				{
 					var now = DateTimeOffset.UtcNow;
 
 					await bucket.TryResetLimitAsync(now).ConfigureAwait(false);
 
 					// Decrement the remaining number of requests as there can be other concurrent requests before this one finishes and has a chance to update the bucket
 					if (Interlocked.Decrement(ref bucket.RemainingInternal) < 0)
 					{
 						this._logger.LogDebug(LoggerEvents.RatelimitDiag, "Request for {0} is blocked", bucket.ToString());
 						var delay = bucket.Reset - now;
 						var resetDate = bucket.Reset;
 
 						if (this._useResetAfter)
 						{
 							delay = bucket.ResetAfter.Value;
 							resetDate = bucket.ResetAfterOffset;
 						}
 
 						if (delay < new TimeSpan(-TimeSpan.TicksPerMinute))
 						{
 							this._logger.LogError(LoggerEvents.RatelimitDiag, "Failed to retrieve ratelimits - giving up and allowing next request for bucket");
 							bucket.RemainingInternal = 1;
 						}
 
 						if (delay < TimeSpan.Zero)
 							delay = TimeSpan.FromMilliseconds(100);
 
 						this._logger.LogWarning(LoggerEvents.RatelimitPreemptive, "Pre-emptive ratelimit triggered - waiting until {0:yyyy-MM-dd HH:mm:ss zzz} ({1:c}).", resetDate, delay);
 						Task.Delay(delay)
 							.ContinueWith(_ => this.ExecuteRequestAsync(request, null, null))
 							.LogTaskFault(this._logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 
 						return;
 					}
 					this._logger.LogDebug(LoggerEvents.RatelimitDiag, "Request for {0} is allowed", bucket.ToString());
 				}
 				else
 					this._logger.LogDebug(LoggerEvents.RatelimitDiag, "Initial request for {0} is allowed", bucket.ToString());
 
 				var req = this.BuildRequest(request);
 
 				if (this.Debug)
 					this._logger.LogTrace(LoggerEvents.Misc, await req.Content.ReadAsStringAsync());
 
 				var response = new RestResponse();
 				try
 				{
 					if (this._disposed)
 						return;
 
 					res = await this.HttpClient.SendAsync(req, HttpCompletionOption.ResponseContentRead, CancellationToken.None).ConfigureAwait(false);
 
 					var bts = await res.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
 					var txt = Utilities.UTF8.GetString(bts, 0, bts.Length);
 
 					this._logger.LogTrace(LoggerEvents.RestRx, txt);
 
 					response.Headers = res.Headers.ToDictionary(xh => xh.Key, xh => string.Join("\n", xh.Value), StringComparer.OrdinalIgnoreCase);
 					response.Response = txt;
 					response.ResponseCode = (int)res.StatusCode;
 				}
 				catch (HttpRequestException httpex)
 				{
 					this._logger.LogError(LoggerEvents.RestError, httpex, "Request to {0} triggered an HttpException", request.Url);
 					request.SetFaulted(httpex);
 					this.FailInitialRateLimitTest(request, ratelimitTcs);
 					return;
 				}
 
 				this.UpdateBucket(request, response, ratelimitTcs);
 
 				Exception ex = null;
 				switch (response.ResponseCode)
 				{
 					case 400:
 					case 405:
 						ex = new BadRequestException(request, response);
 						break;
 
 					case 401:
 					case 403:
 						ex = new UnauthorizedException(request, response);
 						break;
 
 					case 404:
 						ex = new NotFoundException(request, response);
 						break;
 
 					case 413:
 						ex = new RequestSizeException(request, response);
 						break;
 
 					case 429:
 						ex = new RateLimitException(request, response);
 
 						// check the limit info and requeue
 						this.Handle429(response, out var wait, out var global);
 						if (wait != null)
 						{
 							if (global)
 							{
 								bucket.IsGlobal = true;
 								this._logger.LogError(LoggerEvents.RatelimitHit, "Global ratelimit hit, cooling down");
 								try
 								{
 									this._globalRateLimitEvent.Reset();
 									await wait.ConfigureAwait(false);
 								}
 								finally
 								{
 									// we don't want to wait here until all the blocked requests have been run, additionally Set can never throw an exception that could be suppressed here
 									_ = this._globalRateLimitEvent.SetAsync();
 								}
 								this.ExecuteRequestAsync(request, bucket, ratelimitTcs)
 									.LogTaskFault(this._logger, LogLevel.Error, LoggerEvents.RestError, "Error while retrying request");
 							}
 							else
 							{
 								this._logger.LogError(LoggerEvents.RatelimitHit, "Ratelimit hit, requeueing request to {0}", request.Url);
 								await wait.ConfigureAwait(false);
 								this.ExecuteRequestAsync(request, bucket, ratelimitTcs)
 									.LogTaskFault(this._logger, LogLevel.Error, LoggerEvents.RestError, "Error while retrying request");
 							}
 
 							return;
 						}
 						break;
 
 					case 500:
 					case 502:
 					case 503:
 					case 504:
 						ex = new ServerErrorException(request, response);
 						break;
 				}
 
 				if (ex != null)
 					request.SetFaulted(ex);
 				else
 					request.SetCompleted(response);
 			}
 			catch (Exception ex)
 			{
 				this._logger.LogError(LoggerEvents.RestError, ex, "Request to {0} triggered an exception", request.Url);
 
 				// if something went wrong and we couldn't get rate limits for the first request here, allow the next request to run
 				if (bucket != null && ratelimitTcs != null && bucket.LimitTesting != 0)
 					this.FailInitialRateLimitTest(request, ratelimitTcs);
 
 				if (!request.TrySetFaulted(ex))
 					throw;
 			}
 			finally
 			{
 				res?.Dispose();
 
 				// Get and decrement active requests in this bucket by 1.
 				_ = this._requestQueue.TryGetValue(bucket.BucketId, out var count);
 				this._requestQueue[bucket.BucketId] = Interlocked.Decrement(ref count);
 
 				// If it's 0 or less, we can remove the bucket from the active request queue,
 				// along with any of its past routes.
 				if (count <= 0)
 				{
 					foreach (var r in bucket.RouteHashes)
 					{
 						if (this._requestQueue.ContainsKey(r))
 						{
 							_ = this._requestQueue.TryRemove(r, out _);
 						}
 					}
 				}
 			}
 		}
 
 		/// <summary>
 		/// Fails the initial rate limit test.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		/// <param name="ratelimitTcs">The ratelimit task completion source.</param>
 		/// <param name="resetToInitial">If true, reset to initial.</param>
 		private void FailInitialRateLimitTest(BaseRestRequest request, TaskCompletionSource<bool> ratelimitTcs, bool resetToInitial = false)
 		{
 			if (ratelimitTcs == null && !resetToInitial)
 				return;
 
 			var bucket = request.RateLimitBucket;
 
 			bucket.LimitValid = false;
 			bucket.LimitTestFinished = null;
 			bucket.LimitTesting = 0;
 
 			//Reset to initial values.
 			if (resetToInitial)
 			{
 				this.UpdateHashCaches(request, bucket);
 				bucket.Maximum = 0;
 				bucket.RemainingInternal = 0;
 				return;
 			}
 
 			// no need to wait on all the potentially waiting tasks
 			_ = Task.Run(() => ratelimitTcs.TrySetResult(false));
 		}
 
 		/// <summary>
 		/// Waits for the initial rate limit.
 		/// </summary>
 		/// <param name="bucket">The bucket.</param>
 		private async Task<TaskCompletionSource<bool>> WaitForInitialRateLimit(RateLimitBucket bucket)
 		{
 			while (!bucket.LimitValid)
 			{
 				if (bucket.LimitTesting == 0)
 				{
 					if (Interlocked.CompareExchange(ref bucket.LimitTesting, 1, 0) == 0)
 					{
 						// if we got here when the first request was just finishing, we must not create the waiter task as it would signel ExecureRequestAsync to bypass rate limiting
 						if (bucket.LimitValid)
 							return null;
 
 						// allow exactly one request to go through without having rate limits available
 						var ratelimitsTcs = new TaskCompletionSource<bool>();
 						bucket.LimitTestFinished = ratelimitsTcs.Task;
 						return ratelimitsTcs;
 					}
 				}
 				// it can take a couple of cycles for the task to be allocated, so wait until it happens or we are no longer probing for the limits
 				Task waitTask = null;
 				while (bucket.LimitTesting != 0 && (waitTask = bucket.LimitTestFinished) == null)
 					await Task.Yield();
 				if (waitTask != null)
 					await waitTask.ConfigureAwait(false);
 
 				// if the request failed and the response did not have rate limit headers we have allow the next request and wait again, thus this is a loop here
 			}
 			return null;
 		}
 
 		/// <summary>
 		/// Builds the request.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		/// <returns>A http request message.</returns>
 		private HttpRequestMessage BuildRequest(BaseRestRequest request)
 		{
 			var req = new HttpRequestMessage(new HttpMethod(request.Method.ToString()), request.Url);
 			if (request.Headers != null && request.Headers.Any())
 				foreach (var kvp in request.Headers)
 					req.Headers.Add(kvp.Key, kvp.Value);
 
 			if (request is RestRequest nmprequest && !string.IsNullOrWhiteSpace(nmprequest.Payload))
 			{
 				this._logger.LogTrace(LoggerEvents.RestTx, nmprequest.Payload);
 
 				req.Content = new StringContent(nmprequest.Payload);
 				req.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
 			}
 
 			if (request is MultipartWebRequest mprequest)
 			{
 				this._logger.LogTrace(LoggerEvents.RestTx, "<multipart request>");
 
 				var boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x");
 
 				req.Headers.Add("Connection", "keep-alive");
 				req.Headers.Add("Keep-Alive", "600");
 
 				var content = new MultipartFormDataContent(boundary);
 				if (mprequest.Values != null && mprequest.Values.Any())
 					foreach (var kvp in mprequest.Values)
 						content.Add(new StringContent(kvp.Value), kvp.Key);
 
 				var fileId = mprequest.OverwriteFileIdStart ?? 0;
 
 				if (mprequest.Files != null && mprequest.Files.Any())
 				{
 					foreach (var f in mprequest.Files)
 					{
 						var name = $"files[{fileId.ToString(CultureInfo.InvariantCulture)}]";
 						content.Add(new StreamContent(f.Value), name, f.Key);
 						fileId++;
 					}
 				}
 
 				req.Content = content;
 			}
 
 			if (request is MultipartStickerWebRequest mpsrequest)
 			{
 				this._logger.LogTrace(LoggerEvents.RestTx, "<multipart request>");
 
 				var boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x");
 
 				req.Headers.Add("Connection", "keep-alive");
 				req.Headers.Add("Keep-Alive", "600");
 
 				var sc = new StreamContent(mpsrequest.File.Stream);
 
 				if (mpsrequest.File.ContentType != null)
 					sc.Headers.ContentType = new MediaTypeHeaderValue(mpsrequest.File.ContentType);
 
 				var fileName = mpsrequest.File.FileName;
 
 				if (mpsrequest.File.FileType != null)
 					fileName += '.' + mpsrequest.File.FileType;
 
 				var content = new MultipartFormDataContent(boundary)
 				{
 					{ new StringContent(mpsrequest.Name), "name" },
 					{ new StringContent(mpsrequest.Tags), "tags" },
 					{ new StringContent(mpsrequest.Description), "description" },
 					{ sc, "file", fileName }
 				};
 
 				req.Content = content;
 			}
 			return req;
 		}
 
 		/// <summary>
 		/// Handles the http 429 status.
 		/// </summary>
 		/// <param name="response">The response.</param>
 		/// <param name="waitTask">The wait task.</param>
 		/// <param name="global">If true, global.</param>
 		private void Handle429(RestResponse response, out Task waitTask, out bool global)
 		{
 			waitTask = null;
 			global = false;
 
 			if (response.Headers == null)
 				return;
 			var hs = response.Headers;
 
 			// handle the wait
 			if (hs.TryGetValue("Retry-After", out var retryAfterRaw))
 			{
 				var retryAfter = TimeSpan.FromSeconds(int.Parse(retryAfterRaw, CultureInfo.InvariantCulture));
 				waitTask = Task.Delay(retryAfter);
 			}
 
 			// check if global b1nzy
 			if (hs.TryGetValue("X-RateLimit-Global", out var isglobal) && isglobal.ToLowerInvariant() == "true")
 			{
 				// global
 				global = true;
 			}
 		}
 
 		/// <summary>
 		/// Updates the bucket.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		/// <param name="response">The response.</param>
 		/// <param name="ratelimitTcs">The ratelimit task completion source.</param>
 		private void UpdateBucket(BaseRestRequest request, RestResponse response, TaskCompletionSource<bool> ratelimitTcs)
 		{
 			var bucket = request.RateLimitBucket;
 
 			if (response.Headers == null)
 			{
 				if (response.ResponseCode != 429) // do not fail when ratelimit was or the next request will be scheduled hitting the rate limit again
 					this.FailInitialRateLimitTest(request, ratelimitTcs);
 				return;
 			}
 
 			var hs = response.Headers;
 
 			if (hs.TryGetValue("X-RateLimit-Scope", out var scope))
 			{
 				bucket.Scope = scope;
 			}
 
 
 			if (hs.TryGetValue("X-RateLimit-Global", out var isglobal) && isglobal.ToLowerInvariant() == "true")
 			{
 				if (response.ResponseCode != 429)
 				{
 					bucket.IsGlobal = true;
 					this.FailInitialRateLimitTest(request, ratelimitTcs);
 				}
 
 				return;
 			}
 
 			var r1 = hs.TryGetValue("X-RateLimit-Limit", out var usesmax);
 			var r2 = hs.TryGetValue("X-RateLimit-Remaining", out var usesleft);
 			var r3 = hs.TryGetValue("X-RateLimit-Reset", out var reset);
 			var r4 = hs.TryGetValue("X-Ratelimit-Reset-After", out var resetAfter);
 			var r5 = hs.TryGetValue("X-Ratelimit-Bucket", out var hash);
 
 			if (!r1 || !r2 || !r3 || !r4)
 			{
 				//If the limits were determined before this request, make the bucket initial again.
 				if (response.ResponseCode != 429)
 					this.FailInitialRateLimitTest(request, ratelimitTcs, ratelimitTcs == null);
 
 				return;
 			}
 
 			var clienttime = DateTimeOffset.UtcNow;
 			var resettime = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).AddSeconds(double.Parse(reset, CultureInfo.InvariantCulture));
 			var servertime = clienttime;
 			if (hs.TryGetValue("Date", out var rawDate))
 				servertime = DateTimeOffset.Parse(rawDate, CultureInfo.InvariantCulture).ToUniversalTime();
 
 			var resetdelta = resettime - servertime;
 			//var difference = clienttime - servertime;
 			//if (Math.Abs(difference.TotalSeconds) >= 1)
 			////    this.Logger.LogMessage(LogLevel.DebugBaseDiscordClient.RestEventId,  $"Difference between machine and server time: {difference.TotalMilliseconds.ToString("#,##0.00", CultureInfo.InvariantCulture)}ms", DateTime.Now);
 			//else
 			//    difference = TimeSpan.Zero;
 
 			if (request.RateLimitWaitOverride.HasValue)
 				resetdelta = TimeSpan.FromSeconds(request.RateLimitWaitOverride.Value);
 			var newReset = clienttime + resetdelta;
 
 			if (this._useResetAfter)
 			{
 				bucket.ResetAfter = TimeSpan.FromSeconds(double.Parse(resetAfter, CultureInfo.InvariantCulture));
 				newReset = clienttime + bucket.ResetAfter.Value + (request.RateLimitWaitOverride.HasValue
 					? resetdelta
 					: TimeSpan.Zero);
 				bucket.ResetAfterOffset = newReset;
 			}
 			else
 				bucket.Reset = newReset;
 
 			var maximum = int.Parse(usesmax, CultureInfo.InvariantCulture);
 			var remaining = int.Parse(usesleft, CultureInfo.InvariantCulture);
 
 			if (ratelimitTcs != null)
 			{
 				// initial population of the ratelimit data
 				bucket.SetInitialValues(maximum, remaining, newReset);
 
 				_ = Task.Run(() => ratelimitTcs.TrySetResult(true));
 			}
 			else
 			{
 				// only update the bucket values if this request was for a newer interval than the one
 				// currently in the bucket, to avoid issues with concurrent requests in one bucket
 				// remaining is reset by TryResetLimit and not the response, just allow that to happen when it is time
 				if (bucket.NextReset == 0)
 					bucket.NextReset = newReset.UtcTicks;
 			}
 
 			this.UpdateHashCaches(request, bucket, hash);
 		}
 
 		/// <summary>
 		/// Updates the hash caches.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		/// <param name="bucket">The bucket.</param>
 		/// <param name="newHash">The new hash.</param>
 		private void UpdateHashCaches(BaseRestRequest request, RateLimitBucket bucket, string newHash = null)
 		{
 			var hashKey = RateLimitBucket.GenerateHashKey(request.Method, request.Route);
 
 			if (!this._routesToHashes.TryGetValue(hashKey, out var oldHash))
 				return;
 
 			// This is an unlimited bucket, which we don't need to keep track of.
 			if (newHash == null)
 			{
 				_ = this._routesToHashes.TryRemove(hashKey, out _);
 				_ = this._hashesToBuckets.TryRemove(bucket.BucketId, out _);
 				return;
 			}
 
 			// Only update the hash once, due to a bug on Discord's end.
 			// This will cause issues if the bucket hashes are dynamically changed from the API while running,
 			// in which case, Dispose will need to be called to clear the caches.
 			if (bucket.IsUnlimited && newHash != oldHash)
 			{
 				this._logger.LogDebug(LoggerEvents.RestHashMover, "Updating hash in {0}: \"{1}\" -> \"{2}\"", hashKey, oldHash, newHash);
 				var bucketId = RateLimitBucket.GenerateBucketId(newHash, bucket.GuildId, bucket.ChannelId, bucket.WebhookId);
 
 				_ = this._routesToHashes.AddOrUpdate(hashKey, newHash, (key, oldHash) =>
 				{
 					bucket.Hash = newHash;
 
 					var oldBucketId = RateLimitBucket.GenerateBucketId(oldHash, bucket.GuildId, bucket.ChannelId, bucket.WebhookId);
 
 					// Remove the old unlimited bucket.
 					_ = this._hashesToBuckets.TryRemove(oldBucketId, out _);
 					_ = this._hashesToBuckets.AddOrUpdate(bucketId, bucket, (key, oldBucket) => bucket);
 
 					return newHash;
 				});
 			}
 
 			return;
 		}
 
 		/// <summary>
 		/// Cleanups the buckets.
 		/// </summary>
 		private async Task CleanupBucketsAsync()
 		{
 			while (!this._bucketCleanerTokenSource.IsCancellationRequested)
 			{
 				try
 				{
 					await Task.Delay(this._bucketCleanupDelay, this._bucketCleanerTokenSource.Token).ConfigureAwait(false);
 				}
 				catch { }
 
 				if (this._disposed)
 					return;
 
 				//Check and clean request queue first in case it wasn't removed properly during requests.
 				foreach (var key in this._requestQueue.Keys)
 				{
 					var bucket = this._hashesToBuckets.Values.FirstOrDefault(x => x.RouteHashes.Contains(key));
 
 					if (bucket == null || (bucket != null && bucket.LastAttemptAt.AddSeconds(5) < DateTimeOffset.UtcNow))
 						_ = this._requestQueue.TryRemove(key, out _);
 				}
 
 				var removedBuckets = 0;
 				StringBuilder bucketIdStrBuilder = default;
 
 				foreach (var kvp in this._hashesToBuckets)
 				{
 					if (bucketIdStrBuilder == null)
 						bucketIdStrBuilder = new StringBuilder();
 
 					var key = kvp.Key;
 					var value = kvp.Value;
 
 					// Don't remove the bucket if it's currently being handled by the rest client, unless it's an unlimited bucket.
 					if (this._requestQueue.ContainsKey(value.BucketId) && !value.IsUnlimited)
 						continue;
 
 					var resetOffset = this._useResetAfter ? value.ResetAfterOffset : value.Reset;
 
 					// Don't remove the bucket if it's reset date is less than now + the additional wait time, unless it's an unlimited bucket.
 					if (resetOffset != null && !value.IsUnlimited && (resetOffset > DateTimeOffset.UtcNow || DateTimeOffset.UtcNow - resetOffset < this._bucketCleanupDelay))
 						continue;
 
 					_ = this._hashesToBuckets.TryRemove(key, out _);
 					removedBuckets++;
 					bucketIdStrBuilder.Append(value.BucketId + ", ");
 				}
 
 				if (removedBuckets > 0)
 					this._logger.LogDebug(LoggerEvents.RestCleaner, "Removed {0} unused bucket{1}: [{2}]", removedBuckets, removedBuckets > 1 ? "s" : string.Empty, bucketIdStrBuilder.ToString().TrimEnd(',', ' '));
 
 				if (this._hashesToBuckets.Count == 0)
 					break;
 			}
 
 			if (!this._bucketCleanerTokenSource.IsCancellationRequested)
 				this._bucketCleanerTokenSource.Cancel();
 
 			this._cleanerRunning = false;
 			this._logger.LogDebug(LoggerEvents.RestCleaner, "Bucket cleaner task stopped.");
 		}
 
 		~RestClient()
-			=> this.Dispose();
+		{
+			this.Dispose();
+		}
 
 		/// <summary>
 		/// Disposes the rest client.
 		/// </summary>
 		public void Dispose()
 		{
 			if (this._disposed)
 				return;
 
 			this._disposed = true;
 
 			this._globalRateLimitEvent.Reset();
 
 			if (this._bucketCleanerTokenSource?.IsCancellationRequested == false)
 			{
 				this._bucketCleanerTokenSource?.Cancel();
 				this._logger.LogDebug(LoggerEvents.RestCleaner, "Bucket cleaner task stopped.");
 			}
 
 			try
 			{
 				this._cleanerTask?.Dispose();
 				this._bucketCleanerTokenSource?.Dispose();
 				this.HttpClient?.Dispose();
 			}
 			catch { }
 
 			this._routesToHashes.Clear();
 			this._hashesToBuckets.Clear();
 			this._requestQueue.Clear();
 		}
 	}
 }
diff --git a/DisCatSharp/Net/WebSocket/WebSocketClient.cs b/DisCatSharp/Net/WebSocket/WebSocketClient.cs
index 42a443829..3983fb52d 100644
--- a/DisCatSharp/Net/WebSocket/WebSocketClient.cs
+++ b/DisCatSharp/Net/WebSocket/WebSocketClient.cs
@@ -1,415 +1,415 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.IO;
 using System.Net;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.EventArgs;
 
 namespace DisCatSharp.Net.WebSocket
 {
 	// weebsocket
 	// not even sure whether emzi or I posted this. much love, naam.
 	/// <summary>
 	/// The default, native-based WebSocket client implementation.
 	/// </summary>
 	public class WebSocketClient : IWebSocketClient
 	{
 		/// <summary>
 		/// The outgoing chunk size.
 		/// </summary>
 		private const int OUTGOING_CHUNK_SIZE = 8192; // 8 KiB
 
 		/// <summary>
 		/// The incoming chunk size.
 		/// </summary>
 		private const int INCOMING_CHUNK_SIZE = 32768; // 32 KiB
 
 		/// <summary>
 		/// Gets the proxy settings for this client.
 		/// </summary>
 		public IWebProxy Proxy { get; }
 
 		/// <summary>
 		/// Gets the collection of default headers to send when connecting to the remote endpoint.
 		/// </summary>
 		public IReadOnlyDictionary<string, string> DefaultHeaders { get; }
 
 		/// <summary>
 		/// Gets or sets the service provider.
 		/// </summary>
 		IServiceProvider IWebSocketClient.ServiceProvider
 		{
 			get => this._serviceProvider;
 			set => this._serviceProvider = value;
 		}
 
 		private readonly Dictionary<string, string> _defaultHeaders;
 
 		private Task _receiverTask;
 		private CancellationTokenSource _receiverTokenSource;
 		private CancellationToken _receiverToken;
 		private readonly SemaphoreSlim _senderLock;
 
 		private CancellationTokenSource _socketTokenSource;
 		private CancellationToken _socketToken;
 		private ClientWebSocket _ws;
 
-		private volatile bool _isClientClose = false;
-		private volatile bool _isConnected = false;
-		private bool _isDisposed = false;
+		private volatile bool _isClientClose;
+		private volatile bool _isConnected;
+		private bool _isDisposed;
 
 		/// <summary>
 		/// Instantiates a new WebSocket client with specified proxy settings.
 		/// </summary>
 		/// <param name="proxy">Proxy settings for the client.</param>
 		/// <param name="provider">Service provider.</param>
 		private WebSocketClient(IWebProxy proxy, IServiceProvider provider)
 		{
 			this._connected = new AsyncEvent<WebSocketClient, SocketEventArgs>("WS_CONNECT", TimeSpan.Zero, this.EventErrorHandler);
 			this._disconnected = new AsyncEvent<WebSocketClient, SocketCloseEventArgs>("WS_DISCONNECT", TimeSpan.Zero, this.EventErrorHandler);
 			this._messageReceived = new AsyncEvent<WebSocketClient, SocketMessageEventArgs>("WS_MESSAGE", TimeSpan.Zero, this.EventErrorHandler);
 			this._exceptionThrown = new AsyncEvent<WebSocketClient, SocketErrorEventArgs>("WS_ERROR", TimeSpan.Zero, null);
 
 			this.Proxy = proxy;
 			this._defaultHeaders = new Dictionary<string, string>();
 			this.DefaultHeaders = new ReadOnlyDictionary<string, string>(this._defaultHeaders);
 
 			this._receiverTokenSource = null;
 			this._receiverToken = CancellationToken.None;
 			this._senderLock = new SemaphoreSlim(1);
 
 			this._socketTokenSource = null;
 			this._socketToken = CancellationToken.None;
 
 			this._serviceProvider = provider;
 		}
 
 		/// <summary>
 		/// Connects to a specified remote WebSocket endpoint.
 		/// </summary>
 		/// <param name="uri">The URI of the WebSocket endpoint.</param>
 		public async Task ConnectAsync(Uri uri)
 		{
 			// Disconnect first
 			try { await this.DisconnectAsync().ConfigureAwait(false); } catch { }
 
 			// Disallow sending messages
 			await this._senderLock.WaitAsync().ConfigureAwait(false);
 
 			try
 			{
 				// This can be null at this point
 				this._receiverTokenSource?.Dispose();
 				this._socketTokenSource?.Dispose();
 
 				this._ws?.Dispose();
 				this._ws = new ClientWebSocket();
 				this._ws.Options.Proxy = this.Proxy;
 				this._ws.Options.KeepAliveInterval = TimeSpan.Zero;
 				if (this._defaultHeaders != null)
 					foreach (var (k, v) in this._defaultHeaders)
 						this._ws.Options.SetRequestHeader(k, v);
 
 				this._receiverTokenSource = new CancellationTokenSource();
 				this._receiverToken = this._receiverTokenSource.Token;
 
 				this._socketTokenSource = new CancellationTokenSource();
 				this._socketToken = this._socketTokenSource.Token;
 
 				this._isClientClose = false;
 				this._isDisposed = false;
 				await this._ws.ConnectAsync(uri, this._socketToken).ConfigureAwait(false);
 				this._receiverTask = Task.Run(this.ReceiverLoopAsync, this._receiverToken);
 			}
 			finally
 			{
 				this._senderLock.Release();
 			}
 		}
 
 		/// <summary>
 		/// Disconnects the WebSocket connection.
 		/// </summary>
 		/// <param name="code">The code</param>
 		/// <param name="message">The message</param>
 		/// <created>Lala Sabathil,06.07.2021</created>
 		/// <changed>Lala Sabathil,06.07.2021</changed>
 		public async Task DisconnectAsync(int code = 1000, string message = "")
 		{
 			// Ensure that messages cannot be sent
 			await this._senderLock.WaitAsync().ConfigureAwait(false);
 
 			try
 			{
 				this._isClientClose = true;
 				if (this._ws != null && (this._ws.State == WebSocketState.Open || this._ws.State == WebSocketState.CloseReceived))
 					await this._ws.CloseOutputAsync((WebSocketCloseStatus)code, message, CancellationToken.None).ConfigureAwait(false);
 
 				if (this._receiverTask != null)
 					await this._receiverTask.ConfigureAwait(false); // Ensure that receiving completed
 
 				if (this._isConnected)
 					this._isConnected = false;
 
 				if (!this._isDisposed)
 				{
 					// Cancel all running tasks
 					if (this._socketToken.CanBeCanceled)
 						this._socketTokenSource?.Cancel();
 					this._socketTokenSource?.Dispose();
 
 					if (this._receiverToken.CanBeCanceled)
 						this._receiverTokenSource?.Cancel();
 					this._receiverTokenSource?.Dispose();
 
 					this._isDisposed = true;
 				}
 			}
 			catch { }
 			finally
 			{
 				this._senderLock.Release();
 			}
 		}
 
 		/// <summary>
 		/// Send a message to the WebSocket server.
 		/// </summary>
 		/// <param name="message">The message to send.</param>
 		public async Task SendMessageAsync(string message)
 		{
 			if (this._ws == null)
 				return;
 
 			if (this._ws.State != WebSocketState.Open && this._ws.State != WebSocketState.CloseReceived)
 				return;
 
 			var bytes = Utilities.UTF8.GetBytes(message);
 			await this._senderLock.WaitAsync().ConfigureAwait(false);
 			try
 			{
 				var len = bytes.Length;
 				var segCount = len / OUTGOING_CHUNK_SIZE;
 				if (len % OUTGOING_CHUNK_SIZE != 0)
 					segCount++;
 
 				for (var i = 0; i < segCount; i++)
 				{
 					var segStart = OUTGOING_CHUNK_SIZE * i;
 					var segLen = Math.Min(OUTGOING_CHUNK_SIZE, len - segStart);
 
 					await this._ws.SendAsync(new ArraySegment<byte>(bytes, segStart, segLen), WebSocketMessageType.Text, i == segCount - 1, CancellationToken.None).ConfigureAwait(false);
 				}
 			}
 			finally
 			{
 				this._senderLock.Release();
 			}
 		}
 
 		/// <summary>
 		/// Adds a header to the default header collection.
 		/// </summary>
 		/// <param name="name">Name of the header to add.</param>
 		/// <param name="value">Value of the header to add.</param>
 		/// <returns>Whether the operation succeeded.</returns>
 		public bool AddDefaultHeader(string name, string value)
 		{
 			this._defaultHeaders[name] = value;
 			return true;
 		}
 
 		/// <summary>
 		/// Removes a header from the default header collection.
 		/// </summary>
 		/// <param name="name">Name of the header to remove.</param>
 		/// <returns>Whether the operation succeeded.</returns>
 		public bool RemoveDefaultHeader(string name)
 			=> this._defaultHeaders.Remove(name);
 
 		/// <summary>
 		/// Disposes of resources used by this WebSocket client instance.
 		/// </summary>
 		public void Dispose()
 		{
 			if (this._isDisposed)
 				return;
 
 			this._isDisposed = true;
 
 			this.DisconnectAsync().ConfigureAwait(false).GetAwaiter().GetResult();
 
 			this._receiverTokenSource?.Dispose();
 			this._socketTokenSource?.Dispose();
 		}
 
 		/// <summary>
 		/// Receivers the loop.
 		/// </summary>
 		internal async Task ReceiverLoopAsync()
 		{
 			await Task.Yield();
 
 			var token = this._receiverToken;
 			var buffer = new ArraySegment<byte>(new byte[INCOMING_CHUNK_SIZE]);
 
 			try
 			{
 				using var bs = new MemoryStream();
 				while (!token.IsCancellationRequested)
 				{
 					// See https://github.com/RogueException/Discord.Net/commit/ac389f5f6823e3a720aedd81b7805adbdd78b66d
 					// for explanation on the cancellation token
 
 					WebSocketReceiveResult result;
 					byte[] resultBytes;
 					do
 					{
 						result = await this._ws.ReceiveAsync(buffer, CancellationToken.None).ConfigureAwait(false);
 
 						if (result.MessageType == WebSocketMessageType.Close)
 							break;
 
 						bs.Write(buffer.Array, 0, result.Count);
 					}
 					while (!result.EndOfMessage);
 
 					resultBytes = new byte[bs.Length];
 					bs.Position = 0;
 					bs.Read(resultBytes, 0, resultBytes.Length);
 					bs.Position = 0;
 					bs.SetLength(0);
 
 					if (!this._isConnected && result.MessageType != WebSocketMessageType.Close)
 					{
 						this._isConnected = true;
 						await this._connected.InvokeAsync(this, new SocketEventArgs(this._serviceProvider)).ConfigureAwait(false);
 					}
 
 					if (result.MessageType == WebSocketMessageType.Binary)
 					{
 						await this._messageReceived.InvokeAsync(this, new SocketBinaryMessageEventArgs(resultBytes)).ConfigureAwait(false);
 					}
 					else if (result.MessageType == WebSocketMessageType.Text)
 					{
 						await this._messageReceived.InvokeAsync(this, new SocketTextMessageEventArgs(Utilities.UTF8.GetString(resultBytes))).ConfigureAwait(false);
 					}
 					else // close
 					{
 						if (!this._isClientClose)
 						{
 							var code = result.CloseStatus.Value;
 							code = code == WebSocketCloseStatus.NormalClosure || code == WebSocketCloseStatus.EndpointUnavailable
 								? (WebSocketCloseStatus)4000
 								: code;
 
 							await this._ws.CloseOutputAsync(code, result.CloseStatusDescription, CancellationToken.None).ConfigureAwait(false);
 						}
 
 						await this._disconnected.InvokeAsync(this, new SocketCloseEventArgs(this._serviceProvider) { CloseCode = (int)result.CloseStatus, CloseMessage = result.CloseStatusDescription }).ConfigureAwait(false);
 						break;
 					}
 				}
 			}
 			catch (Exception ex)
 			{
 				await this._exceptionThrown.InvokeAsync(this, new SocketErrorEventArgs(this._serviceProvider) { Exception = ex }).ConfigureAwait(false);
 				await this._disconnected.InvokeAsync(this, new SocketCloseEventArgs(this._serviceProvider) { CloseCode = -1, CloseMessage = "" }).ConfigureAwait(false);
 			}
 
 			// Don't await or you deadlock
 			// DisconnectAsync waits for this method
 			_ = this.DisconnectAsync().ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Creates a new instance of <see cref="WebSocketClient"/>.
 		/// </summary>
 		/// <param name="proxy">Proxy to use for this client instance.</param>
 		/// <param name="provider">Service provider.</param>
 		/// <returns>An instance of <see cref="WebSocketClient"/>.</returns>
 		public static IWebSocketClient CreateNew(IWebProxy proxy, IServiceProvider provider)
 			=> new WebSocketClient(proxy, provider);
 
 		#region Events
 		/// <summary>
 		/// Triggered when the client connects successfully.
 		/// </summary>
 		public event AsyncEventHandler<IWebSocketClient, SocketEventArgs> Connected
 		{
 			add => this._connected.Register(value);
 			remove => this._connected.Unregister(value);
 		}
 		private readonly AsyncEvent<WebSocketClient, SocketEventArgs> _connected;
 
 		/// <summary>
 		/// Triggered when the client is disconnected.
 		/// </summary>
 		public event AsyncEventHandler<IWebSocketClient, SocketCloseEventArgs> Disconnected
 		{
 			add => this._disconnected.Register(value);
 			remove => this._disconnected.Unregister(value);
 		}
 		private readonly AsyncEvent<WebSocketClient, SocketCloseEventArgs> _disconnected;
 
 		/// <summary>
 		/// Triggered when the client receives a message from the remote party.
 		/// </summary>
 		public event AsyncEventHandler<IWebSocketClient, SocketMessageEventArgs> MessageReceived
 		{
 			add => this._messageReceived.Register(value);
 			remove => this._messageReceived.Unregister(value);
 		}
 		private readonly AsyncEvent<WebSocketClient, SocketMessageEventArgs> _messageReceived;
 
 		/// <summary>
 		/// Triggered when an error occurs in the client.
 		/// </summary>
 		public event AsyncEventHandler<IWebSocketClient, SocketErrorEventArgs> ExceptionThrown
 		{
 			add => this._exceptionThrown.Register(value);
 			remove => this._exceptionThrown.Unregister(value);
 		}
 		private readonly AsyncEvent<WebSocketClient, SocketErrorEventArgs> _exceptionThrown;
 		private IServiceProvider _serviceProvider;
 
 		/// <summary>
 		/// Events the error handler.
 		/// </summary>
 		/// <param name="asyncEvent">The event.</param>
 		/// <param name="ex">The exeption.</param>
 		/// <param name="handler">The handler.</param>
 		/// <param name="sender">The sender.</param>
 		/// <param name="eventArgs">The event args.</param>
 		private void EventErrorHandler<TArgs>(AsyncEvent<WebSocketClient, TArgs> asyncEvent, Exception ex, AsyncEventHandler<WebSocketClient, TArgs> handler, WebSocketClient sender, TArgs eventArgs)
 			where TArgs : AsyncEventArgs
 			=> this._exceptionThrown.InvokeAsync(this, new SocketErrorEventArgs(this._serviceProvider) { Exception = ex }).ConfigureAwait(false).GetAwaiter().GetResult();
 		#endregion
 	}
 }
diff --git a/DisCatSharp/QueryUriBuilder.cs b/DisCatSharp/QueryUriBuilder.cs
index 7a242345f..b6bde9f0d 100644
--- a/DisCatSharp/QueryUriBuilder.cs
+++ b/DisCatSharp/QueryUriBuilder.cs
@@ -1,96 +1,94 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Represents a query uri builder.
 	/// </summary>
 	internal class QueryUriBuilder
 	{
 		/// <summary>
 		/// Gets the source uri.
 		/// </summary>
 		public Uri SourceUri { get; }
 
 		/// <summary>
 		/// Gets the query parameters.
 		/// </summary>
 		public IReadOnlyList<KeyValuePair<string, string>> QueryParameters => this._queryParams;
 		private readonly List<KeyValuePair<string, string>> _queryParams = new();
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="QueryUriBuilder"/> class.
 		/// </summary>
 		/// <param name="uri">The uri.</param>
 		public QueryUriBuilder(string uri)
 		{
 			if (uri == null)
 				throw new ArgumentNullException(nameof(uri));
 
 			this.SourceUri = new Uri(uri);
 		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="QueryUriBuilder"/> class.
 		/// </summary>
 		/// <param name="uri">The uri.</param>
 		public QueryUriBuilder(Uri uri)
 		{
 			if (uri == null)
 				throw new ArgumentNullException(nameof(uri));
 
 			this.SourceUri = uri;
 		}
 
 		/// <summary>
 		/// Adds a parameter.
 		/// </summary>
 		/// <param name="key">The key to be added.</param>
 		/// <param name="value">The value to be added.</param>
 		public QueryUriBuilder AddParameter(string key, string value)
 		{
 			this._queryParams.Add(new KeyValuePair<string, string>(key, value));
 			return this;
 		}
 
 		/// <summary>
 		/// Builds the uri.
 		/// </summary>
-		public Uri Build()
-		{
-			return new UriBuilder(this.SourceUri)
+		public Uri Build() =>
+			new UriBuilder(this.SourceUri)
 			{
 				Query = string.Join("&", this._queryParams.Select(e => Uri.EscapeDataString(e.Key) + '=' + Uri.EscapeDataString(e.Value)))
 			}.Uri;
-		}
 
 		/// <summary>
 		/// Returns a readable string.
 		/// </summary>
 		public override string ToString() => this.Build().ToString();
 	}
 }
diff --git a/DisCatSharp/RingBuffer.cs b/DisCatSharp/RingBuffer.cs
index 1e042083a..553edcc5f 100644
--- a/DisCatSharp/RingBuffer.cs
+++ b/DisCatSharp/RingBuffer.cs
@@ -1,241 +1,239 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// A circular buffer collection.
 	/// </summary>
 	/// <typeparam name="T">Type of elements within this ring buffer.</typeparam>
 	public class RingBuffer<T> : ICollection<T>
 	{
 		/// <summary>
 		/// Gets the current index of the buffer items.
 		/// </summary>
 		public int CurrentIndex { get; protected set; }
 
 		/// <summary>
 		/// Gets the capacity of this ring buffer.
 		/// </summary>
 		public int Capacity { get; protected set; }
 
 		/// <summary>
 		/// Gets the number of items in this ring buffer.
 		/// </summary>
 		public int Count
 			=> this._reachedEnd ? this.Capacity : this.CurrentIndex;
 
 		/// <summary>
 		/// Gets whether this ring buffer is read-only.
 		/// </summary>
 		public bool IsReadOnly
 			=> false;
 
 		/// <summary>
 		/// Gets or sets the internal collection of items.
 		/// </summary>
 		protected T[] InternalBuffer { get; set; }
-		private bool _reachedEnd = false;
+		private bool _reachedEnd;
 
 		/// <summary>
 		/// Creates a new ring buffer with specified size.
 		/// </summary>
 		/// <param name="size">Size of the buffer to create.</param>
 		/// <exception cref="System.ArgumentOutOfRangeException" />
 		public RingBuffer(int size)
 		{
 			if (size <= 0)
 				throw new ArgumentOutOfRangeException(nameof(size), "Size must be positive.");
 
 			this.CurrentIndex = 0;
 			this.Capacity = size;
 			this.InternalBuffer = new T[this.Capacity];
 		}
 
 		/// <summary>
 		/// Creates a new ring buffer, filled with specified elements.
 		/// </summary>
 		/// <param name="elements">Elements to fill the buffer with.</param>
 		/// <exception cref="System.ArgumentException" />
 		/// <exception cref="System.ArgumentOutOfRangeException" />
 		public RingBuffer(IEnumerable<T> elements)
 			: this(elements, 0)
 		{ }
 
 		/// <summary>
 		/// Creates a new ring buffer, filled with specified elements, and starting at specified index.
 		/// </summary>
 		/// <param name="elements">Elements to fill the buffer with.</param>
 		/// <param name="index">Starting element index.</param>
 		/// <exception cref="System.ArgumentException" />
 		/// <exception cref="System.ArgumentOutOfRangeException" />
 		public RingBuffer(IEnumerable<T> elements, int index)
 		{
 			if (elements == null || !elements.Any())
 				throw new ArgumentException(nameof(elements), "The collection cannot be null or empty.");
 
 			this.CurrentIndex = index;
 			this.InternalBuffer = elements.ToArray();
 			this.Capacity = this.InternalBuffer.Length;
 
 			if (this.CurrentIndex >= this.InternalBuffer.Length || this.CurrentIndex < 0)
 				throw new ArgumentOutOfRangeException(nameof(index), "Index must be less than buffer capacity, and greater than zero.");
 		}
 
 		/// <summary>
 		/// Inserts an item into this ring buffer.
 		/// </summary>
 		/// <param name="item">Item to insert.</param>
 		public void Add(T item)
 		{
 			this.InternalBuffer[this.CurrentIndex++] = item;
 
 			if (this.CurrentIndex == this.Capacity)
 			{
 				this.CurrentIndex = 0;
 				this._reachedEnd = true;
 			}
 		}
 
 		/// <summary>
 		/// Gets first item from the buffer that matches the predicate.
 		/// </summary>
 		/// <param name="predicate">Predicate used to find the item.</param>
 		/// <param name="item">Item that matches the predicate, or default value for the type of the items in this ring buffer, if one is not found.</param>
 		/// <returns>Whether an item that matches the predicate was found or not.</returns>
 		public bool TryGet(Func<T, bool> predicate, out T item)
 		{
 			for (var i = this.CurrentIndex; i < this.InternalBuffer.Length; i++)
 			{
 				if (this.InternalBuffer[i] != null && predicate(this.InternalBuffer[i]))
 				{
 					item = this.InternalBuffer[i];
 					return true;
 				}
 			}
 			for (var i = 0; i < this.CurrentIndex; i++)
 			{
 				if (this.InternalBuffer[i] != null && predicate(this.InternalBuffer[i]))
 				{
 					item = this.InternalBuffer[i];
 					return true;
 				}
 			}
 
 			item = default;
 			return false;
 		}
 
 		/// <summary>
 		/// Clears this ring buffer and resets the current item index.
 		/// </summary>
 		public void Clear()
 		{
 			for (var i = 0; i < this.InternalBuffer.Length; i++)
 				this.InternalBuffer[i] = default;
 
 			this.CurrentIndex = 0;
 		}
 
 		/// <summary>
 		/// Checks whether given item is present in the buffer. This method is not implemented. Use <see cref="Contains(Func{T, bool})"/> instead.
 		/// </summary>
 		/// <param name="item">Item to check for.</param>
 		/// <returns>Whether the buffer contains the item.</returns>
 		/// <exception cref="System.NotImplementedException" />
 		public bool Contains(T item) => throw new NotImplementedException("This method is not implemented. Use .Contains(predicate) instead.");
 
 		/// <summary>
 		/// Checks whether given item is present in the buffer using given predicate to find it.
 		/// </summary>
 		/// <param name="predicate">Predicate used to check for the item.</param>
 		/// <returns>Whether the buffer contains the item.</returns>
 		public bool Contains(Func<T, bool> predicate) => this.InternalBuffer.Any(predicate);
 
 		/// <summary>
 		/// Copies this ring buffer to target array, attempting to maintain the order of items within.
 		/// </summary>
 		/// <param name="array">Target array.</param>
 		/// <param name="index">Index starting at which to copy the items to.</param>
 		public void CopyTo(T[] array, int index)
 		{
 			if (array.Length - index < 1)
 				throw new ArgumentException("Target array is too small to contain the elements from this buffer.", nameof(array));
 
 			var ci = 0;
 			for (var i = this.CurrentIndex; i < this.InternalBuffer.Length; i++)
 				array[ci++] = this.InternalBuffer[i];
 			for (var i = 0; i < this.CurrentIndex; i++)
 				array[ci++] = this.InternalBuffer[i];
 		}
 
 		/// <summary>
 		/// Removes an item from the buffer. This method is not implemented. Use <see cref="Remove(Func{T, bool})"/> instead.
 		/// </summary>
 		/// <param name="item">Item to remove.</param>
 		/// <returns>Whether an item was removed or not.</returns>
 		public bool Remove(T item) => throw new NotImplementedException("This method is not implemented. Use .Remove(predicate) instead.");
 
 		/// <summary>
 		/// Removes an item from the buffer using given predicate to find it.
 		/// </summary>
 		/// <param name="predicate">Predicate used to find the item.</param>
 		/// <returns>Whether an item was removed or not.</returns>
 		public bool Remove(Func<T, bool> predicate)
 		{
 			for (var i = 0; i < this.InternalBuffer.Length; i++)
 			{
 				if (this.InternalBuffer[i] != null && predicate(this.InternalBuffer[i]))
 				{
 					this.InternalBuffer[i] = default;
 					return true;
 				}
 			}
 
 			return false;
 		}
 
 		/// <summary>
 		/// Returns an enumerator for this ring buffer.
 		/// </summary>
 		/// <returns>Enumerator for this ring buffer.</returns>
-		public IEnumerator<T> GetEnumerator()
-		{
-			return !this._reachedEnd
+		public IEnumerator<T> GetEnumerator() =>
+			!this._reachedEnd
 				? this.InternalBuffer.AsEnumerable().GetEnumerator()
 				: this.InternalBuffer.Skip(this.CurrentIndex)
-				.Concat(this.InternalBuffer.Take(this.CurrentIndex))
-				.GetEnumerator();
-		}
+					.Concat(this.InternalBuffer.Take(this.CurrentIndex))
+					.GetEnumerator();
 
 		/// <summary>
 		/// Returns an enumerator for this ring buffer.
 		/// </summary>
 		/// <returns>Enumerator for this ring buffer.</returns>
 		IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
 	}
 }
diff --git a/DisCatSharp/Utilities.cs b/DisCatSharp/Utilities.cs
index c306ee1c1..7f6d515df 100644
--- a/DisCatSharp/Utilities.cs
+++ b/DisCatSharp/Utilities.cs
@@ -1,466 +1,462 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.Net;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// Various Discord-related utilities.
 	/// </summary>
 	public static class Utilities
 	{
 		/// <summary>
 		/// Gets the version of the library
 		/// </summary>
 		internal static string VersionHeader { get; set; }
 
 		/// <summary>
 		/// Gets or sets the permission strings.
 		/// </summary>
 		internal static Dictionary<Permissions, string> PermissionStrings { get; set; }
 
 		/// <summary>
 		/// Gets the utf8 encoding
 		/// </summary>
 		// ReSharper disable once InconsistentNaming
-		internal static UTF8Encoding UTF8 { get; } = new UTF8Encoding(false);
+		internal static UTF8Encoding UTF8 { get; } = new(false);
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="Utilities"/> class.
 		/// </summary>
 		static Utilities()
 		{
 			PermissionStrings = new Dictionary<Permissions, string>();
 			var t = typeof(Permissions);
 			var ti = t.GetTypeInfo();
 			var vals = Enum.GetValues(t).Cast<Permissions>();
 
 			foreach (var xv in vals)
 			{
 				var xsv = xv.ToString();
 				var xmv = ti.DeclaredMembers.FirstOrDefault(xm => xm.Name == xsv);
 				var xav = xmv.GetCustomAttribute<PermissionStringAttribute>();
 
 				PermissionStrings[xv] = xav.String;
 			}
 
 			var a = typeof(DiscordClient).GetTypeInfo().Assembly;
 
 			var vs = "";
 			var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
 			if (iv != null)
 				vs = iv.InformationalVersion;
 			else
 			{
 				var v = a.GetName().Version;
 				vs = v.ToString(3);
 			}
 
 			VersionHeader = $"DiscordBot (https://github.com/Aiko-IT-Systems/DisCatSharp, v{vs})";
 		}
 
 		/// <summary>
 		/// Gets the api base uri.
 		/// </summary>
 		/// <param name="config">The config</param>
 		/// <returns>A string.</returns>
 		internal static string GetApiBaseUri(DiscordConfiguration config = null)
 			=> config == null ? Endpoints.BASE_URI + "9" : config.UseCanary ? Endpoints.CANARY_URI + config.ApiVersion : Endpoints.BASE_URI + config.ApiVersion;
 
 		/// <summary>
 		/// Gets the api uri for.
 		/// </summary>
 		/// <param name="path">The path.</param>
 		/// <param name="config">The config</param>
 		/// <returns>An Uri.</returns>
 		internal static Uri GetApiUriFor(string path, DiscordConfiguration config)
 			=> new($"{GetApiBaseUri(config)}{path}");
 
 		/// <summary>
 		/// Gets the api uri for.
 		/// </summary>
 		/// <param name="path">The path.</param>
 		/// <param name="queryString">The query string.</param>
 		/// <param name="config">The config</param>
 		/// <returns>An Uri.</returns>
 		internal static Uri GetApiUriFor(string path, string queryString, DiscordConfiguration config)
 			=> new($"{GetApiBaseUri(config)}{path}{queryString}");
 
 		/// <summary>
 		/// Gets the api uri builder for.
 		/// </summary>
 		/// <param name="path">The path.</param>
 		/// <param name="config">The config</param>
 		/// <returns>A QueryUriBuilder.</returns>
 		internal static QueryUriBuilder GetApiUriBuilderFor(string path, DiscordConfiguration config)
 			=> new($"{GetApiBaseUri(config)}{path}");
 
 		/// <summary>
 		/// Gets the formatted token.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <returns>A string.</returns>
 		internal static string GetFormattedToken(BaseDiscordClient client) => GetFormattedToken(client.Configuration);
 
 		/// <summary>
 		/// Gets the formatted token.
 		/// </summary>
 		/// <param name="config">The config.</param>
 		/// <returns>A string.</returns>
-		internal static string GetFormattedToken(DiscordConfiguration config)
-		{
-			return config.TokenType switch
+		internal static string GetFormattedToken(DiscordConfiguration config) =>
+			config.TokenType switch
 			{
 				TokenType.Bearer => $"Bearer {config.Token}",
 				TokenType.Bot => $"Bot {config.Token}",
 				_ => throw new ArgumentException("Invalid token type specified.", nameof(config.Token)),
 			};
-		}
 
 		/// <summary>
 		/// Gets the base headers.
 		/// </summary>
 		/// <returns>A Dictionary.</returns>
 		internal static Dictionary<string, string> GetBaseHeaders()
 			=> new();
 
 		/// <summary>
 		/// Gets the user agent.
 		/// </summary>
 		/// <returns>A string.</returns>
 		internal static string GetUserAgent()
 			=> VersionHeader;
 
 		/// <summary>
 		/// Contains the user mentions.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <returns>A bool.</returns>
 		internal static bool ContainsUserMentions(string message)
 		{
 			var pattern = @"<@(\d+)>";
 			var regex = new Regex(pattern, RegexOptions.ECMAScript);
 			return regex.IsMatch(message);
 		}
 
 		/// <summary>
 		/// Contains the nickname mentions.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <returns>A bool.</returns>
 		internal static bool ContainsNicknameMentions(string message)
 		{
 			var pattern = @"<@!(\d+)>";
 			var regex = new Regex(pattern, RegexOptions.ECMAScript);
 			return regex.IsMatch(message);
 		}
 
 		/// <summary>
 		/// Contains the channel mentions.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <returns>A bool.</returns>
 		internal static bool ContainsChannelMentions(string message)
 		{
 			var pattern = @"<#(\d+)>";
 			var regex = new Regex(pattern, RegexOptions.ECMAScript);
 			return regex.IsMatch(message);
 		}
 
 		/// <summary>
 		/// Contains the role mentions.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <returns>A bool.</returns>
 		internal static bool ContainsRoleMentions(string message)
 		{
 			var pattern = @"<@&(\d+)>";
 			var regex = new Regex(pattern, RegexOptions.ECMAScript);
 			return regex.IsMatch(message);
 		}
 
 		/// <summary>
 		/// Contains the emojis.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <returns>A bool.</returns>
 		internal static bool ContainsEmojis(string message)
 		{
 			var pattern = @"<a?:(.*):(\d+)>";
 			var regex = new Regex(pattern, RegexOptions.ECMAScript);
 			return regex.IsMatch(message);
 		}
 
 		/// <summary>
 		/// Gets the user mentions.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <returns>A list of ulong.</returns>
 		internal static IEnumerable<ulong> GetUserMentions(DiscordMessage message)
 		{
 			var regex = new Regex(@"<@!?(\d+)>", RegexOptions.ECMAScript);
 			var matches = regex.Matches(message.Content);
 			foreach (Match match in matches)
 				yield return ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
 		}
 
 		/// <summary>
 		/// Gets the role mentions.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <returns>A list of ulong.</returns>
 		internal static IEnumerable<ulong> GetRoleMentions(DiscordMessage message)
 		{
 			var regex = new Regex(@"<@&(\d+)>", RegexOptions.ECMAScript);
 			var matches = regex.Matches(message.Content);
 			foreach (Match match in matches)
 				yield return ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
 		}
 
 		/// <summary>
 		/// Gets the channel mentions.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <returns>A list of ulong.</returns>
 		internal static IEnumerable<ulong> GetChannelMentions(DiscordMessage message)
 		{
 			var regex = new Regex(@"<#(\d+)>", RegexOptions.ECMAScript);
 			var matches = regex.Matches(message.Content);
 			foreach (Match match in matches)
 				yield return ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
 		}
 
 		/// <summary>
 		/// Gets the emojis.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <returns>A list of ulong.</returns>
 		internal static IEnumerable<ulong> GetEmojis(DiscordMessage message)
 		{
 			var regex = new Regex(@"<a?:([a-zA-Z0-9_]+):(\d+)>", RegexOptions.ECMAScript);
 			var matches = regex.Matches(message.Content);
 			foreach (Match match in matches)
 				yield return ulong.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture);
 		}
 
 		/// <summary>
 		/// Are the valid slash command name.
 		/// </summary>
 		/// <param name="name">The name.</param>
 		/// <returns>A bool.</returns>
 		internal static bool IsValidSlashCommandName(string name)
 		{
 			var regex = new Regex(@"^[\w-]{1,32}$", RegexOptions.ECMAScript);
 			return regex.IsMatch(name);
 		}
 
 		/// <summary>
 		/// Checks the thread auto archive duration feature.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <param name="taad">The taad.</param>
 		/// <returns>A bool.</returns>
-		internal static bool CheckThreadAutoArchiveDurationFeature(DiscordGuild guild, ThreadAutoArchiveDuration taad)
-		{
-			return taad == ThreadAutoArchiveDuration.ThreeDays
-				? (guild.PremiumTier.HasFlag(PremiumTier.TierOne) || guild.Features.CanSetThreadArchiveDurationThreeDays)
+		internal static bool CheckThreadAutoArchiveDurationFeature(DiscordGuild guild, ThreadAutoArchiveDuration taad) =>
+			taad == ThreadAutoArchiveDuration.ThreeDays
+				? guild.PremiumTier.HasFlag(PremiumTier.TierOne) || guild.Features.CanSetThreadArchiveDurationThreeDays
 				: taad != ThreadAutoArchiveDuration.OneWeek || guild.PremiumTier.HasFlag(PremiumTier.TierTwo) || guild.Features.CanSetThreadArchiveDurationSevenDays;
-		}
 
 		/// <summary>
 		/// Checks the thread private feature.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <returns>A bool.</returns>
 		internal static bool CheckThreadPrivateFeature(DiscordGuild guild) => guild.PremiumTier.HasFlag(PremiumTier.TierTwo) || guild.Features.CanCreatePrivateThreads;
 
 		/// <summary>
 		/// Have the message intents.
 		/// </summary>
 		/// <param name="intents">The intents.</param>
 		/// <returns>A bool.</returns>
 		internal static bool HasMessageIntents(DiscordIntents intents)
 			=> intents.HasIntent(DiscordIntents.GuildMessages) || intents.HasIntent(DiscordIntents.DirectMessages);
 
 		/// <summary>
 		/// Have the reaction intents.
 		/// </summary>
 		/// <param name="intents">The intents.</param>
 		/// <returns>A bool.</returns>
 		internal static bool HasReactionIntents(DiscordIntents intents)
 			=> intents.HasIntent(DiscordIntents.GuildMessageReactions) || intents.HasIntent(DiscordIntents.DirectMessageReactions);
 
 		/// <summary>
 		/// Have the typing intents.
 		/// </summary>
 		/// <param name="intents">The intents.</param>
 		/// <returns>A bool.</returns>
 		internal static bool HasTypingIntents(DiscordIntents intents)
 			=> intents.HasIntent(DiscordIntents.GuildMessageTyping) || intents.HasIntent(DiscordIntents.DirectMessageTyping);
 
 		// https://discord.com/developers/docs/topics/gateway#sharding-sharding-formula
 		/// <summary>
 		/// Gets a shard id from a guild id and total shard count.
 		/// </summary>
 		/// <param name="guildId">The guild id the shard is on.</param>
 		/// <param name="shardCount">The total amount of shards.</param>
 		/// <returns>The shard id.</returns>
 		public static int GetShardId(ulong guildId, int shardCount)
 			=> (int)(guildId >> 22) % shardCount;
 
 		/// <summary>
 		/// Helper method to create a <see cref="System.DateTimeOffset"/> from Unix time seconds for targets that do not support this natively.
 		/// </summary>
 		/// <param name="unixTime">Unix time seconds to convert.</param>
 		/// <param name="shouldThrow">Whether the method should throw on failure. Defaults to true.</param>
 		/// <returns>Calculated <see cref="System.DateTimeOffset"/>.</returns>
 		public static DateTimeOffset GetDateTimeOffset(long unixTime, bool shouldThrow = true)
 		{
 			try
 			{
 				return DateTimeOffset.FromUnixTimeSeconds(unixTime);
 			}
 			catch (Exception)
 			{
 				if (shouldThrow)
 					throw;
 
 				return DateTimeOffset.MinValue;
 			}
 		}
 
 		/// <summary>
 		/// Helper method to create a <see cref="System.DateTimeOffset"/> from Unix time milliseconds for targets that do not support this natively.
 		/// </summary>
 		/// <param name="unixTime">Unix time milliseconds to convert.</param>
 		/// <param name="shouldThrow">Whether the method should throw on failure. Defaults to true.</param>
 		/// <returns>Calculated <see cref="System.DateTimeOffset"/>.</returns>
 		public static DateTimeOffset GetDateTimeOffsetFromMilliseconds(long unixTime, bool shouldThrow = true)
 		{
 			try
 			{
 				return DateTimeOffset.FromUnixTimeMilliseconds(unixTime);
 			}
 			catch (Exception)
 			{
 				if (shouldThrow)
 					throw;
 
 				return DateTimeOffset.MinValue;
 			}
 		}
 
 		/// <summary>
 		/// Helper method to calculate Unix time seconds from a <see cref="System.DateTimeOffset"/> for targets that do not support this natively.
 		/// </summary>
 		/// <param name="dto"><see cref="System.DateTimeOffset"/> to calculate Unix time for.</param>
 		/// <returns>Calculated Unix time.</returns>
 		public static long GetUnixTime(DateTimeOffset dto)
 			=> dto.ToUnixTimeMilliseconds();
 
 		/// <summary>
 		/// Computes a timestamp from a given snowflake.
 		/// </summary>
 		/// <param name="snowflake">Snowflake to compute a timestamp from.</param>
 		/// <returns>Computed timestamp.</returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static DateTimeOffset GetSnowflakeTime(this ulong snowflake)
 			=> DiscordClient.DiscordEpoch.AddMilliseconds(snowflake >> 22);
 
 		/// <summary>
 		/// Converts this <see cref="Permissions"/> into human-readable format.
 		/// </summary>
 		/// <param name="perm">Permissions enumeration to convert.</param>
 		/// <returns>Human-readable permissions.</returns>
 		public static string ToPermissionString(this Permissions perm)
 		{
 			if (perm == Permissions.None)
 				return PermissionStrings[perm];
 
 			perm &= PermissionMethods.FullPerms;
 
 			var strs = PermissionStrings
 				.Where(xkvp => xkvp.Key != Permissions.None && (perm & xkvp.Key) == xkvp.Key)
 				.Select(xkvp => xkvp.Value);
 
 			return string.Join(", ", strs.OrderBy(xs => xs));
 		}
 
 		/// <summary>
 		/// Checks whether this string contains given characters.
 		/// </summary>
 		/// <param name="str">String to check.</param>
 		/// <param name="characters">Characters to check for.</param>
 		/// <returns>Whether the string contained these characters.</returns>
 		public static bool Contains(this string str, params char[] characters)
 		{
 			foreach (var xc in str)
 				if (characters.Contains(xc))
 					return true;
 
 			return false;
 		}
 
 		/// <summary>
 		/// Logs the task fault.
 		/// </summary>
 		/// <param name="task">The task.</param>
 		/// <param name="logger">The logger.</param>
 		/// <param name="level">The level.</param>
 		/// <param name="eventId">The event id.</param>
 		/// <param name="message">The message.</param>
 		internal static void LogTaskFault(this Task task, ILogger logger, LogLevel level, EventId eventId, string message)
 		{
 			if (task == null)
 				throw new ArgumentNullException(nameof(task));
 
 			if (logger == null)
 				return;
 
 			task.ContinueWith(t => logger.Log(level, eventId, t.Exception, message), TaskContinuationOptions.OnlyOnFaulted);
 		}
 
 		/// <summary>
 		/// Deconstructs the.
 		/// </summary>
 		/// <param name="kvp">The kvp.</param>
 		/// <param name="key">The key.</param>
 		/// <param name="value">The value.</param>
 		internal static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> kvp, out TKey key, out TValue value)
 		{
 			key = kvp.Key;
 			value = kvp.Value;
 		}
 	}
 }