diff --git a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
index 52a94cbe6..cb54f7f4a 100644
--- a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
+++ b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
@@ -1,1871 +1,1864 @@
 // 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>
 	/// Set to true if anything fails when registering.
 	/// </summary>
 	private static bool s_errored { get; set; }
 
 	/// <summary>
 	/// Gets a list of registered commands. The key is the guild id (null if global).
 	/// </summary>
 	public IReadOnlyList<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> RegisteredCommands
 		=> s_registeredCommands;
 	private static readonly List<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> s_registeredCommands = new();
 
 	/// <summary>
 	/// Gets a list of registered global commands.
 	/// </summary>
 	public IReadOnlyList<DiscordApplicationCommand> GlobalCommands
 		=> GlobalCommandsInternal;
 	internal static readonly List<DiscordApplicationCommand> GlobalCommandsInternal = new();
 
 	/// <summary>
 	/// Gets a list of registered guild commands mapped by guild id.
 	/// </summary>
 	public IReadOnlyDictionary<ulong, IReadOnlyList<DiscordApplicationCommand>> GuildCommands
 		=> GuildCommandsInternal;
 	internal static readonly Dictionary<ulong, IReadOnlyList<DiscordApplicationCommand>> GuildCommandsInternal = new();
 
 	/// <summary>
 	/// Gets the registration count.
 	/// </summary>
 	private static int s_registrationCount { get; set; }
 
 	/// <summary>
 	/// Gets the expected count.
 	/// </summary>
 	private static int s_expectedCount { get; set; }
 
 	/// <summary>
 	/// Gets the guild ids where the applications.commands scope is missing.
 	/// </summary>
 	private IReadOnlyList<ulong> _missingScopeGuildIds;
 
 	/// <summary>
 	/// Gets whether debug is enabled.
 	/// </summary>
 	internal static bool DebugEnabled { get; set; }
 
 	internal static LogLevel ApplicationCommandsLogLevel
 		=> DebugEnabled ? LogLevel.Debug : LogLevel.Trace;
 
 	/// <summary>
 	/// Gets whether check through all guilds is enabled.
 	/// </summary>
 	internal static bool CheckAllGuilds { get; set; }
 
 	/// <summary>
 	/// Gets whether the registration check should be manually overridden.
 	/// </summary>
 	internal static bool ManOr { get; set; }
 
 	/// <summary>
 	/// Gets whether interactions should be automatically deffered.
 	/// </summary>
 	internal static bool AutoDeferEnabled { get; set; }
 
 	/// <summary>
 	/// Whether this module finished the startup.
 	/// </summary>
 	internal bool StartupFinished { 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;
 
 		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.StartupFinished = false;
 		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)
 	{
 		if (!this.StartupFinished)
 			await e.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AsEphemeral(true).WithContent("Attention: This application is still starting up. Application commands are unavailable for now."));
 		else
 			await Task.Delay(1);
 	}
 
 	private async Task CatchContextMenuInteractionsOnStartup(DiscordClient sender, ContextMenuInteractionCreateEventArgs e)
 	{
 		if (!this.StartupFinished)
 			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."));
 		else
 			await Task.Delay(1);
 	}
 
 	private void FinishedRegistration()
 	{
 		this.Client.InteractionCreated -= this.CatchInteractionsOnStartup;
 		this.Client.ContextMenuInteractionCreated -= this.CatchContextMenuInteractionsOnStartup;
 
 		this.StartupFinished = true;
 
 		this.Client.InteractionCreated += this.InteractionHandler;
 		this.Client.ContextMenuInteractionCreated += this.ContextMenuHandler;
 	}
 	/// <summary>
 	/// Cleans the module for a new start of the bot.
 	/// DO NOT USE IF YOU DON'T KNOW WHAT IT DOES.
 	/// </summary>
 	public void CleanModule()
 	{
 		this._updateList.Clear();
 		s_singletonModules.Clear();
 		s_errored = false;
 		s_expectedCount = 0;
 		s_registrationCount = 0;
 		s_commandMethods.Clear();
 		s_groupCommands.Clear();
 		s_contextMenuCommands.Clear();
 		s_subGroupCommands.Clear();
 		s_singletonModules.Clear();
 		s_registeredCommands.Clear();
 		GlobalCommandsInternal.Clear();
 		GuildCommandsInternal.Clear();
 	}
 
 	/// <summary>
 	/// 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 optional translation setup for a guild.
 	/// </summary>
 	/// <typeparam name="T">The command class to register.</typeparam>
 	/// <param name="guildId">The guild id to register it on.</param>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGuildCommands<T>(ulong guildId, Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
 		=> this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(typeof(T), translationSetup)));
 
 
 	/// <summary>
 	/// Registers a command class with optional translation setup for a guild.
 	/// </summary>
 	/// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
 	/// <param name="guildId">The guild id to register it on.</param>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGuildCommands(Type type, ulong guildId, Action<ApplicationCommandsTranslationContext> translationSetup = null)
 	{
 		if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
 			throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
 		this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(type, translationSetup)));
 	}
 
 	/// <summary>
 	/// Registers a command class with optional translation setup globally.
 	/// </summary>
 	/// <typeparam name="T">The command class to register.</typeparam>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGlobalCommands<T>(Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
 		=> this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(typeof(T), translationSetup)));
 
 	/// <summary>
 	/// Registers a command class with optional translation setup globally.
 	/// </summary>
 	/// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGlobalCommands(Type type, Action<ApplicationCommandsTranslationContext> translationSetup = null)
 	{
 		if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
 			throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
 		this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(type, translationSetup)));
 	}
 
 	/// <summary>
 	/// Fired when the application commands module is ready.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs> ApplicationCommandsModuleReady
 	{
 		add => this._applicationCommandsModuleReady.Register(value);
 		remove => this._applicationCommandsModuleReady.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs> _applicationCommandsModuleReady;
 
 	/// <summary>
 	/// Fired when the application commands modules startup is finished.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs> ApplicationCommandsModuleStartupFinished
 	{
 		add => this._applicationCommandsModuleStartupFinished.Register(value);
 		remove => this._applicationCommandsModuleStartupFinished.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs> _applicationCommandsModuleStartupFinished;
 
 
 	/// <summary>
 	/// Fired when guild commands are registered on a guild.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs> GuildApplicationCommandsRegistered
 	{
 		add => this._guildApplicationCommandsRegistered.Register(value);
 		remove => this._guildApplicationCommandsRegistered.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs> _guildApplicationCommandsRegistered;
 
 	/// <summary>
 	/// Fired when the global commands are registered.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs> GlobalApplicationCommandsRegistered
 	{
 		add => this._globalApplicationCommandsRegistered.Register(value);
 		remove => this._globalApplicationCommandsRegistered.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs> _globalApplicationCommandsRegistered;
 
 	/// <summary>
 	/// Used for RegisterCommands and the <see cref="DisCatSharp.DiscordClient.Ready"/> event.
 	/// </summary>
 	internal async Task UpdateAsync()
 	{
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Request to register commands on shard {shard}", this.Client.ShardId);
 		GlobalDiscordCommands = new();
 		GuildDiscordCommands = new();
 
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Expected Count: {count}", s_expectedCount);
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Shard {shard} has {guilds} guilds.", this.Client.ShardId, this.Client.Guilds?.Count);
 		List<ulong> failedGuilds = new();
 		List<DiscordApplicationCommand> globalCommands = null;
 		globalCommands = (await this.Client.GetGlobalApplicationCommandsAsync(Configuration?.EnableLocalization ?? false)).ToList() ?? null;
 		var updateList = this._updateList;
 		var guilds = CheckAllGuilds ? this.Client.Guilds?.Keys.ToList() : updateList.Where(x => x.Key != null)?.Select(x => x.Key.Value).Distinct().ToList();
 		var wrongShards = guilds.Where(x => !this.Client.Guilds.ContainsKey(x)).ToList();
 		if (wrongShards.Any())
 		{
 			this.Client.Logger.Log(ApplicationCommandsLogLevel, "Some guilds are not on the same shard as the client. Removing them from the update list.");
 			foreach (var guild in wrongShards)
 			{
 				updateList.RemoveAll(x => x.Key == guild);
 				guilds.Remove(guild);
 			}
 		}
 
 		var commandsPending = updateList.Select(x => x.Key).Distinct().ToList();
 		s_expectedCount = commandsPending.Count();
 
 		foreach (var guild in guilds)
 		{
 			List<DiscordApplicationCommand> commands = null;
 			var unauthorized = false;
 			try
 			{
 				commands = (await this.Client.GetGuildApplicationCommandsAsync(guild, Configuration?.EnableLocalization ?? false)).ToList() ?? null;
 			}
 			catch (UnauthorizedException)
 			{
 				unauthorized = true;
 			}
 			finally
 			{
 				if (!unauthorized && commands != null && commands.Any())
 					GuildDiscordCommands.Add(guild, commands.ToList());
 				else if (unauthorized)
 					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))
 		{
 			updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>
 				(null, new ApplicationCommandsModuleConfiguration(typeof(DefaultHelpModule))));
 			commandsPending = updateList.Select(x => x.Key).Distinct().ToList();
 		}
 
 		if (globalCommands != null && globalCommands.Any())
 			GlobalDiscordCommands.AddRange(globalCommands);
 
 		foreach (var key in commandsPending)
 		{
 			this.Client.Logger.Log(ApplicationCommandsLogLevel, key.HasValue ? $"Registering commands in guild {key.Value}" : "Registering global commands.");
 			if (key.HasValue)
 			{
 				this.Client.Logger.Log(ApplicationCommandsLogLevel, "Found guild {guild} in shard {shard}!", key.Value, this.Client.ShardId);
 				this.Client.Logger.Log(ApplicationCommandsLogLevel, "Registering");
 			}
 			await this.RegisterCommands(updateList.Where(x => x.Key == key).Select(x => x.Value).ToList(), key);
 		}
 
 		this._missingScopeGuildIds = failedGuilds;
 
 		await this._applicationCommandsModuleReady.InvokeAsync(this, new ApplicationCommandsModuleReadyEventArgs(Configuration?.ServiceProvider)
 		{
 			GuildsWithoutScope = failedGuilds
 		});
 		this.Client.GuildDownloadCompleted -= async (c, e) => await this.UpdateAsync();
 	}
 
 	/// <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 async Task RegisterCommands(List<ApplicationCommandsModuleConfiguration> types, ulong? guildId)
 	{
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Registering commands on shard {shard}", this.Client.ShardId);
 		//Initialize empty lists to be added to the global ones at the end
 		var commandMethods = new List<CommandMethod>();
 		var groupCommands = new List<GroupCommand>();
 		var subGroupCommands = new List<SubGroupCommand>();
 		var contextMenuCommands = new List<ContextMenuCommand>();
 		var updateList = new List<DiscordApplicationCommand>();
 
 		var commandTypeSources = new List<KeyValuePair<Type, Type>>();
 
 		//Iterates over all the modules
 		foreach (var config in types)
 		{
 			var type = config.Type;
 			try
 			{
 				var module = type.GetTypeInfo();
 				var classes = new List<TypeInfo>();
 
 				var ctx = new ApplicationCommandsTranslationContext(type, module.FullName);
 				config.Translations?.Invoke(ctx);
 
 				//Add module to classes list if it's a group
 				if (module.GetCustomAttribute<SlashCommandGroupAttribute>() != null)
 				{
 					classes.Add(module);
 				}
 				else
 				{
 					//Otherwise add the nested groups
 					classes = module.DeclaredNestedTypes.Where(x => x.GetCustomAttribute<SlashCommandGroupAttribute>() != null).ToList();
 				}
 
 				List<GroupTranslator> groupTranslations = null;
 
 				if (!string.IsNullOrEmpty(ctx.Translations))
 				{
 					groupTranslations = JsonConvert.DeserializeObject<List<GroupTranslator>>(ctx.Translations);
 				}
 
 				var slashGroupsTuple = await NestedCommandWorker.ParseSlashGroupsAsync(type, classes, guildId, groupTranslations);
 
 				if (slashGroupsTuple.applicationCommands != null && slashGroupsTuple.applicationCommands.Any())
 					updateList.AddRange(slashGroupsTuple.applicationCommands);
 
 				if (slashGroupsTuple.commandTypeSources != null && slashGroupsTuple.commandTypeSources.Any())
 					commandTypeSources.AddRange(slashGroupsTuple.commandTypeSources);
 
 				if (slashGroupsTuple.singletonModules != null && slashGroupsTuple.singletonModules.Any())
 					s_singletonModules.AddRange(slashGroupsTuple.singletonModules);
 
 				if (slashGroupsTuple.groupCommands != null && slashGroupsTuple.groupCommands.Any())
 					groupCommands.AddRange(slashGroupsTuple.groupCommands);
 
 				if (slashGroupsTuple.subGroupCommands != null && slashGroupsTuple.subGroupCommands.Any())
 					subGroupCommands.AddRange(slashGroupsTuple.subGroupCommands);
 
 				//Handles methods and context menus, only if the module isn't a group itself
 				if (module.GetCustomAttribute<SlashCommandGroupAttribute>() == null)
 				{
 					List<CommandTranslator> commandTranslations = null;
 
 					if (!string.IsNullOrEmpty(ctx.Translations))
 					{
 						commandTranslations = JsonConvert.DeserializeObject<List<CommandTranslator>>(ctx.Translations);
 					}
 
 					//Slash commands
 					var methods = module.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null);
 
 					var slashCommands = await CommandWorker.ParseBasicSlashCommandsAsync(type, methods, guildId, commandTranslations);
 
 					if (slashCommands.applicationCommands != null && slashCommands.applicationCommands.Any())
 						updateList.AddRange(slashCommands.applicationCommands);
 
 					if (slashCommands.commandTypeSources != null && slashCommands.commandTypeSources.Any())
 						commandTypeSources.AddRange(slashCommands.commandTypeSources);
 
 					if (slashCommands.commandMethods != null && slashCommands.commandMethods.Any())
 						commandMethods.AddRange(slashCommands.commandMethods);
 
 					//Context Menus
 					var contextMethods = module.DeclaredMethods.Where(x => x.GetCustomAttribute<ContextMenuAttribute>() != null);
 
 					var contextCommands = await CommandWorker.ParseContextMenuCommands(type, contextMethods, commandTranslations);
 
 					if (contextCommands.applicationCommands != null && contextCommands.applicationCommands.Any())
 						updateList.AddRange(contextCommands.applicationCommands);
 
 					if (contextCommands.commandTypeSources != null && contextCommands.commandTypeSources.Any())
 						commandTypeSources.AddRange(contextCommands.commandTypeSources);
 
 					if (contextCommands.contextMenuCommands != null && contextCommands.contextMenuCommands.Any())
 						contextMenuCommands.AddRange(contextCommands.contextMenuCommands);
 
 					//Accounts for lifespans
 					if (module.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null && module.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
 						s_singletonModules.Add(CreateInstance(module, Configuration?.ServiceProvider));
 				}
 			}
 			catch (Exception ex)
 			{
 				if (ex is BadRequestException brex)
 				{
 					this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.WebResponse.Response}");
 				}
 				else
 				{
 					if (ex.InnerException is not null && ex.InnerException is BadRequestException brex1)
 						this.Client.Logger.LogCritical(brex1, $"There was an error registering application commands: {brex1.WebResponse.Response}");
 					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 = await RegistrationWorker.RegisterGlobalCommandsAsync(this.Client, updateList);
 							var actualCommands = regCommands.Distinct().ToList();
 							commands.AddRange(actualCommands);
 							GlobalCommandsInternal.AddRange(actualCommands);
 						}
 						else
 						{
 							foreach (var cmd in GlobalDiscordCommands)
 							{
 								try
 								{
 									await this.Client.DeleteGlobalApplicationCommandAsync(cmd.Id);
 								}
 								catch (NotFoundException)
 								{
 									this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Could not delete global command {cmd.Id}. Please clean up manually");
 								}
 							}
 						}
 					}
 					else
 					{
 						if (updateList != null && updateList.Any())
 						{
 							var regCommands = await  RegistrationWorker.RegisterGuildCommandsAsync(this.Client, guildId.Value, updateList);
 							var actualCommands = regCommands.Distinct().ToList();
 							commands.AddRange(actualCommands);
 							GuildCommandsInternal.Add(guildId.Value, actualCommands);
 							/*
 							if (client.Guilds.TryGetValue(guildId.Value, out var guild))
 							{
 								guild.InternalRegisteredApplicationCommands = new();
 								guild.InternalRegisteredApplicationCommands.AddRange(actualCommands);
 							}
 							*/
 						}
 						else
 						{
 							foreach (var cmd in GuildDiscordCommands.First(x => x.Key == guildId.Value).Value)
 							{
 								try
 								{
 									await this.Client.DeleteGuildApplicationCommandAsync(guildId.Value, cmd.Id);
 								}
 								catch (NotFoundException)
 								{
 									this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Could not delete guild command {cmd.Id} in guild {guildId.Value}. Please clean up manually");
 								}
 							}
 						}
 					}
 				}
 				catch (UnauthorizedException ex)
 				{
 					this.Client.Logger.LogError($"Could not register application commands for guild {guildId}.\nError: {ex.JsonMessage}");
 					return;
 				}
 				//Creates a guild command if a guild id is specified, otherwise global
 				//Checks against the ids and adds them to the command method lists
 				foreach (var command in commands)
 				{
 					if (commandMethods.GetFirstValueWhere(x => x.Name == command.Name, out var com))
 						com.CommandId = command.Id;
 					else if (groupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var groupCom))
 						groupCom.CommandId = command.Id;
 					else if (subGroupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var subCom))
 						subCom.CommandId = command.Id;
 					else if (contextMenuCommands.GetFirstValueWhere(x => x.Name == command.Name, out var cmCom))
 						cmCom.CommandId = command.Id;
 				}
 
 				//Adds to the global lists finally
 				s_commandMethods.AddRange(commandMethods);
 				s_groupCommands.AddRange(groupCommands);
 				s_subGroupCommands.AddRange(subGroupCommands);
 				s_contextMenuCommands.AddRange(contextMenuCommands);
 
 				s_registeredCommands.Add(new KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>(guildId, commands.ToList()));
 
 				foreach (var command in commandMethods)
 				{
 					var app = types.First(t => t.Type == command.Method.DeclaringType);
 				}
 
 				this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Expected Count: {s_expectedCount}\nCurrent Count: {s_registrationCount}");
 
 				if (guildId.HasValue)
 				{
 					await this._guildApplicationCommandsRegistered.InvokeAsync(this, new GuildApplicationCommandsRegisteredEventArgs(Configuration?.ServiceProvider)
 					{
 						Handled = true,
 						GuildId = guildId.Value,
 						RegisteredCommands = GuildCommandsInternal.Any(c => c.Key == guildId.Value) ? GuildCommandsInternal.FirstOrDefault(c => c.Key == guildId.Value).Value : null
 					});
 				}
 				else
 				{
 					await this._globalApplicationCommandsRegistered.InvokeAsync(this, new GlobalApplicationCommandsRegisteredEventArgs(Configuration?.ServiceProvider)
 					{
 						Handled = true,
 						RegisteredCommands = GlobalCommandsInternal
 					});
 				}
 
 				s_registrationCount++;
 				this.CheckRegistrationStartup(ManOr);
 			}
 			catch (Exception ex)
 			{
 				if (ex is BadRequestException brex)
 				{
 					this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.WebResponse.Response}");
 				}
 				else
 				{
 					if (ex.InnerException is not null && ex.InnerException is BadRequestException brex1)
 						this.Client.Logger.LogCritical(brex1, $"There was an error registering application commands: {brex1.WebResponse.Response}");
 					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\n" +
 			$"Expected Count: {s_expectedCount}\n" +
 			$"Current Count: {s_registrationCount}");
 
 		if ((s_registrationCount == s_expectedCount) || man)
 		{
 			await this._applicationCommandsModuleStartupFinished.InvokeAsync(this, new ApplicationCommandsModuleStartupFinishedEventArgs(Configuration?.ServiceProvider)
 			{
 				Handled = true,
 				RegisteredGlobalCommands = GlobalCommandsInternal,
 				RegisteredGuildCommands = GuildCommandsInternal,
 				GuildsWithoutScope = this._missingScopeGuildIds
 			});
 
 			this.FinishedRegistration();
 		}
 	}
 
 	/// <summary>
 	/// Interaction handler.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The event args.</param>
 	private Task InteractionHandler(DiscordClient client, InteractionCreateEventArgs e)
 	{
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Got interaction on shard {shard}", this.Client.ShardId);
 		_ = 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,
 					AppPermissions = e.Interaction.AppPermissions
 				};
 
 				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;
 						this.Client.Logger.LogDebug("Executing {cmd}", method.Name);
 						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;
 
 						this.Client.Logger.LogDebug("Executing {cmd}", method.Name);
 						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;
 
 						this.Client.Logger.LogDebug("Executing {cmd}", method.Name);
 						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)
 				{
 					this.Client.Logger.LogError(ex.Message);
 					this.Client.Logger.LogError(ex.StackTrace);
 
 					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 = 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,
 							AppPermissions = e.Interaction.AppPermissions
 						};
 
 						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
 						{
 							Client = client,
 							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,
 							AppPermissions = e.Interaction.AppPermissions
 						};
 
 						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
 						{
 							Client = client,
 							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,
 							AppPermissions = e.Interaction.AppPermissions
 						};
 
 						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,
 				AppPermissions = e.Interaction.AppPermissions
 			};
 
 			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;
 
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Executing {cmd}", method.Name);
 		//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);
 
 		foreach (var parameter in parameters)
 		{
 			//Accounts for optional arguments without values given
 			if (parameter.IsOptional && (options == null || (!options?.Any(x => x.Name == parameter.GetCustomAttribute<OptionAttribute>().Name.ToLower()) ?? true)))
 				args.Add(parameter.DefaultValue);
 			else
 			{
 				var option = options.Single(x => x.Name == parameter.GetCustomAttribute<OptionAttribute>().Name.ToLower());
 
 				if (parameter.ParameterType == typeof(string))
 					args.Add(option.Value.ToString());
 				else if (parameter.ParameterType.IsEnum)
 					args.Add(Enum.Parse(parameter.ParameterType, (string)option.Value));
 				else if (parameter.ParameterType == typeof(long) || parameter.ParameterType == typeof(long?))
 					args.Add((long?)option.Value);
 				else if (parameter.ParameterType == typeof(bool) || parameter.ParameterType == typeof(bool?))
 					args.Add((bool?)option.Value);
 				else if (parameter.ParameterType == typeof(double) || parameter.ParameterType == typeof(double?))
 					args.Add((double?)option.Value);
 				else if (parameter.ParameterType == typeof(int) || parameter.ParameterType == typeof(int?))
 					args.Add((int?)option.Value);
 				else if (parameter.ParameterType == typeof(DiscordAttachment))
 				{
 					//Checks through resolved
 					if (e.Interaction.Data.Resolved.Attachments != null &&
 						e.Interaction.Data.Resolved.Attachments.TryGetValue((ulong)option.Value, out var attachment))
 						args.Add(attachment);
 					else
 						args.Add(new DiscordAttachment() { Id = (ulong)option.Value, Discord = this.Client.ApiClient.Discord });
 				}
 				else if (parameter.ParameterType == typeof(DiscordUser))
 				{
 					//Checks through resolved
 					if (e.Interaction.Data.Resolved.Members != null &&
 						e.Interaction.Data.Resolved.Members.TryGetValue((ulong)option.Value, out var member))
 						args.Add(member);
 					else if (e.Interaction.Data.Resolved.Users != null &&
 							 e.Interaction.Data.Resolved.Users.TryGetValue((ulong)option.Value, out var user))
 						args.Add(user);
 					else
 						args.Add(await this.Client.GetUserAsync((ulong)option.Value));
 				}
 				else if (parameter.ParameterType == typeof(DiscordChannel))
 				{
 					//Checks through resolved
 					if (e.Interaction.Data.Resolved.Channels != null &&
 						e.Interaction.Data.Resolved.Channels.TryGetValue((ulong)option.Value, out var channel))
 						args.Add(channel);
 					else
 						args.Add(e.Interaction.Guild.GetChannel((ulong)option.Value));
 				}
 				else if (parameter.ParameterType == typeof(DiscordRole))
 				{
 					//Checks through resolved
 					if (e.Interaction.Data.Resolved.Roles != null &&
 						e.Interaction.Data.Resolved.Roles.TryGetValue((ulong)option.Value, out var role))
 						args.Add(role);
 					else
 						args.Add(e.Interaction.Guild.GetRole((ulong)option.Value));
 				}
 				else if (parameter.ParameterType == typeof(SnowflakeObject))
 				{
 					//Checks through resolved
 					if (e.Interaction.Data.Resolved.Roles != null && e.Interaction.Data.Resolved.Roles.TryGetValue((ulong)option.Value, out var role))
 						args.Add(role);
 					else if (e.Interaction.Data.Resolved.Members != null && e.Interaction.Data.Resolved.Members.TryGetValue((ulong)option.Value, out var member))
 						args.Add(member);
 					else if (e.Interaction.Data.Resolved.Users != null && e.Interaction.Data.Resolved.Users.TryGetValue((ulong)option.Value, out var user))
 						args.Add(user);
 					else
 						throw new ArgumentException("Error resolving mentionable option.");
 				}
 				else
 					throw new ArgumentException($"Error resolving interaction.");
 			}
 		}
 
 		return args;
 	}
 
 	/// <summary>
 	/// Runs the pre-execution checks.
 	/// </summary>
 	/// <param name="method">The method info.</param>
 	/// <param name="context">The base context.</param>
 	private async Task RunPreexecutionChecksAsync(MethodInfo method, BaseContext context)
 	{
 		if (context is InteractionContext ctx)
 		{
 			//Gets all attributes from parent classes as well and stuff
 			var attributes = new List<SlashCheckBaseAttribute>();
 			attributes.AddRange(method.GetCustomAttributes<SlashCheckBaseAttribute>(true));
 			attributes.AddRange(method.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 			if (method.DeclaringType.DeclaringType != null)
 			{
 				attributes.AddRange(method.DeclaringType.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 				if (method.DeclaringType.DeclaringType.DeclaringType != null)
 				{
 					attributes.AddRange(method.DeclaringType.DeclaringType.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 				}
 			}
 
 			var dict = new Dictionary<SlashCheckBaseAttribute, bool>();
 			foreach (var att in attributes)
 			{
 				//Runs the check and adds the result to a list
 				var result = await att.ExecuteChecksAsync(ctx);
 				dict.Add(att, result);
 			}
 
 			//Checks if any failed, and throws an exception
 			if (dict.Any(x => x.Value == false))
 				throw new SlashExecutionChecksFailedException { FailedChecks = dict.Where(x => x.Value == false).Select(x => x.Key).ToList() };
 		}
 		if (context is ContextMenuContext cMctx)
 		{
 			var attributes = new List<ContextMenuCheckBaseAttribute>();
 			attributes.AddRange(method.GetCustomAttributes<ContextMenuCheckBaseAttribute>(true));
 			attributes.AddRange(method.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 			if (method.DeclaringType.DeclaringType != null)
 			{
 				attributes.AddRange(method.DeclaringType.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 				if (method.DeclaringType.DeclaringType.DeclaringType != null)
 				{
 					attributes.AddRange(method.DeclaringType.DeclaringType.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 				}
 			}
 
 			var dict = new Dictionary<ContextMenuCheckBaseAttribute, bool>();
 			foreach (var att in attributes)
 			{
 				//Runs the check and adds the result to a list
 				var result = await att.ExecuteChecksAsync(cMctx);
 				dict.Add(att, result);
 			}
 
 			//Checks if any failed, and throws an exception
 			if (dict.Any(x => x.Value == false))
 				throw new ContextMenuExecutionChecksFailedException { FailedChecks = dict.Where(x => x.Value == false).Select(x => x.Key).ToList() };
 		}
 	}
 
 	/// <summary>
 	/// Gets the choice attributes from choice provider.
 	/// </summary>
 	/// <param name="customAttributes">The custom attributes.</param>
 	/// <param name="guildId">The optional guild id</param>
 	private static async Task<List<DiscordApplicationCommandOptionChoice>> GetChoiceAttributesFromProvider(IEnumerable<ChoiceProviderAttribute> customAttributes, ulong? guildId = null)
 	{
 		var choices = new List<DiscordApplicationCommandOptionChoice>();
 		foreach (var choiceProviderAttribute in customAttributes)
 		{
 			var method = choiceProviderAttribute.ProviderType.GetMethod(nameof(IChoiceProvider.Provider));
 
 			if (method == null)
 				throw new ArgumentException("ChoiceProviders must inherit from IChoiceProvider.");
 			else
 			{
 				var instance = Activator.CreateInstance(choiceProviderAttribute.ProviderType);
 
 				// Abstract class offers more properties that can be set
 				if (choiceProviderAttribute.ProviderType.IsSubclassOf(typeof(ChoiceProvider)))
 				{
 					choiceProviderAttribute.ProviderType.GetProperty(nameof(ChoiceProvider.GuildId))
 						?.SetValue(instance, guildId);
 
 					choiceProviderAttribute.ProviderType.GetProperty(nameof(ChoiceProvider.Services))
 						?.SetValue(instance, Configuration.ServiceProvider);
 				}
 
 				//Gets the choices from the method
 				var result = await (Task<IEnumerable<DiscordApplicationCommandOptionChoice>>)method.Invoke(instance, null);
 
 				if (result.Any())
 				{
 					choices.AddRange(result);
 				}
 			}
 		}
 
 		return choices;
 	}
 
 	/// <summary>
 	/// Gets the choice attributes from enum parameter.
 	/// </summary>
 	/// <param name="enumParam">The enum parameter.</param>
 	private static List<DiscordApplicationCommandOptionChoice> GetChoiceAttributesFromEnumParameter(Type enumParam)
 	{
 		var choices = new List<DiscordApplicationCommandOptionChoice>();
 		foreach (Enum enumValue in Enum.GetValues(enumParam))
 		{
 			choices.Add(new DiscordApplicationCommandOptionChoice(enumValue.GetName(), enumValue.ToString()));
 		}
 		return choices;
 	}
 
 	/// <summary>
 	/// Gets the parameter type.
 	/// </summary>
 	/// <param name="type">The type.</param>
 	private static ApplicationCommandOptionType GetParameterType(Type type)
 	{
 		var parameterType = type == typeof(string)
 			? ApplicationCommandOptionType.String
 			: type == typeof(long) || type == typeof(long?) || type == typeof(int) || type == typeof(int?)
 			? ApplicationCommandOptionType.Integer
 			: type == typeof(bool) || type == typeof(bool?)
 			? ApplicationCommandOptionType.Boolean
 			: type == typeof(double) || type == typeof(double?)
 			? ApplicationCommandOptionType.Number
 			: type == typeof(DiscordAttachment)
 			? ApplicationCommandOptionType.Attachment
 			: type == typeof(DiscordChannel)
 			? ApplicationCommandOptionType.Channel
 			: type == typeof(DiscordUser)
 			? ApplicationCommandOptionType.User
 			: type == typeof(DiscordRole)
 			? ApplicationCommandOptionType.Role
 			: type == typeof(SnowflakeObject)
 			? ApplicationCommandOptionType.Mentionable
 			: type.IsEnum
 			? ApplicationCommandOptionType.String
 			: throw new ArgumentException("Cannot convert type! Argument types must be string, int, long, bool, double, DiscordChannel, DiscordUser, DiscordRole, SnowflakeObject, DiscordAttachment or an Enum.");
 		return parameterType;
 	}
 
 	/// <summary>
 	/// Gets the choice attributes from parameter.
 	/// </summary>
 	/// <param name="choiceAttributes">The choice attributes.</param>
 	private static List<DiscordApplicationCommandOptionChoice> GetChoiceAttributesFromParameter(IEnumerable<ChoiceAttribute> choiceAttributes) =>
 		!choiceAttributes.Any()
 			? null
 			: choiceAttributes.Select(att => new DiscordApplicationCommandOptionChoice(att.Name, att.Value)).ToList();
 
 	/// <summary>
 	/// Parses the parameters.
 	/// </summary>
 	/// <param name="parameters">The parameters.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	internal static async Task<List<DiscordApplicationCommandOption>> ParseParametersAsync(IEnumerable<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<MinimumValueAttribute>()?.Value ?? null;
 			var maximumValue = parameter.GetCustomAttribute<MaximumValueAttribute>()?.Value ?? null;
 			var minimumLength = parameter.GetCustomAttribute<MinimumLengthAttribute>()?.Value ?? null;
 			var maximumLength = parameter.GetCustomAttribute<MaximumLengthAttribute>()?.Value ?? null;
 			var channelTypes = parameter.GetCustomAttribute<ChannelTypesAttribute>()?.ChannelTypes ?? 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);
 
 			if (parameterType == ApplicationCommandOptionType.String)
 			{
 				minimumValue = null;
 				maximumValue = null;
 			}
 			else if (parameterType == ApplicationCommandOptionType.Integer || parameterType == ApplicationCommandOptionType.Number)
 			{
 				minimumLength = null;
 				maximumLength = null;
 			}
 
 			if (parameterType != ApplicationCommandOptionType.Channel)
 				channelTypes = null;
 
 			//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);
 			}
 
 			options.Add(new DiscordApplicationCommandOption(optionAttribute.Name, optionAttribute.Description, parameterType, !parameter.IsOptional, choices, null, channelTypes, optionAttribute.Autocomplete, minimumValue, maximumValue, minimumLength: minimumLength, maximumLength: maximumLength));
 		}
 
 		return options;
 	}
 	/*
 	/// <summary>
 	/// <para>Refreshes your commands, used for refreshing choice providers or applying commands registered after the ready event on the discord client.</para>
 	/// <para>Not recommended and should be avoided since it can make slash commands be unresponsive for a while.</para>
 	/// </summary>
 	public async Task RefreshCommandsAsync()
 	{
 		s_commandMethods.Clear();
 		s_groupCommands.Clear();
 		s_subGroupCommands.Clear();
 		s_registeredCommands.Clear();
 		s_contextMenuCommands.Clear();
 		GlobalDiscordCommands.Clear();
 		GuildDiscordCommands.Clear();
 		GuildCommandsInternal.Clear();
 		GlobalCommandsInternal.Clear();
 		GlobalDiscordCommands = null;
 		GuildDiscordCommands = null;
 		s_errored = false;
 
 		/*if (Configuration != null && Configuration.EnableDefaultHelp)
 		{
 			this._updateList.RemoveAll(x => x.Value.Type == typeof(DefaultHelpModule));
 		}*/
 	/*
 		await this.UpdateAsync();
 	}*/
 
 	/// <summary>
 	/// Fires when the execution of a slash command fails.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, SlashCommandErrorEventArgs> SlashCommandErrored
 	{
 		add => this._slashError.Register(value);
 		remove => this._slashError.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, SlashCommandErrorEventArgs> _slashError;
 
 	/// <summary>
 	/// Fires when the execution of a slash command is successful.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, SlashCommandExecutedEventArgs> SlashCommandExecuted
 	{
 		add => this._slashExecuted.Register(value);
 		remove => this._slashExecuted.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, SlashCommandExecutedEventArgs> _slashExecuted;
 
 	/// <summary>
 	/// Fires when the execution of a context menu fails.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ContextMenuErrorEventArgs> ContextMenuErrored
 	{
 		add => this._contextMenuErrored.Register(value);
 		remove => this._contextMenuErrored.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ContextMenuErrorEventArgs> _contextMenuErrored;
 
 	/// <summary>
 	/// Fire when the execution of a context menu is successful.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ContextMenuExecutedEventArgs> ContextMenuExecuted
 	{
 		add => this._contextMenuExecuted.Register(value);
 		remove => this._contextMenuExecuted.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ContextMenuExecutedEventArgs> _contextMenuExecuted;
-
-	public override void Dispose()
-	{
-		this.Client.InteractionCreated -= this.InteractionHandler;
-		this.Client.ContextMenuInteractionCreated -= this.ContextMenuHandler;
-		GC.SuppressFinalize(this);
-	}
 }
 
 /// <summary>
 /// Holds configuration data for setting up an application command.
 /// </summary>
 internal class ApplicationCommandsModuleConfiguration
 {
 	/// <summary>
 	/// The type of the command module.
 	/// </summary>
 	public Type Type { get; }
 
 	/// <summary>
 	/// The translation setup.
 	/// </summary>
 	public Action<ApplicationCommandsTranslationContext> Translations { get; }
 
 	/// <summary>
 	/// Creates a new command configuration.
 	/// </summary>
 	/// <param name="type">The type of the command module.</param>
 	/// <param name="translations">The translation setup callback.</param>
 	public ApplicationCommandsModuleConfiguration(Type type, Action<ApplicationCommandsTranslationContext> translations = null)
 	{
 		this.Type = type;
 		this.Translations = translations;
 	}
 }
 
 /// <summary>
 /// Links a command to its original command module.
 /// </summary>
 internal class ApplicationCommandSourceLink
 {
 	/// <summary>
 	/// The command.
 	/// </summary>
 	public DiscordApplicationCommand ApplicationCommand { get; set; }
 
 	/// <summary>
 	/// The base/root module the command is contained in.
 	/// </summary>
 	public Type RootCommandContainerType { get; set; }
 
 	/// <summary>
 	/// The direct group the command is contained in.
 	/// </summary>
 	public Type CommandContainerType { get; set; }
 }
 
 /// <summary>
 /// The command method.
 /// </summary>
 internal class CommandMethod
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the method.
 	/// </summary>
 	public MethodInfo Method { get; set; }
 }
 
 /// <summary>
 /// The group command.
 /// </summary>
 internal class GroupCommand
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the methods.
 	/// </summary>
 	public List<KeyValuePair<string, MethodInfo>> Methods { get; set; } = null;
 }
 
 /// <summary>
 /// The sub group command.
 /// </summary>
 internal class SubGroupCommand
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the sub commands.
 	/// </summary>
 	public List<GroupCommand> SubCommands { get; set; } = new();
 }
 
 /// <summary>
 /// The context menu command.
 /// </summary>
 internal class ContextMenuCommand
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the method.
 	/// </summary>
 	public MethodInfo Method { get; set; }
 }
 
 #region Default Help
 /// <summary>
 /// Represents the default help module.
 /// </summary>
 internal class DefaultHelpModule : ApplicationCommandsModule
 {
 	public class DefaultHelpAutoCompleteProvider : IAutocompleteProvider
 	{
 		public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 		{
 			var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 
 			IEnumerable<DiscordApplicationCommand> slashCommands = null;
 			var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 			if (context.Guild != null)
 			{
 				var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 				slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First())
 					.Where(ac => ac.Name.StartsWith(context.Options[0].Value.ToString(), StringComparison.OrdinalIgnoreCase))
 					.ToList();
 			}
 			else
 			{
 				await Task.WhenAll(globalCommandsTask);
 				slashCommands = globalCommandsTask.Result
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First())
 					.Where(ac => ac.Name.StartsWith(context.Options[0].Value.ToString(), StringComparison.OrdinalIgnoreCase))
 					.ToList();
 			}
 
 			foreach (var sc in slashCommands.Take(25))
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice(sc.Name, sc.Name.Trim()));
 			}
 			return options.AsEnumerable();
 		}
 	}
 
 	public class DefaultHelpAutoCompleteLevelOneProvider : IAutocompleteProvider
 	{
 		public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 		{
 			var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 			IEnumerable<DiscordApplicationCommand> slashCommands = null;
 			var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 			if (context.Guild != null)
 			{
 				var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 				slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 			else
 			{
 				await Task.WhenAll(globalCommandsTask);
 				slashCommands = globalCommandsTask.Result
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 
 			var command = slashCommands.FirstOrDefault(ac =>
 				ac.Name.Equals(context.Options[0].Value.ToString().Trim(),StringComparison.OrdinalIgnoreCase));
 			if (command is null || command.Options is null)
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 			}
 			else
 			{
 				var opt = command.Options.Where(c => c.Type is ApplicationCommandOptionType.SubCommandGroup or ApplicationCommandOptionType.SubCommand
 													 && c.Name.StartsWith(context.Options[1].Value.ToString(), StringComparison.InvariantCultureIgnoreCase)).ToList();
 				foreach (var option in opt.Take(25))
 				{
 					options.Add(new DiscordApplicationCommandAutocompleteChoice(option.Name, option.Name.Trim()));
 				}
 			}
 			return options.AsEnumerable();
 		}
 	}
 
 	public class DefaultHelpAutoCompleteLevelTwoProvider : IAutocompleteProvider
 	{
 		public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 		{
 			var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 			IEnumerable<DiscordApplicationCommand> slashCommands = null;
 			var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 			if (context.Guild != null)
 			{
 				var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 				slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 			else
 			{
 				await Task.WhenAll(globalCommandsTask);
 				slashCommands = globalCommandsTask.Result
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 
 			var command = slashCommands.FirstOrDefault(ac =>
 				ac.Name.Equals(context.Options[0].Value.ToString().Trim(), StringComparison.OrdinalIgnoreCase));
 			if (command.Options is null)
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 				return options.AsEnumerable();
 			}
 			var foundCommand = command.Options.FirstOrDefault(op => op.Name.Equals(context.Options[1].Value.ToString().Trim(), StringComparison.OrdinalIgnoreCase));
 			if (foundCommand is null || foundCommand.Options is null)
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 			}
 			else
 			{
 				var opt = foundCommand.Options.Where(x => x.Type == ApplicationCommandOptionType.SubCommand &&
 														  x.Name.StartsWith(context.Options[2].Value.ToString(), StringComparison.OrdinalIgnoreCase)).ToList();
 				foreach (var option in opt.Take(25))
 				{
 					options.Add(new DiscordApplicationCommandAutocompleteChoice(option.Name, option.Name.Trim()));
 				}
 			}
 			return options.AsEnumerable();
 		}
 	}
 
 	[SlashCommand("help", "Displays command help")]
 	internal async Task DefaultHelpAsync(InteractionContext ctx,
 		[Autocomplete(typeof(DefaultHelpAutoCompleteProvider))]
 		[Option("option_one", "top level command to provide help for", true)] string commandName,
 		[Autocomplete(typeof(DefaultHelpAutoCompleteLevelOneProvider))]
 		[Option("option_two", "subgroup or command to provide help for", true)] string commandOneName = null,
 		[Autocomplete(typeof(DefaultHelpAutoCompleteLevelTwoProvider))]
 		[Option("option_three", "command to provide help for", true)] string commandTwoName = null)
 	{
 		List<DiscordApplicationCommand> applicationCommands = null;
 		var globalCommandsTask = ctx.Client.GetGlobalApplicationCommandsAsync();
 		if (ctx.Guild != null)
 		{
 			var guildCommandsTask= ctx.Client.GetGuildApplicationCommandsAsync(ctx.Guild.Id);
 			await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 			applicationCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 				.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 				.GroupBy(ac => ac.Name).Select(x => x.First())
 				.ToList();
 		}
 		else
 		{
 			await Task.WhenAll(globalCommandsTask);
 			applicationCommands = globalCommandsTask.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").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 subCommandParent = commandsWithSubCommands.FirstOrDefault(cm => cm.Name.Equals(commandName,StringComparison.OrdinalIgnoreCase));
 			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 = $"{subCommandParent.Mention.Replace(subCommandParent.Name, $"{subCommandParent.Name} {cmdParent.Name} {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(option.Description ?? "No description provided.").Append('\n');
 
 				sb.Append('\n');
 				discordEmbed.AddField(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 			}
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 				new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 		}
 		else if (commandOneName is not null && commandTwoName is null && !commandOneName.Equals("no_options_for_this_command"))
 		{
 			var commandsWithOptions = applicationCommands.FindAll(ac => ac.Options is not null && ac.Options.All(op => op.Type == ApplicationCommandOptionType.SubCommand));
 			var subCommandParent = commandsWithOptions.FirstOrDefault(cm => cm.Name.Equals(commandName,StringComparison.OrdinalIgnoreCase));
 			var subCommand = subCommandParent.Options.FirstOrDefault(op => op.Name.Equals(commandOneName,StringComparison.OrdinalIgnoreCase));
 			var discordEmbed = new DiscordEmbedBuilder
 			{
 				Title = "Help",
 				Description = $"{subCommandParent.Mention.Replace(subCommandParent.Name, $"{subCommandParent.Name} {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(option.Description ?? "No description provided.").Append('\n');
 
 				sb.Append('\n');
 				discordEmbed.AddField(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 			}
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 				new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 		}
 		else
 		{
 			var command = applicationCommands.FirstOrDefault(cm => cm.Name.Equals(commandName, StringComparison.OrdinalIgnoreCase));
 			if (command is null)
 			{
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder()
 						.WithContent($"No command called {commandName} in guild {ctx.Guild.Name}").AsEphemeral(true));
 				return;
 			}
 			var discordEmbed = new DiscordEmbedBuilder
 			{
 				Title = "Help",
 				Description = $"{command.Mention}: {command.Description ?? "No description provided."}"
 			}.AddField(new DiscordEmbedField("Command is NSFW", command.IsNsfw.ToString()));
 			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(option.Description ?? "No description provided.").Append('\n');
 
 				sb.Append('\n');
 				discordEmbed.AddField(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 			}
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 				new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 		}
 	}
 }
 #endregion
diff --git a/DisCatSharp.CommandsNext/CommandsNextExtension.cs b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
index b7c101900..e9447807a 100644
--- a/DisCatSharp.CommandsNext/CommandsNextExtension.cs
+++ b/DisCatSharp.CommandsNext/CommandsNextExtension.cs
@@ -1,1094 +1,1086 @@
 // 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.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 
 using DisCatSharp.CommandsNext.Attributes;
 using DisCatSharp.CommandsNext.Builders;
 using DisCatSharp.CommandsNext.Converters;
 using DisCatSharp.CommandsNext.Entities;
 using DisCatSharp.CommandsNext.Exceptions;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.CommandsNext;
 
 /// <summary>
 /// This is the class which handles command registration, management, and execution.
 /// </summary>
 public class CommandsNextExtension : BaseExtension
 {
 	/// <summary>
 	/// Gets the config.
 	/// </summary>
 	private readonly CommandsNextConfiguration _config;
 
 	/// <summary>
 	/// Gets the help formatter.
 	/// </summary>
 	private readonly HelpFormatterFactory _helpFormatter;
 
 	/// <summary>
 	/// Gets the convert generic.
 	/// </summary>
 	private readonly MethodInfo _convertGeneric;
 
 	/// <summary>
 	/// Gets the user friendly type names.
 	/// </summary>
 	private readonly Dictionary<Type, string> _userFriendlyTypeNames;
 	/// <summary>
 	/// Gets the argument converters.
 	/// </summary>
 	internal Dictionary<Type, IArgumentConverter> ArgumentConverters { get; }
 
 	/// <summary>
 	/// Gets the service provider this CommandsNext module was configured with.
 	/// </summary>
 	public IServiceProvider Services
 		=> this._config.ServiceProvider;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="CommandsNextExtension"/> class.
 	/// </summary>
 	/// <param name="cfg">The cfg.</param>
 	internal CommandsNextExtension(CommandsNextConfiguration cfg)
 	{
 		this._config = new CommandsNextConfiguration(cfg);
 		this._topLevelCommands = new Dictionary<string, Command>();
 		this._registeredCommandsLazy = new Lazy<IReadOnlyDictionary<string, Command>>(() => new ReadOnlyDictionary<string, Command>(this._topLevelCommands));
 		this._helpFormatter = new HelpFormatterFactory();
 		this._helpFormatter.SetFormatterType<DefaultHelpFormatter>();
 
 		this.ArgumentConverters = new Dictionary<Type, IArgumentConverter>
 		{
 			[typeof(string)] = new StringConverter(),
 			[typeof(bool)] = new BoolConverter(),
 			[typeof(sbyte)] = new Int8Converter(),
 			[typeof(byte)] = new Uint8Converter(),
 			[typeof(short)] = new Int16Converter(),
 			[typeof(ushort)] = new Uint16Converter(),
 			[typeof(int)] = new Int32Converter(),
 			[typeof(uint)] = new Uint32Converter(),
 			[typeof(long)] = new Int64Converter(),
 			[typeof(ulong)] = new Uint64Converter(),
 			[typeof(float)] = new Float32Converter(),
 			[typeof(double)] = new Float64Converter(),
 			[typeof(decimal)] = new Float128Converter(),
 			[typeof(DateTime)] = new DateTimeConverter(),
 			[typeof(DateTimeOffset)] = new DateTimeOffsetConverter(),
 			[typeof(TimeSpan)] = new TimeSpanConverter(),
 			[typeof(Uri)] = new UriConverter(),
 			[typeof(DiscordUser)] = new DiscordUserConverter(),
 			[typeof(DiscordMember)] = new DiscordMemberConverter(),
 			[typeof(DiscordRole)] = new DiscordRoleConverter(),
 			[typeof(DiscordChannel)] = new DiscordChannelConverter(),
 			[typeof(DiscordGuild)] = new DiscordGuildConverter(),
 			[typeof(DiscordMessage)] = new DiscordMessageConverter(),
 			[typeof(DiscordEmoji)] = new DiscordEmojiConverter(),
 			[typeof(DiscordThreadChannel)] = new DiscordThreadChannelConverter(),
 			[typeof(DiscordInvite)] = new DiscordInviteConverter(),
 			[typeof(DiscordColor)] = new DiscordColorConverter(),
 			[typeof(DiscordScheduledEvent)] = new DiscordScheduledEventConverter(),
 		};
 
 		this._userFriendlyTypeNames = new Dictionary<Type, string>()
 		{
 			[typeof(string)] = "string",
 			[typeof(bool)] = "boolean",
 			[typeof(sbyte)] = "signed byte",
 			[typeof(byte)] = "byte",
 			[typeof(short)] = "short",
 			[typeof(ushort)] = "unsigned short",
 			[typeof(int)] = "int",
 			[typeof(uint)] = "unsigned int",
 			[typeof(long)] = "long",
 			[typeof(ulong)] = "unsigned long",
 			[typeof(float)] = "float",
 			[typeof(double)] = "double",
 			[typeof(decimal)] = "decimal",
 			[typeof(DateTime)] = "date and time",
 			[typeof(DateTimeOffset)] = "date and time",
 			[typeof(TimeSpan)] = "time span",
 			[typeof(Uri)] = "URL",
 			[typeof(DiscordUser)] = "user",
 			[typeof(DiscordMember)] = "member",
 			[typeof(DiscordRole)] = "role",
 			[typeof(DiscordChannel)] = "channel",
 			[typeof(DiscordGuild)] = "guild",
 			[typeof(DiscordMessage)] = "message",
 			[typeof(DiscordEmoji)] = "emoji",
 			[typeof(DiscordThreadChannel)] = "thread",
 			[typeof(DiscordInvite)] = "invite",
 			[typeof(DiscordColor)] = "color",
 			[typeof(DiscordScheduledEvent)] = "event"
 		};
 
 		foreach (var xt in this.ArgumentConverters.Keys.ToArray())
 		{
 			var xti = xt.GetTypeInfo();
 			if (!xti.IsValueType)
 				continue;
 
 			var xcvt = typeof(NullableConverter<>).MakeGenericType(xt);
 			var xnt = typeof(Nullable<>).MakeGenericType(xt);
 			if (this.ArgumentConverters.ContainsKey(xcvt))
 				continue;
 
 			var xcv = Activator.CreateInstance(xcvt) as IArgumentConverter;
 			this.ArgumentConverters[xnt] = xcv;
 			this._userFriendlyTypeNames[xnt] = this._userFriendlyTypeNames[xt];
 		}
 
 		var t = this.GetType();
 		var ms = t.GetTypeInfo().DeclaredMethods;
 		var m = ms.FirstOrDefault(xm => xm.Name == "ConvertArgumentToObj" && xm.ContainsGenericParameters && !xm.IsStatic && xm.IsPrivate);
 		this._convertGeneric = m;
 	}
 
 	/// <summary>
 	/// Sets the help formatter to use with the default help command.
 	/// </summary>
 	/// <typeparam name="T">Type of the formatter to use.</typeparam>
 	public void SetHelpFormatter<T>() where T : BaseHelpFormatter => this._helpFormatter.SetFormatterType<T>();
 
 	#region DiscordClient Registration
 	/// <summary>
 	/// DO NOT USE THIS MANUALLY.
 	/// </summary>
 	/// <param name="client">DO NOT USE THIS MANUALLY.</param>
 	/// <exception cref="System.InvalidOperationException"/>
 	protected internal override void Setup(DiscordClient client)
 	{
 		if (this.Client != null)
 			throw new InvalidOperationException("What did I tell you?");
 
 		this.Client = client;
 
 		this._executed = new AsyncEvent<CommandsNextExtension, CommandExecutionEventArgs>("COMMAND_EXECUTED", TimeSpan.Zero, this.Client.EventErrorHandler);
 		this._error = new AsyncEvent<CommandsNextExtension, CommandErrorEventArgs>("COMMAND_ERRORED", TimeSpan.Zero, this.Client.EventErrorHandler);
 
 		if (this._config.UseDefaultCommandHandler)
 			this.Client.MessageCreated += this.HandleCommandsAsync;
 		else
 			this.Client.Logger.LogWarning(CommandsNextEvents.Misc, "Not attaching default command handler - if this is intentional, you can ignore this message");
 
 		if (this._config.EnableDefaultHelp)
 		{
 			this.RegisterCommands(typeof(DefaultHelpModule), null, null, out var tcmds);
 
 			if (this._config.DefaultHelpChecks != null)
 			{
 				var checks = this._config.DefaultHelpChecks.ToArray();
 
 				foreach (var cb in tcmds)
 					cb.WithExecutionChecks(checks);
 			}
 
 			if (tcmds != null)
 				foreach (var xc in tcmds)
 					this.AddToCommandDictionary(xc.Build(null));
 		}
 
 	}
 	#endregion
 
 	#region Command Handling
 	/// <summary>
 	/// Handles the commands async.
 	/// </summary>
 	/// <param name="sender">The sender.</param>
 	/// <param name="e">The e.</param>
 	/// <returns>A Task.</returns>
 	private async Task HandleCommandsAsync(DiscordClient sender, MessageCreateEventArgs e)
 	{
 		if (e.Author.IsBot) // bad bot
 			return;
 
 		if (!this._config.EnableDms && e.Channel.IsPrivate)
 			return;
 
 		var mpos = -1;
 		if (this._config.EnableMentionPrefix)
 			mpos = e.Message.GetMentionPrefixLength(this.Client.CurrentUser);
 
 		if (this._config.StringPrefixes?.Any() == true)
 			foreach (var pfix in this._config.StringPrefixes)
 				if (mpos == -1 && !string.IsNullOrWhiteSpace(pfix))
 					mpos = e.Message.GetStringPrefixLength(pfix, this._config.CaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase);
 
 		if (mpos == -1 && this._config.PrefixResolver != null)
 			mpos = await this._config.PrefixResolver(e.Message).ConfigureAwait(false);
 
 		if (mpos == -1)
 			return;
 
 		var pfx = e.Message.Content[..mpos];
 		var cnt = e.Message.Content[mpos..];
 
 		var __ = 0;
 		var fname = cnt.ExtractNextArgument(ref __);
 
 		var cmd = this.FindCommand(cnt, out var args);
 		var ctx = this.CreateContext(e.Message, pfx, cmd, args);
 		if (cmd == null)
 		{
 			await this._error.InvokeAsync(this, new CommandErrorEventArgs(this.Client.ServiceProvider) { Context = ctx, Exception = new CommandNotFoundException(fname) }).ConfigureAwait(false);
 			return;
 		}
 
 		_ = Task.Run(async () => await this.ExecuteCommandAsync(ctx).ConfigureAwait(false));
 	}
 
 	/// <summary>
 	/// Finds a specified command by its qualified name, then separates arguments.
 	/// </summary>
 	/// <param name="commandString">Qualified name of the command, optionally with arguments.</param>
 	/// <param name="rawArguments">Separated arguments.</param>
 	/// <returns>Found command or null if none was found.</returns>
 	public Command FindCommand(string commandString, out string rawArguments)
 	{
 		rawArguments = null;
 
 		var ignoreCase = !this._config.CaseSensitive;
 		var pos = 0;
 		var next = commandString.ExtractNextArgument(ref pos);
 		if (next == null)
 			return null;
 
 		if (!this.RegisteredCommands.TryGetValue(next, out var cmd))
 		{
 			if (!ignoreCase)
 				return null;
 
 			next = next.ToLowerInvariant();
 			var cmdKvp = this.RegisteredCommands.FirstOrDefault(x => x.Key.ToLowerInvariant() == next);
 			if (cmdKvp.Value == null)
 				return null;
 
 			cmd = cmdKvp.Value;
 		}
 
 		if (cmd is not CommandGroup)
 		{
 			rawArguments = commandString[pos..].Trim();
 			return cmd;
 		}
 
 		while (cmd is CommandGroup)
 		{
 			var cm2 = cmd as CommandGroup;
 			var oldPos = pos;
 			next = commandString.ExtractNextArgument(ref pos);
 			if (next == null)
 				break;
 
 			if (ignoreCase)
 			{
 				next = next.ToLowerInvariant();
 				cmd = cm2.Children.FirstOrDefault(x => x.Name.ToLowerInvariant() == next || x.Aliases?.Any(xx => xx.ToLowerInvariant() == next) == true);
 			}
 			else
 			{
 				cmd = cm2.Children.FirstOrDefault(x => x.Name == next || x.Aliases?.Contains(next) == true);
 			}
 
 			if (cmd == null)
 			{
 				cmd = cm2;
 				pos = oldPos;
 				break;
 			}
 		}
 
 		rawArguments = commandString[pos..].Trim();
 		return cmd;
 	}
 
 	/// <summary>
 	/// Creates a command execution context from specified arguments.
 	/// </summary>
 	/// <param name="msg">Message to use for context.</param>
 	/// <param name="prefix">Command prefix, used to execute commands.</param>
 	/// <param name="cmd">Command to execute.</param>
 	/// <param name="rawArguments">Raw arguments to pass to command.</param>
 	/// <returns>Created command execution context.</returns>
 	public CommandContext CreateContext(DiscordMessage msg, string prefix, Command cmd, string rawArguments = null)
 	{
 		var ctx = new CommandContext
 		{
 			Client = this.Client,
 			Command = cmd,
 			Message = msg,
 			Config = this._config,
 			RawArgumentString = rawArguments ?? "",
 			Prefix = prefix,
 			CommandsNext = this,
 			Services = this.Services
 		};
 
 		if (cmd != null && (cmd.Module is TransientCommandModule || cmd.Module == null))
 		{
 			var scope = ctx.Services.CreateScope();
 			ctx.ServiceScopeContext = new CommandContext.ServiceContext(ctx.Services, scope);
 			ctx.Services = scope.ServiceProvider;
 		}
 
 		return ctx;
 	}
 
 	/// <summary>
 	/// Executes specified command from given context.
 	/// </summary>
 	/// <param name="ctx">Context to execute command from.</param>
 	/// <returns></returns>
 	public async Task ExecuteCommandAsync(CommandContext ctx)
 	{
 		try
 		{
 			var cmd = ctx.Command;
 			await this.RunAllChecksAsync(cmd, ctx).ConfigureAwait(false);
 
 			var res = await cmd.ExecuteAsync(ctx).ConfigureAwait(false);
 
 			if (res.IsSuccessful)
 				await this._executed.InvokeAsync(this, new CommandExecutionEventArgs(this.Client.ServiceProvider) { Context = res.Context }).ConfigureAwait(false);
 			else
 				await this._error.InvokeAsync(this, new CommandErrorEventArgs(this.Client.ServiceProvider) { Context = res.Context, Exception = res.Exception }).ConfigureAwait(false);
 		}
 		catch (Exception ex)
 		{
 			await this._error.InvokeAsync(this, new CommandErrorEventArgs(this.Client.ServiceProvider) { Context = ctx, Exception = ex }).ConfigureAwait(false);
 		}
 		finally
 		{
 			if (ctx.ServiceScopeContext.IsInitialized)
 				ctx.ServiceScopeContext.Dispose();
 		}
 	}
 
 	/// <summary>
 	/// Runs the all checks async.
 	/// </summary>
 	/// <param name="cmd">The cmd.</param>
 	/// <param name="ctx">The ctx.</param>
 	/// <returns>A Task.</returns>
 	private async Task RunAllChecksAsync(Command cmd, CommandContext ctx)
 	{
 		if (cmd.Parent != null)
 			await this.RunAllChecksAsync(cmd.Parent, ctx).ConfigureAwait(false);
 
 		var fchecks = await cmd.RunChecksAsync(ctx, false).ConfigureAwait(false);
 		if (fchecks.Any())
 			throw new ChecksFailedException(cmd, ctx, fchecks);
 	}
 	#endregion
 
 	#region Command Registration
 	/// <summary>
 	/// Gets a dictionary of registered top-level commands.
 	/// </summary>
 	public IReadOnlyDictionary<string, Command> RegisteredCommands
 		=> this._registeredCommandsLazy.Value;
 
 	/// <summary>
 	/// Gets or sets the top level commands.
 	/// </summary>
 	private readonly Dictionary<string, Command> _topLevelCommands;
 	private readonly Lazy<IReadOnlyDictionary<string, Command>> _registeredCommandsLazy;
 
 	/// <summary>
 	/// Registers all commands from a given assembly. The command classes need to be public to be considered for registration.
 	/// </summary>
 	/// <param name="assembly">Assembly to register commands from.</param>
 	public void RegisterCommands(Assembly assembly)
 	{
 		var types = assembly.ExportedTypes.Where(xt =>
 		{
 			var xti = xt.GetTypeInfo();
 			return xti.IsModuleCandidateType() && !xti.IsNested;
 		});
 		foreach (var xt in types)
 			this.RegisterCommands(xt);
 	}
 
 	/// <summary>
 	/// Registers all commands from a given command class.
 	/// </summary>
 	/// <typeparam name="T">Class which holds commands to register.</typeparam>
 	public void RegisterCommands<T>() where T : BaseCommandModule
 	{
 		var t = typeof(T);
 		this.RegisterCommands(t);
 	}
 
 	/// <summary>
 	/// Registers all commands from a given command class.
 	/// </summary>
 	/// <param name="t">Type of the class which holds commands to register.</param>
 	public void RegisterCommands(Type t)
 	{
 		if (t == null)
 			throw new ArgumentNullException(nameof(t), "Type cannot be null.");
 
 		if (!t.IsModuleCandidateType())
 			throw new ArgumentNullException(nameof(t), "Type must be a class, which cannot be abstract or static.");
 
 		this.RegisterCommands(t, null, null, out var tempCommands);
 
 		if (tempCommands != null)
 			foreach (var command in tempCommands)
 				this.AddToCommandDictionary(command.Build(null));
 	}
 
 	/// <summary>
 	/// Registers the commands.
 	/// </summary>
 	/// <param name="t">The type.</param>
 	/// <param name="currentParent">The current parent.</param>
 	/// <param name="inheritedChecks">The inherited checks.</param>
 	/// <param name="foundCommands">The found commands.</param>
 	private void RegisterCommands(Type t, CommandGroupBuilder currentParent, IEnumerable<CheckBaseAttribute> inheritedChecks, out List<CommandBuilder> foundCommands)
 	{
 		var ti = t.GetTypeInfo();
 
 		var lifespan = ti.GetCustomAttribute<ModuleLifespanAttribute>();
 		var moduleLifespan = lifespan != null ? lifespan.Lifespan : ModuleLifespan.Singleton;
 
 		var module = new CommandModuleBuilder()
 			.WithType(t)
 			.WithLifespan(moduleLifespan)
 			.Build(this.Services);
 
 		// restrict parent lifespan to more or equally restrictive
 		if (currentParent?.Module is TransientCommandModule && moduleLifespan != ModuleLifespan.Transient)
 			throw new InvalidOperationException("In a transient module, child modules can only be transient.");
 
 		// check if we are anything
 		var groupBuilder = new CommandGroupBuilder(module);
 		var isModule = false;
 		var moduleAttributes = ti.GetCustomAttributes();
 		var moduleHidden = false;
 		var moduleChecks = new List<CheckBaseAttribute>();
 
 		foreach (var xa in moduleAttributes)
 		{
 			switch (xa)
 			{
 				case GroupAttribute g:
 					isModule = true;
 					var moduleName = g.Name;
 					if (moduleName == null)
 					{
 						moduleName = ti.Name;
 
 						if (moduleName.EndsWith("Group") && moduleName != "Group")
 							moduleName = moduleName[0..^5];
 						else if (moduleName.EndsWith("Module") && moduleName != "Module")
 							moduleName = moduleName[0..^6];
 						else if (moduleName.EndsWith("Commands") && moduleName != "Commands")
 							moduleName = moduleName[0..^8];
 					}
 
 					if (!this._config.CaseSensitive)
 						moduleName = moduleName.ToLowerInvariant();
 
 					groupBuilder.WithName(moduleName);
 
 					if (inheritedChecks != null)
 						foreach (var chk in inheritedChecks)
 							groupBuilder.WithExecutionCheck(chk);
 
 					foreach (var mi in ti.DeclaredMethods.Where(x => x.IsCommandCandidate(out _) && x.GetCustomAttribute<GroupCommandAttribute>() != null))
 						groupBuilder.WithOverload(new CommandOverloadBuilder(mi));
 					break;
 
 				case AliasesAttribute a:
 					foreach (var xalias in a.Aliases)
 						groupBuilder.WithAlias(this._config.CaseSensitive ? xalias : xalias.ToLowerInvariant());
 					break;
 
 				case HiddenAttribute h:
 					groupBuilder.WithHiddenStatus(true);
 					moduleHidden = true;
 					break;
 
 				case DescriptionAttribute d:
 					groupBuilder.WithDescription(d.Description);
 					break;
 
 				case CheckBaseAttribute c:
 					moduleChecks.Add(c);
 					groupBuilder.WithExecutionCheck(c);
 					break;
 
 				default:
 					groupBuilder.WithCustomAttribute(xa);
 					break;
 			}
 		}
 
 		if (!isModule)
 		{
 			groupBuilder = null;
 			if (inheritedChecks != null)
 				moduleChecks.AddRange(inheritedChecks);
 		}
 
 		// candidate methods
 		var methods = ti.DeclaredMethods;
 		var commands = new List<CommandBuilder>();
 		var commandBuilders = new Dictionary<string, CommandBuilder>();
 		foreach (var m in methods)
 		{
 			if (!m.IsCommandCandidate(out _))
 				continue;
 
 			var attrs = m.GetCustomAttributes();
 			if (attrs.FirstOrDefault(xa => xa is CommandAttribute) is not CommandAttribute cattr)
 				continue;
 
 			var commandName = cattr.Name;
 			if (commandName == null)
 			{
 				commandName = m.Name;
 				if (commandName.EndsWith("Async") && commandName != "Async")
 					commandName = commandName[0..^5];
 			}
 
 			if (!this._config.CaseSensitive)
 				commandName = commandName.ToLowerInvariant();
 
 			if (!commandBuilders.TryGetValue(commandName, out var commandBuilder))
 			{
 				commandBuilders.Add(commandName, commandBuilder = new CommandBuilder(module).WithName(commandName));
 
 				if (!isModule)
 					if (currentParent != null)
 						currentParent.WithChild(commandBuilder);
 					else
 						commands.Add(commandBuilder);
 				else
 					groupBuilder.WithChild(commandBuilder);
 			}
 
 			commandBuilder.WithOverload(new CommandOverloadBuilder(m));
 
 			if (!isModule && moduleChecks.Any())
 				foreach (var chk in moduleChecks)
 					commandBuilder.WithExecutionCheck(chk);
 
 			foreach (var xa in attrs)
 			{
 				switch (xa)
 				{
 					case AliasesAttribute a:
 						foreach (var xalias in a.Aliases)
 							commandBuilder.WithAlias(this._config.CaseSensitive ? xalias : xalias.ToLowerInvariant());
 						break;
 
 					case CheckBaseAttribute p:
 						commandBuilder.WithExecutionCheck(p);
 						break;
 
 					case DescriptionAttribute d:
 						commandBuilder.WithDescription(d.Description);
 						break;
 
 					case HiddenAttribute h:
 						commandBuilder.WithHiddenStatus(true);
 						break;
 
 					default:
 						commandBuilder.WithCustomAttribute(xa);
 						break;
 				}
 			}
 
 			if (!isModule && moduleHidden)
 				commandBuilder.WithHiddenStatus(true);
 		}
 
 		// candidate types
 		var types = ti.DeclaredNestedTypes
 			.Where(xt => xt.IsModuleCandidateType() && xt.DeclaredConstructors.Any(xc => xc.IsPublic));
 		foreach (var type in types)
 		{
 			this.RegisterCommands(type.AsType(),
 				groupBuilder,
 				!isModule ? moduleChecks : null,
 				out var tempCommands);
 
 			if (isModule)
 				foreach (var chk in moduleChecks)
 					groupBuilder.WithExecutionCheck(chk);
 
 			if (isModule && tempCommands != null)
 				foreach (var xtcmd in tempCommands)
 					groupBuilder.WithChild(xtcmd);
 			else if (tempCommands != null)
 				commands.AddRange(tempCommands);
 		}
 
 		if (isModule && currentParent == null)
 			commands.Add(groupBuilder);
 		else if (isModule)
 			currentParent.WithChild(groupBuilder);
 		foundCommands = commands;
 	}
 
 	/// <summary>
 	/// Builds and registers all supplied commands.
 	/// </summary>
 	/// <param name="cmds">Commands to build and register.</param>
 	public void RegisterCommands(params CommandBuilder[] cmds)
 	{
 		foreach (var cmd in cmds)
 			this.AddToCommandDictionary(cmd.Build(null));
 	}
 
 	/// <summary>
 	/// Unregister specified commands from CommandsNext.
 	/// </summary>
 	/// <param name="cmds">Commands to unregister.</param>
 	public void UnregisterCommands(params Command[] cmds)
 	{
 		if (cmds.Any(x => x.Parent != null))
 			throw new InvalidOperationException("Cannot unregister nested commands.");
 
 		var keys = this.RegisteredCommands.Where(x => cmds.Contains(x.Value)).Select(x => x.Key).ToList();
 		foreach (var key in keys)
 			this._topLevelCommands.Remove(key);
 	}
 
 	/// <summary>
 	/// Adds the to command dictionary.
 	/// </summary>
 	/// <param name="cmd">The cmd.</param>
 	private void AddToCommandDictionary(Command cmd)
 	{
 		if (cmd.Parent != null)
 			return;
 
 		if (this._topLevelCommands.ContainsKey(cmd.Name) || (cmd.Aliases != null && cmd.Aliases.Any(xs => this._topLevelCommands.ContainsKey(xs))))
 			throw new DuplicateCommandException(cmd.QualifiedName);
 
 		this._topLevelCommands[cmd.Name] = cmd;
 		if (cmd.Aliases != null)
 			foreach (var xs in cmd.Aliases)
 				this._topLevelCommands[xs] = cmd;
 	}
 	#endregion
 
 	#region Default Help
 	/// <summary>
 	/// Represents the default help module.
 	/// </summary>
 	[ModuleLifespan(ModuleLifespan.Transient)]
 	public class DefaultHelpModule : BaseCommandModule
 	{
 		/// <summary>
 		/// Defaults the help async.
 		/// </summary>
 		/// <param name="ctx">The ctx.</param>
 		/// <param name="command">The command.</param>
 		/// <returns>A Task.</returns>
 		[Command("help"), Description("Displays command help.")]
 		public async Task DefaultHelpAsync(CommandContext ctx, [Description("Command to provide help for.")] params string[] command)
 		{
 			var topLevel = ctx.CommandsNext._topLevelCommands.Values.Distinct();
 			var helpBuilder = ctx.CommandsNext._helpFormatter.Create(ctx);
 
 			if (command != null && command.Any())
 			{
 				Command cmd = null;
 				var searchIn = topLevel;
 				foreach (var c in command)
 				{
 					if (searchIn == null)
 					{
 						cmd = null;
 						break;
 					}
 
 					cmd = ctx.Config.CaseSensitive
 						? searchIn.FirstOrDefault(xc => xc.Name == c || (xc.Aliases != null && xc.Aliases.Contains(c)))
 						: searchIn.FirstOrDefault(xc => xc.Name.ToLowerInvariant() == c.ToLowerInvariant() || (xc.Aliases != null && xc.Aliases.Select(xs => xs.ToLowerInvariant()).Contains(c.ToLowerInvariant())));
 
 					if (cmd == null)
 						break;
 
 					var failedChecks = await cmd.RunChecksAsync(ctx, true).ConfigureAwait(false);
 					if (failedChecks.Any())
 						throw new ChecksFailedException(cmd, ctx, failedChecks);
 
 					searchIn = cmd is CommandGroup ? (cmd as CommandGroup).Children : null;
 				}
 
 				if (cmd == null)
 					throw new CommandNotFoundException(string.Join(" ", command));
 
 				helpBuilder.WithCommand(cmd);
 
 				if (cmd is CommandGroup group)
 				{
 					var commandsToSearch = group.Children.Where(xc => !xc.IsHidden);
 					var eligibleCommands = new List<Command>();
 					foreach (var candidateCommand in commandsToSearch)
 					{
 						if (candidateCommand.ExecutionChecks == null || !candidateCommand.ExecutionChecks.Any())
 						{
 							eligibleCommands.Add(candidateCommand);
 							continue;
 						}
 
 						var candidateFailedChecks = await candidateCommand.RunChecksAsync(ctx, true).ConfigureAwait(false);
 						if (!candidateFailedChecks.Any())
 							eligibleCommands.Add(candidateCommand);
 					}
 
 					if (eligibleCommands.Any())
 						helpBuilder.WithSubcommands(eligibleCommands.OrderBy(xc => xc.Name));
 				}
 			}
 			else
 			{
 				var commandsToSearch = topLevel.Where(xc => !xc.IsHidden);
 				var eligibleCommands = new List<Command>();
 				foreach (var sc in commandsToSearch)
 				{
 					if (sc.ExecutionChecks == null || !sc.ExecutionChecks.Any())
 					{
 						eligibleCommands.Add(sc);
 						continue;
 					}
 
 					var candidateFailedChecks = await sc.RunChecksAsync(ctx, true).ConfigureAwait(false);
 					if (!candidateFailedChecks.Any())
 						eligibleCommands.Add(sc);
 				}
 
 				if (eligibleCommands.Any())
 					helpBuilder.WithSubcommands(eligibleCommands.OrderBy(xc => xc.Name));
 			}
 
 			var helpMessage = helpBuilder.Build();
 
 			var builder = new DiscordMessageBuilder().WithContent(helpMessage.Content).WithEmbed(helpMessage.Embed);
 
 			if (!ctx.Config.DmHelp || ctx.Channel is DiscordDmChannel || ctx.Guild == null)
 				await ctx.RespondAsync(builder).ConfigureAwait(false);
 			else
 				await ctx.Member.SendMessageAsync(builder).ConfigureAwait(false);
 
 		}
 	}
 	#endregion
 
 	#region Sudo
 	/// <summary>
 	/// Creates a fake command context to execute commands with.
 	/// </summary>
 	/// <param name="actor">The user or member to use as message author.</param>
 	/// <param name="channel">The channel the message is supposed to appear from.</param>
 	/// <param name="messageContents">Contents of the message.</param>
 	/// <param name="prefix">Command prefix, used to execute commands.</param>
 	/// <param name="cmd">Command to execute.</param>
 	/// <param name="rawArguments">Raw arguments to pass to command.</param>
 	/// <returns>Created fake context.</returns>
 	public CommandContext CreateFakeContext(DiscordUser actor, DiscordChannel channel, string messageContents, string prefix, Command cmd, string rawArguments = null)
 	{
 		var epoch = new DateTimeOffset(2015, 1, 1, 0, 0, 0, TimeSpan.Zero);
 		var now = DateTimeOffset.UtcNow;
 		var timeSpan = (ulong)(now - epoch).TotalMilliseconds;
 
 		// create fake message
 		var msg = new DiscordMessage
 		{
 			Discord = this.Client,
 			Author = actor,
 			ChannelId = channel.Id,
 			Content = messageContents,
 			Id = timeSpan << 22,
 			Pinned = false,
 			MentionEveryone = messageContents.Contains("@everyone"),
 			IsTts = false,
 			AttachmentsInternal = new List<DiscordAttachment>(),
 			EmbedsInternal = new List<DiscordEmbed>(),
 			TimestampRaw = now.ToString("yyyy-MM-ddTHH:mm:sszzz"),
 			ReactionsInternal = new List<DiscordReaction>()
 		};
 
 		var mentionedUsers = new List<DiscordUser>();
 		var mentionedRoles = msg.Channel.Guild != null ? new List<DiscordRole>() : null;
 		var mentionedChannels = msg.Channel.Guild != null ? new List<DiscordChannel>() : null;
 
 		if (!string.IsNullOrWhiteSpace(msg.Content))
 		{
 			if (msg.Channel.Guild != null)
 			{
 				mentionedUsers = Utilities.GetUserMentions(msg).Select(xid => msg.Channel.Guild.MembersInternal.TryGetValue(xid, out var member) ? member : null).Cast<DiscordUser>().ToList();
 				mentionedRoles = Utilities.GetRoleMentions(msg).Select(xid => msg.Channel.Guild.GetRole(xid)).ToList();
 				mentionedChannels = Utilities.GetChannelMentions(msg).Select(xid => msg.Channel.Guild.GetChannel(xid)).ToList();
 			}
 			else
 			{
 				mentionedUsers = Utilities.GetUserMentions(msg).Select(this.Client.GetCachedOrEmptyUserInternal).ToList();
 			}
 		}
 
 		msg.MentionedUsersInternal = mentionedUsers;
 		msg.MentionedRolesInternal = mentionedRoles;
 		msg.MentionedChannelsInternal = mentionedChannels;
 
 		var ctx = new CommandContext
 		{
 			Client = this.Client,
 			Command = cmd,
 			Message = msg,
 			Config = this._config,
 			RawArgumentString = rawArguments ?? "",
 			Prefix = prefix,
 			CommandsNext = this,
 			Services = this.Services
 		};
 
 		if (cmd != null && (cmd.Module is TransientCommandModule || cmd.Module == null))
 		{
 			var scope = ctx.Services.CreateScope();
 			ctx.ServiceScopeContext = new CommandContext.ServiceContext(ctx.Services, scope);
 			ctx.Services = scope.ServiceProvider;
 		}
 
 		return ctx;
 	}
 	#endregion
 
 	#region Type Conversion
 	/// <summary>
 	/// Converts a string to specified type.
 	/// </summary>
 	/// <typeparam name="T">Type to convert to.</typeparam>
 	/// <param name="value">Value to convert.</param>
 	/// <param name="ctx">Context in which to convert to.</param>
 	/// <returns>Converted object.</returns>
 	public async Task<T> ConvertArgument<T>(string value, CommandContext ctx)
 	{
 		var t = typeof(T);
 		if (!this.ArgumentConverters.ContainsKey(t))
 			throw new ArgumentException("There is no converter specified for given type.", nameof(T));
 
 		if (this.ArgumentConverters[t] is not IArgumentConverter<T> cv)
 			throw new ArgumentException("Invalid converter registered for this type.", nameof(T));
 
 		var cvr = await cv.ConvertAsync(value, ctx).ConfigureAwait(false);
 		return !cvr.HasValue ? throw new ArgumentException("Could not convert specified value to given type.", nameof(value)) : cvr.Value;
 	}
 
 	/// <summary>
 	/// Converts a string to specified type.
 	/// </summary>
 	/// <param name="value">Value to convert.</param>
 	/// <param name="ctx">Context in which to convert to.</param>
 	/// <param name="type">Type to convert to.</param>
 	/// <returns>Converted object.</returns>
 	public async Task<object> ConvertArgument(string value, CommandContext ctx, Type type)
 	{
 		var m = this._convertGeneric.MakeGenericMethod(type);
 		try
 		{
 			return await (m.Invoke(this, new object[] { value, ctx }) as Task<object>).ConfigureAwait(false);
 		}
 		catch (TargetInvocationException ex)
 		{
 			throw ex.InnerException;
 		}
 	}
 
 	/// <summary>
 	/// Registers an argument converter for specified type.
 	/// </summary>
 	/// <typeparam name="T">Type for which to register the converter.</typeparam>
 	/// <param name="converter">Converter to register.</param>
 	public void RegisterConverter<T>(IArgumentConverter<T> converter)
 	{
 		if (converter == null)
 			throw new ArgumentNullException(nameof(converter), "Converter cannot be null.");
 
 		var t = typeof(T);
 		var ti = t.GetTypeInfo();
 		this.ArgumentConverters[t] = converter;
 
 		if (!ti.IsValueType)
 			return;
 
 		var nullableConverterType = typeof(NullableConverter<>).MakeGenericType(t);
 		var nullableType = typeof(Nullable<>).MakeGenericType(t);
 		if (this.ArgumentConverters.ContainsKey(nullableType))
 			return;
 
 		var nullableConverter = Activator.CreateInstance(nullableConverterType) as IArgumentConverter;
 		this.ArgumentConverters[nullableType] = nullableConverter;
 	}
 
 	/// <summary>
 	/// Unregister an argument converter for specified type.
 	/// </summary>
 	/// <typeparam name="T">Type for which to unregister the converter.</typeparam>
 	public void UnregisterConverter<T>()
 	{
 		var t = typeof(T);
 		var ti = t.GetTypeInfo();
 		if (this.ArgumentConverters.ContainsKey(t))
 			this.ArgumentConverters.Remove(t);
 
 		if (this._userFriendlyTypeNames.ContainsKey(t))
 			this._userFriendlyTypeNames.Remove(t);
 
 		if (!ti.IsValueType)
 			return;
 
 		var nullableType = typeof(Nullable<>).MakeGenericType(t);
 		if (!this.ArgumentConverters.ContainsKey(nullableType))
 			return;
 
 		this.ArgumentConverters.Remove(nullableType);
 		this._userFriendlyTypeNames.Remove(nullableType);
 	}
 
 	/// <summary>
 	/// Registers a user-friendly type name.
 	/// </summary>
 	/// <typeparam name="T">Type to register the name for.</typeparam>
 	/// <param name="value">Name to register.</param>
 	public void RegisterUserFriendlyTypeName<T>(string value)
 	{
 		if (string.IsNullOrWhiteSpace(value))
 			throw new ArgumentNullException(nameof(value), "Name cannot be null or empty.");
 
 		var t = typeof(T);
 		var ti = t.GetTypeInfo();
 		if (!this.ArgumentConverters.ContainsKey(t))
 			throw new InvalidOperationException("Cannot register a friendly name for a type which has no associated converter.");
 
 		this._userFriendlyTypeNames[t] = value;
 
 		if (!ti.IsValueType)
 			return;
 
 		var nullableType = typeof(Nullable<>).MakeGenericType(t);
 		this._userFriendlyTypeNames[nullableType] = value;
 	}
 
 	/// <summary>
 	/// Converts a type into user-friendly type name.
 	/// </summary>
 	/// <param name="t">Type to convert.</param>
 	/// <returns>User-friendly type name.</returns>
 	public string GetUserFriendlyTypeName(Type t)
 	{
 		if (this._userFriendlyTypeNames.ContainsKey(t))
 			return this._userFriendlyTypeNames[t];
 
 		var ti = t.GetTypeInfo();
 		if (ti.IsGenericTypeDefinition && t.GetGenericTypeDefinition() == typeof(Nullable<>))
 		{
 			var tn = ti.GenericTypeArguments[0];
 			return this._userFriendlyTypeNames.ContainsKey(tn) ? this._userFriendlyTypeNames[tn] : tn.Name;
 		}
 
 		return t.Name;
 	}
 	#endregion
 
 	#region Helpers
 	/// <summary>
 	/// Allows easier interoperability with reflection by turning the <see cref="Task{T}"/> returned by <see cref="ConvertArgument"/>
 	/// into a task containing <see cref="object"/>, using the provided generic type information.
 	/// </summary>
 	private async Task<object> ConvertArgumentToObj<T>(string value, CommandContext ctx)
 		=> await this.ConvertArgument<T>(value, ctx).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets the configuration-specific string comparer. This returns <see cref="StringComparer.Ordinal"/> or <see cref="StringComparer.OrdinalIgnoreCase"/>,
 	/// depending on whether <see cref="CommandsNextConfiguration.CaseSensitive"/> is set to <see langword="true"/> or <see langword="false"/>.
 	/// </summary>
 	/// <returns>A string comparer.</returns>
 	internal IEqualityComparer<string> GetStringComparer()
 		=> this._config.CaseSensitive
 			? StringComparer.Ordinal
 			: StringComparer.OrdinalIgnoreCase;
 	#endregion
 
 	#region Events
 	/// <summary>
 	/// Triggered whenever a command executes successfully.
 	/// </summary>
 	public event AsyncEventHandler<CommandsNextExtension, CommandExecutionEventArgs> CommandExecuted
 	{
 		add => this._executed.Register(value);
 		remove => this._executed.Unregister(value);
 	}
 	private AsyncEvent<CommandsNextExtension, CommandExecutionEventArgs> _executed;
 
 	/// <summary>
 	/// Triggered whenever a command throws an exception during execution.
 	/// </summary>
 	public event AsyncEventHandler<CommandsNextExtension, CommandErrorEventArgs> CommandErrored
 	{
 		add => this._error.Register(value);
 		remove => this._error.Unregister(value);
 	}
 	private AsyncEvent<CommandsNextExtension, CommandErrorEventArgs> _error;
 
 	/// <summary>
 	/// Fires when a command gets executed.
 	/// </summary>
 	/// <param name="e">The command execution event arguments.</param>
 	private Task OnCommandExecuted(CommandExecutionEventArgs e)
 		=> this._executed.InvokeAsync(this, e);
 
 	/// <summary>
 	/// Fires when a command fails.
 	/// </summary>
 	/// <param name="e">The command error event arguments.</param>
 	private Task OnCommandErrored(CommandErrorEventArgs e)
 		=> this._error.InvokeAsync(this, e);
 	#endregion
-
-
-
-	public override void Dispose()
-	{
-		this.Client.MessageCreated -= this.HandleCommandsAsync;
-		GC.SuppressFinalize(this);
-	}
 }
diff --git a/DisCatSharp.Interactivity/InteractivityExtension.cs b/DisCatSharp.Interactivity/InteractivityExtension.cs
index b54a663c2..42cfda735 100644
--- a/DisCatSharp.Interactivity/InteractivityExtension.cs
+++ b/DisCatSharp.Interactivity/InteractivityExtension.cs
@@ -1,973 +1,971 @@
 // 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.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Interactivity.Enums;
 using DisCatSharp.Interactivity.EventHandling;
 
 namespace DisCatSharp.Interactivity;
 
 /// <summary>
 /// Extension class for DisCatSharp.Interactivity
 /// </summary>
 public class InteractivityExtension : BaseExtension
 {
 
 	/// <summary>
 	/// Gets the config.
 	/// </summary>
 	internal InteractivityConfiguration Config { get; }
 
 	private EventWaiter<MessageCreateEventArgs> _messageCreatedWaiter;
 
 	private EventWaiter<MessageReactionAddEventArgs> _messageReactionAddWaiter;
 
 	private EventWaiter<TypingStartEventArgs> _typingStartWaiter;
 
 	private EventWaiter<ComponentInteractionCreateEventArgs> _modalInteractionWaiter;
 
 	private EventWaiter<ComponentInteractionCreateEventArgs> _componentInteractionWaiter;
 
 	private ComponentEventWaiter _componentEventWaiter;
 
 	private ModalEventWaiter _modalEventWaiter;
 
 	private ReactionCollector _reactionCollector;
 
 	private Poller _poller;
 
 	private Paginator _paginator;
 	private  ComponentPaginator _compPaginator;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="InteractivityExtension"/> class.
 	/// </summary>
 	/// <param name="cfg">The configuration.</param>
 	internal InteractivityExtension(InteractivityConfiguration cfg)
 	{
 		this.Config = new InteractivityConfiguration(cfg);
 	}
 
 	/// <summary>
 	/// Setups the Interactivity Extension.
 	/// </summary>
 	/// <param name="client">Discord client.</param>
 	protected internal override void Setup(DiscordClient client)
 	{
 		this.Client = client;
 		this._messageCreatedWaiter = new EventWaiter<MessageCreateEventArgs>(this.Client);
 		this._messageReactionAddWaiter = new EventWaiter<MessageReactionAddEventArgs>(this.Client);
 		this._componentInteractionWaiter = new EventWaiter<ComponentInteractionCreateEventArgs>(this.Client);
 		this._modalInteractionWaiter = new EventWaiter<ComponentInteractionCreateEventArgs>(this.Client);
 		this._typingStartWaiter = new EventWaiter<TypingStartEventArgs>(this.Client);
 		this._poller = new Poller(this.Client);
 		this._reactionCollector = new ReactionCollector(this.Client);
 		this._paginator = new Paginator(this.Client);
 		this._compPaginator = new ComponentPaginator(this.Client, this.Config);
 		this._componentEventWaiter = new ComponentEventWaiter(this.Client, this.Config);
 		this._modalEventWaiter = new ModalEventWaiter(this.Client, this.Config);
+
 	}
 
 	/// <summary>
 	/// Makes a poll and returns poll results.
 	/// </summary>
 	/// <param name="m">Message to create poll on.</param>
 	/// <param name="emojis">Emojis to use for this poll.</param>
 	/// <param name="behaviour">What to do when the poll ends.</param>
 	/// <param name="timeout">Override timeout period.</param>
 	/// <returns></returns>
 	public async Task<ReadOnlyCollection<PollEmoji>> DoPollAsync(DiscordMessage m, IEnumerable<DiscordEmoji> emojis, PollBehaviour? behaviour = default, TimeSpan? timeout = null)
 	{
 		if (!Utilities.HasReactionIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No reaction intents are enabled.");
 
 		if (!emojis.Any())
 			throw new ArgumentException("You need to provide at least one emoji for a poll!");
 
 		foreach (var em in emojis)
 			await m.CreateReactionAsync(em).ConfigureAwait(false);
 
 		var res = await this._poller.DoPollAsync(new PollRequest(m, timeout ?? this.Config.Timeout, emojis)).ConfigureAwait(false);
 
 		var pollBehaviour = behaviour ?? this.Config.PollBehaviour;
 		var thisMember = await m.Channel.Guild.GetMemberAsync(this.Client.CurrentUser.Id).ConfigureAwait(false);
 
 		if (pollBehaviour == PollBehaviour.DeleteEmojis && m.Channel.PermissionsFor(thisMember).HasPermission(Permissions.ManageMessages))
 			await m.DeleteAllReactionsAsync().ConfigureAwait(false);
 
 		return new ReadOnlyCollection<PollEmoji>(res.ToList());
 	}
 
 	/// <summary>
 	/// Waits for any button in the specified collection to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="buttons">A collection of buttons to listen for.</param>
 	/// <param name="timeoutOverride">Override the timeout period in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, IEnumerable<DiscordButtonComponent> buttons, TimeSpan? timeoutOverride = null)
 		=> this.WaitForButtonAsync(message, buttons, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for any button in the specified collection to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="buttons">A collection of buttons to listen for.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, IEnumerable<DiscordButtonComponent> buttons, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!buttons.Any())
 			throw new ArgumentException("You must specify at least one button to listen for.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 			throw new ArgumentException("Provided Message does not contain any button components.");
 
 		var res = await this._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message,
 				c =>
 					c.Interaction.Data.ComponentType == ComponentType.Button &&
 					buttons.Any(b => b.CustomId == c.Id), token)).ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(res is null, res);
 	}
 
 	/// <summary>
 	/// Waits for a user modal submit.
 	/// </summary>
 	/// <param name="customId">The custom id of the modal to wait for.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the modal.</returns>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForModalAsync(string customId, TimeSpan? timeoutOverride = null)
 		=> this.WaitForModalAsync(customId, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for a user modal submit.
 	/// </summary>
 	/// <param name="customId">The custom id of the modal to wait for.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the modal.</returns>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForModalAsync(string customId, CancellationToken token)
 	{
 		var result =
 			await this
 			._modalEventWaiter
 			.WaitForModalMatchAsync(new ModalMatchRequest(customId, c => c.Interaction.Type == InteractionType.ModalSubmit, token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 	/// <summary>
 	/// Waits for any button on the specified message to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, TimeSpan? timeoutOverride = null)
 		=> this.WaitForButtonAsync(message, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for any button on the specified message to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 			throw new ArgumentException("Message does not contain any button components.");
 
 		var ids = message.Components.SelectMany(m => m.Components).Select(c => c.CustomId);
 
 		var result =
 			await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, c => c.Interaction.Data.ComponentType == ComponentType.Button && ids.Contains(c.Id), token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 	/// <summary>
 	/// Waits for any button on the specified message to be pressed by the specified user.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="user">The user to wait for the button press from.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, DiscordUser user, TimeSpan? timeoutOverride = null)
 		=> this.WaitForButtonAsync(message, user, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for any button on the specified message to be pressed by the specified user.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="user">The user to wait for the button press from.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of button that was pressed, if any.</returns>
 	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, DiscordUser user, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 			throw new ArgumentException("Message does not contain any button components.");
 
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Button && c.User == user, token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 
 	}
 
 	/// <summary>
 	/// Waits for a button with the specified Id to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="id">The Id of the button to wait for.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the operation.</returns>
 	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, string id, TimeSpan? timeoutOverride = null)
 		=> this.WaitForButtonAsync(message, id, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for a button with the specified Id to be pressed.
 	/// </summary>
 	/// <param name="message">The message to wait for the button on.</param>
 	/// <param name="id">The Id of the button to wait for.</param>
 	/// <param name="token">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <returns>A <see cref="InteractivityResult{T}"/> with the result of the operation.</returns>
 	/// <exception cref="System.InvalidOperationException">Thrown when attempting to wait for a message that is not authored by the current user.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not contain a button with the specified Id, or any buttons at all.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, string id, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 			throw new ArgumentException("Message does not contain any button components.");
 
 		if (!message.Components.SelectMany(c => c.Components).OfType<DiscordButtonComponent>().Any(c => c.CustomId == id))
 			throw new ArgumentException($"Message does not contain button with Id of '{id}'.");
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Button && c.Id == id, token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 	/// <summary>
 	/// Waits for any button to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="predicate">The predicate to filter interactions by.</param>
 	/// <param name="timeoutOverride">Override the timeout specified in <see cref="InteractivityConfiguration"/></param>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, TimeSpan? timeoutOverride = null)
 		=> this.WaitForButtonAsync(message, predicate, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for any button to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="predicate">The predicate to filter interactions by.</param>
 	/// <param name="token">A token to cancel interactivity with at any time. Pass <see cref="System.Threading.CancellationToken.None"/> to wait indefinitely.</param>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForButtonAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Button))
 			throw new ArgumentException("Message does not contain any button components.");
 
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, c => c.Interaction.Data.ComponentType is ComponentType.Button && predicate(c), token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 
 	/// <summary>
 	/// Waits for any dropdown to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait for.</param>
 	/// <param name="predicate">A filter predicate.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the Provided message does not contain any dropdowns</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, TimeSpan? timeoutOverride = null)
 		=> this.WaitForSelectAsync(message, predicate, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for any dropdown to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait for.</param>
 	/// <param name="predicate">A filter predicate.</param>
 	/// <param name="token">A token that can be used to cancel interactivity. Pass <see cref="System.Threading.CancellationToken.None"/> to wait indefinitely.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the Provided message does not contain any dropdowns</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, Func<ComponentInteractionCreateEventArgs, bool> predicate, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Select))
 			throw new ArgumentException("Message does not contain any select components.");
 
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, c => c.Interaction.Data.ComponentType is ComponentType.Select && predicate(c), token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with.
 	/// </summary>
 	/// <remarks>This is here for backwards-compatibility and will internally create a cancellation token.</remarks>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="id">The Id of the dropdown to wait on.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, string id, TimeSpan? timeoutOverride = null)
 		=> this.WaitForSelectAsync(message, id, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="id">The Id of the dropdown to wait on.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, string id, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Select))
 			throw new ArgumentException("Message does not contain any select components.");
 
 		if (message.Components.SelectMany(c => c.Components).OfType<DiscordSelectComponent>().All(c => c.CustomId != id))
 			throw new ArgumentException($"Message does not contain select component with Id of '{id}'.");
 
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Interaction.Data.ComponentType is ComponentType.Select && c.Id == id, token))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with by a specific user.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="user">The user to wait on.</param>
 	/// <param name="id">The Id of the dropdown to wait on.</param>
 	/// <param name="timeoutOverride">Override the timeout period specified in <see cref="InteractivityConfiguration"/>.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 	public Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, DiscordUser user, string id, TimeSpan? timeoutOverride = null)
 		=> this.WaitForSelectAsync(message, user, id, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Waits for a dropdown to be interacted with by a specific user.
 	/// </summary>
 	/// <param name="message">The message to wait on.</param>
 	/// <param name="user">The user to wait on.</param>
 	/// <param name="id">The Id of the dropdown to wait on.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the message does not have any dropdowns or any dropdown with the specified Id.</exception>
 	public async Task<InteractivityResult<ComponentInteractionCreateEventArgs>> WaitForSelectAsync(DiscordMessage message, DiscordUser user, string id, CancellationToken token)
 	{
 		if (message.Author != this.Client.CurrentUser)
 			throw new InvalidOperationException("Interaction events are only sent to the application that created them.");
 
 		if (!message.Components.Any())
 			throw new ArgumentException("Provided message does not contain any components.");
 
 		if (!message.Components.SelectMany(c => c.Components).Any(c => c.Type is ComponentType.Select))
 			throw new ArgumentException("Message does not contain any select components.");
 
 		if (message.Components.SelectMany(c => c.Components).OfType<DiscordSelectComponent>().All(c => c.CustomId != id))
 			throw new ArgumentException($"Message does not contain select with Id of '{id}'.");
 
 		var result = await this
 			._componentEventWaiter
 			.WaitForMatchAsync(new ComponentMatchRequest(message, (c) => c.Id == id && c.User == user, token)).ConfigureAwait(false);
 
 		return new InteractivityResult<ComponentInteractionCreateEventArgs>(result is null, result);
 	}
 
 
 	/// <summary>
 	/// Waits for a specific message.
 	/// </summary>
 	/// <param name="predicate">Predicate to match.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<DiscordMessage>> WaitForMessageAsync(Func<DiscordMessage, bool> predicate,
 		TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasMessageIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No message intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var returns = await this._messageCreatedWaiter.WaitForMatchAsync(new MatchRequest<MessageCreateEventArgs>(x => predicate(x.Message), timeout)).ConfigureAwait(false);
 
 		return new InteractivityResult<DiscordMessage>(returns == null, returns?.Message);
 	}
 
 	/// <summary>
 	/// Wait for a specific reaction.
 	/// </summary>
 	/// <param name="predicate">Predicate to match.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(Func<MessageReactionAddEventArgs, bool> predicate,
 		TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasReactionIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No reaction intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var returns = await this._messageReactionAddWaiter.WaitForMatchAsync(new MatchRequest<MessageReactionAddEventArgs>(predicate, timeout)).ConfigureAwait(false);
 
 		return new InteractivityResult<MessageReactionAddEventArgs>(returns == null, returns);
 	}
 
 	/// <summary>
 	/// Wait for a specific reaction.
 	/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 	/// </summary>
 	/// <param name="message">Message reaction was added to.</param>
 	/// <param name="user">User that made the reaction.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(DiscordMessage message, DiscordUser user,
 		TimeSpan? timeoutOverride = null)
 		=> await this.WaitForReactionAsync(x => x.User.Id == user.Id && x.Message.Id == message.Id, timeoutOverride).ConfigureAwait(false);
 
 	/// <summary>
 	/// Waits for a specific reaction.
 	/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 	/// </summary>
 	/// <param name="predicate">Predicate to match.</param>
 	/// <param name="message">Message reaction was added to.</param>
 	/// <param name="user">User that made the reaction.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(Func<MessageReactionAddEventArgs, bool> predicate,
 		DiscordMessage message, DiscordUser user, TimeSpan? timeoutOverride = null)
 		=> await this.WaitForReactionAsync(x => predicate(x) && x.User.Id == user.Id && x.Message.Id == message.Id, timeoutOverride).ConfigureAwait(false);
 
 	/// <summary>
 	/// Waits for a specific reaction.
 	/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 	/// </summary>
 	/// <param name="predicate">predicate to match.</param>
 	/// <param name="user">User that made the reaction.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<MessageReactionAddEventArgs>> WaitForReactionAsync(Func<MessageReactionAddEventArgs, bool> predicate,
 		DiscordUser user, TimeSpan? timeoutOverride = null)
 		=> await this.WaitForReactionAsync(x => predicate(x) && x.User.Id == user.Id, timeoutOverride).ConfigureAwait(false);
 
 	/// <summary>
 	/// Waits for a user to start typing.
 	/// </summary>
 	/// <param name="user">User that starts typing.</param>
 	/// <param name="channel">Channel the user is typing in.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<TypingStartEventArgs>> WaitForUserTypingAsync(DiscordUser user,
 		DiscordChannel channel, TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasTypingIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No typing intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var returns = await this._typingStartWaiter.WaitForMatchAsync(
 			new MatchRequest<TypingStartEventArgs>(x => x.User.Id == user.Id && x.Channel.Id == channel.Id, timeout))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<TypingStartEventArgs>(returns == null, returns);
 	}
 
 	/// <summary>
 	/// Waits for a user to start typing.
 	/// </summary>
 	/// <param name="user">User that starts typing.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<TypingStartEventArgs>> WaitForUserTypingAsync(DiscordUser user, TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasTypingIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No typing intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var returns = await this._typingStartWaiter.WaitForMatchAsync(
 			new MatchRequest<TypingStartEventArgs>(x => x.User.Id == user.Id, timeout))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<TypingStartEventArgs>(returns == null, returns);
 	}
 
 	/// <summary>
 	/// Waits for any user to start typing.
 	/// </summary>
 	/// <param name="channel">Channel to type in.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<TypingStartEventArgs>> WaitForTypingAsync(DiscordChannel channel, TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasTypingIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No typing intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var returns = await this._typingStartWaiter.WaitForMatchAsync(
 			new MatchRequest<TypingStartEventArgs>(x => x.Channel.Id == channel.Id, timeout))
 			.ConfigureAwait(false);
 
 		return new InteractivityResult<TypingStartEventArgs>(returns == null, returns);
 	}
 
 	/// <summary>
 	/// Collects reactions on a specific message.
 	/// </summary>
 	/// <param name="m">Message to collect reactions on.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<ReadOnlyCollection<Reaction>> CollectReactionsAsync(DiscordMessage m, TimeSpan? timeoutOverride = null)
 	{
 		if (!Utilities.HasReactionIntents(this.Client.Configuration.Intents))
 			throw new InvalidOperationException("No reaction intents are enabled.");
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 		var collection = await this._reactionCollector.CollectAsync(new ReactionCollectRequest(m, timeout)).ConfigureAwait(false);
 
 		return collection;
 	}
 
 	/// <summary>
 	/// Waits for specific event args to be received. Make sure the appropriate <see cref="DiscordIntents"/> are registered, if needed.
 	/// </summary>
 	/// <typeparam name="T"></typeparam>
 	/// <param name="predicate">The predicate.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<InteractivityResult<T>> WaitForEventArgsAsync<T>(Func<T, bool> predicate, TimeSpan? timeoutOverride = null) where T : AsyncEventArgs
 	{
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 
 		using var waiter = new EventWaiter<T>(this.Client);
 		var res = await waiter.WaitForMatchAsync(new MatchRequest<T>(predicate, timeout)).ConfigureAwait(false);
 		return new InteractivityResult<T>(res == null, res);
 	}
 
 	/// <summary>
 	/// Collects the event arguments.
 	/// </summary>
 	/// <param name="predicate">The predicate.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task<ReadOnlyCollection<T>> CollectEventArgsAsync<T>(Func<T, bool> predicate, TimeSpan? timeoutOverride = null) where T : AsyncEventArgs
 	{
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 
 		using var waiter = new EventWaiter<T>(this.Client);
 		var res = await waiter.CollectMatchesAsync(new CollectRequest<T>(predicate, timeout)).ConfigureAwait(false);
 		return res;
 	}
 
 	/// <summary>
 	/// Sends a paginated message with buttons.
 	/// </summary>
 	/// <param name="channel">The channel to send it on.</param>
 	/// <param name="user">User to give control.</param>
 	/// <param name="pages">The pages.</param>
 	/// <param name="buttons">Pagination buttons (pass null to use buttons defined in <see cref="InteractivityConfiguration"/>).</param>
 	/// <param name="behaviour">Pagination behaviour.</param>
 	/// <param name="deletion">Deletion behaviour.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	public async Task SendPaginatedMessageAsync(
 		DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons,
 		PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 	{
 		var bhv = behaviour ?? this.Config.PaginationBehaviour;
 		var del = deletion ?? this.Config.ButtonBehavior;
 		var bts = buttons ?? this.Config.PaginationButtons;
 
 		bts = new PaginationButtons(bts);
 		if (bhv is PaginationBehaviour.Ignore)
 		{
 			bts.SkipLeft.Disable();
 			bts.Left.Disable();
 		}
 
 		var builder = new DiscordMessageBuilder()
 			.WithContent(pages.First().Content)
 			.WithEmbed(pages.First().Embed)
 			.AddComponents(bts.ButtonArray);
 
 		var message = await builder.SendAsync(channel).ConfigureAwait(false);
 
 		var req = new ButtonPaginationRequest(message, user, bhv, del, bts, pages, token == default ? this.GetCancellationToken() : token);
 
 		await this._compPaginator.DoPaginationAsync(req).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sends a paginated message with buttons.
 	/// </summary>
 	/// <param name="channel">The channel to send it on.</param>
 	/// <param name="user">User to give control.</param>
 	/// <param name="pages">The pages.</param>
 	/// <param name="buttons">Pagination buttons (pass null to use buttons defined in <see cref="InteractivityConfiguration"/>).</param>
 	/// <param name="behaviour">Pagination behaviour.</param>
 	/// <param name="deletion">Deletion behaviour.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public Task SendPaginatedMessageAsync(
 		DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons, TimeSpan? timeoutOverride,
 		PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default)
 		=> this.SendPaginatedMessageAsync(channel, user, pages, buttons, behaviour, deletion, this.GetCancellationToken(timeoutOverride));
 
 	/// <summary>
 	/// Sends the paginated message.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	/// <param name="user">The user.</param>
 	/// <param name="pages">The pages.</param>
 	/// <param name="behaviour">The behaviour.</param>
 	/// <param name="deletion">The deletion.</param>
 	/// <param name="token">The token.</param>
 	/// <returns>A Task.</returns>
 	public Task SendPaginatedMessageAsync(DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 		=> this.SendPaginatedMessageAsync(channel, user, pages, default, behaviour, deletion, token);
 
 	/// <summary>
 	/// Sends the paginated message.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	/// <param name="user">The user.</param>
 	/// <param name="pages">The pages.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	/// <param name="behaviour">The behaviour.</param>
 	/// <param name="deletion">The deletion.</param>
 	/// <returns>A Task.</returns>
 	public Task SendPaginatedMessageAsync(DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, TimeSpan? timeoutOverride, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default)
 		=> this.SendPaginatedMessageAsync(channel, user, pages, timeoutOverride, behaviour, deletion);
 
 	/// <summary>
 	/// Sends a paginated message.
 	/// For this Event you need the <see cref="DiscordIntents.GuildMessageReactions"/> intent specified in <seealso cref="DiscordConfiguration.Intents"/>
 	/// </summary>
 	/// <param name="channel">Channel to send paginated message in.</param>
 	/// <param name="user">User to give control.</param>
 	/// <param name="pages">Pages.</param>
 	/// <param name="emojis">Pagination emojis.</param>
 	/// <param name="behaviour">Pagination behaviour (when hitting max and min indices).</param>
 	/// <param name="deletion">Deletion behaviour.</param>
 	/// <param name="timeoutOverride">Override timeout period.</param>
 	public async Task SendPaginatedMessageAsync(DiscordChannel channel, DiscordUser user, IEnumerable<Page> pages, PaginationEmojis emojis,
 		PaginationBehaviour? behaviour = default, PaginationDeletion? deletion = default, TimeSpan? timeoutOverride = null)
 	{
 		var builder = new DiscordMessageBuilder()
 			.WithContent(pages.First().Content)
 			.WithEmbed(pages.First().Embed);
 		var m = await builder.SendAsync(channel).ConfigureAwait(false);
 
 		var timeout = timeoutOverride ?? this.Config.Timeout;
 
 		var bhv = behaviour ?? this.Config.PaginationBehaviour;
 		var del = deletion ?? this.Config.PaginationDeletion;
 		var ems = emojis ?? this.Config.PaginationEmojis;
 
 		var pRequest = new PaginationRequest(m, user, bhv, del, ems, timeout, pages);
 
 		await this._paginator.DoPaginationAsync(pRequest).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sends a paginated message in response to an interaction.
 	/// <para>
 	/// <b>Pass the interaction directly. Interactivity will ACK it.</b>
 	/// </para>
 	/// </summary>
 	/// <param name="interaction">The interaction to create a response to.</param>
 	/// <param name="deferred">Whether the interaction was deferred.</param>
 	/// <param name="ephemeral">Whether the response should be ephemeral.</param>
 	/// <param name="user">The user to listen for button presses from.</param>
 	/// <param name="pages">The pages to paginate.</param>
 	/// <param name="buttons">Optional: custom buttons.</param>
 	/// <param name="behaviour">Pagination behaviour.</param>
 	/// <param name="deletion">Deletion behaviour.</param>
 	/// <param name="token">A custom cancellation token that can be cancelled at any point.</param>
 	public async Task SendPaginatedResponseAsync(DiscordInteraction interaction, bool deferred, bool ephemeral, DiscordUser user, IEnumerable<Page> pages, PaginationButtons buttons = null, PaginationBehaviour? behaviour = default, ButtonPaginationBehavior? deletion = default, CancellationToken token = default)
 	{
 		var bhv = behaviour ?? this.Config.PaginationBehaviour;
 		var del = deletion ?? this.Config.ButtonBehavior;
 		var bts = buttons ?? this.Config.PaginationButtons;
 
 		bts = new PaginationButtons(bts);
 		if (bhv is PaginationBehaviour.Ignore)
 		{
 			bts.SkipLeft.Disable();
 			bts.Left.Disable();
 		}
 
 		DiscordMessage message;
 
 		if (deferred)
 		{
 			var builder = new DiscordWebhookBuilder()
 			.WithContent(pages.First().Content)
 			.AddEmbed(pages.First().Embed)
 			.AddComponents(bts.ButtonArray);
 			message = await interaction.EditOriginalResponseAsync(builder).ConfigureAwait(false);
 		}
 		else
 		{
 			var builder = new DiscordInteractionResponseBuilder()
 			.WithContent(pages.First().Content)
 			.AddEmbed(pages.First().Embed)
 			.AsEphemeral(ephemeral)
 			.AddComponents(bts.ButtonArray);
 			await interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder).ConfigureAwait(false);
 			message = await interaction.GetOriginalResponseAsync().ConfigureAwait(false);
 		}
 
 		var req = new InteractionPaginationRequest(interaction, message, user, bhv, del, bts, pages, token);
 
 		await this._compPaginator.DoPaginationAsync(req).ConfigureAwait(false);
 	}
 
 
 	/// <summary>
 	/// Waits for a custom pagination request to finish.
 	/// This does NOT handle removing emojis after finishing for you.
 	/// </summary>
 	/// <param name="request"></param>
 	/// <returns></returns>
 	public async Task WaitForCustomPaginationAsync(IPaginationRequest request) => await this._paginator.DoPaginationAsync(request).ConfigureAwait(false);
 
 	/// <summary>
 	/// Waits for custom button-based pagination request to finish.
 	/// <br/>
 	/// This does <i><b>not</b></i> invoke <see cref="DisCatSharp.Interactivity.EventHandling.IPaginationRequest.DoCleanupAsync"/>.
 	/// </summary>
 	/// <param name="request">The request to wait for.</param>
 	public async Task WaitForCustomComponentPaginationAsync(IPaginationRequest request) => await this._compPaginator.DoPaginationAsync(request).ConfigureAwait(false);
 
 	/// <summary>
 	/// Generates pages from a string, and puts them in message content.
 	/// </summary>
 	/// <param name="input">Input string.</param>
 	/// <param name="splitType">How to split input string.</param>
 	/// <returns></returns>
 	public IEnumerable<Page> GeneratePagesInContent(string input, SplitType splitType = SplitType.Character)
 	{
 		if (string.IsNullOrEmpty(input))
 			throw new ArgumentException("You must provide a string that is not null or empty!");
 
 		var result = new List<Page>();
 		List<string> split;
 
 		switch (splitType)
 		{
 			default:
 			case SplitType.Character:
 				split = this.SplitString(input, 500).ToList();
 				break;
 			case SplitType.Line:
 				var subsplit = input.Split('\n');
 
 				split = new List<string>();
 				var s = "";
 
 				for (var i = 0; i < subsplit.Length; i++)
 				{
 					s += subsplit[i];
 					if (i >= 15 && i % 15 == 0)
 					{
 						split.Add(s);
 						s = "";
 					}
 				}
 				if (split.All(x => x != s))
 					split.Add(s);
 				break;
 		}
 
 		var page = 1;
 		foreach (var s in split)
 		{
 			result.Add(new Page($"Page {page}:\n{s}"));
 			page++;
 		}
 
 		return result;
 	}
 
 	/// <summary>
 	/// Generates pages from a string, and puts them in message embeds.
 	/// </summary>
 	/// <param name="input">Input string.</param>
 	/// <param name="splitType">How to split input string.</param>
 	/// <param name="embedBase">Base embed for output embeds.</param>
 	/// <returns></returns>
 	public IEnumerable<Page> GeneratePagesInEmbed(string input, SplitType splitType = SplitType.Character, DiscordEmbedBuilder embedBase = null)
 	{
 		if (string.IsNullOrEmpty(input))
 			throw new ArgumentException("You must provide a string that is not null or empty!");
 
 		var embed = embedBase ?? new DiscordEmbedBuilder();
 
 		var result = new List<Page>();
 		List<string> split;
 
 		switch (splitType)
 		{
 			default:
 			case SplitType.Character:
 				split = this.SplitString(input, 500).ToList();
 				break;
 			case SplitType.Line:
 				var subsplit = input.Split('\n');
 
 				split = new List<string>();
 				var s = "";
 
 				for (var i = 0; i < subsplit.Length; i++)
 				{
 					s += $"{subsplit[i]}\n";
 					if (i % 15 == 0 && i != 0)
 					{
 						split.Add(s);
 						s = "";
 					}
 				}
 				if (!split.Any(x => x == s))
 					split.Add(s);
 				break;
 		}
 
 		var page = 1;
 		foreach (var s in split)
 		{
 			result.Add(new Page("", new DiscordEmbedBuilder(embed).WithDescription(s).WithFooter($"Page {page}/{split.Count}")));
 			page++;
 		}
 
 		return result;
 	}
 
 	/// <summary>
 	/// Splits the string.
 	/// </summary>
 	/// <param name="str">The string.</param>
 	/// <param name="chunkSize">The chunk size.</param>
 	private List<string> SplitString(string str, int chunkSize)
 	{
 		var res = new List<string>();
 		var len = str.Length;
 		var i = 0;
 
 		while (i < len)
 		{
 			var size = Math.Min(len - i, chunkSize);
 			res.Add(str.Substring(i, size));
 			i += size;
 		}
 
 		return res;
 	}
 
 	/// <summary>
 	/// Gets the cancellation token.
 	/// </summary>
 	/// <param name="timeout">The timeout.</param>
 	private CancellationToken GetCancellationToken(TimeSpan? timeout = null) => new CancellationTokenSource(timeout ?? this.Config.Timeout).Token;
 
-	public override void Dispose()
-		=> GC.SuppressFinalize(this);
-
 	/// <summary>
 	/// Handles an invalid interaction.
 	/// </summary>
 	/// <param name="interaction">The interaction.</param>
 	private async Task HandleInvalidInteraction(DiscordInteraction interaction)
 	{
 		var at = this.Config.ResponseBehavior switch
 		{
 			InteractionResponseBehavior.Ack => interaction.CreateResponseAsync(InteractionResponseType.DeferredMessageUpdate),
 			InteractionResponseBehavior.Respond => interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder { Content = this.Config.ResponseMessage, IsEphemeral = true}),
 			InteractionResponseBehavior.Ignore => Task.CompletedTask,
 			_ => throw new ArgumentException("Unknown enum value.")
 		};
 
 		await at;
 	}
 }
