diff --git a/DisCatSharp.ApplicationCommands/ApplicationCommandsConfiguration.cs b/DisCatSharp.ApplicationCommands/ApplicationCommandsConfiguration.cs
index 11ea2f560..0379e9510 100644
--- a/DisCatSharp.ApplicationCommands/ApplicationCommandsConfiguration.cs
+++ b/DisCatSharp.ApplicationCommands/ApplicationCommandsConfiguration.cs
@@ -1,97 +1,103 @@
 // 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 Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.ApplicationCommands
 {
 	/// <summary>
 	/// A configuration for a <see cref="ApplicationCommandsExtension"/>
 	/// </summary>
 	public class ApplicationCommandsConfiguration
 	{
 		/// <summary>
 		/// <para>Sets the service provider.</para>
 		/// <para>Objects in this provider are used when instantiating application command modules. This allows passing data around without resorting to static members.</para>
 		/// <para>Defaults to null.</para>
 		/// </summary>
 		public IServiceProvider ServiceProvider { internal get; set; } = new ServiceCollection().BuildServiceProvider(true);
 
 		/// <summary>
 		/// <para>Sets whether to enable default help command.</para>
 		/// <para>Disabling this will allow you to make your own help command.</para>
 		/// <para>
 		/// </para>
 		/// <para>Defaults to true.</para>
 		/// </summary>
 		public bool EnableDefaultHelp { internal get; set; } = true;
 
 		/// <summary>
 		/// Debugs the startup.
 		/// </summary>
 		public bool DebugStartup { internal get; set; } = false;
 
+		/// <summary>
+		/// Enable localization features.
+		/// </summary>
+		public bool EnableLocalization { internal get; set; } = false;
+
 		/// <summary>
 		/// Manual override.
 		/// <note type="warning">DO NOT USE THIS!</note>
 		/// </summary>
 		public bool ManualOverride { internal get; set; } = false;
 
 		/// <summary>
 		/// Automatically defer all responses.
 		/// <note type="note">If you enable this, you can't use CreateResponse. Use EditResponse instad.</note>
 		/// </summary>
 		public bool AutoDefer { internal get; set; } = false;
 
 		/// <summary>
 		/// Checks through all guilds.
 		/// <note type="warning">This will take quite a while, when the bot is on more than 1k guilds.</note>
 		/// </summary>
 		public bool CheckAllGuilds { internal get; set; } = false;
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="ApplicationCommandsConfiguration"/> class.
 		/// </summary>
 		/// <param name="provider">The service provider.</param>
 		[ActivatorUtilitiesConstructor]
 		public ApplicationCommandsConfiguration(IServiceProvider provider = null)
 		{
 			this.ServiceProvider = provider;
 		}
 
 		/// <summary>
 		/// Creates a new instance of <see cref="ApplicationCommandsConfiguration"/>, copying the properties of another configuration.
 		/// </summary>
 		/// <param name="acc">Configuration the properties of which are to be copied.</param>
 		public ApplicationCommandsConfiguration(ApplicationCommandsConfiguration acc)
 		{
 			this.EnableDefaultHelp = acc.EnableDefaultHelp;
 			this.ServiceProvider = acc.ServiceProvider;
 			this.DebugStartup = acc.DebugStartup;
 			this.CheckAllGuilds = acc.CheckAllGuilds;
 			this.ManualOverride = acc.ManualOverride;
 			this.AutoDefer = acc.AutoDefer;
+			this.EnableLocalization = acc.EnableLocalization;
 		}
 	}
 }
