diff --git a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
index cacb597db..c7c5c9643 100644
--- a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
+++ b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
@@ -1,1822 +1,1819 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 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();
 
 		/// <summary>
 		/// List of groups.
 		/// </summary>
 		private static List<GroupCommand> s_groupCommands { get; set; } = new();
 
 		/// <summary>
 		/// List of groups with subgroups.
 		/// </summary>
 		private static List<SubGroupCommand> s_subGroupCommands { get; set; } = new();
 
 		/// <summary>
 		/// List of context menus.
 		/// </summary>
 		private static List<ContextMenuCommand> s_contextMenuCommands { get; set; } = new();
 
 		/// <summary>
 		/// List of global commands on discords backend.
 		/// </summary>
 		internal static List<DiscordApplicationCommand> GlobalDiscordCommands { get; set; }
 
 		/// <summary>
 		/// List of guild commands on discords backend.
 		/// </summary>
 		internal static Dictionary<ulong, List<DiscordApplicationCommand>> GuildDiscordCommands { get; set; }
 
 		/// <summary>
 		/// Singleton modules.
 		/// </summary>
 		private static List<object> s_singletonModules { get; set; } = new();
 
 		/// <summary>
 		/// List of modules to register.
 		/// </summary>
 		private readonly List<KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>> _updateList = new();
 
 		/// <summary>
 		/// Configuration for Discord.
 		/// </summary>
 		internal static ApplicationCommandsConfiguration Configuration;
 
 		/// <summary>
 		/// Discord client.
 		/// </summary>
 		internal static DiscordClient ClientInternal;
 
 		/// <summary>
 		/// Set to true if anything fails when registering.
 		/// </summary>
 		private static bool s_errored { get; set; }
 
 		/// <summary>
 		/// Gets a list of registered commands. The key is the guild id (null if global).
 		/// </summary>
 		public IReadOnlyList<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> RegisteredCommands
 			=> s_registeredCommands;
 		private static readonly List<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> s_registeredCommands = new();
 
 		/// <summary>
 		/// Gets a list of registered global commands.
 		/// </summary>
 		public IReadOnlyList<DiscordApplicationCommand> GlobalCommands
 			=> GlobalCommandsInternal;
 		internal static readonly List<DiscordApplicationCommand> GlobalCommandsInternal = new();
 
 		/// <summary>
 		/// Gets a list of registered guild commands mapped by guild id.
 		/// </summary>
 		public IReadOnlyDictionary<ulong, IReadOnlyList<DiscordApplicationCommand>> GuildCommands
 		=> GuildCommandsInternal;
 		internal static readonly Dictionary<ulong, IReadOnlyList<DiscordApplicationCommand>> GuildCommandsInternal = new();
 
 		/// <summary>
 		/// Gets the registration count.
 		/// </summary>
 		private static int s_registrationCount { get; set; }
 
 		/// <summary>
 		/// Gets the expected count.
 		/// </summary>
 		private static int s_expectedCount { get; set; }
 
 		/// <summary>
 		/// Gets the guild ids where the applications.commands scope is missing.
 		/// </summary>
 		private IReadOnlyList<ulong> _missingScopeGuildIds;
 
 		/// <summary>
 		/// Gets whether debug is enabled.
 		/// </summary>
 		internal static bool DebugEnabled { get; set; }
 
 		internal static LogLevel ApplicationCommandsLogLevel
 			=> DebugEnabled ? LogLevel.Debug : LogLevel.Trace;
 
 		/// <summary>
 		/// Gets whether check through all guilds is enabled.
 		/// </summary>
 		internal static bool CheckAllGuilds { get; set; }
 
 		internal static bool ManOr { get; set; }
 
 		internal static bool AutoDeferEnabled { get; set; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ApplicationCommandsExtension"/> class.
 		/// </summary>
 		/// <param name="configuration">The configuration.</param>
 		internal ApplicationCommandsExtension(ApplicationCommandsConfiguration configuration = null)
 		{
 			Configuration = configuration;
 			DebugEnabled = configuration?.DebugStartup ?? false;
 			CheckAllGuilds = configuration?.CheckAllGuilds ?? false;
 			ManOr = configuration?.ManualOverride ?? false;
 			AutoDeferEnabled = configuration?.AutoDefer ?? false;
 		}
 
 		/// <summary>
 		/// Runs setup.
 		/// <note type="caution">DO NOT RUN THIS MANUALLY. DO NOT DO ANYTHING WITH THIS.</note>
 		/// </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>
 		/// Cleans the module for a new start of the bot.
 		/// DO NOT USE IF YOU DON'T KNOW WHAT IT DOES.
 		/// </summary>
 		public void CleanModule()
 		{
 			this._updateList.Clear();
 			s_singletonModules.Clear();
 			s_errored = false;
 			s_expectedCount = 0;
 			s_registrationCount = 0;
 			s_commandMethods.Clear();
 			s_groupCommands.Clear();
 			s_contextMenuCommands.Clear();
 			s_subGroupCommands.Clear();
 			s_singletonModules.Clear();
 			s_registeredCommands.Clear();
 			GlobalCommandsInternal.Clear();
 			GuildCommandsInternal.Clear();
 		}
 
 		/// <summary>
 		/// Registers a command class.
 		/// </summary>
 		/// <typeparam name="T">The command class to register.</typeparam>
 		public void RegisterGlobalCommands<T>() where T : ApplicationCommandsModule
 		{
 			if (this.Client.ShardId == 0)
 				this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, 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>
 		public void RegisterGlobalCommands(Type type)
 		{
 			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)));
 		}
 
 		/// <summary>
 		/// Cleans all guild application commands.
 		/// <note type="caution">You normally don't need to execute it.</note>
 		/// </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.
 		/// <note type="caution">You normally don't need to execute it.</note>
 		/// </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="translationSetup">A callback to setup translations with.</param>
 		public void RegisterGuildCommands<T>(ulong guildId, Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
 		{
 			if (this.Client.ShardId == 0)
 				this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(typeof(T), 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="translationSetup">A callback to setup translations with.</param>
 		public void RegisterGuildCommands(Type type, ulong guildId, 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, 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="translationSetup">A callback to setup translations with.</param>
 		public void RegisterGlobalCommands<T>(Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
         {
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(typeof(T), translationSetup)));
         }
 
 		/// <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="translationSetup">A callback to setup translations with.</param>
 		public void RegisterGlobalCommands(Type type, 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>(null, new ApplicationCommandsModuleConfiguration(type, translationSetup)));
         }
 
 		/// <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();
 
 				this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Expected Count: {s_expectedCount}");
 
 				List<ulong> failedGuilds = new();
 				IEnumerable<DiscordApplicationCommand> globalCommands = null;
 				globalCommands = await this.Client.GetGlobalApplicationCommandsAsync(Configuration?.EnableLocalization ?? false) ?? null;
 				var guilds = CheckAllGuilds ? this.Client.Guilds?.Keys : this._updateList.Select(x => x.Key)?.Distinct().Where(x => x != null)?.Select(x => x.Value);
 
 				foreach (var guild in guilds)
 				{
 					IEnumerable<DiscordApplicationCommand> commands = null;
 					var unauthorized = false;
 					try
 					{
 						commands = await this.Client.GetGuildApplicationCommandsAsync(guild, Configuration?.EnableLocalization ?? false) ?? 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))
 				{
 					this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>
 						(null, new ApplicationCommandsModuleConfiguration(typeof(DefaultHelpModule))));
 					commandsPending = this._updateList.Select(x => x.Key).Distinct();
 				}
 
 				if (globalCommands != null && globalCommands.Any())
 					GlobalDiscordCommands.AddRange(globalCommands);
 
 				foreach (var key in commandsPending.ToList())
 				{
 					this.Client.Logger.LogInformation(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 withLocales = false;
 
 			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);
-							withLocales = true;
 						}
 
 						var slashGroupsTuple = NestedCommandWorker.ParseSlashGroupsAsync(type, classes, guildId, groupTranslations).Result;
 
 						if (slashGroupsTuple.applicationCommands != null && slashGroupsTuple.applicationCommands.Any())
 							updateList.AddRange(slashGroupsTuple.applicationCommands);
 
 						if (slashGroupsTuple.commandTypeSources != null && slashGroupsTuple.commandTypeSources.Any())
 							commandTypeSources.AddRange(slashGroupsTuple.commandTypeSources);
 
 						if (slashGroupsTuple.singletonModules != null && slashGroupsTuple.singletonModules.Any())
 							s_singletonModules.AddRange(slashGroupsTuple.singletonModules);
 
 						if (slashGroupsTuple.groupCommands != null && slashGroupsTuple.groupCommands.Any())
 							groupCommands.AddRange(slashGroupsTuple.groupCommands);
 
 						if (slashGroupsTuple.subGroupCommands != null && slashGroupsTuple.subGroupCommands.Any())
 							subGroupCommands.AddRange(slashGroupsTuple.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);
-								withLocales = true;
 							}
 
 							//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 = CommandWorker.ParseContextMenuCommands(type, contextMethods, commandTranslations).Result;
 
 							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 parsing the application commands");
 						s_errored = true;
 					}
 				}
 				if (!s_errored)
 				{
 					try
 					{
 						List<DiscordApplicationCommand> commands = new();
 
 						try
 						{
 							if (guildId == null)
 							{
 								if (updateList != null && updateList.Any())
 								{
-									var regCommands = RegistrationWorker.RegisterGlobalCommandsAsync(updateList, withLocales).Result;
+									var regCommands = RegistrationWorker.RegisterGlobalCommandsAsync(updateList).Result;
 									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.Log(ApplicationCommandsLogLevel, $"Could not delete global command {cmd.Id}. Please clean up manually");
 										}
 									}
 								}
 							}
 							else
 							{
 								if (updateList != null && updateList.Any())
 								{
-									var regCommands = RegistrationWorker.RegisterGuilldCommandsAsync(guildId.Value, updateList, withLocales).Result;
+									var regCommands = RegistrationWorker.RegisterGuilldCommandsAsync(guildId.Value, updateList).Result;
 									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.Log(ApplicationCommandsLogLevel, $"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;
 							else if (groupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var groupCom))
 								groupCom.CommandId = command.Id;
 							else if (subGroupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var subCom))
 								subCom.CommandId = command.Id;
 							else if (contextMenuCommands.GetFirstValueWhere(x => x.Name == command.Name, out var cmCom))
 								cmCom.CommandId = command.Id;
 						}
 
 						//Adds to the global lists finally
 						s_commandMethods.AddRange(commandMethods);
 						s_groupCommands.AddRange(groupCommands);
 						s_subGroupCommands.AddRange(subGroupCommands);
 						s_contextMenuCommands.AddRange(contextMenuCommands);
 
 						s_registeredCommands.Add(new KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>(guildId, commands.ToList()));
 
 						foreach (var command in commandMethods)
 						{
 							var app = types.First(t => t.Type == command.Method.DeclaringType);
 						}
 
 						this.Client.Logger.Log(ApplicationCommandsLogLevel, $"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
 							});
 						}
 
 						s_registrationCount++;
 						this.CheckRegistrationStartup(ManOr);
 					}
 					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 general error registering application commands");
 						s_errored = true;
 					}
 				}
 			});
 		}
 
 		private async void CheckRegistrationStartup(bool man = false)
 		{
 			this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Checking counts...\n\nExpected Count: {s_expectedCount}\nCurrent Count: {s_registrationCount}");
 
 			if ((s_registrationCount == s_expectedCount) || man)
 			{
 				await this._applicationCommandsModuleStartupFinished.InvokeAsync(this, new ApplicationCommandsModuleStartupFinishedEventArgs(Configuration?.ServiceProvider)
 				{
 					Handled = true,
 					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 group = subgroups.First().SubCommands.First(x => x.Name == command.Name).Methods.First(x => x.Key == command.Options.First().Name).Value;
 
                             var focusedOption = command.Options.First().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.First().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));
                         }
 					}
 					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)
 				{
 					if (AutoDeferEnabled)
 						await context.CreateResponseAsync(InteractionResponseType.DeferredChannelMessageWithSource);
 					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)
 				{
 					if (AutoDeferEnabled)
 						await context.CreateResponseAsync(InteractionResponseType.DeferredChannelMessageWithSource);
 					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
 							throw new ArgumentException("Error resolving mentionable option.");
 					}
 					else
 						throw new ArgumentException($"Error resolving interaction.");
 				}
 			}
 
 			return args;
 		}
 
 		/// <summary>
 		/// Runs the pre-execution 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(DiscordAttachment)
 				? ApplicationCommandOptionType.Attachment
 				: type == typeof(DiscordChannel)
 				? ApplicationCommandOptionType.Channel
 				: type == typeof(DiscordUser)
 				? ApplicationCommandOptionType.User
 				: type == typeof(DiscordRole)
 				? ApplicationCommandOptionType.Role
 				: type == typeof(SnowflakeObject)
 				? ApplicationCommandOptionType.Mentionable
 				: 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) =>
 			!choiceAttributes.Any()
 				? null
 				: choiceAttributes.Select(att => new DiscordApplicationCommandOptionChoice(att.Name, att.Value)).ToList();
 
 		/// <summary>
 		/// Parses the parameters.
 		/// </summary>
 		/// <param name="parameters">The parameters.</param>
 		/// <param name="guildId">The optional guild id.</param>
 		internal static async Task<List<DiscordApplicationCommandOption>> ParseParametersAsync(ParameterInfo[] parameters, ulong? guildId)
 		{
 			var options = new List<DiscordApplicationCommandOption>();
 			foreach (var parameter in parameters)
 			{
 				//Gets the attribute
 				var optionAttribute = parameter.GetCustomAttribute<OptionAttribute>();
 				if (optionAttribute == null)
 					throw new ArgumentException("Arguments must have the Option attribute!");
 
 				var minimumValue = parameter.GetCustomAttribute<MinimumAttribute>()?.Value ?? null;
 				var maximumValue = parameter.GetCustomAttribute<MaximumAttribute>()?.Value ?? null;
 
 
 				var autocompleteAttribute = parameter.GetCustomAttribute<AutocompleteAttribute>();
 				if (optionAttribute.Autocomplete && autocompleteAttribute == null)
 					throw new ArgumentException("Autocomplete options must have the Autocomplete attribute!");
 				if (!optionAttribute.Autocomplete && autocompleteAttribute != null)
 					throw new ArgumentException("Setting an autocomplete provider requires the option to have autocomplete set to true!");
 
 				//Sets the type
 				var type = parameter.ParameterType;
 				var parameterType = GetParameterType(type);
 
 				//Handles choices
 				//From attributes
 				var choices = GetChoiceAttributesFromParameter(parameter.GetCustomAttributes<ChoiceAttribute>());
 				//From enums
 				if (parameter.ParameterType.IsEnum)
 				{
 					choices = GetChoiceAttributesFromEnumParameter(parameter.ParameterType);
 				}
 				//From choice provider
 				var choiceProviders = parameter.GetCustomAttributes<ChoiceProviderAttribute>();
 				if (choiceProviders.Any())
 				{
 					choices = await GetChoiceAttributesFromProvider(choiceProviders, guildId);
 				}
 
 				var channelTypes = parameter.GetCustomAttribute<ChannelTypesAttribute>()?.ChannelTypes ?? null;
 
 				options.Add(new DiscordApplicationCommandOption(optionAttribute.Name, optionAttribute.Description, parameterType, !parameter.IsOptional, choices, null, channelTypes, optionAttribute.Autocomplete, minimumValue, maximumValue));
 			}
 
 			return options;
 		}
 
 		/// <summary>
 		/// <para>Refreshes your commands, used for refreshing choice providers or applying commands registered after the ready event on the discord client.
 		/// Should only be run on the slash command extension linked to shard 0 if sharding.</para>
 		/// <para>Not recommended and should be avoided since it can make slash commands be unresponsive for a while.</para>
 		/// </summary>
 		public async Task RefreshCommandsAsync()
 		{
 			s_commandMethods.Clear();
 			s_groupCommands.Clear();
 			s_subGroupCommands.Clear();
 			s_registeredCommands.Clear();
 			s_contextMenuCommands.Clear();
 			GlobalDiscordCommands.Clear();
 			GuildDiscordCommands.Clear();
 			GuildCommandsInternal.Clear();
 			GlobalCommandsInternal.Clear();
 			GlobalDiscordCommands = null;
 			GuildDiscordCommands = null;
 			s_errored = false;
 
 			if (Configuration != null && Configuration.EnableDefaultHelp)
 			{
 				this._updateList.RemoveAll(x => x.Value.Type == typeof(DefaultHelpModule));
 			}
 
 			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 translation setup.
 		/// </summary>
 		public Action<ApplicationCommandsTranslationContext> Translations { get; }
 
 		/// <summary>
 		/// Creates a new command configuration.
 		/// </summary>
 		/// <param name="type">The type of the command module.</param>
 		/// <param name="translations">The translation setup callback.</param>
 		public ApplicationCommandsModuleConfiguration(Type type, Action<ApplicationCommandsTranslationContext> translations = null)
 		{
 			this.Type = type;
 			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();
 	}
 
 	/// <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>
 	internal class DefaultHelpModule : ApplicationCommandsModule
 	{
 		public class DefaultHelpAutoCompleteProvider : IAutocompleteProvider
 		{
 			public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 			{
 				var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 
 				IEnumerable<DiscordApplicationCommand> slashCommands = null;
 				var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 				if (context.Guild != null)
 				{
 					var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 					await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 					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();
 				}
 				else
 				{
 					await Task.WhenAll(globalCommandsTask);
 					slashCommands = globalCommandsTask.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>();
 				IEnumerable<DiscordApplicationCommand> slashCommands = null;
 				var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 				if (context.Guild != null)
 				{
 					var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 					await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 					slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 						.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 						.GroupBy(ac => ac.Name).Select(x => x.First());
 				}
 				else
 				{
 					await Task.WhenAll(globalCommandsTask);
 					slashCommands = globalCommandsTask.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>();
 				IEnumerable<DiscordApplicationCommand> slashCommands = null;
 				var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 				if (context.Guild != null)
 				{
 					var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 					await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 					slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 						.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 						.GroupBy(ac => ac.Name).Select(x => x.First());
 				}
 				else
 				{
 					await Task.WhenAll(globalCommandsTask);
 					slashCommands = globalCommandsTask.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")]
 		internal 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(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 				}
 				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(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 				}
 				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(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 				}
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 					new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 			}
 		}
 	}
 	#endregion
 }
diff --git a/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs b/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs
index 658bdf367..996f7a176 100644
--- a/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs
+++ b/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs
@@ -1,581 +1,579 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common;
 using DisCatSharp.Entities;
 using DisCatSharp.Exceptions;
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.ApplicationCommands
 {
 	/// <summary>
 	/// Represents a <see cref="RegistrationWorker"/>.
 	/// </summary>
 	internal class RegistrationWorker
 	{
 		/// <summary>
 		/// Registers the global commands.
 		/// </summary>
 		/// <param name="commands">The command list.</param>
-		/// <param name="withLocales">Whether this commands has localization.</param>
 		/// <returns>A list of registered commands.</returns>
-		internal static async Task<List<DiscordApplicationCommand>> RegisterGlobalCommandsAsync(List<DiscordApplicationCommand> commands, bool withLocales)
+		internal static async Task<List<DiscordApplicationCommand>> RegisterGlobalCommandsAsync(List<DiscordApplicationCommand> commands)
 		{
 			var (changedCommands, unchangedCommands) = BuildGlobalOverwriteList(commands);
 			var globalCommandsCreateList = BuildGlobalCreateList(commands);
 			var globalCommandsDeleteList = BuildGlobalDeleteList(commands);
 
 			if (globalCommandsCreateList.NotEmptyAndNotNull() && unchangedCommands.NotEmptyAndNotNull() && changedCommands.NotEmptyAndNotNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Creating, re-using and overwriting application commands.");
 
 				foreach (var cmd in globalCommandsCreateList)
 				{
 					var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.CreateGlobalApplicationCommandAsync(cmd);
 					commands.Add(discordBackendCommand);
 				}
 
 				foreach (var cmd in changedCommands)
 				{
 					var command = cmd.Value;
 					var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGlobalApplicationCommandAsync(cmd.Key, action =>
 					{
 						action.Name = command.Name;
 						action.NameLocalizations = command.NameLocalizations;
 						action.Description = command.Description;
 						action.DescriptionLocalizations = command.DescriptionLocalizations;
 						if(command.Options != null && command.Options.Any())
 							action.Options = Entities.Optional.Some(command.Options);
 						if (command.DefaultMemberPermissions.HasValue && command.DefaultMemberPermissions != null)
 							action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 						if (command.DmPermission.HasValue && command.DmPermission != null)
 							action.DmPermission = command.DmPermission.Value;
 					});
 
 					commands.Add(discordBackendCommand);
 				}
 
 				commands.AddRange(unchangedCommands);
 			}
 			else if (globalCommandsCreateList.NotEmptyAndNotNull() && (unchangedCommands.NotEmptyAndNotNull() || changedCommands.NotEmptyAndNotNull()))
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Creating, re-using and overwriting application commands.");
 
 				foreach (var cmd in globalCommandsCreateList)
 				{
 					var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.CreateGlobalApplicationCommandAsync(cmd);
 					commands.Add(discordBackendCommand);
 				}
 
 				if (changedCommands.NotEmptyAndNotNull())
 				{
 					foreach (var cmd in changedCommands)
 					{
 						var command = cmd.Value;
 						var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGlobalApplicationCommandAsync(cmd.Key, action =>
 						{
 							action.Name = command.Name;
 							action.NameLocalizations = command.NameLocalizations;
 							action.Description = command.Description;
 							action.DescriptionLocalizations = command.DescriptionLocalizations;
 							if(command.Options != null && command.Options.Any())
 								action.Options = Entities.Optional.Some(command.Options);
 							if (command.DefaultMemberPermissions.HasValue && command.DefaultMemberPermissions != null)
 								action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 							if (command.DmPermission.HasValue && command.DmPermission != null)
 								action.DmPermission = command.DmPermission.Value;
 						});
 
 						commands.Add(discordBackendCommand);
 					}
 				}
 
 				if (unchangedCommands.NotEmptyAndNotNull())
 					commands.AddRange(unchangedCommands);
 			}
 			else if (globalCommandsCreateList.EmptyOrNull() && unchangedCommands.NotEmptyAndNotNull() && changedCommands.NotEmptyAndNotNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Editing & re-using application commands.");
 
 				foreach (var cmd in changedCommands)
 				{
 					var command = cmd.Value;
 					var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGlobalApplicationCommandAsync(cmd.Key, action =>
 					{
 						action.Name = command.Name;
 						action.NameLocalizations = command.NameLocalizations;
 						action.Description = command.Description;
 						action.DescriptionLocalizations = command.DescriptionLocalizations;
 						if(command.Options != null && command.Options.Any())
 							action.Options = Entities.Optional.Some(command.Options);
 						if (command.DefaultMemberPermissions.HasValue && command.DefaultMemberPermissions != null)
 							action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 						if (command.DmPermission.HasValue && command.DmPermission != null)
 							action.DmPermission = command.DmPermission.Value;
 					});
 
 					commands.Add(discordBackendCommand);
 				}
 
 				commands.AddRange(unchangedCommands);
 			}
 			else if (globalCommandsCreateList.EmptyOrNull() && changedCommands.NotEmptyAndNotNull() && unchangedCommands.EmptyOrNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Overwriting all application commands.");
 
 				List<DiscordApplicationCommand> overwriteList = new();
 				foreach (var overwrite in changedCommands)
 				{
 					var cmd = overwrite.Value;
 					cmd.Id = overwrite.Key;
 					overwriteList.Add(cmd);
 				}
 				var discordBackendCommands = await ApplicationCommandsExtension.ClientInternal.BulkOverwriteGlobalApplicationCommandsAsync(overwriteList);
 				commands.AddRange(discordBackendCommands);
 			}
 			else if (globalCommandsCreateList.NotEmptyAndNotNull() && changedCommands.EmptyOrNull() && unchangedCommands.EmptyOrNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Creating all application commands.");
 
 				var cmds = await ApplicationCommandsExtension.ClientInternal.BulkOverwriteGlobalApplicationCommandsAsync(globalCommandsCreateList);
 				commands.AddRange(cmds);
 			}
 			else if (globalCommandsCreateList.EmptyOrNull() && changedCommands.EmptyOrNull() && unchangedCommands.NotEmptyAndNotNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Re-using all application commands.");
 
 				commands.AddRange(unchangedCommands);
 			}
 
 			if (globalCommandsDeleteList.NotEmptyAndNotNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Deleting missing application commands.");
 
 				foreach (var cmdId in globalCommandsDeleteList)
 				{
 					try
 					{
 						await ApplicationCommandsExtension.ClientInternal.DeleteGlobalApplicationCommandAsync(cmdId);
 					}
 					catch (NotFoundException)
 					{
 						ApplicationCommandsExtension.ClientInternal.Logger.LogError($"Could not delete global command {cmdId}. Please clean up manually");
 					}
 				}
 			}
 
 			return commands.NotEmptyAndNotNull() ? commands : null;
 		}
 
 		/// <summary>
 		/// Registers the guild commands.
 		/// </summary>
 		/// <param name="guildId">The target guild id.</param>
 		/// <param name="commands">The command list.</param>
-		/// <param name="withLocales">Whether this commands has localization.</param>
 		/// <returns>A list of registered commands.</returns>
-		internal static async Task<List<DiscordApplicationCommand>> RegisterGuilldCommandsAsync(ulong guildId, List<DiscordApplicationCommand> commands, bool withLocales)
+		internal static async Task<List<DiscordApplicationCommand>> RegisterGuilldCommandsAsync(ulong guildId, List<DiscordApplicationCommand> commands)
 		{
 			var (changedCommands, unchangedCommands) = BuildGuildOverwriteList(guildId, commands);
 			var guildCommandsCreateList = BuildGuildCreateList(guildId, commands);
 			var guildCommandsDeleteList = BuildGuildDeleteList(guildId, commands);
 
 			if (guildCommandsCreateList.NotEmptyAndNotNull() && unchangedCommands.NotEmptyAndNotNull() && changedCommands.NotEmptyAndNotNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Creating, re-using and overwriting application commands. Guild ID: {guildId}");
 
 				foreach (var cmd in guildCommandsCreateList)
 				{
 					var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.CreateGuildApplicationCommandAsync(guildId, cmd);
 					commands.Add(discordBackendCommand);
 				}
 
 				foreach (var cmd in changedCommands)
 				{
 					var command = cmd.Value;
 					var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGuildApplicationCommandAsync(guildId, cmd.Key, action =>
 					{
 						action.Name = command.Name;
 						action.NameLocalizations = command.NameLocalizations;
 						action.Description = command.Description;
 						action.DescriptionLocalizations = command.DescriptionLocalizations;
 						if(command.Options != null && command.Options.Any())
 							action.Options = Entities.Optional.Some(command.Options);
 						if (command.DefaultMemberPermissions.HasValue && command.DefaultMemberPermissions != null)
 							action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 						if (command.DmPermission.HasValue && command.DmPermission != null)
 							action.DmPermission = command.DmPermission.Value;
 					});
 
 					commands.Add(discordBackendCommand);
 				}
 
 				commands.AddRange(unchangedCommands);
 			}
 			else if (guildCommandsCreateList.NotEmptyAndNotNull() && (unchangedCommands.NotEmptyAndNotNull() || changedCommands.NotEmptyAndNotNull()))
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Creating, re-using and overwriting application commands. Guild ID: {guildId}");
 
 				foreach (var cmd in guildCommandsCreateList)
 				{
 					var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.CreateGuildApplicationCommandAsync(guildId, cmd);
 					commands.Add(discordBackendCommand);
 				}
 
 				if (changedCommands.NotEmptyAndNotNull())
 				{
 					foreach (var cmd in changedCommands)
 					{
 						var command = cmd.Value;
 						var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGuildApplicationCommandAsync(guildId, cmd.Key, action =>
 						{
 							action.Name = command.Name;
 							action.NameLocalizations = command.NameLocalizations;
 							action.Description = command.Description;
 							action.DescriptionLocalizations = command.DescriptionLocalizations;
 							if(command.Options != null && command.Options.Any())
 								action.Options = Entities.Optional.Some(command.Options);
 							if (command.DefaultMemberPermissions.HasValue && command.DefaultMemberPermissions != null)
 								action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 							if (command.DmPermission.HasValue && command.DmPermission != null)
 								action.DmPermission = command.DmPermission.Value;
 						});
 
 						commands.Add(discordBackendCommand);
 					}
 				}
 
 				if (unchangedCommands.NotEmptyAndNotNull())
 					commands.AddRange(unchangedCommands);
 			}
 			else if (guildCommandsCreateList.EmptyOrNull() && unchangedCommands.NotEmptyAndNotNull() && changedCommands.NotEmptyAndNotNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Editing & re-using application commands. Guild ID: {guildId}");
 
 				foreach (var cmd in changedCommands)
 				{
 					var command = cmd.Value;
 					var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGuildApplicationCommandAsync(guildId, cmd.Key, action =>
 					{
 						action.Name = command.Name;
 						action.NameLocalizations = command.NameLocalizations;
 						action.Description = command.Description;
 						action.DescriptionLocalizations = command.DescriptionLocalizations;
 						if(command.Options != null && command.Options.Any())
 							action.Options = Entities.Optional.Some(command.Options);
 						if (command.DefaultMemberPermissions.HasValue && command.DefaultMemberPermissions != null)
 							action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 						if (command.DmPermission.HasValue && command.DmPermission != null)
 							action.DmPermission = command.DmPermission.Value;
 					});
 
 					commands.Add(discordBackendCommand);
 				}
 
 				commands.AddRange(unchangedCommands);
 			}
 			else if (guildCommandsCreateList.EmptyOrNull() && changedCommands.NotEmptyAndNotNull() && unchangedCommands.EmptyOrNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Overwriting all application commands. Guild ID: {guildId}");
 
 				List<DiscordApplicationCommand> overwriteList = new();
 				foreach (var overwrite in changedCommands)
 				{
 					var cmd = overwrite.Value;
 					cmd.Id = overwrite.Key;
 					overwriteList.Add(cmd);
 				}
 				var discordBackendCommands = await ApplicationCommandsExtension.ClientInternal.BulkOverwriteGuildApplicationCommandsAsync(guildId, overwriteList);
 				commands.AddRange(discordBackendCommands);
 			}
 			else if (guildCommandsCreateList.NotEmptyAndNotNull() && changedCommands.EmptyOrNull() && unchangedCommands.EmptyOrNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Creating all application commands. Guild ID: {guildId}");
 
 				var cmds = await ApplicationCommandsExtension.ClientInternal.BulkOverwriteGuildApplicationCommandsAsync(guildId, guildCommandsCreateList);
 				commands.AddRange(cmds);
 			}
 			else if (guildCommandsCreateList.EmptyOrNull() && changedCommands.EmptyOrNull() && unchangedCommands.NotEmptyAndNotNull())
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Re-using all application commands Guild ID: {guildId}.");
 
 				commands.AddRange(unchangedCommands);
 			}
 
 			if (guildCommandsDeleteList.NotEmptyAndNotNull())
 			{
 				foreach (var cmdId in guildCommandsDeleteList)
 				{
 					ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Deleting missing application commands. Guild ID: {guildId}");
 					try
 					{
 						await ApplicationCommandsExtension.ClientInternal.DeleteGuildApplicationCommandAsync(guildId, cmdId);
 					}
 					catch (NotFoundException)
 					{
 						ApplicationCommandsExtension.ClientInternal.Logger.LogError($"Could not delete guild command {cmdId} in guild {guildId}. Please clean up manually");
 					}
 				}
 			}
 
 			return commands.NotEmptyAndNotNull() ? commands : null;
 		}
 
 		/// <summary>
 		/// Builds a list of guild command ids to be deleted on discords backend.
 		/// </summary>
 		/// <param name="guildId">The guild id these commands belong to.</param>
 		/// <param name="updateList">The command list.</param>
 		/// <returns>A list of command ids.</returns>
 		private static List<ulong> BuildGuildDeleteList(ulong guildId, List<DiscordApplicationCommand> updateList)
 		{
 			List<DiscordApplicationCommand> discord;
 
 			if (ApplicationCommandsExtension.GuildDiscordCommands == null || !ApplicationCommandsExtension.GuildDiscordCommands.Any()
 				|| !ApplicationCommandsExtension.GuildDiscordCommands.GetFirstValueByKey(guildId, out discord)
 			)
 				return null;
 
 			List<ulong> invalidCommandIds = new();
 
 			if (discord == null)
 				return null;
 
 			if (updateList == null)
 			{
 				foreach (var cmd in discord)
 				{
 					invalidCommandIds.Add(cmd.Id);
 				}
 			}
 			else
 			{
 				foreach (var cmd in discord)
 				{
 					if (!updateList.Any(ul => ul.Name == cmd.Name))
 						invalidCommandIds.Add(cmd.Id);
 				}
 			}
 
 			return invalidCommandIds;
 		}
 
 		/// <summary>
 		/// Builds a list of guild commands to be created on discords backend.
 		/// </summary>
 		/// <param name="guildId">The guild id these commands belong to.</param>
 		/// <param name="updateList">The command list.</param>
 		/// <returns></returns>
 		private static List<DiscordApplicationCommand> BuildGuildCreateList(ulong guildId, List<DiscordApplicationCommand> updateList)
 		{
 			List<DiscordApplicationCommand> discord;
 
 			if (ApplicationCommandsExtension.GuildDiscordCommands == null || !ApplicationCommandsExtension.GuildDiscordCommands.Any()
 				|| updateList == null || !ApplicationCommandsExtension.GuildDiscordCommands.GetFirstValueByKey(guildId, out discord)
 			)
 				return updateList;
 
 			List<DiscordApplicationCommand> newCommands = new();
 
 			if (discord == null)
 				return updateList;
 
 			foreach (var cmd in updateList)
 			{
 				if (discord.All(d => d.Name != cmd.Name))
 				{
 					newCommands.Add(cmd);
 				}
 			}
 
 			return newCommands;
 		}
 
 		/// <summary>
 		/// Builds a list of guild commands to be overwritten on discords backend.
 		/// </summary>
 		/// <param name="guildId">The guild id these commands belong to.</param>
 		/// <param name="updateList">The command list.</param>
 		/// <returns>A dictionary of command id and command.</returns>
 		private static (
 				Dictionary<ulong, DiscordApplicationCommand> changedCommands,
 				List<DiscordApplicationCommand> unchangedCommands
 			) BuildGuildOverwriteList(ulong guildId, List<DiscordApplicationCommand> updateList)
 		{
 			List<DiscordApplicationCommand> discord;
 
 			if (ApplicationCommandsExtension.GuildDiscordCommands == null || !ApplicationCommandsExtension.GuildDiscordCommands.Any()
 				|| ApplicationCommandsExtension.GuildDiscordCommands.All(l => l.Key != guildId) || updateList == null
 				|| !ApplicationCommandsExtension.GuildDiscordCommands.GetFirstValueByKey(guildId, out discord)
 			)
 				return (null, null);
 
 			Dictionary<ulong, DiscordApplicationCommand> updateCommands = new();
 			List<DiscordApplicationCommand> unchangedCommands = new();
 
 			if (discord == null)
 				return (null, null);
 
 			foreach (var cmd in updateList)
 			{
 				if (discord.GetFirstValueWhere(d => d.Name == cmd.Name, out var command))
 				{
 					if (command.IsEqualTo(cmd))
 					{
 						if (ApplicationCommandsExtension.DebugEnabled)
 							ApplicationCommandsExtension.ClientInternal.Logger.LogDebug($"[AC] Command {cmd.Name} unchanged");
 						cmd.Id = command.Id;
 						cmd.ApplicationId = command.ApplicationId;
 						cmd.Version = command.Version;
 						unchangedCommands.Add(cmd);
 					}
 					else
 					{
 						if (ApplicationCommandsExtension.DebugEnabled)
 							ApplicationCommandsExtension.ClientInternal.Logger.LogDebug($"[AC] Command {cmd.Name} changed");
 						updateCommands.Add(command.Id, cmd);
 					}
 				}
 			}
 
 			return (updateCommands, unchangedCommands);
 		}
 
 		/// <summary>
 		/// Builds a list of global command ids to be deleted on discords backend.
 		/// </summary>
 		/// <param name="updateList">The command list.</param>
 		/// <returns>A list of command ids.</returns>
 		private static List<ulong> BuildGlobalDeleteList(List<DiscordApplicationCommand> updateList = null)
 		{
 			if (ApplicationCommandsExtension.GlobalDiscordCommands == null || !ApplicationCommandsExtension.GlobalDiscordCommands.Any()
 				|| ApplicationCommandsExtension.GlobalDiscordCommands == null
 			)
 				return null;
 
 			var discord = ApplicationCommandsExtension.GlobalDiscordCommands;
 
 			List<ulong> invalidCommandIds = new();
 
 			if (discord == null)
 				return null;
 
 			if (updateList == null)
 			{
 				foreach (var cmd in discord)
 				{
 					invalidCommandIds.Add(cmd.Id);
 				}
 			}
 			else
 			{
 				foreach (var cmd in discord)
 				{
 					if (updateList.All(ul => ul.Name != cmd.Name))
 						invalidCommandIds.Add(cmd.Id);
 				}
 			}
 
 			return invalidCommandIds;
 		}
 
 		/// <summary>
 		/// Builds a list of global commands to be created on discords backend.
 		/// </summary>
 		/// <param name="updateList">The command list.</param>
 		/// <returns>A list of commands.</returns>
 		private static List<DiscordApplicationCommand> BuildGlobalCreateList(List<DiscordApplicationCommand> updateList)
 		{
 			if (ApplicationCommandsExtension.GlobalDiscordCommands == null || !ApplicationCommandsExtension.GlobalDiscordCommands.Any() || updateList == null)
 				return updateList;
 
 			var discord = ApplicationCommandsExtension.GlobalDiscordCommands;
 
 			List<DiscordApplicationCommand> newCommands = new();
 
 			if (discord == null)
 				return updateList;
 
 			foreach (var cmd in updateList)
 			{
 				if (discord.All(d => d.Name != cmd.Name))
 				{
 					newCommands.Add(cmd);
 				}
 			}
 
 			return newCommands;
 		}
 
 		/// <summary>
 		/// Builds a list of global commands to be overwritten on discords backend.
 		/// </summary>
 		/// <param name="updateList">The command list.</param>
 		/// <returns>A dictionary of command ids and commands.</returns>
 		private static (
 				Dictionary<ulong, DiscordApplicationCommand> changedCommands,
 				List<DiscordApplicationCommand> unchangedCommands
 			) BuildGlobalOverwriteList(List<DiscordApplicationCommand> updateList)
 		{
 			if (ApplicationCommandsExtension.GlobalDiscordCommands == null || !ApplicationCommandsExtension.GlobalDiscordCommands.Any()
 				|| updateList == null || ApplicationCommandsExtension.GlobalDiscordCommands == null
 			)
 				return (null, null);
 
 			var discord = ApplicationCommandsExtension.GlobalDiscordCommands;
 
 			if (discord == null)
 				return (null, null);
 
 			Dictionary<ulong, DiscordApplicationCommand> updateCommands = new();
 			List<DiscordApplicationCommand> unchangedCommands = new();
 			foreach (var cmd in updateList)
 			{
 				if (discord.GetFirstValueWhere(d => d.Name == cmd.Name, out var command))
 				{
 					if (command.IsEqualTo(cmd))
 					{
 						if (ApplicationCommandsExtension.DebugEnabled)
 							ApplicationCommandsExtension.ClientInternal.Logger.LogDebug($"[AC] Command {cmd.Name} unchanged");
 						cmd.Id = command.Id;
 						cmd.ApplicationId = command.ApplicationId;
 						cmd.Version = command.Version;
 						unchangedCommands.Add(cmd);
 					}
 					else
 					{
 						if (ApplicationCommandsExtension.DebugEnabled)
 							ApplicationCommandsExtension.ClientInternal.Logger.LogDebug($"[AC] Command {cmd.Name} changed");
 						updateCommands.Add(command.Id, cmd);
 					}
 				}
 			}
 
 			return (updateCommands, unchangedCommands);
 		}
 	}
 }
