diff --git a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
index 927d3a333..34753d80a 100644
--- a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
+++ b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
@@ -1,1776 +1,1776 @@
 // 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>();
 
 		/// <summary>
 		/// List of groups.
 		/// </summary>
 		private static List<GroupCommand> s_groupCommands { get; set; } = new List<GroupCommand>();
 
 		/// <summary>
 		/// List of groups with subgroups.
 		/// </summary>
 		private static List<SubGroupCommand> s_subGroupCommands { get; set; } = new List<SubGroupCommand>();
 
 		/// <summary>
 		/// List of context menus.
 		/// </summary>
 		private static List<ContextMenuCommand> s_contextMenuCommands { get; set; } = new List<ContextMenuCommand>();
 
 		/// <summary>
 		/// List of global commands on discords backend.
 		/// </summary>
 		internal static List<DiscordApplicationCommand> GlobalDiscordCommands { get; set; } = null;
 
 		/// <summary>
 		/// List of guild commands on discords backend.
 		/// </summary>
 		internal static Dictionary<ulong, List<DiscordApplicationCommand>> GuildDiscordCommands { get; set; } = null;
 
 		/// <summary>
 		/// Singleton modules.
 		/// </summary>
 		private static List<object> s_singletonModules { get; set; } = new List<object>();
 
 		/// <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;
 
 		/// <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();
+			=> _registeredCommands;
+		private static readonly List<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> _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;
 
 		/// <summary>
 		/// Gets the expected count.
 		/// </summary>
 		private static int s_expectedCount { get; set; } = 0;
 
 		/// <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); }
 		}
 		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); }
 		}
 		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); }
 		}
 		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); }
 		}
 		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();
 
 				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.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()));
+						_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()
 				? 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();
+			_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); }
 		}
 		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); }
 		}
 		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); }
 		}
 		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); }
 		}
 		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>();
 	}
 
 	/// <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.Lavalink/LavalinkUtil.cs b/DisCatSharp.Lavalink/LavalinkUtil.cs
index 86aae4fc5..e0598ffd2 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;
 				//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();