diff --git a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
index adf9ecb78..7be32de5a 100644
--- a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
+++ b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
@@ -1,2093 +1,2096 @@
 // 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>
 		/// Whether the permission failed to register.
 		/// </summary>
 		private static bool s_permError { get; set; } = false;
 
 		/// <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_permError = 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), true)));
 		}
 
 		/// <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, true)));
 		}
 
 		/// <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="permissionSetup">A callback to setup permissions with.</param>
 		/// <param name="translationSetup">A callback to setup translations with.</param>
 		public void RegisterGuildCommands<T>(ulong guildId, Action<ApplicationCommandsPermissionContext> permissionSetup = null, Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
 		{
 			if (this.Client.ShardId == 0)
 				this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(typeof(T), permissionSetup, translationSetup)));
 		}
 
 		/// <summary>
 		/// Registers a command class with permission and translation setup.
 		/// </summary>
 		/// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
 		/// <param name="guildId">The guild id to register it on.</param>
 		/// <param name="permissionSetup">A callback to setup permissions with.</param>
 		/// <param name="translationSetup">A callback to setup translations with.</param>
 		public void RegisterGuildCommands(Type type, ulong guildId, Action<ApplicationCommandsPermissionContext> permissionSetup = null, Action<ApplicationCommandsTranslationContext> translationSetup = null)
 		{
 			if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
 				throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
 			//If sharding, only register for shard 0
 			if (this.Client.ShardId == 0)
 				this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(type, permissionSetup, translationSetup)));
 		}
 
 		/// <summary>
 		/// Registers a command class with permission setup but without a guild id.
 		/// </summary>
 		/// <typeparam name="T">The command class to register.</typeparam>
 		/// <param name="globalGuildPermissionSetup">A callback to setup permissions with.</param>
 		/// <param name="translationSetup">A callback to setup translations with.</param>
 		public void RegisterGlobalCommands<T>(Action<ApplicationCommandsGlobalPermissionContext> globalGuildPermissionSetup = null, Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
         {
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(typeof(T), true, globalGuildPermissionSetup, 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="globalGuildPermissionSetup">A callback to setup permissions with.</param>
 		/// <param name="translationSetup">A callback to setup translations with.</param>
 		public void RegisterGlobalCommands(Type type, Action<ApplicationCommandsGlobalPermissionContext> globalGuildPermissionSetup = null, Action<ApplicationCommandsTranslationContext> translationSetup = null)
         {
             if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
                 throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
             //If sharding, only register for shard 0
             if (this.Client.ShardId == 0)
                 this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(type, true, globalGuildPermissionSetup, 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() ?? 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) ?? null;
+						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), true)));
 					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 slashGroupsTulpe = NestedCommandWorker.ParseSlashGroupsAsync(type, classes, guildid, groupTranslations).Result;
 
 						if (slashGroupsTulpe.applicationCommands != null && slashGroupsTulpe.applicationCommands.Any())
 							updateList.AddRange(slashGroupsTulpe.applicationCommands);
 
 						if (slashGroupsTulpe.commandTypeSources != null && slashGroupsTulpe.commandTypeSources.Any())
 							commandTypeSources.AddRange(slashGroupsTulpe.commandTypeSources);
 
 						if (slashGroupsTulpe.singletonModules != null && slashGroupsTulpe.singletonModules.Any())
 							s_singletonModules.AddRange(slashGroupsTulpe.singletonModules);
 
 						if (slashGroupsTulpe.groupCommands != null && slashGroupsTulpe.groupCommands.Any())
 							groupCommands.AddRange(slashGroupsTulpe.groupCommands);
 
 						if (slashGroupsTulpe.subGroupCommands != null && slashGroupsTulpe.subGroupCommands.Any())
 							subGroupCommands.AddRange(slashGroupsTulpe.subGroupCommands);
 
 						//Handles methods and context menus, only if the module isn't a group itself
 						if (module.GetCustomAttribute<SlashCommandGroupAttribute>() == null)
 						{
 							List<CommandTranslator> commandTranslations = null;
 
 							if (!string.IsNullOrEmpty(ctx.Translations))
 							{
 								commandTranslations = JsonConvert.DeserializeObject<List<CommandTranslator>>(ctx.Translations);
+								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).Result;
+									var regCommands = RegistrationWorker.RegisterGlobalCommandsAsync(updateList, withLocales).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).Result;
+									var regCommands = RegistrationWorker.RegisterGuilldCommandsAsync(guildid.Value, updateList, withLocales).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;
 						}
 
 						// TODO: Rework permission and minimize put/post/patch calls
 
 						//Creates a guild command if a guild id is specified, otherwise global
 						//Checks against the ids and adds them to the command method lists
 						List<DiscordGuildApplicationCommandPermission> overwrites = new();
 						List< KeyValuePair<ulong, DiscordGuildApplicationCommandPermission>> guildOverwrites = new();
 
 						foreach (var command in commands)
 						{
 							if (commandMethods.GetFirstValueWhere(x => x.Name == command.Name, out var com))
 							{
 								com.CommandId = command.Id;
 
 								var source = commandTypeSources.FirstOrDefault(f => f.Key == com.Method.DeclaringType);
 
 								if(guildid != null)
 								{
 									var (success, commandId, permissions) = PermissionWorker.ResolvePermissions(types, command.Id, com.Name, source.Value, source.Key);
 
 									if (success)
 									{
 										overwrites.Add(new DiscordGuildApplicationCommandPermission()
 										{
 											Id = commandId.Value,
 											Permissions = permissions
 										});
 									}
 								}
 								else
 								{
 									var (success, commandId, permissions) = PermissionWorker.ResolveGlobalPermissions(types, command.Id, com.Name, source.Value, source.Key);
 
 									if (success)
 									{
 										var perms = permissions.Select(x => x.Key).Distinct();
 										foreach(var guild in perms)
 										{
 											guildOverwrites.Add(new KeyValuePair<ulong, DiscordGuildApplicationCommandPermission>(guild, new DiscordGuildApplicationCommandPermission()
 											{
 												Id = commandId.Value,
 												Permissions = permissions.Where(x => x.Key == guild).Select(x => x.Value).ToList(),
 												GuildId = guild
 											}));
 										}
 									}
 								}
 							}
 							else if (groupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var groupCom))
 							{
 								groupCom.CommandId = command.Id;
 								foreach (var gCom in groupCom.Methods)
 								{
 									var source = commandTypeSources.FirstOrDefault(f => f.Key == gCom.Value.DeclaringType);
 
 									if (guildid != null)
 									{
 										var (success, commandId, permissions) = PermissionWorker.ResolvePermissions(types, groupCom.CommandId, gCom.Key, source.Key, source.Value);
 
 										if (success)
 											overwrites.Add(new DiscordGuildApplicationCommandPermission()
 											{
 												Id = commandId.Value,
 												Permissions = permissions
 											});
 									}
 									else
 									{
 										var (success, commandId, permissions) = PermissionWorker.ResolveGlobalPermissions(types, groupCom.CommandId, gCom.Key, source.Key, source.Value);
 
 										if (success)
 										{
 											var perms = permissions.Select(x => x.Key).Distinct();
 											foreach (var guild in perms)
 											{
 												guildOverwrites.Add(new KeyValuePair<ulong, DiscordGuildApplicationCommandPermission>(guild, new DiscordGuildApplicationCommandPermission()
 												{
 													Id = commandId.Value,
 													Permissions = permissions.Where(x => x.Key == guild).Select(x => x.Value).ToList(),
 													GuildId = guild
 												}));
 											}
 										}
 									}
 								}
 							}
 							else if (subGroupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var subCom))
 							{
 								subCom.CommandId = command.Id;
 
 								foreach (var groupComs in subCom.SubCommands)
 								{
 									foreach (var gCom in groupComs.Methods)
 									{
 										var source = commandTypeSources.FirstOrDefault(f => f.Key == gCom.Value.DeclaringType);
 
 										if (guildid != null)
 										{
 											var (success, commandId, permissions) = PermissionWorker.ResolvePermissions(types, subCom.CommandId, gCom.Key, source.Key, source.Value);
 
 											if (success)
 												overwrites.Add(new DiscordGuildApplicationCommandPermission()
 												{
 													Id = commandId.Value,
 													Permissions = permissions
 												});
 										}
 										else
 										{
 											var (success, commandId, permissions) = PermissionWorker.ResolveGlobalPermissions(types, subCom.CommandId, gCom.Key, source.Key, source.Value);
 
 											if (success)
 											{
 												var perms = permissions.Select(x => x.Key).Distinct();
 												foreach (var guild in perms)
 												{
 													guildOverwrites.Add(new KeyValuePair<ulong, DiscordGuildApplicationCommandPermission>(guild, new DiscordGuildApplicationCommandPermission()
 													{
 														Id = commandId.Value,
 														Permissions = permissions.Where(x => x.Key == guild).Select(x => x.Value).ToList(),
 														GuildId = guild
 													}));
 												}
 											}
 										}
 									}
 								}
 							}
 							else if (contextMenuCommands.GetFirstValueWhere(x => x.Name == command.Name, out var cmCom))
 							{
 								cmCom.CommandId = command.Id;
 
 								var source = commandTypeSources.First(f => f.Key == cmCom.Method.DeclaringType);
 
 								if (guildid != null)
 								{
 									var (success, commandId, permissions) = PermissionWorker.ResolvePermissions(types, command.Id, cmCom.Name, source.Value, source.Key);
 
 									if (success)
 										overwrites.Add(new DiscordGuildApplicationCommandPermission()
 										{
 											Id = commandId.Value,
 											Permissions = permissions
 										});
 								}
 								else
 								{
 									var (success, commandId, permissions) = PermissionWorker.ResolveGlobalPermissions(types, command.Id, cmCom.Name, source.Value, source.Key);
 
 									if (success)
 									{
 										var perms = permissions.Select(x => x.Key).Distinct();
 										foreach (var guild in perms)
 										{
 											guildOverwrites.Add(new KeyValuePair<ulong, DiscordGuildApplicationCommandPermission>(guild, new DiscordGuildApplicationCommandPermission()
 											{
 												Id = commandId.Value,
 												Permissions = permissions.Where(x => x.Key == guild).Select(x => x.Value).ToList(),
 												GuildId = guild
 											}));
 										}
 									}
 								}
 							}
 						}
 						
 						if (guildid != null && overwrites != null && overwrites.Any())
 						{
 							if (overwrites.Any(x => x.Id == 0))
 							{
 								s_errored = true;
 								s_permError = true;
 								throw new ArgumentException("Overwrites has a value with command id 0. Seems like an error. Aborting.");
 							}
 
 							try
 							{
 								var perms = await PermissionWorker.BulkOverwriteCommandPermissionsAsync(guildid.Value, overwrites);
 								if (this.Client.Guilds.TryGetValue(guildid.Value, out var guild))
 								{
 									guild.InternalGuildApplicationCommandPermissions = new();
 									guild.InternalGuildApplicationCommandPermissions.AddRange(perms);
 								}
 							}
 							catch (Exception ex)
 							{
 								if (ex is NotFoundException)
 									this.Client.Logger.LogError($"[AC Perms] Command not found");
 								else if (ex is BadRequestException)
 								{
 									s_permError = true;
 									var exc = ex as BadRequestException;
 									this.Client.Logger.LogError($"[AC Perms] Bad Request: {exc.JsonMessage}\nRestarting could help.\n" +
 										$"{exc.WebResponse.Response}");
 								}
 								else
 									this.Client.Logger.LogError($"[AC Perms] General exception: {ex.Message}\n{ex.StackTrace}\nRestarting could help.");
 							}
 						}
 						else if (guildOverwrites != null && guildOverwrites.Any())
 						{
 							if (guildOverwrites.Select(x=> x.Value).Any(x => x.Id == 0))
 							{
 								s_errored = true;
 								s_permError = true;
 								throw new ArgumentException("Overwrites has a value with command id 0. Seems like an error. Aborting.");
 							}
 							
 							try
 							{
 								var gOv = guildOverwrites.Select(x => x.Key).Distinct();
 								foreach(var gid in gOv)
 {
 									var perms = await PermissionWorker.BulkOverwriteCommandPermissionsAsync(gid, guildOverwrites.Where(x => x.Key == gid).Select(x => x.Value).ToList());
 									if (this.Client.Guilds.TryGetValue(gid, out var guild))
 									{
 										guild.InternalGuildApplicationCommandPermissions = new();
 										guild.InternalGuildApplicationCommandPermissions.AddRange(perms);
 									}
 								}
 							}
 							catch (Exception ex)
 							{
 								if (ex is NotFoundException)
 									this.Client.Logger.LogError($"[AC Perms] Command not found");
 								else if (ex is BadRequestException)
 								{
 									s_permError = true;
 									var exc = ex as BadRequestException;
 									this.Client.Logger.LogError($"[AC Perms] Bad Request: {exc.JsonMessage}\nRestarting could help.\n" +
 										$"{exc.WebResponse.Response}");
 								}
 								else
 									this.Client.Logger.LogError($"[AC Perms] General exception: {ex.Message}\n{ex.StackTrace}\nRestarting could help.");
 							}
 						}
 						
 						//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 && !s_permError) || man)
 			{
 				await this._applicationCommandsModuleStartupFinished.InvokeAsync(this, new ApplicationCommandsModuleStartupFinishedEventArgs(Configuration?.ServiceProvider)
 				{
 					Handled = true,
 					RegisteredGlobalCommands = GlobalCommandsInternal,
 					RegisteredGuildCommands = GuildCommandsInternal,
 					GuildsWithoutScope = this._missingScopeGuildIds
 				});
 
 				this.FinishedRegistration();
 			}
 			else if(s_permError)
 			{
 				this.Client.Logger.LogWarning($"We had problems to register the permissions. Shutting down ...");
 				await this.Client.DisconnectAsync();
 			}
 		}
 
 		/// <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 preexecution checks.
 		/// </summary>
 		/// <param name="method">The method info.</param>
 		/// <param name="context">The base context.</param>
 		private async Task RunPreexecutionChecksAsync(MethodInfo method, BaseContext context)
 		{
 			if (context is InteractionContext ctx)
 			{
 				//Gets all attributes from parent classes as well and stuff
 				var attributes = new List<SlashCheckBaseAttribute>();
 				attributes.AddRange(method.GetCustomAttributes<SlashCheckBaseAttribute>(true));
 				attributes.AddRange(method.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 				if (method.DeclaringType.DeclaringType != null)
 				{
 					attributes.AddRange(method.DeclaringType.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 					if (method.DeclaringType.DeclaringType.DeclaringType != null)
 					{
 						attributes.AddRange(method.DeclaringType.DeclaringType.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 					}
 				}
 
 				var dict = new Dictionary<SlashCheckBaseAttribute, bool>();
 				foreach (var att in attributes)
 				{
 					//Runs the check and adds the result to a list
 					var result = await att.ExecuteChecksAsync(ctx);
 					dict.Add(att, result);
 				}
 
 				//Checks if any failed, and throws an exception
 				if (dict.Any(x => x.Value == false))
 					throw new SlashExecutionChecksFailedException { FailedChecks = dict.Where(x => x.Value == false).Select(x => x.Key).ToList() };
 			}
 			if (context is ContextMenuContext cMctx)
 			{
 				var attributes = new List<ContextMenuCheckBaseAttribute>();
 				attributes.AddRange(method.GetCustomAttributes<ContextMenuCheckBaseAttribute>(true));
 				attributes.AddRange(method.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 				if (method.DeclaringType.DeclaringType != null)
 				{
 					attributes.AddRange(method.DeclaringType.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 					if (method.DeclaringType.DeclaringType.DeclaringType != null)
 					{
 						attributes.AddRange(method.DeclaringType.DeclaringType.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 					}
 				}
 
 				var dict = new Dictionary<ContextMenuCheckBaseAttribute, bool>();
 				foreach (var att in attributes)
 				{
 					//Runs the check and adds the result to a list
 					var result = await att.ExecuteChecksAsync(cMctx);
 					dict.Add(att, result);
 				}
 
 				//Checks if any failed, and throws an exception
 				if (dict.Any(x => x.Value == false))
 					throw new ContextMenuExecutionChecksFailedException { FailedChecks = dict.Where(x => x.Value == false).Select(x => x.Key).ToList() };
 			}
 		}
 
 		/// <summary>
 		/// Gets the choice attributes from choice provider.
 		/// </summary>
 		/// <param name="customAttributes">The custom attributes.</param>
 		/// <param name="guildId">The optional guild id</param>
 		private static async Task<List<DiscordApplicationCommandOptionChoice>> GetChoiceAttributesFromProvider(IEnumerable<ChoiceProviderAttribute> customAttributes, ulong? guildId = null)
 		{
 			var choices = new List<DiscordApplicationCommandOptionChoice>();
 			foreach (var choiceProviderAttribute in customAttributes)
 			{
 				var method = choiceProviderAttribute.ProviderType.GetMethod(nameof(IChoiceProvider.Provider));
 
 				if (method == null)
 					throw new ArgumentException("ChoiceProviders must inherit from IChoiceProvider.");
 				else
 				{
 					var instance = Activator.CreateInstance(choiceProviderAttribute.ProviderType);
 
 					// Abstract class offers more properties that can be set
 					if (choiceProviderAttribute.ProviderType.IsSubclassOf(typeof(ChoiceProvider)))
 					{
 						choiceProviderAttribute.ProviderType.GetProperty(nameof(ChoiceProvider.GuildId))
 							?.SetValue(instance, guildId);
 
 						choiceProviderAttribute.ProviderType.GetProperty(nameof(ChoiceProvider.Services))
 							?.SetValue(instance, Configuration.ServiceProvider);
 					}
 
 					//Gets the choices from the method
 					var result = await (Task<IEnumerable<DiscordApplicationCommandOptionChoice>>)method.Invoke(instance, null);
 
 					if (result.Any())
 					{
 						choices.AddRange(result);
 					}
 				}
 			}
 
 			return choices;
 		}
 
 		/// <summary>
 		/// Gets the choice attributes from enum parameter.
 		/// </summary>
 		/// <param name="enumParam">The enum parameter.</param>
 		private static List<DiscordApplicationCommandOptionChoice> GetChoiceAttributesFromEnumParameter(Type enumParam)
 		{
 			var choices = new List<DiscordApplicationCommandOptionChoice>();
 			foreach (Enum enumValue in Enum.GetValues(enumParam))
 			{
 				choices.Add(new DiscordApplicationCommandOptionChoice(enumValue.GetName(), enumValue.ToString()));
 			}
 			return choices;
 		}
 
 		/// <summary>
 		/// Gets the parameter type.
 		/// </summary>
 		/// <param name="type">The type.</param>
 		private static ApplicationCommandOptionType GetParameterType(Type type)
 		{
 			var parametertype = type == typeof(string)
 				? ApplicationCommandOptionType.String
 				: type == typeof(long) || type == typeof(long?) || type == typeof(int) || type == typeof(int?)
 				? ApplicationCommandOptionType.Integer
 				: type == typeof(bool) || type == typeof(bool?)
 				? ApplicationCommandOptionType.Boolean
 				: type == typeof(double) || type == typeof(double?)
 				? ApplicationCommandOptionType.Number
 				: type == typeof(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_permError = false;
 			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 permission setup.
 		/// </summary>
 		public Action<ApplicationCommandsPermissionContext> Permissions { get; }
 
 		/// <summary>
 		/// The global permission setup.
 		/// </summary>
 		public Action<ApplicationCommandsGlobalPermissionContext> GlobalGuildPermissions { get; }
 
 		/// <summary>
 		/// The translation setup.
 		/// </summary>
 		public Action<ApplicationCommandsTranslationContext> Translations { get; }
 
 		/// <summary>
 		/// Whether this config is global.
 		/// </summary>
 		internal bool IsGlobal = false;
 
 		/// <summary>
 		/// Creates a new command configuration.
 		/// </summary>
 		/// <param name="type">The type of the command module.</param>
 		/// <param name="permissions">The permission setup callback.</param>
 		/// <param name="translations">The translation setup callback.</param>
 		public ApplicationCommandsModuleConfiguration(Type type, Action<ApplicationCommandsPermissionContext> permissions = null, Action<ApplicationCommandsTranslationContext> translations = null)
 		{
 			this.Type = type;
 			this.Permissions = permissions;
 			this.Translations = translations;
 			this.GlobalGuildPermissions = null;
 		}
 
 		/// <summary>
 		/// Creates a new command configuration.
 		/// </summary>
 		/// <param name="type">The type of the command module.</param>
 		/// <param name="global">Don't change that. Just set to true if you use global commands here.</param>
 		/// <param name="globalGuildPermissions">The global permission setup callback.</param>
 		/// <param name="translations">The translation setup callback.</param>
 		public ApplicationCommandsModuleConfiguration(Type type, bool global = true, Action<ApplicationCommandsGlobalPermissionContext> globalGuildPermissions = null, Action<ApplicationCommandsTranslationContext> translations = null)
 		{
 			this.Type = type;
 			this.Permissions = null;
 			this.Translations = translations;
 			this.GlobalGuildPermissions = globalGuildPermissions;
 			this.IsGlobal = global;
 		}
 	}
 
 	/// <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("Arguments", sb.ToString().Trim(), false);
 				}
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 					new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 			}
 			else if (commandOneName is not null && commandTwoName is null && !commandOneName.Equals("no_options_for_this_command"))
 			{
 				var commandsWithOptions = applicationCommands.FindAll(ac => ac.Options is not null && ac.Options.All(op => op.Type == ApplicationCommandOptionType.SubCommand));
 				var subCommandParent = commandsWithOptions.FirstOrDefault(cm => cm.Name.Equals(commandName,StringComparison.OrdinalIgnoreCase));
 				var subCommand = subCommandParent.Options.FirstOrDefault(op => op.Name.Equals(commandOneName,StringComparison.OrdinalIgnoreCase));
 				var discordEmbed = new DiscordEmbedBuilder
 				{
 					Title = "Help",
 					Description = $"{Formatter.InlineCode(subCommand.Name)}: {subCommand.Description ?? "No description provided."}"
 				};
 				if (subCommand.Options is not null)
 				{
 					var commandOptions = subCommand.Options.ToList();
 					var sb = new StringBuilder();
 
 					foreach (var option in commandOptions)
 						sb.Append('`').Append(option.Name).Append(" (").Append(")`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 					sb.Append('\n');
 					discordEmbed.AddField("Arguments", sb.ToString().Trim(), false);
 				}
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 					new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 			}
 			else
 			{
 				var command = applicationCommands.FirstOrDefault(cm => cm.Name.Equals(commandName, StringComparison.OrdinalIgnoreCase));
 				if (command is null)
 				{
 					await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder()
 							.WithContent($"No command called {commandName} in guild {ctx.Guild.Name}").AsEphemeral(true));
 					return;
 				}
 				var discordEmbed = new DiscordEmbedBuilder
 				{
 					Title = "Help",
 					Description = $"{Formatter.InlineCode(command.Name)}: {command.Description ?? "No description provided."}"
 				};
 				if (command.Options is not null)
 				{
 					var commandOptions = command.Options.ToList();
 					var sb = new StringBuilder();
 
 					foreach (var option in commandOptions)
 						sb.Append('`').Append(option.Name).Append(" (").Append(")`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 					sb.Append('\n');
 					discordEmbed.AddField("Arguments", sb.ToString().Trim(), false);
 				}
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 					new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 			}
 		}
 	}
 	#endregion
 }
diff --git a/DisCatSharp.ApplicationCommands/Checks/ApplicationCommandEqualityChecks.cs b/DisCatSharp.ApplicationCommands/Checks/ApplicationCommandEqualityChecks.cs
index cf6bcbc08..9013460c8 100644
--- a/DisCatSharp.ApplicationCommands/Checks/ApplicationCommandEqualityChecks.cs
+++ b/DisCatSharp.ApplicationCommands/Checks/ApplicationCommandEqualityChecks.cs
@@ -1,240 +1,263 @@
 // 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.Linq;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.Common;
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.ApplicationCommands
 {
 	internal static class ApplicationCommandEqualityChecks
 	{
 		/// <summary>
 		/// Whether two application commands are equal.
 		/// </summary>
 		/// <param name="ac1">Source command.</param>
 		/// <param name="targetApplicationCommand">Command to check agains.</param>
 		internal static bool IsEqualTo(this DiscordApplicationCommand ac1, DiscordApplicationCommand targetApplicationCommand)
 		{
 			if (targetApplicationCommand is null || ac1 is null)
 				return false;
 
 			DiscordApplicationCommand sourceApplicationCommand = new(
 				ac1.Name, ac1.Description, ac1.Options,
 				ac1.DefaultPermission, ac1.Type,
 				ac1.NameLocalizations, ac1.DescriptionLocalizations
 			);
 
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC Change Check] Command {ac1.Name}\n\n[{JsonConvert.SerializeObject(sourceApplicationCommand)},{JsonConvert.SerializeObject(targetApplicationCommand)}]\n\n");
 
-			return ac1.Type == targetApplicationCommand.Type && sourceApplicationCommand.SoftEqual(targetApplicationCommand, ac1.Type);
+			return ac1.Type == targetApplicationCommand.Type && sourceApplicationCommand.SoftEqual(targetApplicationCommand, ac1.Type, ApplicationCommandsExtension.Configuration?.EnableLocalization ?? false);
 		}
 
 		/// <summary>
-		/// Checks if two <see cref="DisCatSharp.Entities.DiscordApplicationCommand"/>s are the same.
+		/// Checks softly whether two <see cref="DisCatSharp.Entities.DiscordApplicationCommand"/>s are the same.
 		/// Excluding id, application id and version here.
 		/// </summary>
 		/// <param name="source">Source application command.</param>
 		/// <param name="target">Application command to check against.</param>
 		/// <param name="type">The application command type.</param>
-		internal static bool SoftEqual(this DiscordApplicationCommand source, DiscordApplicationCommand target, ApplicationCommandType type)
+		/// <param name="localizationEnabled">Whether localization is enabled.</param>
+		internal static bool SoftEqual(this DiscordApplicationCommand source, DiscordApplicationCommand target, ApplicationCommandType type, bool localizationEnabled = false)
 		{
-			return type switch {
-				ApplicationCommandType.ChatInput => DeepEqual(source, target),
-				_ => (source.Name == target.Name) && (source.DefaultPermission == target.DefaultPermission)
-			&& (source.Type == target.Type)
-			};
+			return localizationEnabled
+				? type switch
+				{
+					ApplicationCommandType.ChatInput => DeepEqual(source, target, localizationEnabled),
+					_ => (source.Name == target.Name) && (source.DefaultPermission == target.DefaultPermission)
+				&& (source.Type == target.Type) && (source.NameLocalizations == target.NameLocalizations)
+				}
+				: type switch {
+					ApplicationCommandType.ChatInput => DeepEqual(source, target),
+					_ => (source.Name == target.Name) && (source.DefaultPermission == target.DefaultPermission)
+				&& (source.Type == target.Type)
+				};
 		}
 
-		internal static bool DeepEqual(DiscordApplicationCommand source, DiscordApplicationCommand target)
+		/// <summary>
+		/// Checks deeply whether two <see cref="DisCatSharp.Entities.DiscordApplicationCommand"/>s are the same.
+		/// Excluding id, application id and version here.
+		/// </summary>
+		/// <param name="source">Source application command.</param>
+		/// <param name="target">Application command to check against.</param>
+		/// <param name="localizationEnabled">Whether localization is enabled.</param>
+		internal static bool DeepEqual(DiscordApplicationCommand source, DiscordApplicationCommand target, bool localizationEnabled = false)
 		{
 			var rootCheck = (source.Name == target.Name) && (source.Description == target.Description) && (source.DefaultPermission == target.DefaultPermission) && (source.Type == target.Type);
+			if (localizationEnabled)
+				rootCheck = rootCheck && (source.NameLocalizations == target.NameLocalizations) && (source.DescriptionLocalizations == target.DescriptionLocalizations);
 
 			if (source.Options == null && target.Options == null)
 				return rootCheck;
 			else if ((source.Options != null && target.Options == null) || (source.Options == null && target.Options != null))
 				return false;
 			else if (source.Options.Any(o => o.Type == ApplicationCommandOptionType.SubCommandGroup) && target.Options.Any(o => o.Type == ApplicationCommandOptionType.SubCommandGroup))
 			{
 				List<DiscordApplicationCommandOption> minimalSourceOptions = new();
 				List<DiscordApplicationCommandOption> minimalTargetOptions = new();
 
 				foreach (var option in source.Options)
 				{
 					List<DiscordApplicationCommandOption> minimalSubSourceOptions = new();
 
 					foreach (var subOption in option.Options)
 					{
 						List<DiscordApplicationCommandOption> minimalSubSubSourceOptions = null;
 
 						if (subOption.Options != null)
 						{
 							minimalSubSubSourceOptions = new();
 
 							foreach (var subSubOption in subOption.Options)
 							{
 								minimalSubSubSourceOptions.Add(new DiscordApplicationCommandOption(
 									subSubOption.Name, subSubOption.Description, subSubOption.Type, subSubOption.Required ?? false,
 									subSubOption.Choices, null, subSubOption.ChannelTypes, subSubOption.AutoComplete ?? false,
-									subSubOption.MinimumValue, subSubOption.MaximumValue, null, null
+									subSubOption.MinimumValue, subSubOption.MaximumValue,
+									localizationEnabled ? subSubOption.NameLocalizations : null, localizationEnabled ? subSubOption.DescriptionLocalizations : null
 								));
 							}
 
 							minimalSubSourceOptions.Add(new DiscordApplicationCommandOption(
 								subOption.Name, subOption.Description, subOption.Type, null, null,
-								minimalSubSubSourceOptions, null, null, null, null, null, null
+								minimalSubSubSourceOptions, null, null, null, null,
+								localizationEnabled ? subOption.NameLocalizations : null, localizationEnabled ? subOption.DescriptionLocalizations : null
 							));
 						}
 
 					}
 
 					minimalSourceOptions.Add(new DiscordApplicationCommandOption(
 						option.Name, option.Description, option.Type, null, null,
-						minimalSubSourceOptions, null, null, null, null, null, null
+						minimalSubSourceOptions, null, null, null, null,
+						localizationEnabled ? option.NameLocalizations : null, localizationEnabled ? option.DescriptionLocalizations : null
 					));
 				}
 
 				foreach (var option in target.Options)
 				{
 					List<DiscordApplicationCommandOption> minimalSubTargetOptions = new();
 
 					foreach (var subOption in option.Options)
 					{
 						List<DiscordApplicationCommandOption> minimalSubSubTargetOptions = null;
 
 						if (subOption.Options != null && subOption.Options.Any())
 						{
 							minimalSubSubTargetOptions = new();
 
 							foreach (var subSubOption in subOption.Options)
 							{
 								minimalSubSubTargetOptions.Add(new DiscordApplicationCommandOption(
 									subSubOption.Name, subSubOption.Description, subSubOption.Type, subSubOption.Required ?? false,
 									subSubOption.Choices, null, subSubOption.ChannelTypes, subSubOption.AutoComplete ?? false,
-									subSubOption.MinimumValue, subSubOption.MaximumValue, null, null
+									subSubOption.MinimumValue, subSubOption.MaximumValue,
+									localizationEnabled ? subSubOption.NameLocalizations : null, localizationEnabled ? subSubOption.DescriptionLocalizations : null
 								));
 							}
 
 							minimalSubTargetOptions.Add(new DiscordApplicationCommandOption(
 								subOption.Name, subOption.Description, subOption.Type, null, null,
-								minimalSubSubTargetOptions, null, null, null, null, null, null
+								minimalSubSubTargetOptions, null, null, null, null,
+								localizationEnabled ? subOption.NameLocalizations : null, localizationEnabled ? subOption.DescriptionLocalizations : null
 							));
 						}
 					}
 
 					minimalTargetOptions.Add(new DiscordApplicationCommandOption(
 						option.Name, option.Description, option.Type, null, null,
-						minimalSubTargetOptions, null, null, null, null, null, null
+						minimalSubTargetOptions, null, null, null, null,
+						localizationEnabled ? option.NameLocalizations : null, localizationEnabled ? option.DescriptionLocalizations : null
 					));
 				}
 
 				return rootCheck && JsonConvert.SerializeObject(minimalSourceOptions) == JsonConvert.SerializeObject(minimalTargetOptions);
 			}
 			else if (source.Options.Any(o => o.Type == ApplicationCommandOptionType.SubCommand) && target.Options.Any(o => o.Type == ApplicationCommandOptionType.SubCommand))
 			{
 				List<DiscordApplicationCommandOption> minimalSourceOptions = new();
 				List<DiscordApplicationCommandOption> minimalTargetOptions = new();
 
 				foreach (var option in source.Options)
 				{
 					List<DiscordApplicationCommandOption> minimalSubSourceOptions =null;
 
 					if (option.Options != null)
 					{
 						minimalSubSourceOptions = new();
 
 						foreach (var subOption in option.Options)
 						{
 							minimalSubSourceOptions.Add(new DiscordApplicationCommandOption(
 								subOption.Name, subOption.Description, subOption.Type, subOption.Required ?? false,
 								subOption.Choices, null, subOption.ChannelTypes, subOption.AutoComplete ?? false,
-								subOption.MinimumValue, subOption.MaximumValue, null, null
+								subOption.MinimumValue, subOption.MaximumValue, localizationEnabled ? subOption.NameLocalizations : null, localizationEnabled ? subOption.DescriptionLocalizations : null
 							));
 						}
 					}
 
 					minimalSourceOptions.Add(new DiscordApplicationCommandOption(
 						option.Name, option.Description, option.Type, null, null,
-						minimalSubSourceOptions, null, null, null, null, null, null
+						minimalSubSourceOptions, null, null, null, null, localizationEnabled ? option.NameLocalizations : null, localizationEnabled ? option.DescriptionLocalizations : null
 					));
 				}
 
 				foreach (var option in target.Options)
 				{
 					List<DiscordApplicationCommandOption> minimalSubTargetOptions = null;
 
 					if (option.Options != null && option.Options.Any())
 					{
 						minimalSubTargetOptions = new();
 
 						foreach (var subOption in option.Options)
 						{
 							minimalSubTargetOptions.Add(new DiscordApplicationCommandOption(
 								subOption.Name, subOption.Description, subOption.Type, subOption.Required ?? false,
 								subOption.Choices, null, subOption.ChannelTypes, subOption.AutoComplete ?? false,
-								subOption.MinimumValue, subOption.MaximumValue, null, null
+								subOption.MinimumValue, subOption.MaximumValue, localizationEnabled ? subOption.NameLocalizations : null, localizationEnabled ? subOption.DescriptionLocalizations : null
 							));
 						}
 					}
 
 					minimalTargetOptions.Add(new DiscordApplicationCommandOption(
 						option.Name, option.Description, option.Type, null, null,
-						minimalSubTargetOptions, null, null, null, null, null, null
+						minimalSubTargetOptions, null, null, null, null, localizationEnabled ? option.NameLocalizations : null, localizationEnabled ? option.DescriptionLocalizations : null
 					));
 				}
 
 				return rootCheck && JsonConvert.SerializeObject(minimalSourceOptions) == JsonConvert.SerializeObject(minimalTargetOptions);
 			}
 			else
 			{
 				List<DiscordApplicationCommandOption> minimalSourceOptions = new();
 				List<DiscordApplicationCommandOption> minimalTargetOptions = new();
 
 				foreach (var option in source.Options)
 					minimalSourceOptions.Add(new DiscordApplicationCommandOption(
 						option.Name, option.Description, option.Type, option.Required ?? false,
 						option.Choices, null, option.ChannelTypes, option.AutoComplete ?? false, option.MinimumValue, option.MaximumValue,
-						null, null
+						localizationEnabled ? option.NameLocalizations : null, localizationEnabled ? option.DescriptionLocalizations : null
 					));
 
 				foreach (var option in target.Options)
 					minimalTargetOptions.Add(new DiscordApplicationCommandOption(
 						option.Name, option.Description, option.Type, option.Required ?? false,
 						option.Choices, null, option.ChannelTypes, option.AutoComplete ?? false, option.MinimumValue, option.MaximumValue,
-						null, null
+						localizationEnabled ? option.NameLocalizations : null, localizationEnabled ? option.DescriptionLocalizations : null
 					));
 
 				return rootCheck && JsonConvert.SerializeObject(minimalSourceOptions) == JsonConvert.SerializeObject(minimalTargetOptions);
 			}
 		}
 
 		// TODO: Later
 		//&& (source.NameLocalizations == target.NameLocalizations) && (source.DescriptionLocalizations == target.DescriptionLocalizations)
 		// && (source.Permission == other.Permission) && (source.DmPermission == other.DmPermission)
 	}
 }
diff --git a/DisCatSharp.ApplicationCommands/Workers/ApplicationCommandWorker.cs b/DisCatSharp.ApplicationCommands/Workers/ApplicationCommandWorker.cs
index 917b550d2..8adac996f 100644
--- a/DisCatSharp.ApplicationCommands/Workers/ApplicationCommandWorker.cs
+++ b/DisCatSharp.ApplicationCommands/Workers/ApplicationCommandWorker.cs
@@ -1,383 +1,386 @@
 // 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.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 
 namespace DisCatSharp.ApplicationCommands
 {
 	/// <summary>
 	/// Represents a <see cref="CommandWorker"/>.
 	/// </summary>
 	internal class CommandWorker
 	{
 		/// <summary>
 		/// Parses context menu application commands.
 		/// </summary>
 		/// <param name="type">The type.</param>
 		/// <param name="methods">List of method infos.</param>
 		/// <param name="translator">The optional command translations.</param>
 		/// <returns>Too much.</returns>
 		internal static Task<
 			(
 				List<DiscordApplicationCommand> applicationCommands,
 				List<KeyValuePair<Type, Type>> commandTypeSources,
-				List<ContextMenuCommand> contextMenuCommands
+				List<ContextMenuCommand> contextMenuCommands,
+				bool withLocalization
 			)
 			> ParseContextMenuCommands(Type type, IEnumerable<MethodInfo> methods, List<CommandTranslator> translator = null)
 		{
 			List<DiscordApplicationCommand> commands = new();
 			List<KeyValuePair<Type, Type>> commandTypeSources = new();
 			List<ContextMenuCommand> contextMenuCommands = new();
 
 
 			foreach (var contextMethod in methods)
 			{
 				var contextAttribute = contextMethod.GetCustomAttribute<ContextMenuAttribute>();
 
 				DiscordApplicationCommandLocalization nameLocalizations = null;
 
 				var commandTranslation = translator?.Single(c => c.Name == contextAttribute.Name && c.Type == contextAttribute.Type);
 				if (commandTranslation != null)
 					nameLocalizations = commandTranslation.NameTranslations;
 
 				var command = new DiscordApplicationCommand(contextAttribute.Name, null, null, contextAttribute.DefaultPermission, contextAttribute.Type, nameLocalizations);
 
 				var parameters = contextMethod.GetParameters();
 				if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.FirstOrDefault()?.ParameterType, typeof(ContextMenuContext)))
 					throw new ArgumentException($"The first argument must be a ContextMenuContext!");
 				if (parameters.Length > 1)
 					throw new ArgumentException($"A context menu cannot have parameters!");
 
 				contextMenuCommands.Add(new ContextMenuCommand { Method = contextMethod, Name = contextAttribute.Name });
 
 				commands.Add(command);
 				commandTypeSources.Add(new KeyValuePair<Type, Type>(type, type));
 			}
 
-			return Task.FromResult((commands, commandTypeSources, contextMenuCommands));
+			return Task.FromResult((commands, commandTypeSources, contextMenuCommands, translator != null));
 		}
 
 		/// <summary>
 		/// Parses single application commands.
 		/// </summary>
 		/// <param name="type">The type.</param>
 		/// <param name="methods">List of method infos.</param>
 		/// <param name="guildId">The optional guild id.</param>
 		/// <param name="translator">The optional command translations.</param>
 		/// <returns>Too much.</returns>
 		internal static async Task<
 			(
 				List<DiscordApplicationCommand> applicationCommands,
 				List<KeyValuePair<Type, Type>> commandTypeSources,
-				List<CommandMethod> commandMethods
+				List<CommandMethod> commandMethods,
+				bool withLocalization
 			)
 			> ParseBasicSlashCommandsAsync(Type type, IEnumerable<MethodInfo> methods, ulong? guildId = null, List<CommandTranslator> translator = null)
 		{
 			List<DiscordApplicationCommand> commands = new();
 			List<KeyValuePair<Type, Type>> commandTypeSources = new();
 			List<CommandMethod> commandMethods = new();
 
 			foreach (var method in methods)
 			{
 				var commandattribute = method.GetCustomAttribute<SlashCommandAttribute>();
 
 				var parameters = method.GetParameters();
 				if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.FirstOrDefault()?.ParameterType, typeof(InteractionContext)))
 					throw new ArgumentException($"The first argument must be an InteractionContext!");
 				parameters = parameters.Skip(1).ToArray();
 				var options = await ApplicationCommandsExtension.ParseParametersAsync(parameters, guildId);
 
 				commandMethods.Add(new CommandMethod { Method = method, Name = commandattribute.Name });
 
 				DiscordApplicationCommandLocalization nameLocalizations = null;
 				DiscordApplicationCommandLocalization descriptionLocalizations = null;
 				List<DiscordApplicationCommandOption> localizisedOptions = null;
 
 				var commandTranslation = translator?.Single(c => c.Name == commandattribute.Name && c.Type == ApplicationCommandType.ChatInput);
 
 				if (commandTranslation != null && commandTranslation.Options != null)
 				{
 					localizisedOptions = new List<DiscordApplicationCommandOption>(options.Count);
 					foreach (var option in options)
 					{
 						var choices = option.Choices != null ? new List<DiscordApplicationCommandOptionChoice>(option.Choices.Count) : null;
 						if (option.Choices != null)
 						{
 							foreach (var choice in option.Choices)
 							{
 								choices.Add(new DiscordApplicationCommandOptionChoice(choice.Name, choice.Value, commandTranslation.Options.Single(o => o.Name == option.Name).Choices.Single(c => c.Name == choice.Name).NameTranslations));
 							}
 						}
 
 						localizisedOptions.Add(new DiscordApplicationCommandOption(option.Name, option.Description, option.Type, option.Required,
 							choices, option.Options, option.ChannelTypes, option.AutoComplete, option.MinimumValue, option.MaximumValue,
 							commandTranslation.Options.Single(o => o.Name == option.Name).NameTranslations, commandTranslation.Options.Single(o => o.Name == option.Name).DescriptionTranslations
 						));
 					}
 
 					nameLocalizations = commandTranslation.NameTranslations;
 					descriptionLocalizations = commandTranslation.DescriptionTranslations;
 				}
 
 				var payload = new DiscordApplicationCommand(commandattribute.Name, commandattribute.Description, (localizisedOptions != null && localizisedOptions.Any() ? localizisedOptions : null) ?? (options != null && options.Any() ? options : null), commandattribute.DefaultPermission, ApplicationCommandType.ChatInput, nameLocalizations, descriptionLocalizations);
 				commands.Add(payload);
 				commandTypeSources.Add(new KeyValuePair<Type, Type>(type, type));
 			}
 
-			return (commands, commandTypeSources, commandMethods);
+			return (commands, commandTypeSources, commandMethods, translator != null);
 		}
 	}
 
 	/// <summary>
 	/// Represents a <see cref="NestedCommandWorker"/>.
 	/// </summary>
 	internal class NestedCommandWorker
 	{
 		/// <summary>
 		/// Parses application command groups.
 		/// </summary>
 		/// <param name="type">The type.</param>
 		/// <param name="types">List of type infos.</param>
 		/// <param name="guildId">The optional guild id.</param>
 		/// <param name="translator">The optional group translations.</param>
 		/// <returns>Too much.</returns>
 		internal static async Task<
 			(
 				List<DiscordApplicationCommand> applicationCommands,
 				List<KeyValuePair<Type, Type>> commandTypeSources,
 				List<object> singletonModules,
 				List<GroupCommand> groupCommands,
-				List<SubGroupCommand> subGroupCommands
+				List<SubGroupCommand> subGroupCommands,
+				bool withLocalization
 			)
 			> ParseSlashGroupsAsync(Type type, List<TypeInfo> types, ulong? guildId = null, List<GroupTranslator> translator = null)
 		{
 			List<DiscordApplicationCommand> commands = new();
 			List<KeyValuePair<Type, Type>> commandTypeSources = new();
 			List<GroupCommand> groupCommands = new();
 			List<SubGroupCommand> subGroupCommands = new();
 			List<object> singletonModules = new();
 
 			//Handles groups
 			foreach (var subclassinfo in types)
 			{
 				//Gets the attribute and methods in the group
 				var groupAttribute = subclassinfo.GetCustomAttribute<SlashCommandGroupAttribute>();
 				var submethods = subclassinfo.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null).ToList();
 				var subclasses = subclassinfo.DeclaredNestedTypes.Where(x => x.GetCustomAttribute<SlashCommandGroupAttribute>() != null).ToList();
 				if (subclasses.Any() && submethods.Any())
 				{
 					throw new ArgumentException("Slash command groups cannot have both subcommands and subgroups!");
 				}
 
 				DiscordApplicationCommandLocalization nameLocalizations = null;
 				DiscordApplicationCommandLocalization descriptionLocalizations = null;
 
 				if (translator != null)
 				{
 					var commandTranslation = translator.Single(c => c.Name == groupAttribute.Name);
 					if (commandTranslation != null)
 					{
 						nameLocalizations = commandTranslation.NameTranslations;
 						descriptionLocalizations = commandTranslation.DescriptionTranslations;
 					}
 				}
 
 				//Initializes the command
 				var payload = new DiscordApplicationCommand(groupAttribute.Name, groupAttribute.Description, defaultPermission: groupAttribute.DefaultPermission, nameLocalizations: nameLocalizations, descriptionLocalizations: descriptionLocalizations);
 				commandTypeSources.Add(new KeyValuePair<Type, Type>(type, type));
 
 				var commandmethods = new List<KeyValuePair<string, MethodInfo>>();
 				//Handles commands in the group
 				foreach (var submethod in submethods)
 				{
 					var commandAttribute = submethod.GetCustomAttribute<SlashCommandAttribute>();
 
 					//Gets the paramaters and accounts for InteractionContext
 					var parameters = submethod.GetParameters();
 					if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.First().ParameterType, typeof(InteractionContext)))
 						throw new ArgumentException($"The first argument must be an InteractionContext!");
 					parameters = parameters.Skip(1).ToArray();
 
 					var options = await ApplicationCommandsExtension.ParseParametersAsync(parameters, guildId);
 
 					DiscordApplicationCommandLocalization subNameLocalizations = null;
 					DiscordApplicationCommandLocalization subDescriptionLocalizations = null;
 					List<DiscordApplicationCommandOption> localizisedOptions = null;
 
 					var commandTranslation = translator?.Single(c => c.Name == payload.Name);
 
 					if (commandTranslation?.Commands != null)
 					{
 
 						var subCommandTranslation = commandTranslation.Commands.Single(sc => sc.Name == commandAttribute.Name);
 						if (subCommandTranslation.Options != null)
 						{
 							localizisedOptions = new List<DiscordApplicationCommandOption>(options.Count);
 							foreach (var option in options)
 							{
 								var choices = option.Choices != null ? new List<DiscordApplicationCommandOptionChoice>(option.Choices.Count) : null;
 								if (option.Choices != null)
 								{
 									foreach (var choice in option.Choices)
 									{
 										choices.Add(new DiscordApplicationCommandOptionChoice(choice.Name, choice.Value, subCommandTranslation.Options.Single(o => o.Name == option.Name).Choices.Single(c => c.Name == choice.Name).NameTranslations));
 									}
 								}
 
 								localizisedOptions.Add(new DiscordApplicationCommandOption(option.Name, option.Description, option.Type, option.Required,
 									choices, option.Options, option.ChannelTypes, option.AutoComplete, option.MinimumValue, option.MaximumValue,
 									subCommandTranslation.Options.Single(o => o.Name == option.Name).NameTranslations, subCommandTranslation.Options.Single(o => o.Name == option.Name).DescriptionTranslations
 								));
 							}
 						}
 
 						subNameLocalizations = subCommandTranslation.NameTranslations;
 						subDescriptionLocalizations = subCommandTranslation.DescriptionTranslations;
 					}
 
 
 					//Creates the subcommand and adds it to the main command
 					var subpayload = new DiscordApplicationCommandOption(commandAttribute.Name, commandAttribute.Description, ApplicationCommandOptionType.SubCommand, null, null, localizisedOptions ?? options, nameLocalizations: subNameLocalizations, descriptionLocalizations: subDescriptionLocalizations);
 					payload = new DiscordApplicationCommand(payload.Name, payload.Description, payload.Options?.Append(subpayload) ?? new[] { subpayload }, payload.DefaultPermission, nameLocalizations: payload.NameLocalizations, descriptionLocalizations: payload.DescriptionLocalizations);
 					commandTypeSources.Add(new KeyValuePair<Type, Type>(subclassinfo, type));
 
 					//Adds it to the method lists
 					commandmethods.Add(new KeyValuePair<string, MethodInfo>(commandAttribute.Name, submethod));
 					groupCommands.Add(new GroupCommand { Name = groupAttribute.Name, Methods = commandmethods });
 				}
 
 				var command = new SubGroupCommand { Name = groupAttribute.Name };
 				//Handles subgroups
 				foreach (var subclass in subclasses)
 				{
 					var subGroupAttribute = subclass.GetCustomAttribute<SlashCommandGroupAttribute>();
 					var subsubmethods = subclass.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null);
 
 					var options = new List<DiscordApplicationCommandOption>();
 
 					var currentMethods = new List<KeyValuePair<string, MethodInfo>>();
 
 
 					DiscordApplicationCommandLocalization subNameLocalizations = null;
 					DiscordApplicationCommandLocalization subDescriptionLocalizations = null;
 
 					if (translator != null)
 					{
 						var commandTranslation = translator.Single(c => c.Name == payload.Name);
 						if (commandTranslation != null && commandTranslation.SubGroups != null)
 						{
 
 							var subCommandTranslation = commandTranslation.SubGroups.Single(sc => sc.Name == subGroupAttribute.Name);
 
 							if (subCommandTranslation != null)
 							{
 								subNameLocalizations = subCommandTranslation.NameTranslations;
 								subDescriptionLocalizations = subCommandTranslation.DescriptionTranslations;
 							}
 						}
 					}
 
 					//Similar to the one for regular groups
 					foreach (var subsubmethod in subsubmethods)
 					{
 						var suboptions = new List<DiscordApplicationCommandOption>();
 						var commatt = subsubmethod.GetCustomAttribute<SlashCommandAttribute>();
 						var parameters = subsubmethod.GetParameters();
 						if (parameters.Length == 0 || parameters == null || !ReferenceEquals(parameters.First().ParameterType, typeof(InteractionContext)))
 							throw new ArgumentException($"The first argument must be an InteractionContext!");
 
 						parameters = parameters.Skip(1).ToArray();
 						suboptions = suboptions.Concat(await ApplicationCommandsExtension.ParseParametersAsync(parameters, guildId)).ToList();
 
 						DiscordApplicationCommandLocalization subSubNameLocalizations = null;
 						DiscordApplicationCommandLocalization subSubDescriptionLocalizations = null;
 						List<DiscordApplicationCommandOption> localizisedOptions = null;
 
 						var commandTranslation = translator?.Single(c => c.Name == payload.Name);
 
 						var subCommandTranslation = commandTranslation?.SubGroups?.Single(sc => sc.Name == commatt.Name);
 
 						var subSubCommandTranslation = subCommandTranslation?.Commands.Single(sc => sc.Name == commatt.Name);
 
 						if (subSubCommandTranslation != null && subSubCommandTranslation.Options != null)
 						{
 							localizisedOptions = new List<DiscordApplicationCommandOption>(suboptions.Count);
 							foreach (var option in suboptions)
 							{
 								var choices = option.Choices != null ? new List<DiscordApplicationCommandOptionChoice>(option.Choices.Count) : null;
 								if (option.Choices != null)
 								{
 									foreach (var choice in option.Choices)
 									{
 										choices.Add(new DiscordApplicationCommandOptionChoice(choice.Name, choice.Value, subSubCommandTranslation.Options.Single(o => o.Name == option.Name).Choices.Single(c => c.Name == choice.Name).NameTranslations));
 									}
 								}
 
 								localizisedOptions.Add(new DiscordApplicationCommandOption(option.Name, option.Description, option.Type, option.Required,
 									choices, option.Options, option.ChannelTypes, option.AutoComplete, option.MinimumValue, option.MaximumValue,
 									subSubCommandTranslation.Options.Single(o => o.Name == option.Name).NameTranslations, subSubCommandTranslation.Options.Single(o => o.Name == option.Name).DescriptionTranslations
 								));
 							}
 
 							subSubNameLocalizations = subSubCommandTranslation.NameTranslations;
 							subSubDescriptionLocalizations = subSubCommandTranslation.DescriptionTranslations;
 						}
 
 						var subsubpayload = new DiscordApplicationCommandOption(commatt.Name, commatt.Description, ApplicationCommandOptionType.SubCommand, null, null, (localizisedOptions != null && localizisedOptions.Any() ? localizisedOptions : null) ?? (suboptions != null && suboptions.Any() ? suboptions : null), nameLocalizations: subSubNameLocalizations, descriptionLocalizations: subSubDescriptionLocalizations);
 						options.Add(subsubpayload);
 						commandmethods.Add(new KeyValuePair<string, MethodInfo>(commatt.Name, subsubmethod));
 						currentMethods.Add(new KeyValuePair<string, MethodInfo>(commatt.Name, subsubmethod));
 					}
 
 					//Adds the group to the command and method lists
 					var subpayload = new DiscordApplicationCommandOption(subGroupAttribute.Name, subGroupAttribute.Description, ApplicationCommandOptionType.SubCommandGroup, null, null, options, nameLocalizations: subNameLocalizations, descriptionLocalizations: subDescriptionLocalizations);
 					command.SubCommands.Add(new GroupCommand { Name = subGroupAttribute.Name, Methods = currentMethods });
 					payload = new DiscordApplicationCommand(payload.Name, payload.Description, payload.Options?.Append(subpayload) ?? new[] { subpayload }, payload.DefaultPermission, nameLocalizations: payload.NameLocalizations, descriptionLocalizations: payload.DescriptionLocalizations);
 					commandTypeSources.Add(new KeyValuePair<Type, Type>(subclass, type));
 
 					//Accounts for lifespans for the sub group
 					if (subclass.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null && subclass.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
 					{
 						singletonModules.Add(ApplicationCommandsExtension.CreateInstance(subclass, ApplicationCommandsExtension.Configuration?.ServiceProvider));
 					}
 				}
 				if (command.SubCommands.Any()) subGroupCommands.Add(command);
 				commands.Add(payload);
 
 				//Accounts for lifespans
 				if (subclassinfo.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null && subclassinfo.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
 				{
 					singletonModules.Add(ApplicationCommandsExtension.CreateInstance(subclassinfo, ApplicationCommandsExtension.Configuration?.ServiceProvider));
 				}
 			}
 
-			return (commands, commandTypeSources, singletonModules, groupCommands, subGroupCommands);
+			return (commands, commandTypeSources, singletonModules, groupCommands, subGroupCommands, translator != null);
 		}
 	}
 }
diff --git a/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs b/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs
index df7c4020a..d30bf3f99 100644
--- a/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs
+++ b/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs
@@ -1,561 +1,563 @@
 // 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)
+		internal static async Task<List<DiscordApplicationCommand>> RegisterGlobalCommandsAsync(List<DiscordApplicationCommand> commands, bool withLocales)
 		{
 			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.FromValue(command.Options);
 						action.DefaultPermission = command.DefaultPermission;
 					});
 
 					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.FromValue(command.Options);
 							action.DefaultPermission = command.DefaultPermission;
 						});
 
 						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.FromValue(command.Options);
 						action.DefaultPermission = command.DefaultPermission;
 					});
 
 					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 GUILD] 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)