diff --git a/DisCatSharp/Net/Rest/RestClient.cs b/DisCatSharp/Net/Rest/RestClient.cs
index 0c19c4438..2ae1dcaf7 100644
--- a/DisCatSharp/Net/Rest/RestClient.cs
+++ b/DisCatSharp/Net/Rest/RestClient.cs
@@ -1,873 +1,873 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Exceptions;
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Net
 {
 	/// <summary>
 	/// Represents a client used to make REST requests.
 	/// </summary>
 	internal sealed class RestClient : IDisposable
 	{
 		/// <summary>
 		/// Gets the route argument regex.
 		/// </summary>
 		private static Regex s_routeArgumentRegex { get; } = new(@":([a-z_]+)");
 
 		/// <summary>
 		/// Gets the http client.
 		/// </summary>
 		internal HttpClient HttpClient { get; }
 
 		/// <summary>
 		/// Gets the discord client.
 		/// </summary>
 		private readonly BaseDiscordClient _discord;
 
 		/// <summary>
 		/// Gets a value indicating whether debug is enabled.
 		/// </summary>
 		internal bool Debug { get; set; }
 
 		/// <summary>
 		/// Gets the logger.
 		/// </summary>
 		private readonly ILogger _logger;
 
 		/// <summary>
 		/// Gets the routes to hashes.
 		/// </summary>
 		private readonly ConcurrentDictionary<string, string> _routesToHashes;
 
 		/// <summary>
 		/// Gets the hashes to buckets.
 		/// </summary>
 		private readonly ConcurrentDictionary<string, RateLimitBucket> _hashesToBuckets;
 
 		/// <summary>
 		/// Gets the request queue.
 		/// </summary>
 		private readonly ConcurrentDictionary<string, int> _requestQueue;
 
 		/// <summary>
 		/// Gets the global rate limit event.
 		/// </summary>
 		private readonly AsyncManualResetEvent _globalRateLimitEvent;
 
 		/// <summary>
 		/// Gets a value indicating whether use reset after.
 		/// </summary>
 		private readonly bool _useResetAfter;
 
 		private CancellationTokenSource _bucketCleanerTokenSource;
 		private readonly TimeSpan _bucketCleanupDelay = TimeSpan.FromSeconds(60);
 		private volatile bool _cleanerRunning;
 		private Task _cleanerTask;
 		private volatile bool _disposed;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="RestClient"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		internal RestClient(BaseDiscordClient client)
 			: this(client.Configuration.Proxy, client.Configuration.HttpTimeout, client.Configuration.UseRelativeRatelimit, client.Logger)
 		{
 			this._discord = client;
 			this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", Utilities.GetFormattedToken(client));
 			if (client.Configuration.Override != null)
 			{
 				this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("x-super-properties", client.Configuration.Override);
 			}
 		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="RestClient"/> class.
 		/// This is for meta-clients, such as the webhook client.
 		/// </summary>
 		/// <param name="proxy">The proxy.</param>
 		/// <param name="timeout">The timeout.</param>
 		/// <param name="useRelativeRatelimit">Whether to use relative ratelimit.</param>
 		/// <param name="logger">The logger.</param>
 		internal RestClient(IWebProxy proxy, TimeSpan timeout, bool useRelativeRatelimit,
 			ILogger logger) 
 		{
 			this._logger = logger;
 
 			var httphandler = new HttpClientHandler
 			{
 				UseCookies = false,
 				AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip,
 				UseProxy = proxy != null,
 				Proxy = proxy
 			};
 
 			this.HttpClient = new HttpClient(httphandler)
 			{
 				BaseAddress = new Uri(Utilities.GetApiBaseUri(this._discord?.Configuration)),
 				Timeout = timeout
 			};
 
 			this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", Utilities.GetUserAgent());
 			if (this._discord != null && this._discord.Configuration != null && this._discord.Configuration.Override != null)
 			{
 				this.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("x-super-properties", this._discord.Configuration.Override);
 			}
 
 			this._routesToHashes = new ConcurrentDictionary<string, string>();
 			this._hashesToBuckets = new ConcurrentDictionary<string, RateLimitBucket>();
 			this._requestQueue = new ConcurrentDictionary<string, int>();
 
 			this._globalRateLimitEvent = new AsyncManualResetEvent(true);
 			this._useResetAfter = useRelativeRatelimit;
 		}
 
 		/// <summary>
 		/// Gets a ratelimit bucket.
 		/// </summary>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <param name="routeParams">The route parameters.</param>
 		/// <param name="url">The url.</param>
 		/// <returns>A ratelimit bucket.</returns>
 		public RateLimitBucket GetBucket(RestRequestMethod method, string route, object routeParams, out string url)
 		{
 			var rparamsProps = routeParams.GetType()
 				.GetTypeInfo()
 				.DeclaredProperties;
 			var rparams = new Dictionary<string, string>();
 			foreach (var xp in rparamsProps)
 			{
 				var val = xp.GetValue(routeParams);
 				rparams[xp.Name] = val is string xs
 					? xs
 					: val is DateTime dt
 					? dt.ToString("yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture)
 					: val is DateTimeOffset dto
 					? dto.ToString("yyyy-MM-ddTHH:mm:sszzz", CultureInfo.InvariantCulture)
 					: val is IFormattable xf ? xf.ToString(null, CultureInfo.InvariantCulture) : val.ToString();
 			}
 
 			var guildId = rparams.ContainsKey("guild_id") ? rparams["guild_id"] : "";
 			var channelId = rparams.ContainsKey("channel_id") ? rparams["channel_id"] : "";
 			var webhookId = rparams.ContainsKey("webhook_id") ? rparams["webhook_id"] : "";
 
 			// Create a generic route (minus major params) key
 			// ex: POST:/channels/channel_id/messages
 			var hashKey = RateLimitBucket.GenerateHashKey(method, route);
 
 			// We check if the hash is present, using our generic route (without major params)
 			// ex: in POST:/channels/channel_id/messages, out 80c17d2f203122d936070c88c8d10f33
 			// If it doesn't exist, we create an unlimited hash as our initial key in the form of the hash key + the unlimited constant
 			// and assign this to the route to hash cache
 			// ex: this.RoutesToHashes[POST:/channels/channel_id/messages] = POST:/channels/channel_id/messages:unlimited
 			var hash = this._routesToHashes.GetOrAdd(hashKey, RateLimitBucket.GenerateUnlimitedHash(method, route));
 
 			// Next we use the hash to generate the key to obtain the bucket.
 			// ex: 80c17d2f203122d936070c88c8d10f33:guild_id:506128773926879242:webhook_id
 			// or if unlimited: POST:/channels/channel_id/messages:unlimited:guild_id:506128773926879242:webhook_id
 			var bucketId = RateLimitBucket.GenerateBucketId(hash, guildId, channelId, webhookId);
 
 			// If it's not in cache, create a new bucket and index it by its bucket id.
 			var bucket = this._hashesToBuckets.GetOrAdd(bucketId, new RateLimitBucket(hash, guildId, channelId, webhookId));
 
 			bucket.LastAttemptAt = DateTimeOffset.UtcNow;
 
 			// Cache the routes for each bucket so it can be used for GC later.
 			if (!bucket.RouteHashes.Contains(bucketId))
 				bucket.RouteHashes.Add(bucketId);
 
 			// Add the current route to the request queue, which indexes the amount
 			// of requests occurring to the bucket id.
 			_ = this._requestQueue.TryGetValue(bucketId, out var count);
 
 			// Increment by one atomically due to concurrency
 			this._requestQueue[bucketId] = Interlocked.Increment(ref count);
 
 			// Start bucket cleaner if not already running.
 			if (!this._cleanerRunning)
 			{
 				this._cleanerRunning = true;
 				this._bucketCleanerTokenSource = new CancellationTokenSource();
 				this._cleanerTask = Task.Run(this.CleanupBucketsAsync, this._bucketCleanerTokenSource.Token);
 				this._logger.LogDebug(LoggerEvents.RestCleaner, "Bucket cleaner task started.");
 			}
 
 			url = s_routeArgumentRegex.Replace(route, xm => rparams[xm.Groups[1].Value]);
 			return bucket;
 		}
 
 		/// <summary>
 		/// Executes the request.
 		/// </summary>
 		/// <param name="request">The request to be executed.</param>
 		public Task ExecuteRequestAsync(BaseRestRequest request)
 			=> request == null ? throw new ArgumentNullException(nameof(request)) : this.ExecuteRequestAsync(request, null, null);
 
 		/// <summary>
 		/// Executes the request.
 		/// This is to allow proper rescheduling of the first request from a bucket.
 		/// </summary>
 		/// <param name="request">The request to be executed.</param>
 		/// <param name="bucket">The bucket.</param>
 		/// <param name="ratelimitTcs">The ratelimit task completion source.</param>
 		private async Task ExecuteRequestAsync(BaseRestRequest request, RateLimitBucket bucket, TaskCompletionSource<bool> ratelimitTcs)
 		{
 			if (this._disposed)
 				return;
 
 			HttpResponseMessage res = default;
 
 			try
 			{
 				await this._globalRateLimitEvent.WaitAsync().ConfigureAwait(false);
 
 				if (bucket == null)
 					bucket = request.RateLimitBucket;
 
 				if (ratelimitTcs == null)
 					ratelimitTcs = await this.WaitForInitialRateLimit(bucket).ConfigureAwait(false);
 
 				if (ratelimitTcs == null) // ckeck rate limit only if we are not the probe request
 				{
 					var now = DateTimeOffset.UtcNow;
 
 					await bucket.TryResetLimitAsync(now).ConfigureAwait(false);
 
 					// Decrement the remaining number of requests as there can be other concurrent requests before this one finishes and has a chance to update the bucket
 					if (Interlocked.Decrement(ref bucket.RemainingInternal) < 0)
 					{
 						this._logger.LogDebug(LoggerEvents.RatelimitDiag, "Request for {0} is blocked", bucket.ToString());
 						var delay = bucket.Reset - now;
 						var resetDate = bucket.Reset;
 
 						if (this._useResetAfter)
 						{
 							delay = bucket.ResetAfter.Value;
 							resetDate = bucket.ResetAfterOffset;
 						}
 
 						if (delay < new TimeSpan(-TimeSpan.TicksPerMinute))
 						{
 							this._logger.LogError(LoggerEvents.RatelimitDiag, "Failed to retrieve ratelimits - giving up and allowing next request for bucket");
 							bucket.RemainingInternal = 1;
 						}
 
 						if (delay < TimeSpan.Zero)
 							delay = TimeSpan.FromMilliseconds(100);
 
 						this._logger.LogWarning(LoggerEvents.RatelimitPreemptive, "Preemptive ratelimit triggered - waiting until {0:yyyy-MM-dd HH:mm:ss zzz} ({1:c}).", resetDate, delay);
 						Task.Delay(delay)
 							.ContinueWith(_ => this.ExecuteRequestAsync(request, null, null))
 							.LogTaskFault(this._logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 
 						return;
 					}
 					this._logger.LogDebug(LoggerEvents.RatelimitDiag, "Request for {0} is allowed", bucket.ToString());
 				}
 				else
 					this._logger.LogDebug(LoggerEvents.RatelimitDiag, "Initial request for {0} is allowed", bucket.ToString());
 
 				var req = this.BuildRequest(request);
 
 				if (this.Debug)
 					this._logger.LogTrace(LoggerEvents.Misc, await req.Content.ReadAsStringAsync());
 
 				var response = new RestResponse();
 				try
 				{
 					if (this._disposed)
 						return;
 
 					res = await this.HttpClient.SendAsync(req, HttpCompletionOption.ResponseContentRead, CancellationToken.None).ConfigureAwait(false);
 
 					var bts = await res.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
 					var txt = Utilities.UTF8.GetString(bts, 0, bts.Length);
 
 					this._logger.LogTrace(LoggerEvents.RestRx, txt);
 
 					response.Headers = res.Headers.ToDictionary(xh => xh.Key, xh => string.Join("\n", xh.Value), StringComparer.OrdinalIgnoreCase);
 					response.Response = txt;
 					response.ResponseCode = (int)res.StatusCode;
 				}
 				catch (HttpRequestException httpex)
 				{
 					this._logger.LogError(LoggerEvents.RestError, httpex, "Request to {0} triggered an HttpException", request.Url);
 					request.SetFaulted(httpex);
 					this.FailInitialRateLimitTest(request, ratelimitTcs);
 					return;
 				}
 
 				this.UpdateBucket(request, response, ratelimitTcs);
 
 				Exception ex = null;
 				switch (response.ResponseCode)
 				{
 					case 400:
 					case 405:
 						ex = new BadRequestException(request, response);
 						break;
 
 					case 401:
 					case 403:
 						ex = new UnauthorizedException(request, response);
 						break;
 
 					case 404:
 						ex = new NotFoundException(request, response);
 						break;
 
 					case 413:
 						ex = new RequestSizeException(request, response);
 						break;
 
 					case 429:
 						ex = new RateLimitException(request, response);
 
 						// check the limit info and requeue
 						this.Handle429(response, out var wait, out var global);
 						if (wait != null)
 						{
 							if (global)
 							{
 								bucket.IsGlobal = true;
 								this._logger.LogError(LoggerEvents.RatelimitHit, "Global ratelimit hit, cooling down");
 								try
 								{
 									this._globalRateLimitEvent.Reset();
 									await wait.ConfigureAwait(false);
 								}
 								finally
 								{
 									// we don't want to wait here until all the blocked requests have been run, additionally Set can never throw an exception that could be suppressed here
 									_ = this._globalRateLimitEvent.SetAsync();
 								}
 								this.ExecuteRequestAsync(request, bucket, ratelimitTcs)
 									.LogTaskFault(this._logger, LogLevel.Error, LoggerEvents.RestError, "Error while retrying request");
 							}
 							else
 							{
 								if (this._discord is DiscordClient)
 								{
 									await (this._discord as DiscordClient)._rateLimitHit.InvokeAsync(this._discord as DiscordClient, new EventArgs.RateLimitExceptionEventArgs(this._discord.ServiceProvider)
 									{
 										Exception = ex as RateLimitException,
 										ApiEndpoint = request.Url.AbsoluteUri
 									});
 								}
 								this._logger.LogError(LoggerEvents.RatelimitHit, "Ratelimit hit, requeuing request to {0}", request.Url);
 								await wait.ConfigureAwait(false);
 								this.ExecuteRequestAsync(request, bucket, ratelimitTcs)
 									.LogTaskFault(this._logger, LogLevel.Error, LoggerEvents.RestError, "Error while retrying request");
 							}
 
 							return;
 						}
 						break;
 
 					case 500:
 					case 502:
 					case 503:
 					case 504:
 						ex = new ServerErrorException(request, response);
 						break;
 				}
 
 				if (ex != null)
 					request.SetFaulted(ex);
 				else
 					request.SetCompleted(response);
 			}
 			catch (Exception ex)
 			{
 				this._logger.LogError(LoggerEvents.RestError, ex, "Request to {0} triggered an exception", request.Url);
 
 				// if something went wrong and we couldn't get rate limits for the first request here, allow the next request to run
 				if (bucket != null && ratelimitTcs != null && bucket.LimitTesting != 0)
 					this.FailInitialRateLimitTest(request, ratelimitTcs);
 
 				if (!request.TrySetFaulted(ex))
 					throw;
 			}
 			finally
 			{
 				res?.Dispose();
 
 				// Get and decrement active requests in this bucket by 1.
 				_ = this._requestQueue.TryGetValue(bucket.BucketId, out var count);
 				this._requestQueue[bucket.BucketId] = Interlocked.Decrement(ref count);
 
 				// If it's 0 or less, we can remove the bucket from the active request queue,
 				// along with any of its past routes.
 				if (count <= 0)
 				{
 					foreach (var r in bucket.RouteHashes)
 					{
 						if (this._requestQueue.ContainsKey(r))
 						{
 							_ = this._requestQueue.TryRemove(r, out _);
 						}
 					}
 				}
 			}
 		}
 
 		/// <summary>
 		/// Fails the initial rate limit test.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		/// <param name="ratelimitTcs">The ratelimit task completion source.</param>
 		/// <param name="resetToInitial">Whether to reset to initial values.</param>
 		private void FailInitialRateLimitTest(BaseRestRequest request, TaskCompletionSource<bool> ratelimitTcs, bool resetToInitial = false)
 		{
 			if (ratelimitTcs == null && !resetToInitial)
 				return;
 
 			var bucket = request.RateLimitBucket;
 
 			bucket.LimitValid = false;
 			bucket.LimitTestFinished = null;
 			bucket.LimitTesting = 0;
 
 			//Reset to initial values.
 			if (resetToInitial)
 			{
 				this.UpdateHashCaches(request, bucket);
 				bucket.Maximum = 0;
 				bucket.RemainingInternal = 0;
 				return;
 			}
 
 			// no need to wait on all the potentially waiting tasks
 			_ = Task.Run(() => ratelimitTcs.TrySetResult(false));
 		}
 
 		/// <summary>
 		/// Waits for the initial rate limit.
 		/// </summary>
 		/// <param name="bucket">The bucket.</param>
 		private async Task<TaskCompletionSource<bool>> WaitForInitialRateLimit(RateLimitBucket bucket)
 		{
 			while (!bucket.LimitValid)
 			{
 				if (bucket.LimitTesting == 0)
 				{
 					if (Interlocked.CompareExchange(ref bucket.LimitTesting, 1, 0) == 0)
 					{
 						// if we got here when the first request was just finishing, we must not create the waiter task as it would signal ExecureRequestAsync to bypass rate limiting
 						if (bucket.LimitValid)
 							return null;
 
 						// allow exactly one request to go through without having rate limits available
 						var ratelimitsTcs = new TaskCompletionSource<bool>();
 						bucket.LimitTestFinished = ratelimitsTcs.Task;
 						return ratelimitsTcs;
 					}
 				}
 				// it can take a couple of cycles for the task to be allocated, so wait until it happens or we are no longer probing for the limits
 				Task waitTask = null;
 				while (bucket.LimitTesting != 0 && (waitTask = bucket.LimitTestFinished) == null)
 					await Task.Yield();
 				if (waitTask != null)
 					await waitTask.ConfigureAwait(false);
 
 				// if the request failed and the response did not have rate limit headers we have allow the next request and wait again, thus this is a loop here
 			}
 			return null;
 		}
 
 		/// <summary>
 		/// Builds the request.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		/// <returns>A http request message.</returns>
 		private HttpRequestMessage BuildRequest(BaseRestRequest request)
 		{
 			var req = new HttpRequestMessage(new HttpMethod(request.Method.ToString()), request.Url);
 			if (request.Headers != null && request.Headers.Any())
 				foreach (var kvp in request.Headers)
 					req.Headers.Add(kvp.Key, kvp.Value);
 
 			if (request is RestRequest nmprequest && !string.IsNullOrWhiteSpace(nmprequest.Payload))
 			{
 				this._logger.LogTrace(LoggerEvents.RestTx, nmprequest.Payload);
 
 				req.Content = new StringContent(nmprequest.Payload);
 				req.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
 			}
 
 			if (request is MultipartWebRequest mprequest)
 			{
 				this._logger.LogTrace(LoggerEvents.RestTx, "<multipart request>");
 
 				var boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x");
 
 				req.Headers.Add("Connection", "keep-alive");
 				req.Headers.Add("Keep-Alive", "600");
 
 				var content = new MultipartFormDataContent(boundary);
 				if (mprequest.Values != null && mprequest.Values.Any())
 					foreach (var kvp in mprequest.Values)
 						content.Add(new StringContent(kvp.Value), kvp.Key);
 
 				var fileId = mprequest.OverwriteFileIdStart ?? 0;
 
 				if (mprequest.Files != null && mprequest.Files.Any())
 				{
 					foreach (var f in mprequest.Files)
 					{
 						var name = $"files[{fileId.ToString(CultureInfo.InvariantCulture)}]";
 						content.Add(new StreamContent(f.Value), name, f.Key);
 						fileId++;
 					}
 				}
 
 				req.Content = content;
 			}
 
 			if (request is MultipartStickerWebRequest mpsrequest)
 			{
 				this._logger.LogTrace(LoggerEvents.RestTx, "<multipart request>");
 
 				var boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x");
 
 				req.Headers.Add("Connection", "keep-alive");
 				req.Headers.Add("Keep-Alive", "600");
 
 				var sc = new StreamContent(mpsrequest.File.Stream);
 
 				if (mpsrequest.File.ContentType != null)
 					sc.Headers.ContentType = new MediaTypeHeaderValue(mpsrequest.File.ContentType);
 
 				var fileName = mpsrequest.File.FileName;
 
 				if (mpsrequest.File.FileType != null)
 					fileName += '.' + mpsrequest.File.FileType;
 
 				var content = new MultipartFormDataContent(boundary)
 				{
 					{ new StringContent(mpsrequest.Name), "name" },
 					{ new StringContent(mpsrequest.Tags), "tags" },
 					{ new StringContent(mpsrequest.Description), "description" },
 					{ sc, "file", fileName }
 				};
 
 				req.Content = content;
 			}
 			return req;
 		}
 
 		/// <summary>
 		/// Handles the HTTP 429 status.
 		/// </summary>
 		/// <param name="response">The response.</param>
 		/// <param name="waitTask">The wait task.</param>
 		/// <param name="global">If true, global.</param>
 		private void Handle429(RestResponse response, out Task waitTask, out bool global)
 		{
 			waitTask = null;
 			global = false;
 
 			if (response.Headers == null)
 				return;
 			var hs = response.Headers;
 
 			// handle the wait
 			if (hs.TryGetValue("Retry-After", out var retryAfterRaw))
 			{
 				var retryAfter = TimeSpan.FromSeconds(int.Parse(retryAfterRaw, CultureInfo.InvariantCulture));
 				waitTask = Task.Delay(retryAfter);
 			}
 
 			// check if global b1nzy
 			if (hs.TryGetValue("X-RateLimit-Global", out var isGlobal) && isGlobal.ToLowerInvariant() == "true")
 			{
 				// global
 				global = true;
 			}
 		}
 
 		/// <summary>
 		/// Updates the bucket.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		/// <param name="response">The response.</param>
 		/// <param name="ratelimitTcs">The ratelimit task completion source.</param>
 		private void UpdateBucket(BaseRestRequest request, RestResponse response, TaskCompletionSource<bool> ratelimitTcs)
 		{
 			var bucket = request.RateLimitBucket;
 
 			if (response.Headers == null)
 			{
 				if (response.ResponseCode != 429) // do not fail when ratelimit was or the next request will be scheduled hitting the rate limit again
 					this.FailInitialRateLimitTest(request, ratelimitTcs);
 				return;
 			}
 
 			var hs = response.Headers;
 
 			if (hs.TryGetValue("X-RateLimit-Scope", out var scope))
 			{
 				bucket.Scope = scope;
 			}
 
 
 			if (hs.TryGetValue("X-RateLimit-Global", out var isGlobal) && isGlobal.ToLowerInvariant() == "true")
 			{
 				if (response.ResponseCode != 429)
 				{
 					bucket.IsGlobal = true;
 					this.FailInitialRateLimitTest(request, ratelimitTcs);
 				}
 
 				return;
 			}
 
 			var r1 = hs.TryGetValue("X-RateLimit-Limit", out var usesMax);
 			var r2 = hs.TryGetValue("X-RateLimit-Remaining", out var usesLeft);
 			var r3 = hs.TryGetValue("X-RateLimit-Reset", out var reset);
 			var r4 = hs.TryGetValue("X-Ratelimit-Reset-After", out var resetAfter);
 			var r5 = hs.TryGetValue("X-Ratelimit-Bucket", out var hash);
 
 			if (!r1 || !r2 || !r3 || !r4)
 			{
 				//If the limits were determined before this request, make the bucket initial again.
 				if (response.ResponseCode != 429)
 					this.FailInitialRateLimitTest(request, ratelimitTcs, ratelimitTcs == null);
 
 				return;
 			}
 
 			var clientTime = DateTimeOffset.UtcNow;
 			var resetTime = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).AddSeconds(double.Parse(reset, CultureInfo.InvariantCulture));
 			var serverTime = clientTime;
 			if (hs.TryGetValue("Date", out var rawDate))
 				serverTime = DateTimeOffset.Parse(rawDate, CultureInfo.InvariantCulture).ToUniversalTime();
 
 			var resetDelta = resetTime - serverTime;
 			//var difference = clientTime - serverTime;
 			//if (Math.Abs(difference.TotalSeconds) >= 1)
 			////    this.Logger.LogMessage(LogLevel.DebugBaseDiscordClient.RestEventId,  $"Difference between machine and server time: {difference.TotalMilliseconds.ToString("#,##0.00", CultureInfo.InvariantCulture)}ms", DateTime.Now);
 			//else
 			//    difference = TimeSpan.Zero;
 
 			if (request.RateLimitWaitOverride.HasValue)
 				resetDelta = TimeSpan.FromSeconds(request.RateLimitWaitOverride.Value);
 			var newReset = clientTime + resetDelta;
 
 			if (this._useResetAfter)
 			{
 				bucket.ResetAfter = TimeSpan.FromSeconds(double.Parse(resetAfter, CultureInfo.InvariantCulture));
 				newReset = clientTime + bucket.ResetAfter.Value + (request.RateLimitWaitOverride.HasValue
 					? resetDelta
 					: TimeSpan.Zero);
 				bucket.ResetAfterOffset = newReset;
 			}
 			else
 				bucket.Reset = newReset;
 
 			var maximum = int.Parse(usesMax, CultureInfo.InvariantCulture);
 			var remaining = int.Parse(usesLeft, CultureInfo.InvariantCulture);
 
 			if (ratelimitTcs != null)
 			{
 				// initial population of the ratelimit data
 				bucket.SetInitialValues(maximum, remaining, newReset);
 
 				_ = Task.Run(() => ratelimitTcs.TrySetResult(true));
 			}
 			else
 			{
 				// only update the bucket values if this request was for a newer interval than the one
 				// currently in the bucket, to avoid issues with concurrent requests in one bucket
 				// remaining is reset by TryResetLimit and not the response, just allow that to happen when it is time
 				if (bucket.NextReset == 0)
 					bucket.NextReset = newReset.UtcTicks;
 			}
 
 			this.UpdateHashCaches(request, bucket, hash);
 		}
 
 		/// <summary>
 		/// Updates the hash caches.
 		/// </summary>
 		/// <param name="request">The request.</param>
 		/// <param name="bucket">The bucket.</param>
 		/// <param name="newHash">The new hash.</param>
 		private void UpdateHashCaches(BaseRestRequest request, RateLimitBucket bucket, string newHash = null)
 		{
 			var hashKey = RateLimitBucket.GenerateHashKey(request.Method, request.Route);
 
 			if (!this._routesToHashes.TryGetValue(hashKey, out var oldHash))
 				return;
 
 			// This is an unlimited bucket, which we don't need to keep track of.
 			if (newHash == null)
 			{
 				_ = this._routesToHashes.TryRemove(hashKey, out _);
 				_ = this._hashesToBuckets.TryRemove(bucket.BucketId, out _);
 				return;
 			}
 
 			// Only update the hash once, due to a bug on Discord's end.
 			// This will cause issues if the bucket hashes are dynamically changed from the API while running,
 			// in which case, Dispose will need to be called to clear the caches.
 			if (bucket.IsUnlimited && newHash != oldHash)
 			{
 				this._logger.LogDebug(LoggerEvents.RestHashMover, "Updating hash in {0}: \"{1}\" -> \"{2}\"", hashKey, oldHash, newHash);
 				var bucketId = RateLimitBucket.GenerateBucketId(newHash, bucket.GuildId, bucket.ChannelId, bucket.WebhookId);
 
 				_ = this._routesToHashes.AddOrUpdate(hashKey, newHash, (key, oldHash) =>
 				{
 					bucket.Hash = newHash;
 
 					var oldBucketId = RateLimitBucket.GenerateBucketId(oldHash, bucket.GuildId, bucket.ChannelId, bucket.WebhookId);
 
 					// Remove the old unlimited bucket.
 					_ = this._hashesToBuckets.TryRemove(oldBucketId, out _);
 					_ = this._hashesToBuckets.AddOrUpdate(bucketId, bucket, (key, oldBucket) => bucket);
 
 					return newHash;
 				});
 			}
 
 			return;
 		}
 
 		/// <summary>
 		/// Cleans the buckets.
 		/// </summary>
 		private async Task CleanupBucketsAsync()
 		{
 			while (!this._bucketCleanerTokenSource.IsCancellationRequested)
 			{
 				try
 				{
 					await Task.Delay(this._bucketCleanupDelay, this._bucketCleanerTokenSource.Token).ConfigureAwait(false);
 				}
 				catch { }
 
 				if (this._disposed)
 					return;
 
 				//Check and clean request queue first in case it wasn't removed properly during requests.
 				foreach (var key in this._requestQueue.Keys)
 				{
 					var bucket = this._hashesToBuckets.Values.FirstOrDefault(x => x.RouteHashes.Contains(key));
 
 					if (bucket == null || (bucket != null && bucket.LastAttemptAt.AddSeconds(5) < DateTimeOffset.UtcNow))
 						_ = this._requestQueue.TryRemove(key, out _);
 				}
 
 				var removedBuckets = 0;
 				StringBuilder bucketIdStrBuilder = default;
 
 				foreach (var kvp in this._hashesToBuckets)
 				{
 					if (bucketIdStrBuilder == null)
 						bucketIdStrBuilder = new StringBuilder();
 
 					var key = kvp.Key;
 					var value = kvp.Value;
 
 					// Don't remove the bucket if it's currently being handled by the rest client, unless it's an unlimited bucket.
 					if (this._requestQueue.ContainsKey(value.BucketId) && !value.IsUnlimited)
 						continue;
 
 					var resetOffset = this._useResetAfter ? value.ResetAfterOffset : value.Reset;
 
 					// Don't remove the bucket if it's reset date is less than now + the additional wait time, unless it's an unlimited bucket.
-					if (resetOffset != null && !value.IsUnlimited && (resetOffset > DateTimeOffset.UtcNow || DateTimeOffset.UtcNow - resetOffset < this._bucketCleanupDelay))
+					if (!value.IsUnlimited && (resetOffset > DateTimeOffset.UtcNow || DateTimeOffset.UtcNow - resetOffset < this._bucketCleanupDelay))
 						continue;
 
 					_ = this._hashesToBuckets.TryRemove(key, out _);
 					removedBuckets++;
 					bucketIdStrBuilder.Append(value.BucketId + ", ");
 				}
 
 				if (removedBuckets > 0)
 					this._logger.LogDebug(LoggerEvents.RestCleaner, "Removed {0} unused bucket{1}: [{2}]", removedBuckets, removedBuckets > 1 ? "s" : string.Empty, bucketIdStrBuilder.ToString().TrimEnd(',', ' '));
 
 				if (this._hashesToBuckets.Count == 0)
 					break;
 			}
 
 			if (!this._bucketCleanerTokenSource.IsCancellationRequested)
 				this._bucketCleanerTokenSource.Cancel();
 
 			this._cleanerRunning = false;
 			this._logger.LogDebug(LoggerEvents.RestCleaner, "Bucket cleaner task stopped.");
 		}
 
 		~RestClient()
 		{
 			this.Dispose();
 		}
 
 		/// <summary>
 		/// Disposes the rest client.
 		/// </summary>
 		public void Dispose()
 		{
 			if (this._disposed)
 				return;
 
 			this._disposed = true;
 
 			this._globalRateLimitEvent.Reset();
 
 			if (this._bucketCleanerTokenSource?.IsCancellationRequested == false)
 			{
 				this._bucketCleanerTokenSource?.Cancel();
 				this._logger.LogDebug(LoggerEvents.RestCleaner, "Bucket cleaner task stopped.");
 			}
 
 			try
 			{
 				this._cleanerTask?.Dispose();
 				this._bucketCleanerTokenSource?.Dispose();
 				this.HttpClient?.Dispose();
 			}
 			catch { }
 
 			this._routesToHashes.Clear();
 			this._hashesToBuckets.Clear();
 			this._requestQueue.Clear();
 		}
 	}
 }