diff --git a/DisCatSharp.Lavalink/LavalinkExtension.cs b/DisCatSharp.Lavalink/LavalinkExtension.cs
index a098763f5..9aa3231dd 100644
--- a/DisCatSharp.Lavalink/LavalinkExtension.cs
+++ b/DisCatSharp.Lavalink/LavalinkExtension.cs
@@ -1,218 +1,215 @@
 // 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.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Lavalink.EventArgs;
 using DisCatSharp.Net;
 
 namespace DisCatSharp.Lavalink;
 
 /// <summary>
 /// The lavalink extension.
 /// </summary>
 public sealed class LavalinkExtension : BaseExtension
 {
 	/// <summary>
 	/// Triggered whenever a node disconnects.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkNodeConnection, NodeDisconnectedEventArgs> NodeDisconnected
 	{
 		add => this._nodeDisconnected.Register(value);
 		remove => this._nodeDisconnected.Unregister(value);
 	}
 	private AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs> _nodeDisconnected;
 
 	/// <summary>
 	/// Gets a dictionary of connected Lavalink nodes for the extension.
 	/// </summary>
 	public IReadOnlyDictionary<ConnectionEndpoint, LavalinkNodeConnection> ConnectedNodes { get; }
 	private readonly ConcurrentDictionary<ConnectionEndpoint, LavalinkNodeConnection> _connectedNodes = new();
 
 	/// <summary>
 	/// Creates a new instance of this Lavalink extension.
 	/// </summary>
 	internal LavalinkExtension()
 	{
 		this.ConnectedNodes = new ReadOnlyConcurrentDictionary<ConnectionEndpoint, LavalinkNodeConnection>(this._connectedNodes);
 	}
 
 	/// <summary>
 	/// DO NOT USE THIS MANUALLY.
 	/// </summary>
 	/// <param name="client">DO NOT USE THIS MANUALLY.</param>
 	/// <exception cref="System.InvalidOperationException"/>
 	protected internal override void Setup(DiscordClient client)
 	{
 		if (this.Client != null)
 			throw new InvalidOperationException("What did I tell you?");
 
 		this.Client = client;
 
 		this._nodeDisconnected = new AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs>("LAVALINK_NODE_DISCONNECTED", TimeSpan.Zero, this.Client.EventErrorHandler);
 	}
 
 	/// <summary>
 	/// Connect to a Lavalink node.
 	/// </summary>
 	/// <param name="config">Lavalink client configuration.</param>
 	/// <returns>The established Lavalink connection.</returns>
 	public async Task<LavalinkNodeConnection> ConnectAsync(LavalinkConfiguration config)
 	{
 		if (this._connectedNodes.ContainsKey(config.SocketEndpoint))
 			return this._connectedNodes[config.SocketEndpoint];
 
 		var con = new LavalinkNodeConnection(this.Client, this, config);
 		con.NodeDisconnected += this.Con_NodeDisconnected;
 		con.Disconnected += this.Con_Disconnected;
 		this._connectedNodes[con.NodeEndpoint] = con;
 		try
 		{
 			await con.StartAsync().ConfigureAwait(false);
 		}
 		catch
 		{
 			this.Con_NodeDisconnected(con);
 			throw;
 		}
 
 		return con;
 	}
 
 	/// <summary>
 	/// Gets the Lavalink node connection for the specified endpoint.
 	/// </summary>
 	/// <param name="endpoint">Endpoint at which the node resides.</param>
 	/// <returns>Lavalink node connection.</returns>
 	public LavalinkNodeConnection GetNodeConnection(ConnectionEndpoint endpoint)
 		=> this._connectedNodes.ContainsKey(endpoint) ? this._connectedNodes[endpoint] : null;
 
 	/// <summary>
 	/// Gets a Lavalink node connection based on load balancing and an optional voice region.
 	/// </summary>
 	/// <param name="region">The region to compare with the node's <see cref="LavalinkConfiguration.Region"/>, if any.</param>
 	/// <returns>The least load affected node connection, or null if no nodes are present.</returns>
 	public LavalinkNodeConnection GetIdealNodeConnection(DiscordVoiceRegion region = null)
 	{
 		if (this._connectedNodes.Count <= 1)
 			return this._connectedNodes.Values.FirstOrDefault();
 
 		var nodes = this._connectedNodes.Values.ToArray();
 
 		if (region != null)
 		{
 			var regionPredicate = new Func<LavalinkNodeConnection, bool>(x => x.Region == region);
 
 			if (nodes.Any(regionPredicate))
 				nodes = nodes.Where(regionPredicate).ToArray();
 
 			if (nodes.Length <= 1)
 				return nodes.FirstOrDefault();
 		}
 
 		return this.FilterByLoad(nodes);
 	}
 
 	/// <summary>
 	/// Gets a Lavalink guild connection from a <see cref="DisCatSharp.Entities.DiscordGuild"/>.
 	/// </summary>
 	/// <param name="guild">The guild the connection is on.</param>
 	/// <returns>The found guild connection, or null if one could not be found.</returns>
 	public LavalinkGuildConnection GetGuildConnection(DiscordGuild guild)
 	{
 		var nodes = this._connectedNodes.Values;
 		var node = nodes.FirstOrDefault(x => x.ConnectedGuildsInternal.ContainsKey(guild.Id));
 		return node?.GetGuildConnection(guild);
 	}
 
 	/// <summary>
 	/// Filters the by load.
 	/// </summary>
 	/// <param name="nodes">The nodes.</param>
 	private LavalinkNodeConnection FilterByLoad(LavalinkNodeConnection[] nodes)
 	{
 		Array.Sort(nodes, (a, b) =>
 		{
 			if (!a.Statistics.Updated || !b.Statistics.Updated)
 				return 0;
 
 			//https://github.com/FredBoat/Lavalink-Client/blob/48bc27784f57be5b95d2ff2eff6665451b9366f5/src/main/java/lavalink/client/io/LavalinkLoadBalancer.java#L122
 			//https://github.com/briantanner/eris-lavalink/blob/master/src/PlayerManager.js#L329
 
 			//player count
 			var aPenaltyCount = a.Statistics.ActivePlayers;
 			var bPenaltyCount = b.Statistics.ActivePlayers;
 
 			//cpu load
 			aPenaltyCount += (int)Math.Pow(1.05d, (100 * (a.Statistics.CpuSystemLoad / a.Statistics.CpuCoreCount) * 10) - 10);
 			bPenaltyCount += (int)Math.Pow(1.05d, (100 * (b.Statistics.CpuSystemLoad / a.Statistics.CpuCoreCount) * 10) - 10);
 
 			//frame load
 			if (a.Statistics.AverageDeficitFramesPerMinute > 0)
 			{
 				//deficit frame load
 				aPenaltyCount += (int)((Math.Pow(1.03d, 500f * (a.Statistics.AverageDeficitFramesPerMinute / 3000f)) * 600) - 600);
 
 				//null frame load
 				aPenaltyCount += (int)((Math.Pow(1.03d, 500f * (a.Statistics.AverageNulledFramesPerMinute / 3000f)) * 300) - 300);
 			}
 
 			//frame load
 			if (b.Statistics.AverageDeficitFramesPerMinute > 0)
 			{
 				//deficit frame load
 				bPenaltyCount += (int)((Math.Pow(1.03d, 500f * (b.Statistics.AverageDeficitFramesPerMinute / 3000f)) * 600) - 600);
 
 				//null frame load
 				bPenaltyCount += (int)((Math.Pow(1.03d, 500f * (b.Statistics.AverageNulledFramesPerMinute / 3000f)) * 300) - 300);
 			}
 
 			return aPenaltyCount - bPenaltyCount;
 		});
 
 		return nodes[0];
 	}
 
 	/// <summary>
 	/// Removes a node.
 	/// </summary>
 	/// <param name="node">The node to be removed.</param>
 	private void Con_NodeDisconnected(LavalinkNodeConnection node)
 		=> this._connectedNodes.TryRemove(node.NodeEndpoint, out _);
 
 	/// <summary>
 	/// Disconnects a node.
 	/// </summary>
 	/// <param name="node">The affected node.</param>
 	/// <param name="e">The node disconnected event args.</param>
 	private Task Con_Disconnected(LavalinkNodeConnection node, NodeDisconnectedEventArgs e)
 		=> this._nodeDisconnected.InvokeAsync(node, e);
-
-	public override void Dispose()
-		=> GC.SuppressFinalize(this);
 }