+		internal static async Task<List<DiscordApplicationCommand>> RegisterGuilldCommandsAsync(ulong guildId, List<DiscordApplicationCommand> commands, bool withLocales)
 		{
 			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.FromValue(command.Options);
 						action.DefaultPermission = command.DefaultPermission;
 					});
 
 					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.FromValue(command.Options);
 							action.DefaultPermission = command.DefaultPermission;
 						});
 
 						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.FromValue(command.Options);
 						action.DefaultPermission = command.DefaultPermission;
 					});
 
 					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/Clients/DiscordClient.cs b/DisCatSharp/Clients/DiscordClient.cs
index ef39c3275..1eda310c6 100644
--- a/DisCatSharp/Clients/DiscordClient.cs
+++ b/DisCatSharp/Clients/DiscordClient.cs
@@ -1,1330 +1,1332 @@
 // 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.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp
 {
 	/// <summary>
 	/// A Discord API wrapper.
 	/// </summary>
 	public sealed partial class DiscordClient : BaseDiscordClient
 	{
 		#region Internal Fields/Properties
 
 		internal bool IsShard = false;
 		/// <summary>
 		/// Gets the message cache.
 		/// </summary>
 		internal RingBuffer<DiscordMessage> MessageCache { get; }
 
 		private List<BaseExtension> _extensions = new();
 		private StatusUpdate _status;
 
 		/// <summary>
 		/// Gets the connection lock.
 		/// </summary>
 		private readonly ManualResetEventSlim _connectionLock = new(true);
 
 		#endregion
 
 		#region Public Fields/Properties
 		/// <summary>
 		/// Gets the gateway protocol version.
 		/// </summary>
 		public int GatewayVersion { get; internal set; }
 
 		/// <summary>
 		/// Gets the gateway session information for this client.
 		/// </summary>
 		public GatewayInfo GatewayInfo { get; internal set; }
 
 		/// <summary>
 		/// Gets the gateway URL.
 		/// </summary>
 		public Uri GatewayUri { get; internal set; }
 
 		/// <summary>
 		/// Gets the total number of shards the bot is connected to.
 		/// </summary>
 		public int ShardCount => this.GatewayInfo != null
 			? this.GatewayInfo.ShardCount
 			: this.Configuration.ShardCount;
 
 		/// <summary>
 		/// Gets the currently connected shard ID.
 		/// </summary>
 		public int ShardId
 			=> this.Configuration.ShardId;
 
 		/// <summary>
 		/// Gets the intents configured for this client.
 		/// </summary>
 		public DiscordIntents Intents
 			=> this.Configuration.Intents;
 
 		/// <summary>
 		/// Gets a dictionary of guilds that this client is in. The dictionary's key is the guild ID. Note that the
 		/// guild objects in this dictionary will not be filled in if the specific guilds aren't available (the
 		/// <see cref="GuildAvailable"/> or <see cref="GuildDownloadCompleted"/> events haven't been fired yet)
 		/// </summary>
 		public override IReadOnlyDictionary<ulong, DiscordGuild> Guilds { get; }
 		internal ConcurrentDictionary<ulong, DiscordGuild> GuildsInternal = new();
 
 		/// <summary>
 		/// Gets the websocket latency for this client.
 		/// </summary>
 		public int Ping
 			=> Volatile.Read(ref this._ping);
 
 		private int _ping;
 
 		/// <summary>
 		/// Gets the collection of presences held by this client.
 		/// </summary>
 		public IReadOnlyDictionary<ulong, DiscordPresence> Presences
 			=> this._presencesLazy.Value;
 
 		internal Dictionary<ulong, DiscordPresence> PresencesInternal = new();
 		private Lazy<IReadOnlyDictionary<ulong, DiscordPresence>> _presencesLazy;
 
 		/// <summary>
 		/// Gets the collection of presences held by this client.
 		/// </summary>
 		public IReadOnlyDictionary<string, DiscordActivity> EmbeddedActivities
 			=> this._embeddedActivitiesLazy.Value;
 
 		internal Dictionary<string, DiscordActivity> EmbeddedActivitiesInternal = new();
 		private Lazy<IReadOnlyDictionary<string, DiscordActivity>> _embeddedActivitiesLazy;
 		#endregion
 
 		#region Constructor/Internal Setup
 
 		/// <summary>
 		/// Initializes a new instance of <see cref="DiscordClient"/>.
 		/// </summary>
 		/// <param name="config">Specifies configuration parameters.</param>
 		public DiscordClient(DiscordConfiguration config)
 			: base(config)
 		{
 			if (this.Configuration.MessageCacheSize > 0)
 			{
 				var intents = this.Configuration.Intents;
 				this.MessageCache = intents.HasIntent(DiscordIntents.GuildMessages) || intents.HasIntent(DiscordIntents.DirectMessages)
 						? new RingBuffer<DiscordMessage>(this.Configuration.MessageCacheSize)
 						: null;
 			}
 
 			this.InternalSetup();
 
 			this.Guilds = new ReadOnlyConcurrentDictionary<ulong, DiscordGuild>(this.GuildsInternal);
 		}
 
 		/// <summary>
 		/// Internal setup of the Client.
 		/// </summary>
 		internal void InternalSetup()
 		{
 			this._clientErrored = new AsyncEvent<DiscordClient, ClientErrorEventArgs>("CLIENT_ERRORED", EventExecutionLimit, this.Goof);
 			this._socketErrored = new AsyncEvent<DiscordClient, SocketErrorEventArgs>("SOCKET_ERRORED", EventExecutionLimit, this.Goof);
 			this._socketOpened = new AsyncEvent<DiscordClient, SocketEventArgs>("SOCKET_OPENED", EventExecutionLimit, this.EventErrorHandler);
 			this._socketClosed = new AsyncEvent<DiscordClient, SocketCloseEventArgs>("SOCKET_CLOSED", EventExecutionLimit, this.EventErrorHandler);
 			this._ready = new AsyncEvent<DiscordClient, ReadyEventArgs>("READY", EventExecutionLimit, this.EventErrorHandler);
 			this._resumed = new AsyncEvent<DiscordClient, ReadyEventArgs>("RESUMED", EventExecutionLimit, this.EventErrorHandler);
 			this._channelCreated = new AsyncEvent<DiscordClient, ChannelCreateEventArgs>("CHANNEL_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._channelUpdated = new AsyncEvent<DiscordClient, ChannelUpdateEventArgs>("CHANNEL_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._channelDeleted = new AsyncEvent<DiscordClient, ChannelDeleteEventArgs>("CHANNEL_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._dmChannelDeleted = new AsyncEvent<DiscordClient, DmChannelDeleteEventArgs>("DM_CHANNEL_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._channelPinsUpdated = new AsyncEvent<DiscordClient, ChannelPinsUpdateEventArgs>("CHANNEL_PINS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildCreated = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildAvailable = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_AVAILABLE", EventExecutionLimit, this.EventErrorHandler);
 			this._guildUpdated = new AsyncEvent<DiscordClient, GuildUpdateEventArgs>("GUILD_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildDeleted = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildUnavailable = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_UNAVAILABLE", EventExecutionLimit, this.EventErrorHandler);
 			this._guildDownloadCompletedEv = new AsyncEvent<DiscordClient, GuildDownloadCompletedEventArgs>("GUILD_DOWNLOAD_COMPLETED", EventExecutionLimit, this.EventErrorHandler);
 			this._inviteCreated = new AsyncEvent<DiscordClient, InviteCreateEventArgs>("INVITE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._inviteDeleted = new AsyncEvent<DiscordClient, InviteDeleteEventArgs>("INVITE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageCreated = new AsyncEvent<DiscordClient, MessageCreateEventArgs>("MESSAGE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._presenceUpdated = new AsyncEvent<DiscordClient, PresenceUpdateEventArgs>("PRESENCE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildBanAdded = new AsyncEvent<DiscordClient, GuildBanAddEventArgs>("GUILD_BAN_ADD", EventExecutionLimit, this.EventErrorHandler);
 			this._guildBanRemoved = new AsyncEvent<DiscordClient, GuildBanRemoveEventArgs>("GUILD_BAN_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildEmojisUpdated = new AsyncEvent<DiscordClient, GuildEmojisUpdateEventArgs>("GUILD_EMOJI_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildStickersUpdated = new AsyncEvent<DiscordClient, GuildStickersUpdateEventArgs>("GUILD_STICKER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationsUpdated = new AsyncEvent<DiscordClient, GuildIntegrationsUpdateEventArgs>("GUILD_INTEGRATIONS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberAdded = new AsyncEvent<DiscordClient, GuildMemberAddEventArgs>("GUILD_MEMBER_ADD", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberRemoved = new AsyncEvent<DiscordClient, GuildMemberRemoveEventArgs>("GUILD_MEMBER_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberUpdated = new AsyncEvent<DiscordClient, GuildMemberUpdateEventArgs>("GUILD_MEMBER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildRoleCreated = new AsyncEvent<DiscordClient, GuildRoleCreateEventArgs>("GUILD_ROLE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildRoleUpdated = new AsyncEvent<DiscordClient, GuildRoleUpdateEventArgs>("GUILD_ROLE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildRoleDeleted = new AsyncEvent<DiscordClient, GuildRoleDeleteEventArgs>("GUILD_ROLE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageAcknowledged = new AsyncEvent<DiscordClient, MessageAcknowledgeEventArgs>("MESSAGE_ACKNOWLEDGED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageUpdated = new AsyncEvent<DiscordClient, MessageUpdateEventArgs>("MESSAGE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageDeleted = new AsyncEvent<DiscordClient, MessageDeleteEventArgs>("MESSAGE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._messagesBulkDeleted = new AsyncEvent<DiscordClient, MessageBulkDeleteEventArgs>("MESSAGE_BULK_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._interactionCreated = new AsyncEvent<DiscordClient, InteractionCreateEventArgs>("INTERACTION_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._componentInteractionCreated = new AsyncEvent<DiscordClient, ComponentInteractionCreateEventArgs>("COMPONENT_INTERACTED", EventExecutionLimit, this.EventErrorHandler);
 			this._contextMenuInteractionCreated = new AsyncEvent<DiscordClient, ContextMenuInteractionCreateEventArgs>("CONTEXT_MENU_INTERACTED", EventExecutionLimit, this.EventErrorHandler);
 			this._typingStarted = new AsyncEvent<DiscordClient, TypingStartEventArgs>("TYPING_STARTED", EventExecutionLimit, this.EventErrorHandler);
 			this._userSettingsUpdated = new AsyncEvent<DiscordClient, UserSettingsUpdateEventArgs>("USER_SETTINGS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._userUpdated = new AsyncEvent<DiscordClient, UserUpdateEventArgs>("USER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._voiceStateUpdated = new AsyncEvent<DiscordClient, VoiceStateUpdateEventArgs>("VOICE_STATE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._voiceServerUpdated = new AsyncEvent<DiscordClient, VoiceServerUpdateEventArgs>("VOICE_SERVER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMembersChunked = new AsyncEvent<DiscordClient, GuildMembersChunkEventArgs>("GUILD_MEMBERS_CHUNKED", EventExecutionLimit, this.EventErrorHandler);
 			this._unknownEvent = new AsyncEvent<DiscordClient, UnknownEventArgs>("UNKNOWN_EVENT", EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionAdded = new AsyncEvent<DiscordClient, MessageReactionAddEventArgs>("MESSAGE_REACTION_ADDED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionRemoved = new AsyncEvent<DiscordClient, MessageReactionRemoveEventArgs>("MESSAGE_REACTION_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionsCleared = new AsyncEvent<DiscordClient, MessageReactionsClearEventArgs>("MESSAGE_REACTIONS_CLEARED", EventExecutionLimit, this.EventErrorHandler);
 			this._messageReactionRemovedEmoji = new AsyncEvent<DiscordClient, MessageReactionRemoveEmojiEventArgs>("MESSAGE_REACTION_REMOVED_EMOJI", EventExecutionLimit, this.EventErrorHandler);
 			this._webhooksUpdated = new AsyncEvent<DiscordClient, WebhooksUpdateEventArgs>("WEBHOOKS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._heartbeated = new AsyncEvent<DiscordClient, HeartbeatEventArgs>("HEARTBEATED", EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandCreated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandUpdated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandDeleted = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildApplicationCommandCountUpdated = new AsyncEvent<DiscordClient, GuildApplicationCommandCountEventArgs>("GUILD_APPLICATION_COMMAND_COUNTS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._applicationCommandPermissionsUpdated = new AsyncEvent<DiscordClient, ApplicationCommandPermissionsUpdateEventArgs>("APPLICATION_COMMAND_PERMISSIONS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationCreated = new AsyncEvent<DiscordClient, GuildIntegrationCreateEventArgs>("INTEGRATION_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationUpdated = new AsyncEvent<DiscordClient, GuildIntegrationUpdateEventArgs>("INTEGRATION_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildIntegrationDeleted = new AsyncEvent<DiscordClient, GuildIntegrationDeleteEventArgs>("INTEGRATION_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._stageInstanceCreated = new AsyncEvent<DiscordClient, StageInstanceCreateEventArgs>("STAGE_INSTANCE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._stageInstanceUpdated = new AsyncEvent<DiscordClient, StageInstanceUpdateEventArgs>("STAGE_INSTANCE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._stageInstanceDeleted = new AsyncEvent<DiscordClient, StageInstanceDeleteEventArgs>("STAGE_INSTANCE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadCreated = new AsyncEvent<DiscordClient, ThreadCreateEventArgs>("THREAD_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadUpdated = new AsyncEvent<DiscordClient, ThreadUpdateEventArgs>("THREAD_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadDeleted = new AsyncEvent<DiscordClient, ThreadDeleteEventArgs>("THREAD_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadListSynced = new AsyncEvent<DiscordClient, ThreadListSyncEventArgs>("THREAD_LIST_SYNCED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadMemberUpdated = new AsyncEvent<DiscordClient, ThreadMemberUpdateEventArgs>("THREAD_MEMBER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._threadMembersUpdated = new AsyncEvent<DiscordClient, ThreadMembersUpdateEventArgs>("THREAD_MEMBERS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._zombied = new AsyncEvent<DiscordClient, ZombiedEventArgs>("ZOMBIED", EventExecutionLimit, this.EventErrorHandler);
 			this._payloadReceived = new AsyncEvent<DiscordClient, PayloadReceivedEventArgs>("PAYLOAD_RECEIVED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventCreated = new AsyncEvent<DiscordClient, GuildScheduledEventCreateEventArgs>("GUILD_SCHEDULED_EVENT_CREATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventUpdated = new AsyncEvent<DiscordClient, GuildScheduledEventUpdateEventArgs>("GUILD_SCHEDULED_EVENT_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventDeleted = new AsyncEvent<DiscordClient, GuildScheduledEventDeleteEventArgs>("GUILD_SCHEDULED_EVENT_DELETED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventUserAdded = new AsyncEvent<DiscordClient, GuildScheduledEventUserAddEventArgs>("GUILD_SCHEDULED_EVENT_USER_ADDED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildScheduledEventUserRemoved = new AsyncEvent<DiscordClient, GuildScheduledEventUserRemoveEventArgs>("GUILD_SCHEDULED_EVENT_USER_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 			this._embeddedActivityUpdated = new AsyncEvent<DiscordClient, EmbeddedActivityUpdateEventArgs>("EMBEDDED_ACTIVITY_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberTimeoutAdded = new AsyncEvent<DiscordClient, GuildMemberTimeoutAddEventArgs>("GUILD_MEMBER_TIMEOUT_ADDED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberTimeoutChanged = new AsyncEvent<DiscordClient, GuildMemberTimeoutUpdateEventArgs>("GUILD_MEMBER_TIMEOUT_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 			this._guildMemberTimeoutRemoved = new AsyncEvent<DiscordClient, GuildMemberTimeoutRemoveEventArgs>("GUILD_MEMBER_TIMEOUT_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 			this._rateLimitHit = new AsyncEvent<DiscordClient, RateLimitExceptionEventArgs>("RATELIMIT_HIT", EventExecutionLimit, this.EventErrorHandler);
 
 			this.GuildsInternal.Clear();
 
 			this._presencesLazy = new Lazy<IReadOnlyDictionary<ulong, DiscordPresence>>(() => new ReadOnlyDictionary<ulong, DiscordPresence>(this.PresencesInternal));
 			this._embeddedActivitiesLazy = new Lazy<IReadOnlyDictionary<string, DiscordActivity>>(() => new ReadOnlyDictionary<string, DiscordActivity>(this.EmbeddedActivitiesInternal));
 		}
 
 		#endregion
 
 		#region Client Extension Methods
 
 		/// <summary>
 		/// Registers an extension with this client.
 		/// </summary>
 		/// <param name="ext">Extension to register.</param>
 		public void AddExtension(BaseExtension ext)
 		{
 			ext.Setup(this);
 			this._extensions.Add(ext);
 		}
 
 		/// <summary>
 		/// Retrieves a previously registered extension from this client.
 		/// </summary>
 		/// <typeparam name="T">The type of extension to retrieve.</typeparam>
 		/// <returns>The requested extension.</returns>
 		public T GetExtension<T>() where T : BaseExtension
 			=> this._extensions.FirstOrDefault(x => x.GetType() == typeof(T)) as T;
 
 		#endregion
 
 		#region Public Connection Methods
 
 		/// <summary>
 		/// Connects to the gateway.
 		/// </summary>
 		/// <param name="activity">The activity to set. Defaults to null.</param>
 		/// <param name="status">The optional status to set. Defaults to null.</param>
 		/// <param name="idlesince">Since when is the client performing the specified activity. Defaults to null.</param>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when an invalid token was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task ConnectAsync(DiscordActivity activity = null, UserStatus? status = null, DateTimeOffset? idlesince = null)
 		{
 			// Check if connection lock is already set, and set it if it isn't
 			if (!this._connectionLock.Wait(0))
 				throw new InvalidOperationException("This client is already connected.");
 			this._connectionLock.Set();
 
 			var w = 7500;
 			var i = 5;
 			var s = false;
 			Exception cex = null;
 
 			if (activity == null && status == null && idlesince == null)
 				this._status = null;
 			else
 			{
 				var sinceUnix = idlesince != null ? (long?)Utilities.GetUnixTime(idlesince.Value) : null;
 				this._status = new StatusUpdate()
 				{
 					Activity = new TransportActivity(activity),
 					Status = status ?? UserStatus.Online,
 					IdleSince = sinceUnix,
 					IsAfk = idlesince != null,
 					ActivityInternal = activity
 				};
 			}
 
 			if (!this.IsShard)
 			{
 				if (this.Configuration.TokenType != TokenType.Bot)
 					this.Logger.LogWarning(LoggerEvents.Misc, "You are logging in with a token that is not a bot token. This is not officially supported by Discord, and can result in your account being terminated if you aren't careful.");
 				this.Logger.LogInformation(LoggerEvents.Startup, "Lib {0}, version {1}", this.BotLibrary, this.VersionString);
 			}
 
 			while (i-- > 0 || this.Configuration.ReconnectIndefinitely)
 			{
 				try
 				{
 					await this.InternalConnectAsync().ConfigureAwait(false);
 					s = true;
 					break;
 				}
 				catch (UnauthorizedException e)
 				{
 					FailConnection(this._connectionLock);
 					throw new Exception("Authentication failed. Check your token and try again.", e);
 				}
 				catch (PlatformNotSupportedException)
 				{
 					FailConnection(this._connectionLock);
 					throw;
 				}
 				catch (NotImplementedException)
 				{
 					FailConnection(this._connectionLock);
 					throw;
 				}
 				catch (Exception ex)
 				{
 					FailConnection(null);
 
 					cex = ex;
 					if (i <= 0 && !this.Configuration.ReconnectIndefinitely) break;
 
 					this.Logger.LogError(LoggerEvents.ConnectionFailure, ex, "Connection attempt failed, retrying in {0}s", w / 1000);
 					await Task.Delay(w).ConfigureAwait(false);
 
 					if (i > 0)
 						w *= 2;
 				}
 			}
 
 			if (!s && cex != null)
 			{
 				this._connectionLock.Set();
 				throw new Exception("Could not connect to Discord.", cex);
 			}
 
 			// non-closure, hence args
 			static void FailConnection(ManualResetEventSlim cl) =>
 				// unlock this (if applicable) so we can let others attempt to connect
 				cl?.Set();
 		}
 
 		/// <summary>
 		/// Reconnects to the gateway.
 		/// </summary>
 		/// <param name="startNewSession">Whether to start a new session.</param>
 		public Task ReconnectAsync(bool startNewSession = false)
 			=> this.InternalReconnectAsync(startNewSession, code: startNewSession ? 1000 : 4002);
 
 		/// <summary>
 		/// Disconnects from the gateway.
 		/// </summary>
 		public async Task DisconnectAsync()
 		{
 			this.Configuration.AutoReconnect = false;
 			if (this.WebSocketClient != null)
 				await this.WebSocketClient.DisconnectAsync().ConfigureAwait(false);
 		}
 
 		#endregion
 
 		#region Public REST Methods
 
 		/// <summary>
 		/// Gets a user.
 		/// </summary>
 		/// <param name="userId">Id of the user</param>
 		/// <param name="fetch">Whether to fetch the user again. Defaults to true.</param>
 		/// <returns>The requested user.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordUser> GetUserAsync(ulong userId, bool fetch = true)
 		{
 			if (!fetch)
 			{
 				return this.TryGetCachedUserInternal(userId, out var usr) ? usr : new DiscordUser { Id = userId, Discord = this };
 			}
 			else
 			{
 				var usr = await this.ApiClient.GetUserAsync(userId).ConfigureAwait(false);
 				usr = this.UserCache.AddOrUpdate(userId, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					old.BannerHash = usr.BannerHash;
 					old.BannerColorInternal = usr.BannerColorInternal;
 					return old;
 				});
 
 				return usr;
 			}
 		}
 
 		/// <summary>
 		/// Gets a channel.
 		/// </summary>
 		/// <param name="id">The id of the channel to get.</param>
 		/// <returns>The requested channel.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordChannel> GetChannelAsync(ulong id)
 			=> this.InternalGetCachedChannel(id) ?? await this.ApiClient.GetChannelAsync(id).ConfigureAwait(false);
 
 		/// <summary>
 		/// Gets a thread.
 		/// </summary>
 		/// <param name="id">The id of the thread to get.</param>
 		/// <returns>The requested thread.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordThreadChannel> GetThreadAsync(ulong id)
 			=> this.InternalGetCachedThread(id) ?? await this.ApiClient.GetThreadAsync(id).ConfigureAwait(false);
 
 		/// <summary>
 		/// Sends a normal message.
 		/// </summary>
 		/// <param name="channel">The channel to send to.</param>
 		/// <param name="content">The message content to send.</param>
 		/// <returns>The message that was sent.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content)
 			=> this.ApiClient.CreateMessageAsync(channel.Id, content, embeds: null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 		/// <summary>
 		/// Sends a message with an embed.
 		/// </summary>
 		/// <param name="channel">The channel to send to.</param>
 		/// <param name="embed">The embed to attach to the message.</param>
 		/// <returns>The message that was sent.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordEmbed embed)
 			=> this.ApiClient.CreateMessageAsync(channel.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 		/// <summary>
 		/// Sends a message with content and an embed.
 		/// </summary>
 		/// <param name="channel">Channel to send to.</param>
 		/// <param name="content">The message content to send.</param>
 		/// <param name="embed">The embed to attach to the message.</param>
 		/// <returns>The message that was sent.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content, DiscordEmbed embed)
 			=> this.ApiClient.CreateMessageAsync(channel.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 		/// <summary>
 		/// Sends a message with the <see cref="DisCatSharp.Entities.DiscordMessageBuilder"/>.
 		/// </summary>
 		/// <param name="channel">The channel to send the message to.</param>
 		/// <param name="builder">The message builder.</param>
 		/// <returns>The message that was sent.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordMessageBuilder builder)
 			=> this.ApiClient.CreateMessageAsync(channel.Id, builder);
 
 		/// <summary>
 		/// Sends a message with an <see cref="System.Action{DiscordMessageBuilder}"/>.
 		/// </summary>
 		/// <param name="channel">The channel to send the message to.</param>
 		/// <param name="action">The message builder.</param>
 		/// <returns>The message that was sent.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, Action<DiscordMessageBuilder> action)
 		{
 			var builder = new DiscordMessageBuilder();
 			action(builder);
 
 			return this.ApiClient.CreateMessageAsync(channel.Id, builder);
 		}
 
 		/// <summary>
 		/// Creates a guild. This requires the bot to be in less than 10 guilds total.
 		/// </summary>
 		/// <param name="name">Name of the guild.</param>
 		/// <param name="region">Voice region of the guild.</param>
 		/// <param name="icon">Stream containing the icon for the guild.</param>
 		/// <param name="verificationLevel">Verification level for the guild.</param>
 		/// <param name="defaultMessageNotifications">Default message notification settings for the guild.</param>
 		/// <param name="systemChannelFlags">System channel flags fopr the guild.</param>
 		/// <returns>The created guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuild> CreateGuildAsync(string name, string region = null, Optional<Stream> icon = default, VerificationLevel? verificationLevel = null,
 			DefaultMessageNotifications? defaultMessageNotifications = null, SystemChannelFlags? systemChannelFlags = null)
 		{
 			var iconb64 = Optional.FromNoValue<string>();
 			if (icon.HasValue && icon.Value != null)
 				using (var imgtool = new ImageTool(icon.Value))
 					iconb64 = imgtool.GetBase64();
 			else if (icon.HasValue)
 				iconb64 = null;
 
 			return this.ApiClient.CreateGuildAsync(name, region, iconb64, verificationLevel, defaultMessageNotifications, systemChannelFlags);
 		}
 
 		/// <summary>
 		/// Creates a guild from a template. This requires the bot to be in less than 10 guilds total.
 		/// </summary>
 		/// <param name="code">The template code.</param>
 		/// <param name="name">Name of the guild.</param>
 		/// <param name="icon">Stream containing the icon for the guild.</param>
 		/// <returns>The created guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuild> CreateGuildFromTemplateAsync(string code, string name, Optional<Stream> icon = default)
 		{
 			var iconb64 = Optional.FromNoValue<string>();
 			if (icon.HasValue && icon.Value != null)
 				using (var imgtool = new ImageTool(icon.Value))
 					iconb64 = imgtool.GetBase64();
 			else if (icon.HasValue)
 				iconb64 = null;
 
 			return this.ApiClient.CreateGuildFromTemplateAsync(code, name, iconb64);
 		}
 
 		/// <summary>
 		/// Executes a raw request.
 		/// </summary>
 		/// <example>
 		/// <c>
 		/// var request = await Client.ExecuteRawRequestAsync(RestRequestMethod.GET, $"{Endpoints.CHANNELS}/243184972190742178964/{Endpoints.INVITES}");
 		/// List&lt;DiscordInvite&gt; invites = DiscordJson.ToDiscordObject&lt;List&lt;DiscordInvite&gt;&gt;(request.Response);
 		/// </c>
 		/// </example>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <param name="routeParams">The route parameters.</param>
 		/// <param name="jsonBody">The json body.</param>
 		/// <param name="additionalHeaders">The addditional headers.</param>
 		/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the ressource does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		/// <returns>A awaitable RestResponse</returns>
 		[Obsolete("This is no longer needed. Use DiscordClient.RestClient instead.", false)] 
 		public async Task<RestResponse> ExecuteRawRequestAsync(RestRequestMethod method, string route, object routeParams, string jsonBody = null, Dictionary<string, string> additionalHeaders = null, double? ratelimitWaitOverride = null)
 		{
 			var bucket = this.ApiClient.Rest.GetBucket(method, route, routeParams, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Configuration);
 			var res = await this.ApiClient.DoRequestAsync(this, bucket, url, method, route, additionalHeaders, DiscordJson.SerializeObject(jsonBody), ratelimitWaitOverride);
 
 			return res;
 		}
 
 		/// <summary>
 		/// Gets a guild.
 		/// <para>Setting <paramref name="withCounts"/> to true will make a REST request.</para>
 		/// </summary>
 		/// <param name="id">The guild ID to search for.</param>
 		/// <param name="withCounts">Whether to include approximate presence and member counts in the returned guild.</param>
 		/// <returns>The requested Guild.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordGuild> GetGuildAsync(ulong id, bool? withCounts = null)
 		{
 			if (this.GuildsInternal.TryGetValue(id, out var guild) && (!withCounts.HasValue || !withCounts.Value))
 				return guild;
 
 			guild = await this.ApiClient.GetGuildAsync(id, withCounts).ConfigureAwait(false);
 			var channels = await this.ApiClient.GetGuildChannelsAsync(guild.Id).ConfigureAwait(false);
 			foreach (var channel in channels) guild.ChannelsInternal[channel.Id] = channel;
 
 			return guild;
 		}
 
 		/// <summary>
 		/// Gets a guild preview.
 		/// </summary>
 		/// <param name="id">The guild ID.</param>
 		/// <returns></returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong id)
 			=> this.ApiClient.GetGuildPreviewAsync(id);
 
 		/// <summary>
 		/// Gets an invite.
 		/// </summary>
 		/// <param name="code">The invite code.</param>
 		/// <param name="withCounts">Whether to include presence and total member counts in the returned invite.</param>
 		/// <param name="withExpiration">Whether to include the expiration date in the returned invite.</param>
 		/// <param name="scheduledEventId">The scheduled event id.</param>
 		/// <returns>The requested Invite.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the invite does not exists.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordInvite> GetInviteByCodeAsync(string code, bool? withCounts = null, bool? withExpiration = null, ulong? scheduledEventId = null)
 			=> this.ApiClient.GetInviteAsync(code, withCounts, withExpiration, scheduledEventId);
 
 		/// <summary>
 		/// Gets a list of user connections.
 		/// </summary>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordConnection>> GetConnectionsAsync()
 			=> this.ApiClient.GetUserConnectionsAsync();
 
 		/// <summary>
 		/// Gets a sticker.
 		/// </summary>
 		/// <returns>The requested sticker.</returns>
 		/// <param name="id">The id of the sticker.</param>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the sticker does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordSticker> GetStickerAsync(ulong id)
 			=> this.ApiClient.GetStickerAsync(id);
 
 
 		/// <summary>
 		/// Gets all nitro sticker packs.
 		/// </summary>
 		/// <returns>List of sticker packs.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<IReadOnlyList<DiscordStickerPack>> GetStickerPacksAsync()
 			=> this.ApiClient.GetStickerPacksAsync();
 
 
 		/// <summary>
 		/// Gets the In-App OAuth Url.
 		/// </summary>
 		/// <param name="scopes">Defaults to <see cref="DisCatSharp.Enums.OAuthScopes.BOT_DEFAULT"/>.</param>
 		/// <param name="redir">Redirect Uri.</param>
 		/// <param name="permissions">Defaults to <see cref="Permissions.None"/>.</param>
 		/// <returns>The OAuth Url</returns>
 		public Uri GetInAppOAuth(Permissions permissions = Permissions.None, OAuthScopes scopes = OAuthScopes.BOT_DEFAULT, string redir = null)
 		{
 			permissions &= PermissionMethods.FullPerms;
 			// hey look, it's not all annoying and blue :P
 			return new Uri(new QueryUriBuilder($"{DiscordDomain.GetDomain(CoreDomain.Discord).Url}{Endpoints.OAUTH2}{Endpoints.AUTHORIZE}")
 				.AddParameter("client_id", this.CurrentApplication.Id.ToString(CultureInfo.InvariantCulture))
 				.AddParameter("scope", OAuth.ResolveScopes(scopes))
 				.AddParameter("permissions", ((long)permissions).ToString(CultureInfo.InvariantCulture))
 				.AddParameter("state", "")
 				.AddParameter("redirect_uri", redir ?? "")
 				.ToString());
 		}
 
 		/// <summary>
 		/// Gets a webhook.
 		/// </summary>
 		/// <param name="id">The target webhook id.</param>
 		/// <returns>The requested webhook.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordWebhook> GetWebhookAsync(ulong id)
 			=> this.ApiClient.GetWebhookAsync(id);
 
 		/// <summary>
 		/// Gets a webhook.
 		/// </summary>
 		/// <param name="id">The target webhook id.</param>
 		/// <param name="token">The target webhook token.</param>
 		/// <returns>The requested webhook.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong id, string token)
 			=> this.ApiClient.GetWebhookWithTokenAsync(id, token);
 
 		/// <summary>
 		/// Updates current user's activity and status.
 		/// </summary>
 		/// <param name="activity">Activity to set.</param>
 		/// <param name="userStatus">Status of the user.</param>
 		/// <param name="idleSince">Since when is the client performing the specified activity.</param>
 		/// <returns></returns>
 		public Task UpdateStatusAsync(DiscordActivity activity = null, UserStatus? userStatus = null, DateTimeOffset? idleSince = null)
 			=> this.InternalUpdateStatusAsync(activity, userStatus, idleSince);
 
 		/// <summary>
 		/// Edits current user.
 		/// </summary>
 		/// <param name="username">New username.</param>
 		/// <param name="avatar">New avatar.</param>
 		/// <returns>The modified user.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public async Task<DiscordUser> UpdateCurrentUserAsync(string username = null, Optional<Stream> avatar = default)
 		{
 			var av64 = Optional.FromNoValue<string>();
 			if (avatar.HasValue && avatar.Value != null)
 				using (var imgtool = new ImageTool(avatar.Value))
 					av64 = imgtool.GetBase64();
 			else if (avatar.HasValue)
 				av64 = null;
 
 			var usr = await this.ApiClient.ModifyCurrentUserAsync(username, av64).ConfigureAwait(false);
 
 			this.CurrentUser.Username = usr.Username;
 			this.CurrentUser.Discriminator = usr.Discriminator;
 			this.CurrentUser.AvatarHash = usr.AvatarHash;
 			return this.CurrentUser;
 		}
 
 		/// <summary>
 		/// Gets a guild template by the code.
 		/// </summary>
 		/// <param name="code">The code of the template.</param>
 		/// <returns>The guild template for the code.</returns>
 		/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 		/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 		public Task<DiscordGuildTemplate> GetTemplateAsync(string code)
 			=> this.ApiClient.GetTemplateAsync(code);
 
 		/// <summary>
 		/// Gets all the global application commands for this application.
 		/// </summary>
+		/// <param name="withLocalizations">Whether to get the full localization dict.</param>
 		/// <returns>A list of global application commands.</returns>
-		public Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync() =>
-			this.ApiClient.GetGlobalApplicationCommandsAsync(this.CurrentApplication.Id);
+		public Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync(bool withLocalizations = false) =>
+			this.ApiClient.GetGlobalApplicationCommandsAsync(this.CurrentApplication.Id, withLocalizations);
 
 		/// <summary>
 		/// Overwrites the existing global application commands. New commands are automatically created and missing commands are automatically deleted.
 		/// </summary>
 		/// <param name="commands">The list of commands to overwrite with.</param>
 		/// <returns>The list of global commands.</returns>
 		public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGlobalApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
 			this.ApiClient.BulkOverwriteGlobalApplicationCommandsAsync(this.CurrentApplication.Id, commands);
 
 		/// <summary>
 		/// Creates or overwrites a global application command.
 		/// </summary>
 		/// <param name="command">The command to create.</param>
 		/// <returns>The created command.</returns>
 		public Task<DiscordApplicationCommand> CreateGlobalApplicationCommandAsync(DiscordApplicationCommand command) =>
 			this.ApiClient.CreateGlobalApplicationCommandAsync(this.CurrentApplication.Id, command);
 
 		/// <summary>
 		/// Gets a global application command by its id.
 		/// </summary>
 		/// <param name="commandId">The id of the command to get.</param>
 		/// <returns>The command with the id.</returns>
 		public Task<DiscordApplicationCommand> GetGlobalApplicationCommandAsync(ulong commandId) =>
 			this.ApiClient.GetGlobalApplicationCommandAsync(this.CurrentApplication.Id, commandId);
 
 		/// <summary>
 		/// Edits a global application command.
 		/// </summary>
 		/// <param name="commandId">The id of the command to edit.</param>
 		/// <param name="action">Action to perform.</param>
 		/// <returns>The edited command.</returns>
 		public async Task<DiscordApplicationCommand> EditGlobalApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
 		{
 			var mdl = new ApplicationCommandEditModel();
 			action(mdl);
 			var applicationId = this.CurrentApplication?.Id ?? (await this.GetCurrentApplicationAsync().ConfigureAwait(false)).Id;
 			return await this.ApiClient.EditGlobalApplicationCommandAsync(applicationId, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.DefaultPermission, mdl.NameLocalizations, mdl.DescriptionLocalizations).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Deletes a global application command.
 		/// </summary>
 		/// <param name="commandId">The id of the command to delete.</param>
 		public Task DeleteGlobalApplicationCommandAsync(ulong commandId) =>
 			this.ApiClient.DeleteGlobalApplicationCommandAsync(this.CurrentApplication.Id, commandId);
 
 		/// <summary>
 		/// Gets all the application commands for a guild.
 		/// </summary>
 		/// <param name="guildId">The id of the guild to get application commands for.</param>
+		/// <param name="withLocalizations">Whether to get the full localization dict.</param>
 		/// <returns>A list of application commands in the guild.</returns>
-		public Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong guildId) =>
-			this.ApiClient.GetGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId);
+		public Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong guildId, bool withLocalizations = false) =>
+			this.ApiClient.GetGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, withLocalizations);
 
 		/// <summary>
 		/// Overwrites the existing application commands in a guild. New commands are automatically created and missing commands are automatically deleted.
 		/// </summary>
 		/// <param name="guildId">The id of the guild.</param>
 		/// <param name="commands">The list of commands to overwrite with.</param>
 		/// <returns>The list of guild commands.</returns>
 		public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGuildApplicationCommandsAsync(ulong guildId, IEnumerable<DiscordApplicationCommand> commands) =>
 			this.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, commands);
 
 		/// <summary>
 		/// Creates or overwrites a guild application command.
 		/// </summary>
 		/// <param name="guildId">The id of the guild to create the application command in.</param>
 		/// <param name="command">The command to create.</param>
 		/// <returns>The created command.</returns>
 		public Task<DiscordApplicationCommand> CreateGuildApplicationCommandAsync(ulong guildId, DiscordApplicationCommand command) =>
 			this.ApiClient.CreateGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, command);
 
 		/// <summary>
 		/// Gets a application command in a guild by its id.
 		/// </summary>
 		/// <param name="guildId">The id of the guild the application command is in.</param>
 		/// <param name="commandId">The id of the command to get.</param>
 		/// <returns>The command with the id.</returns>
 		public Task<DiscordApplicationCommand> GetGuildApplicationCommandAsync(ulong guildId, ulong commandId) =>
 			 this.ApiClient.GetGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, commandId);
 
 		/// <summary>
 		/// Edits a application command in a guild.
 		/// </summary>
 		/// <param name="guildId">The id of the guild the application command is in.</param>
 		/// <param name="commandId">The id of the command to edit.</param>
 		/// <param name="action">Action to perform.</param>
 		/// <returns>The edited command.</returns>
 		public async Task<DiscordApplicationCommand> EditGuildApplicationCommandAsync(ulong guildId, ulong commandId, Action<ApplicationCommandEditModel> action)
 		{
 			var mdl = new ApplicationCommandEditModel();
 			action(mdl);
 			var applicationId = this.CurrentApplication?.Id ?? (await this.GetCurrentApplicationAsync().ConfigureAwait(false)).Id;
 			return await this.ApiClient.EditGuildApplicationCommandAsync(applicationId, guildId, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.DefaultPermission, mdl.NameLocalizations, mdl.DescriptionLocalizations).ConfigureAwait(false);
 		}
 
 		/// <summary>
 		/// Deletes a application command in a guild.
 		/// </summary>
 		/// <param name="guildId">The id of the guild to delete the application command in.</param>
 		/// <param name="commandId">The id of the command.</param>
 		public Task DeleteGuildApplicationCommandAsync(ulong guildId, ulong commandId) =>
 			this.ApiClient.DeleteGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, commandId);
 
 		/// <summary>
 		/// Gets all command permissions for a guild.
 		/// </summary>
 		/// <param name="guildId">The target guild.</param>
 		public Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> GetGuildApplicationCommandPermissionsAsync(ulong guildId) =>
 			this.ApiClient.GetGuildApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId);
 
 		/// <summary>
 		/// Gets the permissions for a guild command.
 		/// </summary>
 		/// <param name="guildId">The target guild.</param>
 		/// <param name="commandId">The target command id.</param>
 		public Task<DiscordGuildApplicationCommandPermission> GetApplicationCommandPermissionAsync(ulong guildId, ulong commandId) =>
 			this.ApiClient.GetGuildApplicationCommandPermissionAsync(this.CurrentApplication.Id, guildId, commandId);
 
 		/// <summary>
 		/// Overwrites the existing permissions for a application command in a guild. New permissions are automatically created and missing permissions are deleted.
 		/// A command takes up to 10 permission overwrites.
 		/// </summary>
 		/// <param name="guildId">The id of the guild.</param>
 		/// <param name="commandId">The id of the command.</param>
 		/// <param name="permissions">List of permissions.</param>
 		public Task<DiscordGuildApplicationCommandPermission> OverwriteGuildApplicationCommandPermissionsAsync(ulong guildId, ulong commandId, IEnumerable<DiscordApplicationCommandPermission> permissions) =>
 			this.ApiClient.OverwriteGuildApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId, commandId, permissions);
 
 		/// <summary>
 		/// Overwrites the existing application command permissions in a guild. New permissions are automatically created and missing permissions are deleted.
 		/// Each command takes up to 10 permission overwrites.
 		/// </summary>
 		/// <param name="guildId">The id of the guild.</param>
 		/// <param name="permissionsOverwrites">The list of permissions to overwrite with.</param>
 		public Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> BulkOverwriteGuildApplicationCommandsAsync(ulong guildId, IEnumerable<DiscordGuildApplicationCommandPermission> permissionsOverwrites) =>
 			this.ApiClient.BulkOverwriteGuildApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId, permissionsOverwrites);
 		#endregion
 
 		#region Internal Caching Methods
 		/// <summary>
 		/// Gets the internal chached threads.
 		/// </summary>
 		/// <param name="threadId">The target thread id.</param>
 		/// <returns>The requested thread.</returns>
 		internal DiscordThreadChannel InternalGetCachedThread(ulong threadId)
 		{
 			foreach (var guild in this.Guilds.Values)
 				if (guild.Threads.TryGetValue(threadId, out var foundThread))
 					return foundThread;
 
 			return null;
 		}
 
 
 		/// <summary>
 		/// Gets the internal chached scheduled event.
 		/// </summary>
 		/// <param name="scheduledEventId">The target scheduled event id.</param>
 		/// <returns>The requested scheduled event.</returns>
 		internal DiscordScheduledEvent InternalGetCachedScheduledEvent(ulong scheduledEventId)
 		{
 			foreach (var guild in this.Guilds.Values)
 				if (guild.ScheduledEvents.TryGetValue(scheduledEventId, out var foundScheduledEvent))
 					return foundScheduledEvent;
 
 			return null;
 		}
 
 		/// <summary>
 		/// Gets the internal chached channel.
 		/// </summary>
 		/// <param name="channelId">The target channel id.</param>
 		/// <returns>The requested channel.</returns>
 		internal DiscordChannel InternalGetCachedChannel(ulong channelId)
 		{
 			foreach (var guild in this.Guilds.Values)
 				if (guild.Channels.TryGetValue(channelId, out var foundChannel))
 					return foundChannel;
 
 			return null;
 		}
 
 		/// <summary>
 		/// Gets the internal chached guild.
 		/// </summary>
 		/// <param name="guildId">The target guild id.</param>
 		/// <returns>The requested guild.</returns>
 		internal DiscordGuild InternalGetCachedGuild(ulong? guildId)
 		{
 			if (this.GuildsInternal != null && guildId.HasValue)
 			{
 				if (this.GuildsInternal.TryGetValue(guildId.Value, out var guild))
 					return guild;
 			}
 
 			return null;
 		}
 
 		/// <summary>
 		/// Updates a message.
 		/// </summary>
 		/// <param name="message">The message to update.</param>
 		/// <param name="author">The author to update.</param>
 		/// <param name="guild">The guild to update.</param>
 		/// <param name="member">The member to update.</param>
 		private void UpdateMessage(DiscordMessage message, TransportUser author, DiscordGuild guild, TransportMember member)
 		{
 			if (author != null)
 			{
 				var usr = new DiscordUser(author) { Discord = this };
 
 				if (member != null)
 					member.User = author;
 
 				message.Author = this.UpdateUser(usr, guild?.Id, guild, member);
 			}
 
 			var channel = this.InternalGetCachedChannel(message.ChannelId);
 
 			if (channel != null) return;
 
 			channel = !message.GuildId.HasValue
 				? new DiscordDmChannel
 				{
 					Id = message.ChannelId,
 					Discord = this,
 					Type = ChannelType.Private
 				}
 				: new DiscordChannel
 				{
 					Id = message.ChannelId,
 					Discord = this
 				};
 
 			message.Channel = channel;
 		}
 
 		/// <summary>
 		/// Updates a scheduled event.
 		/// </summary>
 		/// <param name="scheduledEvent">The scheduled event to update.</param>
 		/// <param name="guild">The guild to update.</param>
 		/// <returns>The updated scheduled event.</returns>
 		private DiscordScheduledEvent UpdateScheduledEvent(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 		{
 			if (scheduledEvent != null)
 			{
 				_ = guild.ScheduledEventsInternal.AddOrUpdate(scheduledEvent.Id, scheduledEvent, (id, old) =>
 				{
 					old.Discord = this;
 					old.Description = scheduledEvent.Description;
 					old.ChannelId = scheduledEvent.ChannelId;
 					old.EntityId = scheduledEvent.EntityId;
 					old.EntityType = scheduledEvent.EntityType;
 					old.EntityMetadata = scheduledEvent.EntityMetadata;
 					old.PrivacyLevel = scheduledEvent.PrivacyLevel;
 					old.Name = scheduledEvent.Name;
 					old.Status = scheduledEvent.Status;
 					old.UserCount = scheduledEvent.UserCount;
 					old.ScheduledStartTimeRaw = scheduledEvent.ScheduledStartTimeRaw;
 					old.ScheduledEndTimeRaw = scheduledEvent.ScheduledEndTimeRaw;
 					return old;
 				});
 			}
 
 			return scheduledEvent;
 		}
 
 		/// <summary>
 		/// Updates a user.
 		/// </summary>
 		/// <param name="usr">The user to update.</param>
 		/// <param name="guildId">The guild id to update.</param>
 		/// <param name="guild">The guild to update.</param>
 		/// <param name="mbr">The member to update.</param>
 		/// <returns>The updated user.</returns>
 		private DiscordUser UpdateUser(DiscordUser usr, ulong? guildId, DiscordGuild guild, TransportMember mbr)
 		{
 			if (mbr != null)
 			{
 				if (mbr.User != null)
 				{
 					usr = new DiscordUser(mbr.User) { Discord = this };
 
 					_ = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 					{
 						old.Username = usr.Username;
 						old.Discriminator = usr.Discriminator;
 						old.AvatarHash = usr.AvatarHash;
 						return old;
 					});
 
 					usr = new DiscordMember(mbr) { Discord = this, GuildId = guildId.Value };
 				}
 
 				var intents = this.Configuration.Intents;
 
 				DiscordMember member = default;
 
 				if (!intents.HasAllPrivilegedIntents() || guild.IsLarge) // we have the necessary privileged intents, no need to worry about caching here unless guild is large.
 				{
 					if (guild?.MembersInternal.TryGetValue(usr.Id, out member) == false)
 					{
 						if (intents.HasIntent(DiscordIntents.GuildMembers) || this.Configuration.AlwaysCacheMembers) // member can be updated by events, so cache it
 						{
 							guild.MembersInternal.TryAdd(usr.Id, (DiscordMember)usr);
 						}
 					}
 					else if (intents.HasIntent(DiscordIntents.GuildPresences) || this.Configuration.AlwaysCacheMembers) // we can attempt to update it if it's already in cache.
 					{
 						if (!intents.HasIntent(DiscordIntents.GuildMembers)) // no need to update if we already have the member events
 						{
 							_ = guild.MembersInternal.TryUpdate(usr.Id, (DiscordMember)usr, member);
 						}
 					}
 				}
 			}
 			else if (usr.Username != null) // check if not a skeleton user
 			{
 				_ = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
 			}
 
 			return usr;
 		}
 
 		/// <summary>
 		/// Updates the cached scheduled events in a guild.
 		/// </summary>
 		/// <param name="guild">The guild.</param>
 		/// <param name="rawEvents">The raw events.</param>
 		private void UpdateCachedScheduledEvent(DiscordGuild guild, JArray rawEvents)
 		{
 			if (this._disposed)
 				return;
 
 			if (rawEvents != null)
 			{
 				guild.ScheduledEventsInternal.Clear();
 
 				foreach (var xj in rawEvents)
 				{
 					var xtm = xj.ToDiscordObject<DiscordScheduledEvent>();
 
 					xtm.Discord = this;
 
 					guild.ScheduledEventsInternal[xtm.Id] = xtm;
 				}
 			}
 		}
 
 		/// <summary>
 		/// Updates the cached guild.
 		/// </summary>
 		/// <param name="newGuild">The new guild.</param>
 		/// <param name="rawMembers">The raw members.</param>
 		private void UpdateCachedGuild(DiscordGuild newGuild, JArray rawMembers)
 		{
 			if (this._disposed)
 				return;
 
 			if (!this.GuildsInternal.ContainsKey(newGuild.Id))
 				this.GuildsInternal[newGuild.Id] = newGuild;
 
 			var guild = this.GuildsInternal[newGuild.Id];
 
 			if (newGuild.ChannelsInternal != null && newGuild.ChannelsInternal.Count > 0)
 			{
 				foreach (var channel in newGuild.ChannelsInternal.Values)
 				{
 					if (guild.ChannelsInternal.TryGetValue(channel.Id, out _)) continue;
 
 					foreach (var overwrite in channel.PermissionOverwritesInternal)
 					{
 						overwrite.Discord = this;
 						overwrite.ChannelId = channel.Id;
 					}
 
 					guild.ChannelsInternal[channel.Id] = channel;
 				}
 			}
 
 			if (newGuild.ThreadsInternal != null && newGuild.ThreadsInternal.Count > 0)
 			{
 				foreach (var thread in newGuild.ThreadsInternal.Values)
 				{
 					if (guild.ThreadsInternal.TryGetValue(thread.Id, out _)) continue;
 
 					guild.ThreadsInternal[thread.Id] = thread;
 				}
 			}
 
 			if (newGuild.ScheduledEventsInternal != null && newGuild.ScheduledEventsInternal.Count > 0)
 			{
 				foreach (var @event in newGuild.ScheduledEventsInternal.Values)
 				{
 					if (guild.ScheduledEventsInternal.TryGetValue(@event.Id, out _)) continue;
 
 					guild.ScheduledEventsInternal[@event.Id] = @event;
 				}
 			}
 
 			foreach (var newEmoji in newGuild.EmojisInternal.Values)
 				_ = guild.EmojisInternal.GetOrAdd(newEmoji.Id, _ => newEmoji);
 
 			foreach (var newSticker in newGuild.StickersInternal.Values)
 				_ = guild.StickersInternal.GetOrAdd(newSticker.Id, _ => newSticker);
 
 			foreach (var newStageInstance in newGuild.StageInstancesInternal.Values)
 				_ = guild.StageInstancesInternal.GetOrAdd(newStageInstance.Id, _ => newStageInstance);
 
 			if (rawMembers != null)
 			{
 				guild.MembersInternal.Clear();
 
 				foreach (var xj in rawMembers)
 				{
 					var xtm = xj.ToDiscordObject<TransportMember>();
 
 					var xu = new DiscordUser(xtm.User) { Discord = this };
 					_ = this.UserCache.AddOrUpdate(xtm.User.Id, xu, (id, old) =>
 					{
 						old.Username = xu.Username;
 						old.Discriminator = xu.Discriminator;
 						old.AvatarHash = xu.AvatarHash;
 						old.PremiumType = xu.PremiumType;
 						return old;
 					});
 
 					guild.MembersInternal[xtm.User.Id] = new DiscordMember(xtm) { Discord = this, GuildId = guild.Id };
 				}
 			}
 
 			foreach (var role in newGuild.RolesInternal.Values)
 			{
 				if (guild.RolesInternal.TryGetValue(role.Id, out _)) continue;
 
 				role.GuildId = guild.Id;
 				guild.RolesInternal[role.Id] = role;
 			}
 
 			guild.Name = newGuild.Name;
 			guild.AfkChannelId = newGuild.AfkChannelId;
 			guild.AfkTimeout = newGuild.AfkTimeout;
 			guild.DefaultMessageNotifications = newGuild.DefaultMessageNotifications;
 			guild.RawFeatures = newGuild.RawFeatures;
 			guild.IconHash = newGuild.IconHash;
 			guild.MfaLevel = newGuild.MfaLevel;
 			guild.OwnerId = newGuild.OwnerId;
 			guild.VoiceRegionId = newGuild.VoiceRegionId;
 			guild.SplashHash = newGuild.SplashHash;
 			guild.VerificationLevel = newGuild.VerificationLevel;
 			guild.WidgetEnabled = newGuild.WidgetEnabled;
 			guild.WidgetChannelId = newGuild.WidgetChannelId;
 			guild.ExplicitContentFilter = newGuild.ExplicitContentFilter;
 			guild.PremiumTier = newGuild.PremiumTier;
 			guild.PremiumSubscriptionCount = newGuild.PremiumSubscriptionCount;
 			guild.PremiumProgressBarEnabled = newGuild.PremiumProgressBarEnabled;
 			guild.BannerHash = newGuild.BannerHash;
 			guild.Description = newGuild.Description;
 			guild.VanityUrlCode = newGuild.VanityUrlCode;
 			guild.SystemChannelId = newGuild.SystemChannelId;
 			guild.SystemChannelFlags = newGuild.SystemChannelFlags;
 			guild.DiscoverySplashHash = newGuild.DiscoverySplashHash;
 			guild.MaxMembers = newGuild.MaxMembers;
 			guild.MaxPresences = newGuild.MaxPresences;
 			guild.ApproximateMemberCount = newGuild.ApproximateMemberCount;
 			guild.ApproximatePresenceCount = newGuild.ApproximatePresenceCount;
 			guild.MaxVideoChannelUsers = newGuild.MaxVideoChannelUsers;
 			guild.PreferredLocale = newGuild.PreferredLocale;
 			guild.RulesChannelId = newGuild.RulesChannelId;
 			guild.PublicUpdatesChannelId = newGuild.PublicUpdatesChannelId;
 			guild.ApplicationId = newGuild.ApplicationId;
 
 			// fields not sent for update:
 			// - guild.Channels
 			// - voice states
 			// - guild.JoinedAt = new_guild.JoinedAt;
 			// - guild.Large = new_guild.Large;
 			// - guild.MemberCount = Math.Max(new_guild.MemberCount, guild._members.Count);
 			// - guild.Unavailable = new_guild.Unavailable;
 		}
 
 		/// <summary>
 		/// Populates the message reactions and cache.
 		/// </summary>
 		/// <param name="message">The message.</param>
 		/// <param name="author">The author.</param>
 		/// <param name="member">The member.</param>
 		private void PopulateMessageReactionsAndCache(DiscordMessage message, TransportUser author, TransportMember member)
 		{
 			var guild = message.Channel?.Guild ?? this.InternalGetCachedGuild(message.GuildId);
 
 			this.UpdateMessage(message, author, guild, member);
 
 			if (message.ReactionsInternal == null)
 				message.ReactionsInternal = new List<DiscordReaction>();
 			foreach (var xr in message.ReactionsInternal)
 				xr.Emoji.Discord = this;
 
 			if (this.Configuration.MessageCacheSize > 0 && message.Channel != null)
 				this.MessageCache?.Add(message);
 		}
 
 
 		#endregion
 
 		#region Disposal
 
 		~DiscordClient()
 		{
 			this.Dispose();
 		}
 
 		/// <summary>
 		/// Whether the client is disposed.
 		/// </summary>
 
 		private bool _disposed;
 
 		/// <summary>
 		/// Disposes the client.
 		/// </summary>
 		public override void Dispose()
 		{
 			if (this._disposed)
 				return;
 
 			this._disposed = true;
 			GC.SuppressFinalize(this);
 
 			this.DisconnectAsync().ConfigureAwait(false).GetAwaiter().GetResult();
 			this.ApiClient.Rest.Dispose();
 			this.CurrentUser = null;
 
 			var extensions = this._extensions; // prevent _extensions being modified during dispose
 			this._extensions = null;
 			foreach (var extension in extensions)
 				if (extension is IDisposable disposable)
 					disposable.Dispose();
 
 			try
 			{
 				this._cancelTokenSource?.Cancel();
 				this._cancelTokenSource?.Dispose();
 			}
 			catch { }
 
 			this.GuildsInternal = null;
 			this._heartbeatTask = null;
 		}
 
 		#endregion
 	}
 }
diff --git a/DisCatSharp/Net/Rest/DiscordApiClient.cs b/DisCatSharp/Net/Rest/DiscordApiClient.cs
index fb7399078..d8b1a3d01 100644
--- a/DisCatSharp/Net/Rest/DiscordApiClient.cs
+++ b/DisCatSharp/Net/Rest/DiscordApiClient.cs
@@ -1,5397 +1,5408 @@
 // 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.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Text;
 using System.Threading.Tasks;
+using System.Xml.Linq;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Serialization;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Net
 {
 	/// <summary>
 	/// Represents a discord api client.
 	/// </summary>
 	public sealed class DiscordApiClient
 	{
 		/// <summary>
 		/// The audit log reason header name.
 		/// </summary>
 		private const string REASON_HEADER_NAME = "X-Audit-Log-Reason";
 
 		/// <summary>
 		/// Gets the discord client.
 		/// </summary>
 		internal BaseDiscordClient Discord { get; }
 		/// <summary>
 		/// Gets the rest client.
 		/// </summary>
 		internal RestClient Rest { get; }
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordApiClient"/> class.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		internal DiscordApiClient(BaseDiscordClient client)
 		{
 			this.Discord = client;
 			this.Rest = new RestClient(client);
 		}
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="DiscordApiClient"/> class.
 		/// </summary>
 		/// <param name="proxy">The proxy.</param>
 		/// <param name="timeout">The timeout.</param>
 		/// <param name="useRelativeRateLimit">If true, use relative rate limit.</param>
 		/// <param name="logger">The logger.</param>
 		internal DiscordApiClient(IWebProxy proxy, TimeSpan timeout, bool useRelativeRateLimit, ILogger logger) // This is for meta-clients, such as the webhook client
 		{
 			this.Rest = new RestClient(proxy, timeout, useRelativeRateLimit, logger);
 		}
 
 		/// <summary>
 		/// Builds the query string.
 		/// </summary>
 		/// <param name="values">The values.</param>
 		/// <param name="post">Whether this query will be transmitted via POST.</param>
 		private static string BuildQueryString(IDictionary<string, string> values, bool post = false)
 		{
 			if (values == null || values.Count == 0)
 				return string.Empty;
 
 			var valsCollection = values.Select(xkvp =>
 				$"{WebUtility.UrlEncode(xkvp.Key)}={WebUtility.UrlEncode(xkvp.Value)}");
 			var vals = string.Join("&", valsCollection);
 
 			return !post ? $"?{vals}" : vals;
 		}
 
 		/// <summary>
 		/// Prepares the message.
 		/// </summary>
 		/// <param name="msgRaw">The msg_raw.</param>
 		/// <returns>A DiscordMessage.</returns>
 		private DiscordMessage PrepareMessage(JToken msgRaw)
 		{
 			var author = msgRaw["author"].ToObject<TransportUser>();
 			var ret = msgRaw.ToDiscordObject<DiscordMessage>();
 			ret.Discord = this.Discord;
 
 			this.PopulateMessage(author, ret);
 
 			var referencedMsg = msgRaw["referenced_message"];
 			if (ret.MessageType == MessageType.Reply && !string.IsNullOrWhiteSpace(referencedMsg?.ToString()))
 			{
 				author = referencedMsg["author"].ToObject<TransportUser>();
 				ret.ReferencedMessage.Discord = this.Discord;
 				this.PopulateMessage(author, ret.ReferencedMessage);
 			}
 
 			if (ret.Channel != null)
 				return ret;
 
 			var channel = !ret.GuildId.HasValue
 				? new DiscordDmChannel
 				{
 					Id = ret.ChannelId,
 					Discord = this.Discord,
 					Type = ChannelType.Private
 				}
 				: new DiscordChannel
 				{
 					Id = ret.ChannelId,
 					GuildId = ret.GuildId,
 					Discord = this.Discord
 				};
 
 			ret.Channel = channel;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Populates the message.
 		/// </summary>
 		/// <param name="author">The author.</param>
 		/// <param name="ret">The message.</param>
 		private void PopulateMessage(TransportUser author, DiscordMessage ret)
 		{
 			var guild = ret.Channel?.Guild;
 
 			//If this is a webhook, it shouldn't be in the user cache.
 			if (author.IsBot && int.Parse(author.Discriminator) == 0)
 			{
 				ret.Author = new DiscordUser(author) { Discord = this.Discord };
 			}
 			else
 			{
 				if (!this.Discord.UserCache.TryGetValue(author.Id, out var usr))
 				{
 					this.Discord.UserCache[author.Id] = usr = new DiscordUser(author) { Discord = this.Discord };
 				}
 
 				if (guild != null)
 				{
 					if (!guild.Members.TryGetValue(author.Id, out var mbr))
 						mbr = new DiscordMember(usr) { Discord = this.Discord, GuildId = guild.Id };
 					ret.Author = mbr;
 				}
 				else
 				{
 					ret.Author = usr;
 				}
 			}
 
 			ret.PopulateMentions();
 
 			if (ret.ReactionsInternal == null)
 				ret.ReactionsInternal = new List<DiscordReaction>();
 			foreach (var xr in ret.ReactionsInternal)
 				xr.Emoji.Discord = this.Discord;
 		}
 
 		/// <summary>
 		/// Executes a rest request.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="bucket">The bucket.</param>
 		/// <param name="url">The url.</param>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <param name="headers">The headers.</param>
 		/// <param name="payload">The payload.</param>
 		/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 		internal Task<RestResponse> DoRequestAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null, string payload = null, double? ratelimitWaitOverride = null)
 		{
 			var req = new RestRequest(client, bucket, url, method, route, headers, payload, ratelimitWaitOverride);
 
 			if (this.Discord != null)
 				this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 			else
 				_ = this.Rest.ExecuteRequestAsync(req);
 
 			return req.WaitForCompletionAsync();
 		}
 
 		/// <summary>
 		/// Executes a multipart rest request for stickers.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="bucket">The bucket.</param>
 		/// <param name="url">The url.</param>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <param name="headers">The headers.</param>
 		/// <param name="file">The file.</param>
 		/// <param name="name">The sticker name.</param>
 		/// <param name="tags">The sticker tag.</param>
 		/// <param name="description">The sticker description.</param>
 		/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 		private Task<RestResponse> DoStickerMultipartAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null,
 			DiscordMessageFile file = null, string name = "", string tags = "", string description = "", double? ratelimitWaitOverride = null)
 		{
 			var req = new MultipartStickerWebRequest(client, bucket, url, method, route, headers, file, name, tags, description, ratelimitWaitOverride);
 
 			if (this.Discord != null)
 				this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 			else
 				_ = this.Rest.ExecuteRequestAsync(req);
 
 			return req.WaitForCompletionAsync();
 		}
 
 		/// <summary>
 		/// Executes a multipart request.
 		/// </summary>
 		/// <param name="client">The client.</param>
 		/// <param name="bucket">The bucket.</param>
 		/// <param name="url">The url.</param>
 		/// <param name="method">The method.</param>
 		/// <param name="route">The route.</param>
 		/// <param name="headers">The headers.</param>
 		/// <param name="values">The values.</param>
 		/// <param name="files">The files.</param>
 		/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 		private Task<RestResponse> DoMultipartAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null, IReadOnlyDictionary<string, string> values = null,
 			IReadOnlyCollection<DiscordMessageFile> files = null, double? ratelimitWaitOverride = null)
 		{
 			var req = new MultipartWebRequest(client, bucket, url, method, route, headers, values, files, ratelimitWaitOverride);
 
 			if (this.Discord != null)
 				this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 			else
 				_ = this.Rest.ExecuteRequestAsync(req);
 
 			return req.WaitForCompletionAsync();
 		}
 
 		#region Guild
 
 		/// <summary>
 		/// Searches the members async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="limit">The limit.</param>
 		internal async Task<IReadOnlyList<DiscordMember>> SearchMembersAsync(ulong guildId, string name, int? limit)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}{Endpoints.SEARCH}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 			var querydict = new Dictionary<string, string>
 			{
 				["query"] = name,
 				["limit"] = limit.ToString()
 			};
 			var url = Utilities.GetApiUriFor(path, BuildQueryString(querydict), this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 			var json = JArray.Parse(res.Response);
 			var tms = json.ToObject<IReadOnlyList<TransportMember>>();
 
 			var mbrs = new List<DiscordMember>();
 			foreach (var xtm in tms)
 			{
 				var usr = new DiscordUser(xtm.User) { Discord = this.Discord };
 
 				this.Discord.UserCache.AddOrUpdate(xtm.User.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discord = usr.Discord;
 					old.AvatarHash = usr.AvatarHash;
 
 					return old;
 				});
 
 				mbrs.Add(new DiscordMember(xtm) { Discord = this.Discord, GuildId = guildId });
 			}
 
 			return mbrs;
 		}
 
 		/// <summary>
 		/// Gets the guild ban async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		internal async Task<DiscordBan> GetGuildBanAsync(ulong guildId, ulong userId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, user_id = userId}, out var path);
 			var uri = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, uri, RestRequestMethod.GET, route).ConfigureAwait(false);
 			var json = JObject.Parse(res.Response);
 
 			var ban = json.ToObject<DiscordBan>();
 
 			return ban;
 		}
 
 		/// <summary>
 		/// Creates the guild async.
 		/// </summary>
 		/// <param name="name">The name.</param>
 		/// <param name="regionId">The region_id.</param>
 		/// <param name="iconb64">The iconb64.</param>
 		/// <param name="verificationLevel">The verification_level.</param>
 		/// <param name="defaultMessageNotifications">The default_message_notifications.</param>
 		/// <param name="systemChannelFlags">The system_channel_flags.</param>
 		internal async Task<DiscordGuild> CreateGuildAsync(string name, string regionId, Optional<string> iconb64, VerificationLevel? verificationLevel,
 			DefaultMessageNotifications? defaultMessageNotifications, SystemChannelFlags? systemChannelFlags)
 		{
 			var pld = new RestGuildCreatePayload
 			{
 				Name = name,
 				RegionId = regionId,
 				DefaultMessageNotifications = defaultMessageNotifications,
 				VerificationLevel = verificationLevel,
 				IconBase64 = iconb64,
 				SystemChannelFlags = systemChannelFlags
 
 			};
 
 			var route = $"{Endpoints.GUILDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawMembers = (JArray)json["members"];
 			var guild = json.ToDiscordObject<DiscordGuild>();
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildCreateEventAsync(guild, rawMembers, null).ConfigureAwait(false);
 			return guild;
 		}
 
 		/// <summary>
 		/// Creates the guild from template async.
 		/// </summary>
 		/// <param name="templateCode">The template_code.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="iconb64">The iconb64.</param>
 		internal async Task<DiscordGuild> CreateGuildFromTemplateAsync(string templateCode, string name, Optional<string> iconb64)
 		{
 			var pld = new RestGuildCreateFromTemplatePayload
 			{
 				Name = name,
 				IconBase64 = iconb64
 			};
 
 			var route = $"{Endpoints.GUILDS}{Endpoints.TEMPLATES}/:template_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {template_code = templateCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawMembers = (JArray)json["members"];
 			var guild = json.ToDiscordObject<DiscordGuild>();
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildCreateEventAsync(guild, rawMembers, null).ConfigureAwait(false);
 			return guild;
 		}
 
 		/// <summary>
 		/// Deletes the guild async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		internal async Task DeleteGuildAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route).ConfigureAwait(false);
 
 			if (this.Discord is DiscordClient dc)
 			{
 				var gld = dc.GuildsInternal[guildId];
 				await dc.OnGuildDeleteEventAsync(gld).ConfigureAwait(false);
 			}
 		}
 
 		/// <summary>
 		/// Modifies the guild.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="verificationLevel">The verification level.</param>
 		/// <param name="defaultMessageNotifications">The default message notifications.</param>
 		/// <param name="mfaLevel">The mfa level.</param>
 		/// <param name="explicitContentFilter">The explicit content filter.</param>
 		/// <param name="afkChannelId">The afk channel id.</param>
 		/// <param name="afkTimeout">The afk timeout.</param>
 		/// <param name="iconb64">The iconb64.</param>
 		/// <param name="ownerId">The owner id.</param>
 		/// <param name="splashb64">The splashb64.</param>
 		/// <param name="systemChannelId">The system channel id.</param>
 		/// <param name="systemChannelFlags">The system channel flags.</param>
 		/// <param name="publicUpdatesChannelId">The public updates channel id.</param>
 		/// <param name="rulesChannelId">The rules channel id.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="bannerb64">The banner base64.</param>
 		/// <param name="discorverySplashb64">The discovery base64.</param>
 		/// <param name="preferredLocale">The preferred locale.</param>
 		/// <param name="premiumProgressBarEnabled">Whether the premium progress bar should be enabled.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordGuild> ModifyGuildAsync(ulong guildId, Optional<string> name, Optional<VerificationLevel> verificationLevel,
 			Optional<DefaultMessageNotifications> defaultMessageNotifications, Optional<MfaLevel> mfaLevel,
 			Optional<ExplicitContentFilter> explicitContentFilter, Optional<ulong?> afkChannelId,
 			Optional<int> afkTimeout, Optional<string> iconb64, Optional<ulong> ownerId, Optional<string> splashb64,
 			Optional<ulong?> systemChannelId, Optional<SystemChannelFlags> systemChannelFlags,
 			Optional<ulong?> publicUpdatesChannelId, Optional<ulong?> rulesChannelId, Optional<string> description,
 			Optional<string> bannerb64, Optional<string> discorverySplashb64, Optional<string> preferredLocale, Optional<bool> premiumProgressBarEnabled, string reason)
 		{
 			var pld = new RestGuildModifyPayload
 			{
 				Name = name,
 				VerificationLevel = verificationLevel,
 				DefaultMessageNotifications = defaultMessageNotifications,
 				MfaLevel = mfaLevel,
 				ExplicitContentFilter = explicitContentFilter,
 				AfkChannelId = afkChannelId,
 				AfkTimeout = afkTimeout,
 				IconBase64 = iconb64,
 				SplashBase64 = splashb64,
 				BannerBase64 = bannerb64,
 				DiscoverySplashBase64 = discorverySplashb64,
 				OwnerId = ownerId,
 				SystemChannelId = systemChannelId,
 				SystemChannelFlags = systemChannelFlags,
 				RulesChannelId = rulesChannelId,
 				PublicUpdatesChannelId = publicUpdatesChannelId,
 				PreferredLocale = preferredLocale,
 				Description = description,
 				PremiumProgressBarEnabled = premiumProgressBarEnabled
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawMembers = (JArray)json["members"];
 			var guild = json.ToDiscordObject<DiscordGuild>();
 			foreach (var r in guild.RolesInternal.Values)
 				r.GuildId = guild.Id;
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildUpdateEventAsync(guild, rawMembers).ConfigureAwait(false);
 			return guild;
 		}
 
 
 
 		/// <summary>
 		/// Modifies the guild community settings.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="features">The guild features.</param>
 		/// <param name="rulesChannelId">The rules channel id.</param>
 		/// <param name="publicUpdatesChannelId">The public updates channel id.</param>
 		/// <param name="preferredLocale">The preferred locale.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="defaultMessageNotifications">The default message notifications.</param>
 		/// <param name="explicitContentFilter">The explicit content filter.</param>
 		/// <param name="verificationLevel">The verification level.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordGuild> ModifyGuildCommunitySettingsAsync(ulong guildId, List<string> features, Optional<ulong?> rulesChannelId, Optional<ulong?> publicUpdatesChannelId, string preferredLocale, string description, DefaultMessageNotifications defaultMessageNotifications, ExplicitContentFilter explicitContentFilter, VerificationLevel verificationLevel, string reason)
 		{
 			var pld = new RestGuildCommunityModifyPayload
 			{
 				VerificationLevel = verificationLevel,
 				DefaultMessageNotifications = defaultMessageNotifications,
 				ExplicitContentFilter = explicitContentFilter,
 				RulesChannelId = rulesChannelId,
 				PublicUpdatesChannelId = publicUpdatesChannelId,
 				PreferredLocale = preferredLocale,
 				Description = description ?? Optional.FromNoValue<string>(),
 				Features = features
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawMembers = (JArray)json["members"];
 			var guild = json.ToDiscordObject<DiscordGuild>();
 			foreach (var r in guild.RolesInternal.Values)
 				r.GuildId = guild.Id;
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildUpdateEventAsync(guild, rawMembers).ConfigureAwait(false);
 			return guild;
 		}
 
 		/// <summary>
 		/// Gets the guild bans async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordBan>> GetGuildBansAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var bansRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordBan>>(res.Response).Select(xb =>
 			{
 				if (!this.Discord.TryGetCachedUserInternal(xb.RawUser.Id, out var usr))
 				{
 					usr = new DiscordUser(xb.RawUser) { Discord = this.Discord };
 					usr = this.Discord.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 					{
 						old.Username = usr.Username;
 						old.Discriminator = usr.Discriminator;
 						old.AvatarHash = usr.AvatarHash;
 						return old;
 					});
 				}
 
 				xb.User = usr;
 				return xb;
 			});
 			var bans = new ReadOnlyCollection<DiscordBan>(new List<DiscordBan>(bansRaw));
 
 			return bans;
 		}
 
 		/// <summary>
 		/// Creates the guild ban async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="deleteMessageDays">The delete_message_days.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task CreateGuildBanAsync(ulong guildId, ulong userId, int deleteMessageDays, string reason)
 		{
 			if (deleteMessageDays < 0 || deleteMessageDays > 7)
 				throw new ArgumentException("Delete message days must be a number between 0 and 7.", nameof(deleteMessageDays));
 
 			var urlparams = new Dictionary<string, string>
 			{
 				["delete_message_days"] = deleteMessageDays.ToString(CultureInfo.InvariantCulture)
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, BuildQueryString(urlparams), this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers);
 		}
 
 		/// <summary>
 		/// Removes the guild ban async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task RemoveGuildBanAsync(ulong guildId, ulong userId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Leaves the guild async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal Task LeaveGuildAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.GUILDS}/:guild_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Adds the guild member async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="accessToken">The access_token.</param>
 		/// <param name="nick">The nick.</param>
 		/// <param name="roles">The roles.</param>
 		/// <param name="muted">If true, muted.</param>
 		/// <param name="deafened">If true, deafened.</param>
 
 		internal async Task<DiscordMember> AddGuildMemberAsync(ulong guildId, ulong userId, string accessToken, string nick, IEnumerable<DiscordRole> roles, bool muted, bool deafened)
 		{
 			var pld = new RestGuildMemberAddPayload
 			{
 				AccessToken = accessToken,
 				Nickname = nick ?? "",
 				Roles = roles ?? new List<DiscordRole>(),
 				Deaf = deafened,
 				Mute = muted
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var tm = JsonConvert.DeserializeObject<TransportMember>(res.Response);
 
 			return new DiscordMember(tm) { Discord = this.Discord, GuildId = guildId };
 		}
 
 		/// <summary>
 		/// Lists the guild members async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="limit">The limit.</param>
 		/// <param name="after">The after.</param>
 
 		internal async Task<IReadOnlyList<TransportMember>> ListGuildMembersAsync(ulong guildId, int? limit, ulong? after)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (limit != null && limit > 0)
 				urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 			if (after != null)
 				urlparams["after"] = after.Value.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var membersRaw = JsonConvert.DeserializeObject<List<TransportMember>>(res.Response);
 			return new ReadOnlyCollection<TransportMember>(membersRaw);
 		}
 
 		/// <summary>
 		/// Adds the guild member role async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="roleId">The role_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task AddGuildMemberRoleAsync(ulong guildId, ulong userId, ulong roleId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id{Endpoints.ROLES}/:role_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, user_id = userId, role_id = roleId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers);
 		}
 
 		/// <summary>
 		/// Removes the guild member role async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="roleId">The role_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task RemoveGuildMemberRoleAsync(ulong guildId, ulong userId, ulong roleId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id{Endpoints.ROLES}/:role_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, user_id = userId, role_id = roleId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Modifies the guild channel position async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="pld">The pld.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task ModifyGuildChannelPositionAsync(ulong guildId, IEnumerable<RestGuildChannelReorderPayload> pld, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Modifies the guild channel parent async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="pld">The pld.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task ModifyGuildChannelParentAsync(ulong guildId, IEnumerable<RestGuildChannelNewParentPayload> pld, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Detaches the guild channel parent async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="pld">The pld.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DetachGuildChannelParentAsync(ulong guildId, IEnumerable<RestGuildChannelNoParentPayload> pld, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Modifies the guild role position async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="pld">The pld.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task ModifyGuildRolePositionAsync(ulong guildId, IEnumerable<RestGuildRoleReorderPayload> pld, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Gets the audit logs async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="limit">The limit.</param>
 		/// <param name="after">The after.</param>
 		/// <param name="before">The before.</param>
 		/// <param name="responsible">The responsible.</param>
 		/// <param name="actionType">The action_type.</param>
 
 		internal async Task<AuditLog> GetAuditLogsAsync(ulong guildId, int limit, ulong? after, ulong? before, ulong? responsible, int? actionType)
 		{
 			var urlparams = new Dictionary<string, string>
 			{
 				["limit"] = limit.ToString(CultureInfo.InvariantCulture)
 			};
 			if (after != null)
 				urlparams["after"] = after?.ToString(CultureInfo.InvariantCulture);
 			if (before != null)
 				urlparams["before"] = before?.ToString(CultureInfo.InvariantCulture);
 			if (responsible != null)
 				urlparams["user_id"] = responsible?.ToString(CultureInfo.InvariantCulture);
 			if (actionType != null)
 				urlparams["action_type"] = actionType?.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.AUDIT_LOGS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var auditLogDataRaw = JsonConvert.DeserializeObject<AuditLog>(res.Response);
 
 			return auditLogDataRaw;
 		}
 
 		/// <summary>
 		/// Gets the guild vanity url async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<DiscordInvite> GetGuildVanityUrlAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VANITY_URL}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var invite = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 
 			return invite;
 		}
 
 		/// <summary>
 		/// Gets the guild widget async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<DiscordWidget> GetGuildWidgetAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET_JSON}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawChannels = (JArray)json["channels"];
 
 			var ret = json.ToDiscordObject<DiscordWidget>();
 			ret.Discord = this.Discord;
 			ret.Guild = this.Discord.Guilds[guildId];
 
 			ret.Channels = ret.Guild == null
 				? rawChannels.Select(r => new DiscordChannel
 				{
 					Id = (ulong)r["id"],
 					Name = r["name"].ToString(),
 					Position = (int)r["position"]
 				}).ToList()
 				: rawChannels.Select(r =>
 				{
 					var c = ret.Guild.GetChannel((ulong)r["id"]);
 					c.Position = (int)r["position"];
 					return c;
 				}).ToList();
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the guild widget settings async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<DiscordWidgetSettings> GetGuildWidgetSettingsAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWidgetSettings>(res.Response);
 			ret.Guild = this.Discord.Guilds[guildId];
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the guild widget settings async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="isEnabled">If true, is enabled.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<DiscordWidgetSettings> ModifyGuildWidgetSettingsAsync(ulong guildId, bool? isEnabled, ulong? channelId, string reason)
 		{
 			var pld = new RestGuildWidgetSettingsPayload
 			{
 				Enabled = isEnabled,
 				ChannelId = channelId
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWidgetSettings>(res.Response);
 			ret.Guild = this.Discord.Guilds[guildId];
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the guild templates async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordGuildTemplate>> GetGuildTemplatesAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var templatesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildTemplate>>(res.Response);
 
 			return new ReadOnlyCollection<DiscordGuildTemplate>(new List<DiscordGuildTemplate>(templatesRaw));
 		}
 
 		/// <summary>
 		/// Creates the guild template async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 
 		internal async Task<DiscordGuildTemplate> CreateGuildTemplateAsync(ulong guildId, string name, string description)
 		{
 			var pld = new RestGuildTemplateCreateOrModifyPayload
 			{
 				Name = name,
 				Description = description
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Syncs the guild template async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="templateCode">The template_code.</param>
 
 		internal async Task<DiscordGuildTemplate> SyncGuildTemplateAsync(ulong guildId, string templateCode)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, template_code = templateCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route).ConfigureAwait(false);
 
 			var templateRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 			return templateRaw;
 		}
 
 		/// <summary>
 		/// Modifies the guild template async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="templateCode">The template_code.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 
 		internal async Task<DiscordGuildTemplate> ModifyGuildTemplateAsync(ulong guildId, string templateCode, string name, string description)
 		{
 			var pld = new RestGuildTemplateCreateOrModifyPayload
 			{
 				Name = name,
 				Description = description
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, template_code = templateCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var templateRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 			return templateRaw;
 		}
 
 		/// <summary>
 		/// Deletes the guild template async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="templateCode">The template_code.</param>
 
 		internal async Task<DiscordGuildTemplate> DeleteGuildTemplateAsync(ulong guildId, string templateCode)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, template_code = templateCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route).ConfigureAwait(false);
 
 			var templateRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 			return templateRaw;
 		}
 
 		/// <summary>
 		/// Gets the guild membership screening form async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<DiscordGuildMembershipScreening> GetGuildMembershipScreeningFormAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBER_VERIFICATION}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var screeningRaw = JsonConvert.DeserializeObject<DiscordGuildMembershipScreening>(res.Response);
 
 			return screeningRaw;
 		}
 
 		/// <summary>
 		/// Modifies the guild membership screening form async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="enabled">The enabled.</param>
 		/// <param name="fields">The fields.</param>
 		/// <param name="description">The description.</param>
 
 		internal async Task<DiscordGuildMembershipScreening> ModifyGuildMembershipScreeningFormAsync(ulong guildId, Optional<bool> enabled, Optional<DiscordGuildMembershipScreeningField[]> fields, Optional<string> description)
 		{
 			var pld = new RestGuildMembershipScreeningFormModifyPayload
 			{
 				Enabled = enabled,
 				Description = description,
 				Fields = fields
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBER_VERIFICATION}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var screeningRaw = JsonConvert.DeserializeObject<DiscordGuildMembershipScreening>(res.Response);
 
 			return screeningRaw;
 		}
 
 		/// <summary>
 		/// Gets the guild welcome screen async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<DiscordGuildWelcomeScreen> GetGuildWelcomeScreenAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WELCOME_SCREEN}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildWelcomeScreen>(res.Response);
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the guild welcome screen async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="enabled">The enabled.</param>
 		/// <param name="welcomeChannels">The welcome channels.</param>
 		/// <param name="description">The description.</param>
 
 		internal async Task<DiscordGuildWelcomeScreen> ModifyGuildWelcomeScreenAsync(ulong guildId, Optional<bool> enabled, Optional<IEnumerable<DiscordGuildWelcomeScreenChannel>> welcomeChannels, Optional<string> description)
 		{
 			var pld = new RestGuildWelcomeScreenModifyPayload
 			{
 				Enabled = enabled,
 				WelcomeChannels = welcomeChannels,
 				Description = description
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WELCOME_SCREEN}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildWelcomeScreen>(res.Response);
 			return ret;
 		}
 
 		/// <summary>
 		/// Updates the current user voice state async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="suppress">If true, suppress.</param>
 		/// <param name="requestToSpeakTimestamp">The request to speak timestamp.</param>
 
 		internal async Task UpdateCurrentUserVoiceStateAsync(ulong guildId, ulong channelId, bool? suppress, DateTimeOffset? requestToSpeakTimestamp)
 		{
 			var pld = new RestGuildUpdateCurrentUserVoiceStatePayload
 			{
 				ChannelId = channelId,
 				Suppress = suppress,
 				RequestToSpeakTimestamp = requestToSpeakTimestamp
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VOICE_STATES}/@me";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Updates the user voice state async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="suppress">If true, suppress.</param>
 
 		internal async Task UpdateUserVoiceStateAsync(ulong guildId, ulong userId, ulong channelId, bool? suppress)
 		{
 			var pld = new RestGuildUpdateUserVoiceStatePayload
 			{
 				ChannelId = channelId,
 				Suppress = suppress
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VOICE_STATES}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 		}
 		#endregion
 
 		#region Guild Scheduled Events
 
 		/// <summary>
 		/// Creates a scheduled event.
 		/// </summary>
 		internal async Task<DiscordScheduledEvent> CreateGuildScheduledEventAsync(ulong guildId, ulong? channelId, DiscordScheduledEventEntityMetadata metadata, string name, DateTimeOffset scheduledStartTime, DateTimeOffset? scheduledEndTime, string description, ScheduledEventEntityType type, Optional<string> coverb64, string reason = null)
 		{
 			var pld = new RestGuildScheduledEventCreatePayload
 			{
 				ChannelId = channelId,
 				EntityMetadata = metadata,
 				Name = name,
 				ScheduledStartTime = scheduledStartTime,
 				ScheduledEndTime = scheduledEndTime,
 				Description = description,
 				EntityType = type,
 				CoverBase64 = coverb64
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
 			var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 			var guild = this.Discord.Guilds[guildId];
 
 			scheduledEvent.Discord = this.Discord;
 
 			if (scheduledEvent.Creator != null)
 				scheduledEvent.Creator.Discord = this.Discord;
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildScheduledEventCreateEventAsync(scheduledEvent, guild);
 
 			return scheduledEvent;
 		}
 
 		/// <summary>
 		/// Modifies a scheduled event.
 		/// </summary>
 		internal async Task<DiscordScheduledEvent> ModifyGuildScheduledEventAsync(ulong guildId, ulong scheduledEventId, Optional<ulong?> channelId, Optional<DiscordScheduledEventEntityMetadata> metadata, Optional<string> name, Optional<DateTimeOffset> scheduledStartTime, Optional<DateTimeOffset> scheduledEndTime, Optional<string> description, Optional<ScheduledEventEntityType> type, Optional<ScheduledEventStatus> status, Optional<string> coverb64, string reason = null)
 		{
 			var pld = new RestGuildSheduledEventModifyPayload
 			{
 				ChannelId = channelId,
 				EntityMetadata = metadata,
 				Name = name,
 				ScheduledStartTime = scheduledStartTime,
 				ScheduledEndTime = scheduledEndTime,
 				Description = description,
 				EntityType = type,
 				Status = status,
 				CoverBase64 = coverb64
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 
 			var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 			var guild = this.Discord.Guilds[guildId];
 
 			scheduledEvent.Discord = this.Discord;
 
 			if (scheduledEvent.Creator != null)
 			{
 				scheduledEvent.Creator.Discord = this.Discord;
 				this.Discord.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 				{
 					old.Username = scheduledEvent.Creator.Username;
 					old.Discriminator = scheduledEvent.Creator.Discriminator;
 					old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 					old.Flags = scheduledEvent.Creator.Flags;
 					return old;
 				});
 			}
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildScheduledEventUpdateEventAsync(scheduledEvent, guild);
 
 			return scheduledEvent;
 		}
 
 		/// <summary>
 		/// Modifies a scheduled event.
 		/// </summary>
 		internal async Task<DiscordScheduledEvent> ModifyGuildScheduledEventStatusAsync(ulong guildId, ulong scheduledEventId, ScheduledEventStatus status, string reason = null)
 		{
 			var pld = new RestGuildSheduledEventModifyPayload
 			{
 				Status = status
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 
 			var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 			var guild = this.Discord.Guilds[guildId];
 
 			scheduledEvent.Discord = this.Discord;
 
 			if (scheduledEvent.Creator != null)
 			{
 				scheduledEvent.Creator.Discord = this.Discord;
 				this.Discord.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 				{
 					old.Username = scheduledEvent.Creator.Username;
 					old.Discriminator = scheduledEvent.Creator.Discriminator;
 					old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 					old.Flags = scheduledEvent.Creator.Flags;
 					return old;
 				});
 			}
 
 			if (this.Discord is DiscordClient dc)
 				await dc.OnGuildScheduledEventUpdateEventAsync(scheduledEvent, guild);
 
 			return scheduledEvent;
 		}
 
 		/// <summary>
 		/// Gets a scheduled event.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="scheduledEventId">The event id.</param>
 		/// <param name="withUserCount">Whether to include user count.</param>
 		internal async Task<DiscordScheduledEvent> GetGuildScheduledEventAsync(ulong guildId, ulong scheduledEventId, bool? withUserCount)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (withUserCount.HasValue)
 				urlparams["with_user_count"] = withUserCount?.ToString();
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 			var guild = this.Discord.Guilds[guildId];
 
 			scheduledEvent.Discord = this.Discord;
 
 			if (scheduledEvent.Creator != null)
 			{
 				scheduledEvent.Creator.Discord = this.Discord;
 				this.Discord.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 				{
 					old.Username = scheduledEvent.Creator.Username;
 					old.Discriminator = scheduledEvent.Creator.Discriminator;
 					old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 					old.Flags = scheduledEvent.Creator.Flags;
 					return old;
 				});
 			}
 
 			return scheduledEvent;
 		}
 
 		/// <summary>
 		/// Gets the guilds scheduled events.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="withUserCount">Whether to include the count of users subscribed to the scheduled event.</param>
 		internal async Task<IReadOnlyDictionary<ulong, DiscordScheduledEvent>> ListGuildScheduledEventsAsync(ulong guildId, bool? withUserCount)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (withUserCount.HasValue)
 				urlparams["with_user_count"] = withUserCount?.ToString();
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var events = new Dictionary<ulong, DiscordScheduledEvent>();
 			var eventsRaw = JsonConvert.DeserializeObject<List<DiscordScheduledEvent>>(res.Response);
 			var guild = this.Discord.Guilds[guildId];
 
 			foreach (var ev in eventsRaw)
 			{
 				ev.Discord = this.Discord;
 				if (ev.Creator != null)
 				{
 					ev.Creator.Discord = this.Discord;
 					this.Discord.UserCache.AddOrUpdate(ev.Creator.Id, ev.Creator, (id, old) =>
 					{
 						old.Username = ev.Creator.Username;
 						old.Discriminator = ev.Creator.Discriminator;
 						old.AvatarHash = ev.Creator.AvatarHash;
 						old.Flags = ev.Creator.Flags;
 						return old;
 					});
 				}
 
 				events.Add(ev.Id, ev);
 			}
 
 			return new ReadOnlyDictionary<ulong, DiscordScheduledEvent>(new Dictionary<ulong, DiscordScheduledEvent>(events));
 		}
 
 		/// <summary>
 		/// Deletes a guild sheduled event.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="scheduledEventId">The sheduled event id.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task DeleteGuildScheduledEventAsync(ulong guildId, ulong scheduledEventId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Gets the users who RSVP'd to a sheduled event.
 		/// Optional with member objects.
 		/// This endpoint is paginated.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="scheduledEventId">The sheduled event id.</param>
 		/// <param name="limit">The limit how many users to receive from the event.</param>
 		/// <param name="before">Get results before the given id.</param>
 		/// <param name="after">Get results after the given id.</param>
 		/// <param name="withMember">Wether to include guild member data. attaches guild_member property to the user object.</param>
 		internal async Task<IReadOnlyDictionary<ulong, DiscordScheduledEventUser>> GetGuildScheduledEventRspvUsersAsync(ulong guildId, ulong scheduledEventId, int? limit, ulong? before, ulong? after, bool? withMember)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (limit != null && limit > 0)
 				urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 			if (before != null)
 				urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 			if (after != null)
 				urlparams["after"] = after.Value.ToString(CultureInfo.InvariantCulture);
 			if (withMember != null)
 				urlparams["with_member"] = withMember.Value.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id{Endpoints.USERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var rspvUsers = JsonConvert.DeserializeObject<IEnumerable<DiscordScheduledEventUser>>(res.Response);
 			Dictionary<ulong, DiscordScheduledEventUser> rspv = new();
 
 			foreach (var rspvUser in rspvUsers)
 			{
 
 				rspvUser.Discord = this.Discord;
 				rspvUser.GuildId = guildId;
 
 				rspvUser.User.Discord = this.Discord;
 				rspvUser.User = this.Discord.UserCache.AddOrUpdate(rspvUser.User.Id, rspvUser.User, (id, old) =>
 				{
 					old.Username = rspvUser.User.Username;
 					old.Discriminator = rspvUser.User.Discriminator;
 					old.AvatarHash = rspvUser.User.AvatarHash;
 					old.BannerHash = rspvUser.User.BannerHash;
 					old.BannerColorInternal = rspvUser.User.BannerColorInternal;
 					return old;
 				});
 
 				/*if (with_member.HasValue && with_member.Value && rspv_user.Member != null)
                 {
                     rspv_user.Member.Discord = this.Discord;
                 }*/
 
 				rspv.Add(rspvUser.User.Id, rspvUser);
 			}
 
 			return new ReadOnlyDictionary<ulong, DiscordScheduledEventUser>(new Dictionary<ulong, DiscordScheduledEventUser>(rspv));
 		}
 		#endregion
 
 		#region Channel
 		/// <summary>
 		/// Creates the guild channel async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="parent">The parent.</param>
 		/// <param name="topic">The topic.</param>
 		/// <param name="bitrate">The bitrate.</param>
 		/// <param name="userLimit">The user_limit.</param>
 		/// <param name="overwrites">The overwrites.</param>
 		/// <param name="nsfw">If true, nsfw.</param>
 		/// <param name="perUserRateLimit">The per user rate limit.</param>
 		/// <param name="qualityMode">The quality mode.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<DiscordChannel> CreateGuildChannelAsync(ulong guildId, string name, ChannelType type, ulong? parent, Optional<string> topic, int? bitrate, int? userLimit, IEnumerable<DiscordOverwriteBuilder> overwrites, bool? nsfw, Optional<int?> perUserRateLimit, VideoQualityMode? qualityMode, string reason)
 		{
 			var restoverwrites = new List<DiscordRestOverwrite>();
 			if (overwrites != null)
 				foreach (var ow in overwrites)
 					restoverwrites.Add(ow.Build());
 
 			var pld = new RestChannelCreatePayload
 			{
 				Name = name,
 				Type = type,
 				Parent = parent,
 				Topic = topic,
 				Bitrate = bitrate,
 				UserLimit = userLimit,
 				PermissionOverwrites = restoverwrites,
 				Nsfw = nsfw,
 				PerUserRateLimit = perUserRateLimit,
 				QualityMode = qualityMode
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
 			ret.Discord = this.Discord;
 			foreach (var xo in ret.PermissionOverwritesInternal)
 			{
 				xo.Discord = this.Discord;
 				xo.ChannelId = ret.Id;
 			}
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the channel async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="position">The position.</param>
 		/// <param name="topic">The topic.</param>
 		/// <param name="nsfw">If true, nsfw.</param>
 		/// <param name="parent">The parent.</param>
 		/// <param name="bitrate">The bitrate.</param>
 		/// <param name="userLimit">The user_limit.</param>
 		/// <param name="perUserRateLimit">The per user rate limit.</param>
 		/// <param name="rtcRegion">The rtc region.</param>
 		/// <param name="qualityMode">The quality mode.</param>
 		/// <param name="autoArchiveDuration">The default auto archive duration.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="permissionOverwrites">The permission overwrites.</param>
 		/// <param name="bannerb64">The banner.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task ModifyChannelAsync(ulong channelId, string name, int? position, Optional<string> topic, bool? nsfw, Optional<ulong?> parent, int? bitrate, int? userLimit, Optional<int?> perUserRateLimit, Optional<string> rtcRegion, VideoQualityMode? qualityMode, ThreadAutoArchiveDuration? autoArchiveDuration, Optional<ChannelType> type, IEnumerable<DiscordOverwriteBuilder> permissionOverwrites, Optional<string> bannerb64, string reason)
 		{
 
 			List<DiscordRestOverwrite> restoverwrites = null;
 			if (permissionOverwrites != null)
 			{
 				restoverwrites = new List<DiscordRestOverwrite>();
 				foreach (var ow in permissionOverwrites)
 					restoverwrites.Add(ow.Build());
 			}
 
 			var pld = new RestChannelModifyPayload
 			{
 				Name = name,
 				Position = position,
 				Topic = topic,
 				Nsfw = nsfw,
 				Parent = parent,
 				Bitrate = bitrate,
 				UserLimit = userLimit,
 				PerUserRateLimit = perUserRateLimit,
 				RtcRegion = rtcRegion,
 				QualityMode = qualityMode,
 				DefaultAutoArchiveDuration = autoArchiveDuration,
 				Type = type,
 				PermissionOverwrites = restoverwrites,
 				BannerBase64 = bannerb64
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Gets the channel async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 
 		internal async Task<DiscordChannel> GetChannelAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
 			ret.Discord = this.Discord;
 			foreach (var xo in ret.PermissionOverwritesInternal)
 			{
 				xo.Discord = this.Discord;
 				xo.ChannelId = ret.Id;
 			}
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the channel async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DeleteChannelAsync(ulong channelId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Gets the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 
 		internal async Task<DiscordMessage> GetMessageAsync(ulong channelId, ulong messageId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Creates the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="content">The content.</param>
 		/// <param name="embeds">The embeds.</param>
 		/// <param name="sticker">The sticker.</param>
 		/// <param name="replyMessageId">The reply message id.</param>
 		/// <param name="mentionReply">If true, mention reply.</param>
 		/// <param name="failOnInvalidReply">If true, fail on invalid reply.</param>
 
 		internal async Task<DiscordMessage> CreateMessageAsync(ulong channelId, string content, IEnumerable<DiscordEmbed> embeds, DiscordSticker sticker, ulong? replyMessageId, bool mentionReply, bool failOnInvalidReply)
 		{
 			if (content != null && content.Length > 2000)
 				throw new ArgumentException("Message content length cannot exceed 2000 characters.");
 
 			if (!embeds?.Any() ?? true)
 			{
 				if (content == null && sticker == null)
 					throw new ArgumentException("You must specify message content, a sticker or an embed.");
 				if (content.Length == 0)
 					throw new ArgumentException("Message content must not be empty.");
 			}
 
 			if (embeds != null)
 				foreach (var embed in embeds)
 					if (embed.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			var pld = new RestChannelMessageCreatePayload
 			{
 				HasContent = content != null,
 				Content = content,
 				StickersIds = sticker is null ? Array.Empty<ulong>() : new[] {sticker.Id},
 				IsTts = false,
 				HasEmbed = embeds?.Any() ?? false,
 				Embeds = embeds
 			};
 
 			if (replyMessageId != null)
 				pld.MessageReference = new InternalDiscordMessageReference { MessageId = replyMessageId, FailIfNotExists = failOnInvalidReply };
 
 			if (replyMessageId != null)
 				pld.Mentions = new DiscordMentions(Mentions.All, true, mentionReply);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Creates the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="builder">The builder.</param>
 
 		internal async Task<DiscordMessage> CreateMessageAsync(ulong channelId, DiscordMessageBuilder builder)
 		{
 			builder.Validate();
 
 			if (builder.Embeds != null)
 				foreach (var embed in builder.Embeds)
 					if (embed?.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			var pld = new RestChannelMessageCreatePayload
 			{
 				HasContent = builder.Content != null,
 				Content = builder.Content,
 				StickersIds = builder.Sticker is null ? Array.Empty<ulong>() : new[] {builder.Sticker.Id},
 				IsTts = builder.IsTts,
 				HasEmbed = builder.Embeds != null,
 				Embeds = builder.Embeds,
 				Components = builder.Components
 			};
 
 			if (builder.ReplyId != null)
 				pld.MessageReference = new InternalDiscordMessageReference { MessageId = builder.ReplyId, FailIfNotExists = builder.FailOnInvalidReply };
 
 			pld.Mentions = new DiscordMentions(builder.Mentions ?? Mentions.All, builder.Mentions?.Any() ?? false, builder.MentionOnReply);
 
 			if (builder.Files.Count == 0)
 			{
 				var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 				var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 				var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 				var ret = this.PrepareMessage(JObject.Parse(res.Response));
 				return ret;
 			}
 			else
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachments = new(builder.Files.Count);
 				foreach (var file in builder.Files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName
 					};
 					attachments.Add(att);
 					fileId++;
 				}
 				pld.Attachments = attachments;
 
 				var values = new Dictionary<string, string>
 				{
 					["payload_json"] = DiscordJson.SerializeObject(pld)
 				};
 
 				var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 				var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 				var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 
 				var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 				foreach (var file in builder.FilesInternal.Where(x => x.ResetPositionTo.HasValue))
 				{
 					file.Stream.Position = file.ResetPositionTo.Value;
 				}
 
 				return ret;
 			}
 		}
 
 		/// <summary>
 		/// Gets the guild channels async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordChannel>> GetGuildChannelsAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var channelsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordChannel>>(res.Response).Select(xc => { xc.Discord = this.Discord; return xc; });
 
 			foreach (var ret in channelsRaw)
 				foreach (var xo in ret.PermissionOverwritesInternal)
 				{
 					xo.Discord = this.Discord;
 					xo.ChannelId = ret.Id;
 				}
 
 			return new ReadOnlyCollection<DiscordChannel>(new List<DiscordChannel>(channelsRaw));
 		}
 
 		/// <summary>
 		/// Creates the stage instance async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="topic">The topic.</param>
 		/// <param name="sendStartNotification">Whether everyone should be notified about the stage.</param>
 		/// <param name="privacyLevel">The privacy_level.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordStageInstance> CreateStageInstanceAsync(ulong channelId, string topic, bool sendStartNotification, StagePrivacyLevel privacyLevel, string reason)
 		{
 			var pld = new RestStageInstanceCreatePayload
 			{
 				ChannelId = channelId,
 				Topic = topic,
 				PrivacyLevel = privacyLevel,
 				SendStartNotification = sendStartNotification
 			};
 
 			var route = $"{Endpoints.STAGE_INSTANCES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var stageInstance = JsonConvert.DeserializeObject<DiscordStageInstance>(res.Response);
 
 			return stageInstance;
 		}
 
 		/// <summary>
 		/// Gets the stage instance async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		internal async Task<DiscordStageInstance> GetStageInstanceAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var stageInstance = JsonConvert.DeserializeObject<DiscordStageInstance>(res.Response);
 
 			return stageInstance;
 		}
 
 		/// <summary>
 		/// Modifies the stage instance async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="topic">The topic.</param>
 		/// <param name="privacyLevel">The privacy_level.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task ModifyStageInstanceAsync(ulong channelId, Optional<string> topic, Optional<StagePrivacyLevel> privacyLevel, string reason)
 		{
 			var pld = new RestStageInstanceModifyPayload
 			{
 				Topic = topic,
 				PrivacyLevel = privacyLevel
 			};
 
 			var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId }, out var path);
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Deletes the stage instance async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="reason">The reason.</param>
 		internal Task DeleteStageInstanceAsync(ulong channelId, string reason)
 		{
 			var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId }, out var path);
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Gets the channel messages async.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="limit">The limit.</param>
 		/// <param name="before">The before.</param>
 		/// <param name="after">The after.</param>
 		/// <param name="around">The around.</param>
 
 		internal async Task<IReadOnlyList<DiscordMessage>> GetChannelMessagesAsync(ulong channelId, int limit, ulong? before, ulong? after, ulong? around)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (around != null)
 				urlparams["around"] = around?.ToString(CultureInfo.InvariantCulture);
 			if (before != null)
 				urlparams["before"] = before?.ToString(CultureInfo.InvariantCulture);
 			if (after != null)
 				urlparams["after"] = after?.ToString(CultureInfo.InvariantCulture);
 			if (limit > 0)
 				urlparams["limit"] = limit.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var msgsRaw = JArray.Parse(res.Response);
 			var msgs = new List<DiscordMessage>();
 			foreach (var xj in msgsRaw)
 				msgs.Add(this.PrepareMessage(xj));
 
 			return new ReadOnlyCollection<DiscordMessage>(new List<DiscordMessage>(msgs));
 		}
 
 		/// <summary>
 		/// Gets the channel message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 
 		internal async Task<DiscordMessage> GetChannelMessageAsync(ulong channelId, ulong messageId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Edits the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="content">The content.</param>
 		/// <param name="embeds">The embeds.</param>
 		/// <param name="mentions">The mentions.</param>
 		/// <param name="components">The components.</param>
 		/// <param name="suppressEmbed">The suppress_embed.</param>
 		/// <param name="files">The files.</param>
 		/// <param name="attachments">The attachments to keep.</param>
 
 		internal async Task<DiscordMessage> EditMessageAsync(ulong channelId, ulong messageId, Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds, IEnumerable<IMention> mentions, IReadOnlyList<DiscordActionRowComponent> components, Optional<bool> suppressEmbed, IReadOnlyCollection<DiscordMessageFile> files, Optional<IEnumerable<DiscordAttachment>> attachments)
 		{
 			if (embeds.HasValue && embeds.Value != null)
 				foreach (var embed in embeds.Value)
 					if (embed.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			var pld = new RestChannelMessageEditPayload
 			{
 				HasContent = content.HasValue,
 				Content = content.HasValue ? (string)content : null,
 				HasEmbed = embeds.HasValue && (embeds.Value?.Any() ?? false),
 				Embeds = embeds.HasValue && (embeds.Value?.Any() ?? false) ? embeds.Value : null,
 				Components = components ?? null,
 				Flags = suppressEmbed.HasValue ? (bool)suppressEmbed ? MessageFlags.SuppressedEmbeds : null : null
 			};
 
 			pld.Mentions = new DiscordMentions(mentions ?? Mentions.None, false, mentions?.OfType<RepliedUserMention>().Any() ?? false);
 
 			if (files?.Count > 0)
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachmentsNew = new();
 				foreach (var file in files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName
 					};
 					attachmentsNew.Add(att);
 					fileId++;
 				}
 				if (attachments.HasValue && attachments.Value.Any())
 					attachmentsNew.AddRange(attachments.Value);
 
 				pld.Attachments = attachmentsNew;
 
 				var values = new Dictionary<string, string>
 				{
 					["payload_json"] = DiscordJson.SerializeObject(pld)
 				};
 
 				var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 				var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 				var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: files).ConfigureAwait(false);
 
 				var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 				foreach (var file in files.Where(x => x.ResetPositionTo.HasValue))
 				{
 					file.Stream.Position = file.ResetPositionTo.Value;
 				}
 
 				return ret;
 			}
 			else
 			{
 				pld.Attachments = attachments.HasValue ? attachments.Value : null;
 
 				var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 				var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 				var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 				var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 				return ret;
 			}
 		}
 
 		/// <summary>
 		/// Deletes the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DeleteMessageAsync(ulong channelId, ulong messageId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Deletes the messages async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageIds">The message_ids.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DeleteMessagesAsync(ulong channelId, IEnumerable<ulong> messageIds, string reason)
 		{
 			var pld = new RestChannelMessageBulkDeletePayload
 			{
 				Messages = messageIds
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}{Endpoints.BULK_DELETE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Gets the channel invites async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordInvite>> GetChannelInvitesAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.INVITES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var invitesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordInvite>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 			return new ReadOnlyCollection<DiscordInvite>(new List<DiscordInvite>(invitesRaw));
 		}
 
 		/// <summary>
 		/// Creates the channel invite async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="maxAge">The max_age.</param>
 		/// <param name="maxUses">The max_uses.</param>
 		/// <param name="targetType">The target_type.</param>
 		/// <param name="targetApplication">The target_application.</param>
 		/// <param name="targetUser">The target_user.</param>
 		/// <param name="temporary">If true, temporary.</param>
 		/// <param name="unique">If true, unique.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<DiscordInvite> CreateChannelInviteAsync(ulong channelId, int maxAge, int maxUses, TargetType? targetType, TargetActivity? targetApplication, ulong? targetUser, bool temporary, bool unique, string reason)
 		{
 			var pld = new RestChannelInviteCreatePayload
 			{
 				MaxAge = maxAge,
 				MaxUses = maxUses,
 				TargetType = targetType,
 				TargetApplication = targetApplication,
 				TargetUserId = targetUser,
 				Temporary = temporary,
 				Unique = unique
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.INVITES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the channel permission async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="overwriteId">The overwrite_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DeleteChannelPermissionAsync(ulong channelId, ulong overwriteId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PERMISSIONS}/:overwrite_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, overwrite_id = overwriteId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Edits the channel permissions async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="overwriteId">The overwrite_id.</param>
 		/// <param name="allow">The allow.</param>
 		/// <param name="deny">The deny.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task EditChannelPermissionsAsync(ulong channelId, ulong overwriteId, Permissions allow, Permissions deny, string type, string reason)
 		{
 			var pld = new RestChannelPermissionEditPayload
 			{
 				Type = type,
 				Allow = allow & PermissionMethods.FullPerms,
 				Deny = deny & PermissionMethods.FullPerms
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PERMISSIONS}/:overwrite_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, overwrite_id = overwriteId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Triggers the typing async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 
 		internal Task TriggerTypingAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.TYPING}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route);
 		}
 
 		/// <summary>
 		/// Gets the pinned messages async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var msgsRaw = JArray.Parse(res.Response);
 			var msgs = new List<DiscordMessage>();
 			foreach (var xj in msgsRaw)
 				msgs.Add(this.PrepareMessage(xj));
 
 			return new ReadOnlyCollection<DiscordMessage>(new List<DiscordMessage>(msgs));
 		}
 
 		/// <summary>
 		/// Pins the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 
 		internal Task PinMessageAsync(ulong channelId, ulong messageId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
 		}
 
 		/// <summary>
 		/// Unpins the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 
 		internal Task UnpinMessageAsync(ulong channelId, ulong messageId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Adds the group dm recipient async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="accessToken">The access_token.</param>
 		/// <param name="nickname">The nickname.</param>
 
 		internal Task AddGroupDmRecipientAsync(ulong channelId, ulong userId, string accessToken, string nickname)
 		{
 			var pld = new RestChannelGroupDmRecipientAddPayload
 			{
 				AccessToken = accessToken,
 				Nickname = nickname
 			};
 
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}/:channel_id{Endpoints.RECIPIENTS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Removes the group dm recipient async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="userId">The user_id.</param>
 
 		internal Task RemoveGroupDmRecipientAsync(ulong channelId, ulong userId)
 		{
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}/:channel_id{Endpoints.RECIPIENTS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Creates the group dm async.
 		/// </summary>
 		/// <param name="accessTokens">The access_tokens.</param>
 		/// <param name="nicks">The nicks.</param>
 
 		internal async Task<DiscordDmChannel> CreateGroupDmAsync(IEnumerable<string> accessTokens, IDictionary<ulong, string> nicks)
 		{
 			var pld = new RestUserGroupDmCreatePayload
 			{
 				AccessTokens = accessTokens,
 				Nicknames = nicks
 			};
 
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordDmChannel>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Creates the dm async.
 		/// </summary>
 		/// <param name="recipientId">The recipient_id.</param>
 
 		internal async Task<DiscordDmChannel> CreateDmAsync(ulong recipientId)
 		{
 			var pld = new RestUserDmCreatePayload
 			{
 				Recipient = recipientId
 			};
 
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordDmChannel>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Follows the channel async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="webhookChannelId">The webhook_channel_id.</param>
 
 		internal async Task<DiscordFollowedChannel> FollowChannelAsync(ulong channelId, ulong webhookChannelId)
 		{
 			var pld = new FollowedChannelAddPayload
 			{
 				WebhookChannelId = webhookChannelId
 			};
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.FOLLOWERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var response = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			return JsonConvert.DeserializeObject<DiscordFollowedChannel>(response.Response);
 		}
 
 		/// <summary>
 		/// Crossposts the message async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 
 		internal async Task<DiscordMessage> CrosspostMessageAsync(ulong channelId, ulong messageId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.CROSSPOST}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var response = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route).ConfigureAwait(false);
 			return JsonConvert.DeserializeObject<DiscordMessage>(response.Response);
 		}
 
 		#endregion
 
 		#region Member
 		/// <summary>
 		/// Gets the current user async.
 		/// </summary>
 
 		internal Task<DiscordUser> GetCurrentUserAsync()
 			=> this.GetUserAsync("@me");
 
 		/// <summary>
 		/// Gets the user async.
 		/// </summary>
 		/// <param name="userId">The user_id.</param>
 
 		internal Task<DiscordUser> GetUserAsync(ulong userId)
 			=> this.GetUserAsync(userId.ToString(CultureInfo.InvariantCulture));
 
 		/// <summary>
 		/// Gets the user async.
 		/// </summary>
 		/// <param name="userId">The user_id.</param>
 
 		internal async Task<DiscordUser> GetUserAsync(string userId)
 		{
 			var route = $"{Endpoints.USERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var userRaw = JsonConvert.DeserializeObject<TransportUser>(res.Response);
 			var duser = new DiscordUser(userRaw) { Discord = this.Discord };
 
 			return duser;
 		}
 
 		/// <summary>
 		/// Gets the guild member async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 
 		internal async Task<DiscordMember> GetGuildMemberAsync(ulong guildId, ulong userId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var tm = JsonConvert.DeserializeObject<TransportMember>(res.Response);
 
 			var usr = new DiscordUser(tm.User) { Discord = this.Discord };
 			usr = this.Discord.UserCache.AddOrUpdate(tm.User.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				return old;
 			});
 
 			return new DiscordMember(tm)
 			{
 				Discord = this.Discord,
 				GuildId = guildId
 			};
 		}
 
 		/// <summary>
 		/// Removes the guild member async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task RemoveGuildMemberAsync(ulong guildId, ulong userId, string reason)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (reason != null)
 				urlparams["reason"] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, BuildQueryString(urlparams), this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Modifies the current user async.
 		/// </summary>
 		/// <param name="username">The username.</param>
 		/// <param name="base64Avatar">The base64_avatar.</param>
 
 		internal async Task<TransportUser> ModifyCurrentUserAsync(string username, Optional<string> base64Avatar)
 		{
 			var pld = new RestUserUpdateCurrentPayload
 			{
 				Username = username,
 				AvatarBase64 = base64Avatar.HasValue ? base64Avatar.Value : null,
 				AvatarSet = base64Avatar.HasValue
 			};
 
 			var route = $"{Endpoints.USERS}{Endpoints.ME}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var userRaw = JsonConvert.DeserializeObject<TransportUser>(res.Response);
 
 			return userRaw;
 		}
 
 		/// <summary>
 		/// Gets the current user guilds async.
 		/// </summary>
 		/// <param name="limit">The limit.</param>
 		/// <param name="before">The before.</param>
 		/// <param name="after">The after.</param>
 
 		internal async Task<IReadOnlyList<DiscordGuild>> GetCurrentUserGuildsAsync(int limit = 100, ulong? before = null, ulong? after = null)
 		{
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.GUILDS}";
 
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration)
 				.AddParameter($"limit", limit.ToString(CultureInfo.InvariantCulture));
 
 			if (before != null)
 				url.AddParameter("before", before.Value.ToString(CultureInfo.InvariantCulture));
 			if (after != null)
 				url.AddParameter("after", after.Value.ToString(CultureInfo.InvariantCulture));
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url.Build(), RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			if (this.Discord is DiscordClient)
 			{
 				var guildsRaw = JsonConvert.DeserializeObject<IEnumerable<RestUserGuild>>(res.Response);
 				var glds = guildsRaw.Select(xug => (this.Discord as DiscordClient)?.GuildsInternal[xug.Id]);
 				return new ReadOnlyCollection<DiscordGuild>(new List<DiscordGuild>(glds));
 			}
 			else
 			{
 				return new ReadOnlyCollection<DiscordGuild>(JsonConvert.DeserializeObject<List<DiscordGuild>>(res.Response));
 			}
 		}
 
 		/// <summary>
 		/// Modifies the guild member async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="nick">The nick.</param>
 		/// <param name="roleIds">The role_ids.</param>
 		/// <param name="mute">The mute.</param>
 		/// <param name="deaf">The deaf.</param>
 		/// <param name="voiceChannelId">The voice_channel_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task ModifyGuildMemberAsync(ulong guildId, ulong userId, Optional<string> nick,
 			Optional<IEnumerable<ulong>> roleIds, Optional<bool> mute, Optional<bool> deaf,
 			Optional<ulong?> voiceChannelId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var pld = new RestGuildMemberModifyPayload
 			{
 				Nickname = nick,
 				RoleIds = roleIds,
 				Deafen = deaf,
 				Mute = mute,
 				VoiceChannelId = voiceChannelId
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Modifies the time out of a guild member.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="until">Datetime offset.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task ModifyTimeoutAsync(ulong guildId, ulong userId, DateTimeOffset? until, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var pld = new RestGuildMemberTimeoutModifyPayload
 			{
 				CommunicationDisabledUntil = until
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Modifies the current member nickname async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="nick">The nick.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task ModifyCurrentMemberNicknameAsync(ulong guildId, string nick, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var pld = new RestGuildMemberModifyPayload
 			{
 				Nickname = nick
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}{Endpoints.ME}{Endpoints.NICK}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 		}
 		#endregion
 
 		#region Roles
 		/// <summary>
 		/// Gets the guild roles async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordRole>> GetGuildRolesAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var rolesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordRole>>(res.Response).Select(xr => { xr.Discord = this.Discord; xr.GuildId = guildId; return xr; });
 
 			return new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(rolesRaw));
 		}
 
 		/// <summary>
 		/// Gets the guild async.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="withCounts">If true, with_counts.</param>
 
 		internal async Task<DiscordGuild> GetGuildAsync(ulong guildId, bool? withCounts)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (withCounts.HasValue)
 				urlparams["with_counts"] = withCounts?.ToString();
 
 			var route = $"{Endpoints.GUILDS}/:guild_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route, urlparams).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var rawMembers = (JArray)json["members"];
 			var guildRest = json.ToDiscordObject<DiscordGuild>();
 			foreach (var r in guildRest.RolesInternal.Values)
 				r.GuildId = guildRest.Id;
 
 			if (this.Discord is DiscordClient dc)
 			{
 				await dc.OnGuildUpdateEventAsync(guildRest, rawMembers).ConfigureAwait(false);
 				return dc.GuildsInternal[guildRest.Id];
 			}
 			else
 			{
 				guildRest.Discord = this.Discord;
 				return guildRest;
 			}
 		}
 
 		/// <summary>
 		/// Modifies the guild role async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="roleId">The role_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="permissions">The permissions.</param>
 		/// <param name="color">The color.</param>
 		/// <param name="hoist">If true, hoist.</param>
 		/// <param name="mentionable">If true, mentionable.</param>
 		/// <param name="iconb64">The icon.</param>
 		/// <param name="emoji">The unicode emoji icon.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordRole> ModifyGuildRoleAsync(ulong guildId, ulong roleId, string name, Permissions? permissions, int? color, bool? hoist, bool? mentionable, Optional<string> iconb64, Optional<string> emoji, string reason)
 		{
 			var pld = new RestGuildRolePayload
 			{
 				Name = name,
 				Permissions = permissions & PermissionMethods.FullPerms,
 				Color = color,
 				Hoist = hoist,
 				Mentionable = mentionable,
 			};
 
 			if (emoji.HasValue && !iconb64.HasValue)
 				pld.UnicodeEmoji = emoji;
 
 			if (emoji.HasValue && iconb64.HasValue)
 			{
 				pld.IconBase64 = null;
 				pld.UnicodeEmoji = emoji;
 			}
 
 			if (iconb64.HasValue)
 				pld.IconBase64 = iconb64;
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}/:role_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, role_id = roleId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordRole>(res.Response);
 			ret.Discord = this.Discord;
 			ret.GuildId = guildId;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the role async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="roleId">The role_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DeleteRoleAsync(ulong guildId, ulong roleId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}/:role_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, role_id = roleId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Creates the guild role async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="permissions">The permissions.</param>
 		/// <param name="color">The color.</param>
 		/// <param name="hoist">If true, hoist.</param>
 		/// <param name="mentionable">If true, mentionable.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<DiscordRole> CreateGuildRoleAsync(ulong guildId, string name, Permissions? permissions, int? color, bool? hoist, bool? mentionable, string reason)
 		{
 			var pld = new RestGuildRolePayload
 			{
 				Name = name,
 				Permissions = permissions & PermissionMethods.FullPerms,
 				Color = color,
 				Hoist = hoist,
 				Mentionable = mentionable
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordRole>(res.Response);
 			ret.Discord = this.Discord;
 			ret.GuildId = guildId;
 
 			return ret;
 		}
 		#endregion
 
 		#region Prune
 		/// <summary>
 		/// Gets the guild prune count async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="days">The days.</param>
 		/// <param name="includeRoles">The include_roles.</param>
 
 		internal async Task<int> GetGuildPruneCountAsync(ulong guildId, int days, IEnumerable<ulong> includeRoles)
 		{
 			if (days < 0 || days > 30)
 				throw new ArgumentException("Prune inactivity days must be a number between 0 and 30.", nameof(days));
 
 			var urlparams = new Dictionary<string, string>
 			{
 				["days"] = days.ToString(CultureInfo.InvariantCulture)
 			};
 
 			var sb = new StringBuilder();
 
 			if (includeRoles != null)
 			{
 				var roleArray = includeRoles.ToArray();
 				var roleArrayCount = roleArray.Count();
 
 				for (var i = 0; i < roleArrayCount; i++)
 					sb.Append($"&include_roles={roleArray[i]}");
 			}
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PRUNE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 			var url = Utilities.GetApiUriFor(path, $"{BuildQueryString(urlparams)}{sb}", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var pruned = JsonConvert.DeserializeObject<RestGuildPruneResultPayload>(res.Response);
 
 			return pruned.Pruned.Value;
 		}
 
 		/// <summary>
 		/// Begins the guild prune async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="days">The days.</param>
 		/// <param name="computePruneCount">If true, compute_prune_count.</param>
 		/// <param name="includeRoles">The include_roles.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<int?> BeginGuildPruneAsync(ulong guildId, int days, bool computePruneCount, IEnumerable<ulong> includeRoles, string reason)
 		{
 			if (days < 0 || days > 30)
 				throw new ArgumentException("Prune inactivity days must be a number between 0 and 30.", nameof(days));
 
 			var urlparams = new Dictionary<string, string>
 			{
 				["days"] = days.ToString(CultureInfo.InvariantCulture),
 				["compute_prune_count"] = computePruneCount.ToString()
 			};
 
 			var sb = new StringBuilder();
 
 			if (includeRoles != null)
 			{
 				var roleArray = includeRoles.ToArray();
 				var roleArrayCount = roleArray.Count();
 
 				for (var i = 0; i < roleArrayCount; i++)
 					sb.Append($"&include_roles={roleArray[i]}");
 			}
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PRUNE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, $"{BuildQueryString(urlparams)}{sb}", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers).ConfigureAwait(false);
 
 			var pruned = JsonConvert.DeserializeObject<RestGuildPruneResultPayload>(res.Response);
 
 			return pruned.Pruned;
 		}
 		#endregion
 
 		#region GuildVarious
 		/// <summary>
 		/// Gets the template async.
 		/// </summary>
 		/// <param name="code">The code.</param>
 
 		internal async Task<DiscordGuildTemplate> GetTemplateAsync(string code)
 		{
 			var route = $"{Endpoints.GUILDS}{Endpoints.TEMPLATES}/:code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { code }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var templatesRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 			return templatesRaw;
 		}
 
 		/// <summary>
 		/// Gets the guild integrations async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordIntegration>> GetGuildIntegrationsAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var integrationsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordIntegration>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 			return new ReadOnlyCollection<DiscordIntegration>(new List<DiscordIntegration>(integrationsRaw));
 		}
 
 		/// <summary>
 		/// Gets the guild preview async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PREVIEW}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildPreview>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Creates the guild integration async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="id">The id.</param>
 
 		internal async Task<DiscordIntegration> CreateGuildIntegrationAsync(ulong guildId, string type, ulong id)
 		{
 			var pld = new RestGuildIntegrationAttachPayload
 			{
 				Type = type,
 				Id = id
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordIntegration>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the guild integration async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="integrationId">The integration_id.</param>
 		/// <param name="expireBehaviour">The expire_behaviour.</param>
 		/// <param name="expireGracePeriod">The expire_grace_period.</param>
 		/// <param name="enableEmoticons">If true, enable_emoticons.</param>
 
 		internal async Task<DiscordIntegration> ModifyGuildIntegrationAsync(ulong guildId, ulong integrationId, int expireBehaviour, int expireGracePeriod, bool enableEmoticons)
 		{
 			var pld = new RestGuildIntegrationModifyPayload
 			{
 				ExpireBehavior = expireBehaviour,
 				ExpireGracePeriod = expireGracePeriod,
 				EnableEmoticons = enableEmoticons
 			};
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, integration_id = integrationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordIntegration>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the guild integration async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="integration">The integration.</param>
 
 		internal Task DeleteGuildIntegrationAsync(ulong guildId, DiscordIntegration integration)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, integration_id = integration.Id }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, payload: DiscordJson.SerializeObject(integration));
 		}
 
 		/// <summary>
 		/// Syncs the guild integration async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="integrationId">The integration_id.</param>
 
 		internal Task SyncGuildIntegrationAsync(ulong guildId, ulong integrationId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id{Endpoints.SYNC}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId, integration_id = integrationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route);
 		}
 
 		/// <summary>
 		/// Gets the guild voice regions async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordVoiceRegion>> GetGuildVoiceRegionsAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.REGIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var regionsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordVoiceRegion>>(res.Response);
 
 			return new ReadOnlyCollection<DiscordVoiceRegion>(new List<DiscordVoiceRegion>(regionsRaw));
 		}
 
 		/// <summary>
 		/// Gets the guild invites async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordInvite>> GetGuildInvitesAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INVITES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var invitesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordInvite>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 			return new ReadOnlyCollection<DiscordInvite>(new List<DiscordInvite>(invitesRaw));
 		}
 		#endregion
 
 		#region Invite
 		/// <summary>
 		/// Gets the invite async.
 		/// </summary>
 		/// <param name="inviteCode">The invite_code.</param>
 		/// <param name="withCounts">If true, with_counts.</param>
 		/// <param name="withExpiration">If true, with_expiration.</param>
 		/// <param name="guildScheduledEventId">The scheduled event id to get.</param>
 
 		internal async Task<DiscordInvite> GetInviteAsync(string inviteCode, bool? withCounts, bool? withExpiration, ulong? guildScheduledEventId)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (withCounts.HasValue)
 				urlparams["with_counts"] = withCounts?.ToString();
 			if (withExpiration.HasValue)
 				urlparams["with_expiration"] = withExpiration?.ToString();
 			if (guildScheduledEventId.HasValue)
 				urlparams["guild_scheduled_event_id"] = guildScheduledEventId?.ToString();
 
 			var route = $"{Endpoints.INVITES}/:invite_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {invite_code = inviteCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the invite async.
 		/// </summary>
 		/// <param name="inviteCode">The invite_code.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<DiscordInvite> DeleteInviteAsync(string inviteCode, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.INVITES}/:invite_code";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {invite_code = inviteCode }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/*
          * Disabled due to API restrictions
          *
          * internal async Task<DiscordInvite> InternalAcceptInvite(string invite_code)
          * {
          *     this.Discord.DebugLogger.LogMessage(LogLevel.Warning, "REST API", "Invite accept endpoint was used; this account is now likely unverified", DateTime.Now);
          *
          *     var url = new Uri($"{Utils.GetApiBaseUri(this.Configuration), Endpoints.INVITES}/{invite_code));
          *     var bucket = this.Rest.GetBucket(0, MajorParameterType.Unbucketed, url, HttpRequestMethod.POST);
          *     var res = await this.DoRequestAsync(this.Discord, bucket, url, HttpRequestMethod.POST).ConfigureAwait(false);
          *
          *     var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
          *     ret.Discord = this.Discord;
          *
          *     return ret;
          * }
          */
 		#endregion
 
 		#region Connections
 		/// <summary>
 		/// Gets the users connections async.
 		/// </summary>
 
 		internal async Task<IReadOnlyList<DiscordConnection>> GetUserConnectionsAsync()
 		{
 			var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CONNECTIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var connectionsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordConnection>>(res.Response).Select(xc => { xc.Discord = this.Discord; return xc; });
 
 			return new ReadOnlyCollection<DiscordConnection>(new List<DiscordConnection>(connectionsRaw));
 		}
 		#endregion
 
 		#region Voice
 		/// <summary>
 		/// Lists the voice regions async.
 		/// </summary>
 
 		internal async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
 		{
 			var route = $"{Endpoints.VOICE}{Endpoints.REGIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var regions = JsonConvert.DeserializeObject<IEnumerable<DiscordVoiceRegion>>(res.Response);
 
 			return new ReadOnlyCollection<DiscordVoiceRegion>(new List<DiscordVoiceRegion>(regions));
 		}
 		#endregion
 
 		#region Webhooks
 		/// <summary>
 		/// Creates the webhook async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="base64Avatar">The base64_avatar.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<DiscordWebhook> CreateWebhookAsync(ulong channelId, string name, Optional<string> base64Avatar, string reason)
 		{
 			var pld = new RestWebhookPayload
 			{
 				Name = name,
 				AvatarBase64 = base64Avatar.HasValue ? base64Avatar.Value : null,
 				AvatarSet = base64Avatar.HasValue
 			};
 
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.WEBHOOKS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 			ret.Discord = this.Discord;
 			ret.ApiClient = this;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the channel webhooks async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordWebhook>> GetChannelWebhooksAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.WEBHOOKS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var webhooksRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordWebhook>>(res.Response).Select(xw => { xw.Discord = this.Discord; xw.ApiClient = this; return xw; });
 
 			return new ReadOnlyCollection<DiscordWebhook>(new List<DiscordWebhook>(webhooksRaw));
 		}
 
 		/// <summary>
 		/// Gets the guild webhooks async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordWebhook>> GetGuildWebhooksAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WEBHOOKS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var webhooksRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordWebhook>>(res.Response).Select(xw => { xw.Discord = this.Discord; xw.ApiClient = this; return xw; });
 
 			return new ReadOnlyCollection<DiscordWebhook>(new List<DiscordWebhook>(webhooksRaw));
 		}
 
 		/// <summary>
 		/// Gets the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 
 		internal async Task<DiscordWebhook> GetWebhookAsync(ulong webhookId)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 			ret.Discord = this.Discord;
 			ret.ApiClient = this;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the webhook with token async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 
 		internal async Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong webhookId, string webhookToken)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 			ret.Token = webhookToken;
 			ret.Id = webhookId;
 			ret.Discord = this.Discord;
 			ret.ApiClient = this;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="base64Avatar">The base64_avatar.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<DiscordWebhook> ModifyWebhookAsync(ulong webhookId, ulong channelId, string name, Optional<string> base64Avatar, string reason)
 		{
 			var pld = new RestWebhookPayload
 			{
 				Name = name,
 				AvatarBase64 = base64Avatar.HasValue ? base64Avatar.Value : null,
 				AvatarSet = base64Avatar.HasValue,
 				ChannelId = channelId
 			};
 
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 			ret.Discord = this.Discord;
 			ret.ApiClient = this;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="base64Avatar">The base64_avatar.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<DiscordWebhook> ModifyWebhookAsync(ulong webhookId, string name, string base64Avatar, string webhookToken, string reason)
 		{
 			var pld = new RestWebhookPayload
 			{
 				Name = name,
 				AvatarBase64 = base64Avatar
 			};
 
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 			ret.Discord = this.Discord;
 			ret.ApiClient = this;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DeleteWebhookAsync(ulong webhookId, string reason)
 		{
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Deletes the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DeleteWebhookAsync(ulong webhookId, string webhookToken, string reason)
 		{
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		/// <summary>
 		/// Executes the webhook async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="builder">The builder.</param>
 		/// <param name="threadId">The thread_id.</param>
 
 		internal async Task<DiscordMessage> ExecuteWebhookAsync(ulong webhookId, string webhookToken, DiscordWebhookBuilder builder, string threadId)
 		{
 			builder.Validate();
 
 			if (builder.Embeds != null)
 				foreach (var embed in builder.Embeds)
 					if (embed.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			var values = new Dictionary<string, string>();
 			var pld = new RestWebhookExecutePayload
 			{
 				Content = builder.Content,
 				Username = builder.Username.HasValue ? builder.Username.Value : null,
 				AvatarUrl = builder.AvatarUrl.HasValue ? builder.AvatarUrl.Value : null,
 				IsTts = builder.IsTts,
 				Embeds = builder.Embeds,
 				Components = builder.Components
 			};
 
 			if (builder.Mentions != null)
 				pld.Mentions = new DiscordMentions(builder.Mentions, builder.Mentions.Any());
 
 			if (builder.Files?.Count > 0)
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachments = new();
 				foreach (var file in builder.Files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName,
 						FileSize = null
 					};
 					attachments.Add(att);
 					fileId++;
 				}
 				pld.Attachments = attachments;
 			}
 
 			if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count() > 0 || builder.Files?.Count > 0 || builder.IsTts == true || builder.Mentions != null)
 				values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 
 			var url = qub.Build();
 
 			var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 			foreach (var att in ret.Attachments)
 				att.Discord = this.Discord;
 
 			foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 			{
 				file.Stream.Position = file.ResetPositionTo.Value;
 			}
 
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Executes the webhook slack async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="jsonPayload">The json_payload.</param>
 		/// <param name="threadId">The thread_id.</param>
 
 		internal async Task<DiscordMessage> ExecuteWebhookSlackAsync(ulong webhookId, string webhookToken, string jsonPayload, string threadId)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.SLACK}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 			var url = qub.Build();
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: jsonPayload).ConfigureAwait(false);
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Executes the webhook github async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="jsonPayload">The json_payload.</param>
 		/// <param name="threadId">The thread_id.</param>
 
 		internal async Task<DiscordMessage> ExecuteWebhookGithubAsync(ulong webhookId, string webhookToken, string jsonPayload, string threadId)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.GITHUB}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 			var url = qub.Build();
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: jsonPayload).ConfigureAwait(false);
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Edits the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="builder">The builder.</param>
 		/// <param name="threadId">The thread_id.</param>
 
 		internal async Task<DiscordMessage> EditWebhookMessageAsync(ulong webhookId, string webhookToken, string messageId, DiscordWebhookBuilder builder, string threadId)
 		{
 			builder.Validate(true);
 
 			var pld = new RestWebhookMessageEditPayload
 			{
 				Content = builder.Content,
 				Embeds = builder.Embeds,
 				Mentions = builder.Mentions,
 				Components = builder.Components,
 			};
 
 			if (builder.Files?.Count > 0)
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachments = new();
 				foreach (var file in builder.Files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName,
 						FileSize = null
 					};
 					attachments.Add(att);
 					fileId++;
 				}
 				if (builder.Attachments != null && builder.Attachments?.Count() > 0)
 					attachments.AddRange(builder.Attachments);
 
 				pld.Attachments = attachments;
 
 				var values = new Dictionary<string, string>
 				{
 					["payload_json"] = DiscordJson.SerializeObject(pld)
 				};
 				var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 				var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 				if (threadId != null)
 					qub.AddParameter("thread_id", threadId);
 
 				var url = qub.Build();
 				var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: builder.Files);
 
 				var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 				ret.Discord = this.Discord;
 
 				foreach (var att in ret.AttachmentsInternal)
 					att.Discord = this.Discord;
 
 				foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 				{
 					file.Stream.Position = file.ResetPositionTo.Value;
 				}
 
 				return ret;
 			}
 			else
 			{
 				pld.Attachments = builder.Attachments;
 
 				var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 				var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 				var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 				if (threadId != null)
 					qub.AddParameter("thread_id", threadId);
 
 				var url = qub.Build();
 				var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 				var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 				ret.Discord = this.Discord;
 
 				foreach (var att in ret.AttachmentsInternal)
 					att.Discord = this.Discord;
 
 				return ret;
 			}
 		}
 
 		/// <summary>
 		/// Edits the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="builder">The builder.</param>
 		/// <param name="threadId">The thread_id.</param>
 
 		internal Task<DiscordMessage> EditWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId, DiscordWebhookBuilder builder, ulong threadId) =>
 			this.EditWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), builder, threadId.ToString());
 
 		/// <summary>
 		/// Gets the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="threadId">The thread_id.</param>
 
 		internal async Task<DiscordMessage> GetWebhookMessageAsync(ulong webhookId, string webhookToken, string messageId, string threadId)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 			var url = qub.Build();
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 
 		internal Task<DiscordMessage> GetWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId) =>
 			this.GetWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), null);
 
 		/// <summary>
 		/// Gets the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="threadId">The thread_id.</param>
 
 		internal Task<DiscordMessage> GetWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId, ulong threadId) =>
 			this.GetWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), threadId.ToString());
 
 		/// <summary>
 		/// Deletes the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="threadId">The thread_id.</param>
 
 		internal async Task DeleteWebhookMessageAsync(ulong webhookId, string webhookToken, string messageId, string threadId)
 		{
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 			var url = qub.Build();
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Deletes the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 
 		internal Task DeleteWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId) =>
 			this.DeleteWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), null);
 
 		/// <summary>
 		/// Deletes the webhook message async.
 		/// </summary>
 		/// <param name="webhookId">The webhook_id.</param>
 		/// <param name="webhookToken">The webhook_token.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="threadId">The thread_id.</param>
 
 		internal Task DeleteWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId, ulong threadId) =>
 			this.DeleteWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), threadId.ToString());
 		#endregion
 
 		#region Reactions
 		/// <summary>
 		/// Creates the reaction async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="emoji">The emoji.</param>
 
 		internal Task CreateReactionAsync(ulong channelId, ulong messageId, string emoji)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji{Endpoints.ME}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 		}
 
 		/// <summary>
 		/// Deletes the own reaction async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="emoji">The emoji.</param>
 
 		internal Task DeleteOwnReactionAsync(ulong channelId, ulong messageId, string emoji)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji{Endpoints.ME}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 		}
 
 		/// <summary>
 		/// Deletes the user reaction async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="userId">The user_id.</param>
 		/// <param name="emoji">The emoji.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DeleteUserReactionAsync(ulong channelId, ulong messageId, ulong userId, string emoji, string reason)
 		{
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId, emoji, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 		}
 
 		/// <summary>
 		/// Gets the reactions async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="emoji">The emoji.</param>
 		/// <param name="afterId">The after_id.</param>
 		/// <param name="limit">The limit.</param>
 
 		internal async Task<IReadOnlyList<DiscordUser>> GetReactionsAsync(ulong channelId, ulong messageId, string emoji, ulong? afterId = null, int limit = 25)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (afterId.HasValue)
 				urlparams["after"] = afterId.Value.ToString(CultureInfo.InvariantCulture);
 
 			urlparams["limit"] = limit.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, BuildQueryString(urlparams), this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var reactersRaw = JsonConvert.DeserializeObject<IEnumerable<TransportUser>>(res.Response);
 			var reacters = new List<DiscordUser>();
 			foreach (var xr in reactersRaw)
 			{
 				var usr = new DiscordUser(xr) { Discord = this.Discord };
 				usr = this.Discord.UserCache.AddOrUpdate(xr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
 
 				reacters.Add(usr);
 			}
 
 			return new ReadOnlyCollection<DiscordUser>(new List<DiscordUser>(reacters));
 		}
 
 		/// <summary>
 		/// Deletes the all reactions async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DeleteAllReactionsAsync(ulong channelId, ulong messageId, string reason)
 		{
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 		}
 
 		/// <summary>
 		/// Deletes the reactions emoji async.
 		/// </summary>
 		/// <param name="channelId">The channel_id.</param>
 		/// <param name="messageId">The message_id.</param>
 		/// <param name="emoji">The emoji.</param>
 
 		internal Task DeleteReactionsEmojiAsync(ulong channelId, ulong messageId, string emoji)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 		}
 		#endregion
 
 		#region Threads
 
 		/// <summary>
 		/// Creates the thread with message.
 		/// </summary>
 		/// <param name="channelId">The channel id to create the thread in.</param>
 		/// <param name="messageId">The message id to create the thread from.</param>
 		/// <param name="name">The name of the thread.</param>
 		/// <param name="autoArchiveDuration">The auto_archive_duration for the thread.</param>
 		/// <param name="rateLimitPerUser">The rate limit per user.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordThreadChannel> CreateThreadWithMessageAsync(ulong channelId, ulong messageId, string name, ThreadAutoArchiveDuration autoArchiveDuration, int? rateLimitPerUser, string reason = null)
 		{
 			var pld = new RestThreadChannelCreatePayload
 			{
 				Name = name,
 				AutoArchiveDuration = autoArchiveDuration,
 				PerUserRateLimit = rateLimitPerUser
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.THREADS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
 			var threadChannel = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
 
 			return threadChannel;
 		}
 
 		/// <summary>
 		/// Creates the thread without a message.
 		/// </summary>
 		/// <param name="channelId">The channel id to create the thread in.</param>
 		/// <param name="name">The name of the thread.</param>
 		/// <param name="autoArchiveDuration">The auto_archive_duration for the thread.</param>
 		/// <param name="type">Can be either <see cref="ChannelType.PublicThread"/> or <see cref="ChannelType.PrivateThread"/>.</param>
 		/// <param name="rateLimitPerUser">The rate limit per user.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordThreadChannel> CreateThreadWithoutMessageAsync(ulong channelId, string name, ThreadAutoArchiveDuration autoArchiveDuration, ChannelType type = ChannelType.PublicThread, int? rateLimitPerUser = null, string reason = null)
 		{
 			var pld = new RestThreadChannelCreatePayload
 			{
 				Name = name,
 				AutoArchiveDuration = autoArchiveDuration,
 				PerUserRateLimit = rateLimitPerUser,
 				Type = type
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
 			var threadChannel = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
 
 			return threadChannel;
 		}
 
 		/// <summary>
 		/// Gets the thread.
 		/// </summary>
 		/// <param name="threadId">The thread id.</param>
 		internal async Task<DiscordThreadChannel> GetThreadAsync(ulong threadId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:thread_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {thread_id = threadId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var ret = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Joins the thread.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		internal async Task JoinThreadAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}{Endpoints.ME}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
 		}
 
 		/// <summary>
 		/// Leaves the thread.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		internal async Task LeaveThreadAsync(ulong channelId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}{Endpoints.ME}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Adds a thread member.
 		/// </summary>
 		/// <param name="channelId">The channel id to add the member to.</param>
 		/// <param name="userId">The user id to add.</param>
 		internal async Task AddThreadMemberAsync(ulong channelId, ulong userId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
 		}
 
 		/// <summary>
 		/// Gets a thread member.
 		/// </summary>
 		/// <param name="channelId">The channel id to get the member from.</param>
 		/// <param name="userId">The user id to get.</param>
 		internal async Task<DiscordThreadChannelMember> GetThreadMemberAsync(ulong channelId, ulong userId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadMember = JsonConvert.DeserializeObject<DiscordThreadChannelMember>(res.Response);
 
 			return threadMember;
 		}
 
 		/// <summary>
 		/// Removes a thread member.
 		/// </summary>
 		/// <param name="channelId">The channel id to remove the member from.</param>
 		/// <param name="userId">The user id to remove.</param>
 		internal async Task RemoveThreadMemberAsync(ulong channelId, ulong userId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Gets the thread members.
 		/// </summary>
 		/// <param name="threadId">The thread id.</param>
 		internal async Task<IReadOnlyList<DiscordThreadChannelMember>> GetThreadMembersAsync(ulong threadId)
 		{
 			var route = $"{Endpoints.CHANNELS}/:thread_id{Endpoints.THREAD_MEMBERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {thread_id = threadId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadMembersRaw = JsonConvert.DeserializeObject<List<DiscordThreadChannelMember>>(res.Response);
 
 			return new ReadOnlyCollection<DiscordThreadChannelMember>(threadMembersRaw);
 		}
 
 		/// <summary>
 		/// Gets the active threads in a guild.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		internal async Task<DiscordThreadResult> GetActiveThreadsAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.THREADS}{Endpoints.THREAD_ACTIVE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 			return threadReturn;
 		}
 
 		/// <summary>
 		/// Gets the joined private archived threads in a channel.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="before">Get threads before snowflake.</param>
 		/// <param name="limit">Limit the results.</param>
 		internal async Task<DiscordThreadResult> GetJoinedPrivateArchivedThreadsAsync(ulong channelId, ulong? before, int? limit)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (before != null)
 				urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 			if (limit != null && limit > 0)
 				urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.USERS}{Endpoints.ME}{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PRIVATE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 			return threadReturn;
 		}
 
 		/// <summary>
 		/// Gets the public archived threads in a channel.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="before">Get threads before snowflake.</param>
 		/// <param name="limit">Limit the results.</param>
 		internal async Task<DiscordThreadResult> GetPublicArchivedThreadsAsync(ulong channelId, ulong? before, int? limit)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (before != null)
 				urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 			if (limit != null && limit > 0)
 				urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PUBLIC}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 			return threadReturn;
 		}
 
 		/// <summary>
 		/// Gets the private archived threads in a channel.
 		/// </summary>
 		/// <param name="channelId">The channel id.</param>
 		/// <param name="before">Get threads before snowflake.</param>
 		/// <param name="limit">Limit the results.</param>
 		internal async Task<DiscordThreadResult> GetPrivateArchivedThreadsAsync(ulong channelId, ulong? before, int? limit)
 		{
 			var urlparams = new Dictionary<string, string>();
 			if (before != null)
 				urlparams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 			if (limit != null && limit > 0)
 				urlparams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PRIVATE}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, urlparams.Any() ? BuildQueryString(urlparams) : "", this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 			return threadReturn;
 		}
 
 		/// <summary>
 		/// Modifies a thread.
 		/// </summary>
 		/// <param name="threadId">The thread to modify.</param>
 		/// <param name="name">The new name.</param>
 		/// <param name="locked">The new locked state.</param>
 		/// <param name="archived">The new archived state.</param>
 		/// <param name="autoArchiveDuration">The new auto archive duration.</param>
 		/// <param name="perUserRateLimit">The new per user rate limit.</param>
 		/// <param name="invitable">The new user invitable state.</param>
 		/// <param name="reason">The reason for the modification.</param>
 		internal Task ModifyThreadAsync(ulong threadId, string name, Optional<bool?> locked, Optional<bool?> archived, Optional<ThreadAutoArchiveDuration?> autoArchiveDuration, Optional<int?> perUserRateLimit, Optional<bool?> invitable, string reason)
 		{
 			var pld = new RestThreadChannelModifyPayload
 			{
 				Name = name,
 				Archived = archived,
 				AutoArchiveDuration = autoArchiveDuration,
 				Locked = locked,
 				PerUserRateLimit = perUserRateLimit,
 				Invitable = invitable
 			};
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:thread_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {thread_id = threadId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Deletes a thread.
 		/// </summary>
 		/// <param name="threadId">The thread to delete.</param>
 		/// <param name="reason">The reason for deletion.</param>
 		internal Task DeleteThreadAsync(ulong threadId, string reason)
 		{
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var route = $"{Endpoints.CHANNELS}/:thread_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {thread_id = threadId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 
 		#endregion
 
 		#region Emoji
 		/// <summary>
 		/// Gets the guild emojis async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 
 		internal async Task<IReadOnlyList<DiscordGuildEmoji>> GetGuildEmojisAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var emojisRaw = JsonConvert.DeserializeObject<IEnumerable<JObject>>(res.Response);
 
 			this.Discord.Guilds.TryGetValue(guildId, out var gld);
 			var users = new Dictionary<ulong, DiscordUser>();
 			var emojis = new List<DiscordGuildEmoji>();
 			foreach (var rawEmoji in emojisRaw)
 			{
 				var xge = rawEmoji.ToObject<DiscordGuildEmoji>();
 				xge.Guild = gld;
 
 				var xtu = rawEmoji["user"]?.ToObject<TransportUser>();
 				if (xtu != null)
 				{
 					if (!users.ContainsKey(xtu.Id))
 					{
 						var user = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 						users[user.Id] = user;
 					}
 
 					xge.User = users[xtu.Id];
 				}
 
 				emojis.Add(xge);
 			}
 
 			return new ReadOnlyCollection<DiscordGuildEmoji>(emojis);
 		}
 
 		/// <summary>
 		/// Gets the guild emoji async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="emojiId">The emoji_id.</param>
 
 		internal async Task<DiscordGuildEmoji> GetGuildEmojiAsync(ulong guildId, ulong emojiId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, emoji_id = emojiId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			this.Discord.Guilds.TryGetValue(guildId, out var gld);
 
 			var emojiRaw = JObject.Parse(res.Response);
 			var emoji = emojiRaw.ToObject<DiscordGuildEmoji>();
 			emoji.Guild = gld;
 
 			var xtu = emojiRaw["user"]?.ToObject<TransportUser>();
 			if (xtu != null)
 				emoji.User = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 
 			return emoji;
 		}
 
 		/// <summary>
 		/// Creates the guild emoji async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="imageb64">The imageb64.</param>
 		/// <param name="roles">The roles.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<DiscordGuildEmoji> CreateGuildEmojiAsync(ulong guildId, string name, string imageb64, IEnumerable<ulong> roles, string reason)
 		{
 			var pld = new RestGuildEmojiCreatePayload
 			{
 				Name = name,
 				ImageB64 = imageb64,
 				Roles = roles?.ToArray()
 			};
 
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			this.Discord.Guilds.TryGetValue(guildId, out var gld);
 
 			var emojiRaw = JObject.Parse(res.Response);
 			var emoji = emojiRaw.ToObject<DiscordGuildEmoji>();
 			emoji.Guild = gld;
 
 			var xtu = emojiRaw["user"]?.ToObject<TransportUser>();
 			emoji.User = xtu != null
 				? gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu)
 				: this.Discord.CurrentUser;
 
 			return emoji;
 		}
 
 		/// <summary>
 		/// Modifies the guild emoji async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="emojiId">The emoji_id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="roles">The roles.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal async Task<DiscordGuildEmoji> ModifyGuildEmojiAsync(ulong guildId, ulong emojiId, string name, IEnumerable<ulong> roles, string reason)
 		{
 			var pld = new RestGuildEmojiModifyPayload
 			{
 				Name = name,
 				Roles = roles?.ToArray()
 			};
 
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, emoji_id = emojiId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			this.Discord.Guilds.TryGetValue(guildId, out var gld);
 
 			var emojiRaw = JObject.Parse(res.Response);
 			var emoji = emojiRaw.ToObject<DiscordGuildEmoji>();
 			emoji.Guild = gld;
 
 			var xtu = emojiRaw["user"]?.ToObject<TransportUser>();
 			if (xtu != null)
 				emoji.User = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 
 			return emoji;
 		}
 
 		/// <summary>
 		/// Deletes the guild emoji async.
 		/// </summary>
 		/// <param name="guildId">The guild_id.</param>
 		/// <param name="emojiId">The emoji_id.</param>
 		/// <param name="reason">The reason.</param>
 
 		internal Task DeleteGuildEmojiAsync(ulong guildId, ulong emojiId, string reason)
 		{
 			var headers = new Dictionary<string, string>();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers[REASON_HEADER_NAME] = reason;
 
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, emoji_id = emojiId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 		#endregion
 
 		#region Stickers
 
 		/// <summary>
 		/// Gets a sticker.
 		/// </summary>
 		/// <param name="stickerId">The sticker id.</param>
 		internal async Task<DiscordSticker> GetStickerAsync(ulong stickerId)
 		{
 			var route = $"{Endpoints.STICKERS}/:sticker_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {sticker_id = stickerId}, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 			var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the sticker packs.
 		/// </summary>
 		internal async Task<IReadOnlyList<DiscordStickerPack>> GetStickerPacksAsync()
 		{
 			var route = $"{Endpoints.STICKERPACKS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response)["sticker_packs"] as JArray;
 			var ret = json.ToDiscordObject<DiscordStickerPack[]>();
 
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Gets the guild stickers.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		internal async Task<IReadOnlyList<DiscordSticker>> GetGuildStickersAsync(ulong guildId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId}, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 			var json = JArray.Parse(res.Response);
 			var ret = json.ToDiscordObject<DiscordSticker[]>();
 
 			for (var i = 0; i < ret.Length; i++)
 			{
 				var stkr = ret[i];
 				stkr.Discord = this.Discord;
 
 				if (json[i]["user"] is JObject obj) // Null = Missing stickers perm //
 				{
 					var tsr = obj.ToDiscordObject<TransportUser>();
 					var usr = new DiscordUser(tsr) {Discord = this.Discord};
 					usr = this.Discord.UserCache.AddOrUpdate(tsr.Id, usr, (id, old) =>
 					{
 						old.Username = usr.Username;
 						old.Discriminator = usr.Discriminator;
 						old.AvatarHash = usr.AvatarHash;
 						return old;
 					});
 					stkr.User = usr;
 				}
 			}
 
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Gets a guild sticker.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="stickerId">The sticker id.</param>
 		internal async Task<DiscordSticker> GetGuildStickerAsync(ulong guildId, ulong stickerId)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, sticker_id = stickerId}, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var json = JObject.Parse(res.Response);
 			var ret = json.ToDiscordObject<DiscordSticker>();
 			if (json["user"] is not null) // Null = Missing stickers perm //
 			{
 				var tsr = json["user"].ToDiscordObject<TransportUser>();
 				var usr = new DiscordUser(tsr) {Discord = this.Discord};
 				usr = this.Discord.UserCache.AddOrUpdate(tsr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
 				ret.User = usr;
 			}
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Creates the guild sticker.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="tags">The tags.</param>
 		/// <param name="file">The file.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordSticker> CreateGuildStickerAsync(ulong guildId, string name, string description, string tags, DiscordMessageFile file, string reason)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId}, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var res = await this.DoStickerMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, file, name, tags, description);
 
 			var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Modifies the guild sticker.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="stickerId">The sticker id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="tags">The tags.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task<DiscordSticker> ModifyGuildStickerAsync(ulong guildId, ulong stickerId, Optional<string> name, Optional<string> description, Optional<string> tags, string reason)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, sticker_id = stickerId}, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			var pld = new RestStickerModifyPayload()
 			{
 				Name = name,
 				Description = description,
 				Tags = tags
 			};
 
 			var values = new Dictionary<string, string>
 			{
 				["payload_json"] = DiscordJson.SerializeObject(pld)
 			};
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route);
 			var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 			ret.Discord = this.Discord;
 
 			return null;
 		}
 
 		/// <summary>
 		/// Deletes the guild sticker async.
 		/// </summary>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="stickerId">The sticker id.</param>
 		/// <param name="reason">The reason.</param>
 		internal async Task DeleteGuildStickerAsync(ulong guildId, ulong stickerId, string reason)
 		{
 			var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, sticker_id = stickerId }, out var path);
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var headers = Utilities.GetBaseHeaders();
 			if (!string.IsNullOrWhiteSpace(reason))
 				headers.Add(REASON_HEADER_NAME, reason);
 
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 		}
 		#endregion
 
 		#region Application Commands
 
 		/// <summary>
 		/// Gets the global application commands.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