+		private static readonly Encoding _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)
+		public JavaBinaryReader(Stream ms) : base(ms, _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/Entities/Color/DiscordColor.cs b/DisCatSharp/Entities/Color/DiscordColor.cs
index 3fe0a8892..a8d7fe46d 100644
--- a/DisCatSharp/Entities/Color/DiscordColor.cs
+++ b/DisCatSharp/Entities/Color/DiscordColor.cs
@@ -1,130 +1,130 @@
 // 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.Linq;
 
 namespace DisCatSharp.Entities
 {
 	/// <summary>
 	/// Represents a color used in Discord API.
 	/// </summary>
 	public partial struct DiscordColor
 	{
-		private static readonly char[] s_hexAlphabet = new[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+		private static readonly char[] _hexAlphabet = new[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 
 		/// <summary>
 		/// Gets the integer representation of this color.
 		/// </summary>
 		public int Value { get; }
 
 		/// <summary>
 		/// Gets the red component of this color as an 8-bit integer.
 		/// </summary>
 		public byte R
 			=> (byte)((this.Value >> 16) & 0xFF);
 
 		/// <summary>
 		/// Gets the green component of this color as an 8-bit integer.
 		/// </summary>
 		public byte G
 			=> (byte)((this.Value >> 8) & 0xFF);
 
 		/// <summary>
 		/// Gets the blue component of this color as an 8-bit integer.
 		/// </summary>
 		public byte B
 			=> (byte)(this.Value & 0xFF);
 
 		/// <summary>
 		/// Creates a new color with specified value.
 		/// </summary>
 		/// <param name="color">Value of the color.</param>
 		public DiscordColor(int color)
 		{
 			this.Value = color;
 		}
 
 		/// <summary>
 		/// Creates a new color with specified values for red, green, and blue components.
 		/// </summary>
 		/// <param name="r">Value of the red component.</param>
 		/// <param name="g">Value of the green component.</param>
 		/// <param name="b">Value of the blue component.</param>
 		public DiscordColor(byte r, byte g, byte b)
 		{
 			this.Value = (r << 16) | (g << 8) | b;
 		}
 
 		/// <summary>
 		/// Creates a new color with specified values for red, green, and blue components.
 		/// </summary>
 		/// <param name="r">Value of the red component.</param>
 		/// <param name="g">Value of the green component.</param>
 		/// <param name="b">Value of the blue component.</param>
 		public DiscordColor(float r, float g, float b)
 		{
 			if (r < 0 || r > 1 || g < 0 || g > 1 || b < 0 || b > 1)
 				throw new ArgumentOutOfRangeException("Each component must be between 0.0 and 1.0 inclusive.");
 
 			var rb = (byte)(r * 255);
 			var gb = (byte)(g * 255);
 			var bb = (byte)(b * 255);
 
 			this.Value = (rb << 16) | (gb << 8) | bb;
 		}
 
 		/// <summary>
 		/// Creates a new color from specified string representation.
 		/// </summary>
 		/// <param name="color">String representation of the color. Must be 6 hexadecimal characters, optionally with # prefix.</param>
 		public DiscordColor(string color)
 		{
 			if (string.IsNullOrWhiteSpace(color))
 				throw new ArgumentNullException(nameof(color), "Null or empty values are not allowed!");
 
 			if (color.Length != 6 && color.Length != 7)
 				throw new ArgumentException(nameof(color), "Color must be 6 or 7 characters in length.");
 
 			color = color.ToUpper();
 			if (color.Length == 7 && color[0] != '#')
 				throw new ArgumentException(nameof(color), "7-character colors must begin with #.");
 			else if (color.Length == 7)
 				color = color[1..];
 
-			if (color.Any(xc => !s_hexAlphabet.Contains(xc)))
+			if (color.Any(xc => !_hexAlphabet.Contains(xc)))
 				throw new ArgumentException(nameof(color), "Colors must consist of hexadecimal characters only.");
 
 			this.Value = int.Parse(color, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
 		}
 
 		/// <summary>
 		/// Gets a string representation of this color.
 		/// </summary>
 		/// <returns>String representation of this color.</returns>
 		public override string ToString() => $"#{this.Value:X6}";
 
 		public static implicit operator DiscordColor(int value)
 			=> new(value);
 	}
 }
diff --git a/DisCatSharp/Logging/DefaultLogger.cs b/DisCatSharp/Logging/DefaultLogger.cs
index 2584cd6ae..0994f996b 100644
--- a/DisCatSharp/Logging/DefaultLogger.cs
+++ b/DisCatSharp/Logging/DefaultLogger.cs
@@ -1,148 +1,148 @@
 // 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.
 	/// </summary>
 	public class DefaultLogger : ILogger<BaseDiscordClient>
 	{
-		private static readonly object s_lock = new();
+		private static readonly object _lock = new();
 
 		/// <summary>
 		/// Gets the minimum log level.
 		/// </summary>
 		private readonly LogLevel _minimumLevel;
 
 		/// <summary>
 		/// Gets the timestamp format.
 		/// </summary>
 		private readonly string _timestampFormat;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DefaultLogger"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		internal DefaultLogger(BaseDiscordClient client)
 			: this(client.Configuration.MinimumLogLevel, client.Configuration.LogTimestampFormat)
 		{ }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DefaultLogger"/> class.
 		/// </summary>
 		/// <param name="minLevel">The min level.</param>
 		/// <param name="timestampFormat">The timestamp format.</param>
 		internal DefaultLogger(LogLevel minLevel = LogLevel.Information, string timestampFormat = "yyyy-MM-dd HH:mm:ss zzz")
 		{
 			this._minimumLevel = minLevel;
 			this._timestampFormat = timestampFormat;
 		}
 
 		/// <summary>
 		/// Logs an event.
 		/// </summary>
 		/// <param name="logLevel">The log level.</param>
 		/// <param name="eventId">The event id.</param>
 		/// <param name="state">The state.</param>
 		/// <param name="exception">The exception.</param>
 		/// <param name="formatter">The formatter.</param>
 		public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
 		{
 			if (!this.IsEnabled(logLevel))
 				return;
 
-			lock (s_lock)
+			lock (_lock)
 			{
 				var ename = eventId.Name;
 				ename = ename?.Length > 12 ? ename?[..12] : ename;
 				Console.Write($"[{DateTimeOffset.Now.ToString(this._timestampFormat)}] [{eventId.Id,-4}/{ename,-12}] ");
 
 				switch (logLevel)
 				{
 					case LogLevel.Trace:
 						Console.ForegroundColor = ConsoleColor.Gray;
 						break;
 
 					case LogLevel.Debug:
 						Console.ForegroundColor = ConsoleColor.DarkMagenta;
 						break;
 
 					case LogLevel.Information:
 						Console.ForegroundColor = ConsoleColor.DarkCyan;
 						break;
 
 					case LogLevel.Warning:
 						Console.ForegroundColor = ConsoleColor.Yellow;
 						break;
 
 					case LogLevel.Error:
 						Console.ForegroundColor = ConsoleColor.Red;
 						break;
 
 					case LogLevel.Critical:
 						Console.BackgroundColor = ConsoleColor.Red;
 						Console.ForegroundColor = ConsoleColor.Black;
 						break;
 				}
 				Console.Write(logLevel switch
 				{
 					LogLevel.Trace => "[Trace] ",
 					LogLevel.Debug => "[Debug] ",
 					LogLevel.Information => "[Info ] ",
 					LogLevel.Warning => "[Warn ] ",
 					LogLevel.Error => "[Error] ",
 					LogLevel.Critical => "[Crit ]",
 					LogLevel.None => "[None ] ",
 					_ => "[?????] "
 				});
 				Console.ResetColor();
 
 				//The foreground color is off.
 				if (logLevel == LogLevel.Critical)
 					Console.Write(" ");
 
 				var message = formatter(state, exception);
 				Console.WriteLine(message);
 				if (exception != null)
 					Console.WriteLine(exception);
 			}
 		}
 
 		/// <summary>
 		/// Whether the logger is enabled.
 		/// </summary>
 		/// <param name="logLevel">The log level.</param>
 		public bool IsEnabled(LogLevel logLevel)
 			=> logLevel >= this._minimumLevel;
 
 		/// <summary>
 		/// Begins the scope.
 		/// </summary>
 		/// <param name="state">The state.</param>
 		/// <returns>An IDisposable.</returns>
 		public IDisposable BeginScope<TState>(TState state) => throw new NotImplementedException();
 	}
 }
diff --git a/DisCatSharp/Net/Rest/RateLimitBucket.cs b/DisCatSharp/Net/Rest/RateLimitBucket.cs
index d3027623d..ec4dff4ba 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);
+				this.IsUnlimited = value.Contains(_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;
 
 		/// <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";
+		private static readonly string _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}";
+			=> $"{GenerateHashKey(method, route)}:{_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/Serialization/DiscordJson.cs b/DisCatSharp/Net/Serialization/DiscordJson.cs
index 2454cd149..77716a742 100644
--- a/DisCatSharp/Net/Serialization/DiscordJson.cs
+++ b/DisCatSharp/Net/Serialization/DiscordJson.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 System;
 using System.Globalization;
 using System.IO;
 using System.Text;
 using DisCatSharp.Entities;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Net.Serialization
 {
 	/// <summary>
 	/// Represents discord json.
 	/// </summary>
 	public static class DiscordJson
 	{
-		private static readonly JsonSerializer s_serializer = JsonSerializer.CreateDefault(new JsonSerializerSettings
+		private static readonly JsonSerializer _serializer = JsonSerializer.CreateDefault(new JsonSerializerSettings
 		{
 			ContractResolver = new OptionalJsonContractResolver()
 		});
 
 		/// <summary>Serializes the specified object to a JSON string.</summary>
 		/// <param name="value">The object to serialize.</param>
 		/// <returns>A JSON string representation of the object.</returns>
-		public static string SerializeObject(object value) => SerializeObjectInternal(value, null, s_serializer);
+		public static string SerializeObject(object value) => SerializeObjectInternal(value, null, _serializer);
 
 		/// <summary>Populates an object with the values from a JSON node.</summary>
 		/// <param name="value">The token to populate the object with.</param>
 		/// <param name="target">The object to populate.</param>
 		public static void PopulateObject(JToken value, object target)
 		{
 			using var reader = value.CreateReader();
-			s_serializer.Populate(reader, target);
+			_serializer.Populate(reader, target);
 		}
 
 		/// <summary>
 		/// Converts this token into an object, passing any properties through extra <see cref="Newtonsoft.Json.JsonConverter"/>s if needed.
 		/// </summary>
 		/// <param name="token">The token to convert</param>
 		/// <typeparam name="T">Type to convert to</typeparam>
 		/// <returns>The converted token</returns>
-		public static T ToDiscordObject<T>(this JToken token) => token.ToObject<T>(s_serializer);
+		public static T ToDiscordObject<T>(this JToken token) => token.ToObject<T>(_serializer);
 
 		/// <summary>
 		/// Serializes the object.
 		/// </summary>
 		/// <param name="value">The value.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="jsonSerializer">The json serializer.</param>
 		private static string SerializeObjectInternal(object value, Type type, JsonSerializer jsonSerializer)
 		{
 			var stringWriter = new StringWriter(new StringBuilder(256), CultureInfo.InvariantCulture);
 			using (var jsonTextWriter = new JsonTextWriter(stringWriter))
 			{
 				jsonTextWriter.Formatting = jsonSerializer.Formatting;
 				jsonSerializer.Serialize(jsonTextWriter, value, type);
 			}
 			return stringWriter.ToString();
 		}
 	}
 }