diff --git a/DisCatSharp.VoiceNext/VoiceNextExtension.cs b/DisCatSharp.VoiceNext/VoiceNextExtension.cs
index 4fa01c4ee..fc7f47b3f 100644
--- a/DisCatSharp.VoiceNext/VoiceNextExtension.cs
+++ b/DisCatSharp.VoiceNext/VoiceNextExtension.cs
@@ -1,268 +1,265 @@
 // 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.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Net;
 using DisCatSharp.VoiceNext.Entities;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.VoiceNext;
 
 /// <summary>
 /// Represents VoiceNext extension, which acts as Discord voice client.
 /// </summary>
 public sealed class VoiceNextExtension : BaseExtension
 {
 	/// <summary>
 	/// Gets or sets the configuration.
 	/// </summary>
 	private readonly VoiceNextConfiguration _configuration;
 
 	/// <summary>
 	/// Gets or sets the active connections.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, VoiceNextConnection> _activeConnections;
 
 	/// <summary>
 	/// Gets or sets the voice state updates.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>> _voiceStateUpdates;
 
 	/// <summary>
 	/// Gets or sets the voice server updates.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>> _voiceServerUpdates;
 
 	/// <summary>
 	/// Gets whether this connection has incoming voice enabled.
 	/// </summary>
 	public bool IsIncomingEnabled { get; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="VoiceNextExtension"/> class.
 	/// </summary>
 	/// <param name="config">The config.</param>
 	internal VoiceNextExtension(VoiceNextConfiguration config)
 	{
 		this._configuration = new VoiceNextConfiguration(config);
 		this.IsIncomingEnabled = config.EnableIncoming;
 
 		this._activeConnections = new ConcurrentDictionary<ulong, VoiceNextConnection>();
 		this._voiceStateUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>>();
 		this._voiceServerUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>>();
 	}
 
 	/// <summary>
 	/// DO NOT USE THIS MANUALLY.
 	/// </summary>
 	/// <param name="client">DO NOT USE THIS MANUALLY.</param>
 	/// <exception cref="System.InvalidOperationException"/>
 	protected internal override void Setup(DiscordClient client)
 	{
 		if (this.Client != null)
 			throw new InvalidOperationException("What did I tell you?");
 
 		this.Client = client;
 
 		this.Client.VoiceStateUpdated += this.Client_VoiceStateUpdate;
 		this.Client.VoiceServerUpdated += this.Client_VoiceServerUpdate;
 	}
 
 	/// <summary>
 	/// Create a VoiceNext connection for the specified channel.
 	/// </summary>
 	/// <param name="channel">Channel to connect to.</param>
 	/// <returns>VoiceNext connection for this channel.</returns>
 	public async Task<VoiceNextConnection> ConnectAsync(DiscordChannel channel)
 	{
 		if (channel.Type != ChannelType.Voice && channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Invalid channel specified; needs to be voice or stage channel", nameof(channel));
 
 		if (channel.Guild == null)
 			throw new ArgumentException("Invalid channel specified; needs to be guild channel", nameof(channel));
 
 		if (!channel.PermissionsFor(channel.Guild.CurrentMember).HasPermission(Permissions.AccessChannels | Permissions.UseVoice))
 			throw new InvalidOperationException("You need AccessChannels and UseVoice permission to connect to this voice channel");
 
 		var gld = channel.Guild;
 		if (this._activeConnections.ContainsKey(gld.Id))
 			throw new InvalidOperationException("This guild already has a voice connection");
 
 		var vstut = new TaskCompletionSource<VoiceStateUpdateEventArgs>();
 		var vsrut = new TaskCompletionSource<VoiceServerUpdateEventArgs>();
 		this._voiceStateUpdates[gld.Id] = vstut;
 		this._voiceServerUpdates[gld.Id] = vsrut;
 
 		var vsd = new VoiceDispatch
 		{
 			OpCode = 4,
 			Payload = new VoiceStateUpdatePayload
 			{
 				GuildId = gld.Id,
 				ChannelId = channel.Id,
 				Deafened = false,
 				Muted = false
 			}
 		};
 		var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
 		await (channel.Discord as DiscordClient).WsSendAsync(vsj).ConfigureAwait(false);
 
 		var vstu = await vstut.Task.ConfigureAwait(false);
 		var vstup = new VoiceStateUpdatePayload
 		{
 			SessionId = vstu.SessionId,
 			UserId = vstu.User.Id
 		};
 		var vsru = await vsrut.Task.ConfigureAwait(false);
 		var vsrup = new VoiceServerUpdatePayload
 		{
 			Endpoint = vsru.Endpoint,
 			GuildId = vsru.Guild.Id,
 			Token = vsru.VoiceToken
 		};
 
 		var vnc = new VoiceNextConnection(this.Client, gld, channel, this._configuration, vsrup, vstup);
 		vnc.VoiceDisconnected += this.Vnc_VoiceDisconnected;
 		await vnc.ConnectAsync().ConfigureAwait(false);
 		await vnc.WaitForReadyAsync().ConfigureAwait(false);
 		this._activeConnections[gld.Id] = vnc;
 		return vnc;
 	}
 
 	/// <summary>
 	/// Gets a VoiceNext connection for specified guild.
 	/// </summary>
 	/// <param name="guild">Guild to get VoiceNext connection for.</param>
 	/// <returns>VoiceNext connection for the specified guild.</returns>
 	public VoiceNextConnection GetConnection(DiscordGuild guild) => this._activeConnections.ContainsKey(guild.Id) ? this._activeConnections[guild.Id] : null;
 
 	/// <summary>
 	/// Vnc_S the voice disconnected.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <returns>A Task.</returns>
 	private async Task Vnc_VoiceDisconnected(DiscordGuild guild)
 	{
 		VoiceNextConnection vnc = null;
 		if (this._activeConnections.ContainsKey(guild.Id))
 			this._activeConnections.TryRemove(guild.Id, out vnc);
 
 		var vsd = new VoiceDispatch
 		{
 			OpCode = 4,
 			Payload = new VoiceStateUpdatePayload
 			{
 				GuildId = guild.Id,
 				ChannelId = null
 			}
 		};
 		var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
 		await (guild.Discord as DiscordClient).WsSendAsync(vsj).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Client_S the voice state update.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The e.</param>
 	/// <returns>A Task.</returns>
 	private Task Client_VoiceStateUpdate(DiscordClient client, VoiceStateUpdateEventArgs e)
 	{
 		var gld = e.Guild;
 		if (gld == null)
 			return Task.CompletedTask;
 
 		if (e.User == null)
 			return Task.CompletedTask;
 
 		if (e.User.Id == this.Client.CurrentUser.Id)
 		{
 			if (e.After.Channel == null && this._activeConnections.TryRemove(gld.Id, out var ac))
 				ac.Disconnect();
 
 			if (this._activeConnections.TryGetValue(e.Guild.Id, out var vnc))
 				vnc.TargetChannel = e.Channel;
 
 			if (!string.IsNullOrWhiteSpace(e.SessionId) && e.Channel != null && this._voiceStateUpdates.TryRemove(gld.Id, out var xe))
 				xe.SetResult(e);
 		}
 
 		return Task.CompletedTask;
 	}
 
 	/// <summary>
 	/// Client_S the voice server update.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The e.</param>
 	/// <returns>A Task.</returns>
 	private async Task Client_VoiceServerUpdate(DiscordClient client, VoiceServerUpdateEventArgs e)
 	{
 		var gld = e.Guild;
 		if (gld == null)
 			return;
 
 		if (this._activeConnections.TryGetValue(e.Guild.Id, out var vnc))
 		{
 			vnc.ServerData = new VoiceServerUpdatePayload
 			{
 				Endpoint = e.Endpoint,
 				GuildId = e.Guild.Id,
 				Token = e.VoiceToken
 			};
 
 			var eps = e.Endpoint;
 			var epi = eps.LastIndexOf(':');
 			var eph = string.Empty;
 			var epp = 443;
 			if (epi != -1)
 			{
 				eph = eps[..epi];
 				epp = int.Parse(eps[(epi + 1)..]);
 			}
 			else
 			{
 				eph = eps;
 			}
 			vnc.WebSocketEndpoint = new ConnectionEndpoint { Hostname = eph, Port = epp };
 
 			vnc.Resume = false;
 			await vnc.ReconnectAsync().ConfigureAwait(false);
 		}
 
 		if (this._voiceServerUpdates.ContainsKey(gld.Id))
 		{
 			this._voiceServerUpdates.TryRemove(gld.Id, out var xe);
 			xe.SetResult(e);
 		}
 	}
-
-	public override void Dispose()
-		=> GC.SuppressFinalize(this);
 }
diff --git a/DisCatSharp/BaseExtension.cs b/DisCatSharp/BaseExtension.cs
index a01275840..2199924bb 100644
--- a/DisCatSharp/BaseExtension.cs
+++ b/DisCatSharp/BaseExtension.cs
@@ -1,44 +1,40 @@
 // 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;
-
 namespace DisCatSharp;
 
 /// <summary>
 /// Represents base for all DisCatSharp extensions. To implement your own extension, extend this class, and implement its abstract members.
 /// </summary>
-public abstract class BaseExtension : IDisposable
+public abstract class BaseExtension
 {
 	/// <summary>
 	/// Gets the instance of <see cref="DiscordClient"/> this extension is attached to.
 	/// </summary>
 	public DiscordClient Client { get; protected set; }
 
 	/// <summary>
 	/// Initializes this extension for given <see cref="DiscordClient"/> instance.
 	/// </summary>
 	/// <param name="client">Discord client to initialize for.</param>
 	protected internal abstract void Setup(DiscordClient client);
-
-	public abstract void Dispose();
 }