-		internal async Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync(ulong applicationId)
+		/// <param name="withLocalizations">Whether to get the full localization dict.</param>
+		internal async Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync(ulong applicationId, bool withLocalizations = false)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId }, out var path);
 
-			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
+			var querydict = new Dictionary<string, string>
+			{
+				["with_localizations"] = withLocalizations.ToString().ToLower()
+			};
+			var url = Utilities.GetApiUriFor(path, BuildQueryString(querydict), this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Bulk overwrites the global application commands.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="commands">The commands.</param>
 		internal async Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGlobalApplicationCommandsAsync(ulong applicationId, IEnumerable<DiscordApplicationCommand> commands)
 		{
 			var pld = new List<RestApplicationCommandCreatePayload>();
 			foreach (var command in commands)
 			{
 				pld.Add(new RestApplicationCommandCreatePayload
 				{
 					Type = command.Type,
 					Name = command.Name,
 					Description = command.Description,
 					Options = command.Options,
 					DefaultPermission = command.DefaultPermission,
 					NameLocalizations = command.NameLocalizations?.GetKeyValuePairs(),
 					DescriptionLocalizations = command.DescriptionLocalizations?.GetKeyValuePairs()
 				});
 			}
 
 			this.Discord.Logger.LogDebug(DiscordJson.SerializeObject(pld));
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {application_id = applicationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Creates a global application command.
 		/// </summary>
 		/// <param name="applicationId">The applicationid.</param>
 		/// <param name="command">The command.</param>
 		internal async Task<DiscordApplicationCommand> CreateGlobalApplicationCommandAsync(ulong applicationId, DiscordApplicationCommand command)
 		{
 			var pld = new RestApplicationCommandCreatePayload
 			{
 				Type = command.Type,
 				Name = command.Name,
 				Description = command.Description,
 				Options = command.Options,
 				DefaultPermission = command.DefaultPermission,
 				NameLocalizations = command.NameLocalizations.GetKeyValuePairs(),
 				DescriptionLocalizations = command.DescriptionLocalizations.GetKeyValuePairs()
 			};
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {application_id = applicationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets a global application command.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="commandId">The command id.</param>
 		internal async Task<DiscordApplicationCommand> GetGlobalApplicationCommandAsync(ulong applicationId, ulong commandId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Edits a global application command.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="commandId">The command id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="options">The options.</param>
 		/// <param name="defaultPermission">The default permission.</param>
 		/// <param name="nameLocalization">The localizations of the name.</param>
 		/// <param name="descriptionLocalization">The localizations of the description.</param>
 		internal async Task<DiscordApplicationCommand> EditGlobalApplicationCommandAsync(ulong applicationId, ulong commandId, Optional<string> name, Optional<string> description, Optional<IReadOnlyCollection<DiscordApplicationCommandOption>> options, Optional<bool> defaultPermission, Optional<DiscordApplicationCommandLocalization> nameLocalization, Optional<DiscordApplicationCommandLocalization> descriptionLocalization)
 		{
 			var pld = new RestApplicationCommandEditPayload
 			{
 				Name = name,
 				Description = description,
 				Options = options,
 				DefaultPermission = defaultPermission,
 				NameLocalizations = nameLocalization.HasValue ? nameLocalization.Value.GetKeyValuePairs() : null,
 				DescriptionLocalizations = descriptionLocalization.HasValue ? descriptionLocalization.Value.GetKeyValuePairs() : null
 			};
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {application_id = applicationId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes a global application command.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 		/// <param name="commandId">The command_id.</param>
 
 		internal async Task DeleteGlobalApplicationCommandAsync(ulong applicationId, ulong commandId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {application_id = applicationId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Gets the guild application commands.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="guildId">The guild id.</param>
-		internal async Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong applicationId, ulong guildId)
+		/// <param name="withLocalizations">Whether to get the full localization dict.</param>
+		internal async Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong applicationId, ulong guildId, bool withLocalizations = false)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
-			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
+			var querydict = new Dictionary<string, string>
+			{
+				["with_localizations"] = withLocalizations.ToString().ToLower()
+			};
+			var url = Utilities.GetApiUriFor(path, BuildQueryString(querydict), this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Bulk overwrites the guild application commands.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="commands">The commands.</param>
 		internal async Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGuildApplicationCommandsAsync(ulong applicationId, ulong guildId, IEnumerable<DiscordApplicationCommand> commands)
 		{
 			var pld = new List<RestApplicationCommandCreatePayload>();
 			foreach (var command in commands)
 			{
 				pld.Add(new RestApplicationCommandCreatePayload
 				{
 					Type = command.Type,
 					Name = command.Name,
 					Description = command.Description,
 					Options = command.Options,
 					DefaultPermission = command.DefaultPermission,
 					NameLocalizations = command.NameLocalizations?.GetKeyValuePairs(),
 					DescriptionLocalizations = command.DescriptionLocalizations?.GetKeyValuePairs()
 				});
 			}
 			this.Discord.Logger.LogDebug(DiscordJson.SerializeObject(pld));
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Creates a guild application command.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="command">The command.</param>
 		internal async Task<DiscordApplicationCommand> CreateGuildApplicationCommandAsync(ulong applicationId, ulong guildId, DiscordApplicationCommand command)
 		{
 			var pld = new RestApplicationCommandCreatePayload
 			{
 				Type = command.Type,
 				Name = command.Name,
 				Description = command.Description,
 				Options = command.Options,
 				DefaultPermission = command.DefaultPermission,
 				NameLocalizations = command.NameLocalizations.GetKeyValuePairs(),
 				DescriptionLocalizations = command.DescriptionLocalizations.GetKeyValuePairs()
 
 			};
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets a guild application command.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="commandId">The command id.</param>
 		internal async Task<DiscordApplicationCommand> GetGuildApplicationCommandAsync(ulong applicationId, ulong guildId, ulong commandId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Edits a guild application command.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="commandId">The command id.</param>
 		/// <param name="name">The name.</param>
 		/// <param name="description">The description.</param>
 		/// <param name="options">The options.</param>
 		/// <param name="defaultPermission">The default permission.</param>
 		/// <param name="nameLocalization">The localizations of the name.</param>
 		/// <param name="descriptionLocalization">The localizations of the description.</param>
 		internal async Task<DiscordApplicationCommand> EditGuildApplicationCommandAsync(ulong applicationId, ulong guildId, ulong commandId, Optional<string> name, Optional<string> description, Optional<IReadOnlyCollection<DiscordApplicationCommandOption>> options, Optional<bool> defaultPermission, Optional<DiscordApplicationCommandLocalization> nameLocalization, Optional<DiscordApplicationCommandLocalization> descriptionLocalization)
 		{
 			var pld = new RestApplicationCommandEditPayload
 			{
 				Name = name,
 				Description = description,
 				Options = options,
 				DefaultPermission = defaultPermission,
 				NameLocalizations = nameLocalization.HasValue ? nameLocalization.Value.GetKeyValuePairs() : null,
 				DescriptionLocalizations = descriptionLocalization.HasValue ? descriptionLocalization.Value.GetKeyValuePairs() : null
 			};
 
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Deletes a guild application command.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="guildId">The guild id.</param>
 		/// <param name="commandId">The command id.</param>
 		internal async Task DeleteGuildApplicationCommandAsync(ulong applicationId, ulong guildId, ulong commandId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 		}
 
 		/// <summary>
 		/// Gets the guild application command permissions.
 		/// </summary>
 		/// <param name="applicationId">The target application id.</param>
 		/// <param name="guildId">The target guild id.</param>
 		internal async Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> GetGuildApplicationCommandPermissionsAsync(ulong applicationId, ulong guildId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}{Endpoints.PERMISSIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildApplicationCommandPermission>>(res.Response);
 
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Gets a guild application command permission.
 		/// </summary>
 		/// <param name="applicationId">The target application id.</param>
 		/// <param name="guildId">The target guild id.</param>
 		/// <param name="commandId">The target command id.</param>
 		internal async Task<DiscordGuildApplicationCommandPermission> GetGuildApplicationCommandPermissionAsync(ulong applicationId, ulong guildId, ulong commandId)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id{Endpoints.PERMISSIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildApplicationCommandPermission>(res.Response);
 
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Overwrites the guild application command permissions.
 		/// </summary>
 		/// <param name="applicationId">The target application id.</param>
 		/// <param name="guildId">The target guild id.</param>
 		/// <param name="commandId">The target command id.</param>
 		/// <param name="permissions">Array of permissions.</param>
 		internal async Task<DiscordGuildApplicationCommandPermission> OverwriteGuildApplicationCommandPermissionsAsync(ulong applicationId, ulong guildId, ulong commandId, IEnumerable<DiscordApplicationCommandPermission> permissions)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id{Endpoints.PERMISSIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 			if (permissions.ToArray().Length > 10)
 				throw new NotSupportedException("You can add only up to 10 permission overwrites per command.");
 
 			var pld = new RestApplicationCommandPermissionEditPayload
 			{
 				Permissions = permissions
 			};
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordGuildApplicationCommandPermission>(res.Response);
 
 			ret.Discord = this.Discord;
 
 			return ret;
 		}
 
 		/// <summary>
 		/// Bulks overwrite the application command permissions.
 		/// </summary>
 		/// <param name="applicationId">The target application id.</param>
 		/// <param name="guildId">The target guild id.</param>
 		/// <param name="permissionOverwrites">List of overwrites.</param>
 		internal async Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> BulkOverwriteGuildApplicationCommandPermissionsAsync(ulong applicationId, ulong guildId, IEnumerable<DiscordGuildApplicationCommandPermission> permissionOverwrites)
 		{
 			var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}{Endpoints.PERMISSIONS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 			var pld = new List<RestGuildApplicationCommandPermissionEditPayload>();
 			foreach (var overwrite in permissionOverwrites)
 			{
 				if (overwrite.Permissions.Count > 10)
 					throw new NotSupportedException("You can add only up to 10 permission overwrites per command.");
 
 				pld.Add(new RestGuildApplicationCommandPermissionEditPayload
 				{
 					CommandId = overwrite.Id,
 					Permissions = overwrite.Permissions
 				});
 			}
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld.ToArray()));
 
 			var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildApplicationCommandPermission>>(res.Response);
 
 			foreach (var app in ret)
 				app.Discord = this.Discord;
 
 			return ret.ToList();
 		}
 
 		/// <summary>
 		/// Creates the interaction response.
 		/// </summary>
 		/// <param name="interactionId">The interaction id.</param>
 		/// <param name="interactionToken">The interaction token.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="builder">The builder.</param>
 		internal async Task CreateInteractionResponseAsync(ulong interactionId, string interactionToken, InteractionResponseType type, DiscordInteractionResponseBuilder builder)
 		{
 			if (builder?.Embeds != null)
 				foreach (var embed in builder.Embeds)
 					if (embed.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			RestInteractionResponsePayload pld;
 
 			if (type != InteractionResponseType.AutoCompleteResult)
 			{
 				var data = builder != null ? new DiscordInteractionApplicationCommandCallbackData
 				{
 					Content = builder.Content ?? null,
 					Embeds = builder.Embeds ?? null,
 					IsTts = builder.IsTts,
 					Mentions = builder.Mentions ?? null,
 					Flags = builder.IsEphemeral ? MessageFlags.Ephemeral : null,
 					Components = builder.Components ?? null,
 					Choices = null
 				} : null;
 
 
 				pld = new RestInteractionResponsePayload
 				{
 					Type = type,
 					Data = data
 				};
 
 
 				if (builder != null && builder.Files != null && builder.Files.Count > 0)
 				{
 					ulong fileId = 0;
 					List<DiscordAttachment> attachments = new();
 					foreach (var file in builder.Files)
 					{
 						DiscordAttachment att = new()
 						{
 							Id = fileId,
 							Discord = this.Discord,
 							Description = file.Description,
 							FileName = file.FileName,
 							FileSize = null
 						};
 						attachments.Add(att);
 						fileId++;
 					}
 					pld.Attachments = attachments;
 					pld.Data.Attachments = attachments;
 				}
 			}
 			else
 			{
 				pld = new RestInteractionResponsePayload
 				{
 					Type = type,
 					Data = new DiscordInteractionApplicationCommandCallbackData
 					{
 						Content = null,
 						Embeds = null,
 						IsTts = null,
 						Mentions = null,
 						Flags = null,
 						Components = null,
 						Choices = builder.Choices,
 						Attachments = null
 					},
 					Attachments = null
 				};
 			}
 
 			var values = new Dictionary<string, string>();
 
 			if (builder != null)
 				if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count() > 0 || builder.IsTts == true || builder.Mentions != null || builder.Files?.Count > 0)
 					values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 			var route = $"{Endpoints.INTERACTIONS}/:interaction_id/:interaction_token{Endpoints.CALLBACK}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {interaction_id = interactionId, interaction_token = interactionToken }, out var path);
 
 			var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "false").Build();
 			if (builder != null)
 			{
 				await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files);
 
 				foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 				{
 					file.Stream.Position = file.ResetPositionTo.Value;
 				}
 			}
 			else
 			{
 				await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 			}
 		}
 
 		/// <summary>
 		/// Creates the interaction response.
 		/// </summary>
 		/// <param name="interactionId">The interaction id.</param>
 		/// <param name="interactionToken">The interaction token.</param>
 		/// <param name="type">The type.</param>
 		/// <param name="builder">The builder.</param>
 		internal async Task CreateInteractionModalResponseAsync(ulong interactionId, string interactionToken, InteractionResponseType type, DiscordInteractionModalBuilder builder)
 		{
 			if (builder.ModalComponents.Any(mc => mc.Components.Any(c => c.Type != Enums.ComponentType.InputText)))
 				throw new NotSupportedException("Can't send any other type then Input Text as Modal Component.");
 
 			var pld = new RestInteractionModalResponsePayload
 			{
 				Type = type,
 				Data = new DiscordInteractionApplicationCommandModalCallbackData
 				{
 					Title = builder.Title,
 					CustomId = builder.CustomId,
 					ModalComponents = builder.ModalComponents
 				}
 			};
 
 			var values = new Dictionary<string, string>();
 
 			var route = $"{Endpoints.INTERACTIONS}/:interaction_id/:interaction_token{Endpoints.CALLBACK}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {interaction_id = interactionId, interaction_token = interactionToken }, out var path);
 
 			var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 		}
 
 		/// <summary>
 		/// Gets the original interaction response.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="interactionToken">The interaction token.</param>
 		internal Task<DiscordMessage> GetOriginalInteractionResponseAsync(ulong applicationId, string interactionToken) =>
 			this.GetWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, null);
 
 		/// <summary>
 		/// Edits the original interaction response.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="interactionToken">The interaction token.</param>
 		/// <param name="builder">The builder.</param>
 		internal Task<DiscordMessage> EditOriginalInteractionResponseAsync(ulong applicationId, string interactionToken, DiscordWebhookBuilder builder) =>
 			this.EditWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, builder, null);
 
 		/// <summary>
 		/// Deletes the original interaction response.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="interactionToken">The interaction token.</param>
 		internal Task DeleteOriginalInteractionResponseAsync(ulong applicationId, string interactionToken) =>
 			this.DeleteWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, null);
 
 		/// <summary>
 		/// Creates the followup message.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="interactionToken">The interaction token.</param>
 		/// <param name="builder">The builder.</param>
 		internal async Task<DiscordMessage> CreateFollowupMessageAsync(ulong applicationId, string interactionToken, DiscordFollowupMessageBuilder builder)
 		{
 			builder.Validate();
 
 			if (builder.Embeds != null)
 				foreach (var embed in builder.Embeds)
 					if (embed.Timestamp != null)
 						embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 			var values = new Dictionary<string, string>();
 			var pld = new RestFollowupMessageCreatePayload
 			{
 				Content = builder.Content,
 				IsTts = builder.IsTts,
 				Embeds = builder.Embeds,
 				Flags = builder.Flags,
 				Components = builder.Components
 			};
 
 
 			if (builder.Files != null && builder.Files.Count > 0)
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachments = new();
 				foreach (var file in builder.Files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName,
 						FileSize = null
 					};
 					attachments.Add(att);
 					fileId++;
 				}
 				pld.Attachments = attachments;
 			}
 
 			if (builder.Mentions != null)
 				pld.Mentions = new DiscordMentions(builder.Mentions, builder.Mentions.Any());
 
 			if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count() > 0 || builder.IsTts == true || builder.Mentions != null || builder.Files?.Count > 0)
 				values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 			var route = $"{Endpoints.WEBHOOKS}/:application_id/:interaction_token";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {application_id = applicationId, interaction_token = interactionToken }, out var path);
 
 			var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
 			var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 			foreach (var att in ret.AttachmentsInternal)
 			{
 				att.Discord = this.Discord;
 			}
 
 			foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 			{
 				file.Stream.Position = file.ResetPositionTo.Value;
 			}
 
 			ret.Discord = this.Discord;
 			return ret;
 		}
 
 		/// <summary>
 		/// Gets the followup message.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="interactionToken">The interaction token.</param>
 		/// <param name="messageId">The message id.</param>
 		internal Task<DiscordMessage> GetFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId) =>
 			this.GetWebhookMessageAsync(applicationId, interactionToken, messageId);
 
 		/// <summary>
 		/// Edits the followup message.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="interactionToken">The interaction token.</param>
 		/// <param name="messageId">The message id.</param>
 		/// <param name="builder">The builder.</param>
 		internal Task<DiscordMessage> EditFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId, DiscordWebhookBuilder builder) =>
 			this.EditWebhookMessageAsync(applicationId, interactionToken, messageId.ToString(), builder, null);
 
 		/// <summary>
 		/// Deletes the followup message.
 		/// </summary>
 		/// <param name="applicationId">The application id.</param>
 		/// <param name="interactionToken">The interaction token.</param>
 		/// <param name="messageId">The message id.</param>
 		internal Task DeleteFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId) =>
 			this.DeleteWebhookMessageAsync(applicationId, interactionToken, messageId);
 		#endregion
 
 		#region Misc
 		/// <summary>
 		/// Gets the current application info async.
 		/// </summary>
 
 		internal Task<TransportApplication> GetCurrentApplicationInfoAsync()
 			=> this.GetApplicationInfoAsync("@me");
 
 		/// <summary>
 		/// Gets the application info async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 
 		internal Task<TransportApplication> GetApplicationInfoAsync(ulong applicationId)
 			=> this.GetApplicationInfoAsync(applicationId.ToString(CultureInfo.InvariantCulture));
 
 		/// <summary>
 		/// Gets the application info async.
 		/// </summary>
 		/// <param name="applicationId">The application_id.</param>
 
 		private async Task<TransportApplication> GetApplicationInfoAsync(string applicationId)
 		{
 			var route = $"{Endpoints.OAUTH2}{Endpoints.APPLICATIONS}/:application_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			return JsonConvert.DeserializeObject<TransportApplication>(res.Response);
 		}
 
 		/// <summary>
 		/// Gets the application assets async.
 		/// </summary>
 		/// <param name="application">The application.</param>
 
 		internal async Task<IReadOnlyList<DiscordApplicationAsset>> GetApplicationAssetsAsync(DiscordApplication application)
 		{
 			var route = $"{Endpoints.OAUTH2}{Endpoints.APPLICATIONS}/:application_id{Endpoints.ASSETS}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id = application.Id }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 			var assets = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationAsset>>(res.Response);
 			foreach (var asset in assets)
 			{
 				asset.Discord = application.Discord;
 				asset.Application = application;
 			}
 
 			return new ReadOnlyCollection<DiscordApplicationAsset>(new List<DiscordApplicationAsset>(assets));
 		}
 
 		/// <summary>
 		/// Gets the gateway info async.
 		/// </summary>
 
 		internal async Task<GatewayInfo> GetGatewayInfoAsync()
 		{
 			var headers = Utilities.GetBaseHeaders();
 			var route = Endpoints.GATEWAY;
 			if (this.Discord.Configuration.TokenType == TokenType.Bot)
 				route += Endpoints.BOT;
 			var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route, headers).ConfigureAwait(false);
 
 			var info = JObject.Parse(res.Response).ToObject<GatewayInfo>();
 			info.SessionBucket.ResetAfter = DateTimeOffset.UtcNow + TimeSpan.FromMilliseconds(info.SessionBucket.ResetAfterInternal);
 			return info;
 		}
 		#endregion
 
 		#region DCS Internals
 		/// <summary>
 		/// Gets the DisCatSharp team.
 		/// </summary>>
 		internal async Task<DisCatSharpTeam> GetDisCatSharpTeamAsync()
 		{
 			try
 			{
 				var dcs = await this.Discord.RestClient.GetStringAsync(new Uri("https://dcs.aitsys.dev/api/devs/"));
 				var dcsGuild = await this.Discord.RestClient.GetStringAsync(new Uri("https://dcs.aitsys.dev/api/guild/"));
 
 				var app = JsonConvert.DeserializeObject<TransportApplication>(dcs);
 				var guild = JsonConvert.DeserializeObject<DiscordGuild>(dcsGuild);
 
 				var dcst = new DisCatSharpTeam
 				{
 					IconHash = app.Team.IconHash,
 					TeamName = app.Team.Name,
 					PrivacyPolicyUrl = app.PrivacyPolicyUrl,
 					TermsOfServiceUrl = app.TermsOfServiceUrl,
 					RepoUrl = "https://github.com/Aiko-IT-Systems/DisCatSharp",
 					DocsUrl = "https://docs.dcs.aitsys.dev",
 					Id = app.Team.Id,
 					BannerHash = guild.BannerHash,
 					LogoHash = guild.IconHash,
 					GuildId = guild.Id,
 					Guild = guild,
 					SupportInvite = await this.GetInviteAsync("U4BGHpKSF7", true, true, null)
 				};
 				List<DisCatSharpTeamMember> team = new();
 				DisCatSharpTeamMember owner = new();
 				foreach (var mb in app.Team.Members.OrderBy(m => m.User.Username))
 				{
 					var tuser = await this.GetUserAsync(mb.User.Id);
 					var user = mb.User;
 					if (mb.User.Id == 856780995629154305)
 					{
 						owner.Id = user.Id;
 						owner.Username = user.Username;
 						owner.Discriminator = user.Discriminator;
 						owner.AvatarHash = user.AvatarHash;
 						owner.BannerHash = tuser.BannerHash;
 						owner.BannerColorInternal = tuser.BannerColorInternal;
 						team.Add(owner);
 					}
 					else
 					{
 						team.Add(new DisCatSharpTeamMember
 						{
 							Id = user.Id,
 							Username = user.Username,
 							Discriminator = user.Discriminator,
 							AvatarHash = user.AvatarHash,
 							BannerHash = tuser.BannerHash,
 							BannerColorInternal = tuser.BannerColorInternal
 						});
 					}
 				}
 				dcst.Owner = owner;
 				dcst.Developers = team;
 
 				return dcst;
 			}
 			catch (Exception ex)
 			{
 				this.Discord.Logger.LogDebug(ex.Message);
 				this.Discord.Logger.LogDebug(ex.StackTrace);
 				return null;
 			}
 		}
 		#endregion
 	}
 }