diff --git a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
index 735e78a50..9fe47a503 100644
--- a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
+++ b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
@@ -1,1819 +1,1833 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
 
 using DisCatSharp.ApplicationCommands.Attributes;
 using DisCatSharp.ApplicationCommands.EventArgs;
 using DisCatSharp.Common;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.ApplicationCommands;
 
 /// <summary>
 /// A class that handles slash commands for a client.
 /// </summary>
 public sealed class ApplicationCommandsExtension : BaseExtension
 {
 	/// <summary>
 	/// A list of methods for top level commands.
 	/// </summary>
 	private static List<CommandMethod> s_commandMethods { get; set; } = new();
 
 	/// <summary>
 	/// List of groups.
 	/// </summary>
 	private static List<GroupCommand> s_groupCommands { get; set; } = new();
 
 	/// <summary>
 	/// List of groups with subgroups.
 	/// </summary>
 	private static List<SubGroupCommand> s_subGroupCommands { get; set; } = new();
 
 	/// <summary>
 	/// List of context menus.
 	/// </summary>
 	private static List<ContextMenuCommand> s_contextMenuCommands { get; set; } = new();
 
 	/// <summary>
 	/// List of global commands on discords backend.
 	/// </summary>
 	internal static List<DiscordApplicationCommand> GlobalDiscordCommands { get; set; }
 
 	/// <summary>
 	/// List of guild commands on discords backend.
 	/// </summary>
 	internal static Dictionary<ulong, List<DiscordApplicationCommand>> GuildDiscordCommands { get; set; }
 
 	/// <summary>
 	/// Singleton modules.
 	/// </summary>
 	private static List<object> s_singletonModules { get; set; } = new();
 
 	/// <summary>
 	/// List of modules to register.
 	/// </summary>
 	private readonly List<KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>> _updateList = new();
 
 	/// <summary>
 	/// Configuration for Discord.
 	/// </summary>
 	internal static ApplicationCommandsConfiguration Configuration;
 
 	/// <summary>
 	/// Discord client.
 	/// </summary>
 	internal static DiscordClient ClientInternal;
 
 	/// <summary>
 	/// Set to true if anything fails when registering.
 	/// </summary>
 	private static bool s_errored { get; set; }
 
 	/// <summary>
 	/// Gets a list of registered commands. The key is the guild id (null if global).
 	/// </summary>
 	public IReadOnlyList<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> RegisteredCommands
 		=> s_registeredCommands;
 	private static readonly List<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> s_registeredCommands = new();
 
 	/// <summary>
 	/// Gets a list of registered global commands.
 	/// </summary>
 	public IReadOnlyList<DiscordApplicationCommand> GlobalCommands
 		=> GlobalCommandsInternal;
 	internal static readonly List<DiscordApplicationCommand> GlobalCommandsInternal = new();
 
 	/// <summary>
 	/// Gets a list of registered guild commands mapped by guild id.
 	/// </summary>
 	public IReadOnlyDictionary<ulong, IReadOnlyList<DiscordApplicationCommand>> GuildCommands
 	=> GuildCommandsInternal;
 	internal static readonly Dictionary<ulong, IReadOnlyList<DiscordApplicationCommand>> GuildCommandsInternal = new();
 
 	/// <summary>
 	/// Gets the registration count.
 	/// </summary>
 	private static int s_registrationCount { get; set; }
 
 	/// <summary>
 	/// Gets the expected count.
 	/// </summary>
 	private static int s_expectedCount { get; set; }
 
 	/// <summary>
 	/// Gets the guild ids where the applications.commands scope is missing.
 	/// </summary>
 	private IReadOnlyList<ulong> _missingScopeGuildIds;
 
 	/// <summary>
 	/// Gets whether debug is enabled.
 	/// </summary>
 	internal static bool DebugEnabled { get; set; }
 
 	internal static LogLevel ApplicationCommandsLogLevel
 		=> DebugEnabled ? LogLevel.Debug : LogLevel.Trace;
 
 	/// <summary>
 	/// Gets whether check through all guilds is enabled.
 	/// </summary>
 	internal static bool CheckAllGuilds { get; set; }
 
 	/// <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>
 	/// Initializes a new instance of the <see cref="ApplicationCommandsExtension"/> class.
 	/// </summary>
 	/// <param name="configuration">The configuration.</param>
 	internal ApplicationCommandsExtension(ApplicationCommandsConfiguration configuration = null)
 	{
 		Configuration = configuration;
 		DebugEnabled = configuration?.DebugStartup ?? false;
 		CheckAllGuilds = configuration?.CheckAllGuilds ?? false;
 		ManOr = configuration?.ManualOverride ?? false;
 		AutoDeferEnabled = configuration?.AutoDefer ?? false;
 	}
 
 	/// <summary>
 	/// Runs setup.
 	/// <note type="caution">DO NOT RUN THIS MANUALLY. DO NOT DO ANYTHING WITH THIS.</note>
 	/// </summary>
 	/// <param name="client">The client to setup on.</param>
 	protected internal override void Setup(DiscordClient client)
 	{
 		if (this.Client != null)
 			throw new InvalidOperationException("What did I tell you?");
 
 		this.Client = client;
 		ClientInternal = client;
 
 		this._slashError = new AsyncEvent<ApplicationCommandsExtension, SlashCommandErrorEventArgs>("SLASHCOMMAND_ERRORED", TimeSpan.Zero, null);
 		this._slashExecuted = new AsyncEvent<ApplicationCommandsExtension, SlashCommandExecutedEventArgs>("SLASHCOMMAND_EXECUTED", TimeSpan.Zero, null);
 		this._contextMenuErrored = new AsyncEvent<ApplicationCommandsExtension, ContextMenuErrorEventArgs>("CONTEXTMENU_ERRORED", TimeSpan.Zero, null);
 		this._contextMenuExecuted = new AsyncEvent<ApplicationCommandsExtension, ContextMenuExecutedEventArgs>("CONTEXTMENU_EXECUTED", TimeSpan.Zero, null);
 		this._applicationCommandsModuleReady = new AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs>("APPLICATION_COMMANDS_MODULE_READY", TimeSpan.Zero, null);
 		this._applicationCommandsModuleStartupFinished = new AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs>("APPLICATION_COMMANDS_MODULE_STARTUP_FINISHED", TimeSpan.Zero, null);
 		this._globalApplicationCommandsRegistered = new AsyncEvent<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs>("GLOBAL_COMMANDS_REGISTERED", TimeSpan.Zero, null);
 		this._guildApplicationCommandsRegistered = new AsyncEvent<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs>("GUILD_COMMANDS_REGISTERED", TimeSpan.Zero, null);
 
 		this.Client.GuildDownloadCompleted += async (c, e) => await this.UpdateAsync();
 		this.Client.InteractionCreated += this.CatchInteractionsOnStartup;
 		this.Client.ContextMenuInteractionCreated += this.CatchContextMenuInteractionsOnStartup;
 	}
 
 	private async Task CatchInteractionsOnStartup(DiscordClient sender, InteractionCreateEventArgs e)
 		=> await e.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AsEphemeral(true).WithContent("Attention: This application is still starting up. Application commands are unavailable for now."));
 
 	private async Task CatchContextMenuInteractionsOnStartup(DiscordClient sender, ContextMenuInteractionCreateEventArgs e)
 		=> await e.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AsEphemeral(true).WithContent("Attention: This application is still starting up. Context menu commands are unavailable for now."));
 
 	private void FinishedRegistration()
 	{
 		this.Client.InteractionCreated -= this.CatchInteractionsOnStartup;
 		this.Client.ContextMenuInteractionCreated -= this.CatchContextMenuInteractionsOnStartup;
 
 		this.Client.InteractionCreated += this.InteractionHandler;
 		this.Client.ContextMenuInteractionCreated += this.ContextMenuHandler;
 	}
 	/// <summary>
 	/// Cleans the module for a new start of the bot.
 	/// DO NOT USE IF YOU DON'T KNOW WHAT IT DOES.
 	/// </summary>
 	public void CleanModule()
 	{
 		this._updateList.Clear();
 		s_singletonModules.Clear();
 		s_errored = false;
 		s_expectedCount = 0;
 		s_registrationCount = 0;
 		s_commandMethods.Clear();
 		s_groupCommands.Clear();
 		s_contextMenuCommands.Clear();
 		s_subGroupCommands.Clear();
 		s_singletonModules.Clear();
 		s_registeredCommands.Clear();
 		GlobalCommandsInternal.Clear();
 		GuildCommandsInternal.Clear();
 	}
 
 	/// <summary>
 	/// Registers a command class.
 	/// </summary>
 	/// <typeparam name="T">The command class to register.</typeparam>
 	public void RegisterGlobalCommands<T>() where T : ApplicationCommandsModule
 	{
 		if (this.Client.ShardId == 0)
 			this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(typeof(T))));
 	}
 	/// <summary>
 	/// Registers a command class.
 	/// </summary>
 	/// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
 	public void RegisterGlobalCommands(Type type)
 	{
 		if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
 			throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
 		//If sharding, only register for shard 0
 		if (this.Client.ShardId == 0)
 			this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(type)));
 	}
 
 	/// <summary>
 	/// Cleans all guild application commands.
 	/// <note type="caution">You normally don't need to execute it.</note>
 	/// </summary>
 	public async Task CleanGuildCommandsAsync()
 	{
 		foreach (var guild in this.Client.Guilds.Values)
 		{
 			await this.Client.BulkOverwriteGuildApplicationCommandsAsync(guild.Id, Array.Empty<DiscordApplicationCommand>());
 		}
 	}
 
 	/// <summary>
 	/// Cleans the global application commands.
 	/// <note type="caution">You normally don't need to execute it.</note>
 	/// </summary>
 	public async Task CleanGlobalCommandsAsync()
 		=> await this.Client.BulkOverwriteGlobalApplicationCommandsAsync(Array.Empty<DiscordApplicationCommand>());
 
 	/// <summary>
 	/// Registers a command class with permission and translation setup.
 	/// </summary>
 	/// <typeparam name="T">The command class to register.</typeparam>
 	/// <param name="guildId">The guild id to register it on.</param>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGuildCommands<T>(ulong guildId, Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
 	{
 		if (this.Client.ShardId == 0)
 			this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(typeof(T), translationSetup)));
 	}
 
 	/// <summary>
 	/// Registers a command class with permission and translation setup.
 	/// </summary>
 	/// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
 	/// <param name="guildId">The guild id to register it on.</param>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGuildCommands(Type type, ulong guildId, Action<ApplicationCommandsTranslationContext> translationSetup = null)
 	{
 		if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
 			throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
 		//If sharding, only register for shard 0
 		if (this.Client.ShardId == 0)
 			this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(type, translationSetup)));
 	}
 
 	/// <summary>
 	/// Registers a command class with permission setup but without a guild id.
 	/// </summary>
 	/// <typeparam name="T">The command class to register.</typeparam>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGlobalCommands<T>(Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
 	{
 		if (this.Client.ShardId == 0)
 			this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(typeof(T), translationSetup)));
 	}
 
 	/// <summary>
 	/// Registers a command class with permission setup but without a guild id.
 	/// </summary>
 	/// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGlobalCommands(Type type, Action<ApplicationCommandsTranslationContext> translationSetup = null)
 	{
 		if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
 			throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
 		//If sharding, only register for shard 0
 		if (this.Client.ShardId == 0)
 			this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(type, translationSetup)));
 	}
 
 	/// <summary>
 	/// Fired when the application commands module is ready.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs> ApplicationCommandsModuleReady
 	{
 		add => this._applicationCommandsModuleReady.Register(value);
 		remove => this._applicationCommandsModuleReady.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs> _applicationCommandsModuleReady;
 
 	/// <summary>
 	/// Fired when the application commands modules startup is finished.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs> ApplicationCommandsModuleStartupFinished
 	{
 		add => this._applicationCommandsModuleStartupFinished.Register(value);
 		remove => this._applicationCommandsModuleStartupFinished.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs> _applicationCommandsModuleStartupFinished;
 
 
 	/// <summary>
 	/// Fired when guild commands are registered on a guild.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs> GuildApplicationCommandsRegistered
 	{
 		add => this._guildApplicationCommandsRegistered.Register(value);
 		remove => this._guildApplicationCommandsRegistered.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs> _guildApplicationCommandsRegistered;
 
 	/// <summary>
 	/// Fired when the global commands are registered.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs> GlobalApplicationCommandsRegistered
 	{
 		add => this._globalApplicationCommandsRegistered.Register(value);
 		remove => this._globalApplicationCommandsRegistered.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs> _globalApplicationCommandsRegistered;
 
 	/// <summary>
 	/// Used for RegisterCommands and the <see cref="DisCatSharp.DiscordClient.GuildDownloadCompleted"/> event.
 	/// </summary>
 	internal async Task UpdateAsync()
 	{
 		//Only update for shard 0
 		if (this.Client.ShardId == 0)
 		{
 			GlobalDiscordCommands = new();
 			GuildDiscordCommands = new();
 
 			var commandsPending = this._updateList.Select(x => x.Key).Distinct();
 			s_expectedCount = commandsPending.Count();
 
 			this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Expected Count: {s_expectedCount}");
 
 			List<ulong> failedGuilds = new();
 			IEnumerable<DiscordApplicationCommand> globalCommands = null;
 			globalCommands = await this.Client.GetGlobalApplicationCommandsAsync(Configuration?.EnableLocalization ?? false) ?? null;
 			var guilds = CheckAllGuilds ? this.Client.Guilds?.Keys : this._updateList.Select(x => x.Key)?.Distinct().Where(x => x != null)?.Select(x => x.Value);
 
 			foreach (var guild in guilds)
 			{
 				IEnumerable<DiscordApplicationCommand> commands = null;
 				var unauthorized = false;
 				try
 				{
 					commands = await this.Client.GetGuildApplicationCommandsAsync(guild, Configuration?.EnableLocalization ?? false) ?? null;
 				}
 				catch (UnauthorizedException)
 				{
 					unauthorized = true;
 				}
 				finally
 				{
 					if (!unauthorized && commands != null && commands.Any())
 						GuildDiscordCommands.Add(guild, commands.ToList());
 					else if (!unauthorized)
 						GuildDiscordCommands.Add(guild, null);
 					else
 						failedGuilds.Add(guild);
 				}
 			}
 
 			//Default should be to add the help and slash commands can be added without setting any configuration
 			//so this should still add the default help
 			if (Configuration is null || (Configuration is not null && Configuration.EnableDefaultHelp))
 			{
 				this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>
 					(null, new ApplicationCommandsModuleConfiguration(typeof(DefaultHelpModule))));
 				commandsPending = this._updateList.Select(x => x.Key).Distinct();
 			}
 
 			if (globalCommands != null && globalCommands.Any())
 				GlobalDiscordCommands.AddRange(globalCommands);
 
 			foreach (var key in commandsPending.ToList())
 			{
 				this.Client.Logger.LogInformation(key.HasValue ? $"Registering commands in guild {key.Value}" : "Registering global commands.");
 				await this.RegisterCommands(this._updateList.Where(x => x.Key == key).Select(x => x.Value), key);
 			}
 
 			this._missingScopeGuildIds = failedGuilds;
 
 			await this._applicationCommandsModuleReady.InvokeAsync(this, new ApplicationCommandsModuleReadyEventArgs(Configuration?.ServiceProvider)
 			{
 				Handled = true,
 				GuildsWithoutScope = failedGuilds
 			});
 		}
 	}
 
 	/// <summary>
 	/// Method for registering commands for a target from modules.
 	/// </summary>
 	/// <param name="types">The types.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	private async Task RegisterCommands(IEnumerable<ApplicationCommandsModuleConfiguration> types, ulong? guildId)
 	{
 		//Initialize empty lists to be added to the global ones at the end
 		var commandMethods = new List<CommandMethod>();
 		var groupCommands = new List<GroupCommand>();
 		var subGroupCommands = new List<SubGroupCommand>();
 		var contextMenuCommands = new List<ContextMenuCommand>();
 		var updateList = new List<DiscordApplicationCommand>();
 
 		var commandTypeSources = new List<KeyValuePair<Type, Type>>();
 
 		//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 = NestedCommandWorker.ParseSlashGroupsAsync(type, classes, guildId, groupTranslations).Result;
 
 				if (slashGroupsTuple.applicationCommands != null && slashGroupsTuple.applicationCommands.Any())
 					updateList.AddRange(slashGroupsTuple.applicationCommands);
 
 				if (slashGroupsTuple.commandTypeSources != null && slashGroupsTuple.commandTypeSources.Any())
 					commandTypeSources.AddRange(slashGroupsTuple.commandTypeSources);
 
 				if (slashGroupsTuple.singletonModules != null && slashGroupsTuple.singletonModules.Any())
 					s_singletonModules.AddRange(slashGroupsTuple.singletonModules);
 
 				if (slashGroupsTuple.groupCommands != null && slashGroupsTuple.groupCommands.Any())
 					groupCommands.AddRange(slashGroupsTuple.groupCommands);
 
 				if (slashGroupsTuple.subGroupCommands != null && slashGroupsTuple.subGroupCommands.Any())
 					subGroupCommands.AddRange(slashGroupsTuple.subGroupCommands);
 
 				//Handles methods and context menus, only if the module isn't a group itself
 				if (module.GetCustomAttribute<SlashCommandGroupAttribute>() == null)
 				{
 					List<CommandTranslator> commandTranslations = null;
 
 					if (!string.IsNullOrEmpty(ctx.Translations))
 					{
 						commandTranslations = JsonConvert.DeserializeObject<List<CommandTranslator>>(ctx.Translations);
 					}
 
 					//Slash commands
 					var methods = module.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null);
 
 					var slashCommands = CommandWorker.ParseBasicSlashCommandsAsync(type, methods, guildId, commandTranslations).Result;
 
 					if (slashCommands.applicationCommands != null && slashCommands.applicationCommands.Any())
 						updateList.AddRange(slashCommands.applicationCommands);
 
 					if (slashCommands.commandTypeSources != null && slashCommands.commandTypeSources.Any())
 						commandTypeSources.AddRange(slashCommands.commandTypeSources);
 
 					if (slashCommands.commandMethods != null && slashCommands.commandMethods.Any())
 						commandMethods.AddRange(slashCommands.commandMethods);
 
 					//Context Menus
 					var contextMethods = module.DeclaredMethods.Where(x => x.GetCustomAttribute<ContextMenuAttribute>() != null);
 
 					var contextCommands = CommandWorker.ParseContextMenuCommands(type, contextMethods, commandTranslations).Result;
 
 					if (contextCommands.applicationCommands != null && contextCommands.applicationCommands.Any())
 						updateList.AddRange(contextCommands.applicationCommands);
 
 					if (contextCommands.commandTypeSources != null && contextCommands.commandTypeSources.Any())
 						commandTypeSources.AddRange(contextCommands.commandTypeSources);
 
 					if (contextCommands.contextMenuCommands != null && contextCommands.contextMenuCommands.Any())
 						contextMenuCommands.AddRange(contextCommands.contextMenuCommands);
 
 					//Accounts for lifespans
 					if (module.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null && module.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
 					{
 						s_singletonModules.Add(CreateInstance(module, Configuration?.ServiceProvider));
 					}
 				}
 			}
 			catch (Exception ex)
 			{
 				if (ex is BadRequestException brex)
-					this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.JsonMessage}");
+				{
+					this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.WebResponse.Response}");
+				}
 				else
-					this.Client.Logger.LogCritical(ex, $"There was an error parsing the application commands");
+				{
+					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 = RegistrationWorker.RegisterGlobalCommandsAsync(updateList).Result;
 							var actualCommands = regCommands.Distinct().ToList();
 							commands.AddRange(actualCommands);
 							GlobalCommandsInternal.AddRange(actualCommands);
 						}
 						else
 						{
 							foreach (var cmd in GlobalDiscordCommands)
 							{
 								try
 								{
 									await this.Client.DeleteGlobalApplicationCommandAsync(cmd.Id);
 								}
 								catch (NotFoundException)
 								{
 									this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Could not delete global command {cmd.Id}. Please clean up manually");
 								}
 							}
 						}
 					}
 					else
 					{
 						if (updateList != null && updateList.Any())
 						{
-							var regCommands = RegistrationWorker.RegisterGuilldCommandsAsync(guildId.Value, updateList).Result;
+							var regCommands = RegistrationWorker.RegisterGuildCommandsAsync(guildId.Value, updateList).Result;
 							var actualCommands = regCommands.Distinct().ToList();
 							commands.AddRange(actualCommands);
 							GuildCommandsInternal.Add(guildId.Value, actualCommands);
 							if (this.Client.Guilds.TryGetValue(guildId.Value, out var guild))
 							{
 								guild.InternalRegisteredApplicationCommands = new();
 								guild.InternalRegisteredApplicationCommands.AddRange(actualCommands);
 							}
 
 						}
 						else
 						{
 							foreach (var cmd in GuildDiscordCommands[guildId.Value])
 							{
 								try
 								{
 									await this.Client.DeleteGuildApplicationCommandAsync(guildId.Value, cmd.Id);
 								}
 								catch (NotFoundException)
 								{
 									this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Could not delete guild command {cmd.Id} in guild {guildId.Value}. Please clean up manually");
 								}
 							}
 						}
 					}
 				}
 				catch (UnauthorizedException ex)
 				{
 					this.Client.Logger.LogError($"Could not register application commands for guild {guildId}.\nError: {ex.JsonMessage}");
 					return;
 				}
 				//Creates a guild command if a guild id is specified, otherwise global
 				//Checks against the ids and adds them to the command method lists
 				foreach (var command in commands)
 				{
 					if (commandMethods.GetFirstValueWhere(x => x.Name == command.Name, out var com))
 						com.CommandId = command.Id;
 					else if (groupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var groupCom))
 						groupCom.CommandId = command.Id;
 					else if (subGroupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var subCom))
 						subCom.CommandId = command.Id;
 					else if (contextMenuCommands.GetFirstValueWhere(x => x.Name == command.Name, out var cmCom))
 						cmCom.CommandId = command.Id;
 				}
 
 				//Adds to the global lists finally
 				s_commandMethods.AddRange(commandMethods);
 				s_groupCommands.AddRange(groupCommands);
 				s_subGroupCommands.AddRange(subGroupCommands);
 				s_contextMenuCommands.AddRange(contextMenuCommands);
 
 				s_registeredCommands.Add(new KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>(guildId, commands.ToList()));
 
 				foreach (var command in commandMethods)
 				{
 					var app = types.First(t => t.Type == command.Method.DeclaringType);
 				}
 
 				this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Expected Count: {s_expectedCount}\nCurrent Count: {s_registrationCount}");
 
 				if (guildId.HasValue)
 				{
 					await this._guildApplicationCommandsRegistered.InvokeAsync(this, new GuildApplicationCommandsRegisteredEventArgs(Configuration?.ServiceProvider)
 					{
 						Handled = true,
 						GuildId = guildId.Value,
 						RegisteredCommands = GuildCommandsInternal.Any(c => c.Key == guildId.Value) ? GuildCommandsInternal.FirstOrDefault(c => c.Key == guildId.Value).Value : null
 					});
 				}
 				else
 				{
 					await this._globalApplicationCommandsRegistered.InvokeAsync(this, new GlobalApplicationCommandsRegisteredEventArgs(Configuration?.ServiceProvider)
 					{
 						Handled = true,
 						RegisteredCommands = GlobalCommandsInternal
 					});
 				}
 
 				s_registrationCount++;
 				this.CheckRegistrationStartup(ManOr);
 			}
 			catch (Exception ex)
 			{
 				if (ex is BadRequestException brex)
-					this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.JsonMessage}");
+				{
+					this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.WebResponse.Response}");
+				}
 				else
-					this.Client.Logger.LogCritical(ex, $"There was an general error registering application commands");
+				{
+					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\nExpected Count: {s_expectedCount}\nCurrent Count: {s_registrationCount}");
 
 		if ((s_registrationCount == s_expectedCount) || man)
 		{
 			await this._applicationCommandsModuleStartupFinished.InvokeAsync(this, new ApplicationCommandsModuleStartupFinishedEventArgs(Configuration?.ServiceProvider)
 			{
 				Handled = true,
 				RegisteredGlobalCommands = GlobalCommandsInternal,
 				RegisteredGuildCommands = GuildCommandsInternal,
 				GuildsWithoutScope = this._missingScopeGuildIds
 			});
 
 			this.FinishedRegistration();
 		}
 	}
 
 	/// <summary>
 	/// Interaction handler.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The event args.</param>
 	private Task InteractionHandler(DiscordClient client, InteractionCreateEventArgs e)
 	{
 		_ = Task.Run(async () =>
 		{
 			if (e.Interaction.Type == InteractionType.ApplicationCommand)
 			{
 				//Creates the context
 				var context = new InteractionContext
 				{
 					Interaction = e.Interaction,
 					Channel = e.Interaction.Channel,
 					Guild = e.Interaction.Guild,
 					User = e.Interaction.User,
 					Client = client,
 					ApplicationCommandsExtension = this,
 					CommandName = e.Interaction.Data.Name,
 					InteractionId = e.Interaction.Id,
 					Token = e.Interaction.Token,
 					Services = Configuration?.ServiceProvider,
 					ResolvedUserMentions = e.Interaction.Data.Resolved?.Users?.Values.ToList(),
 					ResolvedRoleMentions = e.Interaction.Data.Resolved?.Roles?.Values.ToList(),
 					ResolvedChannelMentions = e.Interaction.Data.Resolved?.Channels?.Values.ToList(),
 					ResolvedAttachments = e.Interaction.Data.Resolved?.Attachments?.Values.ToList(),
 					Type = ApplicationCommandType.ChatInput,
 					Locale = e.Interaction.Locale,
 					GuildLocale = e.Interaction.GuildLocale
 				};
 
 				try
 				{
 					if (s_errored)
 						throw new InvalidOperationException("Slash commands failed to register properly on startup.");
 
 					var methods = s_commandMethods.Where(x => x.CommandId == e.Interaction.Data.Id);
 					var groups = s_groupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 					var subgroups = s_subGroupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 					if (!methods.Any() && !groups.Any() && !subgroups.Any())
 						throw new InvalidOperationException("A slash command was executed, but no command was registered for it.");
 
 					if (methods.Any())
 					{
 						var method = methods.First().Method;
 
 						var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options);
 
 						await this.RunCommandAsync(context, method, args);
 					}
 					else if (groups.Any())
 					{
 						var command = e.Interaction.Data.Options.First();
 						var method = groups.First().Methods.First(x => x.Key == command.Name).Value;
 
 						var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options.First().Options);
 
 						await this.RunCommandAsync(context, method, args);
 					}
 					else if (subgroups.Any())
 					{
 						var command = e.Interaction.Data.Options.First();
 						var group = subgroups.First().SubCommands.First(x => x.Name == command.Name);
 
 						var method = group.Methods.First(x => x.Key == command.Options.First().Name).Value;
 
 						var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options.First().Options.First().Options);
 
 						await this.RunCommandAsync(context, method, args);
 					}
 
 					await this._slashExecuted.InvokeAsync(this, new SlashCommandExecutedEventArgs(this.Client.ServiceProvider) { Context = context });
 				}
 				catch (Exception ex)
 				{
 					await this._slashError.InvokeAsync(this, new SlashCommandErrorEventArgs(this.Client.ServiceProvider) { Context = context, Exception = ex });
 				}
 			}
 			else if (e.Interaction.Type == InteractionType.AutoComplete)
 			{
 				if (s_errored)
 					throw new InvalidOperationException("Slash commands failed to register properly on startup.");
 
 				var methods = s_commandMethods.Where(x => x.CommandId == e.Interaction.Data.Id);
 				var groups = s_groupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 				var subgroups = s_subGroupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 				if (!methods.Any() && !groups.Any() && !subgroups.Any())
 					throw new InvalidOperationException("An autocomplete interaction was created, but no command was registered for it.");
 
 				try
 				{
 					if (methods.Any())
 					{
 						var focusedOption = e.Interaction.Data.Options.First(o => o.Focused);
 						var method = methods.First().Method;
 
 						var option = method.GetParameters().Skip(1).First(p => p.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name);
 						var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
 						var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
 						var providerInstance = Activator.CreateInstance(provider);
 
 						var context = new AutocompleteContext
 						{
 							Interaction = e.Interaction,
 							Client = this.Client,
 							Services = Configuration?.ServiceProvider,
 							ApplicationCommandsExtension = this,
 							Guild = e.Interaction.Guild,
 							Channel = e.Interaction.Channel,
 							User = e.Interaction.User,
 							Options = e.Interaction.Data.Options.ToList(),
 							FocusedOption = focusedOption,
 							Locale = e.Interaction.Locale,
 							GuildLocale = e.Interaction.GuildLocale
 						};
 
 						var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
 						await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
 					}
 					else if (groups.Any())
 					{
 						var command = e.Interaction.Data.Options.First();
 						var group = groups.First().Methods.First(x => x.Key == command.Name).Value;
 
 						var focusedOption = command.Options.First(o => o.Focused);
 						var option = group.GetParameters().Skip(1).First(p => p.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name);
 						var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
 						var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
 						var providerInstance = Activator.CreateInstance(provider);
 
 						var context = new AutocompleteContext
 						{
 							Interaction = e.Interaction,
 							Services = Configuration?.ServiceProvider,
 							ApplicationCommandsExtension = this,
 							Guild = e.Interaction.Guild,
 							Channel = e.Interaction.Channel,
 							User = e.Interaction.User,
 							Options = command.Options.ToList(),
 							FocusedOption = focusedOption,
 							Locale = e.Interaction.Locale,
 							GuildLocale = e.Interaction.GuildLocale
 						};
 
 						var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
 						await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
 					}
 					else if (subgroups.Any())
 					{
 						var command = e.Interaction.Data.Options.First();
 						var group = subgroups.First().SubCommands.First(x => x.Name == command.Name).Methods.First(x => x.Key == command.Options.First().Name).Value;
 
 						var focusedOption = command.Options.First().Options.First(o => o.Focused);
 
 						var option = group.GetParameters().Skip(1).First(p => p.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name);
 						var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
 						var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
 						var providerInstance = Activator.CreateInstance(provider);
 
 						var context = new AutocompleteContext
 						{
 							Interaction = e.Interaction,
 							Services = Configuration?.ServiceProvider,
 							ApplicationCommandsExtension = this,
 							Guild = e.Interaction.Guild,
 							Channel = e.Interaction.Channel,
 							User = e.Interaction.User,
 							Options = command.Options.First().Options.ToList(),
 							FocusedOption = focusedOption,
 							Locale = e.Interaction.Locale,
 							GuildLocale = e.Interaction.GuildLocale
 						};
 
 						var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
 						await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
 					}
 				}
 				catch (Exception ex)
 				{
 					this.Client.Logger.LogError(ex, "Error in autocomplete interaction");
 				}
 			}
 		});
 		return Task.CompletedTask;
 	}
 
 	/// <summary>
 	/// Context menu handler.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The event args.</param>
 	private Task ContextMenuHandler(DiscordClient client, ContextMenuInteractionCreateEventArgs e)
 	{
 		_ = Task.Run(async () =>
 		{
 			//Creates the context
 			var context = new ContextMenuContext
 			{
 				Interaction = e.Interaction,
 				Channel = e.Interaction.Channel,
 				Client = client,
 				Services = Configuration?.ServiceProvider,
 				CommandName = e.Interaction.Data.Name,
 				ApplicationCommandsExtension = this,
 				Guild = e.Interaction.Guild,
 				InteractionId = e.Interaction.Id,
 				User = e.Interaction.User,
 				Token = e.Interaction.Token,
 				TargetUser = e.TargetUser,
 				TargetMessage = e.TargetMessage,
 				Type = e.Type,
 				Locale = e.Interaction.Locale,
 				GuildLocale = e.Interaction.GuildLocale
 			};
 
 			try
 			{
 				if (s_errored)
 					throw new InvalidOperationException("Context menus failed to register properly on startup.");
 
 				//Gets the method for the command
 				var method = s_contextMenuCommands.FirstOrDefault(x => x.CommandId == e.Interaction.Data.Id);
 
 				if (method == null)
 					throw new InvalidOperationException("A context menu was executed, but no command was registered for it.");
 
 				await this.RunCommandAsync(context, method.Method, new[] { context });
 
 				await this._contextMenuExecuted.InvokeAsync(this, new ContextMenuExecutedEventArgs(this.Client.ServiceProvider) { Context = context });
 			}
 			catch (Exception ex)
 			{
 				await this._contextMenuErrored.InvokeAsync(this, new ContextMenuErrorEventArgs(this.Client.ServiceProvider) { Context = context, Exception = ex });
 			}
 		});
 
 		return Task.CompletedTask;
 	}
 
 	/// <summary>
 	/// Runs a command.
 	/// </summary>
 	/// <param name="context">The base context.</param>
 	/// <param name="method">The method info.</param>
 	/// <param name="args">The arguments.</param>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0066:Convert switch statement to expression", Justification = "<Pending>")]
 	internal async Task RunCommandAsync(BaseContext context, MethodInfo method, IEnumerable<object> args)
 	{
 		object classInstance;
 
 		//Accounts for lifespans
 		var moduleLifespan = (method.DeclaringType.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null ? method.DeclaringType.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>()?.Lifespan : ApplicationCommandModuleLifespan.Transient) ?? ApplicationCommandModuleLifespan.Transient;
 		switch (moduleLifespan)
 		{
 			case ApplicationCommandModuleLifespan.Scoped:
 				//Accounts for static methods and adds DI
 				classInstance = method.IsStatic ? ActivatorUtilities.CreateInstance(Configuration?.ServiceProvider.CreateScope().ServiceProvider, method.DeclaringType) : CreateInstance(method.DeclaringType, Configuration?.ServiceProvider.CreateScope().ServiceProvider);
 				break;
 
 			case ApplicationCommandModuleLifespan.Transient:
 				//Accounts for static methods and adds DI
 				classInstance = method.IsStatic ? ActivatorUtilities.CreateInstance(Configuration?.ServiceProvider, method.DeclaringType) : CreateInstance(method.DeclaringType, Configuration?.ServiceProvider);
 				break;
 
 			//If singleton, gets it from the singleton list
 			case ApplicationCommandModuleLifespan.Singleton:
 				classInstance = s_singletonModules.First(x => ReferenceEquals(x.GetType(), method.DeclaringType));
 				break;
 
 			default:
 				throw new Exception($"An unknown {nameof(ApplicationCommandModuleLifespanAttribute)} scope was specified on command {context.CommandName}");
 		}
 
 		ApplicationCommandsModule module = null;
 		if (classInstance is ApplicationCommandsModule mod)
 			module = mod;
 
 		// Slash commands
 		if (context is InteractionContext slashContext)
 		{
 			await this.RunPreexecutionChecksAsync(method, slashContext);
 
 			var shouldExecute = await (module?.BeforeSlashExecutionAsync(slashContext) ?? Task.FromResult(true));
 
 			if (shouldExecute)
 			{
 				if (AutoDeferEnabled)
 					await context.CreateResponseAsync(InteractionResponseType.DeferredChannelMessageWithSource);
 				await (Task)method.Invoke(classInstance, args.ToArray());
 
 				await (module?.AfterSlashExecutionAsync(slashContext) ?? Task.CompletedTask);
 			}
 		}
 		// Context menus
 		if (context is ContextMenuContext contextMenuContext)
 		{
 			await this.RunPreexecutionChecksAsync(method, contextMenuContext);
 
 			var shouldExecute = await (module?.BeforeContextMenuExecutionAsync(contextMenuContext) ?? Task.FromResult(true));
 
 			if (shouldExecute)
 			{
 				if (AutoDeferEnabled)
 					await context.CreateResponseAsync(InteractionResponseType.DeferredChannelMessageWithSource);
 				await (Task)method.Invoke(classInstance, args.ToArray());
 
 				await (module?.AfterContextMenuExecutionAsync(contextMenuContext) ?? Task.CompletedTask);
 			}
 		}
 	}
 
 	/// <summary>
 	/// Property injection
 	/// </summary>
 	/// <param name="t">The type.</param>
 	/// <param name="services">The services.</param>
 	internal static object CreateInstance(Type t, IServiceProvider services)
 	{
 		var ti = t.GetTypeInfo();
 		var constructors = ti.DeclaredConstructors
 			.Where(xci => xci.IsPublic)
 			.ToArray();
 
 		if (constructors.Length != 1)
 			throw new ArgumentException("Specified type does not contain a public constructor or contains more than one public constructor.");
 
 		var constructor = constructors[0];
 		var constructorArgs = constructor.GetParameters();
 		var args = new object[constructorArgs.Length];
 
 		if (constructorArgs.Length != 0 && services == null)
 			throw new InvalidOperationException("Dependency collection needs to be specified for parameterized constructors.");
 
 		// inject via constructor
 		if (constructorArgs.Length != 0)
 			for (var i = 0; i < args.Length; i++)
 				args[i] = services.GetRequiredService(constructorArgs[i].ParameterType);
 
 		var moduleInstance = Activator.CreateInstance(t, args);
 
 		// inject into properties
 		var props = t.GetRuntimeProperties().Where(xp => xp.CanWrite && xp.SetMethod != null && !xp.SetMethod.IsStatic && xp.SetMethod.IsPublic);
 		foreach (var prop in props)
 		{
 			if (prop.GetCustomAttribute<DontInjectAttribute>() != null)
 				continue;
 
 			var service = services.GetService(prop.PropertyType);
 			if (service == null)
 				continue;
 
 			prop.SetValue(moduleInstance, service);
 		}
 
 		// inject into fields
 		var fields = t.GetRuntimeFields().Where(xf => !xf.IsInitOnly && !xf.IsStatic && xf.IsPublic);
 		foreach (var field in fields)
 		{
 			if (field.GetCustomAttribute<DontInjectAttribute>() != null)
 				continue;
 
 			var service = services.GetService(field.FieldType);
 			if (service == null)
 				continue;
 
 			field.SetValue(moduleInstance, service);
 		}
 
 		return moduleInstance;
 	}
 
 	/// <summary>
 	/// Resolves the slash command parameters.
 	/// </summary>
 	/// <param name="e">The event arguments.</param>
 	/// <param name="context">The interaction context.</param>
 	/// <param name="method">The method info.</param>
 	/// <param name="options">The options.</param>
 	private async Task<List<object>> ResolveInteractionCommandParameters(InteractionCreateEventArgs e, InteractionContext context, MethodInfo method, IEnumerable<DiscordInteractionDataOption> options)
 	{
 		var args = new List<object> { context };
 		var parameters = method.GetParameters().Skip(1);
 
 		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<MinimumAttribute>()?.Value ?? null;
 			var maximumValue = parameter.GetCustomAttribute<MaximumAttribute>()?.Value ?? null;
 
 
 			var autocompleteAttribute = parameter.GetCustomAttribute<AutocompleteAttribute>();
 			if (optionAttribute.Autocomplete && autocompleteAttribute == null)
 				throw new ArgumentException("Autocomplete options must have the Autocomplete attribute!");
 			if (!optionAttribute.Autocomplete && autocompleteAttribute != null)
 				throw new ArgumentException("Setting an autocomplete provider requires the option to have autocomplete set to true!");
 
 			//Sets the type
 			var type = parameter.ParameterType;
 			var parameterType = GetParameterType(type);
 
 			//Handles choices
 			//From attributes
 			var choices = GetChoiceAttributesFromParameter(parameter.GetCustomAttributes<ChoiceAttribute>());
 			//From enums
 			if (parameter.ParameterType.IsEnum)
 			{
 				choices = GetChoiceAttributesFromEnumParameter(parameter.ParameterType);
 			}
 			//From choice provider
 			var choiceProviders = parameter.GetCustomAttributes<ChoiceProviderAttribute>();
 			if (choiceProviders.Any())
 			{
 				choices = await GetChoiceAttributesFromProvider(choiceProviders, guildId);
 			}
 
 			var channelTypes = parameter.GetCustomAttribute<ChannelTypesAttribute>()?.ChannelTypes ?? null;
 
 			options.Add(new DiscordApplicationCommandOption(optionAttribute.Name, optionAttribute.Description, parameterType, !parameter.IsOptional, choices, null, channelTypes, optionAttribute.Autocomplete, minimumValue, maximumValue));
 		}
 
 		return options;
 	}
 
 	/// <summary>
 	/// <para>Refreshes your commands, used for refreshing choice providers or applying commands registered after the ready event on the discord client.
 	/// Should only be run on the slash command extension linked to shard 0 if sharding.</para>
 	/// <para>Not recommended and should be avoided since it can make slash commands be unresponsive for a while.</para>
 	/// </summary>
 	public async Task RefreshCommandsAsync()
 	{
 		s_commandMethods.Clear();
 		s_groupCommands.Clear();
 		s_subGroupCommands.Clear();
 		s_registeredCommands.Clear();
 		s_contextMenuCommands.Clear();
 		GlobalDiscordCommands.Clear();
 		GuildDiscordCommands.Clear();
 		GuildCommandsInternal.Clear();
 		GlobalCommandsInternal.Clear();
 		GlobalDiscordCommands = null;
 		GuildDiscordCommands = null;
 		s_errored = false;
 
 		if (Configuration != null && Configuration.EnableDefaultHelp)
 		{
 			this._updateList.RemoveAll(x => x.Value.Type == typeof(DefaultHelpModule));
 		}
 
 		await this.UpdateAsync();
 	}
 
 	/// <summary>
 	/// Fires when the execution of a slash command fails.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, SlashCommandErrorEventArgs> SlashCommandErrored
 	{
 		add => this._slashError.Register(value);
 		remove => this._slashError.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, SlashCommandErrorEventArgs> _slashError;
 
 	/// <summary>
 	/// Fires when the execution of a slash command is successful.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, SlashCommandExecutedEventArgs> SlashCommandExecuted
 	{
 		add => this._slashExecuted.Register(value);
 		remove => this._slashExecuted.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, SlashCommandExecutedEventArgs> _slashExecuted;
 
 	/// <summary>
 	/// Fires when the execution of a context menu fails.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ContextMenuErrorEventArgs> ContextMenuErrored
 	{
 		add => this._contextMenuErrored.Register(value);
 		remove => this._contextMenuErrored.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ContextMenuErrorEventArgs> _contextMenuErrored;
 
 	/// <summary>
 	/// Fire when the execution of a context menu is successful.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ContextMenuExecutedEventArgs> ContextMenuExecuted
 	{
 		add => this._contextMenuExecuted.Register(value);
 		remove => this._contextMenuExecuted.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ContextMenuExecutedEventArgs> _contextMenuExecuted;
 }
 
 /// <summary>
 /// Holds configuration data for setting up an application command.
 /// </summary>
 internal class ApplicationCommandsModuleConfiguration
 {
 	/// <summary>
 	/// The type of the command module.
 	/// </summary>
 	public Type Type { get; }
 
 	/// <summary>
 	/// The translation setup.
 	/// </summary>
 	public Action<ApplicationCommandsTranslationContext> Translations { get; }
 
 	/// <summary>
 	/// Creates a new command configuration.
 	/// </summary>
 	/// <param name="type">The type of the command module.</param>
 	/// <param name="translations">The translation setup callback.</param>
 	public ApplicationCommandsModuleConfiguration(Type type, Action<ApplicationCommandsTranslationContext> translations = null)
 	{
 		this.Type = type;
 		this.Translations = translations;
 	}
 }
 
 /// <summary>
 /// Links a command to its original command module.
 /// </summary>
 internal class ApplicationCommandSourceLink
 {
 	/// <summary>
 	/// The command.
 	/// </summary>
 	public DiscordApplicationCommand ApplicationCommand { get; set; }
 
 	/// <summary>
 	/// The base/root module the command is contained in.
 	/// </summary>
 	public Type RootCommandContainerType { get; set; }
 
 	/// <summary>
 	/// The direct group the command is contained in.
 	/// </summary>
 	public Type CommandContainerType { get; set; }
 }
 
 /// <summary>
 /// The command method.
 /// </summary>
 internal class CommandMethod
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the method.
 	/// </summary>
 	public MethodInfo Method { get; set; }
 }
 
 /// <summary>
 /// The group command.
 /// </summary>
 internal class GroupCommand
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the methods.
 	/// </summary>
 	public List<KeyValuePair<string, MethodInfo>> Methods { get; set; } = null;
 }
 
 /// <summary>
 /// The sub group command.
 /// </summary>
 internal class SubGroupCommand
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the sub commands.
 	/// </summary>
 	public List<GroupCommand> SubCommands { get; set; } = new();
 }
 
 /// <summary>
 /// The context menu command.
 /// </summary>
 internal class ContextMenuCommand
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the method.
 	/// </summary>
 	public MethodInfo Method { get; set; }
 }
 
 #region Default Help
 /// <summary>
 /// Represents the default help module.
 /// </summary>
 internal class DefaultHelpModule : ApplicationCommandsModule
 {
 	public class DefaultHelpAutoCompleteProvider : IAutocompleteProvider
 	{
 		public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 		{
 			var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 
 			IEnumerable<DiscordApplicationCommand> slashCommands = null;
 			var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 			if (context.Guild != null)
 			{
 				var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 				slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First())
 					.Where(ac => ac.Name.StartsWith(context.Options[0].Value.ToString(), StringComparison.OrdinalIgnoreCase))
 					.ToList();
 			}
 			else
 			{
 				await Task.WhenAll(globalCommandsTask);
 				slashCommands = globalCommandsTask.Result
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First())
 					.Where(ac => ac.Name.StartsWith(context.Options[0].Value.ToString(), StringComparison.OrdinalIgnoreCase))
 					.ToList();
 			}
 
 			foreach (var sc in slashCommands.Take(25))
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice(sc.Name, sc.Name.Trim()));
 			}
 			return options.AsEnumerable();
 		}
 	}
 
 	public class DefaultHelpAutoCompleteLevelOneProvider : IAutocompleteProvider
 	{
 		public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 		{
 			var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 			IEnumerable<DiscordApplicationCommand> slashCommands = null;
 			var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 			if (context.Guild != null)
 			{
 				var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 				slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 			else
 			{
 				await Task.WhenAll(globalCommandsTask);
 				slashCommands = globalCommandsTask.Result
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 
 			var command = slashCommands.FirstOrDefault(ac =>
 				ac.Name.Equals(context.Options[0].Value.ToString().Trim(),StringComparison.OrdinalIgnoreCase));
 			if (command is null || command.Options is null)
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 			}
 			else
 			{
 				var opt = command.Options.Where(c => c.Type is ApplicationCommandOptionType.SubCommandGroup or ApplicationCommandOptionType.SubCommand
 													 && c.Name.StartsWith(context.Options[1].Value.ToString(), StringComparison.InvariantCultureIgnoreCase)).ToList();
 				foreach (var option in opt.Take(25))
 				{
 					options.Add(new DiscordApplicationCommandAutocompleteChoice(option.Name, option.Name.Trim()));
 				}
 			}
 			return options.AsEnumerable();
 		}
 	}
 
 	public class DefaultHelpAutoCompleteLevelTwoProvider : IAutocompleteProvider
 	{
 		public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 		{
 			var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 			IEnumerable<DiscordApplicationCommand> slashCommands = null;
 			var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 			if (context.Guild != null)
 			{
 				var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 				slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 			else
 			{
 				await Task.WhenAll(globalCommandsTask);
 				slashCommands = globalCommandsTask.Result
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 
 			var command = slashCommands.FirstOrDefault(ac =>
 				ac.Name.Equals(context.Options[0].Value.ToString().Trim(), StringComparison.OrdinalIgnoreCase));
 			if (command.Options is null)
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 				return options.AsEnumerable();
 			}
 			var foundCommand = command.Options.FirstOrDefault(op => op.Name.Equals(context.Options[1].Value.ToString().Trim(), StringComparison.OrdinalIgnoreCase));
 			if (foundCommand is null || foundCommand.Options is null)
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 			}
 			else
 			{
 				var opt = foundCommand.Options.Where(x => x.Type == ApplicationCommandOptionType.SubCommand &&
 														  x.Name.StartsWith(context.Options[2].Value.ToString(), StringComparison.OrdinalIgnoreCase)).ToList();
 				foreach (var option in opt.Take(25))
 				{
 					options.Add(new DiscordApplicationCommandAutocompleteChoice(option.Name, option.Name.Trim()));
 				}
 			}
 			return options.AsEnumerable();
 		}
 	}
 
 	[SlashCommand("help", "Displays command help")]
 	internal async Task DefaultHelpAsync(InteractionContext ctx,
 		[Autocomplete(typeof(DefaultHelpAutoCompleteProvider))]
 		[Option("option_one", "top level command to provide help for", true)] string commandName,
 		[Autocomplete(typeof(DefaultHelpAutoCompleteLevelOneProvider))]
 		[Option("option_two", "subgroup or command to provide help for", true)] string commandOneName = null,
 		[Autocomplete(typeof(DefaultHelpAutoCompleteLevelTwoProvider))]
 		[Option("option_three", "command to provide help for", true)] string commandTwoName = null)
 	{
 		var globalCommandsTask = ctx.Client.GetGlobalApplicationCommandsAsync();
 		var guildCommandsTask= ctx.Client.GetGuildApplicationCommandsAsync(ctx.Guild.Id);
 
 		await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 
 		var applicationCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 			.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 			.GroupBy(ac => ac.Name).Select(x => x.First())
 			.ToList();
 		if (applicationCommands.Count < 1)
 		{
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder()
 				.WithContent($"There are no slash commands for guild {ctx.Guild.Name}").AsEphemeral(true));
 			return;
 		}
 		if (commandTwoName is not null && !commandTwoName.Equals("no_options_for_this_command"))
 		{
 			var commandsWithSubCommands = applicationCommands.FindAll(ac => ac.Options is not null && ac.Options.Any(op => op.Type == ApplicationCommandOptionType.SubCommandGroup));
 			var cmdParent = commandsWithSubCommands.FirstOrDefault(cm => cm.Options.Any(op => op.Name.Equals(commandOneName))).Options
 					.FirstOrDefault(opt => opt.Name.Equals(commandOneName,StringComparison.OrdinalIgnoreCase));
 			var cmd = cmdParent.Options.FirstOrDefault(op => op.Name.Equals(commandTwoName,StringComparison.OrdinalIgnoreCase));
 			var discordEmbed = new DiscordEmbedBuilder
 			{
 				Title = "Help",
 				Description = $"{Formatter.InlineCode(cmd.Name)}: {cmd.Description ?? "No description provided."}"
 			};
 			if (cmd.Options is not null)
 			{
 				var commandOptions = cmd.Options.ToList();
 				var sb = new StringBuilder();
 
 				foreach (var option in commandOptions)
 					sb.Append('`').Append(option.Name).Append(" (").Append(")`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 				sb.Append('\n');
 				discordEmbed.AddField(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 			}
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 				new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 		}
 		else if (commandOneName is not null && commandTwoName is null && !commandOneName.Equals("no_options_for_this_command"))
 		{
 			var commandsWithOptions = applicationCommands.FindAll(ac => ac.Options is not null && ac.Options.All(op => op.Type == ApplicationCommandOptionType.SubCommand));
 			var subCommandParent = commandsWithOptions.FirstOrDefault(cm => cm.Name.Equals(commandName,StringComparison.OrdinalIgnoreCase));
 			var subCommand = subCommandParent.Options.FirstOrDefault(op => op.Name.Equals(commandOneName,StringComparison.OrdinalIgnoreCase));
 			var discordEmbed = new DiscordEmbedBuilder
 			{
 				Title = "Help",
 				Description = $"{Formatter.InlineCode(subCommand.Name)}: {subCommand.Description ?? "No description provided."}"
 			};
 			if (subCommand.Options is not null)
 			{
 				var commandOptions = subCommand.Options.ToList();
 				var sb = new StringBuilder();
 
 				foreach (var option in commandOptions)
 					sb.Append('`').Append(option.Name).Append(" (").Append(")`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 				sb.Append('\n');
 				discordEmbed.AddField(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 			}
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 				new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 		}
 		else
 		{
 			var command = applicationCommands.FirstOrDefault(cm => cm.Name.Equals(commandName, StringComparison.OrdinalIgnoreCase));
 			if (command is null)
 			{
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder()
 						.WithContent($"No command called {commandName} in guild {ctx.Guild.Name}").AsEphemeral(true));
 				return;
 			}
 			var discordEmbed = new DiscordEmbedBuilder
 			{
 				Title = "Help",
 				Description = $"{Formatter.InlineCode(command.Name)}: {command.Description ?? "No description provided."}"
 			}.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(")`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 				sb.Append('\n');
 				discordEmbed.AddField(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 			}
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 				new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 		}
 	}
 }
 #endregion
diff --git a/DisCatSharp.ApplicationCommands/Attributes/SlashCommand/ChannelTypesAttribute.cs b/DisCatSharp.ApplicationCommands/Attributes/SlashCommand/ChannelTypesAttribute.cs
index 8060f26b4..4f0eb6780 100644
--- a/DisCatSharp.ApplicationCommands/Attributes/SlashCommand/ChannelTypesAttribute.cs
+++ b/DisCatSharp.ApplicationCommands/Attributes/SlashCommand/ChannelTypesAttribute.cs
@@ -1,47 +1,49 @@
 // 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 DisCatSharp.Enums;
+
 namespace DisCatSharp.ApplicationCommands.Attributes;
 
 /// <summary>
 /// Defines allowed channel types for a channel parameter.
 /// </summary>
 [AttributeUsage(AttributeTargets.Parameter)]
 public class ChannelTypesAttribute : Attribute
 {
 	/// <summary>
 	/// Allowed channel types.
 	/// </summary>
 	public IEnumerable<ChannelType> ChannelTypes { get; }
 
 	/// <summary>
 	/// Defines allowed channel types for a channel parameter.
 	/// </summary>
 	/// <param name="channelTypes">The channel types to allow.</param>
 	public ChannelTypesAttribute(params ChannelType[] channelTypes)
 	{
 		this.ChannelTypes = channelTypes;
 	}
 }
diff --git a/DisCatSharp.ApplicationCommands/Checks/ApplicationCommandEqualityChecks.cs b/DisCatSharp.ApplicationCommands/Checks/ApplicationCommandEqualityChecks.cs
index 37347a81c..0f30565f5 100644
--- a/DisCatSharp.ApplicationCommands/Checks/ApplicationCommandEqualityChecks.cs
+++ b/DisCatSharp.ApplicationCommands/Checks/ApplicationCommandEqualityChecks.cs
@@ -1,280 +1,280 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 using System.Linq;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.ApplicationCommands;
 
 internal static class ApplicationCommandEqualityChecks
 {
 	/// <summary>
 	/// Whether two application commands are equal.
 	/// </summary>
 	/// <param name="ac1">Source command.</param>
 	/// <param name="targetApplicationCommand">Command to check against.</param>
 	internal static bool IsEqualTo(this DiscordApplicationCommand ac1, DiscordApplicationCommand targetApplicationCommand)
 	{
 		if (targetApplicationCommand is null || ac1 is null)
 			return false;
 
 		DiscordApplicationCommand sourceApplicationCommand = new(
 			ac1.Name, ac1.Description, ac1.Options,
 			ac1.Type,
 			ac1.NameLocalizations, ac1.DescriptionLocalizations
 		);
 
 		ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC Change Check] Command {ac1.Name}\n\n[{JsonConvert.SerializeObject(sourceApplicationCommand)},{JsonConvert.SerializeObject(targetApplicationCommand)}]\n\n");
 
 		return ac1.Type == targetApplicationCommand.Type && sourceApplicationCommand.SoftEqual(targetApplicationCommand, ac1.Type, ApplicationCommandsExtension.Configuration?.EnableLocalization ?? false);
 	}
 
 	/// <summary>
 	/// Checks softly whether two <see cref="DisCatSharp.Entities.DiscordApplicationCommand"/>s are the same.
 	/// Excluding id, application id and version here.
 	/// </summary>
 	/// <param name="source">Source application command.</param>
 	/// <param name="target">Application command to check against.</param>
 	/// <param name="type">The application command type.</param>
 	/// <param name="localizationEnabled">Whether localization is enabled.</param>
 	internal static bool SoftEqual(this DiscordApplicationCommand source, DiscordApplicationCommand target, ApplicationCommandType type, bool localizationEnabled = false)
 	{
 		return localizationEnabled
 			? type switch
 			{
 				ApplicationCommandType.ChatInput => DeepEqual(source, target, localizationEnabled),
 				_ => (source.Name == target.Name)
 					&& (source.Type == target.Type) && (source.NameLocalizations == target.NameLocalizations)
 					&& (source.DefaultMemberPermissions == target.DefaultMemberPermissions)
-					&& (source.IsNsfw == target.IsNsfw)
+				//&& (source.IsNsfw == target.IsNsfw)
 			}
 			: type switch
 			{
 				ApplicationCommandType.ChatInput => DeepEqual(source, target),
 				_ => (source.Name == target.Name)
 					&& (source.Type == target.Type)
 					&& (source.DefaultMemberPermissions == target.DefaultMemberPermissions)
-					&& (source.IsNsfw == target.IsNsfw)
+				//&& (source.IsNsfw == target.IsNsfw)
 			};
 	}
 
 	/// <summary>
 	/// Checks deeply whether two <see cref="DisCatSharp.Entities.DiscordApplicationCommand"/>s are the same.
 	/// Excluding id, application id and version here.
 	/// </summary>
 	/// <param name="source">Source application command.</param>
 	/// <param name="target">Application command to check against.</param>
 	/// <param name="localizationEnabled">Whether localization is enabled.</param>
 	internal static bool DeepEqual(DiscordApplicationCommand source, DiscordApplicationCommand target, bool localizationEnabled = false)
 	{
 		var rootCheck = (source.Name == target.Name) && (source.Description == target.Description) && (source.Type == target.Type)
-			&& (source.DefaultMemberPermissions == target.DefaultMemberPermissions) && (source.DmPermission == target.DmPermission) && (source.IsNsfw == target.IsNsfw);
+			&& (source.DefaultMemberPermissions == target.DefaultMemberPermissions) && (source.DmPermission == target.DmPermission)/* && (source.IsNsfw == target.IsNsfw)*/;
 		if (localizationEnabled)
 			rootCheck = rootCheck && (source.NameLocalizations == target.NameLocalizations) && (source.DescriptionLocalizations == target.DescriptionLocalizations);
 
 		if (source.Options == null && target.Options == null)
 			return rootCheck;
 		else if ((source.Options != null && target.Options == null) || (source.Options == null && target.Options != null))
 			return false;
 		else if (source.Options.Any(o => o.Type == ApplicationCommandOptionType.SubCommandGroup) && target.Options.Any(o => o.Type == ApplicationCommandOptionType.SubCommandGroup))
 		{
 			List<DiscordApplicationCommandOption> minimalSourceOptions = new();
 			List<DiscordApplicationCommandOption> minimalTargetOptions = new();
 
 			foreach (var option in source.Options)
 			{
 				List<DiscordApplicationCommandOption> minimalSubSourceOptions = new();
 
 				foreach (var subOption in option.Options)
 				{
 					List<DiscordApplicationCommandOption> minimalSubSubSourceOptions = null;
 
 					if (subOption.Options != null)
 					{
 						minimalSubSubSourceOptions = new();
 
 						foreach (var subSubOption in subOption.Options)
 						{
 							minimalSubSubSourceOptions.Add(new DiscordApplicationCommandOption(
 								subSubOption.Name, subSubOption.Description, subSubOption.Type, subSubOption.Required ?? false,
 								subSubOption.Choices, null, subSubOption.ChannelTypes, subSubOption.AutoComplete ?? false,
 								subSubOption.MinimumValue, subSubOption.MaximumValue,
 								localizationEnabled ? subSubOption.NameLocalizations : null,
 								localizationEnabled ? subSubOption.DescriptionLocalizations : null
 							));
 						}
 
 						minimalSubSourceOptions.Add(new DiscordApplicationCommandOption(
 							subOption.Name, subOption.Description, subOption.Type,
 							options: minimalSubSubSourceOptions,
 							nameLocalizations: localizationEnabled ? subOption.NameLocalizations : null,
 							descriptionLocalizations: localizationEnabled ? subOption.DescriptionLocalizations : null
 						));
 					}
 
 				}
 
 				minimalSourceOptions.Add(new DiscordApplicationCommandOption(
 					option.Name, option.Description, option.Type,
 					options: minimalSubSourceOptions,
 					nameLocalizations: localizationEnabled ? option.NameLocalizations : null,
 					descriptionLocalizations: localizationEnabled ? option.DescriptionLocalizations : null
 				));
 			}
 
 			foreach (var option in target.Options)
 			{
 				List<DiscordApplicationCommandOption> minimalSubTargetOptions = new();
 
 				foreach (var subOption in option.Options)
 				{
 					List<DiscordApplicationCommandOption> minimalSubSubTargetOptions = null;
 
 					if (subOption.Options != null && subOption.Options.Any())
 					{
 						minimalSubSubTargetOptions = new();
 
 						foreach (var subSubOption in subOption.Options)
 						{
 							minimalSubSubTargetOptions.Add(new DiscordApplicationCommandOption(
 								subSubOption.Name, subSubOption.Description, subSubOption.Type, subSubOption.Required ?? false,
 								subSubOption.Choices, null, subSubOption.ChannelTypes, subSubOption.AutoComplete ?? false,
 								subSubOption.MinimumValue, subSubOption.MaximumValue,
 								localizationEnabled ? subSubOption.NameLocalizations : null,
 								localizationEnabled ? subSubOption.DescriptionLocalizations : null
 							));
 						}
 
 						minimalSubTargetOptions.Add(new DiscordApplicationCommandOption(
 							subOption.Name, subOption.Description, subOption.Type,
 							options: minimalSubSubTargetOptions,
 							nameLocalizations: localizationEnabled ? subOption.NameLocalizations : null,
 							descriptionLocalizations: localizationEnabled ? subOption.DescriptionLocalizations : null
 						));
 					}
 				}
 
 				minimalTargetOptions.Add(new DiscordApplicationCommandOption(
 					option.Name, option.Description, option.Type,
 					options: minimalSubTargetOptions,
 					nameLocalizations: localizationEnabled ? option.NameLocalizations : null,
 					descriptionLocalizations: localizationEnabled ? option.DescriptionLocalizations : null
 				));
 			}
 
 			return rootCheck && JsonConvert.SerializeObject(minimalSourceOptions) == JsonConvert.SerializeObject(minimalTargetOptions);
 		}
 		else if (source.Options.Any(o => o.Type == ApplicationCommandOptionType.SubCommand) && target.Options.Any(o => o.Type == ApplicationCommandOptionType.SubCommand))
 		{
 			List<DiscordApplicationCommandOption> minimalSourceOptions = new();
 			List<DiscordApplicationCommandOption> minimalTargetOptions = new();
 
 			foreach (var option in source.Options)
 			{
 				List<DiscordApplicationCommandOption> minimalSubSourceOptions =null;
 
 				if (option.Options != null)
 				{
 					minimalSubSourceOptions = new();
 
 					foreach (var subOption in option.Options)
 					{
 						minimalSubSourceOptions.Add(new DiscordApplicationCommandOption(
 							subOption.Name, subOption.Description, subOption.Type, subOption.Required ?? false,
 							subOption.Choices, null, subOption.ChannelTypes, subOption.AutoComplete ?? false,
 							subOption.MinimumValue, subOption.MaximumValue,
 							localizationEnabled ? subOption.NameLocalizations : null,
 							localizationEnabled ? subOption.DescriptionLocalizations : null
 						));
 					}
 				}
 
 				minimalSourceOptions.Add(new DiscordApplicationCommandOption(
 					option.Name, option.Description, option.Type,
 					options: minimalSubSourceOptions,
 					nameLocalizations: localizationEnabled ? option.NameLocalizations : null,
 					descriptionLocalizations: localizationEnabled ? option.DescriptionLocalizations : null
 				));
 			}
 
 			foreach (var option in target.Options)
 			{
 				List<DiscordApplicationCommandOption> minimalSubTargetOptions = null;
 
 				if (option.Options != null && option.Options.Any())
 				{
 					minimalSubTargetOptions = new();
 
 					foreach (var subOption in option.Options)
 					{
 						minimalSubTargetOptions.Add(new DiscordApplicationCommandOption(
 							subOption.Name, subOption.Description, subOption.Type, subOption.Required ?? false,
 							subOption.Choices, null, subOption.ChannelTypes, subOption.AutoComplete ?? false,
 							subOption.MinimumValue, subOption.MaximumValue,
 							localizationEnabled ? subOption.NameLocalizations : null,
 							localizationEnabled ? subOption.DescriptionLocalizations : null
 						));
 					}
 				}
 
 				minimalTargetOptions.Add(new DiscordApplicationCommandOption(
 					option.Name, option.Description, option.Type,
 					options: minimalSubTargetOptions,
 					nameLocalizations: localizationEnabled ? option.NameLocalizations : null,
 					descriptionLocalizations: localizationEnabled ? option.DescriptionLocalizations : null
 				));
 			}
 
 			return rootCheck && JsonConvert.SerializeObject(minimalSourceOptions) == JsonConvert.SerializeObject(minimalTargetOptions);
 		}
 		else
 		{
 			List<DiscordApplicationCommandOption> minimalSourceOptions = new();
 			List<DiscordApplicationCommandOption> minimalTargetOptions = new();
 
 			foreach (var option in source.Options)
 				minimalSourceOptions.Add(new DiscordApplicationCommandOption(
 					option.Name, option.Description, option.Type, option.Required ?? false,
 					option.Choices, null, option.ChannelTypes, option.AutoComplete ?? false, option.MinimumValue, option.MaximumValue,
 					localizationEnabled ? option.NameLocalizations : null,
 					localizationEnabled ? option.DescriptionLocalizations : null
 				));
 
 			foreach (var option in target.Options)
 				minimalTargetOptions.Add(new DiscordApplicationCommandOption(
 					option.Name, option.Description, option.Type, option.Required ?? false,
 					option.Choices, null, option.ChannelTypes, option.AutoComplete ?? false, option.MinimumValue, option.MaximumValue,
 					localizationEnabled ? option.NameLocalizations : null,
 					localizationEnabled ? option.DescriptionLocalizations : null
 				));
 
 			return rootCheck && JsonConvert.SerializeObject(minimalSourceOptions) == JsonConvert.SerializeObject(minimalTargetOptions);
 		}
 	}
 }
diff --git a/DisCatSharp.ApplicationCommands/GlobalSuppressions.cs b/DisCatSharp.ApplicationCommands/GlobalSuppressions.cs
index 45e03fe21..ac9ea0a58 100644
--- a/DisCatSharp.ApplicationCommands/GlobalSuppressions.cs
+++ b/DisCatSharp.ApplicationCommands/GlobalSuppressions.cs
@@ -1,44 +1,44 @@
 // 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.Diagnostics.CodeAnalysis;
 
 [assembly: SuppressMessage("Style", "IDE0044:Add readonly modifier", Justification = "<Pending>", Scope = "member", Target = "~F:DisCatSharp.ApplicationCommands.ApplicationCommandsExtension.s_registeredCommands")]
 [assembly: SuppressMessage("Style", "IDE0018:Inline variable declaration", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.RegistrationWorker.BuildGuildCreateList(System.UInt64,System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand})~System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand}")]
 [assembly: SuppressMessage("Style", "IDE0018:Inline variable declaration", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.RegistrationWorker.BuildGuildDeleteList(System.UInt64,System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand})~System.Collections.Generic.List{System.UInt64}")]
 [assembly: SuppressMessage("Style", "IDE0018:Inline variable declaration", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.RegistrationWorker.BuildGuildOverwriteList(System.UInt64,System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand})~System.ValueTuple{System.Collections.Generic.Dictionary{System.UInt64,DisCatSharp.Entities.DiscordApplicationCommand},System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand}}")]
 [assembly: SuppressMessage("Usage", "CA2254:Template should be a static expression", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.ApplicationCommandsExtension.CheckRegistrationStartup(System.Boolean)")]
 [assembly: SuppressMessage("Usage", "CA2254:Template should be a static expression", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.ApplicationCommandsExtension.RegisterCommands(System.Collections.Generic.IEnumerable{DisCatSharp.ApplicationCommands.ApplicationCommandsModuleConfiguration},System.Nullable{System.UInt64})~System.Threading.Tasks.Task")]
 [assembly: SuppressMessage("Usage", "CA2254:Template should be a static expression", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.ApplicationCommandsExtension.UpdateAsync~System.Threading.Tasks.Task")]
 [assembly: SuppressMessage("Performance", "CA1842:Do not use 'WhenAll' with a single task", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.DefaultHelpModule.DefaultHelpAutoCompleteLevelOneProvider.Provider(DisCatSharp.ApplicationCommands.AutocompleteContext)~System.Threading.Tasks.Task{System.Collections.Generic.IEnumerable{DisCatSharp.Entities.DiscordApplicationCommandAutocompleteChoice}}")]
 [assembly: SuppressMessage("Performance", "CA1842:Do not use 'WhenAll' with a single task", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.DefaultHelpModule.DefaultHelpAutoCompleteLevelTwoProvider.Provider(DisCatSharp.ApplicationCommands.AutocompleteContext)~System.Threading.Tasks.Task{System.Collections.Generic.IEnumerable{DisCatSharp.Entities.DiscordApplicationCommandAutocompleteChoice}}")]
 [assembly: SuppressMessage("Performance", "CA1842:Do not use 'WhenAll' with a single task", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.DefaultHelpModule.DefaultHelpAutoCompleteProvider.Provider(DisCatSharp.ApplicationCommands.AutocompleteContext)~System.Threading.Tasks.Task{System.Collections.Generic.IEnumerable{DisCatSharp.Entities.DiscordApplicationCommandAutocompleteChoice}}")]
 [assembly: SuppressMessage("Usage", "CA2254:Template should be a static expression", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.ApplicationCommandEqualityChecks.IsEqualTo(DisCatSharp.Entities.DiscordApplicationCommand,DisCatSharp.Entities.DiscordApplicationCommand)~System.Boolean")]
 [assembly: SuppressMessage("Usage", "CA2254:Template should be a static expression", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.RegistrationWorker.BuildGlobalOverwriteList(System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand})~System.ValueTuple{System.Collections.Generic.Dictionary{System.UInt64,DisCatSharp.Entities.DiscordApplicationCommand},System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand}}")]
 [assembly: SuppressMessage("Usage", "CA2254:Template should be a static expression", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.RegistrationWorker.BuildGuildOverwriteList(System.UInt64,System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand})~System.ValueTuple{System.Collections.Generic.Dictionary{System.UInt64,DisCatSharp.Entities.DiscordApplicationCommand},System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand}}")]
 [assembly: SuppressMessage("Usage", "CA2254:Template should be a static expression", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.RegistrationWorker.RegisterGlobalCommandsAsync(System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand})~System.Threading.Tasks.Task{System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand}}")]
-[assembly: SuppressMessage("Usage", "CA2254:Template should be a static expression", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.RegistrationWorker.RegisterGuilldCommandsAsync(System.UInt64,System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand})~System.Threading.Tasks.Task{System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand}}")]
+[assembly: SuppressMessage("Usage", "CA2254:Template should be a static expression", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.RegistrationWorker.RegisterGuildCommandsAsync(System.UInt64,System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand})~System.Threading.Tasks.Task{System.Collections.Generic.List{DisCatSharp.Entities.DiscordApplicationCommand}}")]
 [assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.DefaultHelpModule.DefaultHelpAsync(DisCatSharp.ApplicationCommands.InteractionContext,System.String,System.String,System.String)~System.Threading.Tasks.Task")]
 [assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.ApplicationCommandsExtension.RunPreexecutionChecksAsync(System.Reflection.MethodInfo,DisCatSharp.ApplicationCommands.BaseContext)~System.Threading.Tasks.Task")]
 [assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~P:DisCatSharp.ApplicationCommands.ApplicationCommandsExtension.GlobalCommands")]
 [assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~P:DisCatSharp.ApplicationCommands.ApplicationCommandsExtension.GuildCommands")]
 [assembly: SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "<Pending>", Scope = "member", Target = "~P:DisCatSharp.ApplicationCommands.ApplicationCommandsExtension.RegisteredCommands")]
diff --git a/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs b/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs
index b55b76375..9f1bc442a 100644
--- a/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs
+++ b/DisCatSharp.ApplicationCommands/Workers/RegistrationWorker.cs
@@ -1,584 +1,584 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common;
 using DisCatSharp.Entities;
 using DisCatSharp.Exceptions;
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.ApplicationCommands;
 
 /// <summary>
 /// Represents a <see cref="RegistrationWorker"/>.
 /// </summary>
 internal class RegistrationWorker
 {
 	/// <summary>
 	/// Registers the global commands.
 	/// </summary>
 	/// <param name="commands">The command list.</param>
 	/// <returns>A list of registered commands.</returns>
 	internal static async Task<List<DiscordApplicationCommand>> RegisterGlobalCommandsAsync(List<DiscordApplicationCommand> commands)
 	{
 		var (changedCommands, unchangedCommands) = BuildGlobalOverwriteList(commands);
 		var globalCommandsCreateList = BuildGlobalCreateList(commands);
 		var globalCommandsDeleteList = BuildGlobalDeleteList(commands);
 
 		if (globalCommandsCreateList.NotEmptyAndNotNull() && unchangedCommands.NotEmptyAndNotNull() && changedCommands.NotEmptyAndNotNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Creating, re-using and overwriting application commands.");
 
 			foreach (var cmd in globalCommandsCreateList)
 			{
 				var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.CreateGlobalApplicationCommandAsync(cmd);
 				commands.Add(discordBackendCommand);
 			}
 
 			foreach (var cmd in changedCommands)
 			{
 				var command = cmd.Value;
 				var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGlobalApplicationCommandAsync(cmd.Key, action =>
 				{
 					action.Name = command.Name;
 					action.NameLocalizations = command.NameLocalizations;
 					action.Description = command.Description;
 					action.DescriptionLocalizations = command.DescriptionLocalizations;
 					if(command.Options != null && command.Options.Any())
 						action.Options = Entities.Optional.Some(command.Options);
 					if (command.DefaultMemberPermissions.HasValue)
 						action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 					if (command.DmPermission.HasValue)
 						action.DmPermission = command.DmPermission.Value;
-					action.IsNsfw = command.IsNsfw;
+					//action.IsNsfw = command.IsNsfw;
 				});
 
 				commands.Add(discordBackendCommand);
 			}
 
 			commands.AddRange(unchangedCommands);
 		}
 		else if (globalCommandsCreateList.NotEmptyAndNotNull() && (unchangedCommands.NotEmptyAndNotNull() || changedCommands.NotEmptyAndNotNull()))
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Creating, re-using and overwriting application commands.");
 
 			foreach (var cmd in globalCommandsCreateList)
 			{
 				var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.CreateGlobalApplicationCommandAsync(cmd);
 				commands.Add(discordBackendCommand);
 			}
 
 			if (changedCommands.NotEmptyAndNotNull())
 			{
 				foreach (var cmd in changedCommands)
 				{
 					var command = cmd.Value;
 					var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGlobalApplicationCommandAsync(cmd.Key, action =>
 					{
 						action.Name = command.Name;
 						action.NameLocalizations = command.NameLocalizations;
 						action.Description = command.Description;
 						action.DescriptionLocalizations = command.DescriptionLocalizations;
 						if(command.Options != null && command.Options.Any())
 							action.Options = Entities.Optional.Some(command.Options);
 						if (command.DefaultMemberPermissions.HasValue)
 							action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 						if (command.DmPermission.HasValue)
 							action.DmPermission = command.DmPermission.Value;
-						action.IsNsfw = command.IsNsfw;
+						//action.IsNsfw = command.IsNsfw;
 					});
 
 					commands.Add(discordBackendCommand);
 				}
 			}
 
 			if (unchangedCommands.NotEmptyAndNotNull())
 				commands.AddRange(unchangedCommands);
 		}
 		else if (globalCommandsCreateList.EmptyOrNull() && unchangedCommands.NotEmptyAndNotNull() && changedCommands.NotEmptyAndNotNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Editing & re-using application commands.");
 
 			foreach (var cmd in changedCommands)
 			{
 				var command = cmd.Value;
 				var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGlobalApplicationCommandAsync(cmd.Key, action =>
 				{
 					action.Name = command.Name;
 					action.NameLocalizations = command.NameLocalizations;
 					action.Description = command.Description;
 					action.DescriptionLocalizations = command.DescriptionLocalizations;
 					if(command.Options != null && command.Options.Any())
 						action.Options = Entities.Optional.Some(command.Options);
 					if (command.DefaultMemberPermissions.HasValue)
 						action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 					if (command.DmPermission.HasValue)
 						action.DmPermission = command.DmPermission.Value;
-					action.IsNsfw = command.IsNsfw;
+					//action.IsNsfw = command.IsNsfw;
 				});
 
 				commands.Add(discordBackendCommand);
 			}
 
 			commands.AddRange(unchangedCommands);
 		}
 		else if (globalCommandsCreateList.EmptyOrNull() && changedCommands.NotEmptyAndNotNull() && unchangedCommands.EmptyOrNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Overwriting all application commands.");
 
 			List<DiscordApplicationCommand> overwriteList = new();
 			foreach (var overwrite in changedCommands)
 			{
 				var cmd = overwrite.Value;
 				cmd.Id = overwrite.Key;
 				overwriteList.Add(cmd);
 			}
 			var discordBackendCommands = await ApplicationCommandsExtension.ClientInternal.BulkOverwriteGlobalApplicationCommandsAsync(overwriteList);
 			commands.AddRange(discordBackendCommands);
 		}
 		else if (globalCommandsCreateList.NotEmptyAndNotNull() && changedCommands.EmptyOrNull() && unchangedCommands.EmptyOrNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Creating all application commands.");
 
 			var cmds = await ApplicationCommandsExtension.ClientInternal.BulkOverwriteGlobalApplicationCommandsAsync(globalCommandsCreateList);
 			commands.AddRange(cmds);
 		}
 		else if (globalCommandsCreateList.EmptyOrNull() && changedCommands.EmptyOrNull() && unchangedCommands.NotEmptyAndNotNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Re-using all application commands.");
 
 			commands.AddRange(unchangedCommands);
 		}
 
 		if (globalCommandsDeleteList.NotEmptyAndNotNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GLOBAL] Deleting missing application commands.");
 
 			foreach (var cmdId in globalCommandsDeleteList)
 			{
 				try
 				{
 					await ApplicationCommandsExtension.ClientInternal.DeleteGlobalApplicationCommandAsync(cmdId);
 				}
 				catch (NotFoundException)
 				{
 					ApplicationCommandsExtension.ClientInternal.Logger.LogError($"Could not delete global command {cmdId}. Please clean up manually");
 				}
 			}
 		}
 
 		return commands.NotEmptyAndNotNull() ? commands : null;
 	}
 
 	/// <summary>
 	/// Registers the guild commands.
 	/// </summary>
 	/// <param name="guildId">The target guild id.</param>
 	/// <param name="commands">The command list.</param>
 	/// <returns>A list of registered commands.</returns>
-	internal static async Task<List<DiscordApplicationCommand>> RegisterGuilldCommandsAsync(ulong guildId, List<DiscordApplicationCommand> commands)
+	internal static async Task<List<DiscordApplicationCommand>> RegisterGuildCommandsAsync(ulong guildId, List<DiscordApplicationCommand> commands)
 	{
 		var (changedCommands, unchangedCommands) = BuildGuildOverwriteList(guildId, commands);
 		var guildCommandsCreateList = BuildGuildCreateList(guildId, commands);
 		var guildCommandsDeleteList = BuildGuildDeleteList(guildId, commands);
 
 		if (guildCommandsCreateList.NotEmptyAndNotNull() && unchangedCommands.NotEmptyAndNotNull() && changedCommands.NotEmptyAndNotNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Creating, re-using and overwriting application commands. Guild ID: {guildId}");
 
 			foreach (var cmd in guildCommandsCreateList)
 			{
 				var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.CreateGuildApplicationCommandAsync(guildId, cmd);
 				commands.Add(discordBackendCommand);
 			}
 
 			foreach (var cmd in changedCommands)
 			{
 				var command = cmd.Value;
 				var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGuildApplicationCommandAsync(guildId, cmd.Key, action =>
 				{
 					action.Name = command.Name;
 					action.NameLocalizations = command.NameLocalizations;
 					action.Description = command.Description;
 					action.DescriptionLocalizations = command.DescriptionLocalizations;
 					if(command.Options != null && command.Options.Any())
 						action.Options = Entities.Optional.Some(command.Options);
 					if (command.DefaultMemberPermissions.HasValue)
 						action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 					if (command.DmPermission.HasValue)
 						action.DmPermission = command.DmPermission.Value;
-					action.IsNsfw = command.IsNsfw;
+					//action.IsNsfw = command.IsNsfw;
 				});
 
 				commands.Add(discordBackendCommand);
 			}
 
 			commands.AddRange(unchangedCommands);
 		}
 		else if (guildCommandsCreateList.NotEmptyAndNotNull() && (unchangedCommands.NotEmptyAndNotNull() || changedCommands.NotEmptyAndNotNull()))
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Creating, re-using and overwriting application commands. Guild ID: {guildId}");
 
 			foreach (var cmd in guildCommandsCreateList)
 			{
 				var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.CreateGuildApplicationCommandAsync(guildId, cmd);
 				commands.Add(discordBackendCommand);
 			}
 
 			if (changedCommands.NotEmptyAndNotNull())
 			{
 				foreach (var cmd in changedCommands)
 				{
 					var command = cmd.Value;
 					var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGuildApplicationCommandAsync(guildId, cmd.Key, action =>
 					{
 						action.Name = command.Name;
 						action.NameLocalizations = command.NameLocalizations;
 						action.Description = command.Description;
 						action.DescriptionLocalizations = command.DescriptionLocalizations;
 						if(command.Options != null && command.Options.Any())
 							action.Options = Entities.Optional.Some(command.Options);
 						if (command.DefaultMemberPermissions.HasValue)
 							action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 						if (command.DmPermission.HasValue)
 							action.DmPermission = command.DmPermission.Value;
-						action.IsNsfw = command.IsNsfw;
+						//action.IsNsfw = command.IsNsfw;
 					});
 
 					commands.Add(discordBackendCommand);
 				}
 			}
 
 			if (unchangedCommands.NotEmptyAndNotNull())
 				commands.AddRange(unchangedCommands);
 		}
 		else if (guildCommandsCreateList.EmptyOrNull() && unchangedCommands.NotEmptyAndNotNull() && changedCommands.NotEmptyAndNotNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Editing & re-using application commands. Guild ID: {guildId}");
 
 			foreach (var cmd in changedCommands)
 			{
 				var command = cmd.Value;
 				var discordBackendCommand = await ApplicationCommandsExtension.ClientInternal.EditGuildApplicationCommandAsync(guildId, cmd.Key, action =>
 				{
 					action.Name = command.Name;
 					action.NameLocalizations = command.NameLocalizations;
 					action.Description = command.Description;
 					action.DescriptionLocalizations = command.DescriptionLocalizations;
 					if(command.Options != null && command.Options.Any())
 						action.Options = Entities.Optional.Some(command.Options);
 					if (command.DefaultMemberPermissions.HasValue)
 						action.DefaultMemberPermissions = command.DefaultMemberPermissions.Value;
 					if (command.DmPermission.HasValue)
 						action.DmPermission = command.DmPermission.Value;
-					action.IsNsfw = command.IsNsfw;
+					//action.IsNsfw = command.IsNsfw;
 				});
 
 				commands.Add(discordBackendCommand);
 			}
 
 			commands.AddRange(unchangedCommands);
 		}
 		else if (guildCommandsCreateList.EmptyOrNull() && changedCommands.NotEmptyAndNotNull() && unchangedCommands.EmptyOrNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Overwriting all application commands. Guild ID: {guildId}");
 
 			List<DiscordApplicationCommand> overwriteList = new();
 			foreach (var overwrite in changedCommands)
 			{
 				var cmd = overwrite.Value;
 				cmd.Id = overwrite.Key;
 				overwriteList.Add(cmd);
 			}
 			var discordBackendCommands = await ApplicationCommandsExtension.ClientInternal.BulkOverwriteGuildApplicationCommandsAsync(guildId, overwriteList);
 			commands.AddRange(discordBackendCommands);
 		}
 		else if (guildCommandsCreateList.NotEmptyAndNotNull() && changedCommands.EmptyOrNull() && unchangedCommands.EmptyOrNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Creating all application commands. Guild ID: {guildId}");
 
 			var cmds = await ApplicationCommandsExtension.ClientInternal.BulkOverwriteGuildApplicationCommandsAsync(guildId, guildCommandsCreateList);
 			commands.AddRange(cmds);
 		}
 		else if (guildCommandsCreateList.EmptyOrNull() && changedCommands.EmptyOrNull() && unchangedCommands.NotEmptyAndNotNull())
 		{
 			ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Re-using all application commands Guild ID: {guildId}.");
 
 			commands.AddRange(unchangedCommands);
 		}
 
 		if (guildCommandsDeleteList.NotEmptyAndNotNull())
 		{
 			foreach (var cmdId in guildCommandsDeleteList)
 			{
 				ApplicationCommandsExtension.ClientInternal.Logger.Log(ApplicationCommandsExtension.ApplicationCommandsLogLevel, $"[AC GUILD] Deleting missing application commands. Guild ID: {guildId}");
 				try
 				{
 					await ApplicationCommandsExtension.ClientInternal.DeleteGuildApplicationCommandAsync(guildId, cmdId);
 				}
 				catch (NotFoundException)
 				{
 					ApplicationCommandsExtension.ClientInternal.Logger.LogError($"Could not delete guild command {cmdId} in guild {guildId}. Please clean up manually");
 				}
 			}
 		}
 
 		return commands.NotEmptyAndNotNull() ? commands : null;
 	}
 
 	/// <summary>
 	/// Builds a list of guild command ids to be deleted on discords backend.
 	/// </summary>
 	/// <param name="guildId">The guild id these commands belong to.</param>
 	/// <param name="updateList">The command list.</param>
 	/// <returns>A list of command ids.</returns>
 	private static List<ulong> BuildGuildDeleteList(ulong guildId, List<DiscordApplicationCommand> updateList)
 	{
 		List<DiscordApplicationCommand> discord;
 
 		if (ApplicationCommandsExtension.GuildDiscordCommands == null || !ApplicationCommandsExtension.GuildDiscordCommands.Any()
 			|| !ApplicationCommandsExtension.GuildDiscordCommands.GetFirstValueByKey(guildId, out discord)
 		)
 			return null;
 
 		List<ulong> invalidCommandIds = new();
 
 		if (discord == null)
 			return null;
 
 		if (updateList == null)
 		{
 			foreach (var cmd in discord)
 			{
 				invalidCommandIds.Add(cmd.Id);
 			}
 		}
 		else
 		{
 			foreach (var cmd in discord)
 			{
 				if (!updateList.Any(ul => ul.Name == cmd.Name))
 					invalidCommandIds.Add(cmd.Id);
 			}
 		}
 
 		return invalidCommandIds;
 	}
 
 	/// <summary>
 	/// Builds a list of guild commands to be created on discords backend.
 	/// </summary>
 	/// <param name="guildId">The guild id these commands belong to.</param>
 	/// <param name="updateList">The command list.</param>
 	/// <returns></returns>
 	private static List<DiscordApplicationCommand> BuildGuildCreateList(ulong guildId, List<DiscordApplicationCommand> updateList)
 	{
 		List<DiscordApplicationCommand> discord;
 
 		if (ApplicationCommandsExtension.GuildDiscordCommands == null || !ApplicationCommandsExtension.GuildDiscordCommands.Any()
 			|| updateList == null || !ApplicationCommandsExtension.GuildDiscordCommands.GetFirstValueByKey(guildId, out discord)
 		)
 			return updateList;
 
 		List<DiscordApplicationCommand> newCommands = new();
 
 		if (discord == null)
 			return updateList;
 
 		foreach (var cmd in updateList)
 		{
 			if (discord.All(d => d.Name != cmd.Name))
 			{
 				newCommands.Add(cmd);
 			}
 		}
 
 		return newCommands;
 	}
 
 	/// <summary>
 	/// Builds a list of guild commands to be overwritten on discords backend.
 	/// </summary>
 	/// <param name="guildId">The guild id these commands belong to.</param>
 	/// <param name="updateList">The command list.</param>
 	/// <returns>A dictionary of command id and command.</returns>
 	private static (
 			Dictionary<ulong, DiscordApplicationCommand> changedCommands,
 			List<DiscordApplicationCommand> unchangedCommands
 		) BuildGuildOverwriteList(ulong guildId, List<DiscordApplicationCommand> updateList)
 	{
 		List<DiscordApplicationCommand> discord;
 
 		if (ApplicationCommandsExtension.GuildDiscordCommands == null || !ApplicationCommandsExtension.GuildDiscordCommands.Any()
 			|| ApplicationCommandsExtension.GuildDiscordCommands.All(l => l.Key != guildId) || updateList == null
 			|| !ApplicationCommandsExtension.GuildDiscordCommands.GetFirstValueByKey(guildId, out discord)
 		)
 			return (null, null);
 
 		Dictionary<ulong, DiscordApplicationCommand> updateCommands = new();
 		List<DiscordApplicationCommand> unchangedCommands = new();
 
 		if (discord == null)
 			return (null, null);
 
 		foreach (var cmd in updateList)
 		{
 			if (discord.GetFirstValueWhere(d => d.Name == cmd.Name, out var command))
 			{
 				if (command.IsEqualTo(cmd))
 				{
 					if (ApplicationCommandsExtension.DebugEnabled)
 						ApplicationCommandsExtension.ClientInternal.Logger.LogDebug($"[AC] Command {cmd.Name} unchanged");
 					cmd.Id = command.Id;
 					cmd.ApplicationId = command.ApplicationId;
 					cmd.Version = command.Version;
 					unchangedCommands.Add(cmd);
 				}
 				else
 				{
 					if (ApplicationCommandsExtension.DebugEnabled)
 						ApplicationCommandsExtension.ClientInternal.Logger.LogDebug($"[AC] Command {cmd.Name} changed");
 					updateCommands.Add(command.Id, cmd);
 				}
 			}
 		}
 
 		return (updateCommands, unchangedCommands);
 	}
 
 	/// <summary>
 	/// Builds a list of global command ids to be deleted on discords backend.
 	/// </summary>
 	/// <param name="updateList">The command list.</param>
 	/// <returns>A list of command ids.</returns>
 	private static List<ulong> BuildGlobalDeleteList(List<DiscordApplicationCommand> updateList = null)
 	{
 		if (ApplicationCommandsExtension.GlobalDiscordCommands == null || !ApplicationCommandsExtension.GlobalDiscordCommands.Any()
 			|| ApplicationCommandsExtension.GlobalDiscordCommands == null
 		)
 			return null;
 
 		var discord = ApplicationCommandsExtension.GlobalDiscordCommands;
 
 		List<ulong> invalidCommandIds = new();
 
 		if (discord == null)
 			return null;
 
 		if (updateList == null)
 		{
 			foreach (var cmd in discord)
 			{
 				invalidCommandIds.Add(cmd.Id);
 			}
 		}
 		else
 		{
 			foreach (var cmd in discord)
 			{
 				if (updateList.All(ul => ul.Name != cmd.Name))
 					invalidCommandIds.Add(cmd.Id);
 			}
 		}
 
 		return invalidCommandIds;
 	}
 
 	/// <summary>
 	/// Builds a list of global commands to be created on discords backend.
 	/// </summary>
 	/// <param name="updateList">The command list.</param>
 	/// <returns>A list of commands.</returns>
 	private static List<DiscordApplicationCommand> BuildGlobalCreateList(List<DiscordApplicationCommand> updateList)
 	{
 		if (ApplicationCommandsExtension.GlobalDiscordCommands == null || !ApplicationCommandsExtension.GlobalDiscordCommands.Any() || updateList == null)
 			return updateList;
 
 		var discord = ApplicationCommandsExtension.GlobalDiscordCommands;
 
 		List<DiscordApplicationCommand> newCommands = new();
 
 		if (discord == null)
 			return updateList;
 
 		foreach (var cmd in updateList)
 		{
 			if (discord.All(d => d.Name != cmd.Name))
 			{
 				newCommands.Add(cmd);
 			}
 		}
 
 		return newCommands;
 	}
 
 	/// <summary>
 	/// Builds a list of global commands to be overwritten on discords backend.
 	/// </summary>
 	/// <param name="updateList">The command list.</param>
 	/// <returns>A dictionary of command ids and commands.</returns>
 	private static (
 			Dictionary<ulong, DiscordApplicationCommand> changedCommands,
 			List<DiscordApplicationCommand> unchangedCommands
 		) BuildGlobalOverwriteList(List<DiscordApplicationCommand> updateList)
 	{
 		if (ApplicationCommandsExtension.GlobalDiscordCommands == null || !ApplicationCommandsExtension.GlobalDiscordCommands.Any()
 			|| updateList == null || ApplicationCommandsExtension.GlobalDiscordCommands == null
 		)
 			return (null, null);
 
 		var discord = ApplicationCommandsExtension.GlobalDiscordCommands;
 
 		if (discord == null)
 			return (null, null);
 
 		Dictionary<ulong, DiscordApplicationCommand> updateCommands = new();
 		List<DiscordApplicationCommand> unchangedCommands = new();
 		foreach (var cmd in updateList)
 		{
 			if (discord.GetFirstValueWhere(d => d.Name == cmd.Name, out var command))
 			{
 				if (command.IsEqualTo(cmd))
 				{
 					if (ApplicationCommandsExtension.DebugEnabled)
 						ApplicationCommandsExtension.ClientInternal.Logger.LogDebug($"[AC] Command {cmd.Name} unchanged");
 					cmd.Id = command.Id;
 					cmd.ApplicationId = command.ApplicationId;
 					cmd.Version = command.Version;
 					unchangedCommands.Add(cmd);
 				}
 				else
 				{
 					if (ApplicationCommandsExtension.DebugEnabled)
 						ApplicationCommandsExtension.ClientInternal.Logger.LogDebug($"[AC] Command {cmd.Name} changed");
 					updateCommands.Add(command.Id, cmd);
 				}
 			}
 		}
 
 		return (updateCommands, unchangedCommands);
 	}
 }
diff --git a/DisCatSharp.Docs/index.md b/DisCatSharp.Docs/index.md
index 4aec8a576..ee37e095c 100644
--- a/DisCatSharp.Docs/index.md
+++ b/DisCatSharp.Docs/index.md
@@ -1,18 +1,18 @@
 ---
 uid: index
 title: DisCatSharp 10.0.0 Documentation
 ---
 
 <h1 class="delete-this">DisCatSharp 10.0.0 Documentation</h1>
 <h1 class="logo-center">![DisCatSharp Logo](/logobig.png "DisCatSharp Documentation")</h1>
 ## DisCatSharp 10.0.0 Documentation
 [DisCatSharp](https://github.com/Aiko-IT-Systems/DisCatSharp) (DCS) is an unofficial .NET wrapper for the [Discord API](https://discordapp.com/developers/docs/intro "Discord API") based off [DSharpPlus](https://github.com/DSharpPlus/DSharpPlus).<br/>
 The library has been rewritten to fit quality and API standards as well as target wider range of .NET implementations. Furthermore this lib will includes many new features of Discord and is pretty fast with keeping up with Discords API.
 
 ## Getting Started
 New users probably want to take a look into the [articles](xref:preamble) for quick start guides, tutorials, and examples of use.<br/>
 Once you've gotten through the articles, head over to the [API Documentation](/api/index.html) for all classes and methods provided by this library.
 
 ## Source and Contributors
-DisCatSharp is licensed under MIT License, as detailed in the [license](https://github.com/Aiko-IT-Systems/DisCatSharp/blob/master/LICENSE.md) found in the repository.<br/>
+DisCatSharp is licensed under MIT License, as detailed in the [license](https://github.com/Aiko-IT-Systems/DisCatSharp/blob/main/LICENSE.md) found in the repository.<br/>
 The repository containing the source code for this library can be found [here](https://github.com/Aiko-IT-Systems/DisCatSharp). Contributions are welcomed.<br/>
diff --git a/DisCatSharp.Interactivity/EventHandling/Components/ComponentPaginator.cs b/DisCatSharp.Interactivity/EventHandling/Components/ComponentPaginator.cs
index 50915b8b1..1f8798141 100644
--- a/DisCatSharp.Interactivity/EventHandling/Components/ComponentPaginator.cs
+++ b/DisCatSharp.Interactivity/EventHandling/Components/ComponentPaginator.cs
@@ -1,182 +1,182 @@
 // 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.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Interactivity.Enums;
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Interactivity.EventHandling;
 
 /// <summary>
 /// The component paginator.
 /// </summary>
 internal class ComponentPaginator : IPaginator
 {
 	private readonly DiscordClient _client;
 	private readonly InteractivityConfiguration _config;
 	private readonly DiscordMessageBuilder _builder = new();
 	private readonly Dictionary<ulong, IPaginationRequest> _requests = new();
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="ComponentPaginator"/> class.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="config">The config.</param>
 	public ComponentPaginator(DiscordClient client, InteractivityConfiguration config)
 	{
 		this._client = client;
 		this._client.ComponentInteractionCreated += this.Handle;
 		this._config = config;
 	}
 
 	/// <summary>
 	/// Does the pagination async.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	public async Task DoPaginationAsync(IPaginationRequest request)
 	{
 		var id = (await request.GetMessageAsync().ConfigureAwait(false)).Id;
 		this._requests.Add(id, request);
 
 		try
 		{
 			var tcs = await request.GetTaskCompletionSourceAsync().ConfigureAwait(false);
 			await tcs.Task.ConfigureAwait(false);
 		}
 		catch (Exception ex)
 		{
 			this._client.Logger.LogError(InteractivityEvents.InteractivityPaginationError, ex, "There was an exception while paginating.");
 		}
 		finally
 		{
 			this._requests.Remove(id);
 			try
 			{
 				await request.DoCleanupAsync().ConfigureAwait(false);
 			}
 			catch (Exception ex)
 			{
 				this._client.Logger.LogError(InteractivityEvents.InteractivityPaginationError, ex, "There was an exception while cleaning up pagination.");
 			}
 		}
 	}
 
 	/// <summary>
 	/// Disposes the paginator.
 	/// </summary>
 	public void Dispose() => this._client.ComponentInteractionCreated -= this.Handle;
 
 
 	/// <summary>
 	/// Handles the pagination event.
 	/// </summary>
 	/// <param name="_">The client.</param>
 	/// <param name="e">The event arguments.</param>
 	private async Task Handle(DiscordClient _, ComponentInteractionCreateEventArgs e)
 	{
 		if (e.Interaction.Type == InteractionType.ModalSubmit)
 			return;
 
 		if (!this._requests.TryGetValue(e.Message.Id, out var req))
 			return;
 
 		if (this._config.AckPaginationButtons)
 		{
 			e.Handled = true;
 			await e.Interaction.CreateResponseAsync(InteractionResponseType.DeferredMessageUpdate).ConfigureAwait(false);
 		}
 
 		if (await req.GetUserAsync().ConfigureAwait(false) != e.User)
 		{
 			if (this._config.ResponseBehavior is InteractionResponseBehavior.Respond)
 				await e.Interaction.CreateFollowupMessageAsync(new DiscordFollowupMessageBuilder { Content = this._config.ResponseMessage, IsEphemeral = true }).ConfigureAwait(false);
 
 			return;
 		}
 
 		if (req is InteractionPaginationRequest ipr)
 			ipr.RegenerateCts(e.Interaction); // Necessary to ensure we don't prematurely yeet the CTS //
 
 		await this.HandlePaginationAsync(req, e).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the pagination async.
 	/// </summary>
 	/// <param name="request">The request.</param>
 	/// <param name="args">The arguments.</param>
 	private async Task HandlePaginationAsync(IPaginationRequest request, ComponentInteractionCreateEventArgs args)
 	{
 		var buttons = this._config.PaginationButtons;
 		var msg = await request.GetMessageAsync().ConfigureAwait(false);
 		var id = args.Id;
 		var tcs = await request.GetTaskCompletionSourceAsync().ConfigureAwait(false);
 
 #pragma warning disable CS8846 // The switch expression does not handle all possible values of its input type (it is not exhaustive).
 		var paginationTask = id switch
 #pragma warning restore CS8846 // The switch expression does not handle all possible values of its input type (it is not exhaustive).
-            {
+		{
 			_ when id == buttons.SkipLeft.CustomId => request.SkipLeftAsync(),
 			_ when id == buttons.SkipRight.CustomId => request.SkipRightAsync(),
 			_ when id == buttons.Stop.CustomId => Task.FromResult(tcs.TrySetResult(true)),
 			_ when id == buttons.Left.CustomId => request.PreviousPageAsync(),
 			_ when id == buttons.Right.CustomId => request.NextPageAsync(),
 		};
 
 		await paginationTask.ConfigureAwait(false);
 
 		if (id == buttons.Stop.CustomId)
 			return;
 
 		var page = await request.GetPageAsync().ConfigureAwait(false);
 
 
 		var bts = await request.GetButtonsAsync().ConfigureAwait(false);
 
 		if (request is InteractionPaginationRequest ipr)
 		{
 			var builder = new DiscordWebhookBuilder()
 				.WithContent(page.Content)
 				.AddEmbed(page.Embed)
 				.AddComponents(bts);
 
 			await args.Interaction.EditOriginalResponseAsync(builder).ConfigureAwait(false);
 			return;
 		}
 
 		this._builder.Clear();
 
 		this._builder
 			.WithContent(page.Content)
 			.AddEmbed(page.Embed)
 			.AddComponents(bts);
 
 		await this._builder.ModifyAsync(msg).ConfigureAwait(false);
 
 	}
 }
diff --git a/DisCatSharp.Lavalink/DiscordClientExtensions.cs b/DisCatSharp.Lavalink/DiscordClientExtensions.cs
index c30f9038e..75a21d526 100644
--- a/DisCatSharp.Lavalink/DiscordClientExtensions.cs
+++ b/DisCatSharp.Lavalink/DiscordClientExtensions.cs
@@ -1,131 +1,132 @@
 // 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.Tasks;
 
 using DisCatSharp.Entities;
+using DisCatSharp.Enums;
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp.Lavalink;
 
 /// <summary>
 /// The discord client extensions.
 /// </summary>
 public static class DiscordClientExtensions
 {
 	/// <summary>
 	/// Creates a new Lavalink client with specified settings.
 	/// </summary>
 	/// <param name="client">Discord client to create Lavalink instance for.</param>
 	/// <returns>Lavalink client instance.</returns>
 	public static LavalinkExtension UseLavalink(this DiscordClient client)
 	{
 		if (client.GetExtension<LavalinkExtension>() != null)
 			throw new InvalidOperationException("Lavalink is already enabled for that client.");
 
 		if (!client.Configuration.Intents.HasIntent(DiscordIntents.GuildVoiceStates))
 			client.Logger.LogCritical(LavalinkEvents.Intents, "The Lavalink extension is registered but the guild voice states intent is not enabled. It is highly recommended to enable it.");
 
 		var lava = new LavalinkExtension();
 		client.AddExtension(lava);
 		return lava;
 	}
 
 	/// <summary>
 	/// Creates new Lavalink clients on all shards in a given sharded client.
 	/// </summary>
 	/// <param name="client">Discord sharded client to create Lavalink instances for.</param>
 	/// <returns>A dictionary of created Lavalink clients.</returns>
 	public static async Task<IReadOnlyDictionary<int, LavalinkExtension>> UseLavalinkAsync(this DiscordShardedClient client)
 	{
 		var modules = new Dictionary<int, LavalinkExtension>();
 		await client.InitializeShardsAsync().ConfigureAwait(false);
 
 		foreach (var shard in client.ShardClients.Select(xkvp => xkvp.Value))
 		{
 			var lava = shard.GetExtension<LavalinkExtension>();
 			if (lava == null)
 				lava = shard.UseLavalink();
 
 			modules[shard.ShardId] = lava;
 		}
 
 		return new ReadOnlyDictionary<int, LavalinkExtension>(modules);
 	}
 
 	/// <summary>
 	/// Gets the active instance of the Lavalink client for the DiscordClient.
 	/// </summary>
 	/// <param name="client">Discord client to get Lavalink instance for.</param>
 	/// <returns>Lavalink client instance.</returns>
 	public static LavalinkExtension GetLavalink(this DiscordClient client)
 		=> client.GetExtension<LavalinkExtension>();
 
 	/// <summary>
 	/// Retrieves a <see cref="LavalinkExtension"/> instance for each shard.
 	/// </summary>
 	/// <param name="client">The shard client to retrieve <see cref="LavalinkExtension"/> instances from.</param>
 	/// <returns>A dictionary containing <see cref="LavalinkExtension"/> instances for each shard.</returns>
 	public static async Task<IReadOnlyDictionary<int, LavalinkExtension>> GetLavalinkAsync(this DiscordShardedClient client)
 	{
 		await client.InitializeShardsAsync().ConfigureAwait(false);
 		var extensions = new Dictionary<int, LavalinkExtension>();
 
 		foreach (var shard in client.ShardClients.Values)
 		{
 			extensions.Add(shard.ShardId, shard.GetExtension<LavalinkExtension>());
 		}
 
 		return new ReadOnlyDictionary<int, LavalinkExtension>(extensions);
 	}
 
 	/// <summary>
 	/// Connects to this voice channel using Lavalink.
 	/// </summary>
 	/// <param name="channel">Channel to connect to.</param>
 	/// <param name="node">Lavalink node to connect through.</param>
 	/// <returns>If successful, the Lavalink client.</returns>
 	public static Task ConnectAsync(this DiscordChannel channel, LavalinkNodeConnection node)
 	{
 		if (channel == null)
 			throw new NullReferenceException();
 
 		if (channel.Guild == null)
 			throw new InvalidOperationException("Lavalink can only be used with guild channels.");
 
 		if (channel.Type != ChannelType.Voice && channel.Type != ChannelType.Stage)
 			throw new InvalidOperationException("You can only connect to voice and stage channels.");
 
 		if (channel.Discord is not DiscordClient discord || discord == null)
 			throw new NullReferenceException();
 
 		var lava = discord.GetLavalink();
 		return lava == null
 			? throw new InvalidOperationException("Lavalink is not initialized for this Discord client.")
 			: node.ConnectAsync(channel);
 	}
 }
diff --git a/DisCatSharp.Lavalink/EventArgs/PlayerUpdateEventArgs.cs b/DisCatSharp.Lavalink/EventArgs/PlayerUpdateEventArgs.cs
index ee41275fe..58c0d541b 100644
--- a/DisCatSharp.Lavalink/EventArgs/PlayerUpdateEventArgs.cs
+++ b/DisCatSharp.Lavalink/EventArgs/PlayerUpdateEventArgs.cs
@@ -1,68 +1,69 @@
 // 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 DisCatSharp.EventArgs;
 
 namespace DisCatSharp.Lavalink.EventArgs;
 
 /// <summary>
 /// Represents arguments for player update event.
 /// </summary>
 public sealed class PlayerUpdateEventArgs : DiscordEventArgs
 {
 	/// <summary>
 	/// Gets the timestamp at which this event was emitted.
 	/// </summary>
 	public DateTimeOffset Timestamp { get; }
 
 	/// <summary>
 	/// Gets the position in the playback stream.
 	/// </summary>
 	public TimeSpan Position { get; }
 
 	/// <summary>
 	/// Gets the player that emitted this event.
 	/// </summary>
 	public LavalinkGuildConnection Player { get; }
 
 	/// <summary>
 	/// Gets whether the player is connected to the voice gateway.
 	/// </summary>
 	public bool IsConnected { get; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="PlayerUpdateEventArgs"/> class.
 	/// </summary>
 	/// <param name="lvl">The lvl.</param>
 	/// <param name="timestamp">The timestamp.</param>
 	/// <param name="position">The position.</param>
+	/// <param name="connected">Whether the player is connected.</param>
 	internal PlayerUpdateEventArgs(LavalinkGuildConnection lvl, DateTimeOffset timestamp, TimeSpan position, bool connected)
 		: base(lvl.Node.Discord.ServiceProvider)
 	{
 		this.Player = lvl;
 		this.Timestamp = timestamp;
 		this.Position = position;
 		this.IsConnected = connected;
 	}
 }
diff --git a/DisCatSharp.Lavalink/LavalinkNodeConnection.cs b/DisCatSharp.Lavalink/LavalinkNodeConnection.cs
index e0d0ff35c..ded9d142b 100644
--- a/DisCatSharp.Lavalink/LavalinkNodeConnection.cs
+++ b/DisCatSharp.Lavalink/LavalinkNodeConnection.cs
@@ -1,625 +1,626 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
+using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Lavalink.Entities;
 using DisCatSharp.Lavalink.EventArgs;
 using DisCatSharp.Net;
 using DisCatSharp.Net.WebSocket;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Lavalink;
 
 internal delegate void NodeDisconnectedEventHandler(LavalinkNodeConnection node);
 
 /// <summary>
 /// Represents a connection to a Lavalink node.
 /// </summary>
 public sealed class LavalinkNodeConnection
 {
 	/// <summary>
 	/// Triggered whenever Lavalink WebSocket throws an exception.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkNodeConnection, SocketErrorEventArgs> LavalinkSocketErrored
 	{
 		add => this._lavalinkSocketError.Register(value);
 		remove => this._lavalinkSocketError.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkNodeConnection, SocketErrorEventArgs> _lavalinkSocketError;
 
 	/// <summary>
 	/// Triggered when this node disconnects.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkNodeConnection, NodeDisconnectedEventArgs> Disconnected
 	{
 		add => this._disconnected.Register(value);
 		remove => this._disconnected.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs> _disconnected;
 
 	/// <summary>
 	/// Triggered when this node receives a statistics update.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkNodeConnection, StatisticsReceivedEventArgs> StatisticsReceived
 	{
 		add => this._statsReceived.Register(value);
 		remove => this._statsReceived.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkNodeConnection, StatisticsReceivedEventArgs> _statsReceived;
 
 	/// <summary>
 	/// Triggered whenever any of the players on this node is updated.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkGuildConnection, PlayerUpdateEventArgs> PlayerUpdated
 	{
 		add => this._playerUpdated.Register(value);
 		remove => this._playerUpdated.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkGuildConnection, PlayerUpdateEventArgs> _playerUpdated;
 
 	/// <summary>
 	/// Triggered whenever playback of a track starts.
 	/// <para>This is only available for version 3.3.1 and greater.</para>
 	/// </summary>
 	public event AsyncEventHandler<LavalinkGuildConnection, TrackStartEventArgs> PlaybackStarted
 	{
 		add => this._playbackStarted.Register(value);
 		remove => this._playbackStarted.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkGuildConnection, TrackStartEventArgs> _playbackStarted;
 
 	/// <summary>
 	/// Triggered whenever playback of a track finishes.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkGuildConnection, TrackFinishEventArgs> PlaybackFinished
 	{
 		add => this._playbackFinished.Register(value);
 		remove => this._playbackFinished.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkGuildConnection, TrackFinishEventArgs> _playbackFinished;
 
 	/// <summary>
 	/// Triggered whenever playback of a track gets stuck.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkGuildConnection, TrackStuckEventArgs> TrackStuck
 	{
 		add => this._trackStuck.Register(value);
 		remove => this._trackStuck.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkGuildConnection, TrackStuckEventArgs> _trackStuck;
 
 	/// <summary>
 	/// Triggered whenever playback of a track encounters an error.
 	/// </summary>
 	public event AsyncEventHandler<LavalinkGuildConnection, TrackExceptionEventArgs> TrackException
 	{
 		add => this._trackException.Register(value);
 		remove => this._trackException.Unregister(value);
 	}
 	private readonly AsyncEvent<LavalinkGuildConnection, TrackExceptionEventArgs> _trackException;
 
 	/// <summary>
 	/// Gets the remote endpoint of this Lavalink node connection.
 	/// </summary>
 	public ConnectionEndpoint NodeEndpoint => this.Configuration.SocketEndpoint;
 
 	/// <summary>
 	/// Gets whether the client is connected to Lavalink.
 	/// </summary>
 	public bool IsConnected => !Volatile.Read(ref this._isDisposed);
 	private bool _isDisposed;
 	private int _backoff;
 	/// <summary>
 	/// The minimum backoff.
 	/// </summary>
 	private const int MINIMUM_BACKOFF = 7500;
 	/// <summary>
 	/// The maximum backoff.
 	/// </summary>
 	private const int MAXIMUM_BACKOFF = 120000;
 
 	/// <summary>
 	/// Gets the current resource usage statistics.
 	/// </summary>
 	public LavalinkStatistics Statistics { get; }
 
 	/// <summary>
 	/// Gets a dictionary of Lavalink guild connections for this node.
 	/// </summary>
 	public IReadOnlyDictionary<ulong, LavalinkGuildConnection> ConnectedGuilds { get; }
 	internal ConcurrentDictionary<ulong, LavalinkGuildConnection> ConnectedGuildsInternal = new();
 
 	/// <summary>
 	/// Gets the REST client for this Lavalink connection.
 	/// </summary>
 	public LavalinkRestClient Rest { get; }
 
 	/// <summary>
 	/// Gets the parent extension which this node connection belongs to.
 	/// </summary>
 	public LavalinkExtension Parent { get; }
 
 	/// <summary>
 	/// Gets the Discord client this node connection belongs to.
 	/// </summary>
 	public DiscordClient Discord { get; }
 
 	/// <summary>
 	/// Gets the configuration.
 	/// </summary>
 	internal LavalinkConfiguration Configuration { get; }
 	/// <summary>
 	/// Gets the region.
 	/// </summary>
 	internal DiscordVoiceRegion Region { get; }
 
 	/// <summary>
 	/// Gets or sets the web socket.
 	/// </summary>
 	private IWebSocketClient _webSocket;
 
 	/// <summary>
 	/// Gets the voice state updates.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>> _voiceStateUpdates;
 
 	/// <summary>
 	/// Gets the voice server updates.
 	/// </summary>
 	private readonly ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>> _voiceServerUpdates;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="LavalinkNodeConnection"/> class.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="extension">the event.tension.</param>
 	/// <param name="config">The config.</param>
 	internal LavalinkNodeConnection(DiscordClient client, LavalinkExtension extension, LavalinkConfiguration config)
 	{
 		this.Discord = client;
 		this.Parent = extension;
 		this.Configuration = new LavalinkConfiguration(config);
 
 		if (config.Region != null && this.Discord.VoiceRegions.Values.Contains(config.Region))
 			this.Region = config.Region;
 
 		this.ConnectedGuilds = new ReadOnlyConcurrentDictionary<ulong, LavalinkGuildConnection>(this.ConnectedGuildsInternal);
 		this.Statistics = new LavalinkStatistics();
 
 		this._lavalinkSocketError = new AsyncEvent<LavalinkNodeConnection, SocketErrorEventArgs>("LAVALINK_SOCKET_ERROR", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._disconnected = new AsyncEvent<LavalinkNodeConnection, NodeDisconnectedEventArgs>("LAVALINK_NODE_DISCONNECTED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._statsReceived = new AsyncEvent<LavalinkNodeConnection, StatisticsReceivedEventArgs>("LAVALINK_STATS_RECEIVED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._playerUpdated = new AsyncEvent<LavalinkGuildConnection, PlayerUpdateEventArgs>("LAVALINK_PLAYER_UPDATED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._playbackStarted = new AsyncEvent<LavalinkGuildConnection, TrackStartEventArgs>("LAVALINK_PLAYBACK_STARTED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._playbackFinished = new AsyncEvent<LavalinkGuildConnection, TrackFinishEventArgs>("LAVALINK_PLAYBACK_FINISHED", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._trackStuck = new AsyncEvent<LavalinkGuildConnection, TrackStuckEventArgs>("LAVALINK_TRACK_STUCK", TimeSpan.Zero, this.Discord.EventErrorHandler);
 		this._trackException = new AsyncEvent<LavalinkGuildConnection, TrackExceptionEventArgs>("LAVALINK_TRACK_EXCEPTION", TimeSpan.Zero, this.Discord.EventErrorHandler);
 
 		this._voiceServerUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceServerUpdateEventArgs>>();
 		this._voiceStateUpdates = new ConcurrentDictionary<ulong, TaskCompletionSource<VoiceStateUpdateEventArgs>>();
 		this.Discord.VoiceStateUpdated += this.Discord_VoiceStateUpdated;
 		this.Discord.VoiceServerUpdated += this.Discord_VoiceServerUpdated;
 
 		this.Rest = new LavalinkRestClient(this.Configuration, this.Discord);
 
 		Volatile.Write(ref this._isDisposed, false);
 	}
 
 	/// <summary>
 	/// Establishes a connection to the Lavalink node.
 	/// </summary>
 	/// <returns></returns>
 	internal async Task StartAsync()
 	{
 		if (this.Discord?.CurrentUser?.Id == null || this.Discord?.ShardCount == null)
 			throw new InvalidOperationException("This operation requires the Discord client to be fully initialized.");
 
 		this._webSocket = this.Discord.Configuration.WebSocketClientFactory(this.Discord.Configuration.Proxy, this.Discord.ServiceProvider);
 		this._webSocket.Connected += this.WebSocket_OnConnect;
 		this._webSocket.Disconnected += this.WebSocket_OnDisconnect;
 		this._webSocket.ExceptionThrown += this.WebSocket_OnException;
 		this._webSocket.MessageReceived += this.WebSocket_OnMessage;
 
 		this._webSocket.AddDefaultHeader("Authorization", this.Configuration.Password);
 		this._webSocket.AddDefaultHeader("Num-Shards", this.Discord.ShardCount.ToString(CultureInfo.InvariantCulture));
 		this._webSocket.AddDefaultHeader("User-Id", this.Discord.CurrentUser.Id.ToString(CultureInfo.InvariantCulture));
-		this._webSocket.AddDefaultHeader("Client-Name", $"DisCatSharp.Lavalink version {this.Discord.VersionString}");		
+		this._webSocket.AddDefaultHeader("Client-Name", $"DisCatSharp.Lavalink version {this.Discord.VersionString}");
 		if (this.Configuration.ResumeKey != null)
 			this._webSocket.AddDefaultHeader("Resume-Key", this.Configuration.ResumeKey);
 
 		do
 		{
 			try
 			{
 				if (this._backoff != 0)
 				{
 					await Task.Delay(this._backoff).ConfigureAwait(false);
 					this._backoff = Math.Min(this._backoff * 2, MAXIMUM_BACKOFF);
 				}
 				else
 				{
 					this._backoff = MINIMUM_BACKOFF;
 				}
 
 				await this._webSocket.ConnectAsync(new Uri(this.Configuration.SocketEndpoint.ToWebSocketString())).ConfigureAwait(false);
 				break;
 			}
 			catch (PlatformNotSupportedException)
 			{ throw; }
 			catch (NotImplementedException)
 			{ throw; }
 			catch (Exception ex)
 			{
 				if (!this.Configuration.SocketAutoReconnect || this._backoff == MAXIMUM_BACKOFF)
 				{
 					this.Discord.Logger.LogCritical(LavalinkEvents.LavalinkConnectionError, ex, "Failed to connect to Lavalink.");
 					throw;
 				}
 				else
 				{
 					this.Discord.Logger.LogCritical(LavalinkEvents.LavalinkConnectionError, ex, $"Failed to connect to Lavalink, retrying in {this._backoff} ms.");
 				}
 			}
 		}
 		while (this.Configuration.SocketAutoReconnect);
 
 		Volatile.Write(ref this._isDisposed, false);
 	}
 
 	/// <summary>
 	/// Stops this Lavalink node connection and frees resources.
 	/// </summary>
 	/// <returns></returns>
 	public async Task StopAsync()
 	{
 		foreach (var kvp in this.ConnectedGuildsInternal)
 			await kvp.Value.DisconnectAsync().ConfigureAwait(false);
 
 		this.NodeDisconnected?.Invoke(this);
 
 		Volatile.Write(ref this._isDisposed, true);
 		await this._webSocket.DisconnectAsync().ConfigureAwait(false);
 		// this should not be here, no?
 		//await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this)).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Connects this Lavalink node to specified Discord channel.
 	/// </summary>
 	/// <param name="channel">Voice channel to connect to.</param>
 	/// <returns>Channel connection, which allows for playback control.</returns>
 	public async Task<LavalinkGuildConnection> ConnectAsync(DiscordChannel channel)
 	{
 		if (this.ConnectedGuildsInternal.ContainsKey(channel.Guild.Id))
 			return this.ConnectedGuildsInternal[channel.Guild.Id];
 
 		if (channel.Guild == null || (channel.Type != ChannelType.Voice && channel.Type != ChannelType.Stage))
 			throw new ArgumentException("Invalid channel specified.", nameof(channel));
 
 		var vstut = new TaskCompletionSource<VoiceStateUpdateEventArgs>();
 		var vsrut = new TaskCompletionSource<VoiceServerUpdateEventArgs>();
 		this._voiceStateUpdates[channel.Guild.Id] = vstut;
 		this._voiceServerUpdates[channel.Guild.Id] = vsrut;
 
 		var vsd = new VoiceDispatch
 		{
 			OpCode = 4,
 			Payload = new VoiceStateUpdatePayload
 			{
 				GuildId = channel.Guild.Id,
 				ChannelId = channel.Id,
 				Deafened = false,
 				Muted = false
 			}
 		};
 		var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
 		await (channel.Discord as DiscordClient).WsSendAsync(vsj).ConfigureAwait(false);
 		var vstu = await vstut.Task.ConfigureAwait(false);
 		var vsru = await vsrut.Task.ConfigureAwait(false);
 		await this.SendPayloadAsync(new LavalinkVoiceUpdate(vstu, vsru)).ConfigureAwait(false);
 
 		var con = new LavalinkGuildConnection(this, channel, vstu);
 		con.ChannelDisconnected += this.Con_ChannelDisconnected;
 		con.PlayerUpdated += (s, e) => this._playerUpdated.InvokeAsync(s, e);
 		con.PlaybackStarted += (s, e) => this._playbackStarted.InvokeAsync(s, e);
 		con.PlaybackFinished += (s, e) => this._playbackFinished.InvokeAsync(s, e);
 		con.TrackStuck += (s, e) => this._trackStuck.InvokeAsync(s, e);
 		con.TrackException += (s, e) => this._trackException.InvokeAsync(s, e);
 		this.ConnectedGuildsInternal[channel.Guild.Id] = con;
 
 		return con;
 	}
 
 	/// <summary>
 	/// Gets a Lavalink connection to specified Discord channel.
 	/// </summary>
 	/// <param name="guild">Guild to get connection for.</param>
 	/// <returns>Channel connection, which allows for playback control.</returns>
 	public LavalinkGuildConnection GetGuildConnection(DiscordGuild guild)
 		=> this.ConnectedGuildsInternal.TryGetValue(guild.Id, out var lgc) && lgc.IsConnected ? lgc : null;
 
 	/// <summary>
 	/// Sends the payload async.
 	/// </summary>
 	/// <param name="payload">The payload.</param>
 	internal async Task SendPayloadAsync(LavalinkPayload payload)
 		=> await this.WsSendAsync(JsonConvert.SerializeObject(payload, Formatting.None)).ConfigureAwait(false);
 
 	/// <summary>
 	/// Webs the socket_ on message.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">the event.ent.</param>
 	private async Task WebSocket_OnMessage(IWebSocketClient client, SocketMessageEventArgs e)
 	{
 		if (e is not SocketTextMessageEventArgs et)
 		{
 			this.Discord.Logger.LogCritical(LavalinkEvents.LavalinkConnectionError, "Lavalink sent binary data - unable to process");
 			return;
 		}
 
 		this.Discord.Logger.LogTrace(LavalinkEvents.LavalinkWsRx, et.Message);
 
 		var json = et.Message;
 		var jsonData = JObject.Parse(json);
 		switch (jsonData["op"].ToString())
 		{
 			case "playerUpdate":
 				var gid = (ulong)jsonData["guildId"];
 				var state = jsonData["state"].ToObject<LavalinkState>();
 				if (this.ConnectedGuildsInternal.TryGetValue(gid, out var lvl))
 					await lvl.InternalUpdatePlayerStateAsync(state).ConfigureAwait(false);
 				break;
 
 			case "stats":
 				var statsRaw = jsonData.ToObject<LavalinkStats>();
 				this.Statistics.Update(statsRaw);
 				await this._statsReceived.InvokeAsync(this, new StatisticsReceivedEventArgs(this.Discord.ServiceProvider, this.Statistics)).ConfigureAwait(false);
 				break;
 
 			case "event":
 				var evtype = jsonData["type"].ToObject<EventType>();
 				var guildId = (ulong)jsonData["guildId"];
 				switch (evtype)
 				{
 					case EventType.TrackStartEvent:
 						if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvtst))
 							await lvlEvtst.InternalPlaybackStartedAsync(jsonData["track"].ToString()).ConfigureAwait(false);
 						break;
 
 					case EventType.TrackEndEvent:
 						var reason = TrackEndReason.Cleanup;
 						switch (jsonData["reason"].ToString())
 						{
 							case "FINISHED":
 								reason = TrackEndReason.Finished;
 								break;
 							case "LOAD_FAILED":
 								reason = TrackEndReason.LoadFailed;
 								break;
 							case "STOPPED":
 								reason = TrackEndReason.Stopped;
 								break;
 							case "REPLACED":
 								reason = TrackEndReason.Replaced;
 								break;
 							case "CLEANUP":
 								reason = TrackEndReason.Cleanup;
 								break;
 						}
 						if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvtf))
 							await lvlEvtf.InternalPlaybackFinishedAsync(new TrackFinishData { Track = jsonData["track"].ToString(), Reason = reason }).ConfigureAwait(false);
 						break;
 
 					case EventType.TrackStuckEvent:
 						if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvts))
 							await lvlEvts.InternalTrackStuckAsync(new TrackStuckData { Track = jsonData["track"].ToString(), Threshold = (long)jsonData["thresholdMs"] }).ConfigureAwait(false);
 						break;
 
 					case EventType.TrackExceptionEvent:
 						var severity = LoadFailedSeverity.Common;
 
 						switch (jsonData["severity"].ToString())
 						{
 							case "COMMON":
 								severity = LoadFailedSeverity.Common;
 								break;
 
 							case "SUSPICIOUS":
 								severity = LoadFailedSeverity.Suspicious;
 								break;
 
 							case "FAULT":
 								severity = LoadFailedSeverity.Fault;
 								break;
 						}
 						if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEvte))
 							await lvlEvte.InternalTrackExceptionAsync(new LavalinkLoadFailedInfo { Message = jsonData["message"].ToString(), Severity = severity }, jsonData["track"].ToString()).ConfigureAwait(false);
 						break;
 
 					case EventType.WebSocketClosedEvent:
 						if (this.ConnectedGuildsInternal.TryGetValue(guildId, out var lvlEwsce))
 						{
 							lvlEwsce.VoiceWsDisconnectTcs.SetResult(true);
 							await lvlEwsce.InternalWebSocketClosedAsync(new WebSocketCloseEventArgs(jsonData["code"].ToObject<int>(), jsonData["reason"].ToString(), jsonData["byRemote"].ToObject<bool>(), this.Discord.ServiceProvider)).ConfigureAwait(false);
 						}
 						break;
 				}
 				break;
 		}
 	}
 
 	/// <summary>
 	/// Webs the socket_ on exception.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">the event.</param>
 	private Task WebSocket_OnException(IWebSocketClient client, SocketErrorEventArgs e)
 		=> this._lavalinkSocketError.InvokeAsync(this, new SocketErrorEventArgs(client.ServiceProvider) { Exception = e.Exception });
 
 	/// <summary>
 	/// Webs the socket_ on disconnect.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">the event.</param>
 	private async Task WebSocket_OnDisconnect(IWebSocketClient client, SocketCloseEventArgs e)
 	{
 		if (this.IsConnected && e.CloseCode != 1001 && e.CloseCode != -1)
 		{
 			this.Discord.Logger.LogWarning(LavalinkEvents.LavalinkConnectionClosed, "Connection broken ({0}, '{1}'), reconnecting", e.CloseCode, e.CloseMessage);
 			await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, false)).ConfigureAwait(false);
 
 			if (this.Configuration.SocketAutoReconnect)
 				await this.StartAsync().ConfigureAwait(false);
 		}
 		else if (e.CloseCode != 1001 && e.CloseCode != -1)
 		{
 			this.Discord.Logger.LogInformation(LavalinkEvents.LavalinkConnectionClosed, "Connection closed ({0}, '{1}')", e.CloseCode, e.CloseMessage);
 			this.NodeDisconnected?.Invoke(this);
 			await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, true)).ConfigureAwait(false);
 		}
 		else
 		{
 			Volatile.Write(ref this._isDisposed, true);
 			this.Discord.Logger.LogWarning(LavalinkEvents.LavalinkConnectionClosed, "Lavalink died");
 			foreach (var kvp in this.ConnectedGuildsInternal)
 			{
 				await kvp.Value.SendVoiceUpdateAsync().ConfigureAwait(false);
 				_ = this.ConnectedGuildsInternal.TryRemove(kvp.Key, out _);
 			}
 			this.NodeDisconnected?.Invoke(this);
 			await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, false)).ConfigureAwait(false);
 
 			if (this.Configuration.SocketAutoReconnect)
 				await this.StartAsync().ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Webs the socket_ on connect.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="ea">the event..</param>
 	private async Task WebSocket_OnConnect(IWebSocketClient client, SocketEventArgs ea)
 	{
 		this.Discord.Logger.LogDebug(LavalinkEvents.LavalinkConnected, "Connection to Lavalink node established");
 		this._backoff = 0;
 
 		if (this.Configuration.ResumeKey != null)
 			await this.SendPayloadAsync(new LavalinkConfigureResume(this.Configuration.ResumeKey, this.Configuration.ResumeTimeout)).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Con_S the channel disconnected.
 	/// </summary>
 	/// <param name="con">The con.</param>
 	private void Con_ChannelDisconnected(LavalinkGuildConnection con)
 		=> this.ConnectedGuildsInternal.TryRemove(con.GuildId, out _);
 
 	/// <summary>
 	/// Discord voice state updated.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">the event.</param>
 	private Task Discord_VoiceStateUpdated(DiscordClient client, VoiceStateUpdateEventArgs e)
 	{
 		var gld = e.Guild;
 		if (gld == null)
 			return Task.CompletedTask;
 
 		if (e.User == null)
 			return Task.CompletedTask;
 
 		if (e.User.Id == this.Discord.CurrentUser.Id)
 		{
 			if (this.ConnectedGuildsInternal.TryGetValue(e.Guild.Id, out var lvlgc))
 				lvlgc.VoiceStateUpdate = e;
 
 			if (e.After.Channel == null && this.IsConnected && this.ConnectedGuildsInternal.ContainsKey(gld.Id))
 			{
 				_ = Task.Run(async () =>
 				{
 					var delayTask = Task.Delay(this.Configuration.WebSocketCloseTimeout);
 					var tcs = lvlgc.VoiceWsDisconnectTcs.Task;
 					_ = await Task.WhenAny(delayTask, tcs).ConfigureAwait(false);
 
 					await lvlgc.DisconnectInternalAsync(false, true).ConfigureAwait(false);
 					_ = this.ConnectedGuildsInternal.TryRemove(gld.Id, out _);
 				});
 			}
 
 			if (!string.IsNullOrWhiteSpace(e.SessionId) && e.Channel != null && this._voiceStateUpdates.TryRemove(gld.Id, out var xe))
 				xe.SetResult(e);
 		}
 
 		return Task.CompletedTask;
 	}
 
 	/// <summary>
 	/// Discord voice server updated.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">the event.</param>
 	private Task Discord_VoiceServerUpdated(DiscordClient client, VoiceServerUpdateEventArgs e)
 	{
 		var gld = e.Guild;
 		if (gld == null)
 			return Task.CompletedTask;
 
 		if (this.ConnectedGuildsInternal.TryGetValue(e.Guild.Id, out var lvlgc))
 		{
 			var lvlp = new LavalinkVoiceUpdate(lvlgc.VoiceStateUpdate, e);
 			_ = Task.Run(() => this.WsSendAsync(JsonConvert.SerializeObject(lvlp)));
 		}
 
 		if (this._voiceServerUpdates.TryRemove(gld.Id, out var xe))
 			xe.SetResult(e);
 
 		return Task.CompletedTask;
 	}
 	/// <summary>
 	/// Ws the send async.
 	/// </summary>
 	/// <param name="payload">The payload.</param>
 
 	private async Task WsSendAsync(string payload)
 	{
 		this.Discord.Logger.LogTrace(LavalinkEvents.LavalinkWsTx, payload);
 		await this._webSocket.SendMessageAsync(payload).ConfigureAwait(false);
 	}
 
 	internal event NodeDisconnectedEventHandler NodeDisconnected;
 }
diff --git a/DisCatSharp.Lavalink/LavalinkTrack.cs b/DisCatSharp.Lavalink/LavalinkTrack.cs
index 0cbd4ac7a..2033a6296 100644
--- a/DisCatSharp.Lavalink/LavalinkTrack.cs
+++ b/DisCatSharp.Lavalink/LavalinkTrack.cs
@@ -1,231 +1,231 @@
 // 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.
 
 #pragma warning disable 0649
 
 using System;
 using System.Collections.Generic;
 using System.Runtime.Serialization;
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
 namespace DisCatSharp.Lavalink;
 
 /// <summary>
 /// Represents a lavalink track.
 /// </summary>
 public class LavalinkTrack
 {
 	/// <summary>
 	/// Gets or sets the ID of the track to play.
 	/// </summary>
 	[JsonIgnore]
 	public string TrackString { get; set; }
 
 	/// <summary>
 	/// Gets the identifier of the track.
 	/// </summary>
 	[JsonProperty("identifier")]
 	public string Identifier { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the track is seekable.
 	/// </summary>
 	[JsonProperty("isSeekable")]
 	public bool IsSeekable { get; internal set; }
 
 	/// <summary>
 	/// Gets the author of the track.
 	/// </summary>
 	[JsonProperty("author")]
 	public string Author { get; internal set; }
 
 	/// <summary>
 	/// Gets the track's duration.
 	/// </summary>
 	[JsonIgnore]
 	public TimeSpan Length => !this.IsStream ? TimeSpan.FromMilliseconds(this.LengthInternal) : TimeSpan.Zero;
 	[JsonProperty("length")]
 	internal long LengthInternal;
 
 	/// <summary>
 	/// Gets whether the track is a stream.
 	/// </summary>
 	[JsonProperty("isStream")]
 	public bool IsStream { get; internal set; }
 
 	/// <summary>
 	/// Gets the starting position of the track.
 	/// </summary>
 	[JsonIgnore]
 	public TimeSpan Position => TimeSpan.FromMilliseconds(this.PositionInternal);
 	[JsonProperty("position")]
 	internal long PositionInternal;
 
 	/// <summary>
 	/// Gets the title of the track.
 	/// </summary>
 	[JsonProperty("title")]
 	public string Title { get; internal set; }
 
 	/// <summary>
 	/// Gets the source Uri of this track.
 	/// </summary>
 	[JsonProperty("uri")]
 	public Uri Uri { get; internal set; }
-	
+
 	/// <summary>
 	/// Gets the source name that this track was retrieved from.
 	/// </summary>
 	[JsonProperty("sourceName")]
 	public string SourceName { get; internal set; }
 }
 
 /// <summary>
 /// Represents Lavalink track loading results.
 /// </summary>
 [JsonConverter(typeof(StringEnumConverter))]
 public enum LavalinkLoadResultType
 {
 	/// <summary>
 	/// Specifies that track was loaded successfully.
 	/// </summary>
 	[EnumMember(Value = "TRACK_LOADED")]
 	TrackLoaded,
 
 	/// <summary>
 	/// Specifies that playlist was loaded successfully.
 	/// </summary>
 	[EnumMember(Value = "PLAYLIST_LOADED")]
 	PlaylistLoaded,
 
 	/// <summary>
 	/// Specifies that the result set contains search results.
 	/// </summary>
 	[EnumMember(Value = "SEARCH_RESULT")]
 	SearchResult,
 
 	/// <summary>
 	/// Specifies that the search yielded no results.
 	/// </summary>
 	[EnumMember(Value = "NO_MATCHES")]
 	NoMatches,
 
 	/// <summary>
 	/// Specifies that the track failed to load.
 	/// </summary>
 	[EnumMember(Value = "LOAD_FAILED")]
 	LoadFailed
 }
 
 /// <summary>
 /// Represents information about playlist that was loaded by Lavalink.
 /// </summary>
 public struct LavalinkPlaylistInfo
 {
 	/// <summary>
 	/// Gets the name of the playlist being loaded.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the index of the track that was selected in this playlist.
 	/// </summary>
 	[JsonProperty("selectedTrack")]
 	public int SelectedTrack { get; internal set; }
 }
 
 /// <summary>
 /// Represents information about track loading request.
 /// </summary>
 public class LavalinkLoadResult
 {
 	/// <summary>
 	/// Gets the loading result type for this request.
 	/// </summary>
 	[JsonProperty("loadType")]
 	public LavalinkLoadResultType LoadResultType { get; internal set; }
 
 	/// <summary>
 	/// <para>Gets the information about the playlist loaded as a result of this request.</para>
 	/// <para>Only applicable if <see cref="LoadResultType"/> is set to <see cref="LavalinkLoadResultType.PlaylistLoaded"/>.</para>
 	/// </summary>
 	[JsonProperty("playlistInfo")]
 	public LavalinkPlaylistInfo PlaylistInfo { get; internal set; }
 
 	/// <summary>
 	/// Gets the exception details if a track loading failed.
 	/// </summary>
 	[JsonProperty("exception", NullValueHandling = NullValueHandling.Ignore)]
 	public LavalinkLoadFailedInfo Exception { get; internal set; }
 
 	/// <summary>
 	/// Gets the tracks that were loaded as a result of this request.
 	/// </summary>
 	//[JsonProperty("tracks")]
 	[JsonIgnore]
 	public IEnumerable<LavalinkTrack> Tracks { get; internal set; }
 }
 
 /// <summary>
 /// Represents properties sent when a Lavalink track is unable to load.
 /// </summary>
 public struct LavalinkLoadFailedInfo
 {
 	/// <summary>
 	/// Gets the message of the sent exception.
 	/// </summary>
 	[JsonProperty("message")]
 	public string Message { get; internal set; }
 
 	/// <summary>
 	/// Gets the severity level of the track loading failure.
 	/// </summary>
 	[JsonProperty("severity")]
 	public LoadFailedSeverity Severity { get; internal set; }
 }
 
 /// <summary>
 /// Represents severity level of the track loading failure.
 /// </summary>
 public enum LoadFailedSeverity
 {
 	/// <summary>
 	/// Indicates a known cause for the failure, and not because of Lavaplayer.
 	/// </summary>
 	[EnumMember(Value = "COMMON")]
 	Common,
 
 	/// <summary>
 	/// Indicates an unknown cause for the failure, most likely caused by outside sources.
 	/// </summary>
 	[EnumMember(Value = "SUSPICIOUS")]
 	Suspicious,
 
 	/// <summary>
 	/// Indicates an issue with Lavaplayer or otherwise no other way to determine the cause.
 	/// </summary>
 	[EnumMember(Value = "FAULT")]
 	Fault
 }
diff --git a/DisCatSharp.Logos/logo_black.png b/DisCatSharp.Logos/logo_black.png
new file mode 100644
index 000000000..c1de797bc
Binary files /dev/null and b/DisCatSharp.Logos/logo_black.png differ
diff --git a/DisCatSharp.VoiceNext/DiscordClientExtensions.cs b/DisCatSharp.VoiceNext/DiscordClientExtensions.cs
index 738aa4d5b..8fa1c6dbb 100644
--- a/DisCatSharp.VoiceNext/DiscordClientExtensions.cs
+++ b/DisCatSharp.VoiceNext/DiscordClientExtensions.cs
@@ -1,139 +1,140 @@
 // 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.Tasks;
 
 using DisCatSharp.Entities;
+using DisCatSharp.Enums;
 
 namespace DisCatSharp.VoiceNext;
 
 /// <summary>
 /// The discord client extensions.
 /// </summary>
 public static class DiscordClientExtensions
 {
 	/// <summary>
 	/// Creates a new VoiceNext client with default settings.
 	/// </summary>
 	/// <param name="client">Discord client to create VoiceNext instance for.</param>
 	/// <returns>VoiceNext client instance.</returns>
 	public static VoiceNextExtension UseVoiceNext(this DiscordClient client)
 		=> UseVoiceNext(client, new VoiceNextConfiguration());
 
 	/// <summary>
 	/// Creates a new VoiceNext client with specified settings.
 	/// </summary>
 	/// <param name="client">Discord client to create VoiceNext instance for.</param>
 	/// <param name="config">Configuration for the VoiceNext client.</param>
 	/// <returns>VoiceNext client instance.</returns>
 	public static VoiceNextExtension UseVoiceNext(this DiscordClient client, VoiceNextConfiguration config)
 	{
 		if (client.GetExtension<VoiceNextExtension>() != null)
 			throw new InvalidOperationException("VoiceNext is already enabled for that client.");
 
 		var vnext = new VoiceNextExtension(config);
 		client.AddExtension(vnext);
 		return vnext;
 	}
 
 	/// <summary>
 	/// Creates new VoiceNext clients on all shards in a given sharded client.
 	/// </summary>
 	/// <param name="client">Discord sharded client to create VoiceNext instances for.</param>
 	/// <param name="config">Configuration for the VoiceNext clients.</param>
 	/// <returns>A dictionary of created VoiceNext clients.</returns>
 	public static async Task<IReadOnlyDictionary<int, VoiceNextExtension>> UseVoiceNextAsync(this DiscordShardedClient client, VoiceNextConfiguration config)
 	{
 		var modules = new Dictionary<int, VoiceNextExtension>();
 		await client.InitializeShardsAsync().ConfigureAwait(false);
 
 		foreach (var shard in client.ShardClients.Select(xkvp => xkvp.Value))
 		{
 			var vnext = shard.GetExtension<VoiceNextExtension>();
 			if (vnext == null)
 				vnext = shard.UseVoiceNext(config);
 
 			modules[shard.ShardId] = vnext;
 		}
 
 		return new ReadOnlyDictionary<int, VoiceNextExtension>(modules);
 	}
 
 	/// <summary>
 	/// Gets the active instance of VoiceNext client for the DiscordClient.
 	/// </summary>
 	/// <param name="client">Discord client to get VoiceNext instance for.</param>
 	/// <returns>VoiceNext client instance.</returns>
 	public static VoiceNextExtension GetVoiceNext(this DiscordClient client)
 		=> client.GetExtension<VoiceNextExtension>();
 
 	/// <summary>
 	/// Retrieves a <see cref="VoiceNextExtension"/> instance for each shard.
 	/// </summary>
 	/// <param name="client">The shard client to retrieve <see cref="VoiceNextExtension"/> instances from.</param>
 	/// <returns>A dictionary containing <see cref="VoiceNextExtension"/> instances for each shard.</returns>
 	public static async Task<IReadOnlyDictionary<int, VoiceNextExtension>> GetVoiceNextAsync(this DiscordShardedClient client)
 	{
 		await client.InitializeShardsAsync().ConfigureAwait(false);
 		var extensions = new Dictionary<int, VoiceNextExtension>();
 
 		foreach (var shard in client.ShardClients.Values)
 		{
 			extensions.Add(shard.ShardId, shard.GetExtension<VoiceNextExtension>());
 		}
 
 		return new ReadOnlyDictionary<int, VoiceNextExtension>(extensions);
 	}
 
 	/// <summary>
 	/// Connects to this voice channel using VoiceNext.
 	/// </summary>
 	/// <param name="channel">Channel to connect to.</param>
 	/// <returns>If successful, the VoiceNext connection.</returns>
 	public static Task<VoiceNextConnection> ConnectAsync(this DiscordChannel channel)
 	{
 		if (channel == null)
 			throw new NullReferenceException();
 
 		if (channel.Guild == null)
 			throw new InvalidOperationException("VoiceNext can only be used with guild channels.");
 
 		if (channel.Type != ChannelType.Voice && channel.Type != ChannelType.Stage)
 			throw new InvalidOperationException("You can only connect to voice or stage channels.");
 
 		if (channel.Discord is not DiscordClient discord || discord == null)
 			throw new NullReferenceException();
 
 		var vnext = discord.GetVoiceNext();
 		if (vnext == null)
 			throw new InvalidOperationException("VoiceNext is not initialized for this Discord client.");
 
 		var vnc = vnext.GetConnection(channel.Guild);
 		return vnc != null
 			? throw new InvalidOperationException("VoiceNext is already connected in this guild.")
 			: vnext.ConnectAsync(channel);
 	}
 }
diff --git a/DisCatSharp.VoiceNext/Interop/Bindings.cs b/DisCatSharp.VoiceNext/Interop/Bindings.cs
index 4e0cd17a9..3698be98f 100644
--- a/DisCatSharp.VoiceNext/Interop/Bindings.cs
+++ b/DisCatSharp.VoiceNext/Interop/Bindings.cs
@@ -1,157 +1,155 @@
 // 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.Runtime.InteropServices;
 
-using DisCatSharp.VoiceNext.Codec;
-
 namespace DisCatSharp.VoiceNext.Interop
 {
 	internal static unsafe class Bindings
 	{
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern IntPtr opus_encoder_create(int samplingRate, int channels, int application, out OpusError error);
 
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern void opus_encoder_destroy(IntPtr encoder);
 
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern int opus_encode(IntPtr encoder, byte* pcm, int frameSize, byte* data, int maxDataBytes);
 
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern OpusError opus_encoder_ctl(IntPtr encoder, OpusControl ctl, int value);
 
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern IntPtr opus_decoder_create(int sampleRate, int channels, out OpusError error);
 
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern void opus_decoder_destroy(IntPtr decoder);
 
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern int opus_decode(IntPtr decoder, byte* opusData, int opusDataLength, byte* data, int frameSize, int decodeFec);
 
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern int opus_packet_get_nb_channels(byte* data);
 
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern int opus_packet_get_nb_frames(byte* data, int length);
 
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern int opus_packet_get_samples_per_frame(byte* data, int samplingRate);
 
 		[DllImport("libopus", CallingConvention = CallingConvention.Cdecl)]
 		private static extern int opus_decoder_ctl(IntPtr decoder, OpusControl ctl, out int value);
 
 		public static IntPtr CreateEncoder(int sampleRate, int channelCount, int application)
 		{
 			var encoder = opus_encoder_create(sampleRate, channelCount, application, out var error);
 			return error == OpusError.Ok ? encoder : throw new Exception($"Failed to instantiate Opus encoder: {error} ({(int)error})");
 		}
 
 		public static void SetEncoderOption(IntPtr encoder, OpusControl option, int value)
 		{
 			var error = OpusError.Ok;
 			if ((error = opus_encoder_ctl(encoder, option, value)) != OpusError.Ok)
 				throw new Exception($"Failed to set Opus encoder option: ${error} ({(int)error})");
 		}
 
 		public static void Encode(IntPtr encoder, ReadOnlySpan<byte> pcm, int frameSize, ref Span<byte> data)
 		{
 			var length = 0;
 
 			fixed (byte* pcmPointer = pcm)
 			fixed (byte* dataPointer = data)
 				length = opus_encode(encoder, pcmPointer, frameSize, dataPointer, data.Length);
 
 			if (length < 0)
 			{
 				var error = (OpusError)length;
 				throw new Exception($"Failed to encode PCM data: {error} ({length})");
 			}
 
 			data = data[..length];
 		}
 
 		public static IntPtr CreateDecoder(int sampleRate, int channelCount)
 		{
 			var decoder = opus_decoder_create(sampleRate, channelCount, out var error);
 			return error == OpusError.Ok ? decoder : throw new Exception($"Failed to instantiate Opus decoder: {error} ({(int)error})");
 		}
 
 		public static int Decode(IntPtr decoder, ReadOnlySpan<byte> data, int frameSize, Span<byte> pcm, bool useFec)
 		{
 			var length = 0;
 
 			fixed (byte* dataPointer = data)
 			fixed (byte* pcmPointer = pcm)
 				length = opus_decode(decoder, dataPointer, data.Length, pcmPointer, frameSize, useFec ? 1 : 0);
 
 			if (length < 0)
 			{
 				var error = (OpusError)length;
 				throw new Exception($"Failed to decode PCM data: {error} ({length})");
 			}
 
 			return length;
 		}
 
 		public static int Decode(IntPtr decoder, int frameSize, Span<byte> pcm)
 		{
 			var length = 0;
 
 			fixed (byte* pcmPointer = pcm)
 				length = opus_decode(decoder, null, 0, pcmPointer, frameSize, 1);
 
 			if (length < 0)
 			{
 				var error = (OpusError)length;
 				throw new Exception($"Failed to decode PCM data: {error} ({length})");
 			}
 
 			return length;
 		}
 
 		public static OpusPacketMetrics GetPacketMetrics(ReadOnlySpan<byte> data, int samplingRate)
 		{
 			int channels, frames, samplesPerFrame;
 
 			fixed (byte* dataPointer = data)
 			{
 				frames = opus_packet_get_nb_frames(dataPointer, data.Length);
 				samplesPerFrame = opus_packet_get_samples_per_frame(dataPointer, samplingRate);
 				channels = opus_packet_get_nb_channels(dataPointer);
 			}
 
 			return new()
 			{
 				ChannelCount = channels,
 				FrameCount = frames,
 				SamplesPerFrame = samplesPerFrame,
 				FrameSize = frames * samplesPerFrame
 			};
 		}
 
 		public static void GetLastPacketDuration(IntPtr decoder, out int sampleCount)
 			=> opus_decoder_ctl(decoder, OpusControl.GetLastPacketDuration, out sampleCount);
 	}
 }
diff --git a/DisCatSharp.VoiceNext/VoiceNextExtension.cs b/DisCatSharp.VoiceNext/VoiceNextExtension.cs
index f08a55329..fc7f47b3f 100644
--- a/DisCatSharp.VoiceNext/VoiceNextExtension.cs
+++ b/DisCatSharp.VoiceNext/VoiceNextExtension.cs
@@ -1,264 +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);
 		}
 	}
 }
diff --git a/DisCatSharp.targets b/DisCatSharp.targets
index bf2cc22bc..205873bca 100644
--- a/DisCatSharp.targets
+++ b/DisCatSharp.targets
@@ -1,28 +1,28 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <Authors>Aiko-IT-Systems, Lala Sabathil, J_M_Lutra , Xorog, Badger2-3, aiko, AITSYS Contributors</Authors>
-    <Company>Aiko IT Systems</Company>
+    <Authors>AITSYS, aiko, J_M_Lutra , Xorog, Badger2-3, AITSYS Contributors</Authors>
+    <Company>AITSYS</Company>
     <GeneratePackageOnBuild>False</GeneratePackageOnBuild>
     <PackageProjectUrl>https://github.com/Aiko-IT-Systems/DisCatSharp</PackageProjectUrl>
     <RepositoryUrl>https://github.com/Aiko-IT-Systems/DisCatSharp</RepositoryUrl>
     <RepositoryType>Git</RepositoryType>
     <PackageIcon>logobig.png</PackageIcon>
     <PackageLicenseExpression />
     <PackageLicenseFile>LICENSE.md</PackageLicenseFile>
     <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
   </PropertyGroup>
 
   <ItemGroup>
     <None Include="..\LICENSE.md">
       <Pack>True</Pack>
       <PackagePath></PackagePath>
     </None>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\DisCatSharp.Logos\logobig.png">
       <Pack>True</Pack>
       <PackagePath></PackagePath>
     </None>
   </ItemGroup>
 </Project>
diff --git a/DisCatSharp/Clients/DiscordClient.Dispatch.cs b/DisCatSharp/Clients/DiscordClient.Dispatch.cs
index 54d0e15fe..987153b42 100644
--- a/DisCatSharp/Clients/DiscordClient.Dispatch.cs
+++ b/DisCatSharp/Clients/DiscordClient.Dispatch.cs
@@ -1,3411 +1,3412 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Serialization;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// Represents a discord client.
 /// </summary>
 public sealed partial class DiscordClient
 {
 	#region Private Fields
 
 	private string _sessionId;
 	private bool _guildDownloadCompleted;
 
 	private readonly Dictionary<string, KeyValuePair<TimeoutHandler, Timer>> _tempTimers = new();
 
 	/// <summary>
 	/// Represents a timeout handler.
 	/// </summary>
 	internal class TimeoutHandler
 	{
 		/// <summary>
 		/// Gets the member.
 		/// </summary>
 		internal readonly DiscordMember Member;
 
 		/// <summary>
 		/// Gets the guild.
 		/// </summary>
 		internal readonly DiscordGuild Guild;
 
 		/// <summary>
 		/// Gets the old timeout value.
 		/// </summary>
 		internal DateTime? TimeoutUntilOld;
 
 		/// <summary>
 		/// Gets the new timeout value.
 		/// </summary>
 		internal DateTime? TimeoutUntilNew;
 
 		/// <summary>
 		/// Constructs a new <see cref="TimeoutHandler"/>.
 		/// </summary>
 		/// <param name="mbr">The affected member.</param>
 		/// <param name="guild">The affected guild.</param>
 		/// <param name="too">The old timeout value.</param>
 		/// <param name="ton">The new timeout value.</param>
 		internal TimeoutHandler(DiscordMember mbr, DiscordGuild guild, DateTime? too, DateTime? ton)
 		{
 			this.Guild = guild;
 			this.Member = mbr;
 			this.TimeoutUntilOld = too;
 			this.TimeoutUntilNew = ton;
 		}
 	}
 
 	#endregion
 
 	#region Dispatch Handler
 
 	/// <summary>
 	/// Handles the dispatch payloads.
 	/// </summary>
 	/// <param name="payload">The payload.</param>
 
 	internal async Task HandleDispatchAsync(GatewayPayload payload)
 	{
 		if (payload.Data is not JObject dat)
 		{
 			this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Invalid payload body (this message is probably safe to ignore); opcode: {0} event: {1}; payload: {2}", payload.OpCode, payload.EventName, payload.Data);
 			return;
 		}
 
 		await this._payloadReceived.InvokeAsync(this, new PayloadReceivedEventArgs(this.ServiceProvider)
 		{
 			EventName = payload.EventName,
 			PayloadObject = dat
 		}).ConfigureAwait(false);
 
 		#region Default objects
 		DiscordChannel chn;
 		ulong gid;
 		ulong cid;
 		ulong uid;
 		DiscordStageInstance stg = default;
 		DiscordIntegration itg = default;
 		DiscordThreadChannel trd = default;
 		DiscordThreadChannelMember trdm = default;
 		DiscordScheduledEvent gse = default;
 		TransportUser usr = default;
 		TransportMember mbr = default;
 		TransportUser refUsr = default;
 		TransportMember refMbr = default;
 		JToken rawMbr = default;
 		var rawRefMsg = dat["referenced_message"];
 		#endregion
 
 		switch (payload.EventName.ToLowerInvariant())
 		{
 			#region Gateway Status
 
 			case "ready":
 				var glds = (JArray)dat["guilds"];
 				await this.OnReadyEventAsync(dat.ToObject<ReadyPayload>(), glds).ConfigureAwait(false);
 				break;
 
 			case "resumed":
 				await this.OnResumedAsync().ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Channel
 
 			case "channel_create":
 				chn = dat.ToObject<DiscordChannel>();
 				await this.OnChannelCreateEventAsync(chn).ConfigureAwait(false);
 				break;
 
 			case "channel_update":
 				await this.OnChannelUpdateEventAsync(dat.ToObject<DiscordChannel>()).ConfigureAwait(false);
 				break;
 
 			case "channel_delete":
 				chn = dat.ToObject<DiscordChannel>();
 				await this.OnChannelDeleteEventAsync(chn.IsPrivate ? dat.ToObject<DiscordDmChannel>() : chn).ConfigureAwait(false);
 				break;
 
 			case "channel_pins_update":
 				cid = (ulong)dat["channel_id"];
 				var ts = (string)dat["last_pin_timestamp"];
 				await this.OnChannelPinsUpdateAsync((ulong?)dat["guild_id"], cid, ts != null ? DateTimeOffset.Parse(ts, CultureInfo.InvariantCulture) : default(DateTimeOffset?)).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Guild
 
 			case "guild_create":
 				await this.OnGuildCreateEventAsync(dat.ToDiscordObject<DiscordGuild>(), (JArray)dat["members"], dat["presences"].ToDiscordObject<IEnumerable<DiscordPresence>>()).ConfigureAwait(false);
 				break;
 
 			case "guild_update":
 				await this.OnGuildUpdateEventAsync(dat.ToDiscordObject<DiscordGuild>(), (JArray)dat["members"]).ConfigureAwait(false);
 				break;
 
 			case "guild_delete":
 				await this.OnGuildDeleteEventAsync(dat.ToDiscordObject<DiscordGuild>()).ConfigureAwait(false);
 				break;
 
 			case "guild_sync":
 				gid = (ulong)dat["id"];
 				await this.OnGuildSyncEventAsync(this.GuildsInternal[gid], (bool)dat["large"], (JArray)dat["members"], dat["presences"].ToDiscordObject<IEnumerable<DiscordPresence>>()).ConfigureAwait(false);
 				break;
 
 			case "guild_emojis_update":
 				gid = (ulong)dat["guild_id"];
 				var ems = dat["emojis"].ToObject<IEnumerable<DiscordEmoji>>();
 				await this.OnGuildEmojisUpdateEventAsync(this.GuildsInternal[gid], ems).ConfigureAwait(false);
 				break;
 
 			case "guild_stickers_update":
 				gid = (ulong)dat["guild_id"];
 				var strs = dat["stickers"].ToDiscordObject<IEnumerable<DiscordSticker>>();
 				await this.OnStickersUpdatedAsync(strs, gid).ConfigureAwait(false);
 				break;
 
 			case "guild_integrations_update":
 				gid = (ulong)dat["guild_id"];
 
 				// discord fires this event inconsistently if the current user leaves a guild.
 				if (!this.GuildsInternal.ContainsKey(gid))
 					return;
 
 				await this.OnGuildIntegrationsUpdateEventAsync(this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_join_request_create":
 				break;
 
 			case "guild_join_request_update":
 				break;
 
 			case "guild_join_request_delete":
 				break;
 
 			#endregion
 
 			#region Guild Ban
 
 			case "guild_ban_add":
 				usr = dat["user"].ToObject<TransportUser>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildBanAddEventAsync(usr, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_ban_remove":
 				usr = dat["user"].ToObject<TransportUser>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildBanRemoveEventAsync(usr, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Guild Event
 
 			case "guild_scheduled_event_create":
 				gse = dat.ToObject<DiscordScheduledEvent>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildScheduledEventCreateEventAsync(gse, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_scheduled_event_update":
 				gse = dat.ToObject<DiscordScheduledEvent>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildScheduledEventUpdateEventAsync(gse, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_scheduled_event_delete":
 				gse = dat.ToObject<DiscordScheduledEvent>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildScheduledEventDeleteEventAsync(gse, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_scheduled_event_user_add":
 				gid = (ulong)dat["guild_id"];
 				uid = (ulong)dat["user_id"];
 				await this.OnGuildScheduledEventUserAddedEventAsync((ulong)dat["guild_scheduled_event_id"], uid, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_scheduled_event_user_remove":
 				gid = (ulong)dat["guild_id"];
 				uid = (ulong)dat["user_id"];
 				await this.OnGuildScheduledEventUserRemovedEventAsync((ulong)dat["guild_scheduled_event_id"], uid, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Guild Integration
 
 			case "integration_create":
 				gid = (ulong)dat["guild_id"];
 				itg = dat.ToObject<DiscordIntegration>();
 
 				// discord fires this event inconsistently if the current user leaves a guild.
 				if (!this.GuildsInternal.ContainsKey(gid))
 					return;
 
 				await this.OnGuildIntegrationCreateEventAsync(this.GuildsInternal[gid], itg).ConfigureAwait(false);
 				break;
 
 			case "integration_update":
 				gid = (ulong)dat["guild_id"];
 				itg = dat.ToObject<DiscordIntegration>();
 
 				// discord fires this event inconsistently if the current user leaves a guild.
 				if (!this.GuildsInternal.ContainsKey(gid))
 					return;
 
 				await this.OnGuildIntegrationUpdateEventAsync(this.GuildsInternal[gid], itg).ConfigureAwait(false);
 				break;
 
 			case "integration_delete":
 				gid = (ulong)dat["guild_id"];
 
 				// discord fires this event inconsistently if the current user leaves a guild.
 				if (!this.GuildsInternal.ContainsKey(gid))
 					return;
 
 				await this.OnGuildIntegrationDeleteEventAsync(this.GuildsInternal[gid], (ulong)dat["id"], (ulong?)dat["application_id"]).ConfigureAwait(false);
 				break;
 			#endregion
 
 			#region Guild Member
 
 			case "guild_member_add":
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildMemberAddEventAsync(dat.ToObject<TransportMember>(), this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_member_remove":
 				gid = (ulong)dat["guild_id"];
 				usr = dat["user"].ToObject<TransportUser>();
 
 				if (!this.GuildsInternal.ContainsKey(gid))
 				{
 					// discord fires this event inconsistently if the current user leaves a guild.
 					if (usr.Id != this.CurrentUser.Id)
 						this.Logger.LogError(LoggerEvents.WebSocketReceive, "Could not find {0} in guild cache", gid);
 					return;
 				}
 
 				await this.OnGuildMemberRemoveEventAsync(usr, this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_member_update":
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildMemberUpdateEventAsync(dat.ToDiscordObject<TransportMember>(), this.GuildsInternal[gid], dat["roles"].ToObject<IEnumerable<ulong>>(), (string)dat["nick"], (bool?)dat["pending"]).ConfigureAwait(false);
 				break;
 
 			case "guild_members_chunk":
 				await this.OnGuildMembersChunkEventAsync(dat).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Guild Role
 
 			case "guild_role_create":
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildRoleCreateEventAsync(dat["role"].ToObject<DiscordRole>(), this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_role_update":
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildRoleUpdateEventAsync(dat["role"].ToObject<DiscordRole>(), this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			case "guild_role_delete":
 				gid = (ulong)dat["guild_id"];
 				await this.OnGuildRoleDeleteEventAsync((ulong)dat["role_id"], this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Invite
 
 			case "invite_create":
 				gid = (ulong)dat["guild_id"];
 				cid = (ulong)dat["channel_id"];
 				await this.OnInviteCreateEventAsync(cid, gid, dat.ToObject<DiscordInvite>()).ConfigureAwait(false);
 				break;
 
 			case "invite_delete":
 				gid = (ulong)dat["guild_id"];
 				cid = (ulong)dat["channel_id"];
 				await this.OnInviteDeleteEventAsync(cid, gid, dat).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Message
 
 			case "message_ack":
 				cid = (ulong)dat["channel_id"];
 				var mid = (ulong)dat["message_id"];
 				await this.OnMessageAckEventAsync(this.InternalGetCachedChannel(cid), mid).ConfigureAwait(false);
 				break;
 
 			case "message_create":
 				rawMbr = dat["member"];
 
 				if (rawMbr != null)
 					mbr = rawMbr.ToObject<TransportMember>();
 
 				if (rawRefMsg != null && rawRefMsg.HasValues)
 				{
 					if (rawRefMsg.SelectToken("author") != null)
 					{
 						refUsr = rawRefMsg.SelectToken("author").ToObject<TransportUser>();
 					}
 
 					if (rawRefMsg.SelectToken("member") != null)
 					{
 						refMbr = rawRefMsg.SelectToken("member").ToObject<TransportMember>();
 					}
 				}
 
 				await this.OnMessageCreateEventAsync(dat.ToDiscordObject<DiscordMessage>(), dat["author"].ToObject<TransportUser>(), mbr, refUsr, refMbr).ConfigureAwait(false);
 				break;
 
 			case "message_update":
 				rawMbr = dat["member"];
 
 				if (rawMbr != null)
 					mbr = rawMbr.ToObject<TransportMember>();
 
 				if (rawRefMsg != null && rawRefMsg.HasValues)
 				{
 					if (rawRefMsg.SelectToken("author") != null)
 					{
 						refUsr = rawRefMsg.SelectToken("author").ToObject<TransportUser>();
 					}
 
 					if (rawRefMsg.SelectToken("member") != null)
 					{
 						refMbr = rawRefMsg.SelectToken("member").ToObject<TransportMember>();
 					}
 				}
 
 				await this.OnMessageUpdateEventAsync(dat.ToDiscordObject<DiscordMessage>(), dat["author"]?.ToObject<TransportUser>(), mbr, refUsr, refMbr).ConfigureAwait(false);
 				break;
 
 			// delete event does *not* include message object
 			case "message_delete":
 				await this.OnMessageDeleteEventAsync((ulong)dat["id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "message_delete_bulk":
 				await this.OnMessageBulkDeleteEventAsync(dat["ids"].ToObject<ulong[]>(), (ulong)dat["channel_id"], (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Message Reaction
 
 			case "message_reaction_add":
 				rawMbr = dat["member"];
 
 				if (rawMbr != null)
 					mbr = rawMbr.ToObject<TransportMember>();
 
 				await this.OnMessageReactionAddAsync((ulong)dat["user_id"], (ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"], mbr, dat["emoji"].ToObject<DiscordEmoji>()).ConfigureAwait(false);
 				break;
 
 			case "message_reaction_remove":
 				await this.OnMessageReactionRemoveAsync((ulong)dat["user_id"], (ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"], dat["emoji"].ToObject<DiscordEmoji>()).ConfigureAwait(false);
 				break;
 
 			case "message_reaction_remove_all":
 				await this.OnMessageReactionRemoveAllAsync((ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "message_reaction_remove_emoji":
 				await this.OnMessageReactionRemoveEmojiAsync((ulong)dat["message_id"], (ulong)dat["channel_id"], (ulong)dat["guild_id"], dat["emoji"]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Stage Instance
 
 			case "stage_instance_create":
 				stg = dat.ToObject<DiscordStageInstance>();
 				await this.OnStageInstanceCreateEventAsync(stg).ConfigureAwait(false);
 				break;
 
 			case "stage_instance_update":
 				stg = dat.ToObject<DiscordStageInstance>();
 				await this.OnStageInstanceUpdateEventAsync(stg).ConfigureAwait(false);
 				break;
 
 			case "stage_instance_delete":
 				stg = dat.ToObject<DiscordStageInstance>();
 				await this.OnStageInstanceDeleteEventAsync(stg).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Thread
 
 			case "thread_create":
 				trd = dat.ToObject<DiscordThreadChannel>();
 				await this.OnThreadCreateEventAsync(trd).ConfigureAwait(false);
 				break;
 
 			case "thread_update":
 				trd = dat.ToObject<DiscordThreadChannel>();
 				await this.OnThreadUpdateEventAsync(trd).ConfigureAwait(false);
 				break;
 
 			case "thread_delete":
 				trd = dat.ToObject<DiscordThreadChannel>();
 				await this.OnThreadDeleteEventAsync(trd).ConfigureAwait(false);
 				break;
 
 			case "thread_list_sync":
 				gid = (ulong)dat["guild_id"]; //get guild
 				await this.OnThreadListSyncEventAsync(this.GuildsInternal[gid], dat["channel_ids"].ToObject<IReadOnlyList<ulong?>>(), dat["threads"].ToObject<IReadOnlyList<DiscordThreadChannel>>(), dat["members"].ToObject<IReadOnlyList<DiscordThreadChannelMember>>()).ConfigureAwait(false);
 				break;
 
 			case "thread_member_update":
 				trdm = dat.ToObject<DiscordThreadChannelMember>();
 				await this.OnThreadMemberUpdateEventAsync(trdm).ConfigureAwait(false);
 				break;
 
 			case "thread_members_update":
 				gid = (ulong)dat["guild_id"];
 
 				await this.OnThreadMembersUpdateEventAsync(this.GuildsInternal[gid], (ulong)dat["id"], (JArray)dat["added_members"], (JArray)dat["removed_member_ids"], (int)dat["member_count"]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Activities
 			case "embedded_activity_update":
 				gid = (ulong)dat["guild_id"];
 				cid = (ulong)dat["channel_id"];
 				await this.OnEmbeddedActivityUpdateAsync((JObject)dat["embedded_activity"], this.GuildsInternal[gid], cid, (JArray)dat["users"], (ulong)dat["embedded_activity"]["application_id"]).ConfigureAwait(false);
 				break;
 			#endregion
 
 			#region User/Presence Update
 
 			case "presence_update":
 				await this.OnPresenceUpdateEventAsync(dat, (JObject)dat["user"]).ConfigureAwait(false);
 				break;
 
 			case "user_settings_update":
 				await this.OnUserSettingsUpdateEventAsync(dat.ToObject<TransportUser>()).ConfigureAwait(false);
 				break;
 
 			case "user_update":
 				await this.OnUserUpdateEventAsync(dat.ToObject<TransportUser>()).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Voice
 
 			case "voice_state_update":
 				await this.OnVoiceStateUpdateEventAsync(dat).ConfigureAwait(false);
 				break;
 
 			case "voice_server_update":
 				gid = (ulong)dat["guild_id"];
 				await this.OnVoiceServerUpdateEventAsync((string)dat["endpoint"], (string)dat["token"], this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Interaction/Integration/Application
 
 			case "interaction_create":
 				rawMbr = dat["member"];
 
 				if (rawMbr != null)
 				{
 					mbr = dat["member"].ToObject<TransportMember>();
 					usr = mbr.User;
 				}
 				else
 				{
 					usr = dat["user"].ToObject<TransportUser>();
 				}
 
 				cid = (ulong)dat["channel_id"];
 				await this.OnInteractionCreateAsync((ulong?)dat["guild_id"], cid, usr, mbr, dat.ToDiscordObject<DiscordInteraction>()).ConfigureAwait(false);
 				break;
 
 			case "application_command_create":
 				await this.OnApplicationCommandCreateAsync(dat.ToObject<DiscordApplicationCommand>(), (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "application_command_update":
 				await this.OnApplicationCommandUpdateAsync(dat.ToObject<DiscordApplicationCommand>(), (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "application_command_delete":
 				await this.OnApplicationCommandDeleteAsync(dat.ToObject<DiscordApplicationCommand>(), (ulong?)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "guild_application_command_counts_update":
 				var counts = dat["application_command_counts"];
 				await this.OnGuildApplicationCommandCountsUpdateAsync((int)counts["1"], (int)counts["2"], (int)counts["3"], (ulong)dat["guild_id"]).ConfigureAwait(false);
 				break;
 
 			case "guild_application_command_index_update":
 				// TODO: Implement.
 				break;
 
 			case "application_command_permissions_update":
 				var aid = (ulong)dat["application_id"];
 				if (aid != this.CurrentApplication.Id)
 					return;
 
 				var pms = dat["permissions"].ToObject<IEnumerable<DiscordApplicationCommandPermission>>();
 				gid = (ulong)dat["guild_id"];
 				await this.OnApplicationCommandPermissionsUpdateAsync(pms, (ulong)dat["id"], gid, aid).ConfigureAwait(false);
 				break;
 
 			#endregion
 
 			#region Misc
 
 			case "gift_code_update": //Not supposed to be dispatched to bots
 				break;
 
 			case "typing_start":
 				cid = (ulong)dat["channel_id"];
 				rawMbr = dat["member"];
 
 				if (rawMbr != null)
 					mbr = rawMbr.ToObject<TransportMember>();
 
 				await this.OnTypingStartEventAsync((ulong)dat["user_id"], cid, this.InternalGetCachedChannel(cid), (ulong?)dat["guild_id"], Utilities.GetDateTimeOffset((long)dat["timestamp"]), mbr).ConfigureAwait(false);
 				break;
 
 			case "webhooks_update":
 				gid = (ulong)dat["guild_id"];
 				cid = (ulong)dat["channel_id"];
 				await this.OnWebhooksUpdateAsync(this.GuildsInternal[gid].GetChannel(cid), this.GuildsInternal[gid]).ConfigureAwait(false);
 				break;
 
 			default:
 				await this.OnUnknownEventAsync(payload).ConfigureAwait(false);
 				this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Unknown event: {0}\npayload: {1}", payload.EventName, payload.Data);
 				break;
 
 				#endregion
 		}
 	}
 
 	#endregion
 
 	#region Events
 
 	#region Gateway
 
 	/// <summary>
 	/// Handles the ready event.
 	/// </summary>
 	/// <param name="ready">The ready payload.</param>
 	/// <param name="rawGuilds">The raw guilds.</param>
 	internal async Task OnReadyEventAsync(ReadyPayload ready, JArray rawGuilds)
 	{
 		//ready.CurrentUser.Discord = this;
 
 		var rusr = ready.CurrentUser;
 		this.CurrentUser.Username = rusr.Username;
 		this.CurrentUser.Discriminator = rusr.Discriminator;
 		this.CurrentUser.AvatarHash = rusr.AvatarHash;
 		this.CurrentUser.MfaEnabled = rusr.MfaEnabled;
 		this.CurrentUser.Verified = rusr.Verified;
 		this.CurrentUser.IsBot = rusr.IsBot;
 		this.CurrentUser.Flags = rusr.Flags;
 
 		this.GatewayVersion = ready.GatewayVersion;
 		this._sessionId = ready.SessionId;
 		var rawGuildIndex = rawGuilds.ToDictionary(xt => (ulong)xt["id"], xt => (JObject)xt);
 
 		this.GuildsInternal.Clear();
 		foreach (var guild in ready.Guilds)
 		{
 			guild.Discord = this;
 
 			if (guild.ChannelsInternal == null)
 				guild.ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>();
 
 			foreach (var xc in guild.Channels.Values)
 			{
 				xc.GuildId = guild.Id;
 				xc.Discord = this;
 				foreach (var xo in xc.PermissionOverwritesInternal)
 				{
 					xo.Discord = this;
 					xo.ChannelId = xc.Id;
 				}
 			}
 
 			if (guild.RolesInternal == null)
 				guild.RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>();
 
 			foreach (var xr in guild.Roles.Values)
 			{
 				xr.Discord = this;
 				xr.GuildId = guild.Id;
 			}
 
 			var rawGuild = rawGuildIndex[guild.Id];
 			var rawMembers = (JArray)rawGuild["members"];
 
 			if (guild.MembersInternal != null)
 				guild.MembersInternal.Clear();
 			else
 				guild.MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>();
 
 			if (rawMembers != null)
 			{
 				foreach (var xj in rawMembers)
 				{
 					var xtm = xj.ToObject<TransportMember>();
 
 					var xu = new DiscordUser(xtm.User) { Discord = this };
 					xu = this.UserCache.AddOrUpdate(xtm.User.Id, xu, (id, old) =>
 					{
 						old.Username = xu.Username;
 						old.Discriminator = xu.Discriminator;
 						old.AvatarHash = xu.AvatarHash;
 						return old;
 					});
 
 					guild.MembersInternal[xtm.User.Id] = new DiscordMember(xtm) { Discord = this, GuildId = guild.Id };
 				}
 			}
 
 			if (guild.EmojisInternal == null)
 				guild.EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>();
 
 			foreach (var xe in guild.Emojis.Values)
 				xe.Discord = this;
 
 			if (guild.StickersInternal == null)
 				guild.StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>();
 
 			foreach (var xs in guild.Stickers.Values)
 				xs.Discord = this;
 
 			if (guild.VoiceStatesInternal == null)
 				guild.VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>();
 
 			foreach (var xvs in guild.VoiceStates.Values)
 				xvs.Discord = this;
 
 			if (guild.ThreadsInternal == null)
 				guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 
 			foreach (var xt in guild.ThreadsInternal.Values)
 				xt.Discord = this;
 
 			if (guild.StageInstancesInternal == null)
 				guild.StageInstancesInternal = new ConcurrentDictionary<ulong, DiscordStageInstance>();
 
 			foreach (var xsi in guild.StageInstancesInternal.Values)
 				xsi.Discord = this;
 
 			if (guild.ScheduledEventsInternal == null)
 				guild.ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>();
 
 			foreach (var xse in guild.ScheduledEventsInternal.Values)
 				xse.Discord = this;
 
 			this.GuildsInternal[guild.Id] = guild;
 		}
 
 		await this._ready.InvokeAsync(this, new ReadyEventArgs(this.ServiceProvider)).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the resumed event.
 	/// </summary>
 	internal Task OnResumedAsync()
 	{
 		this.Logger.LogInformation(LoggerEvents.SessionUpdate, "Session resumed");
 		return this._resumed.InvokeAsync(this, new ReadyEventArgs(this.ServiceProvider));
 	}
 
 	#endregion
 
 	#region Channel
 
 	/// <summary>
 	/// Handles the channel create event.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal async Task OnChannelCreateEventAsync(DiscordChannel channel)
 	{
 		channel.Discord = this;
 		foreach (var xo in channel.PermissionOverwritesInternal)
 		{
 			xo.Discord = this;
 			xo.ChannelId = channel.Id;
 		}
 
 		this.GuildsInternal[channel.GuildId.Value].ChannelsInternal[channel.Id] = channel;
 
 		/*if (this.Configuration.AutoRefreshChannelCache)
             {
                 await this.RefreshChannelsAsync(channel.Guild.Id);
             }*/
 
 		await this._channelCreated.InvokeAsync(this, new ChannelCreateEventArgs(this.ServiceProvider) { Channel = channel, Guild = channel.Guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the channel update event.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal async Task OnChannelUpdateEventAsync(DiscordChannel channel)
 	{
 		if (channel == null)
 			return;
 
 		channel.Discord = this;
 
 		var gld = channel.Guild;
 
 		var channelNew = this.InternalGetCachedChannel(channel.Id);
 		DiscordChannel channelOld = null;
 
 		if (channelNew != null)
 		{
 			channelOld = new DiscordChannel
 			{
 				Bitrate = channelNew.Bitrate,
 				Discord = this,
 				GuildId = channelNew.GuildId,
 				Id = channelNew.Id,
 				LastMessageId = channelNew.LastMessageId,
 				Name = channelNew.Name,
 				PermissionOverwritesInternal = new List<DiscordOverwrite>(channelNew.PermissionOverwritesInternal),
 				Position = channelNew.Position,
 				Topic = channelNew.Topic,
 				Type = channelNew.Type,
 				UserLimit = channelNew.UserLimit,
 				ParentId = channelNew.ParentId,
 				IsNsfw = channelNew.IsNsfw,
 				PerUserRateLimit = channelNew.PerUserRateLimit,
 				RtcRegionId = channelNew.RtcRegionId,
 				QualityMode = channelNew.QualityMode,
 				DefaultAutoArchiveDuration = channelNew.DefaultAutoArchiveDuration
 			};
 
 			channelNew.Bitrate = channel.Bitrate;
 			channelNew.Name = channel.Name;
 			channelNew.Position = channel.Position;
 			channelNew.Topic = channel.Topic;
 			channelNew.UserLimit = channel.UserLimit;
 			channelNew.ParentId = channel.ParentId;
 			channelNew.IsNsfw = channel.IsNsfw;
 			channelNew.PerUserRateLimit = channel.PerUserRateLimit;
 			channelNew.Type = channel.Type;
 			channelNew.RtcRegionId = channel.RtcRegionId;
 			channelNew.QualityMode = channel.QualityMode;
 			channelNew.DefaultAutoArchiveDuration = channel.DefaultAutoArchiveDuration;
 
 			channelNew.PermissionOverwritesInternal.Clear();
 
 			foreach (var po in channel.PermissionOverwritesInternal)
 			{
 				po.Discord = this;
 				po.ChannelId = channel.Id;
 			}
 
 			channelNew.PermissionOverwritesInternal.AddRange(channel.PermissionOverwritesInternal);
 
 			if (this.Configuration.AutoRefreshChannelCache && gld != null)
 			{
 				await this.RefreshChannelsAsync(channel.Guild.Id);
 			}
 		}
 		else if (gld != null)
 		{
 			gld.ChannelsInternal[channel.Id] = channel;
 
 			if (this.Configuration.AutoRefreshChannelCache)
 			{
 				await this.RefreshChannelsAsync(channel.Guild.Id);
 			}
 		}
 
 		await this._channelUpdated.InvokeAsync(this, new ChannelUpdateEventArgs(this.ServiceProvider) { ChannelAfter = channelNew, Guild = gld, ChannelBefore = channelOld }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the channel delete event.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal async Task OnChannelDeleteEventAsync(DiscordChannel channel)
 	{
 		if (channel == null)
 			return;
 
 		channel.Discord = this;
 
 		//if (channel.IsPrivate)
 		if (channel.Type == ChannelType.Group || channel.Type == ChannelType.Private)
 		{
 			var dmChannel = channel as DiscordDmChannel;
 
 			await this._dmChannelDeleted.InvokeAsync(this, new DmChannelDeleteEventArgs(this.ServiceProvider) { Channel = dmChannel }).ConfigureAwait(false);
 		}
 		else
 		{
 			var gld = channel.Guild;
 
 			if (gld.ChannelsInternal.TryRemove(channel.Id, out var cachedChannel)) channel = cachedChannel;
 
 			if (this.Configuration.AutoRefreshChannelCache)
 			{
 				await this.RefreshChannelsAsync(channel.Guild.Id);
 			}
 
 			await this._channelDeleted.InvokeAsync(this, new ChannelDeleteEventArgs(this.ServiceProvider) { Channel = channel, Guild = gld }).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Refreshes the channels.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	internal async Task RefreshChannelsAsync(ulong guildId)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var channels = await this.ApiClient.GetGuildChannelsAsync(guildId);
 		guild.ChannelsInternal.Clear();
 		foreach (var channel in channels.ToList())
 		{
 			channel.Discord = this;
 			foreach (var xo in channel.PermissionOverwritesInternal)
 			{
 				xo.Discord = this;
 				xo.ChannelId = channel.Id;
 			}
 			guild.ChannelsInternal[channel.Id] = channel;
 		}
 	}
 
 	/// <summary>
 	/// Handles the channel pins update event.
 	/// </summary>
 	/// <param name="guildId">The optional guild id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="lastPinTimestamp">The optional last pin timestamp.</param>
 	internal async Task OnChannelPinsUpdateAsync(ulong? guildId, ulong channelId, DateTimeOffset? lastPinTimestamp)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 		var ea = new ChannelPinsUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Channel = channel,
 			LastPinTimestamp = lastPinTimestamp
 		};
 		await this._channelPinsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Guild
 
 	/// <summary>
 	/// Handles the guild create event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="rawMembers">The raw members.</param>
 	/// <param name="presences">The presences.</param>
 	internal async Task OnGuildCreateEventAsync(DiscordGuild guild, JArray rawMembers, IEnumerable<DiscordPresence> presences)
 	{
 		if (presences != null)
 		{
 			foreach (var xp in presences)
 			{
 				xp.Discord = this;
 				xp.GuildId = guild.Id;
 				xp.Activity = new DiscordActivity(xp.RawActivity);
 				if (xp.RawActivities != null)
 				{
 					xp.InternalActivities = xp.RawActivities
 						.Select(x => new DiscordActivity(x)).ToArray();
 				}
 				this.PresencesInternal[xp.InternalUser.Id] = xp;
 			}
 		}
 
 		var exists = this.GuildsInternal.TryGetValue(guild.Id, out var foundGuild);
 
 		guild.Discord = this;
 		guild.IsUnavailable = false;
 		var eventGuild = guild;
 		if (exists)
 			guild = foundGuild;
 
 		if (guild.ChannelsInternal == null)
 			guild.ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>();
 		if (guild.ThreadsInternal == null)
 			guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 		if (guild.RolesInternal == null)
 			guild.RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>();
 		if (guild.ThreadsInternal == null)
 			guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 		if (guild.StickersInternal == null)
 			guild.StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>();
 		if (guild.EmojisInternal == null)
 			guild.EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>();
 		if (guild.VoiceStatesInternal == null)
 			guild.VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>();
 		if (guild.MembersInternal == null)
 			guild.MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>();
 		if (guild.ScheduledEventsInternal == null)
 			guild.ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>();
 
 		this.UpdateCachedGuild(eventGuild, rawMembers);
 
 		guild.JoinedAt = eventGuild.JoinedAt;
 		guild.IsLarge = eventGuild.IsLarge;
 		guild.MemberCount = Math.Max(eventGuild.MemberCount, guild.MembersInternal.Count);
 		guild.IsUnavailable = eventGuild.IsUnavailable;
 		guild.PremiumSubscriptionCount = eventGuild.PremiumSubscriptionCount;
 		guild.PremiumTier = eventGuild.PremiumTier;
 		guild.BannerHash = eventGuild.BannerHash;
 		guild.VanityUrlCode = eventGuild.VanityUrlCode;
 		guild.Description = eventGuild.Description;
 		guild.IsNsfw = eventGuild.IsNsfw;
 
 		foreach (var kvp in eventGuild.VoiceStatesInternal) guild.VoiceStatesInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.ChannelsInternal) guild.ChannelsInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.RolesInternal) guild.RolesInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.EmojisInternal) guild.EmojisInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.ThreadsInternal) guild.ThreadsInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.StickersInternal) guild.StickersInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.StageInstancesInternal) guild.StageInstancesInternal[kvp.Key] = kvp.Value;
 		foreach (var kvp in eventGuild.ScheduledEventsInternal) guild.ScheduledEventsInternal[kvp.Key] = kvp.Value;
 
 		foreach (var xc in guild.ChannelsInternal.Values)
 		{
 			xc.GuildId = guild.Id;
 			xc.Discord = this;
 			foreach (var xo in xc.PermissionOverwritesInternal)
 			{
 				xo.Discord = this;
 				xo.ChannelId = xc.Id;
 			}
 		}
 		foreach (var xt in guild.ThreadsInternal.Values)
 		{
 			xt.GuildId = guild.Id;
 			xt.Discord = this;
 		}
 		foreach (var xe in guild.EmojisInternal.Values)
 			xe.Discord = this;
 		foreach (var xs in guild.StickersInternal.Values)
 			xs.Discord = this;
 		foreach (var xvs in guild.VoiceStatesInternal.Values)
 			xvs.Discord = this;
 		foreach (var xsi in guild.StageInstancesInternal.Values)
 		{
 			xsi.Discord = this;
 			xsi.GuildId = guild.Id;
 		}
 		foreach (var xr in guild.RolesInternal.Values)
 		{
 			xr.Discord = this;
 			xr.GuildId = guild.Id;
 		}
 		foreach (var xse in guild.ScheduledEventsInternal.Values)
 		{
 			xse.Discord = this;
 			xse.GuildId = guild.Id;
 			if (xse.Creator != null)
 				xse.Creator.Discord = this;
 		}
 
 		var old = Volatile.Read(ref this._guildDownloadCompleted);
 		var dcompl = this.GuildsInternal.Values.All(xg => !xg.IsUnavailable);
 		Volatile.Write(ref this._guildDownloadCompleted, dcompl);
 
 		if (exists)
 			await this._guildAvailable.InvokeAsync(this, new GuildCreateEventArgs(this.ServiceProvider) { Guild = guild }).ConfigureAwait(false);
 		else
 			await this._guildCreated.InvokeAsync(this, new GuildCreateEventArgs(this.ServiceProvider) { Guild = guild }).ConfigureAwait(false);
 
 		if (dcompl && !old)
 			await this._guildDownloadCompletedEv.InvokeAsync(this, new GuildDownloadCompletedEventArgs(this.Guilds, this.ServiceProvider)).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild update event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="rawMembers">The raw members.</param>
 	internal async Task OnGuildUpdateEventAsync(DiscordGuild guild, JArray rawMembers)
 	{
 		DiscordGuild oldGuild;
 
 		if (!this.GuildsInternal.ContainsKey(guild.Id))
 		{
 			this.GuildsInternal[guild.Id] = guild;
 			oldGuild = null;
 		}
 		else
 		{
 			var gld = this.GuildsInternal[guild.Id];
 
 			oldGuild = new DiscordGuild
 			{
 				Discord = gld.Discord,
 				Name = gld.Name,
 				AfkChannelId = gld.AfkChannelId,
 				AfkTimeout = gld.AfkTimeout,
 				ApplicationId = gld.ApplicationId,
 				DefaultMessageNotifications = gld.DefaultMessageNotifications,
 				ExplicitContentFilter = gld.ExplicitContentFilter,
 				RawFeatures = gld.RawFeatures,
 				IconHash = gld.IconHash,
 				Id = gld.Id,
 				IsLarge = gld.IsLarge,
 				IsSynced = gld.IsSynced,
 				IsUnavailable = gld.IsUnavailable,
 				JoinedAt = gld.JoinedAt,
 				MemberCount = gld.MemberCount,
 				MaxMembers = gld.MaxMembers,
 				MaxPresences = gld.MaxPresences,
 				ApproximateMemberCount = gld.ApproximateMemberCount,
 				ApproximatePresenceCount = gld.ApproximatePresenceCount,
 				MaxVideoChannelUsers = gld.MaxVideoChannelUsers,
 				DiscoverySplashHash = gld.DiscoverySplashHash,
 				PreferredLocale = gld.PreferredLocale,
 				MfaLevel = gld.MfaLevel,
 				OwnerId = gld.OwnerId,
 				SplashHash = gld.SplashHash,
 				SystemChannelId = gld.SystemChannelId,
 				SystemChannelFlags = gld.SystemChannelFlags,
 				Description = gld.Description,
 				WidgetEnabled = gld.WidgetEnabled,
 				WidgetChannelId = gld.WidgetChannelId,
 				VerificationLevel = gld.VerificationLevel,
 				RulesChannelId = gld.RulesChannelId,
 				PublicUpdatesChannelId = gld.PublicUpdatesChannelId,
 				VoiceRegionId = gld.VoiceRegionId,
 				IsNsfw = gld.IsNsfw,
 				PremiumProgressBarEnabled = gld.PremiumProgressBarEnabled,
 				PremiumSubscriptionCount = gld.PremiumSubscriptionCount,
 				PremiumTier = gld.PremiumTier,
 				ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>(),
 				ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>(),
 				EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>(),
 				StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>(),
 				MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>(),
 				RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>(),
 				StageInstancesInternal = new ConcurrentDictionary<ulong, DiscordStageInstance>(),
 				VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>(),
 				ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>()
 			};
 
 			foreach (var kvp in gld.ChannelsInternal) oldGuild.ChannelsInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.ThreadsInternal) oldGuild.ThreadsInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.EmojisInternal) oldGuild.EmojisInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.StickersInternal) oldGuild.StickersInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.RolesInternal) oldGuild.RolesInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.VoiceStatesInternal) oldGuild.VoiceStatesInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.MembersInternal) oldGuild.MembersInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.StageInstancesInternal) oldGuild.StageInstancesInternal[kvp.Key] = kvp.Value;
 			foreach (var kvp in gld.ScheduledEventsInternal) oldGuild.ScheduledEventsInternal[kvp.Key] = kvp.Value;
 		}
 
 		guild.Discord = this;
 		guild.IsUnavailable = false;
 		var eventGuild = guild;
 		guild = this.GuildsInternal[eventGuild.Id];
 
 		if (guild.ChannelsInternal == null)
 			guild.ChannelsInternal = new ConcurrentDictionary<ulong, DiscordChannel>();
 		if (guild.ThreadsInternal == null)
 			guild.ThreadsInternal = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 		if (guild.RolesInternal == null)
 			guild.RolesInternal = new ConcurrentDictionary<ulong, DiscordRole>();
 		if (guild.EmojisInternal == null)
 			guild.EmojisInternal = new ConcurrentDictionary<ulong, DiscordEmoji>();
 		if (guild.StickersInternal == null)
 			guild.StickersInternal = new ConcurrentDictionary<ulong, DiscordSticker>();
 		if (guild.VoiceStatesInternal == null)
 			guild.VoiceStatesInternal = new ConcurrentDictionary<ulong, DiscordVoiceState>();
 		if (guild.StageInstancesInternal == null)
 			guild.StageInstancesInternal = new ConcurrentDictionary<ulong, DiscordStageInstance>();
 		if (guild.MembersInternal == null)
 			guild.MembersInternal = new ConcurrentDictionary<ulong, DiscordMember>();
 		if (guild.ScheduledEventsInternal == null)
 			guild.ScheduledEventsInternal = new ConcurrentDictionary<ulong, DiscordScheduledEvent>();
 
 		this.UpdateCachedGuild(eventGuild, rawMembers);
 
 		foreach (var xc in guild.ChannelsInternal.Values)
 		{
 			xc.GuildId = guild.Id;
 			xc.Discord = this;
 			foreach (var xo in xc.PermissionOverwritesInternal)
 			{
 				xo.Discord = this;
 				xo.ChannelId = xc.Id;
 			}
 		}
 		foreach (var xc in guild.ThreadsInternal.Values)
 		{
 			xc.GuildId = guild.Id;
 			xc.Discord = this;
 		}
 		foreach (var xe in guild.EmojisInternal.Values)
 			xe.Discord = this;
 		foreach (var xs in guild.StickersInternal.Values)
 			xs.Discord = this;
 		foreach (var xvs in guild.VoiceStatesInternal.Values)
 			xvs.Discord = this;
 		foreach (var xr in guild.RolesInternal.Values)
 		{
 			xr.Discord = this;
 			xr.GuildId = guild.Id;
 		}
 		foreach (var xsi in guild.StageInstancesInternal.Values)
 		{
 			xsi.Discord = this;
 			xsi.GuildId = guild.Id;
 		}
 		foreach (var xse in guild.ScheduledEventsInternal.Values)
 		{
 			xse.Discord = this;
 			xse.GuildId = guild.Id;
 			if (xse.Creator != null)
 				xse.Creator.Discord = this;
 		}
 
 		await this._guildUpdated.InvokeAsync(this, new GuildUpdateEventArgs(this.ServiceProvider) { GuildBefore = oldGuild, GuildAfter = guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild delete event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildDeleteEventAsync(DiscordGuild guild)
 	{
 		if (guild.IsUnavailable)
 		{
 			if (!this.GuildsInternal.TryGetValue(guild.Id, out var gld))
 				return;
 
 			gld.IsUnavailable = true;
 
 			await this._guildUnavailable.InvokeAsync(this, new GuildDeleteEventArgs(this.ServiceProvider) { Guild = guild, Unavailable = true }).ConfigureAwait(false);
 		}
 		else
 		{
 			if (!this.GuildsInternal.TryRemove(guild.Id, out var gld))
 				return;
 
 			await this._guildDeleted.InvokeAsync(this, new GuildDeleteEventArgs(this.ServiceProvider) { Guild = gld }).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Handles the guild sync event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="isLarge">Whether the guild is a large guild..</param>
 	/// <param name="rawMembers">The raw members.</param>
 	/// <param name="presences">The presences.</param>
 	internal async Task OnGuildSyncEventAsync(DiscordGuild guild, bool isLarge, JArray rawMembers, IEnumerable<DiscordPresence> presences)
 	{
 		presences = presences.Select(xp => { xp.Discord = this; xp.Activity = new DiscordActivity(xp.RawActivity); return xp; });
 		foreach (var xp in presences)
 			this.PresencesInternal[xp.InternalUser.Id] = xp;
 
 		guild.IsSynced = true;
 		guild.IsLarge = isLarge;
 
 		this.UpdateCachedGuild(guild, rawMembers);
 
 		await this._guildAvailable.InvokeAsync(this, new GuildCreateEventArgs(this.ServiceProvider) { Guild = guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild emojis update event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="newEmojis">The new emojis.</param>
 	internal async Task OnGuildEmojisUpdateEventAsync(DiscordGuild guild, IEnumerable<DiscordEmoji> newEmojis)
 	{
 		var oldEmojis = new ConcurrentDictionary<ulong, DiscordEmoji>(guild.EmojisInternal);
 		guild.EmojisInternal.Clear();
 
 		foreach (var emoji in newEmojis)
 		{
 			emoji.Discord = this;
 			guild.EmojisInternal[emoji.Id] = emoji;
 		}
 
 		var ea = new GuildEmojisUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			EmojisAfter = guild.Emojis,
 			EmojisBefore = new ReadOnlyConcurrentDictionary<ulong, DiscordEmoji>(oldEmojis)
 		};
 		await this._guildEmojisUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the stickers updated.
 	/// </summary>
 	/// <param name="newStickers">The new stickers.</param>
 	/// <param name="guildId">The guild id.</param>
 	internal async Task OnStickersUpdatedAsync(IEnumerable<DiscordSticker> newStickers, ulong guildId)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var oldStickers = new ConcurrentDictionary<ulong, DiscordSticker>(guild.StickersInternal);
 		guild.StickersInternal.Clear();
 
 		foreach (var nst in newStickers)
 		{
 			if (nst.User is not null)
 			{
 				nst.User.Discord = this;
 				this.UserCache.AddOrUpdate(nst.User.Id, nst.User, (old, @new) => @new);
 			}
 			nst.Discord = this;
 
 			guild.StickersInternal[nst.Id] = nst;
 		}
 
 		var sea = new GuildStickersUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			StickersBefore = oldStickers,
 			StickersAfter = guild.Stickers
 		};
 
 		await this._guildStickersUpdated.InvokeAsync(this, sea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Guild Ban
 
 	/// <summary>
 	/// Handles the guild ban add event.
 	/// </summary>
 	/// <param name="user">The transport user.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildBanAddEventAsync(TransportUser user, DiscordGuild guild)
 	{
 		var usr = new DiscordUser(user) { Discord = this };
 		usr = this.UserCache.AddOrUpdate(user.Id, usr, (id, old) =>
 		{
 			old.Username = usr.Username;
 			old.Discriminator = usr.Discriminator;
 			old.AvatarHash = usr.AvatarHash;
 			return old;
 		});
 
 		if (!guild.Members.TryGetValue(user.Id, out var mbr))
 			mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 		var ea = new GuildBanAddEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Member = mbr
 		};
 		await this._guildBanAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild ban remove event.
 	/// </summary>
 	/// <param name="user">The transport user.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildBanRemoveEventAsync(TransportUser user, DiscordGuild guild)
 	{
 		var usr = new DiscordUser(user) { Discord = this };
 		usr = this.UserCache.AddOrUpdate(user.Id, usr, (id, old) =>
 		{
 			old.Username = usr.Username;
 			old.Discriminator = usr.Discriminator;
 			old.AvatarHash = usr.AvatarHash;
 			return old;
 		});
 
 		if (!guild.Members.TryGetValue(user.Id, out var mbr))
 			mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 		var ea = new GuildBanRemoveEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Member = mbr
 		};
 		await this._guildBanRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Guild Scheduled Event
 
 	/// <summary>
 	/// Handles the scheduled event create event.
 	/// </summary>
 	/// <param name="scheduledEvent">The created event.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildScheduledEventCreateEventAsync(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 	{
 		scheduledEvent.Discord = this;
 
 		guild.ScheduledEventsInternal.AddOrUpdate(scheduledEvent.Id, scheduledEvent, (old, newScheduledEvent) => newScheduledEvent);
 
 		if (scheduledEvent.Creator != null)
 		{
 			scheduledEvent.Creator.Discord = this;
 			this.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 			{
 				old.Username = scheduledEvent.Creator.Username;
 				old.Discriminator = scheduledEvent.Creator.Discriminator;
 				old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 				old.Flags = scheduledEvent.Creator.Flags;
 				return old;
 			});
 		}
 
 		await this._guildScheduledEventCreated.InvokeAsync(this, new GuildScheduledEventCreateEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = scheduledEvent.Guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the scheduled event update event.
 	/// </summary>
 	/// <param name="scheduledEvent">The updated event.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildScheduledEventUpdateEventAsync(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 	{
 		if (guild == null)
 			return;
 
 		DiscordScheduledEvent oldEvent;
 		if (!guild.ScheduledEventsInternal.ContainsKey(scheduledEvent.Id))
 		{
 			oldEvent = null;
 		}
 		else
 		{
 			var ev = guild.ScheduledEventsInternal[scheduledEvent.Id];
 			oldEvent = new DiscordScheduledEvent
 			{
 				Id = ev.Id,
 				ChannelId = ev.ChannelId,
 				EntityId = ev.EntityId,
 				EntityMetadata = ev.EntityMetadata,
 				CreatorId = ev.CreatorId,
 				Creator = ev.Creator,
 				Discord = this,
 				Description = ev.Description,
 				EntityType = ev.EntityType,
 				ScheduledStartTimeRaw = ev.ScheduledStartTimeRaw,
 				ScheduledEndTimeRaw = ev.ScheduledEndTimeRaw,
 				GuildId = ev.GuildId,
 				Status = ev.Status,
 				Name = ev.Name,
 				UserCount = ev.UserCount,
 				CoverImageHash = ev.CoverImageHash
 			};
 
 		}
 		if (scheduledEvent.Creator != null)
 		{
 			scheduledEvent.Creator.Discord = this;
 			this.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 			{
 				old.Username = scheduledEvent.Creator.Username;
 				old.Discriminator = scheduledEvent.Creator.Discriminator;
 				old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 				old.Flags = scheduledEvent.Creator.Flags;
 				return old;
 			});
 		}
 
 		if (scheduledEvent.Status == ScheduledEventStatus.Completed)
 		{
 			guild.ScheduledEventsInternal.TryRemove(scheduledEvent.Id, out var deletedEvent);
 			await this._guildScheduledEventDeleted.InvokeAsync(this, new GuildScheduledEventDeleteEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, Reason = ScheduledEventStatus.Completed }).ConfigureAwait(false);
 		}
 		else if (scheduledEvent.Status == ScheduledEventStatus.Canceled)
 		{
 			guild.ScheduledEventsInternal.TryRemove(scheduledEvent.Id, out var deletedEvent);
 			scheduledEvent.Status = ScheduledEventStatus.Canceled;
 			await this._guildScheduledEventDeleted.InvokeAsync(this, new GuildScheduledEventDeleteEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, Reason = ScheduledEventStatus.Canceled }).ConfigureAwait(false);
 		}
 		else
 		{
 			this.UpdateScheduledEvent(scheduledEvent, guild);
 			await this._guildScheduledEventUpdated.InvokeAsync(this, new GuildScheduledEventUpdateEventArgs(this.ServiceProvider) { ScheduledEventBefore = oldEvent, ScheduledEventAfter = scheduledEvent, Guild = guild }).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Handles the scheduled event delete event.
 	/// </summary>
 	/// <param name="scheduledEvent">The deleted event.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildScheduledEventDeleteEventAsync(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 	{
 		scheduledEvent.Discord = this;
 
 		if (scheduledEvent.Status == ScheduledEventStatus.Scheduled)
 			scheduledEvent.Status = ScheduledEventStatus.Canceled;
 
 		if (scheduledEvent.Creator != null)
 		{
 			scheduledEvent.Creator.Discord = this;
 			this.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 			{
 				old.Username = scheduledEvent.Creator.Username;
 				old.Discriminator = scheduledEvent.Creator.Discriminator;
 				old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 				old.Flags = scheduledEvent.Creator.Flags;
 				return old;
 			});
 		}
 
 		await this._guildScheduledEventDeleted.InvokeAsync(this, new GuildScheduledEventDeleteEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = scheduledEvent.Guild, Reason = scheduledEvent.Status }).ConfigureAwait(false);
 		guild.ScheduledEventsInternal.TryRemove(scheduledEvent.Id, out var deletedEvent);
 	}
 
 	/// <summary>
 	/// Handles the scheduled event user add event.
 	/// <param name="guildScheduledEventId">The event.</param>
 	/// <param name="userId">The added user id.</param>
 	/// <param name="guild">The guild.</param>
 	/// </summary>
 	internal async Task OnGuildScheduledEventUserAddedEventAsync(ulong guildScheduledEventId, ulong userId, DiscordGuild guild)
 	{
 		var scheduledEvent = this.InternalGetCachedScheduledEvent(guildScheduledEventId) ?? this.UpdateScheduledEvent(new DiscordScheduledEvent
 		{
 			Id = guildScheduledEventId,
 			GuildId = guild.Id,
 			Discord = this,
 			UserCount = 0
 		}, guild);
 
 		scheduledEvent.UserCount++;
 		scheduledEvent.Discord = this;
 		guild.Discord = this;
 
 		var user = this.GetUserAsync(userId, true).Result;
 		user.Discord = this;
 		var member = guild.Members.TryGetValue(userId, out var mem) ? mem : guild.GetMemberAsync(userId).Result;
 		member.Discord = this;
 
 		await this._guildScheduledEventUserAdded.InvokeAsync(this, new GuildScheduledEventUserAddEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, User = user, Member = member }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the scheduled event user remove event.
 	/// <param name="guildScheduledEventId">The event.</param>
 	/// <param name="userId">The removed user id.</param>
 	/// <param name="guild">The guild.</param>
 	/// </summary>
 	internal async Task OnGuildScheduledEventUserRemovedEventAsync(ulong guildScheduledEventId, ulong userId, DiscordGuild guild)
 	{
 		var scheduledEvent = this.InternalGetCachedScheduledEvent(guildScheduledEventId) ?? this.UpdateScheduledEvent(new DiscordScheduledEvent
 		{
 			Id = guildScheduledEventId,
 			GuildId = guild.Id,
 			Discord = this,
 			UserCount = 0
 		}, guild);
 
 		scheduledEvent.UserCount = scheduledEvent.UserCount == 0 ? 0 : scheduledEvent.UserCount - 1;
 		scheduledEvent.Discord = this;
 		guild.Discord = this;
 
 		var user = this.GetUserAsync(userId, true).Result;
 		user.Discord = this;
 		var member = guild.Members.TryGetValue(userId, out var mem) ? mem : guild.GetMemberAsync(userId).Result;
 		member.Discord = this;
 
 		await this._guildScheduledEventUserRemoved.InvokeAsync(this, new GuildScheduledEventUserRemoveEventArgs(this.ServiceProvider) { ScheduledEvent = scheduledEvent, Guild = guild, User = user, Member = member }).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Guild Integration
 
 	/// <summary>
 	/// Handles the guild integration create event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="integration">The integration.</param>
 	internal async Task OnGuildIntegrationCreateEventAsync(DiscordGuild guild, DiscordIntegration integration)
 	{
 		integration.Discord = this;
 
 		await this._guildIntegrationCreated.InvokeAsync(this, new GuildIntegrationCreateEventArgs(this.ServiceProvider) { Integration = integration, Guild = guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild integration update event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="integration">The integration.</param>
 	internal async Task OnGuildIntegrationUpdateEventAsync(DiscordGuild guild, DiscordIntegration integration)
 	{
 		integration.Discord = this;
 
 		await this._guildIntegrationUpdated.InvokeAsync(this, new GuildIntegrationUpdateEventArgs(this.ServiceProvider) { Integration = integration, Guild = guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild integrations update event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildIntegrationsUpdateEventAsync(DiscordGuild guild)
 	{
 		var ea = new GuildIntegrationsUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild
 		};
 		await this._guildIntegrationsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild integration delete event.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="integrationId">The integration id.</param>
 	/// <param name="applicationId">The optional application id.</param>
 	internal async Task OnGuildIntegrationDeleteEventAsync(DiscordGuild guild, ulong integrationId, ulong? applicationId)
 		=> await this._guildIntegrationDeleted.InvokeAsync(this, new GuildIntegrationDeleteEventArgs(this.ServiceProvider) { Guild = guild, IntegrationId = integrationId, ApplicationId = applicationId }).ConfigureAwait(false);
 
 	#endregion
 
 	#region Guild Member
 
 	/// <summary>
 	/// Handles the guild member add event.
 	/// </summary>
 	/// <param name="member">The transport member.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildMemberAddEventAsync(TransportMember member, DiscordGuild guild)
 	{
 		var usr = new DiscordUser(member.User) { Discord = this };
 		usr = this.UserCache.AddOrUpdate(member.User.Id, usr, (id, old) =>
 		{
 			old.Username = usr.Username;
 			old.Discriminator = usr.Discriminator;
 			old.AvatarHash = usr.AvatarHash;
 			return old;
 		});
 
 		var mbr = new DiscordMember(member)
 		{
 			Discord = this,
 			GuildId = guild.Id
 		};
 
 		guild.MembersInternal[mbr.Id] = mbr;
 		guild.MemberCount++;
 
 		var ea = new GuildMemberAddEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Member = mbr
 		};
 		await this._guildMemberAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild member remove event.
 	/// </summary>
 	/// <param name="user">The transport user.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildMemberRemoveEventAsync(TransportUser user, DiscordGuild guild)
 	{
 		var usr = new DiscordUser(user);
 
 		if (!guild.MembersInternal.TryRemove(user.Id, out var mbr))
 			mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 		guild.MemberCount--;
 
 		_ = this.UserCache.AddOrUpdate(user.Id, usr, (old, @new) => @new);
 
 		var ea = new GuildMemberRemoveEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Member = mbr
 		};
 		await this._guildMemberRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild member update event.
 	/// </summary>
 	/// <param name="member">The transport member.</param>
 	/// <param name="guild">The guild.</param>
 	/// <param name="roles">The roles.</param>
 	/// <param name="nick">The nick.</param>
 	/// <param name="pending">Whether the member is pending.</param>
 	internal async Task OnGuildMemberUpdateEventAsync(TransportMember member, DiscordGuild guild, IEnumerable<ulong> roles, string nick, bool? pending)
 	{
 		var usr = new DiscordUser(member.User) { Discord = this };
 		usr = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 		{
 			old.Username = usr.Username;
 			old.Discriminator = usr.Discriminator;
 			old.AvatarHash = usr.AvatarHash;
 			return old;
 		});
 
 		if (!guild.Members.TryGetValue(member.User.Id, out var mbr))
 			mbr = new DiscordMember(usr) { Discord = this, GuildId = guild.Id };
 		var old = mbr;
 
 		var gAvOld = old.GuildAvatarHash;
 		var avOld = old.AvatarHash;
 		var nickOld = mbr.Nickname;
 		var pendingOld = mbr.IsPending;
 		var rolesOld = new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(mbr.Roles));
 		var cduOld = mbr.CommunicationDisabledUntil;
 		mbr.MemberFlags = member.MemberFlags;
 		mbr.AvatarHashInternal = member.AvatarHash;
 		mbr.GuildAvatarHash = member.GuildAvatarHash;
 		mbr.Nickname = nick;
+		mbr.GuildPronouns = member.GuildPronouns;
 		mbr.IsPending = pending;
 		mbr.CommunicationDisabledUntil = member.CommunicationDisabledUntil;
 		mbr.RoleIdsInternal.Clear();
 		mbr.RoleIdsInternal.AddRange(roles);
 		guild.MembersInternal.AddOrUpdate(member.User.Id, mbr, (id, oldMbr) => oldMbr);
 
 		var timeoutUntil = member.CommunicationDisabledUntil;
 		/*this.Logger.LogTrace($"Timeout:\nBefore - {cduOld}\nAfter - {timeoutUntil}");
 		if ((timeoutUntil.HasValue && cduOld.HasValue) || (timeoutUntil == null && cduOld.HasValue) || (timeoutUntil.HasValue && cduOld == null))
 		{
 			// We are going to add a scheduled timer to assure that we get a auditlog entry.
 
 			var id = $"tt-{mbr.Id}-{guild.Id}-{DateTime.Now.ToLongTimeString()}";
 
 			this._tempTimers.Add(
 				id,
 				new(
 					new TimeoutHandler(
 						mbr,
 						guild,
 						cduOld,
 						timeoutUntil
 					),
 					new Timer(
 						this.TimeoutTimer,
 						id,
 						2000,
 						Timeout.Infinite
 					)
 				)
 			);
 
 			this.Logger.LogTrace("Scheduling timeout event.");
 
 			return;
 		}*/
 
 		//this.Logger.LogTrace("No timeout detected. Continuing on normal operation.");
 
 		var eargs = new GuildMemberUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Member = mbr,
 
 			NicknameAfter = mbr.Nickname,
 			RolesAfter = new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(mbr.Roles)),
 			PendingAfter = mbr.IsPending,
 			TimeoutAfter = mbr.CommunicationDisabledUntil,
 			AvatarHashAfter = mbr.AvatarHash,
 			GuildAvatarHashAfter = mbr.GuildAvatarHash,
 
 			NicknameBefore = nickOld,
 			RolesBefore = rolesOld,
 			PendingBefore = pendingOld,
 			TimeoutBefore = cduOld,
 			AvatarHashBefore = avOld,
 			GuildAvatarHashBefore = gAvOld
 		};
 		await this._guildMemberUpdated.InvokeAsync(this, eargs).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles timeout events.
 	/// </summary>
 	/// <param name="state">Internally used as uid for the timer data.</param>
 	private async void TimeoutTimer(object state)
 	{
 		var tid = (string)state;
 		var data = this._tempTimers.First(x=> x.Key == tid).Value.Key;
 		var timer = this._tempTimers.First(x=> x.Key == tid).Value.Value;
 
 		IReadOnlyList<DiscordAuditLogEntry> auditlog = null;
 		DiscordAuditLogMemberUpdateEntry filtered = null;
 		try
 		{
 			auditlog = await data.Guild.GetAuditLogsAsync(10, null, AuditLogActionType.MemberUpdate);
 			var preFiltered = auditlog.Select(x => x as DiscordAuditLogMemberUpdateEntry).Where(x => x.Target.Id == data.Member.Id);
 			filtered = preFiltered.First();
 		}
 		catch (UnauthorizedException) { }
 		catch (Exception)
 		{
 			this.Logger.LogTrace("Failing timeout event.");
 			await timer.DisposeAsync();
 			this._tempTimers.Remove(tid);
 			return;
 		}
 
 		var actor = filtered?.UserResponsible as DiscordMember;
 
 		this.Logger.LogTrace("Trying to execute timeout event.");
 
 		if (data.TimeoutUntilOld.HasValue && data.TimeoutUntilNew.HasValue)
 		{
 			// A timeout was updated.
 
 			if (filtered != null && auditlog == null)
 			{
 				this.Logger.LogTrace("Re-scheduling timeout event.");
 				timer.Change(2000, Timeout.Infinite);
 				return;
 			}
 
 			var ea = new GuildMemberTimeoutUpdateEventArgs(this.ServiceProvider)
 			{
 				Guild = data.Guild,
 				Target = data.Member,
 				TimeoutBefore = data.TimeoutUntilOld.Value,
 				TimeoutAfter = data.TimeoutUntilNew.Value,
 				Actor = actor,
 				AuditLogId = filtered?.Id,
 				AuditLogReason = filtered?.Reason
 			};
 			await this._guildMemberTimeoutChanged.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 		else if (!data.TimeoutUntilOld.HasValue && data.TimeoutUntilNew.HasValue)
 		{
 			// A timeout was added.
 
 			if (filtered != null && auditlog == null)
 			{
 				this.Logger.LogTrace("Re-scheduling timeout event.");
 				timer.Change(2000, Timeout.Infinite);
 				return;
 			}
 
 			var ea = new GuildMemberTimeoutAddEventArgs(this.ServiceProvider)
 			{
 				Guild = data.Guild,
 				Target = data.Member,
 				Timeout = data.TimeoutUntilNew.Value,
 				Actor = actor,
 				AuditLogId = filtered?.Id,
 				AuditLogReason = filtered?.Reason
 			};
 			await this._guildMemberTimeoutAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 		else if (data.TimeoutUntilOld.HasValue && !data.TimeoutUntilNew.HasValue)
 		{
 			// A timeout was removed.
 
 			if (filtered != null && auditlog == null)
 			{
 				this.Logger.LogTrace("Re-scheduling timeout event.");
 				timer.Change(2000, Timeout.Infinite);
 				return;
 			}
 
 			var ea = new GuildMemberTimeoutRemoveEventArgs(this.ServiceProvider)
 			{
 				Guild = data.Guild,
 				Target = data.Member,
 				TimeoutBefore = data.TimeoutUntilOld.Value,
 				Actor = actor,
 				AuditLogId = filtered?.Id,
 				AuditLogReason = filtered?.Reason
 			};
 			await this._guildMemberTimeoutRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 		}
 
 		// Ending timer because it worked.
 		this.Logger.LogTrace("Removing timeout event.");
 		await timer.DisposeAsync();
 		this._tempTimers.Remove(tid);
 	}
 
 	/// <summary>
 	/// Handles the guild members chunk event.
 	/// </summary>
 	/// <param name="dat">The raw chunk data.</param>
 	internal async Task OnGuildMembersChunkEventAsync(JObject dat)
 	{
 		var guild = this.Guilds[(ulong)dat["guild_id"]];
 		var chunkIndex = (int)dat["chunk_index"];
 		var chunkCount = (int)dat["chunk_count"];
 		var nonce = (string)dat["nonce"];
 
 		var mbrs = new HashSet<DiscordMember>();
 		var pres = new HashSet<DiscordPresence>();
 
 		var members = dat["members"].ToObject<TransportMember[]>();
 
 		foreach (var member in members)
 		{
 			var mbr = new DiscordMember(member) { Discord = this, GuildId = guild.Id };
 
 			if (!this.UserCache.ContainsKey(mbr.Id))
 				this.UserCache[mbr.Id] = new DiscordUser(member.User) { Discord = this };
 
 			guild.MembersInternal[mbr.Id] = mbr;
 
 			mbrs.Add(mbr);
 		}
 
 		guild.MemberCount = guild.MembersInternal.Count;
 
 		var ea = new GuildMembersChunkEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Members = new ReadOnlySet<DiscordMember>(mbrs),
 			ChunkIndex = chunkIndex,
 			ChunkCount = chunkCount,
 			Nonce = nonce,
 		};
 
 		if (dat["presences"] != null)
 		{
 			var presences = dat["presences"].ToObject<DiscordPresence[]>();
 
 			var presCount = presences.Length;
 			foreach (var presence in presences)
 			{
 				presence.Discord = this;
 				presence.Activity = new DiscordActivity(presence.RawActivity);
 
 				if (presence.RawActivities != null)
 				{
 					presence.InternalActivities = presence.RawActivities
 						.Select(x => new DiscordActivity(x)).ToArray();
 				}
 
 				pres.Add(presence);
 			}
 
 			ea.Presences = new ReadOnlySet<DiscordPresence>(pres);
 		}
 
 		if (dat["not_found"] != null)
 		{
 			var nf = dat["not_found"].ToObject<ISet<ulong>>();
 			ea.NotFound = new ReadOnlySet<ulong>(nf);
 		}
 
 		await this._guildMembersChunked.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Guild Role
 
 	/// <summary>
 	/// Handles the guild role create event.
 	/// </summary>
 	/// <param name="role">The role.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildRoleCreateEventAsync(DiscordRole role, DiscordGuild guild)
 	{
 		role.Discord = this;
 		role.GuildId = guild.Id;
 
 		guild.RolesInternal[role.Id] = role;
 
 		var ea = new GuildRoleCreateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Role = role
 		};
 		await this._guildRoleCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild role update event.
 	/// </summary>
 	/// <param name="role">The role.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildRoleUpdateEventAsync(DiscordRole role, DiscordGuild guild)
 	{
 		var newRole = guild.GetRole(role.Id);
 		var oldRole = new DiscordRole
 		{
 			GuildId = guild.Id,
 			ColorInternal = newRole.ColorInternal,
 			Discord = this,
 			IsHoisted = newRole.IsHoisted,
 			Id = newRole.Id,
 			IsManaged = newRole.IsManaged,
 			IsMentionable = newRole.IsMentionable,
 			Name = newRole.Name,
 			Permissions = newRole.Permissions,
 			Position = newRole.Position,
 			IconHash = newRole.IconHash,
 			Tags = newRole.Tags ?? null,
 			UnicodeEmojiString = newRole.UnicodeEmojiString
 		};
 
 		newRole.GuildId = guild.Id;
 		newRole.ColorInternal = role.ColorInternal;
 		newRole.IsHoisted = role.IsHoisted;
 		newRole.IsManaged = role.IsManaged;
 		newRole.IsMentionable = role.IsMentionable;
 		newRole.Name = role.Name;
 		newRole.Permissions = role.Permissions;
 		newRole.Position = role.Position;
 		newRole.IconHash = role.IconHash;
 		newRole.Tags = role.Tags ?? null;
 		newRole.UnicodeEmojiString = role.UnicodeEmojiString;
 
 		var ea = new GuildRoleUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			RoleAfter = newRole,
 			RoleBefore = oldRole
 		};
 		await this._guildRoleUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild role delete event.
 	/// </summary>
 	/// <param name="roleId">The role id.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnGuildRoleDeleteEventAsync(ulong roleId, DiscordGuild guild)
 	{
 		if (!guild.RolesInternal.TryRemove(roleId, out var role))
 			this.Logger.LogWarning($"Attempted to delete a nonexistent role ({roleId}) from guild ({guild}).");
 
 		var ea = new GuildRoleDeleteEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Role = role
 		};
 		await this._guildRoleDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Invite
 
 	/// <summary>
 	/// Handles the invite create event.
 	/// </summary>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="invite">The invite.</param>
 	internal async Task OnInviteCreateEventAsync(ulong channelId, ulong guildId, DiscordInvite invite)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var channel = this.InternalGetCachedChannel(channelId);
 
 		invite.Discord = this;
 
 		if (invite.Inviter is not null)
 		{
 			invite.Inviter.Discord = this;
 			this.UserCache.AddOrUpdate(invite.Inviter.Id, invite.Inviter, (old, @new) => @new);
 		}
 
 		guild.Invites[invite.Code] = invite;
 
 		var ea = new InviteCreateEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Guild = guild,
 			Invite = invite
 		};
 		await this._inviteCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the invite delete event.
 	/// </summary>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="dat">The raw invite.</param>
 	internal async Task OnInviteDeleteEventAsync(ulong channelId, ulong guildId, JToken dat)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var channel = this.InternalGetCachedChannel(channelId);
 
 		if (!guild.Invites.TryRemove(dat["code"].ToString(), out var invite))
 		{
 			invite = dat.ToObject<DiscordInvite>();
 			invite.Discord = this;
 		}
 
 		invite.IsRevoked = true;
 
 		var ea = new InviteDeleteEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Guild = guild,
 			Invite = invite
 		};
 		await this._inviteDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Message
 
 	/// <summary>
 	/// Handles the message acknowledge event.
 	/// </summary>
 	/// <param name="chn">The channel.</param>
 	/// <param name="messageId">The message id.</param>
 	internal async Task OnMessageAckEventAsync(DiscordChannel chn, ulong messageId)
 	{
 		if (this.MessageCache == null || !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == chn.Id, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 				Id = messageId,
 				ChannelId = chn.Id,
 				Discord = this,
 			};
 		}
 
 		await this._messageAcknowledged.InvokeAsync(this, new MessageAcknowledgeEventArgs(this.ServiceProvider) { Message = msg }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message create event.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <param name="author">The transport user (author).</param>
 	/// <param name="member">The transport member.</param>
 	/// <param name="referenceAuthor">The reference transport user (author).</param>
 	/// <param name="referenceMember">The reference transport member.</param>
 	internal async Task OnMessageCreateEventAsync(DiscordMessage message, TransportUser author, TransportMember member, TransportUser referenceAuthor, TransportMember referenceMember)
 	{
 		message.Discord = this;
 		this.PopulateMessageReactionsAndCache(message, author, member);
 		message.PopulateMentions();
 
 		if (message.Channel == null && message.ChannelId == default)
 			this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Channel which the last message belongs to is not in cache - cache state might be invalid!");
 
 		if (message.ReferencedMessage != null)
 		{
 			message.ReferencedMessage.Discord = this;
 			this.PopulateMessageReactionsAndCache(message.ReferencedMessage, referenceAuthor, referenceMember);
 			message.ReferencedMessage.PopulateMentions();
 		}
 
 		foreach (var sticker in message.Stickers)
 			sticker.Discord = this;
 
 		var ea = new MessageCreateEventArgs(this.ServiceProvider)
 		{
 			Message = message,
 
 			MentionedUsers = new ReadOnlyCollection<DiscordUser>(message.MentionedUsersInternal),
 			MentionedRoles = message.MentionedRolesInternal != null ? new ReadOnlyCollection<DiscordRole>(message.MentionedRolesInternal) : null,
 			MentionedChannels = message.MentionedChannelsInternal != null ? new ReadOnlyCollection<DiscordChannel>(message.MentionedChannelsInternal) : null
 		};
 		await this._messageCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message update event.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <param name="author">The transport user (author).</param>
 	/// <param name="member">The transport member.</param>
 	/// <param name="referenceAuthor">The reference transport user (author).</param>
 	/// <param name="referenceMember">The reference transport member.</param>
 	internal async Task OnMessageUpdateEventAsync(DiscordMessage message, TransportUser author, TransportMember member, TransportUser referenceAuthor, TransportMember referenceMember)
 	{
 		DiscordGuild guild;
 
 		message.Discord = this;
 		var eventMessage = message;
 
 		DiscordMessage oldmsg = null;
 		if (this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
 			|| !this.MessageCache.TryGet(xm => xm.Id == eventMessage.Id && xm.ChannelId == eventMessage.ChannelId, out message))
 		{
 			message = eventMessage;
 			this.PopulateMessageReactionsAndCache(message, author, member);
 			guild = message.Channel?.Guild;
 
 			if (message.ReferencedMessage != null)
 			{
 				message.ReferencedMessage.Discord = this;
 				this.PopulateMessageReactionsAndCache(message.ReferencedMessage, referenceAuthor, referenceMember);
 				message.ReferencedMessage.PopulateMentions();
 			}
 		}
 		else
 		{
 			oldmsg = new DiscordMessage(message);
 
 			guild = message.Channel?.Guild;
 			message.EditedTimestampRaw = eventMessage.EditedTimestampRaw;
 			if (eventMessage.Content != null)
 				message.Content = eventMessage.Content;
 			message.EmbedsInternal.Clear();
 			message.EmbedsInternal.AddRange(eventMessage.EmbedsInternal);
 			message.Pinned = eventMessage.Pinned;
 			message.IsTts = eventMessage.IsTts;
 		}
 
 		message.PopulateMentions();
 
 		var ea = new MessageUpdateEventArgs(this.ServiceProvider)
 		{
 			Message = message,
 			MessageBefore = oldmsg,
 			MentionedUsers = new ReadOnlyCollection<DiscordUser>(message.MentionedUsersInternal),
 			MentionedRoles = message.MentionedRolesInternal != null ? new ReadOnlyCollection<DiscordRole>(message.MentionedRolesInternal) : null,
 			MentionedChannels = message.MentionedChannelsInternal != null ? new ReadOnlyCollection<DiscordChannel>(message.MentionedChannelsInternal) : null
 		};
 		await this._messageUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message delete event.
 	/// </summary>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	internal async Task OnMessageDeleteEventAsync(ulong messageId, ulong channelId, ulong? guildId)
 	{
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		if (channel == null
 			|| this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
 			|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 
 				Id = messageId,
 				ChannelId = channelId,
 				Discord = this,
 			};
 		}
 
 		if (this.Configuration.MessageCacheSize > 0)
 			this.MessageCache?.Remove(xm => xm.Id == msg.Id && xm.ChannelId == channelId);
 
 		var ea = new MessageDeleteEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Message = msg,
 			Guild = guild
 		};
 		await this._messageDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message bulk delete event.
 	/// </summary>
 	/// <param name="messageIds">The message ids.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	internal async Task OnMessageBulkDeleteEventAsync(ulong[] messageIds, ulong channelId, ulong? guildId)
 	{
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 		var msgs = new List<DiscordMessage>(messageIds.Length);
 		foreach (var messageId in messageIds)
 		{
 			if (channel == null
 				|| this.Configuration.MessageCacheSize == 0
 				|| this.MessageCache == null
 				|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 			{
 				msg = new DiscordMessage
 				{
 					Id = messageId,
 					ChannelId = channelId,
 					Discord = this,
 				};
 			}
 			if (this.Configuration.MessageCacheSize > 0)
 				this.MessageCache?.Remove(xm => xm.Id == msg.Id && xm.ChannelId == channelId);
 			msgs.Add(msg);
 		}
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		var ea = new MessageBulkDeleteEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Messages = new ReadOnlyCollection<DiscordMessage>(msgs),
 			Guild = guild
 		};
 		await this._messagesBulkDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Message Reaction
 
 	/// <summary>
 	/// Handles the message reaction add event.
 	/// </summary>
 	/// <param name="userId">The user id.</param>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	/// <param name="mbr">The transport member.</param>
 	/// <param name="emoji">The emoji.</param>
 	internal async Task OnMessageReactionAddAsync(ulong userId, ulong messageId, ulong channelId, ulong? guildId, TransportMember mbr, DiscordEmoji emoji)
 	{
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 		var guild = this.InternalGetCachedGuild(guildId);
 		emoji.Discord = this;
 
 		var usr = this.UpdateUser(new DiscordUser { Id = userId, Discord = this }, guildId, guild, mbr);
 
 		if (channel == null
 			|| this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
 			|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 				Id = messageId,
 				ChannelId = channelId,
 				Discord = this,
 				ReactionsInternal = new List<DiscordReaction>()
 			};
 		}
 
 		var react = msg.ReactionsInternal.FirstOrDefault(xr => xr.Emoji == emoji);
 		if (react == null)
 		{
 			msg.ReactionsInternal.Add(react = new DiscordReaction
 			{
 				Count = 1,
 				Emoji = emoji,
 				IsMe = this.CurrentUser.Id == userId
 			});
 		}
 		else
 		{
 			react.Count++;
 			react.IsMe |= this.CurrentUser.Id == userId;
 		}
 
 		var ea = new MessageReactionAddEventArgs(this.ServiceProvider)
 		{
 			Message = msg,
 			User = usr,
 			Guild = guild,
 			Emoji = emoji
 		};
 		await this._messageReactionAdded.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message reaction remove event.
 	/// </summary>
 	/// <param name="userId">The user id.</param>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="emoji">The emoji.</param>
 	internal async Task OnMessageReactionRemoveAsync(ulong userId, ulong messageId, ulong channelId, ulong? guildId, DiscordEmoji emoji)
 	{
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 		emoji.Discord = this;
 
 		if (!this.UserCache.TryGetValue(userId, out var usr))
 			usr = new DiscordUser { Id = userId, Discord = this };
 
 		if (channel?.Guild != null)
 			usr = channel.Guild.Members.TryGetValue(userId, out var member)
 				? member
 				: new DiscordMember(usr) { Discord = this, GuildId = channel.GuildId.Value };
 
 		if (channel == null
 			|| this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
 			|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 				Id = messageId,
 				ChannelId = channelId,
 				Discord = this
 			};
 		}
 
 		var react = msg.ReactionsInternal?.FirstOrDefault(xr => xr.Emoji == emoji);
 		if (react != null)
 		{
 			react.Count--;
 			react.IsMe &= this.CurrentUser.Id != userId;
 
 			if (msg.ReactionsInternal != null && react.Count <= 0) // shit happens
 				msg.ReactionsInternal.RemoveFirst(x => x.Emoji == emoji);
 		}
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		var ea = new MessageReactionRemoveEventArgs(this.ServiceProvider)
 		{
 			Message = msg,
 			User = usr,
 			Guild = guild,
 			Emoji = emoji
 		};
 		await this._messageReactionRemoved.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message reaction remove event.
 	/// Fired when all message reactions were removed.
 	/// </summary>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	internal async Task OnMessageReactionRemoveAllAsync(ulong messageId, ulong channelId, ulong? guildId)
 	{
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 		if (channel == null
 			|| this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
 			|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 				Id = messageId,
 				ChannelId = channelId,
 				Discord = this
 			};
 		}
 
 		msg.ReactionsInternal?.Clear();
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		var ea = new MessageReactionsClearEventArgs(this.ServiceProvider)
 		{
 			Message = msg
 		};
 
 		await this._messageReactionsCleared.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the message reaction remove event.
 	/// Fired when a emoji got removed.
 	/// </summary>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="dat">The raw discord emoji.</param>
 	internal async Task OnMessageReactionRemoveEmojiAsync(ulong messageId, ulong channelId, ulong guildId, JToken dat)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 		var channel = this.InternalGetCachedChannel(channelId) ?? this.InternalGetCachedThread(channelId);
 
 		if (channel == null
 			|| this.Configuration.MessageCacheSize == 0
 			|| this.MessageCache == null
 			|| !this.MessageCache.TryGet(xm => xm.Id == messageId && xm.ChannelId == channelId, out var msg))
 		{
 			msg = new DiscordMessage
 			{
 				Id = messageId,
 				ChannelId = channelId,
 				Discord = this
 			};
 		}
 
 		var partialEmoji = dat.ToObject<DiscordEmoji>();
 
 		if (!guild.EmojisInternal.TryGetValue(partialEmoji.Id, out var emoji))
 		{
 			emoji = partialEmoji;
 			emoji.Discord = this;
 		}
 
 		msg.ReactionsInternal?.RemoveAll(r => r.Emoji.Equals(emoji));
 
 		var ea = new MessageReactionRemoveEmojiEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Guild = guild,
 			Message = msg,
 			Emoji = emoji
 		};
 
 		await this._messageReactionRemovedEmoji.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Stage Instance
 
 	/// <summary>
 	/// Handles the stage instance create event.
 	/// </summary>
 	/// <param name="stage">The created stage instance.</param>
 	internal async Task OnStageInstanceCreateEventAsync(DiscordStageInstance stage)
 	{
 		stage.Discord = this;
 
 		var guild = this.InternalGetCachedGuild(stage.GuildId);
 		guild.StageInstancesInternal[stage.Id] = stage;
 
 		await this._stageInstanceCreated.InvokeAsync(this, new StageInstanceCreateEventArgs(this.ServiceProvider) { StageInstance = stage, Guild = stage.Guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the stage instance update event.
 	/// </summary>
 	/// <param name="stage">The updated stage instance.</param>
 	internal async Task OnStageInstanceUpdateEventAsync(DiscordStageInstance stage)
 	{
 		stage.Discord = this;
 		var guild = this.InternalGetCachedGuild(stage.GuildId);
 		guild.StageInstancesInternal[stage.Id] = stage;
 
 		await this._stageInstanceUpdated.InvokeAsync(this, new StageInstanceUpdateEventArgs(this.ServiceProvider) { StageInstance = stage, Guild = stage.Guild }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the stage instance delete event.
 	/// </summary>
 	/// <param name="stage">The deleted stage instance.</param>
 	internal async Task OnStageInstanceDeleteEventAsync(DiscordStageInstance stage)
 	{
 		stage.Discord = this;
 		var guild = this.InternalGetCachedGuild(stage.GuildId);
 		guild.StageInstancesInternal[stage.Id] = stage;
 
 		await this._stageInstanceDeleted.InvokeAsync(this, new StageInstanceDeleteEventArgs(this.ServiceProvider) { StageInstance = stage, Guild = stage.Guild }).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Thread
 
 	/// <summary>
 	/// Handles the thread create event.
 	/// </summary>
 	/// <param name="thread">The created thread.</param>
 	internal async Task OnThreadCreateEventAsync(DiscordThreadChannel thread)
 	{
 		thread.Discord = this;
 		this.InternalGetCachedGuild(thread.GuildId).ThreadsInternal.AddOrUpdate(thread.Id, thread, (oldThread, newThread) => newThread);
 
 		await this._threadCreated.InvokeAsync(this, new ThreadCreateEventArgs(this.ServiceProvider) { Thread = thread, Guild = thread.Guild, Parent = thread.Parent }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the thread update event.
 	/// </summary>
 	/// <param name="thread">The updated thread.</param>
 	internal async Task OnThreadUpdateEventAsync(DiscordThreadChannel thread)
 	{
 		if (thread == null)
 			return;
 
 		thread.Discord = this;
 		var guild = thread.Guild;
 
 		var threadNew = this.InternalGetCachedThread(thread.Id);
 		DiscordThreadChannel threadOld = null;
 		ThreadUpdateEventArgs updateEvent;
 
 		if (threadNew != null)
 		{
 			threadOld = new DiscordThreadChannel
 			{
 				Discord = this,
 				Type = threadNew.Type,
 				ThreadMetadata = thread.ThreadMetadata,
 				ThreadMembersInternal = threadNew.ThreadMembersInternal,
 				ParentId = thread.ParentId,
 				OwnerId = thread.OwnerId,
 				Name = thread.Name,
 				LastMessageId = threadNew.LastMessageId,
 				MessageCount = thread.MessageCount,
 				MemberCount = thread.MemberCount,
 				GuildId = thread.GuildId,
 				LastPinTimestampRaw = threadNew.LastPinTimestampRaw,
 				PerUserRateLimit = threadNew.PerUserRateLimit,
 				CurrentMember = threadNew.CurrentMember
 			};
 
 			threadNew.ThreadMetadata = thread.ThreadMetadata;
 			threadNew.ParentId = thread.ParentId;
 			threadNew.OwnerId = thread.OwnerId;
 			threadNew.Name = thread.Name;
 			threadNew.LastMessageId = thread.LastMessageId.HasValue ? thread.LastMessageId : threadOld.LastMessageId;
 			threadNew.MessageCount = thread.MessageCount;
 			threadNew.MemberCount = thread.MemberCount;
 			threadNew.GuildId = thread.GuildId;
 
 			updateEvent = new ThreadUpdateEventArgs(this.ServiceProvider)
 			{
 				ThreadAfter = thread,
 				ThreadBefore = threadOld,
 				Guild = thread.Guild,
 				Parent = thread.Parent
 			};
 		}
 		else
 		{
 			updateEvent = new ThreadUpdateEventArgs(this.ServiceProvider)
 			{
 				ThreadAfter = thread,
 				Guild = thread.Guild,
 				Parent = thread.Parent
 			};
 			guild.ThreadsInternal[thread.Id] = thread;
 		}
 
 		await this._threadUpdated.InvokeAsync(this, updateEvent).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the thread delete event.
 	/// </summary>
 	/// <param name="thread">The deleted thread.</param>
 	internal async Task OnThreadDeleteEventAsync(DiscordThreadChannel thread)
 	{
 		if (thread == null)
 			return;
 
 		thread.Discord = this;
 
 		var gld = thread.Guild;
 		if (gld.ThreadsInternal.TryRemove(thread.Id, out var cachedThread))
 			thread = cachedThread;
 
 		await this._threadDeleted.InvokeAsync(this, new ThreadDeleteEventArgs(this.ServiceProvider) { Thread = thread, Guild = thread.Guild, Parent = thread.Parent, Type = thread.Type }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the thread list sync event.
 	/// </summary>
 	/// <param name="guild">The synced guild.</param>
 	/// <param name="channelIds">The synced channel ids.</param>
 	/// <param name="threads">The synced threads.</param>
 	/// <param name="members">The synced thread members.</param>
 	internal async Task OnThreadListSyncEventAsync(DiscordGuild guild, IReadOnlyList<ulong?> channelIds, IReadOnlyList<DiscordThreadChannel> threads, IReadOnlyList<DiscordThreadChannelMember> members)
 	{
 		guild.Discord = this;
 
 		var channels = channelIds.Select(x => guild.GetChannel(x.Value)); //getting channel objects
 		foreach (var chan in channels)
 		{
 			chan.Discord = this;
 		}
 		_ = threads.Select(x => x.Discord = this);
 
 		await this._threadListSynced.InvokeAsync(this, new ThreadListSyncEventArgs(this.ServiceProvider) { Guild = guild, Channels = channels.ToList().AsReadOnly(), Threads = threads, Members = members.ToList().AsReadOnly() }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the thread member update event.
 	/// </summary>
 	/// <param name="member">The updated member.</param>
 	internal async Task OnThreadMemberUpdateEventAsync(DiscordThreadChannelMember member)
 	{
 		member.Discord = this;
 		var thread = this.InternalGetCachedThread(member.Id);
 		if (thread == null)
 		{
 			var tempThread = await this.ApiClient.GetThreadAsync(member.Id);
 			thread = this.GuildsInternal[member.GuildId].ThreadsInternal.AddOrUpdate(member.Id, tempThread, (old, newThread) => newThread);
 		}
 
 		thread.CurrentMember = member;
 		thread.Guild.ThreadsInternal.AddOrUpdate(member.Id, thread, (oldThread, newThread) => newThread);
 
 
 		await this._threadMemberUpdated.InvokeAsync(this, new ThreadMemberUpdateEventArgs(this.ServiceProvider) { ThreadMember = member, Thread = thread }).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the thread members update event.
 	/// </summary>
 	/// <param name="guild">The target guild.</param>
 	/// <param name="threadId">The thread id of the target thread this update belongs to.</param>
 	/// <param name="membersAdded">The added members.</param>
 	/// <param name="membersRemoved">The ids of the removed members.</param>
 	/// <param name="memberCount">The new member count.</param>
 	internal async Task OnThreadMembersUpdateEventAsync(DiscordGuild guild, ulong threadId, JArray membersAdded, JArray membersRemoved, int memberCount)
 	{
 		var thread = this.InternalGetCachedThread(threadId);
 		if (thread == null)
 		{
 			var tempThread = await this.ApiClient.GetThreadAsync(threadId);
 			thread = guild.ThreadsInternal.AddOrUpdate(threadId, tempThread, (old, newThread) => newThread);
 		}
 
 		thread.Discord = this;
 		guild.Discord = this;
 		List<DiscordThreadChannelMember> addedMembers = new();
 		List<ulong> removedMemberIds = new();
 
 		if (membersAdded != null)
 		{
 			foreach (var xj in membersAdded)
 			{
 				var xtm = xj.ToDiscordObject<DiscordThreadChannelMember>();
 				xtm.Discord = this;
 				xtm.GuildId = guild.Id;
 				if (xtm != null)
 					addedMembers.Add(xtm);
 
 				if (xtm.Id == this.CurrentUser.Id)
 					thread.CurrentMember = xtm;
 			}
 		}
 
 		var removedMembers = new List<DiscordMember>();
 		if (membersRemoved != null)
 		{
 			foreach (var removedId in membersRemoved)
 			{
 				removedMembers.Add(guild.MembersInternal.TryGetValue((ulong)removedId, out var member) ? member : new DiscordMember { Id = (ulong)removedId, GuildId = guild.Id, Discord = this });
 			}
 		}
 
 		if (removedMemberIds.Contains(this.CurrentUser.Id)) //indicates the bot was removed from the thread
 			thread.CurrentMember = null;
 
 		thread.MemberCount = memberCount;
 
 		var threadMembersUpdateArg = new ThreadMembersUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Thread = thread,
 			AddedMembers = addedMembers,
 			RemovedMembers = removedMembers,
 			MemberCount = memberCount
 		};
 
 		await this._threadMembersUpdated.InvokeAsync(this, threadMembersUpdateArg).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Activities
 	/// <summary>
 	/// Dispatches the <see cref="EmbeddedActivityUpdated"/> event.
 	/// </summary>
 	/// <param name="trActivity">The transport activity.</param>
 	/// <param name="guild">The guild.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="jUsers">The users in the activity.</param>
 	/// <param name="appId">The application id.</param>
 	internal async Task OnEmbeddedActivityUpdateAsync(JObject trActivity, DiscordGuild guild, ulong channelId, JArray jUsers, ulong appId)
 		=> await Task.Delay(20);
 
 	/*{
             try
             {
                 var users = j_users?.ToObject<List<ulong>>();
 
                 DiscordActivity old = null;
                 var uid = $"{guild.Id}_{channel_id}_{app_id}";
 
                 if (this._embeddedActivities.TryGetValue(uid, out var activity))
                 {
                     old = new DiscordActivity(activity);
                     DiscordJson.PopulateObject(tr_activity, activity);
                 }
                 else
                 {
                     activity = tr_activity.ToObject<DiscordActivity>();
                     this._embeddedActivities[uid] = activity;
                 }
 
                 var activity_users = new List<DiscordMember>();
 
                 var channel = this.InternalGetCachedChannel(channel_id) ?? await this.ApiClient.GetChannelAsync(channel_id);
 
                 if (users != null)
                 {
                     foreach (var user in users)
                     {
                         var activity_user = guild._members.TryGetValue(user, out var member) ? member : new DiscordMember { Id = user, _guild_id = guild.Id, Discord = this };
                         activity_users.Add(activity_user);
                     }
                 }
                 else
                     activity_users = null;
 
                 var ea = new EmbeddedActivityUpdateEventArgs(this.ServiceProvider)
                 {
                     Guild = guild,
                     Users = activity_users,
                     Channel = channel
 
                 };
                 await this._embeddedActivityUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
             } catch (Exception ex)
             {
                 this.Logger.LogError(ex, ex.Message);
             }
         }*/
 
 	#endregion
 
 	#region User/Presence Update
 
 	/// <summary>
 	/// Handles the presence update event.
 	/// </summary>
 	/// <param name="rawPresence">The raw presence.</param>
 	/// <param name="rawUser">The raw user.</param>
 
 	internal async Task OnPresenceUpdateEventAsync(JObject rawPresence, JObject rawUser)
 	{
 		var uid = (ulong)rawUser["id"];
 		DiscordPresence old = null;
 
 		if (this.PresencesInternal.TryGetValue(uid, out var presence))
 		{
 			old = new DiscordPresence(presence);
 			DiscordJson.PopulateObject(rawPresence, presence);
 		}
 		else
 		{
 			presence = rawPresence.ToObject<DiscordPresence>();
 			presence.Discord = this;
 			presence.Activity = new DiscordActivity(presence.RawActivity);
 			this.PresencesInternal[presence.InternalUser.Id] = presence;
 		}
 
 		// reuse arrays / avoid linq (this is a hot zone)
 		if (presence.Activities == null || rawPresence["activities"] == null)
 		{
 			presence.InternalActivities = Array.Empty<DiscordActivity>();
 		}
 		else
 		{
 			if (presence.InternalActivities.Length != presence.RawActivities.Length)
 				presence.InternalActivities = new DiscordActivity[presence.RawActivities.Length];
 
 			for (var i = 0; i < presence.InternalActivities.Length; i++)
 				presence.InternalActivities[i] = new DiscordActivity(presence.RawActivities[i]);
 
 			if (presence.InternalActivities.Length > 0)
 			{
 				presence.RawActivity = presence.RawActivities[0];
 
 				if (presence.Activity != null)
 					presence.Activity.UpdateWith(presence.RawActivity);
 				else
 					presence.Activity = new DiscordActivity(presence.RawActivity);
 			}
 		}
 
 		if (this.UserCache.TryGetValue(uid, out var usr))
 		{
 			if (old != null)
 			{
 				old.InternalUser.Username = usr.Username;
 				old.InternalUser.Discriminator = usr.Discriminator;
 				old.InternalUser.AvatarHash = usr.AvatarHash;
 			}
 
 			if (rawUser["username"] is object)
 				usr.Username = (string)rawUser["username"];
 			if (rawUser["discriminator"] is object)
 				usr.Discriminator = (string)rawUser["discriminator"];
 			if (rawUser["avatar"] is object)
 				usr.AvatarHash = (string)rawUser["avatar"];
 
 			presence.InternalUser.Username = usr.Username;
 			presence.InternalUser.Discriminator = usr.Discriminator;
 			presence.InternalUser.AvatarHash = usr.AvatarHash;
 		}
 
 		var usrafter = usr ?? new DiscordUser(presence.InternalUser);
 		var ea = new PresenceUpdateEventArgs(this.ServiceProvider)
 		{
 			Status = presence.Status,
 			Activity = presence.Activity,
 			User = usr,
 			PresenceBefore = old,
 			PresenceAfter = presence,
 			UserBefore = old != null ? new DiscordUser(old.InternalUser) : usrafter,
 			UserAfter = usrafter
 		};
 		await this._presenceUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the user settings update event.
 	/// </summary>
 	/// <param name="user">The transport user.</param>
 
 	internal async Task OnUserSettingsUpdateEventAsync(TransportUser user)
 	{
 		var usr = new DiscordUser(user) { Discord = this };
 
 		var ea = new UserSettingsUpdateEventArgs(this.ServiceProvider)
 		{
 			User = usr
 		};
 		await this._userSettingsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the user update event.
 	/// </summary>
 	/// <param name="user">The transport user.</param>
 
 	internal async Task OnUserUpdateEventAsync(TransportUser user)
 	{
 		var usrOld = new DiscordUser
 		{
 			AvatarHash = this.CurrentUser.AvatarHash,
 			Discord = this,
 			Discriminator = this.CurrentUser.Discriminator,
 			Email = this.CurrentUser.Email,
 			Id = this.CurrentUser.Id,
 			IsBot = this.CurrentUser.IsBot,
 			MfaEnabled = this.CurrentUser.MfaEnabled,
 			Username = this.CurrentUser.Username,
 			Verified = this.CurrentUser.Verified
 		};
 
 		this.CurrentUser.AvatarHash = user.AvatarHash;
 		this.CurrentUser.Discriminator = user.Discriminator;
 		this.CurrentUser.Email = user.Email;
 		this.CurrentUser.Id = user.Id;
 		this.CurrentUser.IsBot = user.IsBot;
 		this.CurrentUser.MfaEnabled = user.MfaEnabled;
 		this.CurrentUser.Username = user.Username;
 		this.CurrentUser.Verified = user.Verified;
 
 		var ea = new UserUpdateEventArgs(this.ServiceProvider)
 		{
 			UserAfter = this.CurrentUser,
 			UserBefore = usrOld
 		};
 		await this._userUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Voice
 
 	/// <summary>
 	/// Handles the voice state update event.
 	/// </summary>
 	/// <param name="raw">The raw voice state update object.</param>
 
 	internal async Task OnVoiceStateUpdateEventAsync(JObject raw)
 	{
 		var gid = (ulong)raw["guild_id"];
 		var uid = (ulong)raw["user_id"];
 		var gld = this.GuildsInternal[gid];
 
 		var vstateNew = raw.ToObject<DiscordVoiceState>();
 		vstateNew.Discord = this;
 
 		gld.VoiceStatesInternal.TryRemove(uid, out var vstateOld);
 
 		if (vstateNew.Channel != null)
 		{
 			gld.VoiceStatesInternal[vstateNew.UserId] = vstateNew;
 		}
 
 		if (gld.MembersInternal.TryGetValue(uid, out var mbr))
 		{
 			mbr.IsMuted = vstateNew.IsServerMuted;
 			mbr.IsDeafened = vstateNew.IsServerDeafened;
 		}
 		else
 		{
 			var transportMbr = vstateNew.TransportMember;
 			this.UpdateUser(new DiscordUser(transportMbr.User) { Discord = this }, gid, gld, transportMbr);
 		}
 
 		var ea = new VoiceStateUpdateEventArgs(this.ServiceProvider)
 		{
 			Guild = vstateNew.Guild,
 			Channel = vstateNew.Channel,
 			User = vstateNew.User,
 			SessionId = vstateNew.SessionId,
 
 			Before = vstateOld,
 			After = vstateNew
 		};
 		await this._voiceStateUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the voice server update event.
 	/// </summary>
 	/// <param name="endpoint">The new endpoint.</param>
 	/// <param name="token">The new token.</param>
 	/// <param name="guild">The guild.</param>
 
 	internal async Task OnVoiceServerUpdateEventAsync(string endpoint, string token, DiscordGuild guild)
 	{
 		var ea = new VoiceServerUpdateEventArgs(this.ServiceProvider)
 		{
 			Endpoint = endpoint,
 			VoiceToken = token,
 			Guild = guild
 		};
 		await this._voiceServerUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Commands
 
 	/// <summary>
 	/// Handles the application command create event.
 	/// </summary>
 	/// <param name="cmd">The application command.</param>
 	/// <param name="guildId">The optional guild id.</param>
 
 	internal async Task OnApplicationCommandCreateAsync(DiscordApplicationCommand cmd, ulong? guildId)
 	{
 		cmd.Discord = this;
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		if (guild == null && guildId.HasValue)
 		{
 			guild = new DiscordGuild
 			{
 				Id = guildId.Value,
 				Discord = this
 			};
 		}
 
 		var ea = new ApplicationCommandEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Command = cmd
 		};
 
 		await this._applicationCommandCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the application command update event.
 	/// </summary>
 	/// <param name="cmd">The application command.</param>
 	/// <param name="guildId">The optional guild id.</param>
 
 	internal async Task OnApplicationCommandUpdateAsync(DiscordApplicationCommand cmd, ulong? guildId)
 	{
 		cmd.Discord = this;
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		if (guild == null && guildId.HasValue)
 		{
 			guild = new DiscordGuild
 			{
 				Id = guildId.Value,
 				Discord = this
 			};
 		}
 
 		var ea = new ApplicationCommandEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Command = cmd
 		};
 
 		await this._applicationCommandUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the application command delete event.
 	/// </summary>
 	/// <param name="cmd">The application command.</param>
 	/// <param name="guildId">The optional guild id.</param>
 
 	internal async Task OnApplicationCommandDeleteAsync(DiscordApplicationCommand cmd, ulong? guildId)
 	{
 		cmd.Discord = this;
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		if (guild == null && guildId.HasValue)
 		{
 			guild = new DiscordGuild
 			{
 				Id = guildId.Value,
 				Discord = this
 			};
 		}
 
 		var ea = new ApplicationCommandEventArgs(this.ServiceProvider)
 		{
 			Guild = guild,
 			Command = cmd
 		};
 
 		await this._applicationCommandDeleted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the guild application command counts update event.
 	/// </summary>
 	/// <param name="chatInputCommandCount">The <see cref="ApplicationCommandType.ChatInput"/> count.</param>
 	/// <param name="userContextMenuCommandCount">The <see cref="ApplicationCommandType.User"/> count.</param>
 	/// <param name="messageContextMenuCount">The <see cref="ApplicationCommandType.Message"/> count.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <returns>Count of application commands.</returns>
 	internal async Task OnGuildApplicationCommandCountsUpdateAsync(int chatInputCommandCount, int userContextMenuCommandCount, int messageContextMenuCount, ulong guildId)
 	{
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		if (guild == null)
 		{
 			guild = new DiscordGuild
 			{
 				Id = guildId,
 				Discord = this
 			};
 		}
 
 		var ea = new GuildApplicationCommandCountEventArgs(this.ServiceProvider)
 		{
 			SlashCommands = chatInputCommandCount,
 			UserContextMenuCommands = userContextMenuCommandCount,
 			MessageContextMenuCommands = messageContextMenuCount,
 			Guild = guild
 		};
 
 		await this._guildApplicationCommandCountUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the application command permissions update event.
 	/// </summary>
 	/// <param name="perms">The new permissions.</param>
 	/// <param name="channelId">The command id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="applicationId">The application id.</param>
 	internal async Task OnApplicationCommandPermissionsUpdateAsync(IEnumerable<DiscordApplicationCommandPermission> perms, ulong channelId, ulong guildId, ulong applicationId)
 	{
 		if (applicationId != this.CurrentApplication.Id)
 			return;
 
 		var guild = this.InternalGetCachedGuild(guildId);
 
 		DiscordApplicationCommand cmd;
 		try
 		{
 			cmd = await this.GetGuildApplicationCommandAsync(guildId, channelId);
 		}
 		catch (NotFoundException)
 		{
 			cmd = await this.GetGlobalApplicationCommandAsync(channelId);
 		}
 
 		if (guild == null)
 		{
 			guild = new DiscordGuild
 			{
 				Id = guildId,
 				Discord = this
 			};
 		}
 
 		var ea = new ApplicationCommandPermissionsUpdateEventArgs(this.ServiceProvider)
 		{
 			Permissions = perms.ToList(),
 			Command = cmd,
 			ApplicationId = applicationId,
 			Guild = guild
 		};
 
 		await this._applicationCommandPermissionsUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Interaction
 
 	/// <summary>
 	/// Handles the interaction create event.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="user">The transport user.</param>
 	/// <param name="member">The transport member.</param>
 	/// <param name="interaction">The interaction.</param>
 	internal async Task OnInteractionCreateAsync(ulong? guildId, ulong channelId, TransportUser user, TransportMember member, DiscordInteraction interaction)
 	{
 		var usr = new DiscordUser(user) { Discord = this };
 
 		interaction.ChannelId = channelId;
 		interaction.GuildId = guildId;
 		interaction.Discord = this;
 		interaction.Data.Discord = this;
 
 		if (member != null)
 		{
 			usr = new DiscordMember(member) { GuildId = guildId.Value, Discord = this };
 			this.UpdateUser(usr, guildId, interaction.Guild, member);
 		}
 		else
 		{
 			this.UserCache.AddOrUpdate(usr.Id, usr, (old, @new) => @new);
 		}
 
 		interaction.User = usr;
 
 		var resolved = interaction.Data.Resolved;
 		if (resolved != null)
 		{
 			if (resolved.Users != null)
 			{
 				foreach (var c in resolved.Users)
 				{
 					c.Value.Discord = this;
 					this.UserCache.AddOrUpdate(c.Value.Id, c.Value, (old, @new) => @new);
 				}
 			}
 
 			if (resolved.Members != null)
 			{
 				foreach (var c in resolved.Members)
 				{
 					c.Value.Discord = this;
 					c.Value.Id = c.Key;
 					c.Value.GuildId = guildId.Value;
 					c.Value.User.Discord = this;
 					this.UserCache.AddOrUpdate(c.Value.User.Id, c.Value.User, (old, @new) => @new);
 				}
 			}
 
 			if (resolved.Channels != null)
 			{
 				foreach (var c in resolved.Channels)
 				{
 					c.Value.Discord = this;
 
 					if (guildId.HasValue)
 						c.Value.GuildId = guildId.Value;
 				}
 			}
 
 			if (resolved.Roles != null)
 			{
 				foreach (var c in resolved.Roles)
 				{
 					c.Value.Discord = this;
 
 					if (guildId.HasValue)
 						c.Value.GuildId = guildId.Value;
 				}
 			}
 
 
 			if (resolved.Messages != null)
 			{
 				foreach (var m in resolved.Messages)
 				{
 					m.Value.Discord = this;
 
 					if (guildId.HasValue)
 						m.Value.GuildId = guildId.Value;
 				}
 			}
 
 
 			if (resolved.Attachments != null)
 				foreach (var a in resolved.Attachments)
 					a.Value.Discord = this;
 		}
 
 		if (interaction.Type is InteractionType.Component || interaction.Type is InteractionType.ModalSubmit)
 		{
 			if (interaction.Message != null)
 			{
 				interaction.Message.Discord = this;
 				interaction.Message.ChannelId = interaction.ChannelId;
 			}
 			var cea = new ComponentInteractionCreateEventArgs(this.ServiceProvider)
 			{
 				Message = interaction.Message,
 				Interaction = interaction
 			};
 
 			await this._componentInteractionCreated.InvokeAsync(this, cea).ConfigureAwait(false);
 		}
 		else
 		{
 			if (interaction.Data.Target.HasValue) // Context-Menu. //
 			{
 				var targetId = interaction.Data.Target.Value;
 				DiscordUser targetUser = null;
 				DiscordMember targetMember = null;
 				DiscordMessage targetMessage = null;
 
 				interaction.Data.Resolved.Messages?.TryGetValue(targetId, out targetMessage);
 				interaction.Data.Resolved.Members?.TryGetValue(targetId, out targetMember);
 				interaction.Data.Resolved.Users?.TryGetValue(targetId, out targetUser);
 
 				var ctea = new ContextMenuInteractionCreateEventArgs(this.ServiceProvider)
 				{
 					Interaction = interaction,
 					TargetUser = targetMember ?? targetUser,
 					TargetMessage = targetMessage,
 					Type = interaction.Data.Type,
 				};
 				await this._contextMenuInteractionCreated.InvokeAsync(this, ctea).ConfigureAwait(false);
 			}
 			else
 			{
 				var ea = new InteractionCreateEventArgs(this.ServiceProvider)
 				{
 					Interaction = interaction
 				};
 
 				await this._interactionCreated.InvokeAsync(this, ea).ConfigureAwait(false);
 			}
 		}
 	}
 
 	#endregion
 
 	#region Misc
 
 	/// <summary>
 	/// Handles the typing start event.
 	/// </summary>
 	/// <param name="userId">The user id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="channel">The channel.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	/// <param name="started">The time when the user started typing.</param>
 	/// <param name="mbr">The transport member.</param>
 	internal async Task OnTypingStartEventAsync(ulong userId, ulong channelId, DiscordChannel channel, ulong? guildId, DateTimeOffset started, TransportMember mbr)
 	{
 		if (channel == null)
 		{
 			channel = new DiscordChannel
 			{
 				Discord = this,
 				Id = channelId,
 				GuildId = guildId ?? default,
 			};
 		}
 
 		var guild = this.InternalGetCachedGuild(guildId);
 		var usr = this.UpdateUser(new DiscordUser { Id = userId, Discord = this }, guildId, guild, mbr);
 
 		var ea = new TypingStartEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			User = usr,
 			Guild = guild,
 			StartedAt = started
 		};
 		await this._typingStarted.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the webhooks update.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	/// <param name="guild">The guild.</param>
 	internal async Task OnWebhooksUpdateAsync(DiscordChannel channel, DiscordGuild guild)
 	{
 		var ea = new WebhooksUpdateEventArgs(this.ServiceProvider)
 		{
 			Channel = channel,
 			Guild = guild
 		};
 		await this._webhooksUpdated.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles all unknown events.
 	/// </summary>
 	/// <param name="payload">The payload.</param>
 	internal async Task OnUnknownEventAsync(GatewayPayload payload)
 	{
 		var ea = new UnknownEventArgs(this.ServiceProvider) { EventName = payload.EventName, Json = (payload.Data as JObject)?.ToString() };
 		await this._unknownEvent.InvokeAsync(this, ea).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#endregion
 }
diff --git a/DisCatSharp/Clients/DiscordClient.cs b/DisCatSharp/Clients/DiscordClient.cs
index 2cf5d5994..3121ce9da 100644
--- a/DisCatSharp/Clients/DiscordClient.cs
+++ b/DisCatSharp/Clients/DiscordClient.cs
@@ -1,1296 +1,1303 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// A Discord API wrapper.
 /// </summary>
 public sealed partial class DiscordClient : BaseDiscordClient
 {
 	#region Internal Fields/Properties
 
 	internal bool IsShard = false;
 	/// <summary>
 	/// Gets the message cache.
 	/// </summary>
 	internal RingBuffer<DiscordMessage> MessageCache { get; }
 
 	private List<BaseExtension> _extensions = new();
 	private StatusUpdate _status;
 
 	/// <summary>
 	/// Gets the connection lock.
 	/// </summary>
 	private readonly ManualResetEventSlim _connectionLock = new(true);
 
 	#endregion
 
 	#region Public Fields/Properties
 	/// <summary>
 	/// Gets the gateway protocol version.
 	/// </summary>
 	public int GatewayVersion { get; internal set; }
 
 	/// <summary>
 	/// Gets the gateway session information for this client.
 	/// </summary>
 	public GatewayInfo GatewayInfo { get; internal set; }
 
 	/// <summary>
 	/// Gets the gateway URL.
 	/// </summary>
 	public Uri GatewayUri { get; internal set; }
 
 	/// <summary>
 	/// Gets the total number of shards the bot is connected to.
 	/// </summary>
 	public int ShardCount => this.GatewayInfo != null
 		? this.GatewayInfo.ShardCount
 		: this.Configuration.ShardCount;
 
 	/// <summary>
 	/// Gets the currently connected shard ID.
 	/// </summary>
 	public int ShardId
 		=> this.Configuration.ShardId;
 
 	/// <summary>
 	/// Gets the intents configured for this client.
 	/// </summary>
 	public DiscordIntents Intents
 		=> this.Configuration.Intents;
 
 	/// <summary>
 	/// Gets a dictionary of guilds that this client is in. The dictionary's key is the guild ID. Note that the
 	/// guild objects in this dictionary will not be filled in if the specific guilds aren't available (the
 	/// <see cref="GuildAvailable"/> or <see cref="GuildDownloadCompleted"/> events haven't been fired yet)
 	/// </summary>
 	public override IReadOnlyDictionary<ulong, DiscordGuild> Guilds { get; }
 	internal ConcurrentDictionary<ulong, DiscordGuild> GuildsInternal = new();
 
 	/// <summary>
 	/// Gets the websocket latency for this client.
 	/// </summary>
 	public int Ping
 		=> Volatile.Read(ref this._ping);
 
 	private int _ping;
 
 	/// <summary>
 	/// Gets the collection of presences held by this client.
 	/// </summary>
 	public IReadOnlyDictionary<ulong, DiscordPresence> Presences
 		=> this._presencesLazy.Value;
 
 	internal Dictionary<ulong, DiscordPresence> PresencesInternal = new();
 	private Lazy<IReadOnlyDictionary<ulong, DiscordPresence>> _presencesLazy;
 
 	/// <summary>
 	/// Gets the collection of presences held by this client.
 	/// </summary>
 	public IReadOnlyDictionary<string, DiscordActivity> EmbeddedActivities
 		=> this._embeddedActivitiesLazy.Value;
 
 	internal Dictionary<string, DiscordActivity> EmbeddedActivitiesInternal = new();
 	private Lazy<IReadOnlyDictionary<string, DiscordActivity>> _embeddedActivitiesLazy;
 	#endregion
 
 	#region Constructor/Internal Setup
 
 	/// <summary>
 	/// Initializes a new instance of <see cref="DiscordClient"/>.
 	/// </summary>
 	/// <param name="config">Specifies configuration parameters.</param>
 	public DiscordClient(DiscordConfiguration config)
 		: base(config)
 	{
 		if (this.Configuration.MessageCacheSize > 0)
 		{
 			var intents = this.Configuration.Intents;
 			this.MessageCache = intents.HasIntent(DiscordIntents.GuildMessages) || intents.HasIntent(DiscordIntents.DirectMessages)
 					? new RingBuffer<DiscordMessage>(this.Configuration.MessageCacheSize)
 					: null;
 		}
 
 		this.InternalSetup();
 
 		this.Guilds = new ReadOnlyConcurrentDictionary<ulong, DiscordGuild>(this.GuildsInternal);
 	}
 
 	/// <summary>
 	/// Internal setup of the Client.
 	/// </summary>
 	internal void InternalSetup()
 	{
 		this._clientErrored = new AsyncEvent<DiscordClient, ClientErrorEventArgs>("CLIENT_ERRORED", EventExecutionLimit, this.Goof);
 		this._socketErrored = new AsyncEvent<DiscordClient, SocketErrorEventArgs>("SOCKET_ERRORED", EventExecutionLimit, this.Goof);
 		this._socketOpened = new AsyncEvent<DiscordClient, SocketEventArgs>("SOCKET_OPENED", EventExecutionLimit, this.EventErrorHandler);
 		this._socketClosed = new AsyncEvent<DiscordClient, SocketCloseEventArgs>("SOCKET_CLOSED", EventExecutionLimit, this.EventErrorHandler);
 		this._ready = new AsyncEvent<DiscordClient, ReadyEventArgs>("READY", EventExecutionLimit, this.EventErrorHandler);
 		this._resumed = new AsyncEvent<DiscordClient, ReadyEventArgs>("RESUMED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelCreated = new AsyncEvent<DiscordClient, ChannelCreateEventArgs>("CHANNEL_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelUpdated = new AsyncEvent<DiscordClient, ChannelUpdateEventArgs>("CHANNEL_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelDeleted = new AsyncEvent<DiscordClient, ChannelDeleteEventArgs>("CHANNEL_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._dmChannelDeleted = new AsyncEvent<DiscordClient, DmChannelDeleteEventArgs>("DM_CHANNEL_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._channelPinsUpdated = new AsyncEvent<DiscordClient, ChannelPinsUpdateEventArgs>("CHANNEL_PINS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildCreated = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildAvailable = new AsyncEvent<DiscordClient, GuildCreateEventArgs>("GUILD_AVAILABLE", EventExecutionLimit, this.EventErrorHandler);
 		this._guildUpdated = new AsyncEvent<DiscordClient, GuildUpdateEventArgs>("GUILD_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildDeleted = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildUnavailable = new AsyncEvent<DiscordClient, GuildDeleteEventArgs>("GUILD_UNAVAILABLE", EventExecutionLimit, this.EventErrorHandler);
 		this._guildDownloadCompletedEv = new AsyncEvent<DiscordClient, GuildDownloadCompletedEventArgs>("GUILD_DOWNLOAD_COMPLETED", EventExecutionLimit, this.EventErrorHandler);
 		this._inviteCreated = new AsyncEvent<DiscordClient, InviteCreateEventArgs>("INVITE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._inviteDeleted = new AsyncEvent<DiscordClient, InviteDeleteEventArgs>("INVITE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageCreated = new AsyncEvent<DiscordClient, MessageCreateEventArgs>("MESSAGE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._presenceUpdated = new AsyncEvent<DiscordClient, PresenceUpdateEventArgs>("PRESENCE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildBanAdded = new AsyncEvent<DiscordClient, GuildBanAddEventArgs>("GUILD_BAN_ADD", EventExecutionLimit, this.EventErrorHandler);
 		this._guildBanRemoved = new AsyncEvent<DiscordClient, GuildBanRemoveEventArgs>("GUILD_BAN_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildEmojisUpdated = new AsyncEvent<DiscordClient, GuildEmojisUpdateEventArgs>("GUILD_EMOJI_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildStickersUpdated = new AsyncEvent<DiscordClient, GuildStickersUpdateEventArgs>("GUILD_STICKER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationsUpdated = new AsyncEvent<DiscordClient, GuildIntegrationsUpdateEventArgs>("GUILD_INTEGRATIONS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberAdded = new AsyncEvent<DiscordClient, GuildMemberAddEventArgs>("GUILD_MEMBER_ADD", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberRemoved = new AsyncEvent<DiscordClient, GuildMemberRemoveEventArgs>("GUILD_MEMBER_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberUpdated = new AsyncEvent<DiscordClient, GuildMemberUpdateEventArgs>("GUILD_MEMBER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleCreated = new AsyncEvent<DiscordClient, GuildRoleCreateEventArgs>("GUILD_ROLE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleUpdated = new AsyncEvent<DiscordClient, GuildRoleUpdateEventArgs>("GUILD_ROLE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildRoleDeleted = new AsyncEvent<DiscordClient, GuildRoleDeleteEventArgs>("GUILD_ROLE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageAcknowledged = new AsyncEvent<DiscordClient, MessageAcknowledgeEventArgs>("MESSAGE_ACKNOWLEDGED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageUpdated = new AsyncEvent<DiscordClient, MessageUpdateEventArgs>("MESSAGE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageDeleted = new AsyncEvent<DiscordClient, MessageDeleteEventArgs>("MESSAGE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._messagesBulkDeleted = new AsyncEvent<DiscordClient, MessageBulkDeleteEventArgs>("MESSAGE_BULK_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._interactionCreated = new AsyncEvent<DiscordClient, InteractionCreateEventArgs>("INTERACTION_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._componentInteractionCreated = new AsyncEvent<DiscordClient, ComponentInteractionCreateEventArgs>("COMPONENT_INTERACTED", EventExecutionLimit, this.EventErrorHandler);
 		this._contextMenuInteractionCreated = new AsyncEvent<DiscordClient, ContextMenuInteractionCreateEventArgs>("CONTEXT_MENU_INTERACTED", EventExecutionLimit, this.EventErrorHandler);
 		this._typingStarted = new AsyncEvent<DiscordClient, TypingStartEventArgs>("TYPING_STARTED", EventExecutionLimit, this.EventErrorHandler);
 		this._userSettingsUpdated = new AsyncEvent<DiscordClient, UserSettingsUpdateEventArgs>("USER_SETTINGS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._userUpdated = new AsyncEvent<DiscordClient, UserUpdateEventArgs>("USER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._voiceStateUpdated = new AsyncEvent<DiscordClient, VoiceStateUpdateEventArgs>("VOICE_STATE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._voiceServerUpdated = new AsyncEvent<DiscordClient, VoiceServerUpdateEventArgs>("VOICE_SERVER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMembersChunked = new AsyncEvent<DiscordClient, GuildMembersChunkEventArgs>("GUILD_MEMBERS_CHUNKED", EventExecutionLimit, this.EventErrorHandler);
 		this._unknownEvent = new AsyncEvent<DiscordClient, UnknownEventArgs>("UNKNOWN_EVENT", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionAdded = new AsyncEvent<DiscordClient, MessageReactionAddEventArgs>("MESSAGE_REACTION_ADDED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionRemoved = new AsyncEvent<DiscordClient, MessageReactionRemoveEventArgs>("MESSAGE_REACTION_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionsCleared = new AsyncEvent<DiscordClient, MessageReactionsClearEventArgs>("MESSAGE_REACTIONS_CLEARED", EventExecutionLimit, this.EventErrorHandler);
 		this._messageReactionRemovedEmoji = new AsyncEvent<DiscordClient, MessageReactionRemoveEmojiEventArgs>("MESSAGE_REACTION_REMOVED_EMOJI", EventExecutionLimit, this.EventErrorHandler);
 		this._webhooksUpdated = new AsyncEvent<DiscordClient, WebhooksUpdateEventArgs>("WEBHOOKS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._heartbeated = new AsyncEvent<DiscordClient, HeartbeatEventArgs>("HEARTBEATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandCreated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandUpdated = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandDeleted = new AsyncEvent<DiscordClient, ApplicationCommandEventArgs>("APPLICATION_COMMAND_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildApplicationCommandCountUpdated = new AsyncEvent<DiscordClient, GuildApplicationCommandCountEventArgs>("GUILD_APPLICATION_COMMAND_COUNTS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._applicationCommandPermissionsUpdated = new AsyncEvent<DiscordClient, ApplicationCommandPermissionsUpdateEventArgs>("APPLICATION_COMMAND_PERMISSIONS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationCreated = new AsyncEvent<DiscordClient, GuildIntegrationCreateEventArgs>("INTEGRATION_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationUpdated = new AsyncEvent<DiscordClient, GuildIntegrationUpdateEventArgs>("INTEGRATION_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildIntegrationDeleted = new AsyncEvent<DiscordClient, GuildIntegrationDeleteEventArgs>("INTEGRATION_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceCreated = new AsyncEvent<DiscordClient, StageInstanceCreateEventArgs>("STAGE_INSTANCE_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceUpdated = new AsyncEvent<DiscordClient, StageInstanceUpdateEventArgs>("STAGE_INSTANCE_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._stageInstanceDeleted = new AsyncEvent<DiscordClient, StageInstanceDeleteEventArgs>("STAGE_INSTANCE_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadCreated = new AsyncEvent<DiscordClient, ThreadCreateEventArgs>("THREAD_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadUpdated = new AsyncEvent<DiscordClient, ThreadUpdateEventArgs>("THREAD_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadDeleted = new AsyncEvent<DiscordClient, ThreadDeleteEventArgs>("THREAD_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadListSynced = new AsyncEvent<DiscordClient, ThreadListSyncEventArgs>("THREAD_LIST_SYNCED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadMemberUpdated = new AsyncEvent<DiscordClient, ThreadMemberUpdateEventArgs>("THREAD_MEMBER_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._threadMembersUpdated = new AsyncEvent<DiscordClient, ThreadMembersUpdateEventArgs>("THREAD_MEMBERS_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._zombied = new AsyncEvent<DiscordClient, ZombiedEventArgs>("ZOMBIED", EventExecutionLimit, this.EventErrorHandler);
 		this._payloadReceived = new AsyncEvent<DiscordClient, PayloadReceivedEventArgs>("PAYLOAD_RECEIVED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventCreated = new AsyncEvent<DiscordClient, GuildScheduledEventCreateEventArgs>("GUILD_SCHEDULED_EVENT_CREATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUpdated = new AsyncEvent<DiscordClient, GuildScheduledEventUpdateEventArgs>("GUILD_SCHEDULED_EVENT_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventDeleted = new AsyncEvent<DiscordClient, GuildScheduledEventDeleteEventArgs>("GUILD_SCHEDULED_EVENT_DELETED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUserAdded = new AsyncEvent<DiscordClient, GuildScheduledEventUserAddEventArgs>("GUILD_SCHEDULED_EVENT_USER_ADDED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildScheduledEventUserRemoved = new AsyncEvent<DiscordClient, GuildScheduledEventUserRemoveEventArgs>("GUILD_SCHEDULED_EVENT_USER_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._embeddedActivityUpdated = new AsyncEvent<DiscordClient, EmbeddedActivityUpdateEventArgs>("EMBEDDED_ACTIVITY_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutAdded = new AsyncEvent<DiscordClient, GuildMemberTimeoutAddEventArgs>("GUILD_MEMBER_TIMEOUT_ADDED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutChanged = new AsyncEvent<DiscordClient, GuildMemberTimeoutUpdateEventArgs>("GUILD_MEMBER_TIMEOUT_UPDATED", EventExecutionLimit, this.EventErrorHandler);
 		this._guildMemberTimeoutRemoved = new AsyncEvent<DiscordClient, GuildMemberTimeoutRemoveEventArgs>("GUILD_MEMBER_TIMEOUT_REMOVED", EventExecutionLimit, this.EventErrorHandler);
 		this._rateLimitHit = new AsyncEvent<DiscordClient, RateLimitExceptionEventArgs>("RATELIMIT_HIT", EventExecutionLimit, this.EventErrorHandler);
 
 		this.GuildsInternal.Clear();
 
 		this._presencesLazy = new Lazy<IReadOnlyDictionary<ulong, DiscordPresence>>(() => new ReadOnlyDictionary<ulong, DiscordPresence>(this.PresencesInternal));
 		this._embeddedActivitiesLazy = new Lazy<IReadOnlyDictionary<string, DiscordActivity>>(() => new ReadOnlyDictionary<string, DiscordActivity>(this.EmbeddedActivitiesInternal));
 	}
 
 	#endregion
 
 	#region Client Extension Methods
 
 	/// <summary>
 	/// Registers an extension with this client.
 	/// </summary>
 	/// <param name="ext">Extension to register.</param>
 	public void AddExtension(BaseExtension ext)
 	{
 		ext.Setup(this);
 		this._extensions.Add(ext);
 	}
 
 	/// <summary>
 	/// Retrieves a previously registered extension from this client.
 	/// </summary>
 	/// <typeparam name="T">The type of extension to retrieve.</typeparam>
 	/// <returns>The requested extension.</returns>
 	public T GetExtension<T>() where T : BaseExtension
 		=> this._extensions.FirstOrDefault(x => x.GetType() == typeof(T)) as T;
 
 	#endregion
 
 	#region Public Connection Methods
 
 	/// <summary>
 	/// Connects to the gateway.
 	/// </summary>
 	/// <param name="activity">The activity to set. Defaults to null.</param>
 	/// <param name="status">The optional status to set. Defaults to null.</param>
 	/// <param name="idlesince">Since when is the client performing the specified activity. Defaults to null.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when an invalid token was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task ConnectAsync(DiscordActivity activity = null, UserStatus? status = null, DateTimeOffset? idlesince = null)
 	{
 		// Check if connection lock is already set, and set it if it isn't
 		if (!this._connectionLock.Wait(0))
 			throw new InvalidOperationException("This client is already connected.");
 		this._connectionLock.Set();
 
 		var w = 7500;
 		var i = 5;
 		var s = false;
 		Exception cex = null;
 
 		if (activity == null && status == null && idlesince == null)
 			this._status = null;
 		else
 		{
 			var sinceUnix = idlesince != null ? (long?)Utilities.GetUnixTime(idlesince.Value) : null;
 			this._status = new StatusUpdate()
 			{
 				Activity = new TransportActivity(activity),
 				Status = status ?? UserStatus.Online,
 				IdleSince = sinceUnix,
 				IsAfk = idlesince != null,
 				ActivityInternal = activity
 			};
 		}
 
 		if (!this.IsShard)
 		{
 			if (this.Configuration.TokenType != TokenType.Bot)
 				this.Logger.LogWarning(LoggerEvents.Misc, "You are logging in with a token that is not a bot token. This is not officially supported by Discord, and can result in your account being terminated if you aren't careful.");
 			this.Logger.LogInformation(LoggerEvents.Startup, "Lib {0}, version {1}", this.BotLibrary, this.VersionString);
 		}
 
 		while (i-- > 0 || this.Configuration.ReconnectIndefinitely)
 		{
 			try
 			{
 				await this.InternalConnectAsync().ConfigureAwait(false);
 				s = true;
 				break;
 			}
 			catch (UnauthorizedException e)
 			{
 				FailConnection(this._connectionLock);
 				throw new Exception("Authentication failed. Check your token and try again.", e);
 			}
 			catch (PlatformNotSupportedException)
 			{
 				FailConnection(this._connectionLock);
 				throw;
 			}
 			catch (NotImplementedException)
 			{
 				FailConnection(this._connectionLock);
 				throw;
 			}
 			catch (Exception ex)
 			{
 				FailConnection(null);
 
 				cex = ex;
 				if (i <= 0 && !this.Configuration.ReconnectIndefinitely) break;
 
 				this.Logger.LogError(LoggerEvents.ConnectionFailure, ex, "Connection attempt failed, retrying in {0}s", w / 1000);
 				await Task.Delay(w).ConfigureAwait(false);
 
 				if (i > 0)
 					w *= 2;
 			}
 		}
 
 		if (!s && cex != null)
 		{
 			this._connectionLock.Set();
 			throw new Exception("Could not connect to Discord.", cex);
 		}
 
 		// non-closure, hence args
 		static void FailConnection(ManualResetEventSlim cl) =>
 			// unlock this (if applicable) so we can let others attempt to connect
 			cl?.Set();
 	}
 
 	/// <summary>
 	/// Reconnects to the gateway.
 	/// </summary>
 	/// <param name="startNewSession">Whether to start a new session.</param>
 	public Task ReconnectAsync(bool startNewSession = false)
 		=> this.InternalReconnectAsync(startNewSession, code: startNewSession ? 1000 : 4002);
 
 	/// <summary>
 	/// Disconnects from the gateway.
 	/// </summary>
 	public async Task DisconnectAsync()
 	{
 		this.Configuration.AutoReconnect = false;
 		if (this.WebSocketClient != null)
 			await this.WebSocketClient.DisconnectAsync().ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Public REST Methods
 
 	/// <summary>
 	/// Gets a user.
 	/// </summary>
 	/// <param name="userId">Id of the user</param>
 	/// <param name="fetch">Whether to fetch the user again. Defaults to true.</param>
 	/// <returns>The requested user.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordUser> GetUserAsync(ulong userId, bool fetch = true)
 	{
 		if (!fetch)
 		{
 			return this.TryGetCachedUserInternal(userId, out var usr) ? usr : new DiscordUser { Id = userId, Discord = this };
 		}
 		else
 		{
 			var usr = await this.ApiClient.GetUserAsync(userId).ConfigureAwait(false);
 			usr = this.UserCache.AddOrUpdate(userId, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				old.BannerHash = usr.BannerHash;
 				old.BannerColorInternal = usr.BannerColorInternal;
+				old.Pronouns = usr.Pronouns;
 				return old;
 			});
 
 			return usr;
 		}
 	}
 
 	/// <summary>
 	/// Gets a channel.
 	/// </summary>
 	/// <param name="id">The id of the channel to get.</param>
 	/// <returns>The requested channel.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordChannel> GetChannelAsync(ulong id)
 		=> this.InternalGetCachedChannel(id) ?? await this.ApiClient.GetChannelAsync(id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets a thread.
 	/// </summary>
 	/// <param name="id">The id of the thread to get.</param>
 	/// <returns>The requested thread.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadChannel> GetThreadAsync(ulong id)
 		=> this.InternalGetCachedThread(id) ?? await this.ApiClient.GetThreadAsync(id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends a normal message.
 	/// </summary>
 	/// <param name="channel">The channel to send to.</param>
 	/// <param name="content">The message content to send.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, content, embeds: null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message with an embed.
 	/// </summary>
 	/// <param name="channel">The channel to send to.</param>
 	/// <param name="embed">The embed to attach to the message.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordEmbed embed)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message with content and an embed.
 	/// </summary>
 	/// <param name="channel">Channel to send to.</param>
 	/// <param name="content">The message content to send.</param>
 	/// <param name="embed">The embed to attach to the message.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, string content, DiscordEmbed embed)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message with the <see cref="DisCatSharp.Entities.DiscordMessageBuilder"/>.
 	/// </summary>
 	/// <param name="channel">The channel to send the message to.</param>
 	/// <param name="builder">The message builder.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, DiscordMessageBuilder builder)
 		=> this.ApiClient.CreateMessageAsync(channel.Id, builder);
 
 	/// <summary>
 	/// Sends a message with an <see cref="System.Action{DiscordMessageBuilder}"/>.
 	/// </summary>
 	/// <param name="channel">The channel to send the message to.</param>
 	/// <param name="action">The message builder.</param>
 	/// <returns>The message that was sent.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is false and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordChannel channel, Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 
 		return this.ApiClient.CreateMessageAsync(channel.Id, builder);
 	}
 
 	/// <summary>
 	/// Creates a guild. This requires the bot to be in less than 10 guilds total.
 	/// </summary>
 	/// <param name="name">Name of the guild.</param>
 	/// <param name="region">Voice region of the guild.</param>
 	/// <param name="icon">Stream containing the icon for the guild.</param>
 	/// <param name="verificationLevel">Verification level for the guild.</param>
 	/// <param name="defaultMessageNotifications">Default message notification settings for the guild.</param>
 	/// <param name="systemChannelFlags">System channel flags for the guild.</param>
 	/// <returns>The created guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuild> CreateGuildAsync(string name, string region = null, Optional<Stream> icon = default, VerificationLevel? verificationLevel = null,
 		DefaultMessageNotifications? defaultMessageNotifications = null, SystemChannelFlags? systemChannelFlags = null)
 	{
 		var iconb64 = ImageTool.Base64FromStream(icon);
 		return this.ApiClient.CreateGuildAsync(name, region, iconb64, verificationLevel, defaultMessageNotifications, systemChannelFlags);
 	}
 
 	/// <summary>
 	/// Creates a guild from a template. This requires the bot to be in less than 10 guilds total.
 	/// </summary>
 	/// <param name="code">The template code.</param>
 	/// <param name="name">Name of the guild.</param>
 	/// <param name="icon">Stream containing the icon for the guild.</param>
 	/// <returns>The created guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuild> CreateGuildFromTemplateAsync(string code, string name, Optional<Stream> icon = default)
 	{
 		var iconb64 = ImageTool.Base64FromStream(icon);
 		return this.ApiClient.CreateGuildFromTemplateAsync(code, name, iconb64);
 	}
 
 	/// <summary>
 	/// Executes a raw request.
 	/// </summary>
 	/// <example>
 	/// <c>
 	/// var request = await Client.ExecuteRawRequestAsync(RestRequestMethod.GET, $"{Endpoints.CHANNELS}/243184972190742178964/{Endpoints.INVITES}");
 	/// List&lt;DiscordInvite&gt; invites = DiscordJson.ToDiscordObject&lt;List&lt;DiscordInvite&gt;&gt;(request.Response);
 	/// </c>
 	/// </example>
 	/// <param name="method">The method.</param>
 	/// <param name="route">The route.</param>
 	/// <param name="routeParams">The route parameters.</param>
 	/// <param name="jsonBody">The json body.</param>
 	/// <param name="additionalHeaders">The additional headers.</param>
 	/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the resource does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <returns>A awaitable RestResponse</returns>
 	[Obsolete("This is no longer needed. Use DiscordClient.RestClient instead.", false)]
 	public async Task<RestResponse> ExecuteRawRequestAsync(RestRequestMethod method, string route, object routeParams, string jsonBody = null, Dictionary<string, string> additionalHeaders = null, double? ratelimitWaitOverride = null)
 	{
 		var bucket = this.ApiClient.Rest.GetBucket(method, route, routeParams, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Configuration);
 		var res = await this.ApiClient.DoRequestAsync(this, bucket, url, method, route, additionalHeaders, DiscordJson.SerializeObject(jsonBody), ratelimitWaitOverride);
 
 		return res;
 	}
 
 	/// <summary>
 	/// Gets a guild.
 	/// <para>Setting <paramref name="withCounts"/> to true will make a REST request.</para>
 	/// </summary>
 	/// <param name="id">The guild ID to search for.</param>
 	/// <param name="withCounts">Whether to include approximate presence and member counts in the returned guild.</param>
 	/// <returns>The requested Guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordGuild> GetGuildAsync(ulong id, bool? withCounts = null)
 	{
 		if (this.GuildsInternal.TryGetValue(id, out var guild) && (!withCounts.HasValue || !withCounts.Value))
 			return guild;
 
 		guild = await this.ApiClient.GetGuildAsync(id, withCounts).ConfigureAwait(false);
 		var channels = await this.ApiClient.GetGuildChannelsAsync(guild.Id).ConfigureAwait(false);
 		foreach (var channel in channels) guild.ChannelsInternal[channel.Id] = channel;
 
 		return guild;
 	}
 
 	/// <summary>
 	/// Gets a guild preview.
 	/// </summary>
 	/// <param name="id">The guild ID.</param>
 	/// <returns></returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong id)
 		=> this.ApiClient.GetGuildPreviewAsync(id);
 
 	/// <summary>
 	/// Gets an invite.
 	/// </summary>
 	/// <param name="code">The invite code.</param>
 	/// <param name="withCounts">Whether to include presence and total member counts in the returned invite.</param>
 	/// <param name="withExpiration">Whether to include the expiration date in the returned invite.</param>
 	/// <param name="scheduledEventId">The scheduled event id.</param>
 	/// <returns>The requested Invite.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the invite does not exists.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordInvite> GetInviteByCodeAsync(string code, bool? withCounts = null, bool? withExpiration = null, ulong? scheduledEventId = null)
 		=> this.ApiClient.GetInviteAsync(code, withCounts, withExpiration, scheduledEventId);
 
 	/// <summary>
 	/// Gets a list of user connections.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordConnection>> GetConnectionsAsync()
 		=> this.ApiClient.GetUserConnectionsAsync();
 
 	/// <summary>
 	/// Gets a sticker.
 	/// </summary>
 	/// <returns>The requested sticker.</returns>
 	/// <param name="id">The id of the sticker.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the sticker does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordSticker> GetStickerAsync(ulong id)
 		=> this.ApiClient.GetStickerAsync(id);
 
 
 	/// <summary>
 	/// Gets all nitro sticker packs.
 	/// </summary>
 	/// <returns>List of sticker packs.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordStickerPack>> GetStickerPacksAsync()
 		=> this.ApiClient.GetStickerPacksAsync();
 
 
 	/// <summary>
 	/// Gets the In-App OAuth Url.
 	/// </summary>
 	/// <param name="scopes">Defaults to <see cref="DisCatSharp.Enums.OAuthScopes.BOT_DEFAULT"/>.</param>
 	/// <param name="redir">Redirect Uri.</param>
 	/// <param name="permissions">Defaults to <see cref="Permissions.None"/>.</param>
 	/// <returns>The OAuth Url</returns>
 	public Uri GetInAppOAuth(Permissions permissions = Permissions.None, OAuthScopes scopes = OAuthScopes.BOT_DEFAULT, string redir = null)
 	{
 		permissions &= PermissionMethods.FullPerms;
 		// hey look, it's not all annoying and blue :P
 		return new Uri(new QueryUriBuilder($"{DiscordDomain.GetDomain(CoreDomain.Discord).Url}{Endpoints.OAUTH2}{Endpoints.AUTHORIZE}")
 			.AddParameter("client_id", this.CurrentApplication.Id.ToString(CultureInfo.InvariantCulture))
 			.AddParameter("scope", OAuth.ResolveScopes(scopes))
 			.AddParameter("permissions", ((long)permissions).ToString(CultureInfo.InvariantCulture))
 			.AddParameter("state", "")
 			.AddParameter("redirect_uri", redir ?? "")
 			.ToString());
 	}
 
 	/// <summary>
 	/// Gets a webhook.
 	/// </summary>
 	/// <param name="id">The target webhook id.</param>
 	/// <returns>The requested webhook.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordWebhook> GetWebhookAsync(ulong id)
 		=> this.ApiClient.GetWebhookAsync(id);
 
 	/// <summary>
 	/// Gets a webhook.
 	/// </summary>
 	/// <param name="id">The target webhook id.</param>
 	/// <param name="token">The target webhook token.</param>
 	/// <returns>The requested webhook.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the webhook does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong id, string token)
 		=> this.ApiClient.GetWebhookWithTokenAsync(id, token);
 
 	/// <summary>
 	/// Updates current user's activity and status.
 	/// </summary>
 	/// <param name="activity">Activity to set.</param>
 	/// <param name="userStatus">Status of the user.</param>
 	/// <param name="idleSince">Since when is the client performing the specified activity.</param>
 	/// <returns></returns>
 	public Task UpdateStatusAsync(DiscordActivity activity = null, UserStatus? userStatus = null, DateTimeOffset? idleSince = null)
 		=> this.InternalUpdateStatusAsync(activity, userStatus, idleSince);
 
 	/// <summary>
 	/// Edits current user.
 	/// </summary>
 	/// <param name="username">New username.</param>
 	/// <param name="avatar">New avatar.</param>
 	/// <returns>The modified user.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordUser> UpdateCurrentUserAsync(string username = null, Optional<Stream> avatar = default)
 	{
 		var av64 = ImageTool.Base64FromStream(avatar);
 
 		var usr = await this.ApiClient.ModifyCurrentUserAsync(username, av64).ConfigureAwait(false);
 
 		this.CurrentUser.Username = usr.Username;
 		this.CurrentUser.Discriminator = usr.Discriminator;
 		this.CurrentUser.AvatarHash = usr.AvatarHash;
 		return this.CurrentUser;
 	}
 
 	/// <summary>
 	/// Gets a guild template by the code.
 	/// </summary>
 	/// <param name="code">The code of the template.</param>
 	/// <returns>The guild template for the code.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildTemplate> GetTemplateAsync(string code)
 		=> this.ApiClient.GetTemplateAsync(code);
 
 	/// <summary>
 	/// Gets all the global application commands for this application.
 	/// </summary>
 	/// <param name="withLocalizations">Whether to get the full localization dict.</param>
 	/// <returns>A list of global application commands.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync(bool withLocalizations = false) =>
 		this.ApiClient.GetGlobalApplicationCommandsAsync(this.CurrentApplication.Id, withLocalizations);
 
 	/// <summary>
 	/// Overwrites the existing global application commands. New commands are automatically created and missing commands are automatically deleted.
 	/// </summary>
 	/// <param name="commands">The list of commands to overwrite with.</param>
 	/// <returns>The list of global commands.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGlobalApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
 		this.ApiClient.BulkOverwriteGlobalApplicationCommandsAsync(this.CurrentApplication.Id, commands);
 
 	/// <summary>
 	/// Creates or overwrites a global application command.
 	/// </summary>
 	/// <param name="command">The command to create.</param>
 	/// <returns>The created command.</returns>
 	public Task<DiscordApplicationCommand> CreateGlobalApplicationCommandAsync(DiscordApplicationCommand command) =>
 		this.ApiClient.CreateGlobalApplicationCommandAsync(this.CurrentApplication.Id, command);
 
 	/// <summary>
 	/// Gets a global application command by its id.
 	/// </summary>
 	/// <param name="commandId">The id of the command to get.</param>
 	/// <returns>The command with the id.</returns>
 	public Task<DiscordApplicationCommand> GetGlobalApplicationCommandAsync(ulong commandId) =>
 		this.ApiClient.GetGlobalApplicationCommandAsync(this.CurrentApplication.Id, commandId);
 
 	/// <summary>
 	/// Edits a global application command.
 	/// </summary>
 	/// <param name="commandId">The id of the command to edit.</param>
 	/// <param name="action">Action to perform.</param>
 	/// <returns>The edited command.</returns>
 	public async Task<DiscordApplicationCommand> EditGlobalApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
 	{
 		var mdl = new ApplicationCommandEditModel();
 		action(mdl);
 		var applicationId = this.CurrentApplication?.Id ?? (await this.GetCurrentApplicationAsync().ConfigureAwait(false)).Id;
 		return await this.ApiClient.EditGlobalApplicationCommandAsync(applicationId, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.NameLocalizations, mdl.DescriptionLocalizations, mdl.DefaultMemberPermissions, mdl.DmPermission, mdl.IsNsfw).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a global application command.
 	/// </summary>
 	/// <param name="commandId">The id of the command to delete.</param>
 	public Task DeleteGlobalApplicationCommandAsync(ulong commandId) =>
 		this.ApiClient.DeleteGlobalApplicationCommandAsync(this.CurrentApplication.Id, commandId);
 
 	/// <summary>
 	/// Gets all the application commands for a guild.
 	/// </summary>
 	/// <param name="guildId">The id of the guild to get application commands for.</param>
 	/// <param name="withLocalizations">Whether to get the full localization dict.</param>
 	/// <returns>A list of application commands in the guild.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong guildId, bool withLocalizations = false) =>
 		this.ApiClient.GetGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, withLocalizations);
 
 	/// <summary>
 	/// Overwrites the existing application commands in a guild. New commands are automatically created and missing commands are automatically deleted.
 	/// </summary>
 	/// <param name="guildId">The id of the guild.</param>
 	/// <param name="commands">The list of commands to overwrite with.</param>
 	/// <returns>The list of guild commands.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGuildApplicationCommandsAsync(ulong guildId, IEnumerable<DiscordApplicationCommand> commands) =>
 		this.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.CurrentApplication.Id, guildId, commands);
 
 	/// <summary>
 	/// Creates or overwrites a guild application command.
 	/// </summary>
 	/// <param name="guildId">The id of the guild to create the application command in.</param>
 	/// <param name="command">The command to create.</param>
 	/// <returns>The created command.</returns>
 	public Task<DiscordApplicationCommand> CreateGuildApplicationCommandAsync(ulong guildId, DiscordApplicationCommand command) =>
 		this.ApiClient.CreateGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, command);
 
 	/// <summary>
 	/// Gets a application command in a guild by its id.
 	/// </summary>
 	/// <param name="guildId">The id of the guild the application command is in.</param>
 	/// <param name="commandId">The id of the command to get.</param>
 	/// <returns>The command with the id.</returns>
 	public Task<DiscordApplicationCommand> GetGuildApplicationCommandAsync(ulong guildId, ulong commandId) =>
 		 this.ApiClient.GetGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, commandId);
 
 	/// <summary>
 	/// Edits a application command in a guild.
 	/// </summary>
 	/// <param name="guildId">The id of the guild the application command is in.</param>
 	/// <param name="commandId">The id of the command to edit.</param>
 	/// <param name="action">Action to perform.</param>
 	/// <returns>The edited command.</returns>
 	public async Task<DiscordApplicationCommand> EditGuildApplicationCommandAsync(ulong guildId, ulong commandId, Action<ApplicationCommandEditModel> action)
 	{
 		var mdl = new ApplicationCommandEditModel();
 		action(mdl);
 		var applicationId = this.CurrentApplication?.Id ?? (await this.GetCurrentApplicationAsync().ConfigureAwait(false)).Id;
 		return await this.ApiClient.EditGuildApplicationCommandAsync(applicationId, guildId, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.NameLocalizations, mdl.DescriptionLocalizations, mdl.DefaultMemberPermissions, mdl.DmPermission, mdl.IsNsfw).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a application command in a guild.
 	/// </summary>
 	/// <param name="guildId">The id of the guild to delete the application command in.</param>
 	/// <param name="commandId">The id of the command.</param>
 	public Task DeleteGuildApplicationCommandAsync(ulong guildId, ulong commandId) =>
 		this.ApiClient.DeleteGuildApplicationCommandAsync(this.CurrentApplication.Id, guildId, commandId);
 
 	/// <summary>
 	/// Gets all command permissions for a guild.
 	/// </summary>
 	/// <param name="guildId">The target guild.</param>
 	public Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> GetGuildApplicationCommandPermissionsAsync(ulong guildId) =>
 		this.ApiClient.GetGuildApplicationCommandPermissionsAsync(this.CurrentApplication.Id, guildId);
 
 	/// <summary>
 	/// Gets the permissions for a guild command.
 	/// </summary>
 	/// <param name="guildId">The target guild.</param>
 	/// <param name="commandId">The target command id.</param>
 	public Task<DiscordGuildApplicationCommandPermission> GetApplicationCommandPermissionAsync(ulong guildId, ulong commandId) =>
 		this.ApiClient.GetGuildApplicationCommandPermissionAsync(this.CurrentApplication.Id, guildId, commandId);
 
 	#endregion
 
 	#region Internal Caching Methods
 	/// <summary>
 	/// Gets the internal cached threads.
 	/// </summary>
 	/// <param name="threadId">The target thread id.</param>
 	/// <returns>The requested thread.</returns>
 	internal DiscordThreadChannel InternalGetCachedThread(ulong threadId)
 	{
 		foreach (var guild in this.Guilds.Values)
 			if (guild.Threads.TryGetValue(threadId, out var foundThread))
 				return foundThread;
 
 		return null;
 	}
 
 
 	/// <summary>
 	/// Gets the internal cached scheduled event.
 	/// </summary>
 	/// <param name="scheduledEventId">The target scheduled event id.</param>
 	/// <returns>The requested scheduled event.</returns>
 	internal DiscordScheduledEvent InternalGetCachedScheduledEvent(ulong scheduledEventId)
 	{
 		foreach (var guild in this.Guilds.Values)
 			if (guild.ScheduledEvents.TryGetValue(scheduledEventId, out var foundScheduledEvent))
 				return foundScheduledEvent;
 
 		return null;
 	}
 
 	/// <summary>
 	/// Gets the internal cached channel.
 	/// </summary>
 	/// <param name="channelId">The target channel id.</param>
 	/// <returns>The requested channel.</returns>
 	internal DiscordChannel InternalGetCachedChannel(ulong channelId)
 	{
 		foreach (var guild in this.Guilds.Values)
 			if (guild.Channels.TryGetValue(channelId, out var foundChannel))
 				return foundChannel;
 
 		return null;
 	}
 
 	/// <summary>
 	/// Gets the internal cached guild.
 	/// </summary>
 	/// <param name="guildId">The target guild id.</param>
 	/// <returns>The requested guild.</returns>
 	internal DiscordGuild InternalGetCachedGuild(ulong? guildId)
 	{
 		if (this.GuildsInternal != null && guildId.HasValue)
 		{
 			if (this.GuildsInternal.TryGetValue(guildId.Value, out var guild))
 				return guild;
 		}
 
 		return null;
 	}
 
 	/// <summary>
 	/// Updates a message.
 	/// </summary>
 	/// <param name="message">The message to update.</param>
 	/// <param name="author">The author to update.</param>
 	/// <param name="guild">The guild to update.</param>
 	/// <param name="member">The member to update.</param>
 	private void UpdateMessage(DiscordMessage message, TransportUser author, DiscordGuild guild, TransportMember member)
 	{
 		if (author != null)
 		{
 			var usr = new DiscordUser(author) { Discord = this };
 
 			if (member != null)
 				member.User = author;
 
 			message.Author = this.UpdateUser(usr, guild?.Id, guild, member);
 		}
 
 		var channel = this.InternalGetCachedChannel(message.ChannelId);
 
 		if (channel != null) return;
 
 		channel = !message.GuildId.HasValue
 			? new DiscordDmChannel
 			{
 				Id = message.ChannelId,
 				Discord = this,
 				Type = ChannelType.Private
 			}
 			: new DiscordChannel
 			{
 				Id = message.ChannelId,
 				Discord = this
 			};
 
 		message.Channel = channel;
 	}
 
 	/// <summary>
 	/// Updates a scheduled event.
 	/// </summary>
 	/// <param name="scheduledEvent">The scheduled event to update.</param>
 	/// <param name="guild">The guild to update.</param>
 	/// <returns>The updated scheduled event.</returns>
 	private DiscordScheduledEvent UpdateScheduledEvent(DiscordScheduledEvent scheduledEvent, DiscordGuild guild)
 	{
 		if (scheduledEvent != null)
 		{
 			_ = guild.ScheduledEventsInternal.AddOrUpdate(scheduledEvent.Id, scheduledEvent, (id, old) =>
 			{
 				old.Discord = this;
 				old.Description = scheduledEvent.Description;
 				old.ChannelId = scheduledEvent.ChannelId;
 				old.EntityId = scheduledEvent.EntityId;
 				old.EntityType = scheduledEvent.EntityType;
 				old.EntityMetadata = scheduledEvent.EntityMetadata;
 				old.PrivacyLevel = scheduledEvent.PrivacyLevel;
 				old.Name = scheduledEvent.Name;
 				old.Status = scheduledEvent.Status;
 				old.UserCount = scheduledEvent.UserCount;
 				old.ScheduledStartTimeRaw = scheduledEvent.ScheduledStartTimeRaw;
 				old.ScheduledEndTimeRaw = scheduledEvent.ScheduledEndTimeRaw;
 				return old;
 			});
 		}
 
 		return scheduledEvent;
 	}
 
 	/// <summary>
 	/// Updates a user.
 	/// </summary>
 	/// <param name="usr">The user to update.</param>
 	/// <param name="guildId">The guild id to update.</param>
 	/// <param name="guild">The guild to update.</param>
 	/// <param name="mbr">The member to update.</param>
 	/// <returns>The updated user.</returns>
 	private DiscordUser UpdateUser(DiscordUser usr, ulong? guildId, DiscordGuild guild, TransportMember mbr)
 	{
 		if (mbr != null)
 		{
 			if (mbr.User != null)
 			{
 				usr = new DiscordUser(mbr.User) { Discord = this };
 
 				_ = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
+					old.BannerHash = usr.BannerHash;
+					old.BannerColorInternal = usr.BannerColorInternal;
+					old.Pronouns = usr.Pronouns;
 					return old;
 				});
 
 				usr = new DiscordMember(mbr) { Discord = this, GuildId = guildId.Value };
 			}
 
 			var intents = this.Configuration.Intents;
 
 			DiscordMember member = default;
 
 			if (!intents.HasAllPrivilegedIntents() || guild.IsLarge) // we have the necessary privileged intents, no need to worry about caching here unless guild is large.
 			{
 				if (guild?.MembersInternal.TryGetValue(usr.Id, out member) == false)
 				{
 					if (intents.HasIntent(DiscordIntents.GuildMembers) || this.Configuration.AlwaysCacheMembers) // member can be updated by events, so cache it
 					{
 						guild.MembersInternal.TryAdd(usr.Id, (DiscordMember)usr);
 					}
 				}
 				else if (intents.HasIntent(DiscordIntents.GuildPresences) || this.Configuration.AlwaysCacheMembers) // we can attempt to update it if it's already in cache.
 				{
 					if (!intents.HasIntent(DiscordIntents.GuildMembers)) // no need to update if we already have the member events
 					{
 						_ = guild.MembersInternal.TryUpdate(usr.Id, (DiscordMember)usr, member);
 					}
 				}
 			}
 		}
 		else if (usr.Username != null) // check if not a skeleton user
 		{
 			_ = this.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
+				old.BannerHash = usr.BannerHash;
+				old.BannerColorInternal = usr.BannerColorInternal;
+				old.Pronouns = usr.Pronouns;
 				return old;
 			});
 		}
 
 		return usr;
 	}
 
 	/// <summary>
 	/// Updates the cached scheduled events in a guild.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="rawEvents">The raw events.</param>
 	private void UpdateCachedScheduledEvent(DiscordGuild guild, JArray rawEvents)
 	{
 		if (this._disposed)
 			return;
 
 		if (rawEvents != null)
 		{
 			guild.ScheduledEventsInternal.Clear();
 
 			foreach (var xj in rawEvents)
 			{
 				var xtm = xj.ToDiscordObject<DiscordScheduledEvent>();
 
 				xtm.Discord = this;
 
 				guild.ScheduledEventsInternal[xtm.Id] = xtm;
 			}
 		}
 	}
 
 	/// <summary>
 	/// Updates the cached guild.
 	/// </summary>
 	/// <param name="newGuild">The new guild.</param>
 	/// <param name="rawMembers">The raw members.</param>
 	private void UpdateCachedGuild(DiscordGuild newGuild, JArray rawMembers)
 	{
 		if (this._disposed)
 			return;
 
 		if (!this.GuildsInternal.ContainsKey(newGuild.Id))
 			this.GuildsInternal[newGuild.Id] = newGuild;
 
 		var guild = this.GuildsInternal[newGuild.Id];
 
 		if (newGuild.ChannelsInternal != null && !newGuild.ChannelsInternal.IsEmpty)
 		{
 			foreach (var channel in newGuild.ChannelsInternal.Values)
 			{
 				if (guild.ChannelsInternal.TryGetValue(channel.Id, out _)) continue;
 
 				foreach (var overwrite in channel.PermissionOverwritesInternal)
 				{
 					overwrite.Discord = this;
 					overwrite.ChannelId = channel.Id;
 				}
 
 				guild.ChannelsInternal[channel.Id] = channel;
 			}
 		}
 
 		if (newGuild.ThreadsInternal != null && !newGuild.ThreadsInternal.IsEmpty)
 		{
 			foreach (var thread in newGuild.ThreadsInternal.Values)
 			{
 				if (guild.ThreadsInternal.TryGetValue(thread.Id, out _)) continue;
 
 				guild.ThreadsInternal[thread.Id] = thread;
 			}
 		}
 
 		if (newGuild.ScheduledEventsInternal != null && !newGuild.ScheduledEventsInternal.IsEmpty)
 		{
 			foreach (var @event in newGuild.ScheduledEventsInternal.Values)
 			{
 				if (guild.ScheduledEventsInternal.TryGetValue(@event.Id, out _)) continue;
 
 				guild.ScheduledEventsInternal[@event.Id] = @event;
 			}
 		}
 
 		foreach (var newEmoji in newGuild.EmojisInternal.Values)
 			_ = guild.EmojisInternal.GetOrAdd(newEmoji.Id, _ => newEmoji);
 
 		foreach (var newSticker in newGuild.StickersInternal.Values)
 			_ = guild.StickersInternal.GetOrAdd(newSticker.Id, _ => newSticker);
 
 		foreach (var newStageInstance in newGuild.StageInstancesInternal.Values)
 			_ = guild.StageInstancesInternal.GetOrAdd(newStageInstance.Id, _ => newStageInstance);
 
 		if (rawMembers != null)
 		{
 			guild.MembersInternal.Clear();
 
 			foreach (var xj in rawMembers)
 			{
 				var xtm = xj.ToDiscordObject<TransportMember>();
 
 				var xu = new DiscordUser(xtm.User) { Discord = this };
 				_ = this.UserCache.AddOrUpdate(xtm.User.Id, xu, (id, old) =>
 				{
 					old.Username = xu.Username;
 					old.Discriminator = xu.Discriminator;
 					old.AvatarHash = xu.AvatarHash;
 					old.PremiumType = xu.PremiumType;
 					return old;
 				});
 
 				guild.MembersInternal[xtm.User.Id] = new DiscordMember(xtm) { Discord = this, GuildId = guild.Id };
 			}
 		}
 
 		foreach (var role in newGuild.RolesInternal.Values)
 		{
 			if (guild.RolesInternal.TryGetValue(role.Id, out _)) continue;
 
 			role.GuildId = guild.Id;
 			guild.RolesInternal[role.Id] = role;
 		}
 
 		guild.Name = newGuild.Name;
 		guild.AfkChannelId = newGuild.AfkChannelId;
 		guild.AfkTimeout = newGuild.AfkTimeout;
 		guild.DefaultMessageNotifications = newGuild.DefaultMessageNotifications;
 		guild.RawFeatures = newGuild.RawFeatures;
 		guild.IconHash = newGuild.IconHash;
 		guild.MfaLevel = newGuild.MfaLevel;
 		guild.OwnerId = newGuild.OwnerId;
 		guild.VoiceRegionId = newGuild.VoiceRegionId;
 		guild.SplashHash = newGuild.SplashHash;
 		guild.VerificationLevel = newGuild.VerificationLevel;
 		guild.WidgetEnabled = newGuild.WidgetEnabled;
 		guild.WidgetChannelId = newGuild.WidgetChannelId;
 		guild.ExplicitContentFilter = newGuild.ExplicitContentFilter;
 		guild.PremiumTier = newGuild.PremiumTier;
 		guild.PremiumSubscriptionCount = newGuild.PremiumSubscriptionCount;
 		guild.PremiumProgressBarEnabled = newGuild.PremiumProgressBarEnabled;
 		guild.BannerHash = newGuild.BannerHash;
 		guild.Description = newGuild.Description;
 		guild.VanityUrlCode = newGuild.VanityUrlCode;
 		guild.SystemChannelId = newGuild.SystemChannelId;
 		guild.SystemChannelFlags = newGuild.SystemChannelFlags;
 		guild.DiscoverySplashHash = newGuild.DiscoverySplashHash;
 		guild.MaxMembers = newGuild.MaxMembers;
 		guild.MaxPresences = newGuild.MaxPresences;
 		guild.ApproximateMemberCount = newGuild.ApproximateMemberCount;
 		guild.ApproximatePresenceCount = newGuild.ApproximatePresenceCount;
 		guild.MaxVideoChannelUsers = newGuild.MaxVideoChannelUsers;
 		guild.PreferredLocale = newGuild.PreferredLocale;
 		guild.RulesChannelId = newGuild.RulesChannelId;
 		guild.PublicUpdatesChannelId = newGuild.PublicUpdatesChannelId;
 		guild.ApplicationId = newGuild.ApplicationId;
 
 		// fields not sent for update:
 		// - guild.Channels
 		// - voice states
 		// - guild.JoinedAt = new_guild.JoinedAt;
 		// - guild.Large = new_guild.Large;
 		// - guild.MemberCount = Math.Max(new_guild.MemberCount, guild._members.Count);
 		// - guild.Unavailable = new_guild.Unavailable;
 	}
 
 	/// <summary>
 	/// Populates the message reactions and cache.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <param name="author">The author.</param>
 	/// <param name="member">The member.</param>
 	private void PopulateMessageReactionsAndCache(DiscordMessage message, TransportUser author, TransportMember member)
 	{
 		var guild = message.Channel?.Guild ?? this.InternalGetCachedGuild(message.GuildId);
 
 		this.UpdateMessage(message, author, guild, member);
 
 		if (message.ReactionsInternal == null)
 			message.ReactionsInternal = new List<DiscordReaction>();
 		foreach (var xr in message.ReactionsInternal)
 			xr.Emoji.Discord = this;
 
 		if (this.Configuration.MessageCacheSize > 0 && message.Channel != null)
 			this.MessageCache?.Add(message);
 	}
 
 
 	#endregion
 
 	#region Disposal
 
 	~DiscordClient()
 	{
 		this.Dispose();
 	}
 
 	/// <summary>
 	/// Whether the client is disposed.
 	/// </summary>
 
 	private bool _disposed;
 
 	/// <summary>
 	/// Disposes the client.
 	/// </summary>
 	public override void Dispose()
 	{
 		if (this._disposed)
 			return;
 
 		this._disposed = true;
 		GC.SuppressFinalize(this);
 
 		this.DisconnectAsync().ConfigureAwait(false).GetAwaiter().GetResult();
 		this.ApiClient.Rest.Dispose();
 		this.CurrentUser = null;
 
 		var extensions = this._extensions; // prevent _extensions being modified during dispose
 		this._extensions = null;
 		foreach (var extension in extensions)
 			if (extension is IDisposable disposable)
 				disposable.Dispose();
 
 		try
 		{
 			this._cancelTokenSource?.Cancel();
 			this._cancelTokenSource?.Dispose();
 		}
 		catch { }
 
 		this.GuildsInternal = null;
 		this._heartbeatTask = null;
 	}
 
 	#endregion
 }
diff --git a/DisCatSharp/Entities/Application/DiscordApplicationCommandOption.cs b/DisCatSharp/Entities/Application/DiscordApplicationCommandOption.cs
index 0263ac96a..0891efb24 100644
--- a/DisCatSharp/Entities/Application/DiscordApplicationCommandOption.cs
+++ b/DisCatSharp/Entities/Application/DiscordApplicationCommandOption.cs
@@ -1,163 +1,165 @@
 // 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 DisCatSharp.Enums;
+
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a parameter for a <see cref="DiscordApplicationCommand"/>.
 /// </summary>
 public sealed class DiscordApplicationCommandOption
 {
 	/// <summary>
 	/// Gets the type of this command parameter.
 	/// </summary>
 	[JsonProperty("type")]
 	public ApplicationCommandOptionType Type { get; internal set; }
 
 	/// <summary>
 	/// Gets the name of this command parameter.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Sets the name localizations.
 	/// </summary>
 	[JsonProperty("name_localizations", NullValueHandling = NullValueHandling.Ignore)]
 	internal Dictionary<string, string> RawNameLocalizations { get; set; }
 
 	/// <summary>
 	/// Gets the name localizations.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordApplicationCommandLocalization NameLocalizations
 		=> new(this.RawNameLocalizations);
 
 	/// <summary>
 	/// Gets the description of this command parameter.
 	/// </summary>
 	[JsonProperty("description")]
 	public string Description { get; internal set; }
 
 	/// <summary>
 	/// Sets the description localizations.
 	/// </summary>
 	[JsonProperty("description_localizations", NullValueHandling = NullValueHandling.Ignore)]
 	internal Dictionary<string, string> RawDescriptionLocalizations { get; set; }
 
 	/// <summary>
 	/// Gets the description localizations.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordApplicationCommandLocalization DescriptionLocalizations
 		=> new(this.RawDescriptionLocalizations);
 
 	/// <summary>
 	/// Gets whether this command parameter is required.
 	/// </summary>
 	[JsonProperty("required", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Required { get; internal set; }
 
 	/// <summary>
 	/// Gets the optional choices for this command parameter.
 	/// Not applicable for auto-complete options.
 	/// </summary>
 	[JsonProperty("choices", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyCollection<DiscordApplicationCommandOptionChoice> Choices { get; internal set; }
 
 	/// <summary>
 	/// Gets the optional subcommand parameters for this parameter.
 	/// </summary>
 	[JsonProperty("options", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyCollection<DiscordApplicationCommandOption> Options { get; internal set; }
 
 	/// <summary>
 	/// Gets the optional allowed channel types.
 	/// </summary>
 	[JsonProperty("channel_types", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyCollection<ChannelType> ChannelTypes { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this option provides autocompletion.
 	/// </summary>
 	[JsonProperty("autocomplete", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? AutoComplete { get; internal set; }
 
 	/// <summary>
 	/// Gets the minimum value for this slash command parameter.
 	/// </summary>
 	[JsonProperty("min_value", NullValueHandling = NullValueHandling.Ignore)]
 	public object MinimumValue { get; internal set; }
 
 	/// <summary>
 	/// Gets the maximum value for this slash command parameter.
 	/// </summary>
 	[JsonProperty("max_value", NullValueHandling = NullValueHandling.Ignore)]
 	public object MaximumValue { get; internal set; }
 
 	/// <summary>
 	/// Creates a new instance of a <see cref="DiscordApplicationCommandOption"/>.
 	/// </summary>
 	/// <param name="name">The name of this parameter.</param>
 	/// <param name="description">The description of the parameter.</param>
 	/// <param name="type">The type of this parameter.</param>
 	/// <param name="required">Whether the parameter is required.</param>
 	/// <param name="choices">The optional choice selection for this parameter.</param>
 	/// <param name="options">The optional subcommands for this parameter.</param>
 	/// <param name="channelTypes">If the option is a channel type, the channels shown will be restricted to these types.</param>
 	/// <param name="autocomplete">Whether this option provides autocompletion.</param>
 	/// <param name="minimumValue">The minimum value for this parameter. Only valid for types <see cref="ApplicationCommandOptionType.Integer"/> or <see cref="ApplicationCommandOptionType.Number"/>.</param>
 	/// <param name="maximumValue">The maximum value for this parameter. Only valid for types <see cref="ApplicationCommandOptionType.Integer"/> or <see cref="ApplicationCommandOptionType.Number"/>.</param>
 	/// <param name="nameLocalizations">The localizations of the parameter name.</param>
 	/// <param name="descriptionLocalizations">The localizations of the parameter description.</param>
 	public DiscordApplicationCommandOption(string name, string description, ApplicationCommandOptionType type, bool? required = null, IEnumerable<DiscordApplicationCommandOptionChoice> choices = null, IEnumerable<DiscordApplicationCommandOption> options = null, IEnumerable<ChannelType> channelTypes = null, bool? autocomplete = null, object minimumValue = null, object maximumValue = null, DiscordApplicationCommandLocalization nameLocalizations = null, DiscordApplicationCommandLocalization descriptionLocalizations = null)
 	{
 		if (!Utilities.IsValidSlashCommandName(name))
 			throw new ArgumentException("Invalid application command option name specified. It must be below 32 characters and not contain any whitespace.", nameof(name));
 		if (name.Any(char.IsUpper))
 			throw new ArgumentException("Application command option name cannot have any upper case characters.", nameof(name));
 		if (description.Length > 100)
 			throw new ArgumentException("Application command option description cannot exceed 100 characters.", nameof(description));
 		if ((autocomplete ?? false) && (choices?.Any() ?? false))
 			throw new InvalidOperationException("Auto-complete slash command options cannot provide choices.");
 
 		this.Name = name;
 		this.Description = description;
 		this.Type = type;
 		this.Required = required;
 		this.Choices = choices != null ? new ReadOnlyCollection<DiscordApplicationCommandOptionChoice>(choices.ToList()) : null;
 		this.Options = options != null ? new ReadOnlyCollection<DiscordApplicationCommandOption>(options.ToList()) : null;
 		this.ChannelTypes = channelTypes != null ? new ReadOnlyCollection<ChannelType>(channelTypes.ToList()) : null;
 		this.AutoComplete = autocomplete;
 		this.MinimumValue = minimumValue;
 		this.MaximumValue = maximumValue;
 		this.RawNameLocalizations = nameLocalizations?.GetKeyValuePairs();
 		this.RawDescriptionLocalizations = descriptionLocalizations?.GetKeyValuePairs();
 	}
 }
diff --git a/DisCatSharp/Entities/Channel/DiscordChannel.cs b/DisCatSharp/Entities/Channel/DiscordChannel.cs
index 4621f4887..95f59a2d8 100644
--- a/DisCatSharp/Entities/Channel/DiscordChannel.cs
+++ b/DisCatSharp/Entities/Channel/DiscordChannel.cs
@@ -1,1332 +1,1333 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a discord channel.
 /// </summary>
 public class DiscordChannel : SnowflakeObject, IEquatable<DiscordChannel>
 {
 	/// <summary>
 	/// Gets ID of the guild to which this channel belongs.
 	/// </summary>
 	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? GuildId { get; internal set; }
 
 	/// <summary>
 	/// Gets ID of the category that contains this channel.
 	/// </summary>
 	[JsonProperty("parent_id", NullValueHandling = NullValueHandling.Include)]
 	public ulong? ParentId { get; internal set; }
 
 	/// <summary>
 	/// Gets the category that contains this channel.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel Parent
 		=> this.ParentId.HasValue ? this.Guild.GetChannel(this.ParentId.Value) : null;
 
 	/// <summary>
 	/// Gets the name of this channel.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of this channel.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public ChannelType Type { get; internal set; }
 
+	/// <summary>
+	/// Gets the template for new posts in this channel.
+	/// Applicable if forum channel.
+	/// </summary>
+	[JsonProperty("template", NullValueHandling = NullValueHandling.Ignore)]
+	public string Template { get; internal set; }
+
 	/// <summary>
 	/// Gets this channel's banner hash, when applicable.
 	/// </summary>
 	[JsonProperty("banner")]
 	public string BannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's banner in url form.
 	/// </summary>
 	[JsonIgnore]
 	public string BannerUrl
 		=> !string.IsNullOrWhiteSpace(this.BannerHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Uri}{Endpoints.CHANNELS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.BANNERS}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}" : null;
 
 	/// <summary>
 	/// Gets the position of this channel.
 	/// </summary>
 	[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
 	public int Position { get; internal set; }
 
 	/// <summary>
 	/// Gets the flags of this channel.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public ChannelFlags Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets the maximum available position to move the channel to.
 	/// This can contain outdated information.
 	/// </summary>
 	public int GetMaxPosition()
 	{
 		var channels = this.Guild.Channels.Values;
 		return this.ParentId != null
 			? this.Type == ChannelType.Text || this.Type == ChannelType.News
 				? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News)).OrderBy(xc => xc.Position).Last().Position
 				: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 					? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage)).OrderBy(xc => xc.Position).Last().Position
 					: channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type).OrderBy(xc => xc.Position).Last().Position
 			: channels.Where(xc => xc.ParentId == null && xc.Type == this.Type).OrderBy(xc => xc.Position).Last().Position;
 	}
 
 	/// <summary>
 	/// Gets the minimum available position to move the channel to.
 	/// </summary>
 	public int GetMinPosition()
 	{
 		var channels = this.Guild.Channels.Values;
 		return this.ParentId != null
 			? this.Type == ChannelType.Text || this.Type == ChannelType.News
 				? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News)).OrderBy(xc => xc.Position).First().Position
 				: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 					? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage)).OrderBy(xc => xc.Position).First().Position
 					: channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type).OrderBy(xc => xc.Position).First().Position
 			: channels.Where(xc => xc.ParentId == null && xc.Type == this.Type).OrderBy(xc => xc.Position).First().Position;
 	}
 
 	/// <summary>
 	/// Gets whether this channel is a DM channel.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsPrivate
 		=> this.Type == ChannelType.Private || this.Type == ChannelType.Group;
 
 	/// <summary>
 	/// Gets whether this channel is a channel category.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsCategory
 		=> this.Type == ChannelType.Category;
 
 	/// <summary>
 	/// Gets whether this channel is a stage channel.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsStage
 		=> this.Type == ChannelType.Stage;
 
 	/// <summary>
 	/// Gets the guild to which this channel belongs.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordGuild Guild
 		=> this.GuildId.HasValue && this.Discord.Guilds.TryGetValue(this.GuildId.Value, out var guild) ? guild : null;
 
 	/// <summary>
 	/// Gets a collection of permission overwrites for this channel.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordOverwrite> PermissionOverwrites
 		=> this._permissionOverwritesLazy.Value;
 
 	[JsonProperty("permission_overwrites", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordOverwrite> PermissionOverwritesInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordOverwrite>> _permissionOverwritesLazy;
 
 	/// <summary>
 	/// Gets the channel's topic. This is applicable to text channels only.
 	/// </summary>
 	[JsonProperty("topic", NullValueHandling = NullValueHandling.Ignore)]
 	public string Topic { get; internal set; }
 
 	/// <summary>
 	/// Gets the ID of the last message sent in this channel. This is applicable to text channels only.
 	/// </summary>
 	[JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? LastMessageId { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's bitrate. This is applicable to voice channels only.
 	/// </summary>
 	[JsonProperty("bitrate", NullValueHandling = NullValueHandling.Ignore)]
 	public int? Bitrate { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's user limit. This is applicable to voice channels only.
 	/// </summary>
 	[JsonProperty("user_limit", NullValueHandling = NullValueHandling.Ignore)]
 	public int? UserLimit { get; internal set; }
 
 	/// <summary>
 	/// <para>Gets the slow mode delay configured for this channel.</para>
 	/// <para>All bots, as well as users with <see cref="Permissions.ManageChannels"/> or <see cref="Permissions.ManageMessages"/> permissions in the channel are exempt from slow mode.</para>
 	/// </summary>
 	[JsonProperty("rate_limit_per_user")]
 	public int? PerUserRateLimit { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's video quality mode. This is applicable to voice channels only.
 	/// </summary>
 	[JsonProperty("video_quality_mode", NullValueHandling = NullValueHandling.Ignore)]
 	public VideoQualityMode? QualityMode { get; internal set; }
 
 	/// <summary>
 	/// List of available tags for forum posts.
 	/// </summary>
 	[JsonProperty("available_tags", NullValueHandling = NullValueHandling.Ignore)]
 	public List<ForumPostTag> AvailableTags { get; internal set; }
 
-	/// <summary>
-	/// Starter template for forum posts.
-	/// </summary>
-	[JsonProperty("template", NullValueHandling = NullValueHandling.Ignore)]
-	public string Template { get; internal set; }
-
 	/// <summary>
 	/// Gets when the last pinned message was pinned.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset? LastPinTimestamp
 		=> !string.IsNullOrWhiteSpace(this.LastPinTimestampRaw) && DateTimeOffset.TryParse(this.LastPinTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets when the last pinned message was pinned as raw string.
 	/// </summary>
 	[JsonProperty("last_pin_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string LastPinTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets this channel's default duration for newly created threads, in minutes, to automatically archive the thread after recent activity.
 	/// </summary>
 	[JsonProperty("default_auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
 	public ThreadAutoArchiveDuration? DefaultAutoArchiveDuration { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's mention string.
 	/// </summary>
 	[JsonIgnore]
 	public string Mention
 		=> Formatter.Mention(this);
 
 	/// <summary>
 	/// Gets this channel's children. This applies only to channel categories.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordChannel> Children =>
 		!this.IsCategory
 			? throw new ArgumentException("Only channel categories contain children.")
 			: this.Guild.ChannelsInternal.Values.Where(e => e.ParentId == this.Id).ToList();
 
 	/// <summary>
 	/// Gets the list of members currently in the channel (if voice channel), or members who can see the channel (otherwise).
 	/// </summary>
 	[JsonIgnore]
 	public virtual IReadOnlyList<DiscordMember> Users =>
 		this.Guild == null
 			? throw new InvalidOperationException("Cannot query users outside of guild channels.")
 			: this.IsVoiceJoinable()
 				? this.Guild.Members.Values.Where(x => x.VoiceState?.ChannelId == this.Id).ToList()
 				: this.Guild.Members.Values.Where(x => (this.PermissionsFor(x) & Permissions.AccessChannels) == Permissions.AccessChannels).ToList();
 
 	/// <summary>
 	/// Gets whether this channel is an NSFW channel.
 	/// </summary>
 	[JsonProperty("nsfw")]
 	public bool IsNsfw { get; internal set; }
 
 	/// <summary>
 	/// Gets this channel's region id (if voice channel).
 	/// </summary>
 	[JsonProperty("rtc_region", NullValueHandling = NullValueHandling.Ignore)]
 	internal string RtcRegionId { get; set; }
 
 	/// <summary>
 	/// Gets this channel's region override (if voice channel).
 	/// </summary>
 	[JsonIgnore]
 	public DiscordVoiceRegion RtcRegion
 		=> this.RtcRegionId != null ? this.Discord.VoiceRegions[this.RtcRegionId] : null;
 
 
 	/// <summary>
 	/// Only sent on the resolved channels of interaction responses for application commands.
 	/// Gets the permissions of the user in this channel who invoked the command.
 	/// </summary>
 	[JsonProperty("permissions", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions? UserPermissions { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordChannel"/> class.
 	/// </summary>
 	internal DiscordChannel()
 	{
 		this._permissionOverwritesLazy = new Lazy<IReadOnlyList<DiscordOverwrite>>(() => new ReadOnlyCollection<DiscordOverwrite>(this.PermissionOverwritesInternal));
 	}
 
 	#region Methods
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(string content) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <param name="content">Content of the message to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission if TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="builder">The builder with all the items to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder builder)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="action">The builder with all the items to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission TTS is true and <see cref="Permissions.SendTtsMessages"/> if TTS is true.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> SendMessageAsync(Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 
 
 		return !this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 	}
 
 	/// <summary>
 	/// Deletes a guild channel
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteChannelAsync(this.Id, reason);
 
 	/// <summary>
 	/// Clones this channel. This operation will create a channel with identical settings to this one. Note that this will not copy messages.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>Newly-created channel.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordChannel> CloneAsync(string reason = null)
 	{
 		if (this.Guild == null)
 			throw new InvalidOperationException("Non-guild channels cannot be cloned.");
 
 		var ovrs = new List<DiscordOverwriteBuilder>();
 		foreach (var ovr in this.PermissionOverwritesInternal)
 			ovrs.Add(await new DiscordOverwriteBuilder().FromAsync(ovr).ConfigureAwait(false));
 
 		var bitrate = this.Bitrate;
 		var userLimit = this.UserLimit;
 		Optional<int?> perUserRateLimit = this.PerUserRateLimit;
 
 		if (!this.IsVoiceJoinable())
 		{
 			bitrate = null;
 			userLimit = null;
 		}
 
 		if (this.Type == ChannelType.Stage)
 		{
 			userLimit = null;
 		}
 		if (!this.IsWritable())
 		{
 			perUserRateLimit = Optional.None;
 		}
 
 		return await this.Guild.CreateChannelAsync(this.Name, this.Type, this.Parent, this.Topic, bitrate, userLimit, ovrs, this.IsNsfw, perUserRateLimit, this.QualityMode, this.DefaultAutoArchiveDuration, reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Returns a specific message
 	/// </summary>
 	/// <param name="id">The id of the message</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> GetMessageAsync(ulong id) =>
 		this.Discord.Configuration.MessageCacheSize > 0
 		&& this.Discord is DiscordClient dc
 		&& dc.MessageCache != null
 		&& dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
 			? msg
 			: await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Modifies the current channel.
 	/// </summary>
 	/// <param name="action">Action to perform on this channel</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
 	/// <exception cref="System.NotSupportedException">Thrown when the client does not have the correct <see cref="PremiumTier"/> for modifying the <see cref="ThreadAutoArchiveDuration"/>.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ModifyAsync(Action<ChannelEditModel> action)
 	{
 		var mdl = new ChannelEditModel();
 		action(mdl);
 
 		if (mdl.DefaultAutoArchiveDuration.HasValue)
 		{
 			if (!Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.DefaultAutoArchiveDuration.Value))
 				throw new NotSupportedException($"Cannot modify DefaultAutoArchiveDuration. Guild needs boost tier {(mdl.DefaultAutoArchiveDuration.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 		}
 		if (mdl.Banner.HasValue)
 		{
 			if (!this.Guild.Features.CanSetChannelBanner)
 				throw new NotSupportedException($"Cannot modify Banner. Guild needs boost tier three.");
 		}
 
 		var bannerb64 = ImageTool.Base64FromStream(mdl.Banner);
 
 		return this.Discord.ApiClient.ModifyChannelAsync(this.Id, mdl.Name, mdl.Position, mdl.Topic, mdl.Nsfw,
 			mdl.Parent.Map(p => p?.Id), mdl.Bitrate, mdl.UserLimit, mdl.PerUserRateLimit, mdl.RtcRegion.Map(r => r?.Id),
 			mdl.QualityMode, mdl.DefaultAutoArchiveDuration, mdl.Type, mdl.PermissionOverwrites, bannerb64, mdl.AuditLogReason);
 	}
 
 	/// <summary>
 	/// Updates the channel position when it doesn't have a category.
 	///
 	/// Use <see cref="ModifyParentAsync"/> for moving to other categories.
 	/// Use <see cref="RemoveParentAsync"/> to move out of a category.
 	/// Use <see cref="ModifyPositionInCategoryAsync"/> for moving within a category.
 	/// </summary>
 	/// <param name="position">Position the channel should be moved to.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ModifyPositionAsync(int position, string reason = null)
 	{
 		if (this.Guild == null)
 			throw new ArgumentException("Cannot modify order of non-guild channels.");
 		if (!this.IsMovable())
 			throw new NotSupportedException("You can't move this type of channel in categories.");
 		if (this.ParentId != null)
 			throw new ArgumentException("Cannot modify order of channels within a category. Use ModifyPositionInCategoryAsync instead.");
 
 		var pmds = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type).OrderBy(xc => xc.Position)
 			.Select(x => new RestGuildChannelReorderPayload
 			{
 				ChannelId = x.Id,
 				Position = x.Id == this.Id ? position : x.Position >= position ? x.Position + 1 : x.Position
 			});
 
 		return this.Discord.ApiClient.ModifyGuildChannelPositionAsync(this.Guild.Id, pmds, reason);
 	}
 
 	/// <summary>
 	/// Updates the channel position within it's own category.
 	///
 	/// Use <see cref="ModifyParentAsync"/> for moving to other categories.
 	/// Use <see cref="RemoveParentAsync"/> to move out of a category.
 	/// Use <see cref="ModifyPositionAsync"/> to move channels outside a category.
 	/// </summary>
 	/// <param name="position">The position.</param>
 	/// <param name="reason">The reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when function is called on a channel without a parent channel.</exception>
 	public async Task ModifyPositionInCategoryAsync(int position, string reason = null)
 	{
 		if (!this.IsMovableInParent())
 			throw new NotSupportedException("You can't move this type of channel in categories.");
 
 		var isUp = position > this.Position;
 
 		var channels = await this.InternalRefreshChannelsAsync();
 
 		var chns = this.ParentId != null
 			? this.Type == ChannelType.Text || this.Type == ChannelType.News
 				? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News))
 				: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 					? channels.Where(xc => xc.ParentId == this.ParentId && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage))
 					: channels.Where(xc => xc.ParentId == this.ParentId && xc.Type == this.Type)
 			: this.Type == ChannelType.Text || this.Type == ChannelType.News
 				? channels.Where(xc => xc.ParentId == null && (xc.Type == ChannelType.Text || xc.Type == ChannelType.News))
 				: this.Type == ChannelType.Voice || this.Type == ChannelType.Stage
 					? channels.Where(xc => xc.ParentId == null && (xc.Type == ChannelType.Voice || xc.Type == ChannelType.Stage))
 					: channels.Where(xc => xc.ParentId == null && xc.Type == this.Type);
 
 		var ochns = chns.OrderBy(xc => xc.Position).ToArray();
 		var min = ochns.First().Position;
 		var max = ochns.Last().Position;
 
 		if (position > max || position < min)
 			throw new IndexOutOfRangeException($"Position is not in range. {position} is {(position > max ? "greater then the maximal" : "lower then the minimal")} position.");
 
 		var pmds = ochns.Select(x =>
 			new RestGuildChannelReorderPayload
 			{
 				ChannelId = x.Id,
 				Position = x.Id == this.Id
 					? position
 					: isUp
 						? x.Position <= position && x.Position > this.Position ? x.Position - 1 : x.Position
 						: x.Position >= position && x.Position < this.Position ? x.Position + 1 : x.Position
 			}
 		);
 
 		await this.Discord.ApiClient.ModifyGuildChannelPositionAsync(this.Guild.Id, pmds, reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Internally refreshes the channel list.
 	/// </summary>
 	private async Task<IReadOnlyList<DiscordChannel>> InternalRefreshChannelsAsync()
 	{
 		await this.RefreshPositionsAsync();
 		return this.Guild.Channels.Values.ToList().AsReadOnly();
 	}
 
 	/// <summary>
 	/// Refreshes the positions.
 	/// </summary>
 	public async Task RefreshPositionsAsync()
 	{
 		var channels = await this.Discord.ApiClient.GetGuildChannelsAsync(this.Guild.Id);
 		this.Guild.ChannelsInternal.Clear();
 		foreach (var channel in channels.ToList())
 		{
 			channel.Discord = this.Discord;
 			foreach (var xo in channel.PermissionOverwritesInternal)
 			{
 				xo.Discord = this.Discord;
 				xo.ChannelId = channel.Id;
 			}
 			this.Guild.ChannelsInternal[channel.Id] = channel;
 		}
 	}
 
 	/// <summary>
 	/// Updates the channel position within it's own category.
 	/// Valid modes: '+' or 'down' to move a channel down | '-' or 'up' to move a channel up.
 	///
 	/// Use <see cref="ModifyParentAsync"/> for moving to other categories.
 	/// Use <see cref="RemoveParentAsync"/> to move out of a category.
 	/// Use <see cref="ModifyPositionAsync"/> to move channels outside a category.
 	/// </summary>
 	/// <param name="mode">The mode. Valid: '+' or 'down' to move a channel down | '-' or 'up' to move a channel up</param>
 	/// <param name="position">The position.</param>
 	/// <param name="reason">The reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.IndexOutOfRangeException">Thrown when <paramref name="position"/> is out of range.</exception>
 	/// <exception cref="System.ArgumentException">Thrown when function is called on a channel without a parent channel, a wrong mode is given or given position is zero.</exception>
 	public Task ModifyPositionInCategorySmartAsync(string mode, int position, string reason = null)
 	{
 		if (!this.IsMovableInParent())
 			throw new NotSupportedException("You can't move this type of channel in categories.");
 
 		if (mode != "+" && mode != "-" && mode != "down" && mode != "up")
 			throw new ArgumentException("Error with the selected mode: Valid is '+' or 'down' to move a channel down and '-' or 'up' to move a channel up");
 
 		var positive = mode == "+" || mode == "positive" || mode == "down";
 		var negative = mode == "-" || mode == "negative" || mode == "up";
 		return positive
 			? position < this.GetMaxPosition()
 				? this.ModifyPositionInCategoryAsync(this.Position + position, reason)
 				: throw new IndexOutOfRangeException($"Position is not in range of category.")
 			: negative
 				? position > this.GetMinPosition()
 					? this.ModifyPositionInCategoryAsync(this.Position - position, reason)
 					: throw new IndexOutOfRangeException($"Position is not in range of category.")
 				: throw new ArgumentException("You can only modify with +X or -X. 0 is not valid.");
 	}
 
 	/// <summary>
 	/// Updates the channel parent, moving the channel to the bottom of the new category.
 	/// </summary>
 	/// <param name="newParent">New parent for channel. Use <see cref="RemoveParentAsync(string)"/> to remove from parent.</param>
 	/// <param name="lockPermissions">Sync permissions with parent. Defaults to null.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ModifyParentAsync(DiscordChannel newParent, bool? lockPermissions = null, string reason = null)
 	{
 		if (this.Guild == null)
 			throw new ArgumentException("Cannot modify parent of non-guild channels.");
 		if (!this.IsMovableInParent())
 			throw new NotSupportedException("You can't move this type of channel in categories.");
 		if (newParent.Type is not ChannelType.Category)
 			throw new ArgumentException("Only category type channels can be parents.");
 
 
 		var position = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type && xc.ParentId == newParent.Id) // gets list same type channels in parent
                             .Select(xc => xc.Position).DefaultIfEmpty(-1).Max() + 1; // returns highest position of list +1, default val: 0
 
 		var pmds = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type)
 			.OrderBy(xc => xc.Position)
 			.Select(x =>
 			{
 				var pmd = new RestGuildChannelNewParentPayload
 				{
 					ChannelId = x.Id,
 					Position = x.Position >= position ? x.Position + 1 : x.Position,
 				};
 				if (x.Id == this.Id)
 				{
 					pmd.Position = position;
 					pmd.ParentId = newParent is not null ? newParent.Id : null;
 					pmd.LockPermissions = lockPermissions;
 				}
 
 				return pmd;
 			});
 
 		return this.Discord.ApiClient.ModifyGuildChannelParentAsync(this.Guild.Id, pmds, reason);
 	}
 
 	/// <summary>
 	/// Moves the channel out of a category.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveParentAsync(string reason = null)
 	{
 		if (this.Guild == null)
 			throw new ArgumentException("Cannot modify parent of non-guild channels.");
 		if (!this.IsMovableInParent())
 			throw new NotSupportedException("You can't move this type of channel in categories.");
 
 		var pmds = this.Guild.ChannelsInternal.Values.Where(xc => xc.Type == this.Type)
 			.OrderBy(xc => xc.Position)
 			.Select(x =>
 			{
 				var pmd = new RestGuildChannelNoParentPayload { ChannelId = x.Id };
 				if (x.Id == this.Id)
 				{
 					pmd.Position = 1;
 					pmd.ParentId = null;
 				}
 				else
 				{
 					pmd.Position = x.Position < this.Position ? x.Position + 1 : x.Position;
 				}
 
 				return pmd;
 			});
 
 		return this.Discord.ApiClient.DetachGuildChannelParentAsync(this.Guild.Id, pmds, reason);
 	}
 
 	/// <summary>
 	/// Returns a list of messages before a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="before">Message to fetch before from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordMessage>> GetMessagesBeforeAsync(ulong before, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, before, null, null);
 
 	/// <summary>
 	/// Returns a list of messages after a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="after">Message to fetch after from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordMessage>> GetMessagesAfterAsync(ulong after, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, null, after, null);
 
 	/// <summary>
 	/// Returns a list of messages around a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="around">Message to fetch around from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordMessage>> GetMessagesAroundAsync(ulong around, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, null, null, around);
 
 	/// <summary>
 	/// Returns a list of messages from the last message in the channel.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordMessage>> GetMessagesAsync(int limit = 100) =>
 		this.GetMessagesInternalAsync(limit, null, null, null);
 
 	/// <summary>
 	/// Returns a list of messages
 	/// </summary>
 	/// <param name="limit">How many messages should be returned.</param>
 	/// <param name="before">Get messages before snowflake.</param>
 	/// <param name="after">Get messages after snowflake.</param>
 	/// <param name="around">Get messages around snowflake.</param>
 	private async Task<IReadOnlyList<DiscordMessage>> GetMessagesInternalAsync(int limit = 100, ulong? before = null, ulong? after = null, ulong? around = null)
 	{
 		if (!this.IsWritable())
 			throw new ArgumentException("Cannot get the messages of a non-text channel.");
 
 		if (limit < 0)
 			throw new ArgumentException("Cannot get a negative number of messages.");
 
 		if (limit == 0)
 			return Array.Empty<DiscordMessage>();
 
 		//return this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, limit, before, after, around);
 		if (limit > 100 && around != null)
 			throw new InvalidOperationException("Cannot get more than 100 messages around the specified ID.");
 
 		var msgs = new List<DiscordMessage>(limit);
 		var remaining = limit;
 		ulong? last = null;
 		var isAfter = after != null;
 
 		int lastCount;
 		do
 		{
 			var fetchSize = remaining > 100 ? 100 : remaining;
 			var fetch = await this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, fetchSize, !isAfter ? last ?? before : null, isAfter ? last ?? after : null, around).ConfigureAwait(false);
 
 			lastCount = fetch.Count;
 			remaining -= lastCount;
 
 			if (!isAfter)
 			{
 				msgs.AddRange(fetch);
 				last = fetch.LastOrDefault()?.Id;
 			}
 			else
 			{
 				msgs.InsertRange(0, fetch);
 				last = fetch.FirstOrDefault()?.Id;
 			}
 		}
 		while (remaining > 0 && lastCount > 0);
 
 		return new ReadOnlyCollection<DiscordMessage>(msgs);
 	}
 
 	/// <summary>
 	/// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="DisCatSharp.Exceptions.BadRequestException"/> error.
 	/// </summary>
 	/// <param name="messages">A collection of messages to delete.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task DeleteMessagesAsync(IEnumerable<DiscordMessage> messages, string reason = null)
 	{
 		// don't enumerate more than once
 		var msgs = messages.Where(x => x.Channel.Id == this.Id).Select(x => x.Id).ToArray();
 		if (messages == null || !msgs.Any())
 			throw new ArgumentException("You need to specify at least one message to delete.");
 
 		if (msgs.Length < 2)
 		{
 			await this.Discord.ApiClient.DeleteMessageAsync(this.Id, msgs.Single(), reason).ConfigureAwait(false);
 			return;
 		}
 
 		for (var i = 0; i < msgs.Length; i += 100)
 			await this.Discord.ApiClient.DeleteMessagesAsync(this.Id, msgs.Skip(i).Take(100), reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a message
 	/// </summary>
 	/// <param name="message">The message to be deleted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteMessageAsync(DiscordMessage message, string reason = null)
 		=> this.Discord.ApiClient.DeleteMessageAsync(this.Id, message.Id, reason);
 
 	/// <summary>
 	/// Returns a list of invite objects
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync() =>
 		this.Guild == null
 			? throw new ArgumentException("Cannot get the invites of a channel that does not belong to a guild.")
 			: this.Discord.ApiClient.GetChannelInvitesAsync(this.Id);
 
 	/// <summary>
 	/// Create a new invite object
 	/// </summary>
 	/// <param name="maxAge">Duration of invite in seconds before expiry, or 0 for never.  Defaults to 86400.</param>
 	/// <param name="maxUses">Max number of uses or 0 for unlimited. Defaults to 0</param>
 	/// <param name="temporary">Whether this invite should be temporary. Defaults to false.</param>
 	/// <param name="unique">Whether this invite should be unique. Defaults to false.</param>
 	/// <param name="targetType">The target type. Defaults to null.</param>
 	/// <param name="targetApplication">The target activity. Defaults to null.</param>
 	/// <param name="targetUser">The target user id. Defaults to null.</param>
 	/// <param name="reason">The audit log reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordInvite> CreateInviteAsync(int maxAge = 86400, int maxUses = 0, bool temporary = false, bool unique = false, TargetType? targetType = null, TargetActivity? targetApplication = null, ulong? targetUser = null, string reason = null)
 		=> this.Discord.ApiClient.CreateChannelInviteAsync(this.Id, maxAge, maxUses, targetType, targetApplication, targetUser, temporary, unique, reason);
 
 	#region Stage
 
 	/// <summary>
 	/// Opens a stage.
 	/// </summary>
 	/// <param name="topic">Topic of the stage.</param>
 	/// <param name="sendStartNotification">Whether @everyone should be notified.</param>
 	/// <param name="privacyLevel">Privacy level of the stage (Defaults to <see cref="StagePrivacyLevel.GuildOnly"/>.</param>
 	/// <param name="reason">Audit log reason.</param>
 	/// <returns>Stage instance</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordStageInstance> OpenStageAsync(string topic, bool sendStartNotification = false, StagePrivacyLevel privacyLevel = StagePrivacyLevel.GuildOnly, string reason = null)
 		=> await this.Discord.ApiClient.CreateStageInstanceAsync(this.Id, topic, sendStartNotification, privacyLevel, reason);
 
 	/// <summary>
 	/// Modifies a stage topic.
 	/// </summary>
 	/// <param name="topic">New topic of the stage.</param>
 	/// <param name="privacyLevel">New privacy level of the stage.</param>
 	/// <param name="reason">Audit log reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task ModifyStageAsync(Optional<string> topic, Optional<StagePrivacyLevel> privacyLevel, string reason = null)
 		=> await this.Discord.ApiClient.ModifyStageInstanceAsync(this.Id, topic, privacyLevel, reason);
 
 	/// <summary>
 	/// Closes a stage.
 	/// </summary>
 	/// <param name="reason">Audit log reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task CloseStageAsync(string reason = null)
 		=> await this.Discord.ApiClient.DeleteStageInstanceAsync(this.Id, reason);
 
 	/// <summary>
 	/// Gets a stage.
 	/// </summary>
 	/// <returns>The requested stage.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or <see cref="Permissions.UseVoice"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordStageInstance> GetStageAsync()
 		=> await this.Discord.ApiClient.GetStageInstanceAsync(this.Id);
 
 	#endregion
 
 	#region Scheduled Events
 
 	/// <summary>
 	/// Creates a scheduled event based on the channel type.
 	/// </summary>
 	/// <param name="name">The name.</param>
 	/// <param name="scheduledStartTime">The scheduled start time.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="coverImage">The cover image.</param>
 	/// <param name="reason">The reason.</param>
 	/// <returns>A scheduled event.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the resource does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordScheduledEvent> CreateScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, string description = null, Optional<Stream> coverImage = default, string reason = null)
 	{
 		if (!this.IsVoiceJoinable())
 			throw new NotSupportedException("Cannot create a scheduled event for this type of channel. Channel type must be either voice or stage.");
 
 		var type = this.Type == ChannelType.Voice ? ScheduledEventEntityType.Voice : ScheduledEventEntityType.StageInstance;
 
 		return await this.Guild.CreateScheduledEventAsync(name, scheduledStartTime, null, this, null, description, type, coverImage, reason);
 	}
 
 	#endregion
 
 	#region Threads
 
 	/// <summary>
 	/// Creates a thread.
 	/// Depending on whether it is created inside an <see cref="ChannelType.News"/> or an <see cref="ChannelType.Text"/> it is either an <see cref="ChannelType.NewsThread"/> or an <see cref="ChannelType.PublicThread"/>.
 	/// Depending on whether the <see cref="ChannelType"/> is set to <see cref="ChannelType.PrivateThread"/> it is either an <see cref="ChannelType.PrivateThread"/> or an <see cref="ChannelType.PublicThread"/> (default).
 	/// </summary>
 	/// <param name="name">The name of the thread.</param>
 	/// <param name="autoArchiveDuration"><see cref="ThreadAutoArchiveDuration"/> till it gets archived. Defaults to <see cref="ThreadAutoArchiveDuration.OneHour"/>.</param>
 	/// <param name="type">Can be either an <see cref="ChannelType.PrivateThread"/>, <see cref="ChannelType.NewsThread"/> or an <see cref="ChannelType.PublicThread"/>.</param>
 	/// <param name="rateLimitPerUser">The per user ratelimit, aka slowdown.</param>
 	/// <param name="reason">Audit log reason.</param>
 	/// <returns>The created thread.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePublicThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> or if creating a private thread the <see cref="Permissions.CreatePrivateThreads"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild hasn't enabled threads atm.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>. Or if <see cref="GuildFeatures.CanCreatePrivateThreads"/> is not enabled for guild. This happens, if the guild does not have <see cref="PremiumTier.TierTwo"/></exception>
 	public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, ChannelType type = ChannelType.PublicThread, int? rateLimitPerUser = null, string reason = null) =>
 		type != ChannelType.NewsThread && type != ChannelType.PublicThread && type != ChannelType.PrivateThread
 			? throw new NotSupportedException("Wrong thread type given.")
 			: !this.IsThreadHolder()
 				? throw new NotSupportedException("Parent channel can't have threads.")
 				: type == ChannelType.PrivateThread
 					? Utilities.CheckThreadPrivateFeature(this.Guild)
 						? Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, autoArchiveDuration)
 							? await this.Discord.ApiClient.CreateThreadAsync(this.Id, null, name, autoArchiveDuration, type, rateLimitPerUser, reason)
 							: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.")
 						: throw new NotSupportedException($"Cannot create a private thread. Guild needs to be boost tier two.")
 					: Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, autoArchiveDuration)
 						? await this.Discord.ApiClient.CreateThreadAsync(this.Id, null, name, autoArchiveDuration, this.Type == ChannelType.News ? ChannelType.NewsThread : ChannelType.PublicThread, rateLimitPerUser, reason)
 						: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 
 	/// <summary>
 	/// Gets joined archived private threads. Can contain more threads.
 	/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 	/// </summary>
 	/// <param name="before">Get threads created before this thread id.</param>
 	/// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadResult> GetJoinedPrivateArchivedThreadsAsync(ulong? before, int? limit)
 		=> await this.Discord.ApiClient.GetJoinedPrivateArchivedThreadsAsync(this.Id, before, limit);
 
 	/// <summary>
 	/// Gets archived public threads. Can contain more threads.
 	/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 	/// </summary>
 	/// <param name="before">Get threads created before this thread id.</param>
 	/// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadResult> GetPublicArchivedThreadsAsync(ulong? before, int? limit)
 		=> await this.Discord.ApiClient.GetPublicArchivedThreadsAsync(this.Id, before, limit);
 
 	/// <summary>
 	/// Gets archived private threads. Can contain more threads.
 	/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 	/// </summary>
 	/// <param name="before">Get threads created before this thread id.</param>
 	/// <param name="limit">Defines the limit of returned <see cref="DiscordThreadResult"/>.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> or <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordThreadResult> GetPrivateArchivedThreadsAsync(ulong? before, int? limit)
 		=> await this.Discord.ApiClient.GetPrivateArchivedThreadsAsync(this.Id, before, limit);
 
   /// <summary>
   /// Gets a forum channel tag.
   /// </summary>
   /// <param name="id">The id of the tag to get.</param>
   /// <exception cref="NotImplementedException">This method is currently not implemented.</exception>
   public async Task<ForumPostTag> GetForumPostTagAsync(ulong id)
     => throw new NotImplementedException();
 
   /// <summary>
   /// Gets a list of forum channel tags.
   /// </summary>
   /// <exception cref="NotImplementedException">This method is currently not implemented.</exception>
   public async Task<List<ForumPostTag>> GetForumPostTagsAsync()
     => throw new NotImplementedException();
 
 	#endregion
 
 	/// <summary>
 	/// Adds a channel permission overwrite for specified role.
 	/// </summary>
 	/// <param name="role">The role to have the permission added.</param>
 	/// <param name="allow">The permissions to allow.</param>
 	/// <param name="deny">The permissions to deny.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddOverwriteAsync(DiscordRole role, Permissions allow = Permissions.None, Permissions deny = Permissions.None, string reason = null)
 		=> this.Discord.ApiClient.EditChannelPermissionsAsync(this.Id, role.Id, allow, deny, "role", reason);
 
 
 	/// <summary>
 	/// Adds a channel permission overwrite for specified member.
 	/// </summary>
 	/// <param name="member">The member to have the permission added.</param>
 	/// <param name="allow">The permissions to allow.</param>
 	/// <param name="deny">The permissions to deny.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddOverwriteAsync(DiscordMember member, Permissions allow = Permissions.None, Permissions deny = Permissions.None, string reason = null)
 		=> this.Discord.ApiClient.EditChannelPermissionsAsync(this.Id, member.Id, allow, deny, "member", reason);
 
 	/// <summary>
 	/// Deletes a channel permission overwrite for specified member.
 	/// </summary>
 	/// <param name="member">The member to have the permission deleted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteOverwriteAsync(DiscordMember member, string reason = null)
 		=> this.Discord.ApiClient.DeleteChannelPermissionAsync(this.Id, member.Id, reason);
 
 	/// <summary>
 	/// Deletes a channel permission overwrite for specified role.
 	/// </summary>
 	/// <param name="role">The role to have the permission deleted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteOverwriteAsync(DiscordRole role, string reason = null)
 		=> this.Discord.ApiClient.DeleteChannelPermissionAsync(this.Id, role.Id, reason);
 
 	/// <summary>
 	/// Post a typing indicator.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task TriggerTypingAsync() =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot start typing in a non-text channel.")
 			: this.Discord.ApiClient.TriggerTypingAsync(this.Id);
 
 	/// <summary>
 	/// Returns all pinned messages.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync() =>
 		!this.IsWritable()
 			? throw new ArgumentException("A non-text channel does not have pinned messages.")
 			: this.Discord.ApiClient.GetPinnedMessagesAsync(this.Id);
 
 	/// <summary>
 	/// Create a new webhook.
 	/// </summary>
 	/// <param name="name">The name of the webhook.</param>
 	/// <param name="avatar">The image for the default webhook avatar.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordWebhook> CreateWebhookAsync(string name, Optional<Stream> avatar = default, string reason = null)
 	{
 		var av64 = ImageTool.Base64FromStream(avatar);
 		return await this.Discord.ApiClient.CreateWebhookAsync(this.Id, name, av64, reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Returns a list of webhooks.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
 		=> this.Discord.ApiClient.GetChannelWebhooksAsync(this.Id);
 
 	/// <summary>
 	/// Moves a member to this voice channel.
 	/// </summary>
 	/// <param name="member">The member to be moved.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the channel does not exists or if the Member does not exists.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task PlaceMemberAsync(DiscordMember member)
 	{
 		if (!this.IsVoiceJoinable())
 			throw new ArgumentException("Cannot place a member in a non-voice channel.");
 
 		await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, member.Id, default, default, default,
 			default, this.Id, null).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Follows a news channel.
 	/// </summary>
 	/// <param name="targetChannel">Channel to crosspost messages to.</param>
 	/// <exception cref="System.ArgumentException">Thrown when trying to follow a non-news channel.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the current user doesn't have <see cref="Permissions.ManageWebhooks"/> on the target channel.</exception>
 	public Task<DiscordFollowedChannel> FollowAsync(DiscordChannel targetChannel) =>
 		this.Type != ChannelType.News
 			? throw new ArgumentException("Cannot follow a non-news channel.")
 			: this.Discord.ApiClient.FollowChannelAsync(this.Id, targetChannel.Id);
 
 	/// <summary>
 	/// Publishes a message in a news channel to following channels.
 	/// </summary>
 	/// <param name="message">Message to publish.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the message has already been crossposted.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">
 	///     Thrown when the current user doesn't have <see cref="Permissions.ManageWebhooks"/> and/or <see cref="Permissions.SendMessages"/>
 	/// </exception>
 	public Task<DiscordMessage> CrosspostMessageAsync(DiscordMessage message) =>
 		(message.Flags & MessageFlags.Crossposted) == MessageFlags.Crossposted
 			? throw new ArgumentException("Message is already crossposted.")
 			: this.Discord.ApiClient.CrosspostMessageAsync(this.Id, message.Id);
 
 	/// <summary>
 	/// Updates the current user's suppress state in this channel, if stage channel.
 	/// </summary>
 	/// <param name="suppress">Toggles the suppress state.</param>
 	/// <param name="requestToSpeakTimestamp">Sets the time the user requested to speak.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the channel is not a stage channel.</exception>
 	public async Task UpdateCurrentUserVoiceStateAsync(bool? suppress, DateTimeOffset? requestToSpeakTimestamp = null)
 	{
 		if (this.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated in a stage channel.");
 
 		await this.Discord.ApiClient.UpdateCurrentUserVoiceStateAsync(this.GuildId.Value, this.Id, suppress, requestToSpeakTimestamp).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Calculates permissions for a given member.
 	/// </summary>
 	/// <param name="mbr">Member to calculate permissions for.</param>
 	/// <returns>Calculated permissions for a given member.</returns>
 	public Permissions PermissionsFor(DiscordMember mbr)
 	{
 		// user > role > everyone
 		// allow > deny > undefined
 		// =>
 		// user allow > user deny > role allow > role deny > everyone allow > everyone deny
 
 		if (this.IsPrivate || this.Guild == null)
 			return Permissions.None;
 
 		if (this.Guild.OwnerId == mbr.Id)
 			return PermissionMethods.FullPerms;
 
 		Permissions perms;
 
 		// assign @everyone permissions
 		var everyoneRole = this.Guild.EveryoneRole;
 		perms = everyoneRole.Permissions;
 
 		// roles that member is in
 		var mbRoles = mbr.Roles.Where(xr => xr.Id != everyoneRole.Id);
 
 		// assign permissions from member's roles (in order)
 		perms |= mbRoles.Aggregate(Permissions.None, (c, role) => c | role.Permissions);
 
 		// Administrator grants all permissions and cannot be overridden
 		if ((perms & Permissions.Administrator) == Permissions.Administrator)
 			return PermissionMethods.FullPerms;
 
 		// channel overrides for roles that member is in
 		var mbRoleOverrides = mbRoles
 			.Select(xr => this.PermissionOverwritesInternal.FirstOrDefault(xo => xo.Id == xr.Id))
 			.Where(xo => xo != null)
 			.ToList();
 
 		// assign channel permission overwrites for @everyone pseudo-role
 		var everyoneOverwrites = this.PermissionOverwritesInternal.FirstOrDefault(xo => xo.Id == everyoneRole.Id);
 		if (everyoneOverwrites != null)
 		{
 			perms &= ~everyoneOverwrites.Denied;
 			perms |= everyoneOverwrites.Allowed;
 		}
 
 		// assign channel permission overwrites for member's roles (explicit deny)
 		perms &= ~mbRoleOverrides.Aggregate(Permissions.None, (c, overs) => c | overs.Denied);
 		// assign channel permission overwrites for member's roles (explicit allow)
 		perms |= mbRoleOverrides.Aggregate(Permissions.None, (c, overs) => c | overs.Allowed);
 
 		// channel overrides for just this member
 		var mbOverrides = this.PermissionOverwritesInternal.FirstOrDefault(xo => xo.Id == mbr.Id);
 		if (mbOverrides == null) return perms;
 
 		// assign channel permission overwrites for just this member
 		perms &= ~mbOverrides.Denied;
 		perms |= mbOverrides.Allowed;
 
 		return perms;
 	}
 
 	/// <summary>
 	/// Returns a string representation of this channel.
 	/// </summary>
 	/// <returns>String representation of this channel.</returns>
 	public override string ToString() =>
 		this.Type == ChannelType.Category
 			? $"Channel Category {this.Name} ({this.Id})"
 			: this.Type == ChannelType.Text || this.Type == ChannelType.News || this.IsThread()
 				? $"Channel #{this.Name} ({this.Id})"
 				: this.IsVoiceJoinable()
 					? $"Channel #!{this.Name} ({this.Id})"
 					: !string.IsNullOrWhiteSpace(this.Name) ? $"Channel {this.Name} ({this.Id})" : $"Channel {this.Id}";
 
 	#endregion
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordChannel"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordChannel"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordChannel);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordChannel"/> is equal to another <see cref="DiscordChannel"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordChannel"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordChannel"/> is equal to this <see cref="DiscordChannel"/>.</returns>
 	public bool Equals(DiscordChannel e)
 		=> e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordChannel"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordChannel"/>.</returns>
 	public override int GetHashCode()
 		=> this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordChannel"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First channel to compare.</param>
 	/// <param name="e2">Second channel to compare.</param>
 	/// <returns>Whether the two channels are equal.</returns>
 	public static bool operator ==(DiscordChannel e1, DiscordChannel e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordChannel"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First channel to compare.</param>
 	/// <param name="e2">Second channel to compare.</param>
 	/// <returns>Whether the two channels are not equal.</returns>
 	public static bool operator !=(DiscordChannel e1, DiscordChannel e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs b/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs
index d42d9a1ba..71c61516d 100644
--- a/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs
+++ b/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwrite.cs
@@ -1,121 +1,123 @@
 // 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.Threading.Tasks;
 
+using DisCatSharp.Enums;
+
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a permission overwrite for a channel.
 /// </summary>
 public class DiscordOverwrite : SnowflakeObject
 {
 	/// <summary>
 	/// Gets the type of the overwrite. Either "role" or "member".
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public OverwriteType Type { get; internal set; }
 
 	/// <summary>
 	/// Gets the allowed permission set.
 	/// </summary>
 	[JsonProperty("allow", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions Allowed { get; internal set; }
 
 	/// <summary>
 	/// Gets the denied permission set.
 	/// </summary>
 	[JsonProperty("deny", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions Denied { get; internal set; }
 
 	[JsonIgnore]
 	internal ulong ChannelId;
 
 	#region Methods
 	/// <summary>
 	/// Deletes this channel overwrite.
 	/// </summary>
 	/// <param name="reason">Reason as to why this overwrite gets deleted.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the overwrite does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAsync(string reason = null) => this.Discord.ApiClient.DeleteChannelPermissionAsync(this.ChannelId, this.Id, reason);
 
 	/// <summary>
 	/// Updates this channel overwrite.
 	/// </summary>
 	/// <param name="allow">Permissions that are allowed.</param>
 	/// <param name="deny">Permissions that are denied.</param>
 	/// <param name="reason">Reason as to why you made this change.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the overwrite does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UpdateAsync(Permissions? allow = null, Permissions? deny = null, string reason = null)
 		=> this.Discord.ApiClient.EditChannelPermissionsAsync(this.ChannelId, this.Id, allow ?? this.Allowed, deny ?? this.Denied, this.Type.ToString().ToLowerInvariant(), reason);
 
 	/// <summary>
 	/// Gets the DiscordMember that is affected by this overwrite.
 	/// </summary>
 	/// <returns>The DiscordMember that is affected by this overwrite</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the overwrite does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMember> GetMemberAsync() =>
 		this.Type != OverwriteType.Member
 			? throw new ArgumentException(nameof(this.Type), "This overwrite is for a role, not a member.")
 			: await (await this.Discord.ApiClient.GetChannelAsync(this.ChannelId).ConfigureAwait(false)).Guild.GetMemberAsync(this.Id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Gets the DiscordRole that is affected by this overwrite.
 	/// </summary>
 	/// <returns>The DiscordRole that is affected by this overwrite</returns>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordRole> GetRoleAsync() =>
 		this.Type != OverwriteType.Role
 			? throw new ArgumentException(nameof(this.Type), "This overwrite is for a member, not a role.")
 			: (await this.Discord.ApiClient.GetChannelAsync(this.ChannelId).ConfigureAwait(false)).Guild.GetRole(this.Id);
 	#endregion
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordOverwrite"/> class.
 	/// </summary>
 	internal DiscordOverwrite()
 	{ }
 
 	/// <summary>
 	/// Checks whether given permissions are allowed, denied, or not set.
 	/// </summary>
 	/// <param name="permission">Permissions to check.</param>
 	/// <returns>Whether given permissions are allowed, denied, or not set.</returns>
 	public PermissionLevel CheckPermission(Permissions permission) =>
 		(this.Allowed & permission) != 0
 			? PermissionLevel.Allowed
 			: (this.Denied & permission) != 0 ? PermissionLevel.Denied : PermissionLevel.Unset;
 }
diff --git a/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwriteBuilder.cs b/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwriteBuilder.cs
index 163954b38..f3ab04ca2 100644
--- a/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwriteBuilder.cs
+++ b/DisCatSharp/Entities/Channel/Overwrite/DiscordOverwriteBuilder.cs
@@ -1,178 +1,180 @@
 // 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.Threading.Tasks;
 
+using DisCatSharp.Enums;
+
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord permission overwrite builder.
 /// </summary>
 public sealed class DiscordOverwriteBuilder
 {
 	/// <summary>
 	/// Gets or sets the allowed permissions for this overwrite.
 	/// </summary>
 	public Permissions Allowed { get; set; }
 
 	/// <summary>
 	/// Gets or sets the denied permissions for this overwrite.
 	/// </summary>
 	public Permissions Denied { get; set; }
 
 	/// <summary>
 	/// Gets the type of this overwrite's target.
 	/// </summary>
 	public OverwriteType Type { get; private set; }
 
 	/// <summary>
 	/// Gets the target for this overwrite.
 	/// </summary>
 	public SnowflakeObject Target { get; private set; }
 
 	/// <summary>
 	/// Creates a new Discord permission overwrite builder for a member. This class can be used to construct permission overwrites for guild channels, used when creating channels.
 	/// </summary>
 	public DiscordOverwriteBuilder(DiscordMember member)
 	{
 		this.Target = member;
 		this.Type = OverwriteType.Member;
 	}
 
 	/// <summary>
 	/// Creates a new Discord permission overwrite builder for a role. This class can be used to construct permission overwrites for guild channels, used when creating channels.
 	/// </summary>
 	public DiscordOverwriteBuilder(DiscordRole role)
 	{
 		this.Target = role;
 		this.Type = OverwriteType.Role;
 	}
 
 	/// <summary>
 	/// Creates a new Discord permission overwrite builder. This class can be used to construct permission overwrites for guild channels, used when creating channels.
 	/// </summary>
 	public DiscordOverwriteBuilder()
 	{ }
 
 	/// <summary>
 	/// Allows a permission for this overwrite.
 	/// </summary>
 	/// <param name="permission">Permission or permission set to allow for this overwrite.</param>
 	/// <returns>This builder.</returns>
 	public DiscordOverwriteBuilder Allow(Permissions permission)
 	{
 		this.Allowed |= permission;
 		return this;
 	}
 
 	/// <summary>
 	/// Denies a permission for this overwrite.
 	/// </summary>
 	/// <param name="permission">Permission or permission set to deny for this overwrite.</param>
 	/// <returns>This builder.</returns>
 	public DiscordOverwriteBuilder Deny(Permissions permission)
 	{
 		this.Denied |= permission;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the member to which this overwrite applies.
 	/// </summary>
 	/// <param name="member">Member to which apply this overwrite's permissions.</param>
 	/// <returns>This builder.</returns>
 	public DiscordOverwriteBuilder For(DiscordMember member)
 	{
 		this.Target = member;
 		this.Type = OverwriteType.Member;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the role to which this overwrite applies.
 	/// </summary>
 	/// <param name="role">Role to which apply this overwrite's permissions.</param>
 	/// <returns>This builder.</returns>
 	public DiscordOverwriteBuilder For(DiscordRole role)
 	{
 		this.Target = role;
 		this.Type = OverwriteType.Role;
 		return this;
 	}
 
 	/// <summary>
 	/// Populates this builder with data from another overwrite object.
 	/// </summary>
 	/// <param name="other">Overwrite from which data will be used.</param>
 	/// <returns>This builder.</returns>
 	public async Task<DiscordOverwriteBuilder> FromAsync(DiscordOverwrite other)
 	{
 		this.Allowed = other.Allowed;
 		this.Denied = other.Denied;
 		this.Type = other.Type;
 		this.Target = this.Type == OverwriteType.Member ? await other.GetMemberAsync().ConfigureAwait(false) as SnowflakeObject : await other.GetRoleAsync().ConfigureAwait(false) as SnowflakeObject;
 
 		return this;
 	}
 
 	/// <summary>
 	/// Builds this DiscordOverwrite.
 	/// </summary>
 	/// <returns>Use this object for creation of new overwrites.</returns>
 	internal DiscordRestOverwrite Build() =>
 		new()
 		{
 			Allow = this.Allowed,
 			Deny = this.Denied,
 			Id = this.Target.Id,
 			Type = this.Type,
 		};
 }
 
 internal struct DiscordRestOverwrite
 {
 	/// <summary>
 	/// Determines what is allowed.
 	/// </summary>
 	[JsonProperty("allow", NullValueHandling = NullValueHandling.Ignore)]
 	internal Permissions Allow { get; set; }
 
 	/// <summary>
 	/// Determines what is denied.
 	/// </summary>
 	[JsonProperty("deny", NullValueHandling = NullValueHandling.Ignore)]
 	internal Permissions Deny { get; set; }
 
 	/// <summary>
 	/// Gets or sets the id.
 	/// </summary>
 	[JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
 	internal ulong Id { get; set; }
 
 	/// <summary>
 	/// Gets or sets the overwrite type.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	internal OverwriteType Type { get; set; }
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordAuditLogObjects.cs b/DisCatSharp/Entities/Guild/DiscordAuditLogObjects.cs
index d516304e0..b316a2685 100644
--- a/DisCatSharp/Entities/Guild/DiscordAuditLogObjects.cs
+++ b/DisCatSharp/Entities/Guild/DiscordAuditLogObjects.cs
@@ -1,1149 +1,866 @@
 // 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 DisCatSharp.Enums;
+
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents an audit log entry.
 /// </summary>
 public abstract class DiscordAuditLogEntry : SnowflakeObject
 {
 	/// <summary>
 	/// Gets the entry's action type.
 	/// </summary>
 	public AuditLogActionType ActionType { get; internal set; }
 
 	/// <summary>
 	/// Gets the user responsible for the action.
 	/// </summary>
 	public DiscordUser UserResponsible { get; internal set; }
 
 	/// <summary>
 	/// Gets the reason defined in the action.
 	/// </summary>
 	public string Reason { get; internal set; }
 
 	/// <summary>
 	/// Gets the category under which the action falls.
 	/// </summary>
 	public AuditLogActionCategory ActionCategory { get; internal set; }
 }
 
 /// <summary>
 /// Represents a description of how a property changed.
 /// </summary>
 /// <typeparam name="T">Type of the changed property.</typeparam>
 public sealed class PropertyChange<T>
 {
 	/// <summary>
 	/// The property's value before it was changed.
 	/// </summary>
 	public T Before { get; internal set; }
 
 	/// <summary>
 	/// The property's value after it was changed.
 	/// </summary>
 	public T After { get; internal set; }
 }
 
 /// <summary>
 /// Represents a audit log guild entry.
 /// </summary>
 public sealed class DiscordAuditLogGuildEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected guild.
 	/// </summary>
 	public DiscordGuild Target { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.Name"/>
 	/// </summary>
 	public PropertyChange<string> NameChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.Owner"/>
 	/// </summary>
 	public PropertyChange<DiscordMember> OwnerChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.IconUrl"/>
 	/// </summary>
 	public PropertyChange<string> IconChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.VerificationLevel"/>
 	/// </summary>
 	public PropertyChange<VerificationLevel> VerificationLevelChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.AfkChannel"/>
 	/// </summary>
 	public PropertyChange<DiscordChannel> AfkChannelChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.SystemChannelFlags"/>
 	/// </summary>
 	public PropertyChange<SystemChannelFlags> SystemChannelFlagsChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.WidgetChannel"/>
 	/// </summary>
 	public PropertyChange<DiscordChannel> WidgetChannelChange { get; internal set; }
 
 	[Obsolete("Use properly named WidgetChannelChange")]
 	public PropertyChange<DiscordChannel> EmbedChannelChange => this.WidgetChannelChange;
 
 	/// <summary>
 	/// <see cref="DiscordGuild.RulesChannel"/>
 	/// </summary>
 	public PropertyChange<DiscordChannel> RulesChannelChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.PublicUpdatesChannel"/>
 	/// </summary>
 	public PropertyChange<DiscordChannel> PublicUpdatesChannelChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.DefaultMessageNotifications"/>
 	/// </summary>
 	public PropertyChange<DefaultMessageNotifications> NotificationSettingsChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.SystemChannel"/>
 	/// </summary>
 	public PropertyChange<DiscordChannel> SystemChannelChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.ExplicitContentFilter"/>
 	/// </summary>
 	public PropertyChange<ExplicitContentFilter> ExplicitContentFilterChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.MfaLevel"/>
 	/// </summary>
 	public PropertyChange<MfaLevel> MfaLevelChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.SplashUrl"/>
 	/// </summary>
 	public PropertyChange<string> SplashChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.VoiceRegion"/>
 	/// </summary>
 	public PropertyChange<string> RegionChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.VanityUrlCode"/>
 	/// </summary>
 	public PropertyChange<string> VanityUrlCodeChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordGuild.PremiumProgressBarEnabled"/>
 	/// </summary>
 	public PropertyChange<bool> PremiumProgressBarChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogGuildEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogGuildEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log channel entry.
 /// </summary>
 public sealed class DiscordAuditLogChannelEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected channel.
 	/// </summary>
 	public DiscordChannel Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of channel's name change.
 	/// </summary>
 	public PropertyChange<string> NameChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of channel's type change.
 	/// </summary>
 	public PropertyChange<ChannelType?> TypeChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of channel's nsfw flag change.
 	/// </summary>
 	public PropertyChange<bool?> NsfwChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordChannel.RtcRegionId"/>
 	/// </summary>
 	public PropertyChange<string> RtcRegionIdChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of channel's bitrate change.
 	/// </summary>
 	public PropertyChange<int?> BitrateChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of channel permission overwrites' change.
 	/// </summary>
 	public PropertyChange<IReadOnlyList<DiscordOverwrite>> OverwriteChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of channel's topic change.
 	/// </summary>
 	public PropertyChange<string> TopicChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordChannel.UserLimit"/>
 	/// </summary>
 	public PropertyChange<int?> UserLimitChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of channel's slow mode timeout change.
 	/// </summary>
 	public PropertyChange<int?> PerUserRateLimitChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the channel flags change.
 	/// </summary>
 	public PropertyChange<ChannelFlags> ChannelFlagsChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordChannel.DefaultAutoArchiveDuration"/>
 	/// </summary>
 	public PropertyChange<ThreadAutoArchiveDuration?> DefaultAutoArchiveDurationChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogChannelEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogChannelEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log overwrite entry.
 /// </summary>
 public sealed class DiscordAuditLogOverwriteEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected overwrite.
 	/// </summary>
 	public DiscordOverwrite Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the channel for which the overwrite was changed.
 	/// </summary>
 	public DiscordChannel Channel { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of overwrite's allow value change.
 	/// </summary>
 	public PropertyChange<Permissions?> AllowChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of overwrite's deny value change.
 	/// </summary>
 	public PropertyChange<Permissions?> DenyChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of overwrite's type change.
 	/// </summary>
 	public PropertyChange<OverwriteType?> TypeChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of overwrite's target id change.
 	/// </summary>
 	public PropertyChange<ulong?> TargetIdChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogOverwriteEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogOverwriteEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log kick entry.
 /// </summary>
 public sealed class DiscordAuditLogKickEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the kicked member.
 	/// </summary>
 	public DiscordMember Target { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogKickEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogKickEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log prune entry.
 /// </summary>
 public sealed class DiscordAuditLogPruneEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the number inactivity days after which members were pruned.
 	/// </summary>
 	public int Days { get; internal set; }
 
 	/// <summary>
 	/// Gets the number of members pruned.
 	/// </summary>
 	public int Toll { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogPruneEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogPruneEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log ban entry.
 /// </summary>
 public sealed class DiscordAuditLogBanEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the banned member.
 	/// </summary>
 	public DiscordMember Target { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogBanEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogBanEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log member update entry.
 /// </summary>
 public sealed class DiscordAuditLogMemberUpdateEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected member.
 	/// </summary>
 	public DiscordMember Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of member's nickname change.
 	/// </summary>
 	public PropertyChange<string> NicknameChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the roles that were removed from the member.
 	/// </summary>
 	public IReadOnlyList<DiscordRole> RemovedRoles { get; internal set; }
 
 	/// <summary>
 	/// Gets the roles that were added to the member.
 	/// </summary>
 	public IReadOnlyList<DiscordRole> AddedRoles { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of member's mute status change.
 	/// </summary>
 	public PropertyChange<bool?> MuteChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of member's deaf status change.
 	/// </summary>
 	public PropertyChange<bool?> DeafenChange { get; internal set; }
 
 	/// <summary>
 	/// Get's the timeout change.
 	/// </summary>
 	public PropertyChange<DateTime?> CommunicationDisabledUntilChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogMemberUpdateEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogMemberUpdateEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log role update entry.
 /// </summary>
 public sealed class DiscordAuditLogRoleUpdateEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected role.
 	/// </summary>
 	public DiscordRole Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of role's name change.
 	/// </summary>
 	public PropertyChange<string> NameChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of role's color change.
 	/// </summary>
 	public PropertyChange<int?> ColorChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of role's permission set change.
 	/// </summary>
 	public PropertyChange<Permissions?> PermissionChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of the role's position change.
 	/// </summary>
 	public PropertyChange<int?> PositionChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of the role's mentionability change.
 	/// </summary>
 	public PropertyChange<bool?> MentionableChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of the role's hoist status change.
 	/// </summary>
 	public PropertyChange<bool?> HoistChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordRole.IconHash"/>
 	/// </summary>
 	public PropertyChange<string> IconHashChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogRoleUpdateEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogRoleUpdateEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log invite entry.
 /// </summary>
 public sealed class DiscordAuditLogInviteEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected invite.
 	/// </summary>
 	public DiscordInvite Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of invite's max age change.
 	/// </summary>
 	public PropertyChange<int?> MaxAgeChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of invite's code change.
 	/// </summary>
 	public PropertyChange<string> CodeChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of invite's temporariness change.
 	/// </summary>
 	public PropertyChange<bool?> TemporaryChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of invite's inviting member change.
 	/// </summary>
 	public PropertyChange<DiscordMember> InviterChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of invite's target channel change.
 	/// </summary>
 	public PropertyChange<DiscordChannel> ChannelChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of invite's use count change.
 	/// </summary>
 	public PropertyChange<int?> UsesChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of invite's max use count change.
 	/// </summary>
 	public PropertyChange<int?> MaxUsesChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogInviteEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogInviteEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log webhook entry.
 /// </summary>
 public sealed class DiscordAuditLogWebhookEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected webhook.
 	/// </summary>
 	public DiscordWebhook Target { get; internal set; }
 
 	/// <summary>
 	/// Undocumented.
 	/// </summary>
 	public PropertyChange<ulong?> IdChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of webhook's name change.
 	/// </summary>
 	public PropertyChange<string> NameChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of webhook's target channel change.
 	/// </summary>
 	public PropertyChange<DiscordChannel> ChannelChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of webhook's type change.
 	/// </summary>
 	public PropertyChange<int?> TypeChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of webhook's avatar change.
 	/// </summary>
 	public PropertyChange<string> AvatarHashChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogWebhookEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogWebhookEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log emoji entry.
 /// </summary>
 public sealed class DiscordAuditLogEmojiEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected emoji.
 	/// </summary>
 	public DiscordEmoji Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of emoji's name change.
 	/// </summary>
 	public PropertyChange<string> NameChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogEmojiEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogEmojiEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log sticker entry.
 /// </summary>
 public sealed class DiscordAuditLogStickerEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected sticker.
 	/// </summary>
 	public DiscordSticker Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of sticker's name change.
 	/// </summary>
 	public PropertyChange<string> NameChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of sticker's description change.
 	/// </summary>
 	public PropertyChange<string> DescriptionChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of sticker's tags change.
 	/// </summary>
 	public PropertyChange<string> TagsChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of sticker's tags change.
 	/// </summary>
 	public PropertyChange<string> AssetChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of sticker's guild id change.
 	/// </summary>
 	public PropertyChange<ulong?> GuildIdChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of sticker's availability change.
 	/// </summary>
 	public PropertyChange<bool?> AvailabilityChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of sticker's id change.
 	/// </summary>
 	public PropertyChange<ulong?> IdChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of sticker's type change.
 	/// </summary>
 	public PropertyChange<StickerType?> TypeChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of sticker's format change.
 	/// </summary>
 	public PropertyChange<StickerFormat?> FormatChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogStickerEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogStickerEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log message entry.
 /// </summary>
 public sealed class DiscordAuditLogMessageEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected message. Note that more often than not, this will only have ID specified.
 	/// </summary>
 	public DiscordMessage Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the channel in which the action occurred.
 	/// </summary>
 	public DiscordChannel Channel { get; internal set; }
 
 	/// <summary>
 	/// Gets the number of messages that were affected.
 	/// </summary>
 	public int? MessageCount { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogMessageEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogMessageEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log message pin entry.
 /// </summary>
 public sealed class DiscordAuditLogMessagePinEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected message's user.
 	/// </summary>
 	public DiscordUser Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the channel the message is in.
 	/// </summary>
 	public DiscordChannel Channel { get; internal set; }
 
 	/// <summary>
 	/// Gets the message the pin action was for.
 	/// </summary>
 	public DiscordMessage Message { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogMessagePinEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogMessagePinEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log bot add entry.
 /// </summary>
 public sealed class DiscordAuditLogBotAddEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the bot that has been added to the guild.
 	/// </summary>
 	public DiscordUser TargetBot { get; internal set; }
 }
 
 /// <summary>
 /// Represents a audit log member move entry.
 /// </summary>
 public sealed class DiscordAuditLogMemberMoveEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the channel the members were moved in.
 	/// </summary>
 	public DiscordChannel Channel { get; internal set; }
 
 	/// <summary>
 	/// Gets the amount of users that were moved out from the voice channel.
 	/// </summary>
 	public int UserCount { get; internal set; }
 }
 
 /// <summary>
 /// Represents a audit log member disconnect entry.
 /// </summary>
 public sealed class DiscordAuditLogMemberDisconnectEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the amount of users that were disconnected from the voice channel.
 	/// </summary>
 	public int UserCount { get; internal set; }
 }
 
 /// <summary>
 /// Represents a audit log integration entry.
 /// </summary>
 public sealed class DiscordAuditLogIntegrationEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// The type of integration.
 	/// </summary>
 	public PropertyChange<string> Type { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of emoticons' change.
 	/// </summary>
 	public PropertyChange<bool?> EnableEmoticons { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of expire grace period's change.
 	/// </summary>
 	public PropertyChange<int?> ExpireGracePeriod { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of expire behavior change.
 	/// </summary>
 	public PropertyChange<int?> ExpireBehavior { get; internal set; }
 }
 
 /// <summary>
 /// Represents a audit log stage entry.
 /// </summary>
 public sealed class DiscordAuditLogStageEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected stage instance
 	/// </summary>
 	public DiscordStageInstance Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of stage instance's topic change.
 	/// </summary>
 	public PropertyChange<string> TopicChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description of stage instance's privacy level change.
 	/// </summary>
 	public PropertyChange<StagePrivacyLevel?> PrivacyLevelChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogStageEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogStageEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log event entry.
 /// </summary>
 public sealed class DiscordAuditLogGuildScheduledEventEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected event
 	/// </summary>
 	public DiscordScheduledEvent Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the channel change.
 	/// </summary>
 	public PropertyChange<ulong?> ChannelIdChange { get; internal set; }
 
 	/// <summary>
 	/// <see cref="DiscordScheduledEvent.Name"/>
 	/// </summary>
 	public PropertyChange<string> NameChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the description change.
 	/// </summary>
 	public PropertyChange<string> DescriptionChange { get; internal set; }
 
 	/* Will be added https://github.com/discord/discord-api-docs/pull/3586#issuecomment-969137241
         public PropertyChange<> ScheduledStartTimeChange { get; internal set; }
 
         public PropertyChange<> ScheduledEndTimeChange { get; internal set; }
         */
 
 	/// <summary>
 	/// Gets the location change.
 	/// </summary>
 	public PropertyChange<string> LocationChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the privacy level change.
 	/// </summary>
 	public PropertyChange<ScheduledEventPrivacyLevel?> PrivacyLevelChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the status change.
 	/// </summary>
 	public PropertyChange<ScheduledEventStatus?> StatusChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the entity type change.
 	/// </summary>
 	public PropertyChange<ScheduledEventEntityType?> EntityTypeChange { get; internal set; }
 
 	/*/// <summary>
         /// Gets the sku ids change.
         /// </summary>
         public PropertyChange<IReadOnlyList<ulong>> SkuIdsChange { get; internal set; }*/
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogGuildScheduledEventEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogGuildScheduledEventEntry() { }
 }
 
 /// <summary>
 /// Represents a audit log thread entry.
 /// </summary>
 public sealed class DiscordAuditLogThreadEntry : DiscordAuditLogEntry
 {
 	/// <summary>
 	/// Gets the affected thread
 	/// </summary>
 	public DiscordThreadChannel Target { get; internal set; }
 
 	/// <summary>
 	/// Gets the name of the thread.
 	/// </summary>
 	public PropertyChange<string> NameChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of the thread.
 	/// </summary>
 	public PropertyChange<ChannelType?> TypeChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the archived state of the thread.
 	/// </summary>
 	public PropertyChange<bool?> ArchivedChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the locked state of the thread.
 	/// </summary>
 	public PropertyChange<bool?> LockedChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the invitable state of the thread.
 	/// </summary>
 	public PropertyChange<bool?> InvitableChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the new auto archive duration of the thread.
 	/// </summary>
 	public PropertyChange<ThreadAutoArchiveDuration?> AutoArchiveDurationChange { get; internal set; }
 
 	/// <summary>
 	/// Gets the new ratelimit of the thread.
 	/// </summary>
 	public PropertyChange<int?> PerUserRateLimitChange { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordAuditLogThreadEntry"/> class.
 	/// </summary>
 	internal DiscordAuditLogThreadEntry() { }
 }
-
-/// <summary>
-/// Indicates audit log action category.
-/// </summary>
-public enum AuditLogActionCategory
-{
-	/// <summary>
-	/// Indicates that this action resulted in creation or addition of an object.
-	/// </summary>
-	Create,
-
-	/// <summary>
-	/// Indicates that this action resulted in update of an object.
-	/// </summary>
-	Update,
-
-	/// <summary>
-	/// Indicates that this action resulted in deletion or removal of an object.
-	/// </summary>
-	Delete,
-
-	/// <summary>
-	/// Indicates that this action resulted in something else than creation, addition, update, deletion, or removal of an object.
-	/// </summary>
-	Other
-}
-
-// below is taken from
-// https://github.com/Rapptz/discord.py/blob/rewrite/discord/enums.py#L125
-
-/// <summary>
-/// Represents type of the action that was taken in given audit log event.
-/// </summary>
-public enum AuditLogActionType
-{
-	/// <summary>
-	/// Indicates an invalid action type.
-	/// </summary>
-	Invalid = 0,
-
-	/// <summary>
-	/// Indicates that the guild was updated.
-	/// </summary>
-	GuildUpdate = 1,
-
-	/// <summary>
-	/// Indicates that the channel was created.
-	/// </summary>
-	ChannelCreate = 10,
-
-	/// <summary>
-	/// Indicates that the channel was updated.
-	/// </summary>
-	ChannelUpdate = 11,
-
-	/// <summary>
-	/// Indicates that the channel was deleted.
-	/// </summary>
-	ChannelDelete = 12,
-
-	/// <summary>
-	/// Indicates that the channel permission overwrite was created.
-	/// </summary>
-	OverwriteCreate = 13,
-
-	/// <summary>
-	/// Indicates that the channel permission overwrite was updated.
-	/// </summary>
-	OverwriteUpdate = 14,
-
-	/// <summary>
-	/// Indicates that the channel permission overwrite was deleted.
-	/// </summary>
-	OverwriteDelete = 15,
-
-	/// <summary>
-	/// Indicates that the user was kicked.
-	/// </summary>
-	Kick = 20,
-
-	/// <summary>
-	/// Indicates that users were pruned.
-	/// </summary>
-	Prune = 21,
-
-	/// <summary>
-	/// Indicates that the user was banned.
-	/// </summary>
-	Ban = 22,
-
-	/// <summary>
-	/// Indicates that the user was unbanned.
-	/// </summary>
-	Unban = 23,
-
-	/// <summary>
-	/// Indicates that the member was updated.
-	/// </summary>
-	MemberUpdate = 24,
-
-	/// <summary>
-	/// Indicates that the member's roles were updated.
-	/// </summary>
-	MemberRoleUpdate = 25,
-
-	/// <summary>
-	/// Indicates that the member has moved to another voice channel.
-	/// </summary>
-	MemberMove = 26,
-
-	/// <summary>
-	/// Indicates that the member has disconnected from a voice channel.
-	/// </summary>
-	MemberDisconnect = 27,
-
-	/// <summary>
-	/// Indicates that a bot was added to the guild.
-	/// </summary>
-	BotAdd = 28,
-
-	/// <summary>
-	/// Indicates that the role was created.
-	/// </summary>
-	RoleCreate = 30,
-
-	/// <summary>
-	/// Indicates that the role was updated.
-	/// </summary>
-	RoleUpdate = 31,
-
-	/// <summary>
-	/// Indicates that the role was deleted.
-	/// </summary>
-	RoleDelete = 32,
-
-	/// <summary>
-	/// Indicates that the invite was created.
-	/// </summary>
-	InviteCreate = 40,
-
-	/// <summary>
-	/// Indicates that the invite was updated.
-	/// </summary>
-	InviteUpdate = 41,
-
-	/// <summary>
-	/// Indicates that the invite was deleted.
-	/// </summary>
-	InviteDelete = 42,
-
-	/// <summary>
-	/// Indicates that the webhook was created.
-	/// </summary>
-	WebhookCreate = 50,
-
-	/// <summary>
-	/// Indicates that the webook was updated.
-	/// </summary>
-	WebhookUpdate = 51,
-
-	/// <summary>
-	/// Indicates that the webhook was deleted.
-	/// </summary>
-	WebhookDelete = 52,
-
-	/// <summary>
-	/// Indicates that an emoji was created.
-	/// </summary>
-	EmojiCreate = 60,
-
-	/// <summary>
-	/// Indicates that an emoji was updated.
-	/// </summary>
-	EmojiUpdate = 61,
-
-	/// <summary>
-	/// Indicates that an emoji was deleted.
-	/// </summary>
-	EmojiDelete = 62,
-
-	/// <summary>
-	/// Indicates that the message was deleted.
-	/// </summary>
-	MessageDelete = 72,
-
-	/// <summary>
-	/// Indicates that messages were bulk-deleted.
-	/// </summary>
-	MessageBulkDelete = 73,
-
-	/// <summary>
-	/// Indicates that a message was pinned.
-	/// </summary>
-	MessagePin = 74,
-
-	/// <summary>
-	/// Indicates that a message was unpinned.
-	/// </summary>
-	MessageUnpin = 75,
-
-	/// <summary>
-	/// Indicates that an integration was created.
-	/// </summary>
-	IntegrationCreate = 80,
-
-	/// <summary>
-	/// Indicates that an integration was updated.
-	/// </summary>
-	IntegrationUpdate = 81,
-
-	/// <summary>
-	/// Indicates that an integration was deleted.
-	/// </summary>
-	IntegrationDelete = 82,
-
-	/// <summary>
-	/// Indicates that an stage instance was created.
-	/// </summary>
-	StageInstanceCreate = 83,
-
-	/// <summary>
-	/// Indicates that an stage instance was updated.
-	/// </summary>
-	StageInstanceUpdate = 84,
-
-	/// <summary>
-	/// Indicates that an stage instance was deleted.
-	/// </summary>
-	StageInstanceDelete = 85,
-
-	/// <summary>
-	/// Indicates that an sticker was created.
-	/// </summary>
-	StickerCreate = 90,
-
-	/// <summary>
-	/// Indicates that an sticker was updated.
-	/// </summary>
-	StickerUpdate = 91,
-
-	/// <summary>
-	/// Indicates that an sticker was deleted.
-	/// </summary>
-	StickerDelete = 92,
-
-	/// <summary>
-	/// Indicates that an event was created.
-	/// </summary>
-	GuildScheduledEventCreate = 100,
-
-	/// <summary>
-	/// Indicates that an event was updated.
-	/// </summary>
-	GuildScheduledEventUpdate = 101,
-
-	/// <summary>
-	/// Indicates that an event was deleted.
-	/// </summary>
-	GuildScheduledEventDelete = 102,
-
-	/// <summary>
-	/// Indicates that an thread was created.
-	/// </summary>
-	ThreadCreate = 110,
-
-	/// <summary>
-	/// Indicates that an thread was updated.
-	/// </summary>
-	ThreadUpdate = 111,
-
-	/// <summary>
-	/// Indicates that an thread was deleted.
-	/// </summary>
-	ThreadDelete = 112,
-
-	ApplicationCommandPermissionUpdate = 121,
-
-	AutoModerationRuleCreate = 140,
-
-	AutoModerationRuleUpdate = 141,
-
-	AutoModerationRuleDelete = 142,
-
-	AutoModerationBlockMessage = 143
-}
diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs b/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
index 1a7bb0a49..d0e8a7d3c 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.AuditLog.cs
@@ -1,1302 +1,1306 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Entities;
 
 public partial class DiscordGuild
 {
 	// TODO: Rework audit logs!
 	/// <summary>
 	/// Gets audit log entries for this guild.
 	/// </summary>
 	/// <param name="limit">Maximum number of entries to fetch.</param>
 	/// <param name="byMember">Filter by member responsible.</param>
 	/// <param name="actionType">Filter by action type.</param>
 	/// <returns>A collection of requested audit log entries.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ViewAuditLog"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordAuditLogEntry>> GetAuditLogsAsync(int? limit = null, DiscordMember byMember = null, AuditLogActionType? actionType = null)
 	{
 		var alrs = new List<AuditLog>();
 		int ac = 1, tc = 0, rmn = 100;
 		var last = 0ul;
 		while (ac > 0)
 		{
 			rmn = limit != null ? limit.Value - tc : 100;
 			rmn = Math.Min(100, rmn);
 			if (rmn <= 0) break;
 
 			var alr = await this.Discord.ApiClient.GetAuditLogsAsync(this.Id, rmn, null, last == 0 ? null : (ulong?)last, byMember?.Id, (int?)actionType).ConfigureAwait(false);
 			ac = alr.Entries.Count();
 			tc += ac;
 			if (ac > 0)
 			{
 				last = alr.Entries.Last().Id;
 				alrs.Add(alr);
 			}
 		}
 
 		var amr = alrs.SelectMany(xa => xa.Users)
 			.GroupBy(xu => xu.Id)
 			.Select(xgu => xgu.First());
 
 		foreach (var xau in amr)
 		{
 			if (this.Discord.UserCache.ContainsKey(xau.Id))
 				continue;
 
 			var xtu = new TransportUser
 			{
 				Id = xau.Id,
 				Username = xau.Username,
 				Discriminator = xau.Discriminator,
 				AvatarHash = xau.AvatarHash
 			};
 			var xu = new DiscordUser(xtu) { Discord = this.Discord };
 			xu = this.Discord.UserCache.AddOrUpdate(xu.Id, xu, (id, old) =>
 			{
 				old.Username = xu.Username;
 				old.Discriminator = xu.Discriminator;
 				old.AvatarHash = xu.AvatarHash;
 				return old;
 			});
 		}
 
 		var atgse = alrs.SelectMany(xa => xa.ScheduledEvents)
 			.GroupBy(xse => xse.Id)
 			.Select(xgse => xgse.First());
 
 		var ath = alrs.SelectMany(xa => xa.Threads)
 			.GroupBy(xt => xt.Id)
 			.Select(xgt => xgt.First());
 
 		var aig = alrs.SelectMany(xa => xa.Integrations)
 			.GroupBy(xi => xi.Id)
 			.Select(xgi => xgi.First());
 
 		var ahr = alrs.SelectMany(xa => xa.Webhooks)
 			.GroupBy(xh => xh.Id)
 			.Select(xgh => xgh.First());
 
 		var ams = amr.Select(xau => this.MembersInternal != null && this.MembersInternal.TryGetValue(xau.Id, out var member) ? member : new DiscordMember { Discord = this.Discord, Id = xau.Id, GuildId = this.Id });
 		var amd = ams.ToDictionary(xm => xm.Id, xm => xm);
 
 #pragma warning disable CS0219
 		Dictionary<ulong, DiscordThreadChannel> dtc = null;
 		Dictionary<ulong, DiscordIntegration> di = null;
 		Dictionary<ulong, DiscordScheduledEvent> dse = null;
 #pragma warning restore
 
 		Dictionary<ulong, DiscordWebhook> ahd = null;
 		if (ahr.Any())
 		{
 			var whr = await this.GetWebhooksAsync().ConfigureAwait(false);
 			var whs = whr.ToDictionary(xh => xh.Id, xh => xh);
 
 			var amh = ahr.Select(xah => whs.TryGetValue(xah.Id, out var webhook) ? webhook : new DiscordWebhook { Discord = this.Discord, Name = xah.Name, Id = xah.Id, AvatarHash = xah.AvatarHash, ChannelId = xah.ChannelId, GuildId = xah.GuildId, Token = xah.Token });
 			ahd = amh.ToDictionary(xh => xh.Id, xh => xh);
 		}
 
 		var acs = alrs.SelectMany(xa => xa.Entries).OrderByDescending(xa => xa.Id);
 		var entries = new List<DiscordAuditLogEntry>();
 		foreach (var xac in acs)
 		{
 			DiscordAuditLogEntry entry = null;
 			ulong t1, t2;
 			int t3, t4;
 			long t5, t6;
 			bool p1, p2;
 			switch (xac.ActionType)
 			{
 				case AuditLogActionType.Invalid:
 					break;
 
 				case AuditLogActionType.GuildUpdate:
 					entry = new DiscordAuditLogGuildEntry
 					{
 						Target = this
 					};
 
 					var entrygld = entry as DiscordAuditLogGuildEntry;
 					foreach (var xc in xac.Changes)
 					{
 						PropertyChange<DiscordChannel> GetChannelChange()
 						{
 							ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 							ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 							return new PropertyChange<DiscordChannel>
 							{
 								Before = this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id },
 								After = this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id }
 							};
 						}
 
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrygld.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "owner_id":
 								entrygld.OwnerChange = new PropertyChange<DiscordMember>
 								{
 									Before = this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.OldValueUlong, out var oldMember) ? oldMember : await this.GetMemberAsync(xc.OldValueUlong).ConfigureAwait(false),
 									After = this.MembersInternal != null && this.MembersInternal.TryGetValue(xc.NewValueUlong, out var newMember) ? newMember : await this.GetMemberAsync(xc.NewValueUlong).ConfigureAwait(false)
 								};
 								break;
 
 							case "icon_hash":
 								entrygld.IconChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.OldValueString}.webp" : null,
 									After = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id}/{xc.NewValueString}.webp" : null
 								};
 								break;
 
 							case "verification_level":
 								entrygld.VerificationLevelChange = new PropertyChange<VerificationLevel>
 								{
 									Before = (VerificationLevel)(long)xc.OldValue,
 									After = (VerificationLevel)(long)xc.NewValue
 								};
 								break;
 
 							case "afk_channel_id":
 								entrygld.AfkChannelChange = GetChannelChange();
 								break;
 
 							case "system_channel_flags":
 								entrygld.SystemChannelFlagsChange = new PropertyChange<SystemChannelFlags>()
 								{
 									Before = (SystemChannelFlags)(long)xc.OldValue,
 									After = (SystemChannelFlags)(long)xc.NewValue
 								};
 								break;
 
 							case "widget_channel_id":
 								entrygld.WidgetChannelChange = GetChannelChange();
 								break;
 
 							case "rules_channel_id":
 								entrygld.RulesChannelChange = GetChannelChange();
 								break;
 
 							case "public_updates_channel_id":
 								entrygld.PublicUpdatesChannelChange = GetChannelChange();
 								break;
 
 							case "splash_hash":
 								entrygld.SplashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.OldValueString}.webp?size=2048" : null,
 									After = xc.NewValueString != null ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id}/{xc.NewValueString}.webp?size=2048" : null
 								};
 								break;
 
 							case "default_message_notifications":
 								entrygld.NotificationSettingsChange = new PropertyChange<DefaultMessageNotifications>
 								{
 									Before = (DefaultMessageNotifications)(long)xc.OldValue,
 									After = (DefaultMessageNotifications)(long)xc.NewValue
 								};
 								break;
 
 							case "system_channel_id":
 								entrygld.SystemChannelChange = GetChannelChange();
 								break;
 
 							case "explicit_content_filter":
 								entrygld.ExplicitContentFilterChange = new PropertyChange<ExplicitContentFilter>
 								{
 									Before = (ExplicitContentFilter)(long)xc.OldValue,
 									After = (ExplicitContentFilter)(long)xc.NewValue
 								};
 								break;
 
 							case "mfa_level":
 								entrygld.MfaLevelChange = new PropertyChange<MfaLevel>
 								{
 									Before = (MfaLevel)(long)xc.OldValue,
 									After = (MfaLevel)(long)xc.NewValue
 								};
 								break;
 
 							case "region":
 								entrygld.RegionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "vanity_url_code":
 								entrygld.VanityUrlCodeChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "premium_progress_bar_enabled":
 								entrygld.PremiumProgressBarChange = new PropertyChange<bool>
 								{
 									Before = (bool)xc.OldValue,
 									After = (bool)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in guild update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.ChannelCreate:
 				case AuditLogActionType.ChannelDelete:
 				case AuditLogActionType.ChannelUpdate:
 					entry = new DiscordAuditLogChannelEntry
 					{
 						Target = this.GetChannel(xac.TargetId.Value) ?? new DiscordChannel { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 
 					var entrychn = entry as DiscordAuditLogChannelEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrychn.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "type":
 								p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrychn.TypeChange = new PropertyChange<ChannelType?>
 								{
 									Before = p1 ? (ChannelType?)t1 : null,
 									After = p2 ? (ChannelType?)t2 : null
 								};
 								break;
 
 							case "flags":
 								entrychn.ChannelFlagsChange = new PropertyChange<ChannelFlags>()
 								{
-									Before = (ChannelFlags)(int)xc.OldValue,
-									After = (ChannelFlags)(int)xc.NewValue
+									Before = (ChannelFlags)(long)(xc.OldValue ?? 0L),
+									After = (ChannelFlags)(long)(xc.NewValue ?? 0L)
 								};
 								break;
 
 							case "permission_overwrites":
 								var olds = xc.OldValues?.OfType<JObject>()
 									?.Select(xjo => xjo.ToObject<DiscordOverwrite>())
 									?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 								var news = xc.NewValues?.OfType<JObject>()
 									?.Select(xjo => xjo.ToObject<DiscordOverwrite>())
 									?.Select(xo => { xo.Discord = this.Discord; return xo; });
 
 								entrychn.OverwriteChange = new PropertyChange<IReadOnlyList<DiscordOverwrite>>
 								{
 									Before = olds != null ? new ReadOnlyCollection<DiscordOverwrite>(new List<DiscordOverwrite>(olds)) : null,
 									After = news != null ? new ReadOnlyCollection<DiscordOverwrite>(new List<DiscordOverwrite>(news)) : null
 								};
 								break;
 
 							case "topic":
 								entrychn.TopicChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "nsfw":
 								entrychn.NsfwChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "rtc_region":
 								entrychn.RtcRegionIdChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "bitrate":
 								entrychn.BitrateChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							case "user_limit":
 								entrychn.UserLimitChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							case "rate_limit_per_user":
 								entrychn.PerUserRateLimitChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							case "default_auto_archive_duration":
 								entrychn.DefaultAutoArchiveDurationChange = new PropertyChange<ThreadAutoArchiveDuration?>
 								{
 									Before = (ThreadAutoArchiveDuration?)(long?)xc.OldValue,
 									After = (ThreadAutoArchiveDuration?)(long?)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in channel update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.OverwriteCreate:
 				case AuditLogActionType.OverwriteDelete:
 				case AuditLogActionType.OverwriteUpdate:
 					entry = new DiscordAuditLogOverwriteEntry
 					{
 						Target = this.GetChannel(xac.TargetId.Value)?.PermissionOverwrites.FirstOrDefault(xo => xo.Id == xac.Options.Id),
 						Channel = this.GetChannel(xac.TargetId.Value)
 					};
 
 					var entryovr = entry as DiscordAuditLogOverwriteEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "deny":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.DenyChange = new PropertyChange<Permissions?>
 								{
 									Before = p1 ? (Permissions?)t1 : null,
 									After = p2 ? (Permissions?)t2 : null
 								};
 								break;
 
 							case "allow":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.AllowChange = new PropertyChange<Permissions?>
 								{
 									Before = p1 ? (Permissions?)t1 : null,
 									After = p2 ? (Permissions?)t2 : null
 								};
 								break;
 
 							case "type":
 								entryovr.TypeChange = new PropertyChange<OverwriteType?>
 								{
 									Before = xc.OldValue != null ? (OverwriteType)(long)xc.OldValue : null,
 									After = xc.NewValue != null ? (OverwriteType)(long)xc.NewValue : null
 								};
 								break;
 
 							case "id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryovr.TargetIdChange = new PropertyChange<ulong?>
 								{
 									Before = p1 ? (ulong?)t1 : null,
 									After = p2 ? (ulong?)t2 : null
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in overwrite update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.Kick:
 					entry = new DiscordAuditLogKickEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var kickMember) ? kickMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 					break;
 
 				case AuditLogActionType.Prune:
 					entry = new DiscordAuditLogPruneEntry
 					{
 						Days = xac.Options.DeleteMemberDays,
 						Toll = xac.Options.MembersRemoved
 					};
 					break;
 
 				case AuditLogActionType.Ban:
 				case AuditLogActionType.Unban:
 					entry = new DiscordAuditLogBanEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var unbanMember) ? unbanMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 					break;
 
 				case AuditLogActionType.MemberUpdate:
 				case AuditLogActionType.MemberRoleUpdate:
 					entry = new DiscordAuditLogMemberUpdateEntry
 					{
 						Target = amd.TryGetValue(xac.TargetId.Value, out var roleUpdMember) ? roleUpdMember : new DiscordMember { Id = xac.TargetId.Value, Discord = this.Discord, GuildId = this.Id }
 					};
 
 					var entrymbu = entry as DiscordAuditLogMemberUpdateEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "nick":
 								entrymbu.NicknameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "deaf":
 								entrymbu.DeafenChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "mute":
 								entrymbu.MuteChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 							case "communication_disabled_until":
 								entrymbu.CommunicationDisabledUntilChange = new PropertyChange<DateTime?>
 								{
 									Before = (DateTime?)xc.OldValue,
 									After = (DateTime?)xc.NewValue
 								};
 								break;
 
 							case "$add":
 								entrymbu.AddedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
 								break;
 
 							case "$remove":
 								entrymbu.RemovedRoles = new ReadOnlyCollection<DiscordRole>(xc.NewValues.Select(xo => (ulong)xo["id"]).Select(this.GetRole).ToList());
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in member update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.RoleCreate:
 				case AuditLogActionType.RoleDelete:
 				case AuditLogActionType.RoleUpdate:
 					entry = new DiscordAuditLogRoleUpdateEntry
 					{
 						Target = this.GetRole(xac.TargetId.Value) ?? new DiscordRole { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryrol = entry as DiscordAuditLogRoleUpdateEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entryrol.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "color":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryrol.ColorChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "permissions":
 								entryrol.PermissionChange = new PropertyChange<Permissions?>
 								{
 									Before = xc.OldValue != null ? (Permissions?)long.Parse((string)xc.OldValue) : null,
 									After = xc.NewValue != null ? (Permissions?)long.Parse((string)xc.NewValue) : null
 								};
 								break;
 
 							case "position":
 								entryrol.PositionChange = new PropertyChange<int?>
 								{
 									Before = xc.OldValue != null ? (int?)(long)xc.OldValue : null,
 									After = xc.NewValue != null ? (int?)(long)xc.NewValue : null,
 								};
 								break;
 
 							case "mentionable":
 								entryrol.MentionableChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "hoist":
 								entryrol.HoistChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 
 							case "icon_hash":
 								entryrol.IconHashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in role update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.InviteCreate:
 				case AuditLogActionType.InviteDelete:
 				case AuditLogActionType.InviteUpdate:
 					entry = new DiscordAuditLogInviteEntry();
 
 					var inv = new DiscordInvite
 					{
 						Discord = this.Discord,
 						Guild = new DiscordInviteGuild
 						{
 							Discord = this.Discord,
 							Id = this.Id,
 							Name = this.Name,
 							SplashHash = this.SplashHash
 						}
 					};
 
 					var entryinv = entry as DiscordAuditLogInviteEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "max_age":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.MaxAgeChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "code":
 								inv.Code = xc.OldValueString ?? xc.NewValueString;
 
 								entryinv.CodeChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "temporary":
 								entryinv.TemporaryChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "inviter_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryinv.InviterChange = new PropertyChange<DiscordMember>
 								{
 									Before = amd.TryGetValue(t1, out var propBeforeMember) ? propBeforeMember : new DiscordMember { Id = t1, Discord = this.Discord, GuildId = this.Id },
 									After = amd.TryGetValue(t2, out var propAfterMember) ? propAfterMember : new DiscordMember { Id = t1, Discord = this.Discord, GuildId = this.Id },
 								};
 								break;
 
 							case "channel_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entryinv.ChannelChange = new PropertyChange<DiscordChannel>
 								{
 									Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
 									After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
 								};
 
 								var ch = entryinv.ChannelChange.Before ?? entryinv.ChannelChange.After;
 								var cht = ch?.Type;
 								inv.Channel = new DiscordInviteChannel
 								{
 									Discord = this.Discord,
 									Id = p1 ? t1 : t2,
 									Name = ch?.Name,
 									Type = cht != null ? cht.Value : ChannelType.Unknown
 								};
 								break;
 
 							case "uses":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.UsesChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "max_uses":
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entryinv.MaxUsesChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							// TODO: Add changes for target application
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in invite update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 
 					entryinv.Target = inv;
 					break;
 
 				case AuditLogActionType.WebhookCreate:
 				case AuditLogActionType.WebhookDelete:
 				case AuditLogActionType.WebhookUpdate:
 					entry = new DiscordAuditLogWebhookEntry
 					{
 						Target = ahd.TryGetValue(xac.TargetId.Value, out var webhook) ? webhook : new DiscordWebhook { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrywhk = entry as DiscordAuditLogWebhookEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "application_id": // ???
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrywhk.IdChange = new PropertyChange<ulong?>
 								{
 									Before = p1 ? t1 : null,
 									After = p2 ? t2 : null
 								};
 								break;
 
 							case "name":
 								entrywhk.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "channel_id":
 								p1 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrywhk.ChannelChange = new PropertyChange<DiscordChannel>
 								{
 									Before = p1 ? this.GetChannel(t1) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null,
 									After = p2 ? this.GetChannel(t2) ?? new DiscordChannel { Id = t1, Discord = this.Discord, GuildId = this.Id } : null
 								};
 								break;
 
 							case "type": // ???
 								p1 = int.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t3);
 								p2 = int.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t4);
 
 								entrywhk.TypeChange = new PropertyChange<int?>
 								{
 									Before = p1 ? (int?)t3 : null,
 									After = p2 ? (int?)t4 : null
 								};
 								break;
 
 							case "avatar_hash":
 								entrywhk.AvatarHashChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in webhook update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.EmojiCreate:
 				case AuditLogActionType.EmojiDelete:
 				case AuditLogActionType.EmojiUpdate:
 					entry = new DiscordAuditLogEmojiEntry
 					{
 						Target = this.EmojisInternal.TryGetValue(xac.TargetId.Value, out var target) ? target : new DiscordEmoji { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryemo = entry as DiscordAuditLogEmojiEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entryemo.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in emote update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.StageInstanceCreate:
 				case AuditLogActionType.StageInstanceDelete:
 				case AuditLogActionType.StageInstanceUpdate:
 					entry = new DiscordAuditLogStageEntry
 					{
 						Target = this.StageInstancesInternal.TryGetValue(xac.TargetId.Value, out var stage) ? stage : new DiscordStageInstance { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrysta = entry as DiscordAuditLogStageEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "topic":
 								entrysta.TopicChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "privacy_level":
 								entrysta.PrivacyLevelChange = new PropertyChange<StagePrivacyLevel?>
 								{
 									Before = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5) ? (StagePrivacyLevel?)t5 : null,
 									After = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6) ? (StagePrivacyLevel?)t6 : null,
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in stage instance update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.StickerCreate:
 				case AuditLogActionType.StickerDelete:
 				case AuditLogActionType.StickerUpdate:
 					entry = new DiscordAuditLogStickerEntry
 					{
 						Target = this.StickersInternal.TryGetValue(xac.TargetId.Value, out var sticker) ? sticker : new DiscordSticker { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrysti = entry as DiscordAuditLogStickerEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrysti.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "description":
 								entrysti.DescriptionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "tags":
 								entrysti.TagsChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "guild_id":
 								entrysti.GuildIdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
 									After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
 								};
 								break;
 							case "available":
 								entrysti.AvailabilityChange = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue,
 								};
 								break;
 							case "asset":
 								entrysti.AssetChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "id":
 								entrysti.IdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var oid) ? oid : null,
 									After = ulong.TryParse(xc.NewValueString, out var nid) ? nid : null
 								};
 								break;
 							case "type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 								entrysti.TypeChange = new PropertyChange<StickerType?>
 								{
 									Before = p1 ? (StickerType?)t5 : null,
 									After = p2 ? (StickerType?)t6 : null
 								};
 								break;
 							case "format_type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 								entrysti.FormatChange = new PropertyChange<StickerFormat?>
 								{
 									Before = p1 ? (StickerFormat?)t5 : null,
 									After = p2 ? (StickerFormat?)t6 : null
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in sticker update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 
 
 				case AuditLogActionType.MessageDelete:
 				case AuditLogActionType.MessageBulkDelete:
 				{
 					entry = new DiscordAuditLogMessageEntry();
 
 					var entrymsg = entry as DiscordAuditLogMessageEntry;
 
 					if (xac.Options != null)
 					{
 						entrymsg.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 						entrymsg.MessageCount = xac.Options.Count;
 					}
 
 					if (entrymsg.Channel != null)
 					{
 						entrymsg.Target = this.Discord is DiscordClient dc
 							&& dc.MessageCache != null
 							&& dc.MessageCache.TryGet(xm => xm.Id == xac.TargetId.Value && xm.ChannelId == entrymsg.Channel.Id, out var msg)
 							? msg
 							: new DiscordMessage { Discord = this.Discord, Id = xac.TargetId.Value };
 					}
 					break;
 				}
 
 				case AuditLogActionType.MessagePin:
 				case AuditLogActionType.MessageUnpin:
 				{
 					entry = new DiscordAuditLogMessagePinEntry();
 
 					var entrypin = entry as DiscordAuditLogMessagePinEntry;
 
 					if (this.Discord is not DiscordClient dc)
 					{
 						break;
 					}
 
 					if (xac.Options != null)
 					{
 						DiscordMessage message = default;
 						dc.MessageCache?.TryGet(x => x.Id == xac.Options.MessageId && x.ChannelId == xac.Options.ChannelId, out message);
 
 						entrypin.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 						entrypin.Message = message ?? new DiscordMessage { Id = xac.Options.MessageId, Discord = this.Discord };
 					}
 
 					if (xac.TargetId.HasValue)
 					{
 						dc.UserCache.TryGetValue(xac.TargetId.Value, out var user);
 						entrypin.Target = user ?? new DiscordUser { Id = user.Id, Discord = this.Discord };
 					}
 
 					break;
 				}
 
 				case AuditLogActionType.BotAdd:
 				{
 					entry = new DiscordAuditLogBotAddEntry();
 
 					if (!(this.Discord is DiscordClient dc && xac.TargetId.HasValue))
 					{
 						break;
 					}
 
 					dc.UserCache.TryGetValue(xac.TargetId.Value, out var bot);
 					(entry as DiscordAuditLogBotAddEntry).TargetBot = bot ?? new DiscordUser { Id = xac.TargetId.Value, Discord = this.Discord };
 
 					break;
 				}
 
 				case AuditLogActionType.MemberMove:
 					entry = new DiscordAuditLogMemberMoveEntry();
 
 					if (xac.Options == null)
 					{
 						break;
 					}
 
 					var moveentry = entry as DiscordAuditLogMemberMoveEntry;
 
 					moveentry.UserCount = xac.Options.Count;
 					moveentry.Channel = this.GetChannel(xac.Options.ChannelId) ?? new DiscordChannel { Id = xac.Options.ChannelId, Discord = this.Discord, GuildId = this.Id };
 					break;
 
 				case AuditLogActionType.MemberDisconnect:
 					entry = new DiscordAuditLogMemberDisconnectEntry
 					{
 						UserCount = xac.Options?.Count ?? 0
 					};
 					break;
 
 				case AuditLogActionType.IntegrationCreate:
 				case AuditLogActionType.IntegrationDelete:
 				case AuditLogActionType.IntegrationUpdate:
 					entry = new DiscordAuditLogIntegrationEntry();
 
 					var integentry = entry as DiscordAuditLogIntegrationEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "type":
 								integentry.Type = new PropertyChange<string>()
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 							case "enable_emoticons":
 								integentry.EnableEmoticons = new PropertyChange<bool?>
 								{
 									Before = (bool?)xc.OldValue,
 									After = (bool?)xc.NewValue
 								};
 								break;
 							case "expire_behavior":
 								integentry.ExpireBehavior = new PropertyChange<int?>
 								{
 									Before = (int?)xc.OldValue,
 									After = (int?)xc.NewValue
 								};
 								break;
 							case "expire_grace_period":
 								integentry.ExpireBehavior = new PropertyChange<int?>
 								{
 									Before = (int?)xc.OldValue,
 									After = (int?)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in integration update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 				case AuditLogActionType.ThreadCreate:
 				case AuditLogActionType.ThreadDelete:
 				case AuditLogActionType.ThreadUpdate:
 					entry = new DiscordAuditLogThreadEntry
 					{
 						Target = this.ThreadsInternal.TryGetValue(xac.TargetId.Value, out var thread) ? thread : new DiscordThreadChannel { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entrythr = entry as DiscordAuditLogThreadEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "name":
 								entrythr.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "type":
 								p1 = ulong.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t1);
 								p2 = ulong.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t2);
 
 								entrythr.TypeChange = new PropertyChange<ChannelType?>
 								{
 									Before = p1 ? (ChannelType?)t1 : null,
 									After = p2 ? (ChannelType?)t2 : null
 								};
 								break;
 
 							case "archived":
 								entrythr.ArchivedChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "locked":
 								entrythr.LockedChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "invitable":
 								entrythr.InvitableChange = new PropertyChange<bool?>
 								{
 									Before = xc.OldValue != null ? (bool?)xc.OldValue : null,
 									After = xc.NewValue != null ? (bool?)xc.NewValue : null
 								};
 								break;
 
 							case "auto_archive_duration":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entrythr.AutoArchiveDurationChange = new PropertyChange<ThreadAutoArchiveDuration?>
 								{
 									Before = p1 ? (ThreadAutoArchiveDuration?)t5 : null,
 									After = p2 ? (ThreadAutoArchiveDuration?)t6 : null
 								};
 								break;
 
 							case "rate_limit_per_user":
 								entrythr.PerUserRateLimitChange = new PropertyChange<int?>
 								{
 									Before = (int?)(long?)xc.OldValue,
 									After = (int?)(long?)xc.NewValue
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in thread update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
 
 				case AuditLogActionType.GuildScheduledEventCreate:
 				case AuditLogActionType.GuildScheduledEventDelete:
 				case AuditLogActionType.GuildScheduledEventUpdate:
 					entry = new DiscordAuditLogGuildScheduledEventEntry
 					{
 						Target = this.ScheduledEventsInternal.TryGetValue(xac.TargetId.Value, out var scheduledEvent) ? scheduledEvent : new DiscordScheduledEvent { Id = xac.TargetId.Value, Discord = this.Discord }
 					};
 
 					var entryse = entry as DiscordAuditLogGuildScheduledEventEntry;
 					foreach (var xc in xac.Changes)
 					{
 						switch (xc.Key.ToLowerInvariant())
 						{
 							case "channel_id":
 								entryse.ChannelIdChange = new PropertyChange<ulong?>
 								{
 									Before = ulong.TryParse(xc.OldValueString, out var ogid) ? ogid : null,
 									After = ulong.TryParse(xc.NewValueString, out var ngid) ? ngid : null
 								};
 								break;
 
 							case "name":
 								entryse.NameChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "description":
 								entryse.DescriptionChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "location":
 								entryse.LocationChange = new PropertyChange<string>
 								{
 									Before = xc.OldValueString,
 									After = xc.NewValueString
 								};
 								break;
 
 							case "privacy_level":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.PrivacyLevelChange = new PropertyChange<ScheduledEventPrivacyLevel?>
 								{
 									Before = p1 ? (ScheduledEventPrivacyLevel?)t5 : null,
 									After = p2 ? (ScheduledEventPrivacyLevel?)t6 : null
 								};
 								break;
 
 							case "entity_type":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.EntityTypeChange = new PropertyChange<ScheduledEventEntityType?>
 								{
 									Before = p1 ? (ScheduledEventEntityType?)t5 : null,
 									After = p2 ? (ScheduledEventEntityType?)t6 : null
 								};
 								break;
 
 							case "status":
 								p1 = long.TryParse(xc.OldValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t5);
 								p2 = long.TryParse(xc.NewValue as string, NumberStyles.Integer, CultureInfo.InvariantCulture, out t6);
 
 								entryse.StatusChange = new PropertyChange<ScheduledEventStatus?>
 								{
 									Before = p1 ? (ScheduledEventStatus?)t5 : null,
 									After = p2 ? (ScheduledEventStatus?)t6 : null
 								};
 								break;
 
 							default:
 								this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown key in scheduled event update: {0} - this should be reported to library developers", xc.Key);
 								break;
 						}
 					}
 					break;
 
+				// TODO: Handle ApplicationCommandPermissionUpdate
+				case AuditLogActionType.ApplicationCommandPermissionUpdate:
+					break;
+
 				default:
 					this.Discord.Logger.LogWarning(LoggerEvents.AuditLog, "Unknown audit log action type: {0} - this should be reported to library developers", (int)xac.ActionType);
 					break;
 			}
 
 			if (entry == null)
 				continue;
 
 			entry.ActionCategory = xac.ActionType switch
 			{
 				AuditLogActionType.ChannelCreate or AuditLogActionType.EmojiCreate or AuditLogActionType.InviteCreate or AuditLogActionType.OverwriteCreate or AuditLogActionType.RoleCreate or AuditLogActionType.WebhookCreate or AuditLogActionType.IntegrationCreate or AuditLogActionType.StickerCreate or AuditLogActionType.StageInstanceCreate or AuditLogActionType.ThreadCreate or AuditLogActionType.GuildScheduledEventCreate => AuditLogActionCategory.Create,
 				AuditLogActionType.ChannelDelete or AuditLogActionType.EmojiDelete or AuditLogActionType.InviteDelete or AuditLogActionType.MessageDelete or AuditLogActionType.MessageBulkDelete or AuditLogActionType.OverwriteDelete or AuditLogActionType.RoleDelete or AuditLogActionType.WebhookDelete or AuditLogActionType.IntegrationDelete or AuditLogActionType.StickerDelete or AuditLogActionType.StageInstanceDelete or AuditLogActionType.ThreadDelete or AuditLogActionType.GuildScheduledEventDelete => AuditLogActionCategory.Delete,
 				AuditLogActionType.ChannelUpdate or AuditLogActionType.EmojiUpdate or AuditLogActionType.InviteUpdate or AuditLogActionType.MemberRoleUpdate or AuditLogActionType.MemberUpdate or AuditLogActionType.OverwriteUpdate or AuditLogActionType.RoleUpdate or AuditLogActionType.WebhookUpdate or AuditLogActionType.IntegrationUpdate or AuditLogActionType.StickerUpdate or AuditLogActionType.StageInstanceUpdate or AuditLogActionType.ThreadUpdate or AuditLogActionType.GuildScheduledEventUpdate => AuditLogActionCategory.Update,
 				_ => AuditLogActionCategory.Other,
 			};
 			entry.Discord = this.Discord;
 			entry.ActionType = xac.ActionType;
 			entry.Id = xac.Id;
 			entry.Reason = xac.Reason;
 			entry.UserResponsible = amd[xac.UserId];
 			entries.Add(entry);
 		}
 
 		return new ReadOnlyCollection<DiscordAuditLogEntry>(entries);
 	}
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.Features.cs b/DisCatSharp/Entities/Guild/DiscordGuild.Features.cs
index ea51addda..93de48122 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.Features.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.Features.cs
@@ -1,300 +1,302 @@
 // 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.Linq;
 
+using DisCatSharp.Enums;
+
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents the guild features.
 /// </summary>
 public class GuildFeatures
 {
 	/// <summary>
 	/// Guild has access to set an animated guild icon.
 	/// </summary>
 	public bool CanSetAnimatedIcon { get; }
 
 	/// <summary>
 	/// Guild has access to set a guild banner image.
 	/// </summary>
 	public bool CanSetBanner { get; }
 
 	/// <summary>
 	/// Guild has access to use commerce features (i.e. create store channels)
 	/// </summary>
 	public bool CanCreateStoreChannels { get; }
 
 	/// <summary>
 	/// Guild can enable Welcome Screen, Membership Screening, Stage Channels, News Channels and receives community updates.
 	/// Furthermore the guild can apply as a partner and for the discovery (if the prerequisites are given).
 	/// <see cref="ChannelType.Stage"/> and <see cref="ChannelType.News"/> is usable.
 	/// </summary>
 	public bool HasCommunityEnabled { get; }
 
 	/// <summary>
 	/// Guild is able to be discovered in the discovery.
 	/// </summary>
 	public bool IsDiscoverable { get; }
 
 	/// <summary>
 	/// Guild is able to be featured in the discovery.
 	/// </summary>
 	public bool IsFeatureable { get; }
 
 	/// <summary>
 	/// Guild has access to set an invite splash background.
 	/// </summary>
 	public bool CanSetInviteSplash { get; }
 
 	/// <summary>
 	/// Guild has enabled Membership Screening.
 	/// </summary>
 	public bool HasMembershipScreeningEnabled { get; }
 
 	/// <summary>
 	/// Guild has access to create news channels.
 	/// <see cref="ChannelType.News"/> is usable.
 	/// </summary>
 	public bool CanCreateNewsChannels { get; }
 
 	/// <summary>
 	/// Guild is partnered.
 	/// </summary>
 	public bool IsPartnered { get; }
 
 	/// <summary>
 	/// Guild has increased custom emoji slots.
 	/// </summary>
 	public bool CanUploadMoreEmojis { get; }
 
 	/// <summary>
 	/// Guild can be previewed before joining via Membership Screening or the discovery.
 	/// </summary>
 	public bool HasPreviewEnabled { get; }
 
 	/// <summary>
 	/// Guild has access to set a vanity URL.
 	/// </summary>
 	public bool CanSetVanityUrl { get; }
 
 	/// <summary>
 	/// Guild is verified.
 	/// </summary>
 	public bool IsVerified { get; }
 
 	/// <summary>
 	/// Guild has access to set 384kbps bitrate in voice (previously VIP voice servers).
 	/// </summary>
 	public bool CanAccessVipRegions { get; }
 
 	/// <summary>
 	/// Guild has enabled the welcome screen.
 	/// </summary>
 	public bool HasWelcomeScreenEnabled { get; }
 
 	/// <summary>
 	/// Guild has enabled ticketed events.
 	/// </summary>
 	public bool HasTicketedEventsEnabled { get; }
 
 	/// <summary>
 	/// Guild has enabled monetization.
 	/// </summary>
 	public bool HasMonetizationEnabled { get; }
 
 	/// <summary>
 	/// Guild has increased custom sticker slots.
 	/// </summary>
 	public bool CanUploadMoreStickers { get; }
 
 	/// <summary>
 	/// Guild has access to the three day archive time for threads.
 	/// Needs Premium Tier 1 (<see cref="PremiumTier.TierOne"/>).
 	/// </summary>
 	public bool CanSetThreadArchiveDurationThreeDays { get; }
 
 	/// <summary>
 	/// Guild has access to the seven day archive time for threads.
 	/// Needs Premium Tier 2 (<see cref="PremiumTier.TierTwo"/>).
 	/// </summary>
 	public bool CanSetThreadArchiveDurationSevenDays { get; }
 
 	/// <summary>
 	/// Guild has access to create private threads.
 	/// Needs Premium Tier 2 (<see cref="PremiumTier.TierTwo"/>).
 	/// </summary>
 	public bool CanCreatePrivateThreads { get; }
 
 	/// <summary>
 	/// Guild is a hub.
 	/// <see cref="ChannelType.GuildDirectory"/> is usable.
 	/// </summary>
 	public bool IsHub { get; }
 
 	/// <summary>
 	/// Guild is in a hub.
 	/// https://github.com/discord/discord-api-docs/pull/3757/commits/4932d92c9d0c783861bc715bf7ebbabb15114e34
 	/// </summary>
 	public bool HasDirectoryEntry { get; }
 
 	/// <summary>
 	/// Guild is linked to a hub.
 	/// </summary>
 	public bool IsLinkedToHub { get; }
 
 	/// <summary>
 	/// Guild has full access to threads.
 	/// Old Feature.
 	/// </summary>
 	public bool HasThreadTestingEnabled { get; }
 
 	/// <summary>
 	/// Guild has access to threads.
 	/// </summary>
 	public bool HasThreadsEnabled { get; }
 
 	/// <summary>
 	/// Guild can set role icons.
 	/// </summary>
 	public bool CanSetRoleIcons { get; }
 
 	/// <summary>
 	/// Guild has the new thread permissions.
 	/// Old Feature.
 	/// </summary>
 	public bool HasNewThreadPermissions { get; }
 
 	/// <summary>
 	/// Guild can set thread default auto archive duration.
 	/// Old Feature.
 	/// </summary>
 	public bool CanSetThreadDefaultAutoArchiveDuration { get; }
 
 	/// <summary>
 	/// Guild has enabled role subscriptions.
 	/// </summary>
 	public bool HasRoleSubscriptionsEnabled { get; }
 
 	/// <summary>
 	/// Guild role subscriptions as purchaseable.
 	/// </summary>
 	public bool RoleSubscriptionsIsAvailableForPurchase { get; }
 
 	/// <summary>
 	/// Guild has premium tier 3 override.
 	/// </summary>
 	public bool PremiumTierThreeOverride { get; }
 
 	/// <summary>
 	/// Guild has access to text in voice.
 	/// Restricted to <see cref="IsStaffOnly"/>.
 	/// </summary>
 	public bool TextInVoiceEnabled { get; }
 
 	/// <summary>
 	/// Guild can set an animated banner.
 	/// Needs Premium Tier 3 (<see cref="PremiumTier.TierThree"/>).
 	/// </summary>
 	public bool CanSetAnimatedBanner { get; }
 
 	/// <summary>
 	/// Guild can set an animated banner.
 	/// Needs Premium Tier 3 (<see cref="PremiumTier.TierThree"/>).
 	/// </summary>
 	public bool CanSetChannelBanner { get; }
 
 	/// <summary>
 	/// Allows members to customize their avatar, banner and bio for that server.
 	/// </summary>
 	public bool HasMemberProfiles { get; }
 
 	/// <summary>
 	/// Guild is restricted to users with the <see cref="UserFlags.Staff"/> badge.
 	/// </summary>
 	public bool IsStaffOnly { get; }
 
 	/// <summary>
 	/// Guild can use and setup the experimental auto moderation feature.
 	/// </summary>
 	public bool CanSetupAutoModeration { get; }
 
 	/// <summary>
 	/// String of guild features.
 	/// </summary>
 	public string FeatureString { get; }
 
 	/// <summary>
 	/// Checks the guild features and constructs a new <see cref="GuildFeatures"/> object.
 	/// </summary>
 	/// <param name="guild">Guild to check</param>
 	public GuildFeatures(DiscordGuild guild)
 	{
 		this.CanSetAnimatedIcon = guild.RawFeatures.Contains("ANIMATED_ICON");
 		this.CanSetAnimatedBanner = guild.RawFeatures.Contains("ANIMATED_BANNER");
 		this.CanSetBanner = guild.RawFeatures.Contains("BANNER");
 		this.CanSetChannelBanner = guild.RawFeatures.Contains("CHANNEL_BANNER");
 		this.CanCreateStoreChannels = guild.RawFeatures.Contains("COMMERCE");
 		this.HasCommunityEnabled = guild.RawFeatures.Contains("COMMUNITY");
 		this.IsDiscoverable = !guild.RawFeatures.Contains("DISCOVERABLE_DISABLED") && guild.RawFeatures.Contains("DISCOVERABLE");
 		this.IsFeatureable = guild.RawFeatures.Contains("FEATUREABLE");
 		this.CanSetInviteSplash = guild.RawFeatures.Contains("INVITE_SPLASH");
 		this.HasMembershipScreeningEnabled = guild.RawFeatures.Contains("MEMBER_VERIFICATION_GATE_ENABLED");
 		this.CanCreateNewsChannels = guild.RawFeatures.Contains("NEWS");
 		this.IsPartnered = guild.RawFeatures.Contains("PARTNERED");
 		this.CanUploadMoreEmojis = guild.RawFeatures.Contains("MORE_EMOJI");
 		this.HasPreviewEnabled = guild.RawFeatures.Contains("PREVIEW_ENABLED");
 		this.CanSetVanityUrl = guild.RawFeatures.Contains("VANITY_URL");
 		this.IsVerified = guild.RawFeatures.Contains("VERIFIED");
 		this.CanAccessVipRegions = guild.RawFeatures.Contains("VIP_REGIONS");
 		this.HasWelcomeScreenEnabled = guild.RawFeatures.Contains("WELCOME_SCREEN_ENABLED");
 		this.HasTicketedEventsEnabled = guild.RawFeatures.Contains("TICKETED_EVENTS_ENABLED");
 		this.HasMonetizationEnabled = guild.RawFeatures.Contains("MONETIZATION_ENABLED");
 		this.CanUploadMoreStickers = guild.RawFeatures.Contains("MORE_STICKERS");
 		this.CanSetThreadArchiveDurationThreeDays = guild.RawFeatures.Contains("THREE_DAY_THREAD_ARCHIVE");
 		this.CanSetThreadArchiveDurationSevenDays = guild.RawFeatures.Contains("SEVEN_DAY_THREAD_ARCHIVE");
 		this.CanCreatePrivateThreads = guild.RawFeatures.Contains("PRIVATE_THREADS");
 		this.IsHub = guild.RawFeatures.Contains("HUB");
 		this.HasThreadTestingEnabled = guild.RawFeatures.Contains("THREADS_ENABLED_TESTING");
 		this.HasThreadsEnabled = guild.RawFeatures.Contains("THREADS_ENABLED");
 		this.CanSetRoleIcons = guild.RawFeatures.Contains("ROLE_ICONS");
 		this.HasNewThreadPermissions = guild.RawFeatures.Contains("NEW_THREAD_PERMISSIONS");
 		this.HasRoleSubscriptionsEnabled = guild.RawFeatures.Contains("ROLE_SUBSCRIPTIONS_ENABLED");
 		this.PremiumTierThreeOverride = guild.RawFeatures.Contains("PREMIUM_TIER_3_OVERRIDE");
 		this.CanSetThreadDefaultAutoArchiveDuration = guild.RawFeatures.Contains("THREAD_DEFAULT_AUTO_ARCHIVE_DURATION");
 		this.TextInVoiceEnabled = guild.RawFeatures.Contains("TEXT_IN_VOICE_ENABLED");
 		this.HasDirectoryEntry = guild.RawFeatures.Contains("HAS_DIRECTORY_ENTRY");
 		this.IsLinkedToHub = guild.RawFeatures.Contains("LINKED_TO_HUB");
 		this.HasMemberProfiles = guild.RawFeatures.Contains("MEMBER_PROFILES");
 		this.IsStaffOnly = guild.RawFeatures.Contains("INTERNAL_EMPLOYEE_ONLY");
 		this.RoleSubscriptionsIsAvailableForPurchase = guild.RawFeatures.Contains("ROLE_SUBSCRIPTIONS_AVAILABLE_FOR_PURCHASE");
 		this.CanSetupAutoModeration = guild.RawFeatures.Contains("AUTO_MODERATION");
 
 		var features = guild.RawFeatures.Any() ? "" : "None";
 		foreach (var feature in guild.RawFeatures)
 		{
 			features += feature + " ";
 		}
 		this.FeatureString = features;
 
 	}
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordGuild.cs b/DisCatSharp/Entities/Guild/DiscordGuild.cs
index 2b0a6ba8c..6f257518b 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.cs
@@ -1,2064 +1,1969 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord guild.
 /// </summary>
 public partial class DiscordGuild : SnowflakeObject, IEquatable<DiscordGuild>
 {
 	/// <summary>
 	/// Gets the guild's name.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild icon's hash.
 	/// </summary>
 	[JsonProperty("icon", NullValueHandling = NullValueHandling.Ignore)]
 	public string IconHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild icon's url.
 	/// </summary>
 	[JsonIgnore]
 	public string IconUrl
 		=> !string.IsNullOrWhiteSpace(this.IconHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ICONS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.IconHash}.{(this.IconHash.StartsWith("a_") ? "gif" : "png")}?size=1024" : null;
 
 	/// <summary>
 	/// Gets the guild splash's hash.
 	/// </summary>
 	[JsonProperty("splash", NullValueHandling = NullValueHandling.Ignore)]
 	public string SplashHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild splash's url.
 	/// </summary>
 	[JsonIgnore]
 	public string SplashUrl
 	 => !string.IsNullOrWhiteSpace(this.SplashHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.SPLASHES}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.SplashHash}.png?size=1024" : null;
 
 	/// <summary>
 	/// Gets the guild discovery splash's hash.
 	/// </summary>
 	[JsonProperty("discovery_splash", NullValueHandling = NullValueHandling.Ignore)]
 	public string DiscoverySplashHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild discovery splash's url.
 	/// </summary>
 	[JsonIgnore]
 	public string DiscoverySplashUrl
 		=> !string.IsNullOrWhiteSpace(this.DiscoverySplashHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILD_DISCOVERY_SPLASHES}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.DiscoverySplashHash}.png?size=1024" : null;
 
 	/// <summary>
 	/// Gets the preferred locale of this guild.
 	/// <para>This is used for server discovery, interactions and notices from Discord. Defaults to en-US.</para>
 	/// </summary>
 	[JsonProperty("preferred_locale", NullValueHandling = NullValueHandling.Ignore)]
 	public string PreferredLocale { get; internal set; }
 
 	/// <summary>
 	/// Gets the ID of the guild's owner.
 	/// </summary>
 	[JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong OwnerId { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's owner.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordMember Owner
 		=> this.Members.TryGetValue(this.OwnerId, out var owner)
 			? owner
 			: this.Discord.ApiClient.GetGuildMemberAsync(this.Id, this.OwnerId).ConfigureAwait(false).GetAwaiter().GetResult();
 
 	/// <summary>
 	/// Gets permissions for the user in the guild (does not include channel overrides)
 	/// </summary>
 	[JsonProperty("permissions", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions? Permissions { get; set; }
 
 	/// <summary>
 	/// Gets the guild's voice region ID.
 	/// </summary>
 	[JsonProperty("region", NullValueHandling = NullValueHandling.Ignore)]
 	internal string VoiceRegionId { get; set; }
 
 	/// <summary>
 	/// Gets the guild's voice region.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordVoiceRegion VoiceRegion
 		=> this.Discord.VoiceRegions[this.VoiceRegionId];
 
 	/// <summary>
 	/// Gets the guild's AFK voice channel ID.
 	/// </summary>
 	[JsonProperty("afk_channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	internal ulong AfkChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the guild's AFK voice channel.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel AfkChannel
 		=> this.GetChannel(this.AfkChannelId);
 
 	/// <summary>
 	/// List of <see cref="DisCatSharp.Entities.DiscordApplicationCommand"/>.
 	/// Null if DisCatSharp.ApplicationCommands is not used or no guild commands are registered.
 	/// </summary>
 	[JsonIgnore]
 	public ReadOnlyCollection<DiscordApplicationCommand> RegisteredApplicationCommands
 		=> new(this.InternalRegisteredApplicationCommands);
 	[JsonIgnore]
 	internal List<DiscordApplicationCommand> InternalRegisteredApplicationCommands { get; set; } = null;
 
 	/// <summary>
 	/// Gets the guild's AFK timeout.
 	/// </summary>
 	[JsonProperty("afk_timeout", NullValueHandling = NullValueHandling.Ignore)]
 	public int AfkTimeout { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's verification level.
 	/// </summary>
 	[JsonProperty("verification_level", NullValueHandling = NullValueHandling.Ignore)]
 	public VerificationLevel VerificationLevel { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's default notification settings.
 	/// </summary>
 	[JsonProperty("default_message_notifications", NullValueHandling = NullValueHandling.Ignore)]
 	public DefaultMessageNotifications DefaultMessageNotifications { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's explicit content filter settings.
 	/// </summary>
 	[JsonProperty("explicit_content_filter")]
 	public ExplicitContentFilter ExplicitContentFilter { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's nsfw level.
 	/// </summary>
 	[JsonProperty("nsfw_level")]
 	public NsfwLevel NsfwLevel { get; internal set; }
 
 	/// <summary>
 	/// Gets the system channel id.
 	/// </summary>
 	[JsonProperty("system_channel_id", NullValueHandling = NullValueHandling.Include)]
 	internal ulong? SystemChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the channel where system messages (such as boost and welcome messages) are sent.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel SystemChannel => this.SystemChannelId.HasValue
 		? this.GetChannel(this.SystemChannelId.Value)
 		: null;
 
 	/// <summary>
 	/// Gets the settings for this guild's system channel.
 	/// </summary>
 	[JsonProperty("system_channel_flags")]
 	public SystemChannelFlags SystemChannelFlags { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this guild's widget is enabled.
 	/// </summary>
 	[JsonProperty("widget_enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? WidgetEnabled { get; internal set; }
 
 	/// <summary>
 	/// Gets the widget channel id.
 	/// </summary>
 	[JsonProperty("widget_channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	internal ulong? WidgetChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the widget channel for this guild.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel WidgetChannel => this.WidgetChannelId.HasValue
 		? this.GetChannel(this.WidgetChannelId.Value)
 		: null;
 
 	/// <summary>
 	/// Gets the rules channel id.
 	/// </summary>
 	[JsonProperty("rules_channel_id")]
 	internal ulong? RulesChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the rules channel for this guild.
 	/// <para>This is only available if the guild is considered "discoverable".</para>
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel RulesChannel => this.RulesChannelId.HasValue
 		? this.GetChannel(this.RulesChannelId.Value)
 		: null;
 
 	/// <summary>
 	/// Gets the public updates channel id.
 	/// </summary>
 	[JsonProperty("public_updates_channel_id")]
 	internal ulong? PublicUpdatesChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the public updates channel (where admins and moderators receive messages from Discord) for this guild.
 	/// <para>This is only available if the guild is considered "discoverable".</para>
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel PublicUpdatesChannel => this.PublicUpdatesChannelId.HasValue
 		? this.GetChannel(this.PublicUpdatesChannelId.Value)
 		: null;
 
 	/// <summary>
 	/// Gets the application id of this guild if it is bot created.
 	/// </summary>
 	[JsonProperty("application_id")]
 	public ulong? ApplicationId { get; internal set; }
 
 	/// <summary>
 	/// Gets a collection of this guild's roles.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordRole> Roles => new ReadOnlyConcurrentDictionary<ulong, DiscordRole>(this.RolesInternal);
 
 	[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordRole> RolesInternal;
 
 	/// <summary>
 	/// Gets a collection of this guild's stickers.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordSticker> Stickers => new ReadOnlyConcurrentDictionary<ulong, DiscordSticker>(this.StickersInternal);
 
 	[JsonProperty("stickers", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordSticker> StickersInternal;
 
 	/// <summary>
 	/// Gets a collection of this guild's emojis.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordEmoji> Emojis => new ReadOnlyConcurrentDictionary<ulong, DiscordEmoji>(this.EmojisInternal);
 
 	[JsonProperty("emojis", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordEmoji> EmojisInternal;
 
 	/// <summary>
 	/// Gets a collection of this guild's features.
 	/// </summary>
 	[JsonProperty("features", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyList<string> RawFeatures { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild's features.
 	/// </summary>
 	[JsonIgnore]
 	public GuildFeatures Features => new(this);
 
 	/// <summary>
 	/// Gets the required multi-factor authentication level for this guild.
 	/// </summary>
 	[JsonProperty("mfa_level", NullValueHandling = NullValueHandling.Ignore)]
 	public MfaLevel MfaLevel { get; internal set; }
 
 	/// <summary>
 	/// Gets this guild's join date.
 	/// </summary>
 	[JsonProperty("joined_at", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset JoinedAt { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this guild is considered to be a large guild.
 	/// </summary>
 	[JsonProperty("large", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsLarge { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this guild is unavailable.
 	/// </summary>
 	[JsonProperty("unavailable", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsUnavailable { get; internal set; }
 
 	/// <summary>
 	/// Gets the total number of members in this guild.
 	/// </summary>
 	[JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int MemberCount { get; internal set; }
 
 	/// <summary>
 	/// Gets the maximum amount of members allowed for this guild.
 	/// </summary>
 	[JsonProperty("max_members")]
 	public int? MaxMembers { get; internal set; }
 
 	/// <summary>
 	/// Gets the maximum amount of presences allowed for this guild.
 	/// </summary>
 	[JsonProperty("max_presences")]
 	public int? MaxPresences { get; internal set; }
 
 	/// <summary>
 	/// Gets the approximate number of members in this guild, when using <see cref="DiscordClient.GetGuildAsync(ulong, bool?)"/> and having withCounts set to true.
 	/// </summary>
 	[JsonProperty("approximate_member_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? ApproximateMemberCount { get; internal set; }
 
 	/// <summary>
 	/// Gets the approximate number of presences in this guild, when using <see cref="DiscordClient.GetGuildAsync(ulong, bool?)"/> and having withCounts set to true.
 	/// </summary>
 	[JsonProperty("approximate_presence_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? ApproximatePresenceCount { get; internal set; }
 
 	/// <summary>
 	/// Gets the maximum amount of users allowed per video channel.
 	/// </summary>
 	[JsonProperty("max_video_channel_users", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MaxVideoChannelUsers { get; internal set; }
 
 	/// <summary>
 	/// Gets a dictionary of all the voice states for this guilds. The key for this dictionary is the ID of the user
 	/// the voice state corresponds to.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordVoiceState> VoiceStates => new ReadOnlyConcurrentDictionary<ulong, DiscordVoiceState>(this.VoiceStatesInternal);
 
 	[JsonProperty("voice_states", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordVoiceState> VoiceStatesInternal;
 
 	/// <summary>
 	/// Gets a dictionary of all the members that belong to this guild. The dictionary's key is the member ID.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordMember> Members => new ReadOnlyConcurrentDictionary<ulong, DiscordMember>(this.MembersInternal);
 
 	[JsonProperty("members", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordMember> MembersInternal;
 
 	/// <summary>
 	/// Gets a dictionary of all the channels associated with this guild. The dictionary's key is the channel ID.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordChannel> Channels => new ReadOnlyConcurrentDictionary<ulong, DiscordChannel>(this.ChannelsInternal);
 
 	[JsonProperty("channels", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordChannel> ChannelsInternal;
 
 	internal ConcurrentDictionary<string, DiscordInvite> Invites;
 
 	/// <summary>
 	/// Gets a dictionary of all the active threads associated with this guild the user has permission to view. The dictionary's key is the channel ID.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordThreadChannel> Threads { get; internal set; }
 
 	[JsonProperty("threads", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordThreadChannel> ThreadsInternal = new();
 
 	/// <summary>
 	/// Gets a dictionary of all active stage instances. The dictionary's key is the stage ID.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordStageInstance> StageInstances { get; internal set; }
 
 	[JsonProperty("stage_instances", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordStageInstance> StageInstancesInternal = new();
 
 	/// <summary>
 	/// Gets a dictionary of all scheduled events.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordScheduledEvent> ScheduledEvents { get; internal set; }
 
 	[JsonProperty("guild_scheduled_events", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordScheduledEvent> ScheduledEventsInternal = new();
 
 	/// <summary>
 	/// Gets the guild member for current user.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordMember CurrentMember
 		=> this._currentMemberLazy.Value;
 
 	[JsonIgnore]
 	private readonly Lazy<DiscordMember> _currentMemberLazy;
 
 	/// <summary>
 	/// Gets the @everyone role for this guild.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordRole EveryoneRole
 		=> this.GetRole(this.Id);
 
 	[JsonIgnore]
 	internal bool IsOwnerInternal;
 
 	/// <summary>
 	/// Gets whether the current user is the guild's owner.
 	/// </summary>
 	[JsonProperty("owner", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsOwner
 	{
 		get => this.IsOwnerInternal || this.OwnerId == this.Discord.CurrentUser.Id;
 		internal set => this.IsOwnerInternal = value;
 	}
 
 	/// <summary>
 	/// Gets the vanity URL code for this guild, when applicable.
 	/// </summary>
 	[JsonProperty("vanity_url_code")]
 	public string VanityUrlCode { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild description, when applicable.
 	/// </summary>
 	[JsonProperty("description")]
 	public string Description { get; internal set; }
 
 	/// <summary>
 	/// Gets this guild's banner hash, when applicable.
 	/// </summary>
 	[JsonProperty("banner")]
 	public string BannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets this guild's banner in url form.
 	/// </summary>
 	[JsonIgnore]
 	public string BannerUrl
 		=> !string.IsNullOrWhiteSpace(this.BannerHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Uri}{Endpoints.BANNERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}" : null;
 
 	/// <summary>
 	/// Whether this guild has the community feature enabled.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsCommunity => this.Features.HasCommunityEnabled;
 
 	/// <summary>
 	/// Whether this guild has enabled the welcome screen.
 	/// </summary>
 	[JsonIgnore]
 	public bool HasWelcomeScreen => this.Features.HasWelcomeScreenEnabled;
 
 	/// <summary>
 	/// Whether this guild has enabled membership screening.
 	/// </summary>
 	[JsonIgnore]
 	public bool HasMemberVerificationGate => this.Features.HasMembershipScreeningEnabled;
 
 	/// <summary>
 	/// Gets this guild's premium tier (Nitro boosting).
 	/// </summary>
 	[JsonProperty("premium_tier")]
 	public PremiumTier PremiumTier { get; internal set; }
 
 	/// <summary>
 	/// Gets the amount of members that boosted this guild.
 	/// </summary>
 	[JsonProperty("premium_subscription_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? PremiumSubscriptionCount { get; internal set; }
 
 	/// <summary>
 	/// Whether the premium progress bar is enabled.
 	/// </summary>
 	[JsonProperty("premium_progress_bar_enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public bool PremiumProgressBarEnabled { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this guild is designated as NSFW.
 	/// </summary>
 	[JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsNsfw { get; internal set; }
 
 	/// <summary>
 	/// Gets this guild's hub type, if applicable.
 	/// </summary>
 	[JsonProperty("hub_type", NullValueHandling = NullValueHandling.Ignore)]
 	public HubType HubType { get; internal set; }
 
 	/// <summary>
 	/// Gets a dictionary of all by position ordered channels associated with this guild. The dictionary's key is the channel ID.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordChannel> OrderedChannels => new ReadOnlyDictionary<ulong, DiscordChannel>(this.InternalSortChannels());
 
 	/// <summary>
 	/// Sorts the channels.
 	/// </summary>
 	private Dictionary<ulong, DiscordChannel> InternalSortChannels()
 	{
 		Dictionary<ulong, DiscordChannel> keyValuePairs = new();
 		var ochannels = this.GetOrderedChannels();
 		foreach (var ochan in ochannels)
 		{
 			if (ochan.Key != 0)
 				keyValuePairs.Add(ochan.Key, this.GetChannel(ochan.Key));
 			foreach (var chan in ochan.Value)
 				keyValuePairs.Add(chan.Id, chan);
 		}
 		return keyValuePairs;
 	}
 
 	/// <summary>
 	/// Gets an ordered <see cref="DiscordChannel"/> list out of the channel cache.
 	/// Returns a Dictionary where the key is an ulong and can be mapped to <see cref="ChannelType.Category"/> <see cref="DiscordChannel"/>s.
 	/// Ignore the 0 key here, because that indicates that this is the "has no category" list.
 	/// Each value contains a ordered list of text/news and voice/stage channels as <see cref="DiscordChannel"/>.
 	/// </summary>
 	/// <returns>A ordered list of categories with its channels</returns>
 	public Dictionary<ulong, List<DiscordChannel>> GetOrderedChannels()
 	{
 		IReadOnlyList<DiscordChannel> rawChannels = this.ChannelsInternal.Values.ToList();
 
 		Dictionary<ulong, List<DiscordChannel>> orderedChannels = new()
 		{
 			{ 0, new List<DiscordChannel>() }
 		};
 
 		foreach (var channel in rawChannels.Where(c => c.Type == ChannelType.Category).OrderBy(c => c.Position))
 		{
 			orderedChannels.Add(channel.Id, new List<DiscordChannel>());
 		}
 
 		foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
 		{
 			orderedChannels[channel.ParentId.Value].Add(channel);
 		}
 		foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 		{
 			orderedChannels[channel.ParentId.Value].Add(channel);
 		}
 
 		foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
 		{
 			orderedChannels[0].Add(channel);
 		}
 		foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 		{
 			orderedChannels[0].Add(channel);
 		}
 
 		return orderedChannels;
 	}
 
 	/// <summary>
 	/// Gets an ordered <see cref="DiscordChannel"/> list.
 	/// Returns a Dictionary where the key is an ulong and can be mapped to <see cref="ChannelType.Category"/> <see cref="DiscordChannel"/>s.
 	/// Ignore the 0 key here, because that indicates that this is the "has no category" list.
 	/// Each value contains a ordered list of text/news and voice/stage channels as <see cref="DiscordChannel"/>.
 	/// </summary>
 	/// <returns>A ordered list of categories with its channels</returns>
 	public async Task<Dictionary<ulong, List<DiscordChannel>>> GetOrderedChannelsAsync()
 	{
 		var rawChannels = await this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
 		Dictionary<ulong, List<DiscordChannel>> orderedChannels = new()
 		{
 			{ 0, new List<DiscordChannel>() }
 		};
 
 		foreach (var channel in rawChannels.Where(c => c.Type == ChannelType.Category).OrderBy(c => c.Position))
 		{
 			orderedChannels.Add(channel.Id, new List<DiscordChannel>());
 		}
 
 		foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
 		{
 			orderedChannels[channel.ParentId.Value].Add(channel);
 		}
 		foreach (var channel in rawChannels.Where(c => c.ParentId.HasValue && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 		{
 			orderedChannels[channel.ParentId.Value].Add(channel);
 		}
 
 		foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Text || c.Type == ChannelType.News)).OrderBy(c => c.Position))
 		{
 			orderedChannels[0].Add(channel);
 		}
 		foreach (var channel in rawChannels.Where(c => !c.ParentId.HasValue && c.Type != ChannelType.Category && (c.Type == ChannelType.Voice || c.Type == ChannelType.Stage)).OrderBy(c => c.Position))
 		{
 			orderedChannels[0].Add(channel);
 		}
 
 		return orderedChannels;
 	}
 
 	/// <summary>
 	/// Whether it is synced.
 	/// </summary>
 	[JsonIgnore]
 	internal bool IsSynced { get; set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordGuild"/> class.
 	/// </summary>
 	internal DiscordGuild()
 	{
 		this._currentMemberLazy = new Lazy<DiscordMember>(() => this.MembersInternal != null && this.MembersInternal.TryGetValue(this.Discord.CurrentUser.Id, out var member) ? member : null);
 		this.Invites = new ConcurrentDictionary<string, DiscordInvite>();
 		this.Threads = new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannel>(this.ThreadsInternal);
 		this.StageInstances = new ReadOnlyConcurrentDictionary<ulong, DiscordStageInstance>(this.StageInstancesInternal);
 		this.ScheduledEvents = new ReadOnlyConcurrentDictionary<ulong, DiscordScheduledEvent>(this.ScheduledEventsInternal);
 	}
 
 	#region Guild Methods
 
 	/// <summary>
 	/// Searches the current guild for members who's display name start with the specified name.
 	/// </summary>
 	/// <param name="name">The name to search for.</param>
 	/// <param name="limit">The maximum amount of members to return. Max 1000. Defaults to 1.</param>
 	/// <returns>The members found, if any.</returns>
 	public Task<IReadOnlyList<DiscordMember>> SearchMembersAsync(string name, int? limit = 1)
 		=> this.Discord.ApiClient.SearchMembersAsync(this.Id, name, limit);
 
 	/// <summary>
 	/// Adds a new member to this guild
 	/// </summary>
 	/// <param name="user">User to add</param>
 	/// <param name="accessToken">User's access token (OAuth2)</param>
 	/// <param name="nickname">new nickname</param>
 	/// <param name="roles">new roles</param>
 	/// <param name="muted">whether this user has to be muted</param>
 	/// <param name="deaf">whether this user has to be deafened</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreateInstantInvite" /> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the <paramref name="user"/> or <paramref name="accessToken"/> is not found.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddMemberAsync(DiscordUser user, string accessToken, string nickname = null, IEnumerable<DiscordRole> roles = null,
 		bool muted = false, bool deaf = false)
 		=> this.Discord.ApiClient.AddGuildMemberAsync(this.Id, user.Id, accessToken, nickname, roles, muted, deaf);
 
 	/// <summary>
 	/// Deletes this guild. Requires the caller to be the owner of the guild.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client is not the owner of the guild.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAsync()
 		=> this.Discord.ApiClient.DeleteGuildAsync(this.Id);
 
+	/// <summary>
+	/// Enables the mfa requirement for this guild.
+	/// </summary>
+	/// <param name="reason">The audit log reason.</param>
+	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the current user is not the guilds owner.</exception>
+	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+	public Task EnableMfaAsync(string reason = null)
+		=> this.IsOwner ? this.Discord.ApiClient.EnableGuildMfaAsync(this.Id, reason) : throw new Exception("The current user does not own the guild.");
+
+	/// <summary>
+	/// Disables the mfa requirement for this guild.
+	/// </summary>
+	/// <param name="reason">The audit log reason.</param>
+	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the current user is not the guilds owner.</exception>
+	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
+	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
+
+	public Task DisableMfaAsync(string reason = null)
+		=> this.IsOwner ? this.Discord.ApiClient.DisableGuildMfaAsync(this.Id, reason) : throw new Exception("The current user does not own the guild.");
+
 	/// <summary>
 	/// Modifies this guild.
 	/// </summary>
-	/// <param name="action">Action to perform on this guild..</param>
+	/// <param name="action">Action to perform on this guild.</param>
 	/// <returns>The modified guild object.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordGuild> ModifyAsync(Action<GuildEditModel> action)
 	{
 		var mdl = new GuildEditModel();
 		action(mdl);
 
 		var afkChannelId = mdl.PublicUpdatesChannel
 			.MapOrNull<ulong?>(c => c.Type != ChannelType.Voice
 				? throw new ArgumentException("AFK channel needs to be a text channel.")
 				: c.Id);
 
 		static Optional<ulong?> ChannelToId(Optional<DiscordChannel> ch, string name)
 			=> ch.MapOrNull<ulong?>(c => c.Type != ChannelType.Text && c.Type != ChannelType.News
 				? throw new ArgumentException($"{name} channel needs to be a text channel.")
 				: c.Id);
 
 		var rulesChannelId = ChannelToId(mdl.RulesChannel, "Rules");
 		var publicUpdatesChannelId = ChannelToId(mdl.PublicUpdatesChannel, "Public updates");
 		var systemChannelId = ChannelToId(mdl.SystemChannel, "System");
 
 		var iconb64 = ImageTool.Base64FromStream(mdl.Icon);
 		var splashb64 = ImageTool.Base64FromStream(mdl.Splash);
 		var bannerb64 = ImageTool.Base64FromStream(mdl.Banner);
 		var discoverySplash64 = ImageTool.Base64FromStream(mdl.DiscoverySplash);
 
 		return await this.Discord.ApiClient.ModifyGuildAsync(this.Id, mdl.Name,
 			mdl.VerificationLevel, mdl.DefaultMessageNotifications, mdl.MfaLevel, mdl.ExplicitContentFilter,
 			afkChannelId, mdl.AfkTimeout, iconb64, mdl.Owner.Map(e => e.Id), splashb64,
 			systemChannelId, mdl.SystemChannelFlags, publicUpdatesChannelId, rulesChannelId,
 			mdl.Description, bannerb64, discoverySplash64, mdl.PreferredLocale, mdl.PremiumProgressBarEnabled, mdl.AuditLogReason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Modifies the community settings async.
 	/// This sets <see cref="VerificationLevel.High"/> if not highest and <see cref="ExplicitContentFilter.AllMembers"/>.
 	/// </summary>
 	/// <param name="enabled">If true, enable <see cref="GuildFeatures.HasCommunityEnabled"/>.</param>
 	/// <param name="rulesChannel">The rules channel.</param>
 	/// <param name="publicUpdatesChannel">The public updates channel.</param>
 	/// <param name="preferredLocale">The preferred locale. Defaults to en-US.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="defaultMessageNotifications">The default message notifications. Defaults to <see cref="DefaultMessageNotifications.MentionsOnly"/></param>
 	/// <param name="reason">The audit log reason.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordGuild> ModifyCommunitySettingsAsync(bool enabled, DiscordChannel rulesChannel = null, DiscordChannel publicUpdatesChannel = null, string preferredLocale = "en-US", string description = null, DefaultMessageNotifications defaultMessageNotifications = DefaultMessageNotifications.MentionsOnly, string reason = null)
 	{
 		var verificationLevel = this.VerificationLevel;
 		if (this.VerificationLevel != VerificationLevel.Highest)
 		{
 			verificationLevel = VerificationLevel.High;
 		}
 
 		var explicitContentFilter = ExplicitContentFilter.AllMembers;
 
 		static Optional<ulong?> ChannelToId(DiscordChannel ch, string name)
 			=> ch == null ? null :
 				ch.Type != ChannelType.Text && ch.Type != ChannelType.News
 					? throw new ArgumentException($"{name} channel needs to be a text channel.")
 					: ch.Id;
 
 		var rulesChannelId = ChannelToId(rulesChannel, "Rules");
 		var publicUpdatesChannelId = ChannelToId(publicUpdatesChannel, "Public updates");
 
 		List<string> features = new();
 		var rfeatures = this.RawFeatures.ToList();
 		if (this.RawFeatures.Contains("COMMUNITY") && enabled)
 		{
 			features = rfeatures;
 		}
 		else if (!this.RawFeatures.Contains("COMMUNITY") && enabled)
 		{
 			rfeatures.Add("COMMUNITY");
 			features = rfeatures;
 		}
 		else if (this.RawFeatures.Contains("COMMUNITY") && !enabled)
 		{
 			rfeatures.Remove("COMMUNITY");
 			features = rfeatures;
 		}
 		else if (!this.RawFeatures.Contains("COMMUNITY") && !enabled)
 		{
 			features = rfeatures;
 		}
 
 		return await this.Discord.ApiClient.ModifyGuildCommunitySettingsAsync(this.Id, features, rulesChannelId, publicUpdatesChannelId, preferredLocale, description, defaultMessageNotifications, explicitContentFilter, verificationLevel, reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Timeout a specified member in this guild.
 	/// </summary>
 	/// <param name="memberId">Member to timeout.</param>
 	/// <param name="until">The datetime offset to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task TimeoutAsync(ulong memberId, DateTimeOffset until, string reason = null)
 		=> until.Subtract(DateTimeOffset.UtcNow).Days > 28
 			? throw new ArgumentException("Timeout can not be longer than 28 days")
 			: this.Discord.ApiClient.ModifyTimeoutAsync(this.Id, memberId, until, reason);
 
 	/// <summary>
 	/// Timeout a specified member in this guild.
 	/// </summary>
 	/// <param name="memberId">Member to timeout.</param>
 	/// <param name="until">The timespan to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task TimeoutAsync(ulong memberId, TimeSpan until, string reason = null)
 		=> this.TimeoutAsync(memberId, DateTimeOffset.UtcNow + until, reason);
 
 	/// <summary>
 	/// Timeout a specified member in this guild.
 	/// </summary>
 	/// <param name="memberId">Member to timeout.</param>
 	/// <param name="until">The datetime to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task TimeoutAsync(ulong memberId, DateTime until, string reason = null)
 		=> this.TimeoutAsync(memberId, until.ToUniversalTime() - DateTime.UtcNow, reason);
 
 	/// <summary>
 	/// Removes the timeout from a specified member in this guild.
 	/// </summary>
 	/// <param name="memberId">Member to remove the timeout from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveTimeoutAsync(ulong memberId, string reason = null)
 		=> this.Discord.ApiClient.ModifyTimeoutAsync(this.Id, memberId, null, reason);
 
 	/// <summary>
 	/// Bans a specified member from this guild.
 	/// </summary>
 	/// <param name="member">Member to ban.</param>
 	/// <param name="deleteMessageDays">How many days to remove messages from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task BanMemberAsync(DiscordMember member, int deleteMessageDays = 0, string reason = null)
 		=> this.Discord.ApiClient.CreateGuildBanAsync(this.Id, member.Id, deleteMessageDays, reason);
 
 	/// <summary>
 	/// Bans a specified user by ID. This doesn't require the user to be in this guild.
 	/// </summary>
 	/// <param name="userId">ID of the user to ban.</param>
 	/// <param name="deleteMessageDays">How many days to remove messages from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task BanMemberAsync(ulong userId, int deleteMessageDays = 0, string reason = null)
 		=> this.Discord.ApiClient.CreateGuildBanAsync(this.Id, userId, deleteMessageDays, reason);
 
 	/// <summary>
 	/// Unbans a user from this guild.
 	/// </summary>
 	/// <param name="user">User to unban.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UnbanMemberAsync(DiscordUser user, string reason = null)
 		=> this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, user.Id, reason);
 
 	/// <summary>
 	/// Unbans a user by ID.
 	/// </summary>
 	/// <param name="userId">ID of the user to unban.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UnbanMemberAsync(ulong userId, string reason = null)
 		=> this.Discord.ApiClient.RemoveGuildBanAsync(this.Id, userId, reason);
 
 	/// <summary>
 	/// Leaves this guild.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task LeaveAsync()
 		=> this.Discord.ApiClient.LeaveGuildAsync(this.Id);
 
 	/// <summary>
 	/// Gets the bans for this guild, allowing for pagination.
 	/// </summary>
 	/// <param name="limit">Maximum number of bans to fetch. Max 1000. Defaults to 1000.</param>
 	/// <param name="before">The Id of the user before which to fetch the bans. Overrides <paramref name="after"/> if both are present.</param>
 	/// <param name="after">The Id of the user after which to fetch the bans.</param>
 	/// <returns>Collection of bans in this guild in ascending order by user id.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordBan>> GetBansAsync(int? limit = null, ulong? before = null, ulong? after = null)
 		=> this.Discord.ApiClient.GetGuildBansAsync(this.Id, limit, before, after);
 
 	/// <summary>
 	/// Gets a ban for a specific user.
 	/// </summary>
 	/// <param name="userId">The Id of the user to get the ban for.</param>
 	/// <returns>The requested ban object.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the specified user is not banned.</exception>
 	public Task<DiscordBan> GetBanAsync(ulong userId)
 		=> this.Discord.ApiClient.GetGuildBanAsync(this.Id, userId);
 
 	/// <summary>
 	/// Gets a ban for a specific user.
 	/// </summary>
 	/// <param name="user">The user to get the ban for.</param>
 	/// <returns>The requested ban object.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the specified user is not banned.</exception>
 	public Task<DiscordBan> GetBanAsync(DiscordUser user)
 		=> this.GetBanAsync(user.Id);
 
 	#region Scheduled Events
 
 	/// <summary>
 	/// Creates a scheduled event.
 	/// </summary>
 	/// <param name="name">The name.</param>
 	/// <param name="scheduledStartTime">The scheduled start time.</param>
 	/// <param name="scheduledEndTime">The scheduled end time.</param>
 	/// <param name="channel">The channel.</param>
 	/// <param name="metadata">The metadata.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="type">The type.</param>
 	/// <param name="coverImage">The cover image.</param>
 	/// <param name="reason">The reason.</param>
 	/// <returns>A scheduled event.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordScheduledEvent> CreateScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, DateTimeOffset? scheduledEndTime = null, DiscordChannel channel = null, DiscordScheduledEventEntityMetadata metadata = null, string description = null, ScheduledEventEntityType type = ScheduledEventEntityType.StageInstance, Optional<Stream> coverImage = default, string reason = null)
 	{
 		var coverb64 = ImageTool.Base64FromStream(coverImage);
 		return await this.Discord.ApiClient.CreateGuildScheduledEventAsync(this.Id, type == ScheduledEventEntityType.External ? null : channel?.Id, type == ScheduledEventEntityType.External ? metadata : null, name, scheduledStartTime, scheduledEndTime.HasValue && type == ScheduledEventEntityType.External ? scheduledEndTime.Value : null, description, type, coverb64, reason);
 	}
 
 	/// <summary>
 	/// Creates a scheduled event with type <see cref="ScheduledEventEntityType.External"/>.
 	/// </summary>
 	/// <param name="name">The name.</param>
 	/// <param name="scheduledStartTime">The scheduled start time.</param>
 	/// <param name="scheduledEndTime">The scheduled end time.</param>
 	/// <param name="location">The location of the external event.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="coverImage">The cover image.</param>
 	/// <param name="reason">The reason.</param>
 	/// <returns>A scheduled event.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordScheduledEvent> CreateExternalScheduledEventAsync(string name, DateTimeOffset scheduledStartTime, DateTimeOffset scheduledEndTime, string location, string description = null, Optional<Stream> coverImage = default, string reason = null)
 	{
 		var coverb64 = ImageTool.Base64FromStream(coverImage);
 		return await this.Discord.ApiClient.CreateGuildScheduledEventAsync(this.Id, null, new DiscordScheduledEventEntityMetadata(location), name, scheduledStartTime, scheduledEndTime, description, ScheduledEventEntityType.External, coverb64, reason);
 	}
 
 
 	/// <summary>
 	/// Gets a specific scheduled events.
 	/// </summary>
 	/// <param name="scheduledEventId">The Id of the event to get.</param>
 	/// <param name="withUserCount">Whether to include user count.</param>
 	/// <returns>A scheduled event.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordScheduledEvent> GetScheduledEventAsync(ulong scheduledEventId, bool? withUserCount = null)
 		=> this.ScheduledEventsInternal.TryGetValue(scheduledEventId, out var ev) ? ev : await this.Discord.ApiClient.GetGuildScheduledEventAsync(this.Id, scheduledEventId, withUserCount);
 
 	/// <summary>
 	/// Gets a specific scheduled events.
 	/// </summary>
 	/// <param name="scheduledEvent">The event to get.</param>
 	/// <param name="withUserCount">Whether to include user count.</param>
 	/// <returns>A scheduled event.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordScheduledEvent> GetScheduledEventAsync(DiscordScheduledEvent scheduledEvent, bool? withUserCount = null)
 		=> await this.GetScheduledEventAsync(scheduledEvent.Id, withUserCount);
 
 	/// <summary>
 	/// Gets the guilds scheduled events.
 	/// </summary>
 	/// <param name="withUserCount">Whether to include user count.</param>
 	/// <returns>A list of the guilds scheduled events.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyDictionary<ulong, DiscordScheduledEvent>> GetScheduledEventsAsync(bool? withUserCount = null)
 		=> await this.Discord.ApiClient.ListGuildScheduledEventsAsync(this.Id, withUserCount);
 	#endregion
 
 	/// <summary>
 	/// Creates a new text channel in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new channel.</param>
 	/// <param name="parent">Category to put this channel in.</param>
 	/// <param name="topic">Topic of the channel.</param>
 	/// <param name="overwrites">Permission overwrites for this channel.</param>
 	/// <param name="nsfw">Whether the channel is to be flagged as not safe for work.</param>
 	/// <param name="perUserRateLimit">Slow mode timeout for users.</param>
 	/// <param name="defaultAutoArchiveDuration">The default auto archive duration for new threads.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created channel.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordChannel> CreateTextChannelAsync(string name, DiscordChannel parent = null, Optional<string> topic = default, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, ThreadAutoArchiveDuration defaultAutoArchiveDuration = ThreadAutoArchiveDuration.OneDay, string reason = null)
 		=> this.CreateChannelAsync(name, ChannelType.Text, parent, topic, null, null, overwrites, nsfw, perUserRateLimit, null, defaultAutoArchiveDuration, reason);
 
 	/// <summary>
 	/// Creates a new channel category in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new category.</param>
 	/// <param name="overwrites">Permission overwrites for this category.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created channel category.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordChannel> CreateChannelCategoryAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
 		=> this.CreateChannelAsync(name, ChannelType.Category, null, Optional.None, null, null, overwrites, null, Optional.None, null, null, reason);
 
 	/// <summary>
 	/// Creates a new stage channel in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new stage channel.</param>
 	/// <param name="overwrites">Permission overwrites for this stage channel.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created stage channel.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.NotSupportedException">Thrown when the guilds has not enabled community.</exception>
 	public Task<DiscordChannel> CreateStageChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null)
 		=> this.Features.HasCommunityEnabled ? this.CreateChannelAsync(name, ChannelType.Stage, null, Optional.None, null, null, overwrites, null, Optional.None, null, null, reason) : throw new NotSupportedException("Guild has not enabled community. Can not create a stage channel.");
 
 	/// <summary>
 	/// Creates a new news channel in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new news channel.</param>
 	/// <param name="overwrites">Permission overwrites for this news channel.</param>
 	/// <param name="defaultAutoArchiveDuration">The default auto archive duration for new threads.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created news channel.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/>.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.NotSupportedException">Thrown when the guilds has not enabled community.</exception>
 	public Task<DiscordChannel> CreateNewsChannelAsync(string name, IEnumerable<DiscordOverwriteBuilder> overwrites = null, string reason = null, ThreadAutoArchiveDuration defaultAutoArchiveDuration = ThreadAutoArchiveDuration.OneDay)
 		=> this.Features.HasCommunityEnabled ? this.CreateChannelAsync(name, ChannelType.News, null, Optional.None, null, null, overwrites, null, Optional.None, null, defaultAutoArchiveDuration, reason) : throw new NotSupportedException("Guild has not enabled community. Can not create a news channel.");
 
 	/// <summary>
 	/// Creates a new voice channel in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new channel.</param>
 	/// <param name="parent">Category to put this channel in.</param>
 	/// <param name="bitrate">Bitrate of the channel.</param>
 	/// <param name="userLimit">Maximum number of users in the channel.</param>
 	/// <param name="overwrites">Permission overwrites for this channel.</param>
 	/// <param name="qualityMode">Video quality mode of the channel.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created channel.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordChannel> CreateVoiceChannelAsync(string name, DiscordChannel parent = null, int? bitrate = null, int? userLimit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, VideoQualityMode? qualityMode = null, string reason = null)
 		=> this.CreateChannelAsync(name, ChannelType.Voice, parent, Optional.None, bitrate, userLimit, overwrites, null, Optional.None, qualityMode, null, reason);
 
 	/// <summary>
 	/// Creates a new channel in this guild.
 	/// </summary>
 	/// <param name="name">Name of the new channel.</param>
 	/// <param name="type">Type of the new channel.</param>
 	/// <param name="parent">Category to put this channel in.</param>
 	/// <param name="topic">Topic of the channel.</param>
 	/// <param name="bitrate">Bitrate of the channel. Applies to voice only.</param>
 	/// <param name="userLimit">Maximum number of users in the channel. Applies to voice only.</param>
 	/// <param name="overwrites">Permission overwrites for this channel.</param>
 	/// <param name="nsfw">Whether the channel is to be flagged as not safe for work. Applies to text only.</param>
 	/// <param name="perUserRateLimit">Slow mode timeout for users.</param>
 	/// <param name="qualityMode">Video quality mode of the channel. Applies to voice only.</param>
 	/// <param name="defaultAutoArchiveDuration">The default auto archive duration for new threads.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created channel.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordChannel> CreateChannelAsync(string name, ChannelType type, DiscordChannel parent = null, Optional<string> topic = default, int? bitrate = null, int? userLimit = null, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<int?> perUserRateLimit = default, VideoQualityMode? qualityMode = null, ThreadAutoArchiveDuration? defaultAutoArchiveDuration = null, string reason = null) =>
 		// technically you can create news/store channels but not always
 		type != ChannelType.Text && type != ChannelType.Voice && type != ChannelType.Category && type != ChannelType.News && type != ChannelType.Store && type != ChannelType.Stage
 			? throw new ArgumentException("Channel type must be text, voice, stage, or category.", nameof(type))
 			: type == ChannelType.Category && parent != null
 				? throw new ArgumentException("Cannot specify parent of a channel category.", nameof(parent))
 				: this.Discord.ApiClient.CreateGuildChannelAsync(this.Id, name, type, parent?.Id, topic, bitrate, userLimit, overwrites, nsfw, perUserRateLimit, qualityMode, defaultAutoArchiveDuration, reason);
 
 	/// <summary>
 	/// Gets active threads. Can contain more threads.
 	/// If the result's value 'HasMore' is true, you need to recall this function to get older threads.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordThreadResult> GetActiveThreadsAsync()
 		=> this.Discord.ApiClient.GetActiveThreadsAsync(this.Id);
 
 	/// <summary>
 	/// <para>Deletes all channels in this guild.</para>
 	/// <para>Note that this is irreversible. Use carefully!</para>
 	/// </summary>
 	/// <returns></returns>
 	public Task DeleteAllChannelsAsync()
 	{
 		var tasks = this.Channels.Values.Select(xc => xc.DeleteAsync());
 		return Task.WhenAll(tasks);
 	}
 
 	/// <summary>
 	/// Estimates the number of users to be pruned.
 	/// </summary>
 	/// <param name="days">Minimum number of inactivity days required for users to be pruned. Defaults to 7.</param>
 	/// <param name="includedRoles">The roles to be included in the prune.</param>
 	/// <returns>Number of users that will be pruned.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<int> GetPruneCountAsync(int days = 7, IEnumerable<DiscordRole> includedRoles = null)
 	{
 		if (includedRoles != null)
 		{
 			includedRoles = includedRoles.Where(r => r != null);
 			var rawRoleIds = includedRoles
 				.Where(x => this.RolesInternal.ContainsKey(x.Id))
 				.Select(x => x.Id);
 
 			return this.Discord.ApiClient.GetGuildPruneCountAsync(this.Id, days, rawRoleIds);
 		}
 
 		return this.Discord.ApiClient.GetGuildPruneCountAsync(this.Id, days, null);
 	}
 
 	/// <summary>
 	/// Prunes inactive users from this guild.
 	/// </summary>
 	/// <param name="days">Minimum number of inactivity days required for users to be pruned. Defaults to 7.</param>
 	/// <param name="computePruneCount">Whether to return the prune count after this method completes. This is discouraged for larger guilds.</param>
 	/// <param name="includedRoles">The roles to be included in the prune.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>Number of users pruned.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageChannels"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<int?> PruneAsync(int days = 7, bool computePruneCount = true, IEnumerable<DiscordRole> includedRoles = null, string reason = null)
 	{
 		if (includedRoles != null)
 		{
 			includedRoles = includedRoles.Where(r => r != null);
 			var rawRoleIds = includedRoles
 				.Where(x => this.RolesInternal.ContainsKey(x.Id))
 				.Select(x => x.Id);
 
 			return this.Discord.ApiClient.BeginGuildPruneAsync(this.Id, days, computePruneCount, rawRoleIds, reason);
 		}
 
 		return this.Discord.ApiClient.BeginGuildPruneAsync(this.Id, days, computePruneCount, null, reason);
 	}
 
 	/// <summary>
 	/// Gets integrations attached to this guild.
 	/// </summary>
 	/// <returns>Collection of integrations attached to this guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordIntegration>> GetIntegrationsAsync()
 		=> this.Discord.ApiClient.GetGuildIntegrationsAsync(this.Id);
 
 	/// <summary>
 	/// Attaches an integration from current user to this guild.
 	/// </summary>
 	/// <param name="integration">Integration to attach.</param>
 	/// <returns>The integration after being attached to the guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordIntegration> AttachUserIntegrationAsync(DiscordIntegration integration)
 		=> this.Discord.ApiClient.CreateGuildIntegrationAsync(this.Id, integration.Type, integration.Id);
 
 	/// <summary>
 	/// Modifies an integration in this guild.
 	/// </summary>
 	/// <param name="integration">Integration to modify.</param>
 	/// <param name="expireBehaviour">Number of days after which the integration expires.</param>
 	/// <param name="expireGracePeriod">Length of grace period which allows for renewing the integration.</param>
 	/// <param name="enableEmoticons">Whether emotes should be synced from this integration.</param>
 	/// <returns>The modified integration.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordIntegration> ModifyIntegrationAsync(DiscordIntegration integration, int expireBehaviour, int expireGracePeriod, bool enableEmoticons)
 		=> this.Discord.ApiClient.ModifyGuildIntegrationAsync(this.Id, integration.Id, expireBehaviour, expireGracePeriod, enableEmoticons);
 
 	/// <summary>
 	/// Removes an integration from this guild.
 	/// </summary>
 	/// <param name="integration">Integration to remove.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteIntegrationAsync(DiscordIntegration integration)
 		=> this.Discord.ApiClient.DeleteGuildIntegrationAsync(this.Id, integration);
 
 	/// <summary>
 	/// Forces re-synchronization of an integration for this guild.
 	/// </summary>
 	/// <param name="integration">Integration to synchronize.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the guild does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task SyncIntegrationAsync(DiscordIntegration integration)
 		=> this.Discord.ApiClient.SyncGuildIntegrationAsync(this.Id, integration.Id);
 
 	/// <summary>
 	/// Gets the voice regions for this guild.
 	/// </summary>
 	/// <returns>Voice regions available for this guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
 	{
 		var vrs = await this.Discord.ApiClient.GetGuildVoiceRegionsAsync(this.Id).ConfigureAwait(false);
 		foreach (var xvr in vrs)
 			this.Discord.InternalVoiceRegions.TryAdd(xvr.Id, xvr);
 
 		return vrs;
 	}
 
 	/// <summary>
 	/// Gets an invite from this guild from an invite code.
 	/// </summary>
 	/// <param name="code">The invite code</param>
 	/// <returns>An invite, or null if not in cache.</returns>
 	public DiscordInvite GetInvite(string code)
 		=> this.Invites.TryGetValue(code, out var invite) ? invite : null;
 
 	/// <summary>
 	/// Gets all the invites created for all the channels in this guild.
 	/// </summary>
 	/// <returns>A collection of invites.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordInvite>> GetInvitesAsync()
 	{
 		var res = await this.Discord.ApiClient.GetGuildInvitesAsync(this.Id).ConfigureAwait(false);
 
 		var intents = this.Discord.Configuration.Intents;
 
 		if (!intents.HasIntent(DiscordIntents.GuildInvites))
 		{
 			foreach (var r in res)
 				this.Invites[r.Code] = r;
 		}
 
 		return res;
 	}
 
 	/// <summary>
 	/// Gets the vanity invite for this guild.
 	/// </summary>
 	/// <returns>A partial vanity invite.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordInvite> GetVanityInviteAsync()
 		=> this.Discord.ApiClient.GetGuildVanityUrlAsync(this.Id);
 
 	/// <summary>
 	/// Gets all the webhooks created for all the channels in this guild.
 	/// </summary>
 	/// <returns>A collection of webhooks this guild has.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageWebhooks"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordWebhook>> GetWebhooksAsync()
 		=> this.Discord.ApiClient.GetGuildWebhooksAsync(this.Id);
 
 	/// <summary>
 	/// Gets this guild's widget image.
 	/// </summary>
 	/// <param name="bannerType">The format of the widget.</param>
 	/// <returns>The URL of the widget image.</returns>
 	public string GetWidgetImage(WidgetType bannerType = WidgetType.Shield)
 	{
 		var param = bannerType switch
 		{
 			WidgetType.Banner1 => "banner1",
 			WidgetType.Banner2 => "banner2",
 			WidgetType.Banner3 => "banner3",
 			WidgetType.Banner4 => "banner4",
 			_ => "shield",
 		};
 		return $"{Endpoints.BASE_URI}{Endpoints.GUILDS}/{this.Id}{Endpoints.WIDGET_PNG}?style={param}";
 	}
 
 	/// <summary>
 	/// Gets a member of this guild by their user ID.
 	/// </summary>
 	/// <param name="userId">ID of the member to get.</param>
 	/// <returns>The requested member.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMember> GetMemberAsync(ulong userId)
 	{
 		if (this.MembersInternal != null && this.MembersInternal.TryGetValue(userId, out var mbr))
 			return mbr;
 
 		mbr = await this.Discord.ApiClient.GetGuildMemberAsync(this.Id, userId).ConfigureAwait(false);
 
 		var intents = this.Discord.Configuration.Intents;
 
 		if (intents.HasIntent(DiscordIntents.GuildMembers))
 		{
 			if (this.MembersInternal != null)
 			{
 				this.MembersInternal[userId] = mbr;
 			}
 		}
 
 		return mbr;
 	}
 
 	/// <summary>
 	/// Retrieves a full list of members from Discord. This method will bypass cache.
 	/// </summary>
 	/// <returns>A collection of all members in this guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyCollection<DiscordMember>> GetAllMembersAsync()
 	{
 		var recmbr = new HashSet<DiscordMember>();
 
 		var recd = 1000;
 		var last = 0ul;
 		while (recd > 0)
 		{
 			var tms = await this.Discord.ApiClient.ListGuildMembersAsync(this.Id, 1000, last == 0 ? null : (ulong?)last).ConfigureAwait(false);
 			recd = tms.Count;
 
 			foreach (var xtm in tms)
 			{
 				var usr = new DiscordUser(xtm.User) { Discord = this.Discord };
 
 				usr = this.Discord.UserCache.AddOrUpdate(xtm.User.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discord = usr.Discord;
 					old.AvatarHash = usr.AvatarHash;
 
 					return old;
 				});
 
 				recmbr.Add(new DiscordMember(xtm) { Discord = this.Discord, GuildId = this.Id });
 			}
 
 			var tm = tms.LastOrDefault();
 			last = tm?.User.Id ?? 0;
 		}
 
 		return new ReadOnlySet<DiscordMember>(recmbr);
 	}
 
 	/// <summary>
 	/// Requests that Discord send a list of guild members based on the specified arguments. This method will fire the <see cref="DiscordClient.GuildMembersChunked"/> event.
 	/// <para>If no arguments aside from <paramref name="presences"/> and <paramref name="nonce"/> are specified, this will request all guild members.</para>
 	/// </summary>
 	/// <param name="query">Filters the returned members based on what the username starts with. Either this or <paramref name="userIds"/> must not be null.
 	/// The <paramref name="limit"/> must also be greater than 0 if this is specified.</param>
 	/// <param name="limit">Total number of members to request. This must be greater than 0 if <paramref name="query"/> is specified.</param>
 	/// <param name="presences">Whether to include the <see cref="DisCatSharp.EventArgs.GuildMembersChunkEventArgs.Presences"/> associated with the fetched members.</param>
 	/// <param name="userIds">Whether to limit the request to the specified user ids. Either this or <paramref name="query"/> must not be null.</param>
 	/// <param name="nonce">The unique string to identify the response.</param>
 	public async Task RequestMembersAsync(string query = "", int limit = 0, bool? presences = null, IEnumerable<ulong> userIds = null, string nonce = null)
 	{
 		if (this.Discord is not DiscordClient client)
 			throw new InvalidOperationException("This operation is only valid for regular Discord clients.");
 
 		if (query == null && userIds == null)
 			throw new ArgumentException("The query and user IDs cannot both be null.");
 
 		if (query != null && userIds != null)
 			query = null;
 
 		var grgm = new GatewayRequestGuildMembers(this)
 		{
 			Query = query,
 			Limit = limit >= 0 ? limit : 0,
 			Presences = presences,
 			UserIds = userIds,
 			Nonce = nonce
 		};
 
 		var payload = new GatewayPayload
 		{
 			OpCode = GatewayOpCode.RequestGuildMembers,
 			Data = grgm
 		};
 
 		var payloadStr = JsonConvert.SerializeObject(payload, Formatting.None);
 		await client.WsSendAsync(payloadStr).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Gets all the channels this guild has.
 	/// </summary>
 	/// <returns>A collection of this guild's channels.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordChannel>> GetChannelsAsync()
 		=> this.Discord.ApiClient.GetGuildChannelsAsync(this.Id);
 
 	/// <summary>
 	/// Creates a new role in this guild.
 	/// </summary>
 	/// <param name="name">Name of the role.</param>
 	/// <param name="permissions">Permissions for the role.</param>
 	/// <param name="color">Color for the role.</param>
 	/// <param name="hoist">Whether the role is to be hoisted.</param>
 	/// <param name="mentionable">Whether the role is to be mentionable.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns>The newly-created role.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordRole> CreateRoleAsync(string name = null, Permissions? permissions = null, DiscordColor? color = null, bool? hoist = null, bool? mentionable = null, string reason = null)
 		=> this.Discord.ApiClient.CreateGuildRoleAsync(this.Id, name, permissions, color?.Value, hoist, mentionable, reason);
 
 	/// <summary>
 	/// Gets a role from this guild by its ID.
 	/// </summary>
 	/// <param name="id">ID of the role to get.</param>
 	/// <returns>Requested role.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public DiscordRole GetRole(ulong id)
 		=> this.RolesInternal.TryGetValue(id, out var role) ? role : null;
 
 	/// <summary>
 	/// Gets a channel from this guild by its ID.
 	/// </summary>
 	/// <param name="id">ID of the channel to get.</param>
 	/// <returns>Requested channel.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public DiscordChannel GetChannel(ulong id)
 		=> this.ChannelsInternal != null && this.ChannelsInternal.TryGetValue(id, out var channel) ? channel : null;
 
 	/// <summary>
 	/// Gets a thread from this guild by its ID.
 	/// </summary>
 	/// <param name="id">ID of the thread to get.</param>
 	/// <returns>Requested thread.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public DiscordThreadChannel GetThread(ulong id)
 		=> this.ThreadsInternal != null && this.ThreadsInternal.TryGetValue(id, out var thread) ? thread : null;
 
 	/// <summary>
 	/// Gets all of this guild's custom emojis.
 	/// </summary>
 	/// <returns>All of this guild's custom emojis.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordGuildEmoji>> GetEmojisAsync()
 		=> this.Discord.ApiClient.GetGuildEmojisAsync(this.Id);
 
 	/// <summary>
 	/// Gets this guild's specified custom emoji.
 	/// </summary>
 	/// <param name="id">ID of the emoji to get.</param>
 	/// <returns>The requested custom emoji.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildEmoji> GetEmojiAsync(ulong id)
 		=> this.Discord.ApiClient.GetGuildEmojiAsync(this.Id, id);
 
 	/// <summary>
 	/// Creates a new custom emoji for this guild.
 	/// </summary>
 	/// <param name="name">Name of the new emoji.</param>
 	/// <param name="image">Image to use as the emoji.</param>
 	/// <param name="roles">Roles for which the emoji will be available. This works only if your application is whitelisted as integration.</param>
 	/// <param name="reason">Reason for audit log.</param>
 	/// <returns>The newly-created emoji.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildEmoji> CreateEmojiAsync(string name, Stream image, IEnumerable<DiscordRole> roles = null, string reason = null)
 	{
 		if (string.IsNullOrWhiteSpace(name))
 			throw new ArgumentNullException(nameof(name));
 
 		name = name.Trim();
 		if (name.Length < 2 || name.Length > 50)
 			throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.");
 
 		if (image == null)
 			throw new ArgumentNullException(nameof(image));
 
 		var image64 = ImageTool.Base64FromStream(image);
 
 		return this.Discord.ApiClient.CreateGuildEmojiAsync(this.Id, name, image64, roles?.Select(xr => xr.Id), reason);
 	}
 
 	/// <summary>
 	/// Modifies a this guild's custom emoji.
 	/// </summary>
 	/// <param name="emoji">Emoji to modify.</param>
 	/// <param name="name">New name for the emoji.</param>
 	/// <param name="roles">Roles for which the emoji will be available. This works only if your application is whitelisted as integration.</param>
 	/// <param name="reason">Reason for audit log.</param>
 	/// <returns>The modified emoji.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildEmoji> ModifyEmojiAsync(DiscordGuildEmoji emoji, string name, IEnumerable<DiscordRole> roles = null, string reason = null)
 	{
 		if (emoji == null)
 			throw new ArgumentNullException(nameof(emoji));
 
 		if (emoji.Guild.Id != this.Id)
 			throw new ArgumentException("This emoji does not belong to this guild.");
 
 		if (string.IsNullOrWhiteSpace(name))
 			throw new ArgumentNullException(nameof(name));
 
 		name = name.Trim();
 		return name.Length < 2 || name.Length > 50
 			? throw new ArgumentException("Emoji name needs to be between 2 and 50 characters long.")
 			: this.Discord.ApiClient.ModifyGuildEmojiAsync(this.Id, emoji.Id, name, roles?.Select(xr => xr.Id), reason);
 	}
 
 	/// <summary>
 	/// Deletes this guild's custom emoji.
 	/// </summary>
 	/// <param name="emoji">Emoji to delete.</param>
 	/// <param name="reason">Reason for audit log.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteEmojiAsync(DiscordGuildEmoji emoji, string reason = null) =>
 		emoji == null
 			? throw new ArgumentNullException(nameof(emoji))
 			: emoji.Guild.Id != this.Id
 				? throw new ArgumentException("This emoji does not belong to this guild.")
 				: this.Discord.ApiClient.DeleteGuildEmojiAsync(this.Id, emoji.Id, reason);
 
 	/// <summary>
 	/// Gets all of this guild's custom stickers.
 	/// </summary>
 	/// <returns>All of this guild's custom stickers.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordSticker>> GetStickersAsync()
 	{
 		var stickers = await this.Discord.ApiClient.GetGuildStickersAsync(this.Id);
 
 		foreach (var xstr in stickers)
 		{
 			this.StickersInternal.AddOrUpdate(xstr.Id, xstr, (id, old) =>
 			{
 				old.Name = xstr.Name;
 				old.Description = xstr.Description;
 				old.InternalTags = xstr.InternalTags;
 				return old;
 			});
 		}
 
 		return stickers;
 	}
 
 	/// <summary>
 	/// Gets a sticker
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task<DiscordSticker> GetStickerAsync(ulong stickerId)
 		=> this.Discord.ApiClient.GetGuildStickerAsync(this.Id, stickerId);
 
 	/// <summary>
 	/// Creates a sticker
 	/// </summary>
 	/// <param name="name">The name of the sticker.</param>
 	/// <param name="description">The optional description of the sticker.</param>
 	/// <param name="emoji">The emoji to associate the sticker with.</param>
 	/// <param name="format">The file format the sticker is written in.</param>
 	/// <param name="file">The sticker.</param>
 	/// <param name="reason">Audit log reason</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordSticker> CreateStickerAsync(string name, string description, DiscordEmoji emoji, Stream file, StickerFormat format, string reason = null)
 	{
 		var fileExt = format switch
 		{
 			StickerFormat.Png => "png",
 			StickerFormat.Apng => "png",
 			StickerFormat.Lottie => "json",
 			_ => throw new InvalidOperationException("This format is not supported.")
 		};
 
 		var contentType = format switch
 		{
 			StickerFormat.Png => "image/png",
 			StickerFormat.Apng => "image/png",
 			StickerFormat.Lottie => "application/json",
 			_ => throw new InvalidOperationException("This format is not supported.")
 		};
 
 		return emoji.Id is not 0
 			? throw new InvalidOperationException("Only unicode emoji can be used for stickers.")
 			: name.Length < 2 || name.Length > 30
 			? throw new ArgumentOutOfRangeException(nameof(name), "Sticker name needs to be between 2 and 30 characters long.")
 			: description.Length < 1 || description.Length > 100
 			? throw new ArgumentOutOfRangeException(nameof(description), "Sticker description needs to be between 1 and 100 characters long.")
 			: this.Discord.ApiClient.CreateGuildStickerAsync(this.Id, name, description, emoji.GetDiscordName().Replace(":", ""), new DiscordMessageFile("sticker", file, null, fileExt, contentType), reason);
 	}
 
 	/// <summary>
 	/// Modifies a sticker
 	/// </summary>
 	/// <param name="sticker">The id of the sticker to modify</param>
 	/// <param name="name">The name of the sticker</param>
 	/// <param name="description">The description of the sticker</param>
 	/// <param name="emoji">The emoji to associate with this sticker.</param>
 	/// <param name="reason">Audit log reason</param>
 	/// <returns>A sticker object</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 	public async Task<DiscordSticker> ModifyStickerAsync(ulong sticker, Optional<string> name, Optional<string> description, Optional<DiscordEmoji> emoji, string reason = null)
 	{
 		if (!this.StickersInternal.TryGetValue(sticker, out var stickerobj) || stickerobj.Guild.Id != this.Id)
 			throw new ArgumentException("This sticker does not belong to this guild.");
 		if (name.HasValue && (name.Value.Length < 2 || name.Value.Length > 30))
 			throw new ArgumentException("Sticker name needs to be between 2 and 30 characters long.");
 		if (description.HasValue && (description.Value.Length < 1 || description.Value.Length > 100))
 			throw new ArgumentException("Sticker description needs to be between 1 and 100 characters long.");
 		if (emoji.HasValue && emoji.Value.Id > 0)
 			throw new ArgumentException("Only unicode emojis can be used with stickers.");
 
 		string uemoji = null;
 		if (emoji.HasValue)
 			uemoji = emoji.Value.GetDiscordName().Replace(":", "");
 
 		var usticker = await this.Discord.ApiClient.ModifyGuildStickerAsync(this.Id, sticker, name, description, uemoji, reason).ConfigureAwait(false);
 
 
 		if (this.StickersInternal.TryGetValue(usticker.Id, out var old))
 			this.StickersInternal.TryUpdate(usticker.Id, usticker, old);
 
 		return usticker;
 	}
 
 	/// <summary>
 	/// Modifies a sticker
 	/// </summary>
 	/// <param name="sticker">The sticker to modify</param>
 	/// <param name="name">The name of the sticker</param>
 	/// <param name="description">The description of the sticker</param>
 	/// <param name="emoji">The emoji to associate with this sticker.</param>
 	/// <param name="reason">Audit log reason</param>
 	/// <returns>A sticker object</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task<DiscordSticker> ModifyStickerAsync(DiscordSticker sticker, Optional<string> name, Optional<string> description, Optional<DiscordEmoji> emoji, string reason = null)
 		=> this.ModifyStickerAsync(sticker.Id, name, description, emoji, reason);
 
 	/// <summary>
 	/// Deletes a sticker
 	/// </summary>
 	/// <param name="sticker">Id of sticker to delete</param>
 	/// <param name="reason">Audit log reason</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task DeleteStickerAsync(ulong sticker, string reason = null) =>
 		!this.StickersInternal.TryGetValue(sticker, out var stickerobj)
 			? throw new ArgumentNullException(nameof(sticker))
 			: stickerobj.Guild.Id != this.Id
 				? throw new ArgumentException("This sticker does not belong to this guild.")
 				: this.Discord.ApiClient.DeleteGuildStickerAsync(this.Id, sticker, reason);
 
 	/// <summary>
 	/// Deletes a sticker
 	/// </summary>
 	/// <param name="sticker">Sticker to delete</param>
 	/// <param name="reason">Audit log reason</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task DeleteStickerAsync(DiscordSticker sticker, string reason = null)
 		=> this.DeleteStickerAsync(sticker.Id, reason);
 
 	/// <summary>
 	/// <para>Gets the default channel for this guild.</para>
 	/// <para>Default channel is the first channel current member can see.</para>
 	/// </summary>
 	/// <returns>This member's default guild.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public DiscordChannel GetDefaultChannel() =>
 		this.ChannelsInternal?.Values.Where(xc => xc.Type == ChannelType.Text)
 			.OrderBy(xc => xc.Position)
 			.FirstOrDefault(xc => (xc.PermissionsFor(this.CurrentMember) & DisCatSharp.Permissions.AccessChannels) == DisCatSharp.Permissions.AccessChannels);
 
 	/// <summary>
 	/// Gets the guild's widget
 	/// </summary>
 	/// <returns>The guild's widget</returns>
 	public Task<DiscordWidget> GetWidgetAsync()
 		=> this.Discord.ApiClient.GetGuildWidgetAsync(this.Id);
 
 	/// <summary>
 	/// Gets the guild's widget settings
 	/// </summary>
 	/// <returns>The guild's widget settings</returns>
 	public Task<DiscordWidgetSettings> GetWidgetSettingsAsync()
 		=> this.Discord.ApiClient.GetGuildWidgetSettingsAsync(this.Id);
 
 	/// <summary>
 	/// Modifies the guild's widget settings
 	/// </summary>
 	/// <param name="isEnabled">If the widget is enabled or not</param>
 	/// <param name="channel">Widget channel</param>
 	/// <param name="reason">Reason the widget settings were modified</param>
 	/// <returns>The newly modified widget settings</returns>
 	public Task<DiscordWidgetSettings> ModifyWidgetSettingsAsync(bool? isEnabled = null, DiscordChannel channel = null, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildWidgetSettingsAsync(this.Id, isEnabled, channel?.Id, reason);
 
 	/// <summary>
 	/// Gets all of this guild's templates.
 	/// </summary>
 	/// <returns>All of the guild's templates.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordGuildTemplate>> GetTemplatesAsync()
 		=> this.Discord.ApiClient.GetGuildTemplatesAsync(this.Id);
 
 	/// <summary>
 	/// Creates a guild template.
 	/// </summary>
 	/// <param name="name">Name of the template.</param>
 	/// <param name="description">Description of the template.</param>
 	/// <returns>The template created.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Throws when a template already exists for the guild or a null parameter is provided for the name.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildTemplate> CreateTemplateAsync(string name, string description = null)
 		=> this.Discord.ApiClient.CreateGuildTemplateAsync(this.Id, name, description);
 
 	/// <summary>
 	/// Syncs the template to the current guild's state.
 	/// </summary>
 	/// <param name="code">The code of the template to sync.</param>
 	/// <returns>The template synced.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildTemplate> SyncTemplateAsync(string code)
 		=> this.Discord.ApiClient.SyncGuildTemplateAsync(this.Id, code);
 
 	/// <summary>
 	/// Modifies the template's metadata.
 	/// </summary>
 	/// <param name="code">The template's code.</param>
 	/// <param name="name">Name of the template.</param>
 	/// <param name="description">Description of the template.</param>
 	/// <returns>The template modified.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildTemplate> ModifyTemplateAsync(string code, string name = null, string description = null)
 		=> this.Discord.ApiClient.ModifyGuildTemplateAsync(this.Id, code, name, description);
 
 	/// <summary>
 	/// Deletes the template.
 	/// </summary>
 	/// <param name="code">The code of the template to delete.</param>
 	/// <returns>The deleted template.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Throws when the template for the code cannot be found</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Throws when the client does not have the <see cref="Permissions.ManageGuild"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildTemplate> DeleteTemplateAsync(string code)
 		=> this.Discord.ApiClient.DeleteGuildTemplateAsync(this.Id, code);
 
 	/// <summary>
 	/// Gets this guild's membership screening form.
 	/// </summary>
 	/// <returns>This guild's membership screening form.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildMembershipScreening> GetMembershipScreeningFormAsync()
 		=> this.Discord.ApiClient.GetGuildMembershipScreeningFormAsync(this.Id);
 
 	/// <summary>
 	/// Modifies this guild's membership screening form.
 	/// </summary>
 	/// <param name="action">Action to perform</param>
 	/// <returns>The modified screening form.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordGuildMembershipScreening> ModifyMembershipScreeningFormAsync(Action<MembershipScreeningEditModel> action)
 	{
 		var mdl = new MembershipScreeningEditModel();
 		action(mdl);
 		return await this.Discord.ApiClient.ModifyGuildMembershipScreeningFormAsync(this.Id, mdl.Enabled, mdl.Fields, mdl.Description);
 	}
 
 	/// <summary>
 	/// Gets all the application commands in this guild.
 	/// </summary>
 	/// <returns>A list of application commands in this guild.</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> GetApplicationCommandsAsync() =>
 		this.Discord.ApiClient.GetGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id);
 
 	/// <summary>
 	/// Overwrites the existing application commands in this guild. New commands are automatically created and missing commands are automatically delete
 	/// </summary>
 	/// <param name="commands">The list of commands to overwrite with.</param>
 	/// <returns>The list of guild commands</returns>
 	public Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteApplicationCommandsAsync(IEnumerable<DiscordApplicationCommand> commands) =>
 		this.Discord.ApiClient.BulkOverwriteGuildApplicationCommandsAsync(this.Discord.CurrentApplication.Id, this.Id, commands);
 
 	/// <summary>
 	/// Creates or overwrites a application command in this guild.
 	/// </summary>
 	/// <param name="command">The command to create.</param>
 	/// <returns>The created command.</returns>
 	public Task<DiscordApplicationCommand> CreateApplicationCommandAsync(DiscordApplicationCommand command) =>
 		this.Discord.ApiClient.CreateGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, command);
 
 	/// <summary>
 	/// Edits a application command in this guild.
 	/// </summary>
 	/// <param name="commandId">The id of the command to edit.</param>
 	/// <param name="action">Action to perform.</param>
 	/// <returns>The edit command.</returns>
 	public async Task<DiscordApplicationCommand> EditApplicationCommandAsync(ulong commandId, Action<ApplicationCommandEditModel> action)
 	{
 		var mdl = new ApplicationCommandEditModel();
 		action(mdl);
 		return await this.Discord.ApiClient.EditGuildApplicationCommandAsync(this.Discord.CurrentApplication.Id, this.Id, commandId, mdl.Name, mdl.Description, mdl.Options, mdl.NameLocalizations, mdl.DescriptionLocalizations, mdl.DefaultMemberPermissions, mdl.DmPermission, mdl.IsNsfw).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Gets this guild's welcome screen.
 	/// </summary>
 	/// <returns>This guild's welcome screen object.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordGuildWelcomeScreen> GetWelcomeScreenAsync() =>
 		this.Discord.ApiClient.GetGuildWelcomeScreenAsync(this.Id);
 
 	/// <summary>
 	/// Modifies this guild's welcome screen.
 	/// </summary>
 	/// <param name="action">Action to perform.</param>
 	/// <returns>The modified welcome screen.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client doesn't have the <see cref="Permissions.ManageGuild"/> permission, or community is not enabled on this guild.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordGuildWelcomeScreen> ModifyWelcomeScreenAsync(Action<WelcomeScreenEditModel> action)
 	{
 		var mdl = new WelcomeScreenEditModel();
 		action(mdl);
 		return await this.Discord.ApiClient.ModifyGuildWelcomeScreenAsync(this.Id, mdl.Enabled, mdl.WelcomeChannels, mdl.Description).ConfigureAwait(false);
 	}
 	#endregion
 
 	/// <summary>
 	/// Returns a string representation of this guild.
 	/// </summary>
 	/// <returns>String representation of this guild.</returns>
 	public override string ToString()
 		=> $"Guild {this.Id}; {this.Name}";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordGuild"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordGuild"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordGuild);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordGuild"/> is equal to another <see cref="DiscordGuild"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordGuild"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordGuild"/> is equal to this <see cref="DiscordGuild"/>.</returns>
 	public bool Equals(DiscordGuild e)
 		=> e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordGuild"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordGuild"/>.</returns>
 	public override int GetHashCode()
 		=> this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordGuild"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First guild to compare.</param>
 	/// <param name="e2">Second guild to compare.</param>
 	/// <returns>Whether the two guilds are equal.</returns>
 	public static bool operator ==(DiscordGuild e1, DiscordGuild e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordGuild"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First guild to compare.</param>
 	/// <param name="e2">Second guild to compare.</param>
 	/// <returns>Whether the two guilds are not equal.</returns>
 	public static bool operator !=(DiscordGuild e1, DiscordGuild e2)
 		=> !(e1 == e2);
 
 }
-
-/// <summary>
-/// Represents guild verification level.
-/// </summary>
-public enum VerificationLevel : int
-{
-	/// <summary>
-	/// No verification. Anyone can join and chat right away.
-	/// </summary>
-	None = 0,
-
-	/// <summary>
-	/// Low verification level. Users are required to have a verified email attached to their account in order to be able to chat.
-	/// </summary>
-	Low = 1,
-
-	/// <summary>
-	/// Medium verification level. Users are required to have a verified email attached to their account, and account age need to be at least 5 minutes in order to be able to chat.
-	/// </summary>
-	Medium = 2,
-
-	/// <summary>
-	/// High verification level. Users are required to have a verified email attached to their account, account age need to be at least 5 minutes, and they need to be in the server for at least 10 minutes in order to be able to chat.
-	/// </summary>
-	High = 3,
-
-	/// <summary>
-	/// Highest verification level. Users are required to have a verified phone number attached to their account.
-	/// </summary>
-	Highest = 4
-}
-
-/// <summary>
-/// Represents default notification level for a guild.
-/// </summary>
-public enum DefaultMessageNotifications : int
-{
-	/// <summary>
-	/// All messages will trigger push notifications.
-	/// </summary>
-	AllMessages = 0,
-
-	/// <summary>
-	/// Only messages that mention the user (or a role he's in) will trigger push notifications.
-	/// </summary>
-	MentionsOnly = 1
-}
-
-/// <summary>
-/// Represents multi-factor authentication level required by a guild to use administrator functionality.
-/// </summary>
-public enum MfaLevel : int
-{
-	/// <summary>
-	/// Multi-factor authentication is not required to use administrator functionality.
-	/// </summary>
-	Disabled = 0,
-
-	/// <summary>
-	/// Multi-factor authentication is required to use administrator functionality.
-	/// </summary>
-	Enabled = 1
-}
-
-/// <summary>
-/// Represents the value of explicit content filter in a guild.
-/// </summary>
-public enum ExplicitContentFilter : int
-{
-	/// <summary>
-	/// Explicit content filter is disabled.
-	/// </summary>
-	Disabled = 0,
-
-	/// <summary>
-	/// Only messages from members without any roles are scanned.
-	/// </summary>
-	MembersWithoutRoles = 1,
-
-	/// <summary>
-	/// Messages from all members are scanned.
-	/// </summary>
-	AllMembers = 2
-}
-
-/// <summary>
-/// Represents the formats for a guild widget.
-/// </summary>
-public enum WidgetType : int
-{
-	/// <summary>
-	/// The widget is represented in shield format.
-	/// <para>This is the default widget type.</para>
-	/// </summary>
-	Shield = 0,
-
-	/// <summary>
-	/// The widget is represented as the first banner type.
-	/// </summary>
-	Banner1 = 1,
-
-	/// <summary>
-	/// The widget is represented as the second banner type.
-	/// </summary>
-	Banner2 = 2,
-
-	/// <summary>
-	/// The widget is represented as the third banner type.
-	/// </summary>
-	Banner3 = 3,
-
-	/// <summary>
-	/// The widget is represented in the fourth banner type.
-	/// </summary>
-	Banner4 = 4
-}
diff --git a/DisCatSharp/Entities/Guild/DiscordGuildMembershipScreeningField.cs b/DisCatSharp/Entities/Guild/DiscordGuildMembershipScreeningField.cs
index 57e46588f..6c8b52daf 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuildMembershipScreeningField.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuildMembershipScreeningField.cs
@@ -1,78 +1,80 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 using System.Linq;
 
+using DisCatSharp.Enums;
+
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a field in a guild's membership screening form
 /// </summary>
 public class DiscordGuildMembershipScreeningField
 {
 	/// <summary>
 	/// Gets the type of the field.
 	/// </summary>
 	[JsonProperty("field_type", NullValueHandling = NullValueHandling.Ignore)]
 	public MembershipScreeningFieldType Type { get; internal set; }
 
 	/// <summary>
 	/// Gets the title of the field.
 	/// </summary>
 	[JsonProperty("label", NullValueHandling = NullValueHandling.Ignore)]
 	public string Label { get; internal set; }
 
 	/// <summary>
 	/// Gets the list of rules
 	/// </summary>
 	[JsonProperty("values", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyList<string> Values { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the user has to fill out this field
 	/// </summary>
 	[JsonProperty("required", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsRequired { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordGuildMembershipScreeningField"/> class.
 	/// </summary>
 	/// <param name="type">The type.</param>
 	/// <param name="label">The label.</param>
 	/// <param name="values">The values.</param>
 	/// <param name="required">If true, required.</param>
 	public DiscordGuildMembershipScreeningField(MembershipScreeningFieldType type, string label, IEnumerable<string> values, bool required = true)
 	{
 		this.Type = type;
 		this.Label = label;
 		this.Values = values.ToList();
 		this.IsRequired = required;
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordGuildMembershipScreeningField"/> class.
 	/// </summary>
 	internal DiscordGuildMembershipScreeningField() { }
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordMember.cs b/DisCatSharp/Entities/Guild/DiscordMember.cs
index 468047aab..b4a598998 100644
--- a/DisCatSharp/Entities/Guild/DiscordMember.cs
+++ b/DisCatSharp/Entities/Guild/DiscordMember.cs
@@ -1,784 +1,791 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord guild member.
 /// </summary>
 public class DiscordMember : DiscordUser, IEquatable<DiscordMember>
 {
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMember"/> class.
 	/// </summary>
 	internal DiscordMember()
 	{
 		this._roleIdsLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.RoleIdsInternal));
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMember"/> class.
 	/// </summary>
 	/// <param name="user">The user.</param>
 	internal DiscordMember(DiscordUser user)
 	{
 		this.Discord = user.Discord;
 
 		this.Id = user.Id;
 
 		this.RoleIdsInternal = new List<ulong>();
 		this._roleIdsLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.RoleIdsInternal));
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMember"/> class.
 	/// </summary>
 	/// <param name="mbr">The mbr.</param>
 	internal DiscordMember(TransportMember mbr)
 	{
 		this.Id = mbr.User.Id;
 		this.IsDeafened = mbr.IsDeafened;
 		this.IsMuted = mbr.IsMuted;
 		this.JoinedAt = mbr.JoinedAt;
 		this.Nickname = mbr.Nickname;
 		this.PremiumSince = mbr.PremiumSince;
 		this.IsPending = mbr.IsPending;
 		this.GuildAvatarHash = mbr.GuildAvatarHash;
 		this.GuildBannerHash = mbr.GuildBannerHash;
 		this.GuildBio = mbr.GuildBio;
+		this.GuildPronouns = mbr.GuildPronouns;
 		this.CommunicationDisabledUntil = mbr.CommunicationDisabledUntil;
 		this.AvatarHashInternal = mbr.AvatarHash;
 		this.RoleIdsInternal = mbr.Roles ?? new List<ulong>();
 		this._roleIdsLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.RoleIdsInternal));
 		this.MemberFlags = mbr.MemberFlags;
 	}
 
 	/// <summary>
 	/// Gets the members avatar hash.
 	/// </summary>
 	[JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string GuildAvatarHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the members avatar URL.
 	/// </summary>
 	[JsonIgnore]
 	public string GuildAvatarUrl
 		=> string.IsNullOrWhiteSpace(this.GuildAvatarHash) ? this.User.AvatarUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILDS}/{this.GuildId.ToString(CultureInfo.InvariantCulture)}{Endpoints.USERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.AVATARS}/{this.GuildAvatarHash}.{(this.GuildAvatarHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// Gets the members banner hash.
 	/// </summary>
 	[JsonProperty("banner", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string GuildBannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the members banner URL.
 	/// </summary>
 	[JsonIgnore]
 	public string GuildBannerUrl
 		=> string.IsNullOrWhiteSpace(this.GuildBannerHash) ? this.User.BannerUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.GUILDS}/{this.GuildId.ToString(CultureInfo.InvariantCulture)}{Endpoints.USERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}{Endpoints.BANNERS}/{this.GuildBannerHash}.{(this.GuildBannerHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// The color of this member's banner. Mutually exclusive with <see cref="GuildBannerHash"/>.
 	/// </summary>
 	[JsonIgnore]
 	public override DiscordColor? BannerColor => this.User.BannerColor;
 
 	/// <summary>
 	/// Gets this member's nickname.
 	/// </summary>
 	[JsonProperty("nick", NullValueHandling = NullValueHandling.Ignore)]
 	public string Nickname { get; internal set; }
 
 	/// <summary>
 	/// Gets the members guild bio.
 	/// This is not available to bots tho.
 	/// </summary>
 	[JsonProperty("bio", NullValueHandling = NullValueHandling.Ignore)]
 	public string GuildBio { get; internal set; }
 
+	/// <summary>
+	/// Gets the members's pronouns.
+	/// </summary>
+	[JsonProperty("pronouns", NullValueHandling = NullValueHandling.Ignore)]
+	public string GuildPronouns { get; internal set; }
+
 	/// <summary>
 	/// Gets the members flags.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public MemberFlags MemberFlags { get; internal set; }
 
 	[JsonIgnore]
 	internal string AvatarHashInternal;
 
 	/// <summary>
 	/// Gets this member's display name.
 	/// </summary>
 	[JsonIgnore]
 	public string DisplayName
 		=> this.Nickname ?? this.Username;
 
 	/// <summary>
 	/// List of role ids
 	/// </summary>
 	[JsonIgnore]
 	internal IReadOnlyList<ulong> RoleIds
 		=> this._roleIdsLazy.Value;
 
 	[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<ulong> RoleIdsInternal;
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<ulong>> _roleIdsLazy;
 
 	/// <summary>
 	/// Gets the list of roles associated with this member.
 	/// </summary>
 	[JsonIgnore]
 	public IEnumerable<DiscordRole> Roles
 		=> this.RoleIds.Select(id => this.Guild.GetRole(id)).Where(x => x != null);
 
 	/// <summary>
 	/// Gets the color associated with this user's top color-giving role, otherwise 0 (no color).
 	/// </summary>
 	[JsonIgnore]
 	public DiscordColor Color
 	{
 		get
 		{
 			var role = this.Roles.OrderByDescending(xr => xr.Position).FirstOrDefault(xr => xr.Color.Value != 0);
 			return role != null ? role.Color : new DiscordColor();
 		}
 	}
 
 	/// <summary>
 	/// Date the user joined the guild
 	/// </summary>
 	[JsonProperty("joined_at", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset JoinedAt { get; internal set; }
 
 	/// <summary>
 	/// Date the user started boosting this server
 	/// </summary>
 	[JsonProperty("premium_since", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset? PremiumSince { get; internal set; }
 
 	/// <summary>
 	/// Date until the can communicate again.
 	/// </summary>
 	[JsonProperty("communication_disabled_until", NullValueHandling = NullValueHandling.Include)]
 	public DateTime? CommunicationDisabledUntil { get; internal set; }
 
 	/// <summary>
 	/// If the user is deafened
 	/// </summary>
 	[JsonProperty("is_deafened", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsDeafened { get; internal set; }
 
 	/// <summary>
 	/// If the user is muted
 	/// </summary>
 	[JsonProperty("is_muted", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsMuted { get; internal set; }
 
 	/// <summary>
 	/// Whether the user has not passed the guild's Membership Screening requirements yet.
 	/// </summary>
 	[JsonProperty("pending", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? IsPending { get; internal set; }
 
 	/// <summary>
 	/// Gets this member's voice state.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordVoiceState VoiceState
 		=> this.Discord.Guilds[this.GuildId].VoiceStates.TryGetValue(this.Id, out var voiceState) ? voiceState : null;
 
 	[JsonIgnore]
 	internal ulong GuildId = 0;
 
 	/// <summary>
 	/// Gets the guild of which this member is a part of.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordGuild Guild
 		=> this.Discord.Guilds[this.GuildId];
 
 	/// <summary>
 	/// Gets whether this member is the Guild owner.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsOwner
 		=> this.Id == this.Guild.OwnerId;
 
 	/// <summary>
 	/// Gets the member's position in the role hierarchy, which is the member's highest role's position. Returns <see cref="int.MaxValue"/> for the guild's owner.
 	/// </summary>
 	[JsonIgnore]
 	public int Hierarchy
 		=> this.IsOwner ? int.MaxValue : this.RoleIds.Count == 0 ? 0 : this.Roles.Max(x => x.Position);
 
 	/// <summary>
 	/// Gets the permissions for the current member.
 	/// </summary>
 	[JsonIgnore]
 	public Permissions Permissions => this.GetPermissions();
 
 	#region Overridden user properties
 
 	/// <summary>
 	/// Gets the user.
 	/// </summary>
 	[JsonIgnore]
 	internal DiscordUser User
 		=> this.Discord.UserCache[this.Id];
 
 	/// <summary>
 	/// Gets this member's username.
 	/// </summary>
 	[JsonIgnore]
 	public override string Username
 	{
 		get => this.User.Username;
 		internal set => this.User.Username = value;
 	}
 
 	/// <summary>
 	/// Gets the member's 4-digit discriminator.
 	/// </summary>
 	[JsonIgnore]
 	public override string Discriminator
 	{
 		get => this.User.Discriminator;
 		internal set => this.User.Discriminator = value;
 	}
 
 	/// <summary>
 	/// Gets the member's avatar hash.
 	/// </summary>
 	[JsonIgnore]
 	public override string AvatarHash
 	{
 		get => this.User.AvatarHash;
 		internal set => this.User.AvatarHash = value;
 	}
 
 	/// <summary>
 	/// Gets the member's banner hash.
 	/// </summary>
 	[JsonIgnore]
 	public override string BannerHash
 	{
 		get => this.User.BannerHash;
 		internal set => this.User.BannerHash = value;
 	}
 
 	/// <summary>
 	/// Gets whether the member is a bot.
 	/// </summary>
 	[JsonIgnore]
 	public override bool IsBot
 	{
 		get => this.User.IsBot;
 		internal set => this.User.IsBot = value;
 	}
 
 	/// <summary>
 	/// Gets the member's email address.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonIgnore]
 	public override string Email
 	{
 		get => this.User.Email;
 		internal set => this.User.Email = value;
 	}
 
 	/// <summary>
 	/// Gets whether the member has multi-factor authentication enabled.
 	/// </summary>
 	[JsonIgnore]
 	public override bool? MfaEnabled
 	{
 		get => this.User.MfaEnabled;
 		internal set => this.User.MfaEnabled = value;
 	}
 
 	/// <summary>
 	/// Gets whether the member is verified.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonIgnore]
 	public override bool? Verified
 	{
 		get => this.User.Verified;
 		internal set => this.User.Verified = value;
 	}
 
 	/// <summary>
 	/// Gets the member's chosen language
 	/// </summary>
 	[JsonIgnore]
 	public override string Locale
 	{
 		get => this.User.Locale;
 		internal set => this.User.Locale = value;
 	}
 
 	/// <summary>
 	/// Gets the user's flags.
 	/// </summary>
 	[JsonIgnore]
 	public override UserFlags? OAuthFlags
 	{
 		get => this.User.OAuthFlags;
 		internal set => this.User.OAuthFlags = value;
 	}
 
 	/// <summary>
 	/// Gets the member's flags for OAuth.
 	/// </summary>
 	[JsonIgnore]
 	public override UserFlags? Flags
 	{
 		get => this.User.Flags;
 		internal set => this.User.Flags = value;
 	}
 
 	#endregion
 
 	/// <summary>
 	/// Creates a direct message channel to this member.
 	/// </summary>
 	/// <returns>Direct message channel to this member.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordDmChannel> CreateDmChannelAsync()
 		=> this.Discord.ApiClient.CreateDmAsync(this.Id);
 
 	/// <summary>
 	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> SendMessageAsync(string content)
 	{
 		if (this.IsBot && this.Discord.CurrentUser.IsBot)
 			throw new ArgumentException("Bots cannot DM each other.");
 
 		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
 		return await chn.SendMessageAsync(content).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed)
 	{
 		if (this.IsBot && this.Discord.CurrentUser.IsBot)
 			throw new ArgumentException("Bots cannot DM each other.");
 
 		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
 		return await chn.SendMessageAsync(embed).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed)
 	{
 		if (this.IsBot && this.Discord.CurrentUser.IsBot)
 			throw new ArgumentException("Bots cannot DM each other.");
 
 		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
 		return await chn.SendMessageAsync(content, embed).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sends a direct message to this member. Creates a direct message channel if one does not exist already.
 	/// </summary>
 	/// <param name="message">Builder to with the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the member has the bot blocked, the member is no longer in the guild, or if the member has Allow DM from server members off.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder message)
 	{
 		if (this.IsBot && this.Discord.CurrentUser.IsBot)
 			throw new ArgumentException("Bots cannot DM each other.");
 
 		var chn = await this.CreateDmChannelAsync().ConfigureAwait(false);
 		return await chn.SendMessageAsync(message).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Sets this member's voice mute status.
 	/// </summary>
 	/// <param name="mute">Whether the member is to be muted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task SetMuteAsync(bool mute, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.GuildId, this.Id, default, default, mute, default, default, reason);
 
 	/// <summary>
 	/// Sets this member's voice deaf status.
 	/// </summary>
 	/// <param name="deaf">Whether the member is to be deafened.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.DeafenMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task SetDeafAsync(bool deaf, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.GuildId, this.Id, default, default, default, deaf, default, reason);
 
 	/// <summary>
 	/// Modifies this member.
 	/// </summary>
 	/// <param name="action">Action to perform on this member.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageNicknames"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task ModifyAsync(Action<MemberEditModel> action)
 	{
 		var mdl = new MemberEditModel();
 		action(mdl);
 
 		if (mdl.VoiceChannel.HasValue && mdl.VoiceChannel.Value != null && mdl.VoiceChannel.Value.Type != ChannelType.Voice && mdl.VoiceChannel.Value.Type != ChannelType.Stage)
 			throw new ArgumentException("Given channel is not a voice or stage channel.", nameof(action));
 
 		if (mdl.Nickname.HasValue && this.Discord.CurrentUser.Id == this.Id)
 		{
 			await this.Discord.ApiClient.ModifyCurrentMemberNicknameAsync(this.Guild.Id, mdl.Nickname.Value,
 				mdl.AuditLogReason).ConfigureAwait(false);
 
 			await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, Optional.None,
 				mdl.Roles.Map(e => e.Select(xr => xr.Id)), mdl.Muted, mdl.Deafened,
 				mdl.VoiceChannel.Map(e => e?.Id), mdl.AuditLogReason).ConfigureAwait(false);
 		}
 		else
 		{
 			await this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, mdl.Nickname,
 				mdl.Roles.Map(e => e.Select(xr => xr.Id)), mdl.Muted, mdl.Deafened,
 				mdl.VoiceChannel.Map(e => e?.Id), mdl.AuditLogReason).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Adds a timeout to a member.
 	/// </summary>
 	/// <param name="until">The datetime offset to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task TimeoutAsync(DateTimeOffset until, string reason = null)
 		=> until.Subtract(DateTimeOffset.UtcNow).Days > 28 ? throw new ArgumentException("Timeout can not be longer than 28 days") : this.Discord.ApiClient.ModifyTimeoutAsync(this.Guild.Id, this.Id, until, reason);
 
 	/// <summary>
 	/// Adds a timeout to a member.
 	/// </summary>
 	/// <param name="until">The timespan to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task TimeoutAsync(TimeSpan until, string reason = null)
 		=> this.TimeoutAsync(DateTimeOffset.UtcNow + until, reason);
 
 	/// <summary>
 	/// Adds a timeout to a member.
 	/// </summary>
 	/// <param name="until">The datetime to time out the user. Up to 28 days.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task TimeoutAsync(DateTime until, string reason = null)
 		=> this.TimeoutAsync(until.ToUniversalTime() - DateTime.UtcNow, reason);
 
 	/// <summary>
 	/// Removes the timeout from a member.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ModerateMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveTimeoutAsync(string reason = null) => this.Discord.ApiClient.ModifyTimeoutAsync(this.Guild.Id, this.Id, null, reason);
 
 	/// <summary>
 	/// Grants a role to the member.
 	/// </summary>
 	/// <param name="role">Role to grant.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task GrantRoleAsync(DiscordRole role, string reason = null)
 		=> this.Discord.ApiClient.AddGuildMemberRoleAsync(this.Guild.Id, this.Id, role.Id, reason);
 
 	/// <summary>
 	/// Revokes a role from a member.
 	/// </summary>
 	/// <param name="role">Role to revoke.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RevokeRoleAsync(DiscordRole role, string reason = null)
 		=> this.Discord.ApiClient.RemoveGuildMemberRoleAsync(this.Guild.Id, this.Id, role.Id, reason);
 
 	/// <summary>
 	/// Sets the member's roles to ones specified.
 	/// </summary>
 	/// <param name="roles">Roles to set.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ReplaceRolesAsync(IEnumerable<DiscordRole> roles, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildMemberAsync(this.Guild.Id, this.Id, default,
 			Optional.Some(roles.Select(xr => xr.Id)), default, default, default, reason);
 
 	/// <summary>
 	/// Bans this member from their guild.
 	/// </summary>
 	/// <param name="deleteMessageDays">How many days to remove messages from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task BanAsync(int deleteMessageDays = 0, string reason = null)
 		=> this.Guild.BanMemberAsync(this, deleteMessageDays, reason);
 
 	/// <summary>
 	/// Unbans this member from their guild.
 	/// </summary>
 	/// <exception cref = "Exceptions.UnauthorizedException" > Thrown when the client does not have the<see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UnbanAsync(string reason = null) => this.Guild.UnbanMemberAsync(this, reason);
 
 	/// <summary>
 	/// Kicks this member from their guild.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <returns></returns>
 	/// <remarks>[alias="KickAsync"]</remarks>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.KickMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveAsync(string reason = null)
 		=> this.Discord.ApiClient.RemoveGuildMemberAsync(this.GuildId, this.Id, reason);
 
 	/// <summary>
 	/// Moves this member to the specified voice channel
 	/// </summary>
 	/// <param name="channel"></param>
 
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MoveMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task PlaceInAsync(DiscordChannel channel)
 		=> channel.PlaceMemberAsync(this);
 
 	/// <summary>
 	/// Updates the member's suppress state in a stage channel.
 	/// </summary>
 	/// <param name="channel">The channel the member is currently in.</param>
 	/// <param name="suppress">Toggles the member's suppress state.</param>
 	/// <exception cref="System.ArgumentException">Thrown when the channel in not a voice channel.</exception>
 	public async Task UpdateVoiceStateAsync(DiscordChannel channel, bool? suppress)
 	{
 		if (channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated in a stage channel.");
 
 		await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, channel.Id, suppress).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Makes the user a speaker.
 	/// </summary>
 	/// <exception cref="System.ArgumentException">Thrown when the user is not inside an stage channel.</exception>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task MakeSpeakerAsync()
 	{
 		var vs = this.VoiceState;
 		if (vs == null || vs.Channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated when the user is inside an stage channel.");
 
 		await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, vs.Channel.Id, false).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Moves the user to audience.
 	/// </summary>
 	/// <exception cref="System.ArgumentException">Thrown when the user is not inside an stage channel.</exception>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.MuteMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task MoveToAudienceAsync()
 	{
 		var vs = this.VoiceState;
 		if (vs == null || vs.Channel.Type != ChannelType.Stage)
 			throw new ArgumentException("Voice state can only be updated when the user is inside an stage channel.");
 
 		await this.Discord.ApiClient.UpdateUserVoiceStateAsync(this.Guild.Id, this.Id, vs.Channel.Id, true).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Calculates permissions in a given channel for this member.
 	/// </summary>
 	/// <param name="channel">Channel to calculate permissions for.</param>
 	/// <returns>Calculated permissions for this member in the channel.</returns>
 	public Permissions PermissionsIn(DiscordChannel channel)
 		=> channel.PermissionsFor(this);
 
 	/// <summary>
 	/// Get's the current member's roles based on the sum of the permissions of their given roles.
 	/// </summary>
 	private Permissions GetPermissions()
 	{
 		if (this.Guild.OwnerId == this.Id)
 			return PermissionMethods.FullPerms;
 
 		Permissions perms;
 
 		// assign @everyone permissions
 		var everyoneRole = this.Guild.EveryoneRole;
 		perms = everyoneRole.Permissions;
 
 		// assign permissions from member's roles (in order)
 		perms |= this.Roles.Aggregate(Permissions.None, (c, role) => c | role.Permissions);
 
 		// Administrator grants all permissions and cannot be overridden
 		return (perms & Permissions.Administrator) == Permissions.Administrator ? PermissionMethods.FullPerms : perms;
 	}
 
 	/// <summary>
 	/// Returns a string representation of this member.
 	/// </summary>
 	/// <returns>String representation of this member.</returns>
 	public override string ToString()
 		=> $"Member {this.Id}; {this.Username}#{this.Discriminator} ({this.DisplayName})";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMember"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordMember"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordMember);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMember"/> is equal to another <see cref="DiscordMember"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordMember"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordMember"/> is equal to this <see cref="DiscordMember"/>.</returns>
 	public bool Equals(DiscordMember e)
 		=> e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.GuildId == e.GuildId));
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordMember"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordMember"/>.</returns>
 	public override int GetHashCode()
 	{
 		var hash = 13;
 
 		hash = (hash * 7) + this.Id.GetHashCode();
 		hash = (hash * 7) + this.GuildId.GetHashCode();
 
 		return hash;
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMember"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First member to compare.</param>
 	/// <param name="e2">Second member to compare.</param>
 	/// <returns>Whether the two members are equal.</returns>
 	public static bool operator ==(DiscordMember e1, DiscordMember e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1.GuildId == e2.GuildId));
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMember"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First member to compare.</param>
 	/// <param name="e2">Second member to compare.</param>
 	/// <returns>Whether the two members are not equal.</returns>
 	public static bool operator !=(DiscordMember e1, DiscordMember e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Guild/DiscordRole.cs b/DisCatSharp/Entities/Guild/DiscordRole.cs
index 0f23938c0..5bd61dc35 100644
--- a/DisCatSharp/Entities/Guild/DiscordRole.cs
+++ b/DisCatSharp/Entities/Guild/DiscordRole.cs
@@ -1,283 +1,292 @@
 // 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.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Models;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a discord role, to which users can be assigned.
 /// </summary>
 public class DiscordRole : SnowflakeObject, IEquatable<DiscordRole>
 {
 	/// <summary>
 	/// Gets the name of this role.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the color of this role.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordColor Color
 		=> new(this.ColorInternal);
 
 	[JsonProperty("color", NullValueHandling = NullValueHandling.Ignore)]
 	internal int ColorInternal;
 
 	/// <summary>
 	/// Gets whether this role is hoisted.
 	/// </summary>
 	[JsonProperty("hoist", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsHoisted { get; internal set; }
 
 	/// <summary>
 	/// Gets the position of this role in the role hierarchy.
 	/// </summary>
 	[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
 	public int Position { get; internal set; }
 
 	/// <summary>
 	/// Gets the permissions set for this role.
 	/// </summary>
 	[JsonProperty("permissions", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions Permissions { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this role is managed by an integration.
 	/// </summary>
 	[JsonProperty("managed", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsManaged { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this role is mentionable.
 	/// </summary>
 	[JsonProperty("mentionable", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsMentionable { get; internal set; }
 
 	/// <summary>
 	/// Gets the tags this role has.
 	/// </summary>
 	[JsonProperty("tags", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordRoleTags Tags { get; internal set; }
 
 	/// <summary>
 	/// Gets the role icon's hash.
 	/// </summary>
 	[JsonProperty("icon", NullValueHandling = NullValueHandling.Ignore)]
 	public string IconHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the role icon's url.
 	/// </summary>
 	[JsonIgnore]
 	public string IconUrl
 		=> !string.IsNullOrWhiteSpace(this.IconHash) ? $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.ROLE_ICONS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.IconHash}.png?size=64" : null;
 
 	/// <summary>
 	/// Gets the role unicode_emoji.
 	/// </summary>
 	[JsonProperty("unicode_emoji", NullValueHandling = NullValueHandling.Ignore)]
 	internal string UnicodeEmojiString;
 
 	/// <summary>
 	/// Gets the unicode emoji.
 	/// </summary>
 	public DiscordEmoji UnicodeEmoji
 		=> this.UnicodeEmojiString != null ? DiscordEmoji.FromName(this.Discord, $":{this.UnicodeEmojiString}:", false) : null;
 
 	[JsonIgnore]
 	internal ulong GuildId = 0;
 
 	/// <summary>
 	/// Gets the role flags.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public RoleFlags Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets a mention string for this role. If the role is mentionable, this string will mention all the users that belong to this role.
 	/// </summary>
 	public string Mention
 		=> Formatter.Mention(this);
 
 	#region Methods
 
 	/// <summary>
 	/// Modifies this role's position.
 	/// </summary>
 	/// <param name="position">New position</param>
 	/// <param name="reason">Reason why we moved it</param>
 	/// <returns></returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ModifyPositionAsync(int position, string reason = null)
 	{
 		var roles = this.Discord.Guilds[this.GuildId].Roles.Values.OrderByDescending(xr => xr.Position)
 			.Select(x => new RestGuildRoleReorderPayload
 			{
 				RoleId = x.Id,
 				Position = x.Id == this.Id
 					? position
 					: x.Position <= position ? x.Position - 1 : x.Position
 			});
 
 		return this.Discord.ApiClient.ModifyGuildRolePositionAsync(this.GuildId, roles, reason);
 	}
 
 	/// <summary>
 	/// Updates this role.
 	/// </summary>
 	/// <param name="name">New role name.</param>
 	/// <param name="permissions">New role permissions.</param>
 	/// <param name="color">New role color.</param>
 	/// <param name="hoist">New role hoist.</param>
 	/// <param name="mentionable">Whether this role is mentionable.</param>
 	/// <param name="reason">Audit log reason.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ModifyAsync(string name = null, Permissions? permissions = null, DiscordColor? color = null, bool? hoist = null, bool? mentionable = null, string reason = null)
 		=> this.Discord.ApiClient.ModifyGuildRoleAsync(this.GuildId, this.Id, name, permissions, color?.Value, hoist, mentionable, null, null, reason);
 
 	/// <summary>
 	/// Updates this role.
 	/// </summary>
 	/// <param name="action">The action.</param>
 	/// <exception cref = "Exceptions.UnauthorizedException" > Thrown when the client does not have the<see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ModifyAsync(Action<RoleEditModel> action)
 	{
 		var mdl = new RoleEditModel();
 		action(mdl);
 
 		var canContinue = true;
-		if (mdl.Icon.HasValue || mdl.UnicodeEmoji.HasValue)
+		if ((mdl.Icon.HasValue && mdl.Icon.Value != null) || (mdl.UnicodeEmoji.HasValue && mdl.UnicodeEmoji.Value != null))
 			canContinue = this.Discord.Guilds[this.GuildId].Features.CanSetRoleIcons;
 
-		var iconb64 = ImageTool.Base64FromStream(mdl.Icon);
-
-		var emoji = mdl.UnicodeEmoji
-			.MapOrNull(e => e.Id == 0
-				? e.Name
-				: throw new ArgumentException("Emoji must be unicode"));
+		var iconb64 = Optional.FromNullable<string>(null);
+		if (mdl.Icon.HasValue && mdl.Icon.Value != null)
+			iconb64 = ImageTool.Base64FromStream(mdl.Icon);
+		else if (mdl.Icon.HasValue)
+			iconb64 = Optional.Some<string>(null);
+
+		var emoji = Optional.FromNullable<string>(null);
+
+		if (mdl.UnicodeEmoji.HasValue && mdl.UnicodeEmoji.Value != null)
+			emoji = mdl.UnicodeEmoji
+				.MapOrNull(e => e.Id == 0
+					? e.Name
+					: throw new ArgumentException("Emoji must be unicode"));
+		else if (mdl.UnicodeEmoji.HasValue)
+			emoji = Optional.Some<string>(null);
 
 		return canContinue ? this.Discord.ApiClient.ModifyGuildRoleAsync(this.GuildId, this.Id, mdl.Name, mdl.Permissions, mdl.Color?.Value, mdl.Hoist, mdl.Mentionable, iconb64, emoji, mdl.AuditLogReason) : throw new NotSupportedException($"Cannot modify role icon. Guild needs boost tier two.");
 	}
 
 	/// <summary>
 	/// Deletes this role.
 	/// </summary>
 	/// <param name="reason">Reason as to why this role has been deleted.</param>
 	/// <returns></returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageRoles"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the role does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteRoleAsync(this.GuildId, this.Id, reason);
 
 	#endregion
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordRole"/> class.
 	/// </summary>
 	internal DiscordRole()
 	{ }
 
 	/// <summary>
 	/// Checks whether this role has specific permissions.
 	/// </summary>
 	/// <param name="permission">Permissions to check for.</param>
 	/// <returns>Whether the permissions are allowed or not.</returns>
 	public PermissionLevel CheckPermission(Permissions permission)
 		=> (this.Permissions & permission) != 0 ? PermissionLevel.Allowed : PermissionLevel.Unset;
 
 	/// <summary>
 	/// Returns a string representation of this role.
 	/// </summary>
 	/// <returns>String representation of this role.</returns>
 	public override string ToString()
 		=> $"Role {this.Id}; {this.Name}";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordRole"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordRole"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordRole);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordRole"/> is equal to another <see cref="DiscordRole"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordRole"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordRole"/> is equal to this <see cref="DiscordRole"/>.</returns>
 	public bool Equals(DiscordRole e)
 		=> e switch
 		{
 			null => false,
 			_ => ReferenceEquals(this, e) || this.Id == e.Id
 		};
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordRole"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordRole"/>.</returns>
 	public override int GetHashCode()
 		=> this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordRole"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First role to compare.</param>
 	/// <param name="e2">Second role to compare.</param>
 	/// <returns>Whether the two roles are equal.</returns>
 	public static bool operator ==(DiscordRole e1, DiscordRole e2)
 		=> e1 is null == e2 is null
 		&& ((e1 is null && e2 is null) || e1.Id == e2.Id);
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordRole"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First role to compare.</param>
 	/// <param name="e2">Second role to compare.</param>
 	/// <returns>Whether the two roles are not equal.</returns>
 	public static bool operator !=(DiscordRole e1, DiscordRole e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Interaction/DiscordInteraction.cs b/DisCatSharp/Entities/Interaction/DiscordInteraction.cs
index f4227a536..99356b0be 100644
--- a/DisCatSharp/Entities/Interaction/DiscordInteraction.cs
+++ b/DisCatSharp/Entities/Interaction/DiscordInteraction.cs
@@ -1,219 +1,221 @@
 // 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.Threading.Tasks;
 
+using DisCatSharp.Enums;
+
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents an interaction that was invoked.
 /// </summary>
 public sealed class DiscordInteraction : SnowflakeObject
 {
 	/// <summary>
 	/// Gets the type of interaction invoked.
 	/// </summary>
 	[JsonProperty("type")]
 	public InteractionType Type { get; internal set; }
 
 	/// <summary>
 	/// Gets the command data for this interaction.
 	/// </summary>
 	[JsonProperty("data", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordInteractionData Data { get; internal set; }
 
 	/// <summary>
 	/// Gets the Id of the guild that invoked this interaction.
 	/// </summary>
 	[JsonIgnore]
 	public ulong? GuildId { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild that invoked this interaction.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordGuild Guild
 		=> (this.Discord as DiscordClient).InternalGetCachedGuild(this.GuildId);
 
 	/// <summary>
 	/// Gets the Id of the channel that invoked this interaction.
 	/// </summary>
 	[JsonIgnore]
 	public ulong ChannelId { get; internal set; }
 
 	/// <summary>
 	/// Gets the channel that invoked this interaction.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel Channel
 		 => (this.Discord as DiscordClient).InternalGetCachedChannel(this.ChannelId) ?? (DiscordChannel)(this.Discord as DiscordClient).InternalGetCachedThread(this.ChannelId) ?? (this.Guild == null ? new DiscordDmChannel { Id = this.ChannelId, Type = ChannelType.Private, Discord = this.Discord } : new DiscordChannel() { Id = this.ChannelId, Discord = this.Discord });
 
 	/// <summary>
 	/// Gets the user that invoked this interaction.
 	/// <para>This can be cast to a <see cref="DisCatSharp.Entities.DiscordMember"/> if created in a guild.</para>
 	/// </summary>
 	[JsonIgnore]
 	public DiscordUser User { get; internal set; }
 
 	/// <summary>
 	/// Gets the continuation token for responding to this interaction.
 	/// </summary>
 	[JsonProperty("token")]
 	public string Token { get; internal set; }
 
 	/// <summary>
 	/// Gets the version number for this interaction type.
 	/// </summary>
 	[JsonProperty("version")]
 	public int Version { get; internal set; }
 
 	/// <summary>
 	/// Gets the ID of the application that created this interaction.
 	/// </summary>
 	[JsonProperty("application_id")]
 	public ulong ApplicationId { get; internal set; }
 
 	/// <summary>
 	/// The message this interaction was created with, if any.
 	/// </summary>
 	[JsonProperty("message")]
 	internal DiscordMessage Message { get; set; }
 
 	/// <summary>
 	/// Gets the invoking user locale.
 	/// </summary>
 	[JsonProperty("locale", NullValueHandling = NullValueHandling.Ignore)]
 	public string Locale { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild locale if applicable.
 	/// </summary>
 	[JsonProperty("guild_locale", NullValueHandling = NullValueHandling.Ignore)]
 	public string GuildLocale { get; internal set; }
 
 	/// <summary>
 	/// Creates a response to this interaction.
 	/// </summary>
 	/// <param name="type">The type of the response.</param>
 	/// <param name="builder">The data, if any, to send.</param>
 	public Task CreateResponseAsync(InteractionResponseType type, DiscordInteractionResponseBuilder builder = null)
 		=> this.Discord.ApiClient.CreateInteractionResponseAsync(this.Id, this.Token, type, builder);
 
 	/// <summary>
 	/// Creates a modal response to this interaction.
 	/// </summary>
 	/// <param name="builder">The data to send.</param>
 	public Task CreateInteractionModalResponseAsync(DiscordInteractionModalBuilder builder)
 		=> this.Type != InteractionType.Ping && this.Type != InteractionType.ModalSubmit ? this.Discord.ApiClient.CreateInteractionModalResponseAsync(this.Id, this.Token, InteractionResponseType.Modal, builder) : throw new NotSupportedException("You can't respond to an PING with a modal.");
 
 	/// <summary>
 	/// Gets the original interaction response.
 	/// </summary>
 	/// <returns>The original message that was sent. This <b>does not work on ephemeral messages.</b></returns>
 	public Task<DiscordMessage> GetOriginalResponseAsync()
 		=> this.Discord.ApiClient.GetOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token);
 
 	/// <summary>
 	/// Edits the original interaction response.
 	/// </summary>
 	/// <param name="builder">The webhook builder.</param>
 	/// <returns>The edited <see cref="DiscordMessage"/>.</returns>
 	public async Task<DiscordMessage> EditOriginalResponseAsync(DiscordWebhookBuilder builder)
 	{
 		builder.Validate(isInteractionResponse: true);
 		if (builder.KeepAttachmentsInternal.HasValue && builder.KeepAttachmentsInternal.Value)
 		{
 			var attachments = this.Discord.ApiClient.GetOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token).Result.Attachments;
 			if (attachments?.Count > 0)
 			{
 				builder.AttachmentsInternal.AddRange(attachments);
 			}
 		}
 		else if (builder.KeepAttachmentsInternal.HasValue)
 		{
 			builder.AttachmentsInternal.Clear();
 		}
 
 		return await this.Discord.ApiClient.EditOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token, builder).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes the original interaction response.
 	/// </summary>>
 	public Task DeleteOriginalResponseAsync()
 		=> this.Discord.ApiClient.DeleteOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token);
 
 	/// <summary>
 	/// Creates a follow up message to this interaction.
 	/// </summary>
 	/// <param name="builder">The webhook builder.</param>
 	/// <returns>The created <see cref="DiscordMessage"/>.</returns>
 	public async Task<DiscordMessage> CreateFollowupMessageAsync(DiscordFollowupMessageBuilder builder)
 	{
 		builder.Validate();
 
 		return await this.Discord.ApiClient.CreateFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, builder).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Gets a follow up message.
 	/// </summary>
 	/// <param name="messageId">The id of the follow up message.</param>
 	public Task<DiscordMessage> GetFollowupMessageAsync(ulong messageId)
 		=> this.Discord.ApiClient.GetFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId);
 
 	/// <summary>
 	/// Edits a follow up message.
 	/// </summary>
 	/// <param name="messageId">The id of the follow up message.</param>
 	/// <param name="builder">The webhook builder.</param>
 	/// <returns>The edited <see cref="DiscordMessage"/>.</returns>
 	public async Task<DiscordMessage> EditFollowupMessageAsync(ulong messageId, DiscordWebhookBuilder builder)
 	{
 		builder.Validate(isFollowup: true);
 
 		if (builder.KeepAttachmentsInternal.HasValue && builder.KeepAttachmentsInternal.Value)
 		{
 			var attachments = this.Discord.ApiClient.GetFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId).Result.Attachments;
 			if (attachments?.Count > 0)
 			{
 				builder.AttachmentsInternal.AddRange(attachments);
 			}
 		}
 		else if (builder.KeepAttachmentsInternal.HasValue)
 		{
 			builder.AttachmentsInternal.Clear();
 		}
 
 		return await this.Discord.ApiClient.EditFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId, builder).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a follow up message.
 	/// </summary>
 	/// <param name="messageId">The id of the follow up message.</param>
 	public Task DeleteFollowupMessageAsync(ulong messageId)
 		=> this.Discord.ApiClient.DeleteFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId);
 }
diff --git a/DisCatSharp/Entities/Invite/DiscordInviteChannel.cs b/DisCatSharp/Entities/Invite/DiscordInviteChannel.cs
index 4c1a51fa4..9a348c30f 100644
--- a/DisCatSharp/Entities/Invite/DiscordInviteChannel.cs
+++ b/DisCatSharp/Entities/Invite/DiscordInviteChannel.cs
@@ -1,49 +1,51 @@
 // 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 DisCatSharp.Enums;
+
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents the channel to which an invite is linked.
 /// </summary>
 public class DiscordInviteChannel : SnowflakeObject
 {
 	/// <summary>
 	/// Gets the name of the channel.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of the channel.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public ChannelType Type { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordInviteChannel"/> class.
 	/// </summary>
 	internal DiscordInviteChannel()
 	{ }
 }
diff --git a/DisCatSharp/Entities/Message/DiscordMessage.cs b/DisCatSharp/Entities/Message/DiscordMessage.cs
index c6f6cc30c..3369051e0 100644
--- a/DisCatSharp/Entities/Message/DiscordMessage.cs
+++ b/DisCatSharp/Entities/Message/DiscordMessage.cs
@@ -1,876 +1,878 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
+using DisCatSharp.Enums;
+
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord text message.
 /// </summary>
 public class DiscordMessage : SnowflakeObject, IEquatable<DiscordMessage>
 {
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMessage"/> class.
 	/// </summary>
 	internal DiscordMessage()
 	{
 		this._attachmentsLazy = new Lazy<IReadOnlyList<DiscordAttachment>>(() => new ReadOnlyCollection<DiscordAttachment>(this.AttachmentsInternal));
 		this._embedsLazy = new Lazy<IReadOnlyList<DiscordEmbed>>(() => new ReadOnlyCollection<DiscordEmbed>(this.EmbedsInternal));
 		this._mentionedChannelsLazy = new Lazy<IReadOnlyList<DiscordChannel>>(() => this.MentionedChannelsInternal != null
 				? new ReadOnlyCollection<DiscordChannel>(this.MentionedChannelsInternal)
 				: Array.Empty<DiscordChannel>());
 		this._mentionedRolesLazy = new Lazy<IReadOnlyList<DiscordRole>>(() => this.MentionedRolesInternal != null ? new ReadOnlyCollection<DiscordRole>(this.MentionedRolesInternal) : Array.Empty<DiscordRole>());
 		this.MentionedUsersLazy = new Lazy<IReadOnlyList<DiscordUser>>(() => new ReadOnlyCollection<DiscordUser>(this.MentionedUsersInternal));
 		this._reactionsLazy = new Lazy<IReadOnlyList<DiscordReaction>>(() => new ReadOnlyCollection<DiscordReaction>(this.ReactionsInternal));
 		this._stickersLazy = new Lazy<IReadOnlyList<DiscordSticker>>(() => new ReadOnlyCollection<DiscordSticker>(this.StickersInternal));
 		this._jumpLink = new Lazy<Uri>(() =>
 		{
 			string gid = null;
 			if (this.Channel != null)
 				gid = this.Channel is DiscordDmChannel
 					? "@me"
 					: this.Channel is DiscordThreadChannel
 					? this.INTERNAL_THREAD.GuildId.Value.ToString(CultureInfo.InvariantCulture)
 					: this.Channel.GuildId.Value.ToString(CultureInfo.InvariantCulture);
 
 			var cid = this.ChannelId.ToString(CultureInfo.InvariantCulture);
 			var mid = this.Id.ToString(CultureInfo.InvariantCulture);
 
 			return new Uri($"https://{(this.Discord.Configuration.UseCanary ? "canary.discord.com" : this.Discord.Configuration.UsePtb ? "ptb.discord.com" : "discord.com")}/channels/{gid}/{cid}/{mid}");
 		});
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordMessage"/> class.
 	/// </summary>
 	/// <param name="other">The other message.</param>
 	internal DiscordMessage(DiscordMessage other)
 		: this()
 	{
 		this.Discord = other.Discord;
 
 		this.AttachmentsInternal = other.AttachmentsInternal; // the attachments cannot change, thus no need to copy and reallocate.
 		this.EmbedsInternal = new List<DiscordEmbed>(other.EmbedsInternal);
 
 		if (other.MentionedChannelsInternal != null)
 			this.MentionedChannelsInternal = new List<DiscordChannel>(other.MentionedChannelsInternal);
 		if (other.MentionedRolesInternal != null)
 			this.MentionedRolesInternal = new List<DiscordRole>(other.MentionedRolesInternal);
 		if (other.MentionedRoleIds != null)
 			this.MentionedRoleIds = new List<ulong>(other.MentionedRoleIds);
 		this.MentionedUsersInternal = new List<DiscordUser>(other.MentionedUsersInternal);
 		this.ReactionsInternal = new List<DiscordReaction>(other.ReactionsInternal);
 		this.StickersInternal = new List<DiscordSticker>(other.StickersInternal);
 
 		this.Author = other.Author;
 		this.ChannelId = other.ChannelId;
 		this.Content = other.Content;
 		this.EditedTimestampRaw = other.EditedTimestampRaw;
 		this.Id = other.Id;
 		this.IsTts = other.IsTts;
 		this.MessageType = other.MessageType;
 		this.Pinned = other.Pinned;
 		this.TimestampRaw = other.TimestampRaw;
 		this.WebhookId = other.WebhookId;
 	}
 
 	/// <summary>
 	/// Gets the channel in which the message was sent.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel Channel
 	{
 		get => (this.Discord as DiscordClient)?.InternalGetCachedChannel(this.ChannelId) ?? this._channel;
 		internal set => this._channel = value;
 	}
 
 	private DiscordChannel _channel;
 
 	/// <summary>
 	/// Gets the thread in which the message was sent.
 	/// </summary>
 	[JsonIgnore]
 	private DiscordThreadChannel INTERNAL_THREAD
 	{
 		get => (this.Discord as DiscordClient)?.InternalGetCachedThread(this.ChannelId) ?? this._thread;
 		set => this._thread = value;
 	}
 
 	private DiscordThreadChannel _thread;
 
 	/// <summary>
 	/// Gets the ID of the channel in which the message was sent.
 	/// </summary>
 	[JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ChannelId { get; internal set; }
 
 	/// <summary>
 	/// Gets the components this message was sent with.
 	/// </summary>
 	[JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyCollection<DiscordActionRowComponent> Components { get; internal set; }
 
 	/// <summary>
 	/// Gets the user or member that sent the message.
 	/// </summary>
 	[JsonProperty("author", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordUser Author { get; internal set; }
 
 	/// <summary>
 	/// Gets the message's content.
 	/// </summary>
 	[JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
 	public string Content { get; internal set; }
 
 	/// <summary>
 	/// Gets the message's creation timestamp.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset Timestamp
 		=> !string.IsNullOrWhiteSpace(this.TimestampRaw) && DateTimeOffset.TryParse(this.TimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : this.CreationTimestamp;
 
 	/// <summary>
 	/// Gets the message's creation timestamp as raw string.
 	/// </summary>
 	[JsonProperty("timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string TimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets the message's edit timestamp. Will be null if the message was not edited.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset? EditedTimestamp
 		=> !string.IsNullOrWhiteSpace(this.EditedTimestampRaw) && DateTimeOffset.TryParse(this.EditedTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			(DateTimeOffset?)dto : null;
 
 	/// <summary>
 	/// Gets the message's edit timestamp as raw string. Will be null if the message was not edited.
 	/// </summary>
 	[JsonProperty("edited_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string EditedTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets whether this message was edited.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsEdited
 		=> !string.IsNullOrWhiteSpace(this.EditedTimestampRaw);
 
 	/// <summary>
 	/// Gets whether the message is a text-to-speech message.
 	/// </summary>
 	[JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsTts { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the message mentions everyone.
 	/// </summary>
 	[JsonProperty("mention_everyone", NullValueHandling = NullValueHandling.Ignore)]
 	public bool MentionEveryone { get; internal set; }
 
 	/// <summary>
 	/// Gets users or members mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordUser> MentionedUsers
 		=> this.MentionedUsersLazy.Value;
 
 	[JsonProperty("mentions", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordUser> MentionedUsersInternal;
 	[JsonIgnore]
 	internal readonly Lazy<IReadOnlyList<DiscordUser>> MentionedUsersLazy;
 
 	// TODO: this will probably throw an exception in DMs since it tries to wrap around a null List...
 	// this is probably low priority but need to find out a clean way to solve it...
 	/// <summary>
 	/// Gets roles mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordRole> MentionedRoles
 		=> this._mentionedRolesLazy.Value;
 
 	[JsonIgnore]
 	internal List<DiscordRole> MentionedRolesInternal;
 
 	[JsonProperty("mention_roles")]
 	internal List<ulong> MentionedRoleIds;
 
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordRole>> _mentionedRolesLazy;
 
 	/// <summary>
 	/// Gets channels mentioned by this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordChannel> MentionedChannels
 		=> this._mentionedChannelsLazy.Value;
 
 	[JsonIgnore]
 	internal List<DiscordChannel> MentionedChannelsInternal;
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordChannel>> _mentionedChannelsLazy;
 
 	/// <summary>
 	/// Gets files attached to this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordAttachment> Attachments
 		=> this._attachmentsLazy.Value;
 
 	[JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordAttachment> AttachmentsInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordAttachment>> _attachmentsLazy;
 
 	/// <summary>
 	/// Gets embeds attached to this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordEmbed> Embeds
 		=> this._embedsLazy.Value;
 
 	[JsonProperty("embeds", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordEmbed> EmbedsInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordEmbed>> _embedsLazy;
 
 	/// <summary>
 	/// Gets reactions used on this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordReaction> Reactions
 		=> this._reactionsLazy.Value;
 
 	[JsonProperty("reactions", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordReaction> ReactionsInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordReaction>> _reactionsLazy;
 
 	/// <summary>
 	/// Gets the nonce sent with the message, if the message was sent by the client.
 	/// </summary>
 	[JsonProperty("nonce", NullValueHandling = NullValueHandling.Ignore)]
 	public string Nonce { get; internal set; }
 
 
 	/// <summary>
 	/// Gets whether the message is pinned.
 	/// </summary>
 	[JsonProperty("pinned", NullValueHandling = NullValueHandling.Ignore)]
 	public bool Pinned { get; internal set; }
 
 	/// <summary>
 	/// Gets the id of the webhook that generated this message.
 	/// </summary>
 	[JsonProperty("webhook_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? WebhookId { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of the message.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public MessageType? MessageType { get; internal set; }
 
 	/// <summary>
 	/// Gets the message activity in the Rich Presence embed.
 	/// </summary>
 	[JsonProperty("activity", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessageActivity Activity { get; internal set; }
 
 	/// <summary>
 	/// Gets the message application in the Rich Presence embed.
 	/// </summary>
 	[JsonProperty("application", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessageApplication Application { get; internal set; }
 
 	/// <summary>
 	/// Gets the message application id in the Rich Presence embed.
 	/// </summary>
 	[JsonProperty("application_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ApplicationId { get; internal set; }
 
 	/// <summary>
 	/// Gets the internal reference.
 	/// </summary>
 	[JsonProperty("message_reference", NullValueHandling = NullValueHandling.Ignore)]
 	internal InternalDiscordMessageReference? InternalReference { get; set; }
 
 	/// <summary>
 	/// Gets the original message reference from the crossposted message.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordMessageReference Reference
 		=> this.InternalReference.HasValue ? this?.InternalBuildMessageReference() : null;
 
 	/// <summary>
 	/// Gets the bitwise flags for this message.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public MessageFlags? Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the message originated from a webhook.
 	/// </summary>
 	[JsonIgnore]
 	public bool WebhookMessage
 		=> this.WebhookId != null;
 
 	/// <summary>
 	/// Gets the jump link to this message.
 	/// </summary>
 	[JsonIgnore]
 	public Uri JumpLink => this._jumpLink.Value;
 	private readonly Lazy<Uri> _jumpLink;
 
 	/// <summary>
 	/// Gets stickers for this message.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyList<DiscordSticker> Stickers
 		=> this._stickersLazy.Value;
 
 	[JsonProperty("sticker_items", NullValueHandling = NullValueHandling.Ignore)]
 	internal List<DiscordSticker> StickersInternal = new();
 	[JsonIgnore]
 	private readonly Lazy<IReadOnlyList<DiscordSticker>> _stickersLazy;
 
 	/// <summary>
 	/// Gets the guild id.
 	/// </summary>
 	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 	internal ulong? GuildId { get; set; }
 
 	/// <summary>
 	/// Gets the message object for the referenced message
 	/// </summary>
 	[JsonProperty("referenced_message", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessage ReferencedMessage { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the message is a response to an interaction.
 	/// </summary>
 	[JsonProperty("interaction", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMessageInteraction Interaction { get; internal set; }
 
 	/// <summary>
 	/// Gets the thread that was started from this message.
 	/// </summary>
 	[JsonProperty("thread", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordThreadChannel Thread { get; internal set; }
 
 	/// <summary>
 	/// Build the message reference.
 	/// </summary>
 	internal DiscordMessageReference InternalBuildMessageReference()
 	{
 		var client = this.Discord as DiscordClient;
 		var guildId = this.InternalReference.Value.GuildId;
 		var channelId = this.InternalReference.Value.ChannelId;
 		var messageId = this.InternalReference.Value.MessageId;
 
 		var reference = new DiscordMessageReference();
 
 		if (guildId.HasValue)
 			reference.Guild = client.GuildsInternal.TryGetValue(guildId.Value, out var g)
 				? g
 				: new DiscordGuild
 				{
 					Id = guildId.Value,
 					Discord = client
 				};
 
 		var channel = client.InternalGetCachedChannel(channelId.Value);
 
 		if (channel == null)
 		{
 			reference.Channel = new DiscordChannel
 			{
 				Id = channelId.Value,
 				Discord = client
 			};
 
 			if (guildId.HasValue)
 				reference.Channel.GuildId = guildId.Value;
 		}
 
 		else reference.Channel = channel;
 
 		if (client.MessageCache != null && client.MessageCache.TryGet(m => m.Id == messageId.Value && m.ChannelId == channelId, out var msg))
 			reference.Message = msg;
 
 		else
 		{
 			reference.Message = new DiscordMessage
 			{
 				ChannelId = this.ChannelId,
 				Discord = client
 			};
 
 			if (messageId.HasValue)
 				reference.Message.Id = messageId.Value;
 		}
 
 		return reference;
 	}
 
 
 	/// <summary>
 	/// Gets the mentions.
 	/// </summary>
 	/// <returns>An array of IMentions.</returns>
 	private List<IMention> GetMentions()
 	{
 		var mentions = new List<IMention>();
 
 		if (this.ReferencedMessage != null && this.MentionedUsersInternal.Contains(this.ReferencedMessage.Author))
 			mentions.Add(new RepliedUserMention());
 
 		if (this.MentionedUsersInternal.Any())
 			mentions.AddRange(this.MentionedUsersInternal.Select(m => (IMention)new UserMention(m)));
 
 		if (this.MentionedRoleIds.Any())
 			mentions.AddRange(this.MentionedRoleIds.Select(r => (IMention)new RoleMention(r)));
 
 		return mentions;
 	}
 
 	/// <summary>
 	/// Populates the mentions.
 	/// </summary>
 	internal void PopulateMentions()
 	{
 		var guild = this.Channel?.Guild;
 		this.MentionedUsersInternal ??= new List<DiscordUser>();
 		this.MentionedRolesInternal ??= new List<DiscordRole>();
 		this.MentionedChannelsInternal ??= new List<DiscordChannel>();
 
 		var mentionedUsers = new HashSet<DiscordUser>(new DiscordUserComparer());
 		if (guild != null)
 		{
 			foreach (var usr in this.MentionedUsersInternal)
 			{
 				usr.Discord = this.Discord;
 				this.Discord.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
 
 				mentionedUsers.Add(guild.MembersInternal.TryGetValue(usr.Id, out var member) ? member : usr);
 			}
 		}
 		if (!string.IsNullOrWhiteSpace(this.Content))
 		{
 			//mentionedUsers.UnionWith(Utilities.GetUserMentions(this).Select(this.Discord.GetCachedOrEmptyUserInternal));
 			if (guild != null)
 			{
 				//this._mentionedRoles = this._mentionedRoles.Union(Utilities.GetRoleMentions(this).Select(xid => guild.GetRole(xid))).ToList();
 				this.MentionedRolesInternal = this.MentionedRolesInternal.Union(this.MentionedRoleIds.Select(xid => guild.GetRole(xid))).ToList();
 				this.MentionedChannelsInternal = this.MentionedChannelsInternal.Union(Utilities.GetChannelMentions(this).Select(xid => guild.GetChannel(xid))).ToList();
 			}
 		}
 
 		this.MentionedUsersInternal = mentionedUsers.ToList();
 	}
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<string> content)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, default, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="embed">New embed.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<DiscordEmbed> embed = default)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, embed.Map(v => new[] { v }).ValueOr(Array.Empty<DiscordEmbed>()), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <param name="embed">New embed.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<string> content, Optional<DiscordEmbed> embed = default)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embed.Map(v => new[] { v }).ValueOr(Array.Empty<DiscordEmbed>()), this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="content">New content.</param>
 	/// <param name="embeds">New embeds.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifyAsync(Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds = default)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, content, embeds, this.GetMentions(), default, default, Array.Empty<DiscordMessageFile>(), default);
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="builder">The builder of the message to edit.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> ModifyAsync(DiscordMessageBuilder builder)
 	{
 		builder.Validate(true);
 		return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, Optional.Some(builder.Embeds.AsEnumerable()), builder.Mentions, builder.Components, builder.Suppressed, builder.Files, builder.Attachments.Count > 0 ? Optional.Some(builder.Attachments.AsEnumerable()) : builder.KeepAttachmentsInternal.HasValue ? builder.KeepAttachmentsInternal.Value ? Optional.Some(this.Attachments.AsEnumerable()) : Array.Empty<DiscordAttachment>() : null);
 	}
 
 	/// <summary>
 	/// Edits the message embed suppression.
 	/// </summary>
 	/// <param name="suppress">Suppress embeds.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> ModifySuppressionAsync(bool suppress = false)
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, default, default, suppress, default, default);
 
 	/// <summary>
 	/// Clears all attachments from the message.
 	/// </summary>
 	/// <returns></returns>
 	public Task<DiscordMessage> ClearAttachmentsAsync()
 		=> this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, default, default, this.GetMentions(), default, default, default, Array.Empty<DiscordAttachment>());
 
 	/// <summary>
 	/// Edits the message.
 	/// </summary>
 	/// <param name="action">The builder of the message to edit.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client tried to modify a message not sent by them.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMessage> ModifyAsync(Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 		builder.Validate(true);
 		return await this.Discord.ApiClient.EditMessageAsync(this.ChannelId, this.Id, builder.Content, Optional.Some(builder.Embeds.AsEnumerable()), builder.Mentions, builder.Components, builder.Suppressed, builder.Files, builder.Attachments.Count > 0 ? Optional.Some(builder.Attachments.AsEnumerable()) : builder.KeepAttachmentsInternal.HasValue ? builder.KeepAttachmentsInternal.Value ? Optional.Some(this.Attachments.AsEnumerable()) : Array.Empty<DiscordAttachment>() : null);
 	}
 
 	/// <summary>
 	/// Deletes the message.
 	/// </summary>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteMessageAsync(this.ChannelId, this.Id, reason);
 
 	/// <summary>
 	/// Creates a thread.
 	/// Depending on the <see cref="ChannelType"/> of the parent channel it's either a <see cref="ChannelType.PublicThread"/> or a <see cref="ChannelType.NewsThread"/>.
 	/// </summary>
 	/// <param name="name">The name of the thread.</param>
 	/// <param name="autoArchiveDuration"><see cref="ThreadAutoArchiveDuration"/> till it gets archived. Defaults to <see cref="ThreadAutoArchiveDuration.OneHour"/></param>
 	/// <param name="rateLimitPerUser">The per user ratelimit, aka slowdown.</param>
 	/// <param name="reason">The reason.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.CreatePrivateThreads"/> or <see cref="Permissions.SendMessagesInThreads"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the channel does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified.</exception>
 	public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, int? rateLimitPerUser = null, string reason = null) =>
 		Utilities.CheckThreadAutoArchiveDurationFeature(this.Channel.Guild, autoArchiveDuration)
 			? await this.Discord.ApiClient.CreateThreadAsync(this.ChannelId, this.Id, name, autoArchiveDuration, this.Channel.Type == ChannelType.News ? ChannelType.NewsThread : ChannelType.PublicThread, rateLimitPerUser, reason)
 			: throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(autoArchiveDuration == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 
 	/// <summary>
 	/// Pins the message in its channel.
 	/// </summary>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task PinAsync()
 		=> this.Discord.ApiClient.PinMessageAsync(this.ChannelId, this.Id);
 
 	/// <summary>
 	/// Unpins the message in its channel.
 	/// </summary>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UnpinAsync()
 		=> this.Discord.ApiClient.UnpinMessageAsync(this.ChannelId, this.Id);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="content">Message content to respond with.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(string content)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(DiscordEmbed embed)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, null, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="content">Message content to respond with.</param>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(string content, DiscordEmbed embed)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, content, embed != null ? new[] { embed } : null, sticker: null, replyMessageId: this.Id, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="builder">The Discord message builder.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(DiscordMessageBuilder builder)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 
 	/// <summary>
 	/// Responds to the message. This produces a reply.
 	/// </summary>
 	/// <param name="action">The Discord message builder.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the member does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordMessage> RespondAsync(Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 		return this.Discord.ApiClient.CreateMessageAsync(this.ChannelId, builder.WithReply(this.Id, mention: false, failOnInvalidReply: false));
 	}
 
 	/// <summary>
 	/// Creates a reaction to this message.
 	/// </summary>
 	/// <param name="emoji">The emoji you want to react with, either an emoji or name:id</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AddReactions"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task CreateReactionAsync(DiscordEmoji emoji)
 		=> this.Discord.ApiClient.CreateReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	/// <summary>
 	/// Deletes your own reaction
 	/// </summary>
 	/// <param name="emoji">Emoji for the reaction you want to remove, either an emoji or name:id</param>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteOwnReactionAsync(DiscordEmoji emoji)
 		=> this.Discord.ApiClient.DeleteOwnReactionAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	/// <summary>
 	/// Deletes another user's reaction.
 	/// </summary>
 	/// <param name="emoji">Emoji for the reaction you want to remove, either an emoji or name:id.</param>
 	/// <param name="user">Member you want to remove the reaction for</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteReactionAsync(DiscordEmoji emoji, DiscordUser user, string reason = null)
 		=> this.Discord.ApiClient.DeleteUserReactionAsync(this.ChannelId, this.Id, user.Id, emoji.ToReactionString(), reason);
 
 	/// <summary>
 	/// Gets users that reacted with this emoji.
 	/// </summary>
 	/// <param name="emoji">Emoji to react with.</param>
 	/// <param name="limit">Limit of users to fetch.</param>
 	/// <param name="after">Fetch users after this user's id.</param>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<IReadOnlyList<DiscordUser>> GetReactionsAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
 		=> this.GetReactionsInternalAsync(emoji, limit, after);
 
 	/// <summary>
 	/// Deletes all reactions for this message.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteAllReactionsAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteAllReactionsAsync(this.ChannelId, this.Id, reason);
 
 	/// <summary>
 	/// Deletes all reactions of a specific reaction for this message.
 	/// </summary>
 	/// <param name="emoji">The emoji to clear, either an emoji or name:id.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the emoji does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task DeleteReactionsEmojiAsync(DiscordEmoji emoji)
 		=> this.Discord.ApiClient.DeleteReactionsEmojiAsync(this.ChannelId, this.Id, emoji.ToReactionString());
 
 	/// <summary>
 	/// Gets the reactions.
 	/// </summary>
 	/// <param name="emoji">The emoji to search for.</param>
 	/// <param name="limit">The limit of results.</param>
 	/// <param name="after">Get the reasctions after snowflake.</param>
 	private async Task<IReadOnlyList<DiscordUser>> GetReactionsInternalAsync(DiscordEmoji emoji, int limit = 25, ulong? after = null)
 	{
 		if (limit < 0)
 			throw new ArgumentException("Cannot get a negative number of reactions' users.");
 
 		if (limit == 0)
 			return Array.Empty<DiscordUser>();
 
 		var users = new List<DiscordUser>(limit);
 		var remaining = limit;
 		var last = after;
 
 		int lastCount;
 		do
 		{
 			var fetchSize = remaining > 100 ? 100 : remaining;
 			var fetch = await this.Discord.ApiClient.GetReactionsAsync(this.Channel.Id, this.Id, emoji.ToReactionString(), last, fetchSize).ConfigureAwait(false);
 
 			lastCount = fetch.Count;
 			remaining -= lastCount;
 
 			users.AddRange(fetch);
 			last = fetch.LastOrDefault()?.Id;
 		} while (remaining > 0 && lastCount > 0);
 
 		return new ReadOnlyCollection<DiscordUser>(users);
 	}
 
 	/// <summary>
 	/// Returns a string representation of this message.
 	/// </summary>
 	/// <returns>String representation of this message.</returns>
 	public override string ToString()
 		=> $"Message {this.Id}; Attachment count: {this.AttachmentsInternal.Count}; Embed count: {this.EmbedsInternal.Count}; Contents: {this.Content}";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMessage"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordMessage"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as DiscordMessage);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordMessage"/> is equal to another <see cref="DiscordMessage"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordMessage"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordMessage"/> is equal to this <see cref="DiscordMessage"/>.</returns>
 	public bool Equals(DiscordMessage e)
 		=> e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.ChannelId == e.ChannelId));
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordMessage"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordMessage"/>.</returns>
 	public override int GetHashCode()
 	{
 		var hash = 13;
 
 		hash = (hash * 7) + this.Id.GetHashCode();
 		hash = (hash * 7) + this.ChannelId.GetHashCode();
 
 		return hash;
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMessage"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First message to compare.</param>
 	/// <param name="e2">Second message to compare.</param>
 	/// <returns>Whether the two messages are equal.</returns>
 	public static bool operator ==(DiscordMessage e1, DiscordMessage e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null)
 			&& (o1 == null || o2 != null)
 			&& ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1.ChannelId == e2.ChannelId));
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordMessage"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First message to compare.</param>
 	/// <param name="e2">Second message to compare.</param>
 	/// <returns>Whether the two messages are not equal.</returns>
 	public static bool operator !=(DiscordMessage e1, DiscordMessage e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Sticker/DiscordSticker.cs b/DisCatSharp/Entities/Sticker/DiscordSticker.cs
index a1efe4b14..a01fae220 100644
--- a/DisCatSharp/Entities/Sticker/DiscordSticker.cs
+++ b/DisCatSharp/Entities/Sticker/DiscordSticker.cs
@@ -1,227 +1,233 @@
 // 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.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Net;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord Sticker.
 /// </summary>
 public class DiscordSticker : SnowflakeObject, IEquatable<DiscordSticker>
 {
 	/// <summary>
 	/// Gets the Pack ID of this sticker.
 	/// </summary>
 	[JsonProperty("pack_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? PackId { get; internal set; }
 
 	/// <summary>
 	/// Gets the Name of the sticker.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the Description of the sticker.
 	/// </summary>
 	[JsonProperty("description", NullValueHandling = NullValueHandling.Ignore)]
 	public string Description { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of sticker.
 	/// </summary>
 	[JsonProperty("type")]
 	public StickerType Type { get; internal set; }
 
 	/// <summary>
 	/// For guild stickers, gets the user that made the sticker.
 	/// </summary>
 	[JsonProperty("user", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordUser User { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild associated with this sticker, if any.
 	/// </summary>
 	public DiscordGuild Guild => (this.Discord as DiscordClient).InternalGetCachedGuild(this.GuildId);
 
 	/// <summary>
 	/// Gets the guild id the sticker belongs too.
 	/// </summary>
 	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? GuildId { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this sticker is available. Only applicable to guild stickers.
 	/// </summary>
 	[JsonProperty("available", NullValueHandling = NullValueHandling.Ignore)]
 	public bool Available { get; internal set; }
 
 	/// <summary>
 	/// Gets the sticker's sort order, if it's in a pack.
 	/// </summary>
 	[JsonProperty("sort_value", NullValueHandling = NullValueHandling.Ignore)]
 	public int? SortValue { get; internal set; }
 
 	/// <summary>
 	/// Gets the list of tags for the sticker.
 	/// </summary>
 	[JsonIgnore]
 	public IEnumerable<string> Tags
 		=> this.InternalTags != null ? this.InternalTags.Split(',') : Array.Empty<string>();
 
 	/// <summary>
 	/// Gets the asset hash of the sticker.
 	/// </summary>
 	[JsonProperty("asset", NullValueHandling = NullValueHandling.Ignore)]
 	public string Asset { get; internal set; }
 
 	/// <summary>
 	/// Gets the preview asset hash of the sticker.
 	/// </summary>
 	[JsonProperty("preview_asset", NullValueHandling = NullValueHandling.Ignore)]
 	public string PreviewAsset { get; internal set; }
 
 	/// <summary>
 	/// Gets the Format type of the sticker.
 	/// </summary>
 	[JsonProperty("format_type")]
 	public StickerFormat FormatType { get; internal set; }
 
 	/// <summary>
 	/// Gets the tags of the sticker.
 	/// </summary>
 	[JsonProperty("tags", NullValueHandling = NullValueHandling.Ignore)]
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>")]
 	internal string InternalTags { get; set; }
 
 	/// <summary>
 	/// Gets the url of the sticker.
 	/// </summary>
 	[JsonIgnore]
 	public string Url => $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.STICKERS}/{this.Id}.{(this.FormatType == StickerFormat.Lottie ? "json" : "png")}";
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordSticker"/> class.
 	/// </summary>
 	internal DiscordSticker()
 	{ }
 
+	/// <summary>
+	/// Gets the hash code of the current sticker.
+	/// </summary>
+	/// <returns>The hash code.</returns>
+	public override int GetHashCode()
+		=> this.PackId != null ? HashCode.Combine(this.Id.GetHashCode(), this.PackId.GetHashCode()) : HashCode.Combine(this.Id.GetHashCode(), this.GuildId.GetHashCode());
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordSticker"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordSticker"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as ForumPostTag);
 
 	/// <summary>
 	/// Whether to stickers are equal.
 	/// </summary>
 	/// <param name="other">DiscordSticker</param>
 	public bool Equals(DiscordSticker other)
 		=> this.Id == other.Id;
 
 	/// <summary>
 	/// Gets the sticker in readable format.
 	/// </summary>
 	public override string ToString() => $"Sticker {this.Id}; {this.Name}; {this.FormatType}";
 
 	/// <summary>
 	/// Modifies the sticker
 	/// </summary>
 	/// <param name="name">The name of the sticker</param>
 	/// <param name="description">The description of the sticker</param>
 	/// <param name="tags">The name of a unicode emoji representing the sticker's expression</param>
 	/// <param name="reason">Audit log reason</param>
 	/// <returns>A sticker object</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task<DiscordSticker> ModifyAsync(Optional<string> name, Optional<string> description, Optional<string> tags, string reason = null) =>
 		!this.GuildId.HasValue
 			? throw new ArgumentException("This sticker does not belong to a guild.")
 			: name.HasValue && (name.Value.Length < 2 || name.Value.Length > 30)
 				? throw new ArgumentException("Sticker name needs to be between 2 and 30 characters long.")
 				: description.HasValue && (description.Value.Length < 1 || description.Value.Length > 100)
 					? throw new ArgumentException("Sticker description needs to be between 1 and 100 characters long.")
 					: tags.HasValue && !DiscordEmoji.TryFromUnicode(this.Discord, tags.Value, out var emoji)
 						? throw new ArgumentException("Sticker tags needs to be a unicode emoji.")
 						: this.Discord.ApiClient.ModifyGuildStickerAsync(this.GuildId.Value, this.Id, name, description, tags, reason);
 
 	/// <summary>
 	/// Deletes the sticker
 	/// </summary>
 	/// <param name="reason">Audit log reason</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the sticker could not be found.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageEmojisAndStickers"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.ArgumentException">Sticker does not belong to a guild.</exception>
 	public Task DeleteAsync(string reason = null)
 		=> this.GuildId.HasValue ? this.Discord.ApiClient.DeleteGuildStickerAsync(this.GuildId.Value, this.Id, reason) : throw new ArgumentException("The requested sticker is no guild sticker.");
 }
 
 /// <summary>
 /// The sticker type
 /// </summary>
 public enum StickerType : long
 {
 	/// <summary>
 	/// Standard nitro sticker
 	/// </summary>
 	Standard = 1,
 
 	/// <summary>
 	/// Custom guild sticker
 	/// </summary>
 	Guild = 2
 }
 
 /// <summary>
 /// The sticker type
 /// </summary>
 public enum StickerFormat : long
 {
 	/// <summary>
 	/// Sticker is a png
 	/// </summary>
 	Png = 1,
 
 	/// <summary>
 	/// Sticker is a animated png
 	/// </summary>
 	Apng = 2,
 
 	/// <summary>
 	/// Sticker is lottie
 	/// </summary>
 	Lottie = 3
 }
diff --git a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs b/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
index 89febba14..d3aa9e433 100644
--- a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
+++ b/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
@@ -1,669 +1,670 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
 
+using DisCatSharp.Enums;
 using DisCatSharp.Net.Models;
 using DisCatSharp.Net.Serialization;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a discord thread channel.
 /// </summary>
 public class DiscordThreadChannel : DiscordChannel, IEquatable<DiscordThreadChannel>
 {
 	/// <summary>
 	/// Gets ID of the owner that started this thread.
 	/// </summary>
 	[JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong OwnerId { get; internal set; }
 
 	/// <summary>
 	/// Gets the name of this thread.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public new string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the type of this thread.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public new ChannelType Type { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this thread is private.
 	/// </summary>
 	[JsonIgnore]
 	public new bool IsPrivate
 		=> this.Type == ChannelType.PrivateThread;
 
 	/// <summary>
 	/// Gets the ID of the last message sent in this thread.
 	/// </summary>
 	[JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
 	public new ulong? LastMessageId { get; internal set; }
 
 	/// <summary>
 	/// <para>Gets the slowmode delay configured for this thread.</para>
 	/// <para>All bots, as well as users with <see cref="Permissions.ManageChannels"/> or <see cref="Permissions.ManageMessages"/> permissions in the channel are exempt from slowmode.</para>
 	/// </summary>
 	[JsonProperty("rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
 	public new int? PerUserRateLimit { get; internal set; }
 
 	/// <summary>
 	/// Gets an approximate count of messages in a thread, stops counting at 50.
 	/// </summary>
 	[JsonProperty("message_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MessageCount { get; internal set; }
 
 	/// <summary>
 	/// Gets an approximate count of users in a thread, stops counting at 50.
 	/// </summary>
 	[JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MemberCount { get; internal set; }
 
 	/// <summary>
 	/// Represents the current member for this thread. This will have a value if the user has joined the thread.
 	/// </summary>
 	[JsonProperty("member", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordThreadChannelMember CurrentMember { get; internal set; }
 
 
 	/// <summary>
 	/// Gets when the last pinned message was pinned in this thread.
 	/// </summary>
 	[JsonIgnore]
 	public new DateTimeOffset? LastPinTimestamp
 		=> !string.IsNullOrWhiteSpace(this.LastPinTimestampRaw) && DateTimeOffset.TryParse(this.LastPinTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets when the last pinned message was pinned in this thread as raw string.
 	/// </summary>
 	[JsonProperty("last_pin_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal new string LastPinTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets the threads metadata.
 	/// </summary>
 	[JsonProperty("thread_metadata", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordThreadChannelMetadata ThreadMetadata { get; internal set; }
 
 	/// <summary>
 	/// Gets the thread members object.
 	/// </summary>
 	[JsonIgnore]
 	public IReadOnlyDictionary<ulong, DiscordThreadChannelMember> ThreadMembers => new ReadOnlyConcurrentDictionary<ulong, DiscordThreadChannelMember>(this.ThreadMembersInternal);
 
 	[JsonProperty("thread_member", NullValueHandling = NullValueHandling.Ignore)]
 	[JsonConverter(typeof(SnowflakeArrayAsDictionaryJsonConverter))]
 	internal ConcurrentDictionary<ulong, DiscordThreadChannelMember> ThreadMembersInternal;
 
   /// <summary>
   /// List of applied tag ids.
   /// </summary>
   [JsonIgnore]
   internal IReadOnlyList<ulong> AppliedTagIds
     => this._appliedTagsIdsLazy.Value;
 
   /// <summary>
   /// List of applied tag ids.
   /// </summary>
   [JsonProperty("applied_tags", NullValueHandling = NullValueHandling.Ignore)]
   internal List<ulong> AppliedTagIdsInternal;
   [JsonIgnore]
   private readonly Lazy<IReadOnlyList<ulong>> _appliedTagsIdsLazy;
 
   /// <summary>
   /// Gets the list of applied tags.
   /// Only applicable for forum channel posts.
   /// </summary>
   [JsonIgnore]
   public IEnumerable<ForumPostTag> AppliedTags
     => this.AppliedTagIds.Select(id => this.Parent.GetForumPostTagAsync(id).Result).Where(x => x != null);
 
   /// <summary>
   /// Initializes a new instance of the <see cref="DiscordThreadChannel"/> class.
   /// </summary>
   internal DiscordThreadChannel()
   {
     this._appliedTagsIdsLazy = new Lazy<IReadOnlyList<ulong>>(() => new ReadOnlyCollection<ulong>(this.AppliedTagIdsInternal));
   }
 
 	#region Methods
 
 	/// <summary>
 	/// Deletes a thread.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task DeleteAsync(string reason = null)
 		=> this.Discord.ApiClient.DeleteThreadAsync(this.Id, reason);
 
 	/// <summary>
 	/// Modifies the current thread.
 	/// </summary>
 	/// <param name="action">Action to perform on this thread</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="System.NotSupportedException">Thrown when the <see cref="ThreadAutoArchiveDuration"/> cannot be modified. This happens, when the guild hasn't reached a certain boost <see cref="PremiumTier"/>.</exception>
 	public Task ModifyAsync(Action<ThreadEditModel> action)
 	{
 		var mdl = new ThreadEditModel();
 		action(mdl);
 
 		var canContinue = !mdl.AutoArchiveDuration.HasValue || !mdl.AutoArchiveDuration.Value.HasValue || Utilities.CheckThreadAutoArchiveDurationFeature(this.Guild, mdl.AutoArchiveDuration.Value.Value);
 		if (mdl.Invitable.HasValue)
 		{
 			canContinue = this.Guild.Features.CanCreatePrivateThreads;
 		}
 		return canContinue ? this.Discord.ApiClient.ModifyThreadAsync(this.Id, mdl.Name, mdl.Locked, mdl.Archived, mdl.PerUserRateLimit, mdl.AutoArchiveDuration, mdl.Invitable, mdl.AuditLogReason) : throw new NotSupportedException($"Cannot modify ThreadAutoArchiveDuration. Guild needs boost tier {(mdl.AutoArchiveDuration.Value.Value == ThreadAutoArchiveDuration.ThreeDays ? "one" : "two")}.");
 	}
 
 	/// <summary>
 	/// Archives a thread.
 	/// </summary>
 	/// <param name="locked">Whether the thread should be locked.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageThreads"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task ArchiveAsync(bool locked = true, string reason = null)
 		=> this.Discord.ApiClient.ModifyThreadAsync(this.Id, null, locked, true, null, null, null, reason: reason);
 
 	/// <summary>
 	/// Unarchives a thread.
 	/// </summary>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UnarchiveAsync(string reason = null)
 		=> this.Discord.ApiClient.ModifyThreadAsync(this.Id, null, null, false, null, null, null, reason: reason);
 
 	/// <summary>
 	/// Gets the members of a thread. Needs the <see cref="DiscordIntents.GuildMembers"/> intent.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<IReadOnlyList<DiscordThreadChannelMember>> GetMembersAsync()
 		=> await this.Discord.ApiClient.GetThreadMembersAsync(this.Id);
 
 	/// <summary>
 	/// Adds a member to this thread.
 	/// </summary>
 	/// <param name="memberId">The member id to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddMemberAsync(ulong memberId)
 		=> this.Discord.ApiClient.AddThreadMemberAsync(this.Id, memberId);
 
 	/// <summary>
 	/// Adds a member to this thread.
 	/// </summary>
 	/// <param name="member">The member to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddMemberAsync(DiscordMember member)
 		=> this.AddMemberAsync(member.Id);
 
 	/// <summary>
 	/// Gets a member in this thread.
 	/// </summary>
 	/// <param name="memberId">The member to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member is not part of the thread.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordThreadChannelMember> GetMemberAsync(ulong memberId)
 		=> this.Discord.ApiClient.GetThreadMemberAsync(this.Id, memberId);
 
 	/// <summary>
 	/// Gets a member in this thread.
 	/// </summary>
 	/// <param name="member">The member to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the member is not part of the thread.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task<DiscordThreadChannelMember> GetMemberAsync(DiscordMember member)
 		=> this.Discord.ApiClient.GetThreadMemberAsync(this.Id, member.Id);
 
 	/// <summary>
 	/// Removes a member from this thread.
 	/// </summary>
 	/// <param name="memberId">The member id to be removed.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveMemberAsync(ulong memberId)
 		=> this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, memberId);
 
 	/// <summary>
 	/// Removes a member from this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="member">The member to be removed.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveMemberAsync(DiscordMember member)
 		=> this.RemoveMemberAsync(member.Id);
 
 	/// <summary>
 	/// Adds a role to this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="roleId">The role id to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task AddRoleAsync(ulong roleId)
 	{
 		var role = this.Guild.GetRole(roleId);
 		var members = await this.Guild.GetAllMembersAsync();
 		var roleMembers = members.Where(m => m.Roles.Contains(role));
 		foreach (var member in roleMembers)
 		{
 			await this.Discord.ApiClient.AddThreadMemberAsync(this.Id, member.Id);
 		}
 	}
 
 	/// <summary>
 	/// Adds a role to this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="role">The role to be added.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task AddRoleAsync(DiscordRole role)
 		=> this.AddRoleAsync(role.Id);
 
 	/// <summary>
 	/// Removes a role from this thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="roleId">The role id to be removed.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task RemoveRoleAsync(ulong roleId)
 	{
 		var role = this.Guild.GetRole(roleId);
 		var members = await this.Guild.GetAllMembersAsync();
 		var roleMembers = members.Where(m => m.Roles.Contains(role));
 		foreach (var member in roleMembers)
 		{
 			await this.Discord.ApiClient.RemoveThreadMemberAsync(this.Id, member.Id);
 		}
 	}
 
 	/// <summary>
 	/// Removes a role to from thread. Only applicable to private threads.
 	/// </summary>
 	/// <param name="role">The role to be removed.</param>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task RemoveRoleAsync(DiscordRole role)
 		=> this.RemoveRoleAsync(role.Id);
 
 	/// <summary>
 	/// Joins a thread.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client has no access to this thread.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task JoinAsync()
 		=> this.Discord.ApiClient.JoinThreadAsync(this.Id);
 
 	/// <summary>
 	/// Leaves a thread.
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client has no access to this thread.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task LeaveAsync()
 		=> this.Discord.ApiClient.LeaveThreadAsync(this.Id);
 
 	/// <summary>
 	/// Sends a message to this thread.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<DiscordMessage> SendMessageAsync(string content) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, null, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this thread.
 	/// </summary>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<DiscordMessage> SendMessageAsync(DiscordEmbed embed) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, null, new[] { embed }, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this thread.
 	/// </summary>
 	/// <param name="content">Content of the message to send.</param>
 	/// <param name="embed">Embed to attach to the message.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<DiscordMessage> SendMessageAsync(string content, DiscordEmbed embed) =>
 		!this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-thread channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, content, new[] { embed }, sticker: null, replyMessageId: null, mentionReply: false, failOnInvalidReply: false);
 
 	/// <summary>
 	/// Sends a message to this thread.
 	/// </summary>
 	/// <param name="builder">The builder with all the items to thread.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<DiscordMessage> SendMessageAsync(DiscordMessageBuilder builder)
 		=> this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 
 	/// <summary>
 	/// Sends a message to this channel.
 	/// </summary>
 	/// <param name="action">The builder with all the items to send.</param>
 	/// <returns>The sent message.</returns>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<DiscordMessage> SendMessageAsync(Action<DiscordMessageBuilder> action)
 	{
 		var builder = new DiscordMessageBuilder();
 		action(builder);
 
 		return !this.IsWritable()
 			? throw new ArgumentException("Cannot send a text message to a non-text channel.")
 			: this.Discord.ApiClient.CreateMessageAsync(this.Id, builder);
 	}
 
 	/// <summary>
 	/// Returns a specific message
 	/// </summary>
 	/// <param name="id">The id of the message</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.SendMessagesInThreads"/> permission and <see cref="Permissions.SendTtsMessages"/> if TTS is true or the thread is locked.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new async Task<DiscordMessage> GetMessageAsync(ulong id) =>
 		this.Discord.Configuration.MessageCacheSize > 0
 		&& this.Discord is DiscordClient dc
 		&& dc.MessageCache != null
 		&& dc.MessageCache.TryGet(xm => xm.Id == id && xm.ChannelId == this.Id, out var msg)
 			? msg
 			: await this.Discord.ApiClient.GetMessageAsync(this.Id, id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Returns a list of messages before a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="before">Message to fetch before from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<IReadOnlyList<DiscordMessage>> GetMessagesBeforeAsync(ulong before, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, before, null, null);
 
 	/// <summary>
 	/// Returns a list of messages after a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="after">Message to fetch after from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAfterAsync(ulong after, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, null, after, null);
 
 	/// <summary>
 	/// Returns a list of messages around a certain message.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// <param name="around">Message to fetch around from.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAroundAsync(ulong around, int limit = 100)
 		=> this.GetMessagesInternalAsync(limit, null, null, around);
 
 	/// <summary>
 	/// Returns a list of messages from the last message in the thread.
 	/// <param name="limit">The amount of messages to fetch.</param>
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> or the <see cref="Permissions.ReadMessageHistory"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<IReadOnlyList<DiscordMessage>> GetMessagesAsync(int limit = 100) =>
 		this.GetMessagesInternalAsync(limit, null, null, null);
 
 	/// <summary>
 	/// Returns a list of messages
 	/// </summary>
 	/// <param name="limit">How many messages should be returned.</param>
 	/// <param name="before">Get messages before snowflake.</param>
 	/// <param name="after">Get messages after snowflake.</param>
 	/// <param name="around">Get messages around snowflake.</param>
 	private async Task<IReadOnlyList<DiscordMessage>> GetMessagesInternalAsync(int limit = 100, ulong? before = null, ulong? after = null, ulong? around = null)
 	{
 		if (this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread)
 			throw new ArgumentException("Cannot get the messages of a non-thread channel.");
 
 		if (limit < 0)
 			throw new ArgumentException("Cannot get a negative number of messages.");
 
 		if (limit == 0)
 			return Array.Empty<DiscordMessage>();
 
 		//return this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, limit, before, after, around);
 		if (limit > 100 && around != null)
 			throw new InvalidOperationException("Cannot get more than 100 messages around the specified ID.");
 
 		var msgs = new List<DiscordMessage>(limit);
 		var remaining = limit;
 		ulong? last = null;
 		var isAfter = after != null;
 
 		int lastCount;
 		do
 		{
 			var fetchSize = remaining > 100 ? 100 : remaining;
 			var fetch = await this.Discord.ApiClient.GetChannelMessagesAsync(this.Id, fetchSize, !isAfter ? last ?? before : null, isAfter ? last ?? after : null, around).ConfigureAwait(false);
 
 			lastCount = fetch.Count;
 			remaining -= lastCount;
 
 			if (!isAfter)
 			{
 				msgs.AddRange(fetch);
 				last = fetch.LastOrDefault()?.Id;
 			}
 			else
 			{
 				msgs.InsertRange(0, fetch);
 				last = fetch.FirstOrDefault()?.Id;
 			}
 		}
 		while (remaining > 0 && lastCount > 0);
 
 		return new ReadOnlyCollection<DiscordMessage>(msgs);
 	}
 
 	/// <summary>
 	/// Deletes multiple messages if they are less than 14 days old.  If they are older, none of the messages will be deleted and you will receive a <see cref="DisCatSharp.Exceptions.BadRequestException"/> error.
 	/// </summary>
 	/// <param name="messages">A collection of messages to delete.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new async Task DeleteMessagesAsync(IEnumerable<DiscordMessage> messages, string reason = null)
 	{
 		// don't enumerate more than once
 		var msgs = messages.Where(x => x.Channel.Id == this.Id).Select(x => x.Id).ToArray();
 		if (messages == null || !msgs.Any())
 			throw new ArgumentException("You need to specify at least one message to delete.");
 
 		if (msgs.Length < 2)
 		{
 			await this.Discord.ApiClient.DeleteMessageAsync(this.Id, msgs.Single(), reason).ConfigureAwait(false);
 			return;
 		}
 
 		for (var i = 0; i < msgs.Length; i += 100)
 			await this.Discord.ApiClient.DeleteMessagesAsync(this.Id, msgs.Skip(i).Take(100), reason).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Deletes a message
 	/// </summary>
 	/// <param name="message">The message to be deleted.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.ManageMessages"/> permission.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task DeleteMessageAsync(DiscordMessage message, string reason = null)
 		=> this.Discord.ApiClient.DeleteMessageAsync(this.Id, message.Id, reason);
 
 	/// <summary>
 	/// Post a typing indicator
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task TriggerTypingAsync() =>
 		this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.NewsThread
 			? throw new ArgumentException("Cannot start typing in a non-text channel.")
 			: this.Discord.ApiClient.TriggerTypingAsync(this.Id);
 
 	/// <summary>
 	/// Returns all pinned messages
 	/// </summary>
 	/// <exception cref="DisCatSharp.Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.AccessChannels"/> permission or the client is missing <see cref="Permissions.ReadMessageHistory"/>.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="DisCatSharp.Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public new Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync() =>
 		this.Type != ChannelType.PublicThread && this.Type != ChannelType.PrivateThread && this.Type != ChannelType.News
 			? throw new ArgumentException("A non-thread channel does not have pinned messages.")
 			: this.Discord.ApiClient.GetPinnedMessagesAsync(this.Id);
 
 	/// <summary>
 	/// Returns a string representation of this thread.
 	/// </summary>
 	/// <returns>String representation of this thread.</returns>
 	public override string ToString()
 		=> this.Type switch
 		{
 			ChannelType.NewsThread => $"News thread {this.Name} ({this.Id})",
 			ChannelType.PublicThread => $"Thread {this.Name} ({this.Id})",
 			ChannelType.PrivateThread => $"Private thread {this.Name} ({this.Id})",
 			_ => $"Thread {this.Name} ({this.Id})",
 		};
 	#endregion
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordThreadChannel"/>.</returns>
 	public override bool Equals(object obj) => this.Equals(obj as DiscordThreadChannel);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another <see cref="DiscordThreadChannel"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordThreadChannel"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordThreadChannel"/> is equal to this <see cref="DiscordThreadChannel"/>.</returns>
 	public bool Equals(DiscordThreadChannel e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordThreadChannel"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordThreadChannel"/>.</returns>
 	public override int GetHashCode() => this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordThreadChannel"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First channel to compare.</param>
 	/// <param name="e2">Second channel to compare.</param>
 	/// <returns>Whether the two channels are equal.</returns>
 	public static bool operator ==(DiscordThreadChannel e1, DiscordThreadChannel e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordThreadChannel"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First channel to compare.</param>
 	/// <param name="e2">Second channel to compare.</param>
 	/// <returns>Whether the two channels are not equal.</returns>
 	public static bool operator !=(DiscordThreadChannel e1, DiscordThreadChannel e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/Thread/DiscordThreadChannelMember.cs b/DisCatSharp/Entities/Thread/DiscordThreadChannelMember.cs
index bb3473721..bb9880a88 100644
--- a/DisCatSharp/Entities/Thread/DiscordThreadChannelMember.cs
+++ b/DisCatSharp/Entities/Thread/DiscordThreadChannelMember.cs
@@ -1,138 +1,141 @@
 // 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.Globalization;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a discord thread member object.
 /// </summary>
 public class DiscordThreadChannelMember : SnowflakeObject, IEquatable<DiscordThreadChannelMember>
 {
 	/// <summary>
 	/// Gets the id of the user.
 	/// </summary>
 	[JsonProperty("user_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong UserId { get; internal set; }
 
 	/// <summary>
 	/// Gets the member object of the user.
 	/// </summary>
 	[JsonProperty("member", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMember Member { get; internal set; }
 
 	/// <summary>
 	/// Gets the presence of the user.
 	/// </summary>
 	[JsonProperty("presence", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordPresence Presence { get; internal set; }
 
 	/// <summary>
 	/// Gets the timestamp when the user joined the thread.
 	/// </summary>
 	[JsonIgnore]
 	public DateTimeOffset? JoinTimeStamp
 		=> !string.IsNullOrWhiteSpace(this.JoinTimeStampRaw) && DateTimeOffset.TryParse(this.JoinTimeStampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets the timestamp when the user joined the thread as raw string.
 	/// </summary>
 	[JsonProperty("join_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string JoinTimeStampRaw { get; set; }
 
 	/// <summary>
 	/// Gets the thread member flags.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public ThreadMemberFlags Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets the category that contains this channel. For threads, gets the channel this thread was created in.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordChannel Thread
 		=> this.Guild != null && this.Guild.ThreadsInternal.TryGetValue(this.Id, out var thread) ? thread : null;
 
 	/// <summary>
 	/// Gets the guild to which this channel belongs.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordGuild Guild
 		=> this.Discord.Guilds.TryGetValue(this.GuildId, out var guild) ? guild : null;
 
 	[JsonIgnore]
 	internal ulong GuildId;
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordThreadChannelMember"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordThreadChannelMember"/>.</returns>
-	public override bool Equals(object obj) => this.Equals(obj as DiscordThreadChannelMember);
+	public override bool Equals(object obj)
+		=> this.Equals(obj as DiscordThreadChannelMember);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordThreadChannel"/> is equal to another <see cref="DiscordThreadChannelMember"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordThreadChannel"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordThreadChannel"/> is equal to this <see cref="DiscordThreadChannelMember"/>.</returns>
-	public bool Equals(DiscordThreadChannelMember e) => e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.UserId == e.UserId));
+	public bool Equals(DiscordThreadChannelMember e)
+		=> e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.UserId == e.UserId));
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordThreadChannelMember"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordThreadChannelMember"/>.</returns>
-	public override int GetHashCode() => HashCode.Combine(this.Id.GetHashCode(), this.UserId.GetHashCode());
+	public override int GetHashCode()
+		=> HashCode.Combine(this.Id.GetHashCode(), this.UserId.GetHashCode());
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordThreadChannel"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First channel to compare.</param>
 	/// <param name="e2">Second channel to compare.</param>
 	/// <returns>Whether the two channels are equal.</returns>
 	public static bool operator ==(DiscordThreadChannelMember e1, DiscordThreadChannelMember e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || (e1.Id == e2.Id && e1.UserId == e2.UserId));
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordThreadChannelMember"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First channel to compare.</param>
 	/// <param name="e2">Second channel to compare.</param>
 	/// <returns>Whether the two channels are not equal.</returns>
 	public static bool operator !=(DiscordThreadChannelMember e1, DiscordThreadChannelMember e2)
 		=> !(e1 == e2);
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordThreadChannelMember"/> class.
 	/// </summary>
 	internal DiscordThreadChannelMember()
 	{ }
 }
diff --git a/DisCatSharp/Entities/Channel/ForumPostTag.cs b/DisCatSharp/Entities/Thread/ForumPostTag.cs
similarity index 95%
rename from DisCatSharp/Entities/Channel/ForumPostTag.cs
rename to DisCatSharp/Entities/Thread/ForumPostTag.cs
index bf23a06f3..a957103ab 100644
--- a/DisCatSharp/Entities/Channel/ForumPostTag.cs
+++ b/DisCatSharp/Entities/Thread/ForumPostTag.cs
@@ -1,103 +1,110 @@
 // 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 Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a discord forum post tag.
 /// </summary>
 public class ForumPostTag : SnowflakeObject, IEquatable<ForumPostTag>
 {
 	/// <summary>
 	/// Gets the name of this forum post tag.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the emoji id of the forum post tag.
 	/// </summary>
 	[JsonProperty("emoji_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? EmojiId { get; internal set; }
 
 	/// <summary>
 	/// Gets the unicode emoji of the forum post tag.
 	/// </summary>
 	[JsonProperty("emoji_name", NullValueHandling = NullValueHandling.Ignore)]
 	internal string UnicodeEmojiString;
 
+
+	/// <summary>
+	/// Gets whether the tag can only be used by moderators.
+	/// </summary>
+	[JsonProperty("moderated", NullValueHandling = NullValueHandling.Ignore)]
+	public bool Moderated { get; internal set; }
+
 	/// <summary>
 	/// Gets the unicode emoji.
 	/// </summary>
 	public DiscordEmoji UnicodeEmoji
 		=> this.UnicodeEmojiString != null ? DiscordEmoji.FromName(this.Discord, $":{this.UnicodeEmojiString}:", false) : null;
 
 	/// <summary>
 	/// Checks whether this <see cref="ForumPostTag"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="ForumPostTag"/>.</returns>
 	public override bool Equals(object obj)
 		=> this.Equals(obj as ForumPostTag);
 
 	/// <summary>
 	/// Checks whether this <see cref="ForumPostTag"/> is equal to another <see cref="ForumPostTag"/>.
 	/// </summary>
 	/// <param name="e"><see cref="ForumPostTag"/> to compare to.</param>
 	/// <returns>Whether the <see cref="ForumPostTag"/> is equal to this <see cref="ForumPostTag"/>.</returns>
 	public bool Equals(ForumPostTag e)
 		=> e is not null && (ReferenceEquals(this, e) || (this.Id == e.Id && this.Name == e.Name));
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="ForumPostTag"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="ForumPostTag"/>.</returns>
 	public override int GetHashCode()
 		=> this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="ForumPostTag"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First forum post tag to compare.</param>
 	/// <param name="e2">Second forum post tag to compare.</param>
 	/// <returns>Whether the two forum post tags are equal.</returns>
 	public static bool operator ==(ForumPostTag e1, ForumPostTag e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordEmoji"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First forum post tag to compare.</param>
 	/// <param name="e2">Second forum post tag to compare.</param>
 	/// <returns>Whether the two forum post tags are not equal.</returns>
 	public static bool operator !=(ForumPostTag e1, ForumPostTag e2)
 		=> !(e1 == e2);
 }
diff --git a/DisCatSharp/Entities/User/DiscordUser.cs b/DisCatSharp/Entities/User/DiscordUser.cs
index 15c1d34f0..512c73571 100644
--- a/DisCatSharp/Entities/User/DiscordUser.cs
+++ b/DisCatSharp/Entities/User/DiscordUser.cs
@@ -1,458 +1,465 @@
 // 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.Globalization;
 using System.Threading.Tasks;
 
 using DisCatSharp.Enums;
 using DisCatSharp.Exceptions;
 using DisCatSharp.Net;
 using DisCatSharp.Net.Abstractions;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord user.
 /// </summary>
 public class DiscordUser : SnowflakeObject, IEquatable<DiscordUser>
 {
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordUser"/> class.
 	/// </summary>
 	internal DiscordUser()
 	{ }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordUser"/> class.
 	/// </summary>
 	/// <param name="transport">The transport user.</param>
 	internal DiscordUser(TransportUser transport)
 	{
 		this.Id = transport.Id;
 		this.Username = transport.Username;
 		this.Discriminator = transport.Discriminator;
 		this.AvatarHash = transport.AvatarHash;
 		this.BannerHash = transport.BannerHash;
 		this.BannerColorInternal = transport.BannerColor;
 		this.IsBot = transport.IsBot;
 		this.MfaEnabled = transport.MfaEnabled;
 		this.Verified = transport.Verified;
 		this.Email = transport.Email;
 		this.PremiumType = transport.PremiumType;
 		this.Locale = transport.Locale;
 		this.Flags = transport.Flags;
 		this.OAuthFlags = transport.OAuthFlags;
 		this.Bio = transport.Bio;
+		this.Pronouns = transport.Pronouns;
 	}
 
 	/// <summary>
 	/// Gets this user's username.
 	/// </summary>
 	[JsonProperty("username", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Username { get; internal set; }
 
 	/// <summary>
 	/// Gets this user's username with the discriminator.
 	/// Example: Discord#0000
 	/// </summary>
 	[JsonIgnore]
 	public virtual string UsernameWithDiscriminator
 		=> $"{this.Username}#{this.Discriminator}";
 
 	/// <summary>
 	/// Gets the user's 4-digit discriminator.
 	/// </summary>
 	[JsonProperty("discriminator", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Discriminator { get; internal set; }
 
 	/// <summary>
 	/// Gets the discriminator integer.
 	/// </summary>
 	[JsonIgnore]
 	internal int DiscriminatorInt
 		=> int.Parse(this.Discriminator, NumberStyles.Integer, CultureInfo.InvariantCulture);
 
 	/// <summary>
 	/// Gets the user's banner color, if set. Mutually exclusive with <see cref="BannerHash"/>.
 	/// </summary>
 	public virtual DiscordColor? BannerColor
 		=> !this.BannerColorInternal.HasValue ? null : new DiscordColor(this.BannerColorInternal.Value);
 
 	/// <summary>
 	/// Gets the user's banner color integer.
 	/// </summary>
 	[JsonProperty("accent_color")]
 	internal int? BannerColorInternal;
 
 	/// <summary>
 	/// Gets the user's banner url
 	/// </summary>
 	[JsonIgnore]
 	public string BannerUrl
 		=> string.IsNullOrWhiteSpace(this.BannerHash) ? null : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.BANNERS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.BannerHash}.{(this.BannerHash.StartsWith("a_") ? "gif" : "png")}?size=4096";
 
 	/// <summary>
 	/// Gets the user's profile banner hash. Mutually exclusive with <see cref="BannerColor"/>.
 	/// </summary>
 	[JsonProperty("banner", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string BannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the users bio.
 	/// This is not available to bots tho.
 	/// </summary>
 	[JsonProperty("bio", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Bio { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's avatar hash.
 	/// </summary>
 	[JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string AvatarHash { get; internal set; }
 
 	/// <summary>
 	/// Returns a uri to this users profile.
 	/// </summary>
 	[JsonIgnore]
 	public Uri ProfileUri => new($"{DiscordDomain.GetDomain(CoreDomain.Discord).Url}{Endpoints.USERS}/{this.Id}");
 
 	/// <summary>
 	/// Returns a string representing the direct URL to this users profile.
 	/// </summary>
 	/// <returns>The URL of this users profile.</returns>
 	[JsonIgnore]
 	public string ProfileUrl => this.ProfileUri.AbsoluteUri;
 
 	/// <summary>
 	/// Gets the user's avatar URL.s
 	/// </summary>
 	[JsonIgnore]
 	public string AvatarUrl
 		=> string.IsNullOrWhiteSpace(this.AvatarHash) ? this.DefaultAvatarUrl : $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS}/{this.Id.ToString(CultureInfo.InvariantCulture)}/{this.AvatarHash}.{(this.AvatarHash.StartsWith("a_") ? "gif" : "png")}?size=1024";
 
 	/// <summary>
 	/// Gets the URL of default avatar for this user.
 	/// </summary>
 	[JsonIgnore]
 	public string DefaultAvatarUrl
 		=> $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.EMBED}{Endpoints.AVATARS}/{(this.DiscriminatorInt % 5).ToString(CultureInfo.InvariantCulture)}.png?size=1024";
 
 	/// <summary>
 	/// Gets whether the user is a bot.
 	/// </summary>
 	[JsonProperty("bot", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual bool IsBot { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the user has multi-factor authentication enabled.
 	/// </summary>
 	[JsonProperty("mfa_enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual bool? MfaEnabled { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the user is an official Discord system user.
 	/// </summary>
 	[JsonProperty("system", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? IsSystem { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the user is verified.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonProperty("verified", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual bool? Verified { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's email address.
 	/// <para>This is only present in OAuth.</para>
 	/// </summary>
 	[JsonProperty("email", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Email { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's premium type.
 	/// </summary>
 	[JsonProperty("premium_type", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual PremiumType? PremiumType { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's chosen language
 	/// </summary>
 	[JsonProperty("locale", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual string Locale { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's flags for OAuth.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual UserFlags? OAuthFlags { get; internal set; }
 
 	/// <summary>
 	/// Gets the user's flags.
 	/// </summary>
 	[JsonProperty("public_flags", NullValueHandling = NullValueHandling.Ignore)]
 	public virtual UserFlags? Flags { get; internal set; }
 
+	/// <summary>
+	/// Gets the user's pronouns.
+	/// </summary>
+	[JsonProperty("pronouns", NullValueHandling = NullValueHandling.Ignore)]
+	public virtual string Pronouns { get; internal set; }
+
 	/// <summary>
 	/// Gets the user's mention string.
 	/// </summary>
 	[JsonIgnore]
 	public string Mention
 		=> Formatter.Mention(this, this is DiscordMember);
 
 	/// <summary>
 	/// Gets whether this user is the Client which created this object.
 	/// </summary>
 	[JsonIgnore]
 	public bool IsCurrent
 		=> this.Id == this.Discord.CurrentUser.Id;
 
 	#region Extension of DiscordUser
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.CertifiedModerator"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsMod
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.CertifiedModerator);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.Partner"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsPartner
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.Partner);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.VerifiedBot"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsVerifiedBot
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.VerifiedBot);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.VerifiedDeveloper"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsBotDev
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.VerifiedDeveloper);
 
 	/// <summary>
 	/// Whether this member is a <see cref="UserFlags.Staff"/>
 	/// </summary>
 	/// <returns><see cref="bool"/></returns>
 	[JsonIgnore]
 	public bool IsStaff
 			=> this.Flags.HasValue && this.Flags.Value.HasFlag(UserFlags.Staff);
 
 	#endregion
 
 	/// <summary>
 	/// Fetches the user from the API.
 	/// </summary>
 	/// <returns>The user with fresh data from the API.</returns>
 	public async Task<DiscordUser> GetFromApiAsync()
 		=> await this.Discord.ApiClient.GetUserAsync(this.Id);
 
 	/// <summary>
 	/// Whether this user is in a <see cref="DiscordGuild"/>
 	/// </summary>
 	/// <example>
 	/// <code>
 	/// DiscordGuild guild = await Client.GetGuildAsync(806675511555915806);
 	/// DiscordUser user = await Client.GetUserAsync(469957180968271873);
 	/// Console.WriteLine($"{user.Username} {(user.IsInGuild(guild) ? "is a" : "is not a")} member of {guild.Name}");
 	/// </code>
 	/// results to <c>J_M_Lutra is a member of Project Nyaw~</c>.
 	/// </example>
 	/// <param name="guild"><see cref="DiscordGuild"/></param>
 	/// <returns><see cref="bool"/></returns>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "<Pending>")]
 	public async Task<bool> IsInGuild(DiscordGuild guild)
 	{
 		try
 		{
 			var member = await guild.GetMemberAsync(this.Id);
 			return member is not null;
 
 		}
 		catch (NotFoundException)
 		{
 			return false;
 		}
 	}
 
 	/// <summary>
 	/// Whether this user is not in a <see cref="DiscordGuild"/>
 	/// </summary>
 	/// <param name="guild"><see cref="DiscordGuild"/></param>
 	/// <returns><see cref="bool"/></returns>
 	public async Task<bool> IsNotInGuild(DiscordGuild guild)
 		=> !await this.IsInGuild(guild);
 
 	/// <summary>
 	/// Returns the DiscordMember in the specified <see cref="DiscordGuild"/>
 	/// </summary>
 	/// <param name="guild">The <see cref="DiscordGuild"/> to get this user on.</param>
 	/// <returns>The <see cref="DiscordMember"/>.</returns>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the user is not part of the guild.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public async Task<DiscordMember> ConvertToMember(DiscordGuild guild)
 		=> await guild.GetMemberAsync(this.Id);
 
 	/// <summary>
 	/// Unbans this user from a guild.
 	/// </summary>
 	/// <param name="guild">Guild to unban this user from.</param>
 	/// <param name="reason">Reason for audit logs.</param>
 	/// <exception cref="Exceptions.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.BanMembers"/> permission.</exception>
 	/// <exception cref="Exceptions.NotFoundException">Thrown when the user does not exist.</exception>
 	/// <exception cref="Exceptions.BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="Exceptions.ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	public Task UnbanAsync(DiscordGuild guild, string reason = null)
 		=> guild.UnbanMemberAsync(this, reason);
 
 	/// <summary>
 	/// Gets this user's presence.
 	/// </summary>
 	[JsonIgnore]
 	public DiscordPresence Presence
 		=> this.Discord is DiscordClient dc && dc.Presences.TryGetValue(this.Id, out var presence) ? presence : null;
 
 	/// <summary>
 	/// Gets the user's avatar URL, in requested format and size.
 	/// </summary>
 	/// <param name="fmt">Format of the avatar to get.</param>
 	/// <param name="size">Maximum size of the avatar. Must be a power of two, minimum 16, maximum 2048.</param>
 	/// <returns>URL of the user's avatar.</returns>
 	public string GetAvatarUrl(ImageFormat fmt, ushort size = 1024)
 	{
 		if (fmt == ImageFormat.Unknown)
 			throw new ArgumentException("You must specify valid image format.", nameof(fmt));
 
 		if (size < 16 || size > 2048)
 			throw new ArgumentOutOfRangeException(nameof(size));
 
 		var log = Math.Log(size, 2);
 		if (log < 4 || log > 11 || log % 1 != 0)
 			throw new ArgumentOutOfRangeException(nameof(size));
 
 		var sfmt = "";
 		sfmt = fmt switch
 		{
 			ImageFormat.Gif => "gif",
 			ImageFormat.Jpeg => "jpg",
 			ImageFormat.Png => "png",
 			ImageFormat.WebP => "webp",
 			ImageFormat.Auto => !string.IsNullOrWhiteSpace(this.AvatarHash) ? this.AvatarHash.StartsWith("a_") ? "gif" : "png" : "png",
 			_ => throw new ArgumentOutOfRangeException(nameof(fmt)),
 		};
 		var ssize = size.ToString(CultureInfo.InvariantCulture);
 		if (!string.IsNullOrWhiteSpace(this.AvatarHash))
 		{
 			var id = this.Id.ToString(CultureInfo.InvariantCulture);
 			return $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.AVATARS}/{id}/{this.AvatarHash}.{sfmt}?size={ssize}";
 		}
 		else
 		{
 			var type = (this.DiscriminatorInt % 5).ToString(CultureInfo.InvariantCulture);
 			return $"{DiscordDomain.GetDomain(CoreDomain.DiscordCdn).Url}{Endpoints.EMBED}{Endpoints.AVATARS}/{type}.{sfmt}?size={ssize}";
 		}
 	}
 
 	/// <summary>
 	/// Returns a string representation of this user.
 	/// </summary>
 	/// <returns>String representation of this user.</returns>
 	public override string ToString() => $"User {this.Id}; {this.Username}#{this.Discriminator}";
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordUser"/> is equal to another object.
 	/// </summary>
 	/// <param name="obj">Object to compare to.</param>
 	/// <returns>Whether the object is equal to this <see cref="DiscordUser"/>.</returns>
 	public override bool Equals(object obj) => this.Equals(obj as DiscordUser);
 
 	/// <summary>
 	/// Checks whether this <see cref="DiscordUser"/> is equal to another <see cref="DiscordUser"/>.
 	/// </summary>
 	/// <param name="e"><see cref="DiscordUser"/> to compare to.</param>
 	/// <returns>Whether the <see cref="DiscordUser"/> is equal to this <see cref="DiscordUser"/>.</returns>
 	public bool Equals(DiscordUser e) => e is not null && (ReferenceEquals(this, e) || this.Id == e.Id);
 
 	/// <summary>
 	/// Gets the hash code for this <see cref="DiscordUser"/>.
 	/// </summary>
 	/// <returns>The hash code for this <see cref="DiscordUser"/>.</returns>
 	public override int GetHashCode() => this.Id.GetHashCode();
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordUser"/> objects are equal.
 	/// </summary>
 	/// <param name="e1">First user to compare.</param>
 	/// <param name="e2">Second user to compare.</param>
 	/// <returns>Whether the two users are equal.</returns>
 	public static bool operator ==(DiscordUser e1, DiscordUser e2)
 	{
 		var o1 = e1 as object;
 		var o2 = e2 as object;
 
 		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
 	}
 
 	/// <summary>
 	/// Gets whether the two <see cref="DiscordUser"/> objects are not equal.
 	/// </summary>
 	/// <param name="e1">First user to compare.</param>
 	/// <param name="e2">Second user to compare.</param>
 	/// <returns>Whether the two users are not equal.</returns>
 	public static bool operator !=(DiscordUser e1, DiscordUser e2)
 		=> !(e1 == e2);
 }
 
 /// <summary>
 /// Represents a user comparer.
 /// </summary>
 internal class DiscordUserComparer : IEqualityComparer<DiscordUser>
 {
 	/// <summary>
 	/// Whether the users are equal.
 	/// </summary>
 	/// <param name="x">The first user</param>
 	/// <param name="y">The second user.</param>
 	public bool Equals(DiscordUser x, DiscordUser y) => x.Equals(y);
 
 	/// <summary>
 	/// Gets the hash code.
 	/// </summary>
 	/// <param name="obj">The user.</param>
 	public int GetHashCode(DiscordUser obj) => obj.Id.GetHashCode();
 }
diff --git a/DisCatSharp/Enums/Application/ApplicationCommandPermissionType.cs b/DisCatSharp/Enums/Application/ApplicationCommandPermissionType.cs
index c1652cf2e..f393ddfcc 100644
--- a/DisCatSharp/Enums/Application/ApplicationCommandPermissionType.cs
+++ b/DisCatSharp/Enums/Application/ApplicationCommandPermissionType.cs
@@ -1,47 +1,47 @@
 // 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 the type of the application command permission.
- /// </summary>
+/// Represents the type of the application command permission.
+/// </summary>
 [Flags]
 public enum ApplicationCommandPermissionType
 {
 	/// <summary>
 	/// The permission is bound to a role.
 	/// </summary>
 	Role = 1,
 
 	/// <summary>
 	/// The permission is bound to a user.
 	/// </summary>
 	User = 2,
 
 	/// <summary>
 	/// The permission is bound to a channel.
 	/// </summary>
 	Channel = 3
 }
diff --git a/DisCatSharp/Enums/Channel/ChannelFlags.cs b/DisCatSharp/Enums/Channel/ChannelFlags.cs
index 34e10bf2b..923a7e883 100644
--- a/DisCatSharp/Enums/Channel/ChannelFlags.cs
+++ b/DisCatSharp/Enums/Channel/ChannelFlags.cs
@@ -1,40 +1,56 @@
 // 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.
 
-namespace DisCatSharp;
+using DisCatSharp.Entities;
+
+namespace DisCatSharp.Enums;
 
 /// <summary>
 /// Represents a channel's flags.
 /// </summary>
 public enum ChannelFlags : int
 {
 	/// <summary>
-	/// Indicates that this channel is removed from the guilds home feed.
+	/// Indicates that this channel is removed from the guilds home feed / from highlights.
+	/// Applicable for <see cref="ChannelType"/> Text, Forum and News.
 	/// </summary>
 	RemovedFromHome = 1 << 0,
+	RemovedFromHighlights = RemovedFromHome,
 
 	/// <summary>
 	/// Indicates that this thread is pinned to the top of its parent forum channel.
 	/// Forum channel thread only.
 	/// </summary>
-	Pinned = 1 << 1
+	Pinned = 1 << 1,
+
+	/// <summary>
+	/// Indicates that this channel is removed from the active now within the guilds home feed.
+	/// Applicable for <see cref="ChannelType"/> Text, News, Thread, Forum, Stage and Voice.
+	/// </summary>
+	RemovedFromActiveNow = 1 << 2,
+
+	/// <summary>
+	/// Indicates that the channel requires users to select at least one <see cref="ForumPostTag"/>.
+	/// Only applicable for <see cref="ChannelType.Forum"/>.
+	/// </summary>
+	RequireTags = 1<<4
 }
diff --git a/DisCatSharp/Enums/Channel/ChannelType.cs b/DisCatSharp/Enums/Channel/ChannelType.cs
index 8fbd96e43..df8de5367 100644
--- a/DisCatSharp/Enums/Channel/ChannelType.cs
+++ b/DisCatSharp/Enums/Channel/ChannelType.cs
@@ -1,101 +1,101 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
 /// Represents a channel's type.
 /// </summary>
 public enum ChannelType : int
 {
 	/// <summary>
 	/// Indicates that this is a text channel.
 	/// </summary>
 	Text = 0,
 
 	/// <summary>
 	/// Indicates that this is a private channel.
 	/// </summary>
 	Private = 1,
 
 	/// <summary>
 	/// Indicates that this is a voice channel.
 	/// </summary>
 	Voice = 2,
 
 	/// <summary>
 	/// Indicates that this is a group direct message channel.
 	/// </summary>
 	Group = 3,
 
 	/// <summary>
 	/// Indicates that this is a channel category.
 	/// </summary>
 	Category = 4,
 
 	/// <summary>
 	/// Indicates that this is a news channel.
 	/// </summary>
 	News = 5,
 
 	/// <summary>
 	/// Indicates that this is a store channel.
 	/// </summary>
 	Store = 6,
 
 	/// <summary>
 	/// Indicates that this is a temporary sub-channel within a news channel.
 	/// </summary>
 	NewsThread = 10,
 
 	/// <summary>
 	/// Indicates that this is a temporary sub-channel within a text channel.
 	/// </summary>
 	PublicThread = 11,
 
 	/// <summary>
 	/// Indicates that this is a temporary sub-channel within a text channel that is only viewable
 	/// by those invited and those with the MANAGE_THREADS permission.
 	/// </summary>
 	PrivateThread = 12,
 
 	/// <summary>
 	/// Indicates that this is a stage channel.
 	/// </summary>
 	Stage = 13,
 
 	/// <summary>
 	/// Indicates that this is a guild directory channel.
 	/// This is used for hub guilds (feature for schools).
 	/// </summary>
 	GuildDirectory = 14,
 
 	/// <summary>
 	/// Indicates that this is a guild forum channel (Threads only channel).
 	/// </summary>
 	Forum = 15,
 
 	/// <summary>
 	/// Indicates unknown channel type.
 	/// </summary>
 	Unknown = int.MaxValue
 }
diff --git a/DisCatSharp/Enums/Channel/OverwriteType.cs b/DisCatSharp/Enums/Channel/OverwriteType.cs
index bb336b64b..e60487e06 100644
--- a/DisCatSharp/Enums/Channel/OverwriteType.cs
+++ b/DisCatSharp/Enums/Channel/OverwriteType.cs
@@ -1,39 +1,39 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
 /// Represents a channel permission overwrite's type.
 /// </summary>
 public enum OverwriteType : int
 {
 	/// <summary>
 	/// Specifies that this overwrite applies to a role.
 	/// </summary>
 	Role = 0,
 
 	/// <summary>
 	/// Specifies that this overwrite applies to a member.
 	/// </summary>
 	Member = 1,
 }
diff --git a/DisCatSharp/Enums/Guild/PremiumTier.cs b/DisCatSharp/Enums/Guild/AuditLogActionCategory.cs
similarity index 73%
copy from DisCatSharp/Enums/Guild/PremiumTier.cs
copy to DisCatSharp/Enums/Guild/AuditLogActionCategory.cs
index 27717f131..eca829619 100644
--- a/DisCatSharp/Enums/Guild/PremiumTier.cs
+++ b/DisCatSharp/Enums/Guild/AuditLogActionCategory.cs
@@ -1,54 +1,49 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
-/// Represents a server's premium tier.
+/// Indicates audit log action category.
 /// </summary>
-public enum PremiumTier : int
+public enum AuditLogActionCategory
 {
 	/// <summary>
-	/// Indicates that this server was not boosted.
+	/// Indicates that this action resulted in creation or addition of an object.
 	/// </summary>
-	None = 0,
+	Create,
 
 	/// <summary>
-	/// Indicates that this server was boosted two times.
+	/// Indicates that this action resulted in update of an object.
 	/// </summary>
-	TierOne = 1,
+	Update,
 
 	/// <summary>
-	/// Indicates that this server was boosted seven times.
+	/// Indicates that this action resulted in deletion or removal of an object.
 	/// </summary>
-	TierTwo = 2,
+	Delete,
 
 	/// <summary>
-	/// Indicates that this server was boosted fourteen times.
+	/// Indicates that this action resulted in something else than creation, addition, update, deletion, or removal of an object.
 	/// </summary>
-	TierThree = 3,
-
-	/// <summary>
-	/// Indicates an unknown premium tier.
-	/// </summary>
-	Unknown = int.MaxValue
+	Other
 }
diff --git a/DisCatSharp/Enums/Guild/AuditLogActionType.cs b/DisCatSharp/Enums/Guild/AuditLogActionType.cs
new file mode 100644
index 000000000..05dd71d3c
--- /dev/null
+++ b/DisCatSharp/Enums/Guild/AuditLogActionType.cs
@@ -0,0 +1,294 @@
+// 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.
+
+namespace DisCatSharp.Enums;
+
+/// <summary>
+/// Represents type of the action that was taken in given audit log event.
+/// </summary>
+public enum AuditLogActionType
+{
+	/// <summary>
+	/// Indicates an invalid action type.
+	/// </summary>
+	Invalid = 0,
+
+	/// <summary>
+	/// Indicates that the guild was updated.
+	/// </summary>
+	GuildUpdate = 1,
+
+	/// <summary>
+	/// Indicates that the channel was created.
+	/// </summary>
+	ChannelCreate = 10,
+
+	/// <summary>
+	/// Indicates that the channel was updated.
+	/// </summary>
+	ChannelUpdate = 11,
+
+	/// <summary>
+	/// Indicates that the channel was deleted.
+	/// </summary>
+	ChannelDelete = 12,
+
+	/// <summary>
+	/// Indicates that the channel permission overwrite was created.
+	/// </summary>
+	OverwriteCreate = 13,
+
+	/// <summary>
+	/// Indicates that the channel permission overwrite was updated.
+	/// </summary>
+	OverwriteUpdate = 14,
+
+	/// <summary>
+	/// Indicates that the channel permission overwrite was deleted.
+	/// </summary>
+	OverwriteDelete = 15,
+
+	/// <summary>
+	/// Indicates that the user was kicked.
+	/// </summary>
+	Kick = 20,
+
+	/// <summary>
+	/// Indicates that users were pruned.
+	/// </summary>
+	Prune = 21,
+
+	/// <summary>
+	/// Indicates that the user was banned.
+	/// </summary>
+	Ban = 22,
+
+	/// <summary>
+	/// Indicates that the user was unbanned.
+	/// </summary>
+	Unban = 23,
+
+	/// <summary>
+	/// Indicates that the member was updated.
+	/// </summary>
+	MemberUpdate = 24,
+
+	/// <summary>
+	/// Indicates that the member's roles were updated.
+	/// </summary>
+	MemberRoleUpdate = 25,
+
+	/// <summary>
+	/// Indicates that the member has moved to another voice channel.
+	/// </summary>
+	MemberMove = 26,
+
+	/// <summary>
+	/// Indicates that the member has disconnected from a voice channel.
+	/// </summary>
+	MemberDisconnect = 27,
+
+	/// <summary>
+	/// Indicates that a bot was added to the guild.
+	/// </summary>
+	BotAdd = 28,
+
+	/// <summary>
+	/// Indicates that the role was created.
+	/// </summary>
+	RoleCreate = 30,
+
+	/// <summary>
+	/// Indicates that the role was updated.
+	/// </summary>
+	RoleUpdate = 31,
+
+	/// <summary>
+	/// Indicates that the role was deleted.
+	/// </summary>
+	RoleDelete = 32,
+
+	/// <summary>
+	/// Indicates that the invite was created.
+	/// </summary>
+	InviteCreate = 40,
+
+	/// <summary>
+	/// Indicates that the invite was updated.
+	/// </summary>
+	InviteUpdate = 41,
+
+	/// <summary>
+	/// Indicates that the invite was deleted.
+	/// </summary>
+	InviteDelete = 42,
+
+	/// <summary>
+	/// Indicates that the webhook was created.
+	/// </summary>
+	WebhookCreate = 50,
+
+	/// <summary>
+	/// Indicates that the webook was updated.
+	/// </summary>
+	WebhookUpdate = 51,
+
+	/// <summary>
+	/// Indicates that the webhook was deleted.
+	/// </summary>
+	WebhookDelete = 52,
+
+	/// <summary>
+	/// Indicates that an emoji was created.
+	/// </summary>
+	EmojiCreate = 60,
+
+	/// <summary>
+	/// Indicates that an emoji was updated.
+	/// </summary>
+	EmojiUpdate = 61,
+
+	/// <summary>
+	/// Indicates that an emoji was deleted.
+	/// </summary>
+	EmojiDelete = 62,
+
+	/// <summary>
+	/// Indicates that the message was deleted.
+	/// </summary>
+	MessageDelete = 72,
+
+	/// <summary>
+	/// Indicates that messages were bulk-deleted.
+	/// </summary>
+	MessageBulkDelete = 73,
+
+	/// <summary>
+	/// Indicates that a message was pinned.
+	/// </summary>
+	MessagePin = 74,
+
+	/// <summary>
+	/// Indicates that a message was unpinned.
+	/// </summary>
+	MessageUnpin = 75,
+
+	/// <summary>
+	/// Indicates that an integration was created.
+	/// </summary>
+	IntegrationCreate = 80,
+
+	/// <summary>
+	/// Indicates that an integration was updated.
+	/// </summary>
+	IntegrationUpdate = 81,
+
+	/// <summary>
+	/// Indicates that an integration was deleted.
+	/// </summary>
+	IntegrationDelete = 82,
+
+	/// <summary>
+	/// Indicates that an stage instance was created.
+	/// </summary>
+	StageInstanceCreate = 83,
+
+	/// <summary>
+	/// Indicates that an stage instance was updated.
+	/// </summary>
+	StageInstanceUpdate = 84,
+
+	/// <summary>
+	/// Indicates that an stage instance was deleted.
+	/// </summary>
+	StageInstanceDelete = 85,
+
+	/// <summary>
+	/// Indicates that an sticker was created.
+	/// </summary>
+	StickerCreate = 90,
+
+	/// <summary>
+	/// Indicates that an sticker was updated.
+	/// </summary>
+	StickerUpdate = 91,
+
+	/// <summary>
+	/// Indicates that an sticker was deleted.
+	/// </summary>
+	StickerDelete = 92,
+
+	/// <summary>
+	/// Indicates that an event was created.
+	/// </summary>
+	GuildScheduledEventCreate = 100,
+
+	/// <summary>
+	/// Indicates that an event was updated.
+	/// </summary>
+	GuildScheduledEventUpdate = 101,
+
+	/// <summary>
+	/// Indicates that an event was deleted.
+	/// </summary>
+	GuildScheduledEventDelete = 102,
+
+	/// <summary>
+	/// Indicates that an thread was created.
+	/// </summary>
+	ThreadCreate = 110,
+
+	/// <summary>
+	/// Indicates that an thread was updated.
+	/// </summary>
+	ThreadUpdate = 111,
+
+	/// <summary>
+	/// Indicates that an thread was deleted.
+	/// </summary>
+	ThreadDelete = 112,
+
+	/// <summary>
+	/// Indicates that the permissions for an application command was updated.
+	/// </summary>
+	ApplicationCommandPermissionUpdate = 121,
+
+	/// <summary>
+	/// Indicates that a new automod rule has been added.
+	/// </summary>
+	AutoModerationRuleCreate = 140,
+
+	/// <summary>
+	/// Indicates that a automod rule has been updated.
+	/// </summary>
+	AutoModerationRuleUpdate = 141,
+
+	/// <summary>
+	/// Indicates that a automod rule has been deleted.
+	/// </summary>
+	AutoModerationRuleDelete = 142,
+
+	/// <summary>
+	/// Indicates that automod blocked a message.
+	/// </summary>
+	AutoModerationBlockMessage = 143
+}
diff --git a/DisCatSharp/Enums/Channel/OverwriteType.cs b/DisCatSharp/Enums/Guild/DefaultMessageNotifications.cs
similarity index 80%
copy from DisCatSharp/Enums/Channel/OverwriteType.cs
copy to DisCatSharp/Enums/Guild/DefaultMessageNotifications.cs
index bb336b64b..dd9ec4f43 100644
--- a/DisCatSharp/Enums/Channel/OverwriteType.cs
+++ b/DisCatSharp/Enums/Guild/DefaultMessageNotifications.cs
@@ -1,39 +1,39 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
-/// Represents a channel permission overwrite's type.
+/// Represents default notification level for a guild.
 /// </summary>
-public enum OverwriteType : int
+public enum DefaultMessageNotifications : int
 {
 	/// <summary>
-	/// Specifies that this overwrite applies to a role.
+	/// All messages will trigger push notifications.
 	/// </summary>
-	Role = 0,
+	AllMessages = 0,
 
 	/// <summary>
-	/// Specifies that this overwrite applies to a member.
+	/// Only messages that mention the user (or a role he's in) will trigger push notifications.
 	/// </summary>
-	Member = 1,
+	MentionsOnly = 1
 }
diff --git a/DisCatSharp/Enums/User/PremiumType.cs b/DisCatSharp/Enums/Guild/ExplicitContentFilter.cs
similarity index 79%
copy from DisCatSharp/Enums/User/PremiumType.cs
copy to DisCatSharp/Enums/Guild/ExplicitContentFilter.cs
index 1957de3b5..d4ce64b8b 100644
--- a/DisCatSharp/Enums/User/PremiumType.cs
+++ b/DisCatSharp/Enums/Guild/ExplicitContentFilter.cs
@@ -1,44 +1,44 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
-/// The type of Nitro subscription on a user's account.
+/// Represents the value of explicit content filter in a guild.
 /// </summary>
-public enum PremiumType
+public enum ExplicitContentFilter : int
 {
 	/// <summary>
-	/// User does not have any perks.
+	/// Explicit content filter is disabled.
 	/// </summary>
-	None = 0,
+	Disabled = 0,
 
 	/// <summary>
-	/// Includes basic app perks like animated emojis and avatars.
+	/// Only messages from members without any roles are scanned.
 	/// </summary>
-	NitroClassic = 1,
+	MembersWithoutRoles = 1,
 
 	/// <summary>
-	/// Includes all app perks.
+	/// Messages from all members are scanned.
 	/// </summary>
-	Nitro = 2
+	AllMembers = 2
 }
diff --git a/DisCatSharp/Enums/Guild/HubType.cs b/DisCatSharp/Enums/Guild/HubType.cs
index f110978cb..2b7d4a518 100644
--- a/DisCatSharp/Enums/Guild/HubType.cs
+++ b/DisCatSharp/Enums/Guild/HubType.cs
@@ -1,44 +1,44 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
 /// Represents a guilds hub type.
 /// </summary>
 public enum HubType : int
 {
 	/// <summary>
 	/// Indicates that the hub is a default one.
 	/// </summary>
 	Default = 0,
 
 	/// <summary>
 	/// Indicates that the hub is a high school.
 	/// </summary>
 	HighSchool = 1,
 
 	/// <summary>
 	/// Indicates that the hub is a college.
 	/// </summary>
 	College = 2
 }
diff --git a/DisCatSharp/Enums/Guild/MembershipScreeningFieldType.cs b/DisCatSharp/Enums/Guild/MembershipScreeningFieldType.cs
index a2ffac86b..1acac988a 100644
--- a/DisCatSharp/Enums/Guild/MembershipScreeningFieldType.cs
+++ b/DisCatSharp/Enums/Guild/MembershipScreeningFieldType.cs
@@ -1,41 +1,41 @@
 // 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.Runtime.Serialization;
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
 /// Represents a membership screening field type
 /// </summary>
 [JsonConverter(typeof(StringEnumConverter))]
 public enum MembershipScreeningFieldType
 {
 	/// <summary>
 	/// Specifies the server rules
 	/// </summary>
 	[EnumMember(Value = "TERMS")]
 	Terms
 }
diff --git a/DisCatSharp/Enums/Channel/OverwriteType.cs b/DisCatSharp/Enums/Guild/MfaLevel.cs
similarity index 78%
copy from DisCatSharp/Enums/Channel/OverwriteType.cs
copy to DisCatSharp/Enums/Guild/MfaLevel.cs
index bb336b64b..a1bbc1d83 100644
--- a/DisCatSharp/Enums/Channel/OverwriteType.cs
+++ b/DisCatSharp/Enums/Guild/MfaLevel.cs
@@ -1,39 +1,39 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
-/// Represents a channel permission overwrite's type.
+/// Represents multi-factor authentication level required by a guild to use administrator functionality.
 /// </summary>
-public enum OverwriteType : int
+public enum MfaLevel : int
 {
 	/// <summary>
-	/// Specifies that this overwrite applies to a role.
+	/// Multi-factor authentication is not required to use administrator functionality.
 	/// </summary>
-	Role = 0,
+	Disabled = 0,
 
 	/// <summary>
-	/// Specifies that this overwrite applies to a member.
+	/// Multi-factor authentication is required to use administrator functionality.
 	/// </summary>
-	Member = 1,
+	Enabled = 1
 }
diff --git a/DisCatSharp/Enums/Guild/NsfwLevel.cs b/DisCatSharp/Enums/Guild/NsfwLevel.cs
index b6a96166c..af9072dae 100644
--- a/DisCatSharp/Enums/Guild/NsfwLevel.cs
+++ b/DisCatSharp/Enums/Guild/NsfwLevel.cs
@@ -1,50 +1,51 @@
 // 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.
 
 // ReSharper disable InconsistentNaming
-namespace DisCatSharp;
+
+namespace DisCatSharp.Enums;
 
 /// <summary>
 /// Represents a guild's content level.
 /// </summary>
 public enum NsfwLevel
 {
 	/// <summary>
 	/// Indicates the guild has no special NSFW level.
 	/// </summary>
 	Default = 0,
 
 	/// <summary>
 	/// Indicates the guild has extremely suggestive or mature content that would only be suitable for users over 18
 	/// </summary>
 	Explicit = 1,
 
 	/// <summary>
 	/// Indicates the guild has no content that could be deemed NSFW. It is SFW.
 	/// </summary>
 	Safe = 2,
 
 	/// <summary>
 	/// Indicates the guild has mildly NSFW content that may not be suitable for users under 18.
 	/// </summary>
 	Age_Restricted = 3
 }
diff --git a/DisCatSharp/Enums/Guild/PremiumTier.cs b/DisCatSharp/Enums/Guild/PremiumTier.cs
index 27717f131..298119f9c 100644
--- a/DisCatSharp/Enums/Guild/PremiumTier.cs
+++ b/DisCatSharp/Enums/Guild/PremiumTier.cs
@@ -1,54 +1,54 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
 /// Represents a server's premium tier.
 /// </summary>
 public enum PremiumTier : int
 {
 	/// <summary>
 	/// Indicates that this server was not boosted.
 	/// </summary>
 	None = 0,
 
 	/// <summary>
 	/// Indicates that this server was boosted two times.
 	/// </summary>
 	TierOne = 1,
 
 	/// <summary>
 	/// Indicates that this server was boosted seven times.
 	/// </summary>
 	TierTwo = 2,
 
 	/// <summary>
 	/// Indicates that this server was boosted fourteen times.
 	/// </summary>
 	TierThree = 3,
 
 	/// <summary>
 	/// Indicates an unknown premium tier.
 	/// </summary>
 	Unknown = int.MaxValue
 }
diff --git a/DisCatSharp/Enums/Guild/PriceTierType.cs b/DisCatSharp/Enums/Guild/PriceTierType.cs
index 78c328850..1ce3c4874 100644
--- a/DisCatSharp/Enums/Guild/PriceTierType.cs
+++ b/DisCatSharp/Enums/Guild/PriceTierType.cs
@@ -1,34 +1,34 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
 /// Represents a price tier type.
 /// </summary>
 public enum PriceTierType : int
 {
 	/// <summary>
 	/// Indicates that this is a role subscription.
 	/// </summary>
 	GuildRoleSubscriptions = 1
 }
diff --git a/DisCatSharp/Enums/Guild/SystemChannelFlags.cs b/DisCatSharp/Enums/Guild/SystemChannelFlags.cs
index 8ff081258..da1ef7233 100644
--- a/DisCatSharp/Enums/Guild/SystemChannelFlags.cs
+++ b/DisCatSharp/Enums/Guild/SystemChannelFlags.cs
@@ -1,76 +1,76 @@
 // 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;
+namespace DisCatSharp.Enums;
 
 /// <summary>
 /// Represents a system channel flags extension.
 /// </summary>
 public static class SystemChannelFlagsExtension
 {
 	/// <summary>
 	/// Calculates whether these system channel flags contain a specific flag.
 	/// </summary>
 	/// <param name="baseFlags">The existing flags.</param>
 	/// <param name="flag">The flag to search for.</param>
 	/// <returns></returns>
 	public static bool HasSystemChannelFlag(this SystemChannelFlags baseFlags, SystemChannelFlags flag) => (baseFlags & flag) == flag;
 }
 
 /// <summary>
 /// Represents settings for a guild's system channel.
 /// </summary>
 [Flags]
 public enum SystemChannelFlags
 {
 	/// <summary>
 	/// Member join messages are disabled.
 	/// </summary>
 	SuppressJoinNotifications = 1 << 0,
 
 	/// <summary>
 	/// Server boost messages are disabled.
 	/// </summary>
 	SuppressPremiumSubscriptions = 1 << 1,
 
 	/// <summary>
 	/// Server setup tips are disabled.
 	/// </summary>
 	SuppressGuildReminderNotifications = 1 << 2,
 
 	/// <summary>
 	/// Suppress member join sticker replies.
 	/// </summary>
 	SuppressJoinNotificationReplies = 1 << 3,
 
 	/// <summary>
 	/// Role subscription purchase messages are disabled.
 	/// </summary>
 	SuppressRoleSubbscriptionPurchaseNotification = 1<<4,
 
 	/// <summary>
 	/// Suppress role subscription purchase sticker replies.
 	/// </summary>
 	SuppressRoleSubbscriptionPurchaseNotificationReplies = 1<<5,
 }
diff --git a/DisCatSharp/Enums/Guild/PremiumTier.cs b/DisCatSharp/Enums/Guild/VerificationLevel.cs
similarity index 61%
copy from DisCatSharp/Enums/Guild/PremiumTier.cs
copy to DisCatSharp/Enums/Guild/VerificationLevel.cs
index 27717f131..4462d2a54 100644
--- a/DisCatSharp/Enums/Guild/PremiumTier.cs
+++ b/DisCatSharp/Enums/Guild/VerificationLevel.cs
@@ -1,54 +1,54 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
-/// Represents a server's premium tier.
+/// Represents guild verification level.
 /// </summary>
-public enum PremiumTier : int
+public enum VerificationLevel : int
 {
 	/// <summary>
-	/// Indicates that this server was not boosted.
+	/// No verification. Anyone can join and chat right away.
 	/// </summary>
 	None = 0,
 
 	/// <summary>
-	/// Indicates that this server was boosted two times.
+	/// Low verification level. Users are required to have a verified email attached to their account in order to be able to chat.
 	/// </summary>
-	TierOne = 1,
+	Low = 1,
 
 	/// <summary>
-	/// Indicates that this server was boosted seven times.
+	/// Medium verification level. Users are required to have a verified email attached to their account, and account age need to be at least 5 minutes in order to be able to chat.
 	/// </summary>
-	TierTwo = 2,
+	Medium = 2,
 
 	/// <summary>
-	/// Indicates that this server was boosted fourteen times.
+	/// High verification level. Users are required to have a verified email attached to their account, account age need to be at least 5 minutes, and they need to be in the server for at least 10 minutes in order to be able to chat.
 	/// </summary>
-	TierThree = 3,
+	High = 3,
 
 	/// <summary>
-	/// Indicates an unknown premium tier.
+	/// Highest verification level. Users are required to have a verified phone number attached to their account.
 	/// </summary>
-	Unknown = int.MaxValue
+	Highest = 4
 }
diff --git a/DisCatSharp/Enums/Guild/PremiumTier.cs b/DisCatSharp/Enums/Guild/WidgetType.cs
similarity index 73%
copy from DisCatSharp/Enums/Guild/PremiumTier.cs
copy to DisCatSharp/Enums/Guild/WidgetType.cs
index 27717f131..a56d4d9ec 100644
--- a/DisCatSharp/Enums/Guild/PremiumTier.cs
+++ b/DisCatSharp/Enums/Guild/WidgetType.cs
@@ -1,54 +1,55 @@
 // 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.
 
-namespace DisCatSharp;
+namespace DisCatSharp.Enums;
 
 /// <summary>
-/// Represents a server's premium tier.
+/// Represents the formats for a guild widget.
 /// </summary>
-public enum PremiumTier : int
+public enum WidgetType : int
 {
 	/// <summary>
-	/// Indicates that this server was not boosted.
+	/// The widget is represented in shield format.
+	/// <para>This is the default widget type.</para>
 	/// </summary>
-	None = 0,
+	Shield = 0,
 
 	/// <summary>
-	/// Indicates that this server was boosted two times.
+	/// The widget is represented as the first banner type.
 	/// </summary>
-	TierOne = 1,
+	Banner1 = 1,
 
 	/// <summary>
-	/// Indicates that this server was boosted seven times.
+	/// The widget is represented as the second banner type.
 	/// </summary>
-	TierTwo = 2,
+	Banner2 = 2,
 
 	/// <summary>
-	/// Indicates that this server was boosted fourteen times.
+	/// The widget is represented as the third banner type.
 	/// </summary>
-	TierThree = 3,
+	Banner3 = 3,
 
 	/// <summary>
-	/// Indicates an unknown premium tier.
+	/// The widget is represented in the fourth banner type.
 	/// </summary>
-	Unknown = int.MaxValue
+	Banner4 = 4
 }
diff --git a/DisCatSharp/Enums/Message/MessageFlags.cs b/DisCatSharp/Enums/Message/MessageFlags.cs
index 1b5466303..e1dfa8136 100644
--- a/DisCatSharp/Enums/Message/MessageFlags.cs
+++ b/DisCatSharp/Enums/Message/MessageFlags.cs
@@ -1,91 +1,96 @@
 // 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 a message flag extensions.
 /// </summary>
 public static class MessageFlagExtensions
 {
 	/// <summary>
 	/// Calculates whether these message flags contain a specific flag.
 	/// </summary>
 	/// <param name="baseFlags">The existing flags.</param>
 	/// <param name="flag">The flags to search for.</param>
 	/// <returns></returns>
 	public static bool HasMessageFlag(this MessageFlags baseFlags, MessageFlags flag) => (baseFlags & flag) == flag;
 }
 
 /// <summary>
 /// Represents additional features of a message.
 /// </summary>
 [Flags]
 public enum MessageFlags
 {
 	/// <summary>
 	/// Whether this message is the original message that was published from a news channel to subscriber channels.
 	/// </summary>
 	Crossposted = 1 << 0,
 
 	/// <summary>
 	/// Whether this message is crossposted (automatically posted in a subscriber channel).
 	/// </summary>
 	IsCrosspost = 1 << 1,
 
 	/// <summary>
 	/// Whether any embeds in the message are hidden.
 	/// </summary>
 	SuppressedEmbeds = 1 << 2,
 
 	/// <summary>
 	/// The source message for this crosspost has been deleted.
 	/// </summary>
 	SourceMessageDelete = 1 << 3,
 
 	/// <summary>
 	/// The message came from the urgent message system.
 	/// </summary>
 	Urgent = 1 << 4,
 
 	/// <summary>
 	/// The message has an associated thread, with the same id as the message.
 	/// </summary>
 	HasThread = 1 << 5,
 
 	/// <summary>
 	/// The message is only visible to the user who invoked the interaction.
 	/// </summary>
 	Ephemeral = 1 << 6,
 
 	/// <summary>
 	/// The message is an interaction response and the bot is "thinking".
 	/// </summary>
 	Loading = 1 << 7,
 
 	/// <summary>
 	/// The message is warning that some roles failed to mention in thread.
 	/// </summary>
-	FailedToMentionSomeRolesInThread = 1 << 8
+	FailedToMentionSomeRolesInThread = 1 << 8,
+
+	/// <summary>
+	/// The message contains a link marked as potential dangerous or absusive.
+	/// </summary>
+	ShouldShowLinkNotDiscordWarning = 1 << 10
 }
diff --git a/DisCatSharp/Enums/User/PremiumType.cs b/DisCatSharp/Enums/User/PremiumType.cs
index 1957de3b5..d9460a440 100644
--- a/DisCatSharp/Enums/User/PremiumType.cs
+++ b/DisCatSharp/Enums/User/PremiumType.cs
@@ -1,44 +1,50 @@
 // 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.
 
 namespace DisCatSharp;
 
 /// <summary>
 /// The type of Nitro subscription on a user's account.
 /// </summary>
 public enum PremiumType
 {
 	/// <summary>
 	/// User does not have any perks.
 	/// </summary>
 	None = 0,
 
 	/// <summary>
 	/// Includes basic app perks like animated emojis and avatars.
 	/// </summary>
 	NitroClassic = 1,
 
 	/// <summary>
 	/// Includes all app perks.
 	/// </summary>
-	Nitro = 2
+	Nitro = 2,
+
+	/// <summary>
+	/// Includes lite app perks.
+	/// Unknown if it will be 3.
+	/// </summary>
+	NitroLite = 3
 }
diff --git a/DisCatSharp/Enums/User/UserFlags.cs b/DisCatSharp/Enums/User/UserFlags.cs
index 3f6cc426f..9dd71001f 100644
--- a/DisCatSharp/Enums/User/UserFlags.cs
+++ b/DisCatSharp/Enums/User/UserFlags.cs
@@ -1,178 +1,185 @@
 // 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 additional details of a users account.
 /// </summary>
 [Flags]
 public enum UserFlags : long
 {
 	/// <summary>
 	/// The user has no flags.
 	/// </summary>
 	None = 0,
 
 	/// <summary>
 	/// The user is a Discord employee.
 	/// </summary>
 	Staff = 1L << 0,
 
 	/// <summary>
 	/// The user is a Discord partner.
 	/// </summary>
 	Partner = 1L << 1,
 
 	/// <summary>
 	/// The user has the HypeSquad badge.
 	/// </summary>
 	HypeSquad = 1L << 2,
 
 	/// <summary>
 	/// The user reached the first bug hunter tier.
 	/// </summary>
 	BugHunterLevelOne = 1L << 3,
 
 	/// <summary>
 	/// The user has SMS recovery for 2FA enabled.
 	/// </summary>
 	MfaSms = 1L << 4,
 
 	/// <summary>
 	/// The user is marked as dismissed Nitro promotion
 	/// </summary>
 	PremiumPromoDismissed = 1L << 5,
 
 	/// <summary>
 	/// The user is a member of house bravery.
 	/// </summary>
 	HouseBravery = 1L << 6,
 
 	/// <summary>
 	/// The user is a member of house brilliance.
 	/// </summary>
 	HouseBrilliance = 1L << 7,
 
 	/// <summary>
 	/// The user is a member of house balance.
 	/// </summary>
 	HouseBalance = 1L << 8,
 
 	/// <summary>
 	/// The user has the early supporter badge.
 	/// </summary>
 	PremiumEarlySupporter = 1L << 9,
 
 	/// <summary>
 	/// User is a <see cref="Entities.DiscordTeam"/>.
 	/// </summary>
 	TeamPseudoUser = 1L << 10,
 
 	/// <summary>
 	/// Relates to partner/verification applications.
 	/// </summary>
 	PartnerOrVerificationApplication = 1L << 11,
 
 	/// <summary>
 	/// Whether the user is an official system user.
 	/// </summary>
 	System = 1L << 12,
 
 	/// <summary>
 	/// Whether the user has unread system messages.
 	/// </summary>
 	HasUnreadUrgentMessages = 1L << 13,
 
 	/// <summary>
 	/// The user reached the second bug hunter tier.
 	/// </summary>
 	BugHunterLevelTwo = 1L << 14,
 
 	/// <summary>
 	/// The user has a pending deletion for being underage in DOB prompt.
 	/// </summary>
 	UnderageDeleted = 1L << 15,
 
 	/// <summary>
 	/// The user is a verified bot.
 	/// </summary>
 	VerifiedBot = 1L << 16,
 
 	/// <summary>
 	/// The user is a verified bot developer.
 	/// </summary>
 	VerifiedDeveloper = 1L << 17,
 
 	/// <summary>
 	/// The user is a discord certified moderator.
 	/// </summary>
 	CertifiedModerator = 1L << 18,
 
 	/// <summary>
 	/// The user is a bot and has set an interactions endpoint url.
 	/// </summary>
 	BotHttpInteractions = 1L << 19,
 
 	/// <summary>
 	/// The user is disabled for being a spammer.
 	/// </summary>
 	Spammer = 1L << 20,
 
 	/// <summary>
 	/// Nitro is disabled for user.
 	/// Used by discord staff instead of forcedNonPremium.
 	/// </summary>
 	DisablePremium = 1L << 21,
 
 	/// <summary>
 	/// The user has a premium discriminator.
 	/// </summary>
 	PremiumDiscriminator = 1L << 37,
 
 	/// <summary>
 	/// The user has used the desktop client
 	/// </summary>
 	UsedDesktopClient = 1L << 38,
 
 	/// <summary>
 	/// The user has used the web client
 	/// </summary>
 	UsedWebClient = 1L << 39,
 
 	/// <summary>
 	/// The user has used the mobile client
 	/// </summary>
 	UsedMobileClient = 1L << 40,
 
 	/// <summary>
 	/// The user is currently temporarily or permanently disabled.
 	/// </summary>
 	Disabled = 1L << 42,
 
 	/// <summary>
 	/// The user has a verified email.
 	/// </summary>
-	VerifiedEmail = 1L << 43
+	VerifiedEmail = 1L << 43,
+
+	/// <summary>
+	/// The user is currently quarantined.
+	/// The user can't start new dms and join servers.
+	/// The user has to appeal via https://dis.gd/appeal.
+	/// </summary>
+	Quarantined = 1L << 44
 }
diff --git a/DisCatSharp/EventArgs/Thread/ThreadDeleteEventArgs.cs b/DisCatSharp/EventArgs/Thread/ThreadDeleteEventArgs.cs
index 8d2a39c6b..fb364627d 100644
--- a/DisCatSharp/EventArgs/Thread/ThreadDeleteEventArgs.cs
+++ b/DisCatSharp/EventArgs/Thread/ThreadDeleteEventArgs.cs
@@ -1,58 +1,59 @@
 // 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 DisCatSharp.Entities;
+using DisCatSharp.Enums;
 
 namespace DisCatSharp.EventArgs;
 
 /// <summary>
 /// Represents arguments for <see cref="DiscordClient.ThreadDeleted"/> event.
 /// </summary>
 public class ThreadDeleteEventArgs : DiscordEventArgs
 {
 	/// <summary>
 	/// Gets the thread that was deleted.
 	/// </summary>
 	public DiscordThreadChannel Thread { get; internal set; }
 
 	/// <summary>
 	/// Gets the threads parent channel.
 	/// </summary>
 	public DiscordChannel Parent { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild this thread belonged to.
 	/// </summary>
 	public DiscordGuild Guild { get; internal set; }
 
 	/// <summary>
 	/// Gets the threads type.
 	/// </summary>
 	public ChannelType Type { get; internal set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="ThreadDeleteEventArgs"/> class.
 	/// </summary>
 	internal ThreadDeleteEventArgs(IServiceProvider provider) : base(provider) { }
 }
diff --git a/DisCatSharp/Internals.cs b/DisCatSharp/Internals.cs
index 68939f900..aba2cd938 100644
--- a/DisCatSharp/Internals.cs
+++ b/DisCatSharp/Internals.cs
@@ -1,93 +1,94 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 using System.Text;
 
 using DisCatSharp.Entities;
+using DisCatSharp.Enums;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// Internal tools.
 /// </summary>
 public static class Internals
 {
 	/// <summary>
 	/// Gets the version of the library
 	/// </summary>
 	private static string s_versionHeader
 		=> Utilities.VersionHeader;
 
 	/// <summary>
 	/// Gets the permission strings.
 	/// </summary>
 	private static Dictionary<Permissions, string> s_permissionStrings
 		=> Utilities.PermissionStrings;
 
 	/// <summary>
 	/// Gets the utf8 encoding
 	/// </summary>
 	internal static UTF8Encoding Utf8
 		=> Utilities.UTF8;
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="Internals"/> class.
 	/// </summary>
 	static Internals() { }
 
 	/// <summary>
 	/// Whether the <see cref="DiscordChannel"/> is joinable via voice.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal static bool IsVoiceJoinable(this DiscordChannel channel) => channel.Type == ChannelType.Voice || channel.Type == ChannelType.Stage;
 
 	/// <summary>
 	/// Whether the <see cref="DiscordChannel"/> can have threads.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal static bool IsThreadHolder(this DiscordChannel channel) => channel.Type == ChannelType.Text || channel.Type == ChannelType.News || channel.Type == ChannelType.Forum;
 
 	/// <summary>
 	/// Whether the <see cref="DiscordChannel"/> is related to threads.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal static bool IsThread(this DiscordChannel channel) => channel.Type == ChannelType.PublicThread || channel.Type == ChannelType.PrivateThread || channel.Type == ChannelType.NewsThread;
 
 	/// <summary>
 	/// Whether users can write the <see cref="DiscordChannel"/>.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal static bool IsWritable(this DiscordChannel channel) => channel.Type == ChannelType.PublicThread || channel.Type == ChannelType.PrivateThread || channel.Type == ChannelType.NewsThread || channel.Type == ChannelType.Text || channel.Type == ChannelType.News || channel.Type == ChannelType.Group || channel.Type == ChannelType.Private || channel.Type == ChannelType.Voice;
 
 	/// <summary>
 	/// Whether the <see cref="DiscordChannel"/> is moveable in a parent.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal static bool IsMovableInParent(this DiscordChannel channel) => channel.Type == ChannelType.Voice || channel.Type == ChannelType.Stage || channel.Type == ChannelType.Text || channel.Type == ChannelType.Forum || channel.Type == ChannelType.News;
 
 	/// <summary>
 	/// Whether the <see cref="DiscordChannel"/> is moveable.
 	/// </summary>
 	/// <param name="channel">The channel.</param>
 	internal static bool IsMovable(this DiscordChannel channel) => channel.Type == ChannelType.Voice || channel.Type == ChannelType.Stage || channel.Type == ChannelType.Text || channel.Type == ChannelType.Category || channel.Type == ChannelType.Forum || channel.Type == ChannelType.News;
 }
diff --git a/DisCatSharp/Net/Abstractions/AuditLogAbstractions.cs b/DisCatSharp/Net/Abstractions/AuditLogAbstractions.cs
index 0102f25ea..93a08a50e 100644
--- a/DisCatSharp/Net/Abstractions/AuditLogAbstractions.cs
+++ b/DisCatSharp/Net/Abstractions/AuditLogAbstractions.cs
@@ -1,576 +1,576 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 
-using DisCatSharp.Entities;
+using DisCatSharp.Enums;
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Net.Abstractions;
 
 /// <summary>
 /// Represents a audit log user.
 /// </summary>
 internal sealed class AuditLogUser
 {
 	/// <summary>
 	/// Gets or sets the username.
 	/// </summary>
 	[JsonProperty("username")]
 	public string Username { get; set; }
 
 	/// <summary>
 	/// Gets or sets the discriminator.
 	/// </summary>
 	[JsonProperty("discriminator")]
 	public string Discriminator { get; set; }
 
 	/// <summary>
 	/// Gets or sets the id.
 	/// </summary>
 	[JsonProperty("id")]
 	public ulong Id { get; set; }
 
 	/// <summary>
 	/// Gets or sets the avatar hash.
 	/// </summary>
 	[JsonProperty("avatar")]
 	public string AvatarHash { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log webhook.
 /// </summary>
 internal sealed class AuditLogWebhook
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the channel id.
 	/// </summary>
 	[JsonProperty("channel_id")]
 	public ulong ChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the token.
 	/// </summary>
 	[JsonProperty("token")]
 	public string Token { get; set; }
 
 	/// <summary>
 	/// Gets or sets the avatar hash.
 	/// </summary>
 	[JsonProperty("avatar")]
 	public string AvatarHash { get; set; }
 
 	/// <summary>
 	/// Gets or sets the guild id.
 	/// </summary>
 	[JsonProperty("guild_id")]
 	public ulong GuildId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the id.
 	/// </summary>
 	[JsonProperty("id")]
 	public ulong Id { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log thread metadata.
 /// </summary>
 internal sealed class AuditLogThreadMetadata
 {
 	/// <summary>
 	/// Gets whether the thread is archived.
 	/// </summary>
 	[JsonProperty("archived")]
 	public bool Archived { get; set; }
 
 	/// <summary>
 	/// Gets the threads archive timestamp.
 	/// </summary>
 	[JsonProperty("archive_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	public string ArchiveTimestamp { get; set; }
 
 	/// <summary>
 	/// Gets the threads auto archive duration.
 	/// </summary>
 	[JsonProperty("auto_archive_duration")]
 	public int AutoArchiveDuration { get; set; }
 
 	/// <summary>
 	/// Gets whether the thread is locked.
 	/// </summary>
 	[JsonProperty("locked")]
 	public bool Locked { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log thread.
 /// </summary>
 internal sealed class AuditLogThread
 {
 	/// <summary>
 	/// Gets the thread id.
 	/// </summary>
 	[JsonProperty("id")]
 	public ulong Id { get; set; }
 
 	/// <summary>
 	/// Gets the thread guild id.
 	/// </summary>
 	[JsonProperty("guild_id")]
 	public ulong GuildId { get; set; }
 
 	/// <summary>
 	/// Gets the thread parent channel id.
 	/// </summary>
 	[JsonProperty("parent_id")]
 	public ulong ParentId { get; set; }
 
 	/// <summary>
 	/// Gets the thread owner id.
 	/// </summary>
 	[JsonProperty("owner_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? OwnerId { get; set; }
 
 	/// <summary>
 	/// Gets the thread type.
 	/// </summary>
 	[JsonProperty("type")]
 	public ChannelType Type { get; set; }
 
 	/// <summary>
 	/// Gets the thread name.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets the thread last message id.
 	/// </summary>
 	[JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? LastMessageId { get; set; }
 
 	/// <summary>
 	/// Gets the thread metadata.
 	/// </summary>
 	[JsonProperty("thread_metadata")]
 	public AuditLogThreadMetadata Metadata { get; set; }
 
 	/// <summary>
 	/// Gets the thread approximate message count.
 	/// </summary>
 	[JsonProperty("message_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MessageCount { get; set; }
 
 	/// <summary>
 	/// Gets the thread member count.
 	/// </summary>
 	[JsonProperty("member_count", NullValueHandling = NullValueHandling.Ignore)]
 	public int? MemberCount { get; set; }
 
 	/// <summary>
 	/// Gets the thread rate limit per user.
 	/// </summary>
 	[JsonProperty("rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
 	public int? RateLimitPerUser { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log scheduled event.
 /// </summary>
 internal sealed class AuditLogGuildScheduledEvent
 {
 	/// <summary>
 	/// Gets the scheduled event id.
 	/// </summary>
 	[JsonProperty("id")]
 	public ulong Id { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event guild id.
 	/// </summary>
 	[JsonProperty("guild_id")]
 	public ulong GuildId { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event channel id.
 	/// </summary>
 	[JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ChannelId { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event creator id.
 	/// </summary>
 	[JsonProperty("creator_id")]
 	public ulong CreatorId { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event name.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event description.
 	/// </summary>
 	[JsonProperty("description")]
 	public string Description { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event image.
 	/// </summary>
 	[JsonProperty("image", NullValueHandling = NullValueHandling.Ignore)]
 	public string Image { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event scheduled start time.
 	/// </summary>
 	[JsonProperty("scheduled_start_time")]
 	public string ScheduledStartTime;
 
 	/// <summary>
 	/// Gets the scheduled event scheduled end time.
 	/// </summary>
 	[JsonProperty("scheduled_end_time")]
 	public string ScheduledEndTime { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event privacy level.
 	/// </summary>
 	[JsonProperty("privacy_level")]
 	public ScheduledEventPrivacyLevel PrivacyLevel { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event status.
 	/// </summary>
 	[JsonProperty("status")]
 	public ScheduledEventStatus Status { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event entity type.
 	/// </summary>
 	[JsonProperty("entity_type")]
 	public ScheduledEventEntityType EntityType { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event entity id.
 	/// </summary>
 	[JsonProperty("entity_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong EntityId { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event entity metadata.
 	/// </summary>
 	[JsonProperty("entity_metadata")]
 	public AuditLogGuildScheduledEventEntityMetadata EntityMetadata { get; set; }
 
 	/// <summary>
 	/// Gets the scheduled event sku ids.
 	/// </summary>
 	[JsonProperty("sku_ids")]
 	public List<ulong> SkuIds { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log scheduled event entity metadata.
 /// </summary>
 internal sealed class AuditLogGuildScheduledEventEntityMetadata
 {
 	/// <summary>
 	/// Gets the scheduled events external location.
 	/// </summary>
 	[JsonProperty("location")]
 	public string Location { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log integration account.
 /// </summary>
 internal sealed class AuditLogIntegrationAccount
 {
 	/// <summary>
 	/// Gets the account id.
 	/// </summary>
 	[JsonProperty("id")]
 	public string Id { get; set; }
 
 	/// <summary>
 	/// Gets the account name.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log integration.
 /// </summary>
 internal sealed class AuditLogIntegration
 {
 	/// <summary>
 	/// Gets the integration id.
 	/// </summary>
 	[JsonProperty("id")]
 	public ulong Id { get; set; }
 
 	/// <summary>
 	/// Gets the integration type.
 	/// </summary>
 	[JsonProperty("type")]
 	public string Type { get; set; }
 
 	/// <summary>
 	/// Gets the integration name.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets the integration account.
 	/// </summary>
 	[JsonProperty("account")]
 	public AuditLogIntegrationAccount Account { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log action change.
 /// </summary>
 internal sealed class AuditLogActionChange
 {
 	// this can be a string or an array
 	/// <summary>
 	/// Gets or sets the old value.
 	/// </summary>
 	[JsonProperty("old_value")]
 	public object OldValue { get; set; }
 
 	/// <summary>
 	/// Gets the old values.
 	/// </summary>
 	[JsonIgnore]
 	public IEnumerable<JObject> OldValues
 		=> (this.OldValue as JArray)?.ToObject<IEnumerable<JObject>>();
 
 	/// <summary>
 	/// Gets the old value ulong.
 	/// </summary>
 	[JsonIgnore]
 	public ulong OldValueUlong
 		=> (ulong)this.OldValue;
 
 	/// <summary>
 	/// Gets the old value string.
 	/// </summary>
 	[JsonIgnore]
 	public string OldValueString
 		=> (string)this.OldValue;
 
 	// this can be a string or an array
 	/// <summary>
 	/// Gets or sets the new value.
 	/// </summary>
 	[JsonProperty("new_value")]
 	public object NewValue { get; set; }
 
 	/// <summary>
 	/// Gets the new values.
 	/// </summary>
 	[JsonIgnore]
 	public IEnumerable<JObject> NewValues
 		=> (this.NewValue as JArray)?.ToObject<IEnumerable<JObject>>();
 
 	/// <summary>
 	/// Gets the new value ulong.
 	/// </summary>
 	[JsonIgnore]
 	public ulong NewValueUlong
 		=> (ulong)this.NewValue;
 
 	/// <summary>
 	/// Gets the new value string.
 	/// </summary>
 	[JsonIgnore]
 	public string NewValueString
 		=> (string)this.NewValue;
 
 	/// <summary>
 	/// Gets or sets the key.
 	/// </summary>
 	[JsonProperty("key")]
 	public string Key { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log action options.
 /// </summary>
 internal sealed class AuditLogActionOptions
 {
 	/// <summary>
 	/// Gets or sets the type.
 	/// </summary>
 	[JsonProperty("type")]
 	public object Type { get; set; }
 
 	/// <summary>
 	/// Gets or sets the id.
 	/// </summary>
 	[JsonProperty("id")]
 	public ulong Id { get; set; }
 
 	/// <summary>
 	/// Gets or sets the channel id.
 	/// </summary>
 	[JsonProperty("channel_id")]
 	public ulong ChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the message id.
 	/// </summary>
 	[JsonProperty("message_id")]
 	public ulong MessageId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the count.
 	/// </summary>
 	[JsonProperty("count")]
 	public int Count { get; set; }
 
 	/// <summary>
 	/// Gets or sets the delete member days.
 	/// </summary>
 	[JsonProperty("delete_member_days")]
 	public int DeleteMemberDays { get; set; }
 
 	/// <summary>
 	/// Gets or sets the members removed.
 	/// </summary>
 	[JsonProperty("members_removed")]
 	public int MembersRemoved { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log action.
 /// </summary>
 internal sealed class AuditLogAction
 {
 	/// <summary>
 	/// Gets or sets the target id.
 	/// </summary>
 	[JsonProperty("target_id")]
 	public ulong? TargetId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the user id.
 	/// </summary>
 	[JsonProperty("user_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong UserId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the id.
 	/// </summary>
 	[JsonProperty("id")]
 	public ulong Id { get; set; }
 
 	/// <summary>
 	/// Gets or sets the action type.
 	/// </summary>
 	[JsonProperty("action_type", NullValueHandling = NullValueHandling.Ignore)]
 	public AuditLogActionType ActionType { get; set; }
 
 	/// <summary>
 	/// Gets or sets the changes.
 	/// </summary>
 	[JsonProperty("changes")]
 	public IEnumerable<AuditLogActionChange> Changes { get; set; }
 
 	/// <summary>
 	/// Gets or sets the options.
 	/// </summary>
 	[JsonProperty("options")]
 	public AuditLogActionOptions Options { get; set; }
 
 	/// <summary>
 	/// Gets or sets the reason.
 	/// </summary>
 	[JsonProperty("reason")]
 	public string Reason { get; set; }
 }
 
 /// <summary>
 /// Represents a audit log.
 /// </summary>
 internal sealed class AuditLog
 {
 	/// <summary>
 	/// Gets or sets the webhooks.
 	/// </summary>
 	[JsonProperty("webhooks")]
 	public IEnumerable<AuditLogWebhook> Webhooks { get; set; }
 
 	/// <summary>
 	/// Gets or sets the users.
 	/// </summary>
 	[JsonProperty("users")]
 	public IEnumerable<AuditLogUser> Users { get; set; }
 
 	/// <summary>
 	/// Gets or sets the entries.
 	/// </summary>
 	[JsonProperty("audit_log_entries")]
 	public IEnumerable<AuditLogAction> Entries { get; set; }
 
 	/// <summary>
 	/// Gets or sets the scheduled events.
 	/// </summary>
 	[JsonProperty("guild_scheduled_events")]
 	public IEnumerable<AuditLogGuildScheduledEvent> ScheduledEvents { get; set; }
 
 	/// <summary>
 	/// Gets or sets the threads.
 	/// </summary>
 	[JsonProperty("threads")]
 	public IEnumerable<AuditLogThread> Threads { get; set; }
 
 	/// <summary>
 	/// Gets or sets the integrations.
 	/// Twitch related.
 	/// </summary>
 	[JsonProperty("integrations")]
 	public IEnumerable<AuditLogIntegration> Integrations { get; set; }
 
 	/*
         /// <summary>
         /// Gets or sets the application commands.
         /// Related to Permissions V2.
         /// </summary>
         [JsonProperty("application_commands")]
         public IEnumerable<AuditLogApplicationCommand> ApplicationCommands { get; set; }
         */
 }
diff --git a/DisCatSharp/Net/Abstractions/Rest/RestApplicationCommandPayloads.cs b/DisCatSharp/Net/Abstractions/Rest/RestApplicationCommandPayloads.cs
index 8c145ca39..25ca3dbbe 100644
--- a/DisCatSharp/Net/Abstractions/Rest/RestApplicationCommandPayloads.cs
+++ b/DisCatSharp/Net/Abstractions/Rest/RestApplicationCommandPayloads.cs
@@ -1,246 +1,246 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions;
 
 /// <summary>
 /// Represents a application command create payload.
 /// </summary>
 internal class RestApplicationCommandCreatePayload
 {
 	/// <summary>
 	/// Gets the type.
 	/// </summary>
 	[JsonProperty("type")]
 	public ApplicationCommandType Type { get; set; }
 
 	/// <summary>
 	/// Gets the name.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets the name localizations.
 	/// </summary>
 	[JsonProperty("name_localizations", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<Dictionary<string, string>> NameLocalizations { get; set; }
 
 	/// <summary>
 	/// Gets the description.
 	/// </summary>
 	[JsonProperty("description", NullValueHandling = NullValueHandling.Ignore)]
 	public string Description { get; set; }
 
 	/// <summary>
 	/// Gets the description localizations.
 	/// </summary>
 	[JsonProperty("description_localizations", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<Dictionary<string, string>> DescriptionLocalizations { get; set; }
 
 	/// <summary>
 	/// Gets the options.
 	/// </summary>
 	[JsonProperty("options", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordApplicationCommandOption> Options { get; set; }
 
 	/// <summary>
 	/// Whether the command is allowed for everyone.
 	/// </summary>
 	[JsonProperty("default_permission", NullValueHandling = NullValueHandling.Include)]
 	public bool? DefaultPermission { get; set; } = null;
 
 	/// <summary>
 	/// The command needed permissions.
 	/// </summary>
 	[JsonProperty("default_member_permissions", NullValueHandling = NullValueHandling.Include)]
 	public Permissions? DefaultMemberPermission { get; set; }
 
 	/// <summary>
 	/// Whether the command is allowed for dms.
 	/// </summary>
 	[JsonProperty("dm_permission", NullValueHandling = NullValueHandling.Include)]
 	public bool? DmPermission { get; set; }
-
+	/*
 	/// <summary>
 	/// Whether the command is marked as NSFW.
 	/// </summary>
 	[JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
-	public bool Nsfw { get; set; }
+	public bool Nsfw { get; set; }*/
 }
 
 /// <summary>
 /// Represents a application command edit payload.
 /// </summary>
 internal class RestApplicationCommandEditPayload
 {
 	/// <summary>
 	/// Gets the name.
 	/// </summary>
 	[JsonProperty("name")]
 	public Optional<string> Name { get; set; }
 
 	/// <summary>
 	/// Gets the name localizations.
 	/// </summary>
 	[JsonProperty("name_localizations")]
 	public Optional<Dictionary<string, string>> NameLocalizations { get; set; }
 
 	/// <summary>
 	/// Gets the description.
 	/// </summary>
 	[JsonProperty("description")]
 	public Optional<string> Description { get; set; }
 
 	/// <summary>
 	/// Gets the description localizations.
 	/// </summary>
 	[JsonProperty("description_localizations")]
 	public Optional<Dictionary<string, string>> DescriptionLocalizations { get; set; }
 
 	/// <summary>
 	/// Gets the options.
 	/// </summary>
 	[JsonProperty("options")]
 	public Optional<IReadOnlyCollection<DiscordApplicationCommandOption>> Options { get; set; }
 
 	/// <summary>
 	/// Gets the default permission.
 	/// </summary>
 	[JsonProperty("default_permission", NullValueHandling = NullValueHandling.Include)]
 	public bool? DefaultPermission { get; set; } = null;
 
 	/// <summary>
 	/// The command needed permissions.
 	/// </summary>
 	[JsonProperty("default_member_permissions", NullValueHandling = NullValueHandling.Include)]
 	public Optional<Permissions> DefaultMemberPermission { get; set; }
 
 	/// <summary>
 	/// Whether the command is allowed for dms.
 	/// </summary>
 	[JsonProperty("dm_permission", NullValueHandling = NullValueHandling.Include)]
 	public Optional<bool> DmPermission { get; set; }
-
+	/*
 	/// <summary>
 	/// Whether the command is marked as NSFW.
 	/// </summary>
 	[JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
-	public Optional<bool> Nsfw { get; set; }
+	public Optional<bool> Nsfw { get; set; }*/
 }
 
 /// <summary>
 /// Represents a interaction response payload.
 /// </summary>
 internal class RestInteractionResponsePayload
 {
 	/// <summary>
 	/// Gets the type.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public InteractionResponseType Type { get; set; }
 
 	/// <summary>
 	/// Gets the data.
 	/// </summary>
 	[JsonProperty("data", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordInteractionApplicationCommandCallbackData Data { get; set; }
 
 	/// <summary>
 	/// Gets the attachments.
 	/// </summary>
 	[JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
 	public List<DiscordAttachment> Attachments { get; set; }
 }
 
 /// <summary>
 /// Represents a interaction response payload.
 /// </summary>
 internal class RestInteractionModalResponsePayload
 {
 	/// <summary>
 	/// Gets the type.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public InteractionResponseType Type { get; set; }
 
 	/// <summary>
 	/// Gets the data.
 	/// </summary>
 	[JsonProperty("data", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordInteractionApplicationCommandModalCallbackData Data { get; set; }
 }
 
 /// <summary>
 /// Represents a followup message create payload.
 /// </summary>
 internal class RestFollowupMessageCreatePayload
 {
 	/// <summary>
 	/// Gets the content.
 	/// </summary>
 	[JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
 	public string Content { get; set; }
 
 	/// <summary>
 	/// Get whether the message is tts.
 	/// </summary>
 	[JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? IsTts { get; set; }
 
 	/// <summary>
 	/// Gets the embeds.
 	/// </summary>
 	[JsonProperty("embeds", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordEmbed> Embeds { get; set; }
 
 	/// <summary>
 	/// Gets the mentions.
 	/// </summary>
 	[JsonProperty("allowed_mentions", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMentions Mentions { get; set; }
 
 	/// <summary>
 	/// Gets the flags.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public int? Flags { get; set; }
 
 	/// <summary>
 	/// Gets the components.
 	/// </summary>
 	[JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyCollection<DiscordActionRowComponent> Components { get; set; }
 
 	/// <summary>
 	/// Gets attachments.
 	/// </summary>
 	[JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
 	public List<DiscordAttachment> Attachments { get; set; }
 }
diff --git a/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs b/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs
index 4f81783b1..359df4bd0 100644
--- a/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs
+++ b/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs
@@ -1,504 +1,505 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System.Collections.Generic;
 
 using DisCatSharp.Entities;
+using DisCatSharp.Enums;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions;
 
 /// <summary>
 /// Represents a channel create payload.
 /// </summary>
 internal sealed class RestChannelCreatePayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the type.
 	/// </summary>
 	[JsonProperty("type")]
 	public ChannelType Type { get; set; }
 
 	/// <summary>
 	/// Gets or sets the parent.
 	/// </summary>
 	[JsonProperty("parent_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? Parent { get; set; }
 
 	/// <summary>
 	/// Gets or sets the topic.
 	/// </summary>
 	[JsonProperty("topic")]
 	public Optional<string> Topic { get; set; }
 
 	/// <summary>
 	/// Gets or sets the bitrate.
 	/// </summary>
 	[JsonProperty("bitrate", NullValueHandling = NullValueHandling.Ignore)]
 	public int? Bitrate { get; set; }
 
 	/// <summary>
 	/// Gets or sets the user limit.
 	/// </summary>
 	[JsonProperty("user_limit", NullValueHandling = NullValueHandling.Ignore)]
 	public int? UserLimit { get; set; }
 
 	/// <summary>
 	/// Gets or sets the permission overwrites.
 	/// </summary>
 	[JsonProperty("permission_overwrites", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordRestOverwrite> PermissionOverwrites { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether nsfw.
 	/// </summary>
 	[JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Nsfw { get; set; }
 
 	/// <summary>
 	/// Gets or sets the per user rate limit.
 	/// </summary>
 	[JsonProperty("rate_limit_per_user")]
 	public Optional<int?> PerUserRateLimit { get; set; }
 
 	/// <summary>
 	/// Gets or sets the quality mode.
 	/// </summary>
 	[JsonProperty("video_quality_mode", NullValueHandling = NullValueHandling.Ignore)]
 	public VideoQualityMode? QualityMode { get; set; }
 
 	/// <summary>
 	/// Gets or sets the default auto archive duration.
 	/// </summary>
 	[JsonProperty("default_auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
 	public ThreadAutoArchiveDuration? DefaultAutoArchiveDuration { get; set; }
 }
 
 /// <summary>
 /// Represents a channel modify payload.
 /// </summary>
 internal sealed class RestChannelModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the type.
 	/// </summary>
 	[JsonProperty("type")]
 	public Optional<ChannelType> Type { get; set; }
 
 	/// <summary>
 	/// Gets or sets the position.
 	/// </summary>
 	[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
 	public int? Position { get; set; }
 
 	/// <summary>
 	/// Gets or sets the topic.
 	/// </summary>
 	[JsonProperty("topic")]
 	public Optional<string> Topic { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether nsfw.
 	/// </summary>
 	[JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Nsfw { get; set; }
 
 	/// <summary>
 	/// Gets or sets the parent.
 	/// </summary>
 	[JsonProperty("parent_id")]
 	public Optional<ulong?> Parent { get; set; }
 
 	/// <summary>
 	/// Gets or sets the bitrate.
 	/// </summary>
 	[JsonProperty("bitrate", NullValueHandling = NullValueHandling.Ignore)]
 	public int? Bitrate { get; set; }
 
 	/// <summary>
 	/// Gets or sets the user limit.
 	/// </summary>
 	[JsonProperty("user_limit", NullValueHandling = NullValueHandling.Ignore)]
 	public int? UserLimit { get; set; }
 
 	/// <summary>
 	/// Gets or sets the per user rate limit.
 	/// </summary>
 	[JsonProperty("rate_limit_per_user")]
 	public Optional<int?> PerUserRateLimit { get; set; }
 
 	/// <summary>
 	/// Gets or sets the rtc region.
 	/// </summary>
 	[JsonProperty("rtc_region")]
 	public Optional<string> RtcRegion { get; set; }
 
 	/// <summary>
 	/// Gets or sets the quality mode.
 	/// </summary>
 	[JsonProperty("video_quality_mode", NullValueHandling = NullValueHandling.Ignore)]
 	public VideoQualityMode? QualityMode { get; set; }
 
 	/// <summary>
 	/// Gets or sets the default auto archive duration.
 	/// </summary>
 	[JsonProperty("default_auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
 	public ThreadAutoArchiveDuration? DefaultAutoArchiveDuration { get; set; }
 
 	/// <summary>
 	/// Gets or sets the permission overwrites.
 	/// </summary>
 	[JsonProperty("permission_overwrites", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordRestOverwrite> PermissionOverwrites { get; set; }
 
 	/// <summary>
 	/// Gets or sets the banner base64.
 	/// </summary>
 	[JsonProperty("banner")]
 	public Optional<string> BannerBase64 { get; set; }
 }
 
 /// <summary>
 /// Represents a channel message edit payload.
 /// </summary>
 internal class RestChannelMessageEditPayload
 {
 	/// <summary>
 	/// Gets or sets the content.
 	/// </summary>
 	[JsonProperty("content", NullValueHandling = NullValueHandling.Include)]
 	public string Content { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether has content.
 	/// </summary>
 	[JsonIgnore]
 	public bool HasContent { get; set; }
 
 	/// <summary>
 	/// Gets or sets the embeds.
 	/// </summary>
 	[JsonProperty("embeds", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordEmbed> Embeds { get; set; }
 
 	/// <summary>
 	/// Gets or sets the mentions.
 	/// </summary>
 	[JsonProperty("allowed_mentions", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMentions Mentions { get; set; }
 
 	/// <summary>
 	/// Gets or sets the attachments.
 	/// </summary>
 	[JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordAttachment> Attachments { get; set; }
 
 	/// <summary>
 	/// Gets or sets the flags.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public MessageFlags? Flags { get; set; }
 
 	/// <summary>
 	/// Gets or sets the components.
 	/// </summary>
 	[JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyCollection<DiscordActionRowComponent> Components { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether has embed.
 	/// </summary>
 	[JsonIgnore]
 	public bool HasEmbed { get; set; }
 
 	/// <summary>
 	/// Should serialize the content.
 	/// </summary>
 	public bool ShouldSerializeContent()
 		=> this.HasContent;
 
 	/// <summary>
 	/// Should serialize the embed.
 	/// </summary>
 	public bool ShouldSerializeEmbed()
 		=> this.HasEmbed;
 }
 
 /// <summary>
 /// Represents a channel message create payload.
 /// </summary>
 internal sealed class RestChannelMessageCreatePayload : RestChannelMessageEditPayload
 {
 	/// <summary>
 	/// Gets or sets a value indicating whether t t is s.
 	/// </summary>
 	[JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? IsTts { get; set; }
 
 	/// <summary>
 	/// Gets or sets the stickers ids.
 	/// </summary>
 	[JsonProperty("sticker_ids", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<ulong> StickersIds { get; set; }
 
 	/// <summary>
 	/// Gets or sets the message reference.
 	/// </summary>
 	[JsonProperty("message_reference", NullValueHandling = NullValueHandling.Ignore)]
 	public InternalDiscordMessageReference? MessageReference { get; set; }
 
 }
 
 /// <summary>
 /// Represents a channel message create multipart payload.
 /// </summary>
 internal sealed class RestChannelMessageCreateMultipartPayload
 {
 	/// <summary>
 	/// Gets or sets the content.
 	/// </summary>
 	[JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
 	public string Content { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether t t is s.
 	/// </summary>
 	[JsonProperty("tts", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? IsTts { get; set; }
 
 	/// <summary>
 	/// Gets or sets the embeds.
 	/// </summary>
 	[JsonProperty("embeds", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordEmbed> Embeds { get; set; }
 
 	/// <summary>
 	/// Gets or sets the mentions.
 	/// </summary>
 	[JsonProperty("allowed_mentions", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordMentions Mentions { get; set; }
 
 	/// <summary>
 	/// Gets or sets the message reference.
 	/// </summary>
 	[JsonProperty("message_reference", NullValueHandling = NullValueHandling.Ignore)]
 	public InternalDiscordMessageReference? MessageReference { get; set; }
 }
 
 /// <summary>
 /// Represents a channel message bulk delete payload.
 /// </summary>
 internal sealed class RestChannelMessageBulkDeletePayload
 {
 	/// <summary>
 	/// Gets or sets the messages.
 	/// </summary>
 	[JsonProperty("messages", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<ulong> Messages { get; set; }
 }
 
 /// <summary>
 /// Represents a channel invite create payload.
 /// </summary>
 internal sealed class RestChannelInviteCreatePayload
 {
 	/// <summary>
 	/// Gets or sets the max age.
 	/// </summary>
 	[JsonProperty("max_age", NullValueHandling = NullValueHandling.Ignore)]
 	public int MaxAge { get; set; }
 
 	/// <summary>
 	/// Gets or sets the max uses.
 	/// </summary>
 	[JsonProperty("max_uses", NullValueHandling = NullValueHandling.Ignore)]
 	public int MaxUses { get; set; }
 
 	/// <summary>
 	/// Gets or sets the target type.
 	/// </summary>
 	[JsonProperty("target_type", NullValueHandling = NullValueHandling.Ignore)]
 	public TargetType? TargetType { get; set; }
 
 	/// <summary>
 	/// Gets or sets the target application.
 	/// </summary>
 	[JsonProperty("target_application_id", NullValueHandling = NullValueHandling.Ignore)]
 	public TargetActivity? TargetApplication { get; set; }
 
 	/// <summary>
 	/// Gets or sets the target user id.
 	/// </summary>
 	[JsonProperty("target_user_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? TargetUserId { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether temporary.
 	/// </summary>
 	[JsonProperty("temporary", NullValueHandling = NullValueHandling.Ignore)]
 	public bool Temporary { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether unique.
 	/// </summary>
 	[JsonProperty("unique", NullValueHandling = NullValueHandling.Ignore)]
 	public bool Unique { get; set; }
 }
 
 /// <summary>
 /// Represents a channel permission edit payload.
 /// </summary>
 internal sealed class RestChannelPermissionEditPayload
 {
 	/// <summary>
 	/// Gets or sets the allow.
 	/// </summary>
 	[JsonProperty("allow", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions Allow { get; set; }
 
 	/// <summary>
 	/// Gets or sets the deny.
 	/// </summary>
 	[JsonProperty("deny", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions Deny { get; set; }
 
 	/// <summary>
 	/// Gets or sets the type.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public string Type { get; set; }
 }
 
 /// <summary>
 /// Represents a channel group dm recipient add payload.
 /// </summary>
 internal sealed class RestChannelGroupDmRecipientAddPayload : IOAuth2Payload
 {
 	/// <summary>
 	/// Gets or sets the access token.
 	/// </summary>
 	[JsonProperty("access_token")]
 	public string AccessToken { get; set; }
 
 	/// <summary>
 	/// Gets or sets the nickname.
 	/// </summary>
 	[JsonProperty("nick", NullValueHandling = NullValueHandling.Ignore)]
 	public string Nickname { get; set; }
 }
 
 /// <summary>
 /// The acknowledge payload.
 /// </summary>
 internal sealed class AcknowledgePayload
 {
 	/// <summary>
 	/// Gets or sets the token.
 	/// </summary>
 	[JsonProperty("token", NullValueHandling = NullValueHandling.Include)]
 	public string Token { get; set; }
 }
 
 /// <summary>
 /// Represents a thread channel create payload.
 /// </summary>
 internal sealed class RestThreadChannelCreatePayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the auto archive duration.
 	/// </summary>
 	[JsonProperty("auto_archive_duration")]
 	public ThreadAutoArchiveDuration AutoArchiveDuration { get; set; }
 
 	/// <summary>
 	/// Gets or sets the rate limit per user.
 	/// </summary>
 	[JsonProperty("rate_limit_per_user")]
 	public int? PerUserRateLimit { get; set; }
 
 	/// <summary>
 	/// Gets or sets the thread type.
 	/// </summary>
 	[JsonProperty("type")]
 	public ChannelType Type { get; set; }
 }
 
 /// <summary>
 /// Represents a thread channel modify payload.
 /// </summary>
 internal sealed class RestThreadChannelModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the archived.
 	/// </summary>
 	[JsonProperty("archived", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<bool?> Archived { get; set; }
 
 	/// <summary>
 	/// Gets or sets the auto archive duration.
 	/// </summary>
 	[JsonProperty("auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<ThreadAutoArchiveDuration?> AutoArchiveDuration { get; set; }
 
 	/// <summary>
 	/// Gets or sets the locked.
 	/// </summary>
 	[JsonProperty("locked", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<bool?> Locked { get; set; }
 
 	/// <summary>
 	/// Gets or sets the per user rate limit.
 	/// </summary>
 	[JsonProperty("rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<int?> PerUserRateLimit { get; set; }
 
 	/// <summary>
 	/// Gets or sets the thread's invitable state.
 	/// </summary>
 	[JsonProperty("invitable", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<bool?> Invitable { internal get; set; }
 }
diff --git a/DisCatSharp/Net/Abstractions/Rest/RestGuildPayloads.cs b/DisCatSharp/Net/Abstractions/Rest/RestGuildPayloads.cs
index 27141c1e2..3b7c2aabb 100644
--- a/DisCatSharp/Net/Abstractions/Rest/RestGuildPayloads.cs
+++ b/DisCatSharp/Net/Abstractions/Rest/RestGuildPayloads.cs
@@ -1,723 +1,736 @@
 // 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 DisCatSharp.Entities;
+using DisCatSharp.Enums;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions;
 
 /// <summary>
 /// The reason action.
 /// </summary>
 internal interface IReasonAction
 {
 	/// <summary>
 	/// Gets or sets the reason.
 	/// </summary>
 	string Reason { get; set; }
 
 	//[JsonProperty("reason", NullValueHandling = NullValueHandling.Ignore)]
 	//public string Reason { get; set; }
 }
 
 /// <summary>
 /// Represents a guild create payload.
 /// </summary>
 internal class RestGuildCreatePayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the region id.
 	/// </summary>
 	[JsonProperty("region", NullValueHandling = NullValueHandling.Ignore)]
 	public string RegionId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the icon base64.
 	/// </summary>
 	[JsonProperty("icon", NullValueHandling = NullValueHandling.Include)]
 	public Optional<string> IconBase64 { get; set; }
 
 	/// <summary>
 	/// Gets or sets the verification level.
 	/// </summary>
 	[JsonProperty("verification_level", NullValueHandling = NullValueHandling.Ignore)]
 	public VerificationLevel? VerificationLevel { get; set; }
 
 	/// <summary>
 	/// Gets or sets the default message notifications.
 	/// </summary>
 	[JsonProperty("default_message_notifications", NullValueHandling = NullValueHandling.Ignore)]
 	public DefaultMessageNotifications? DefaultMessageNotifications { get; set; }
 
 	/// <summary>
 	/// Gets or sets the system channel flags.
 	/// </summary>
 	[JsonProperty("system_channel_flags", NullValueHandling = NullValueHandling.Ignore)]
 	public SystemChannelFlags? SystemChannelFlags { get; set; }
 
 	/// <summary>
 	/// Gets or sets the roles.
 	/// </summary>
 	[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordRole> Roles { get; set; }
 
 	/// <summary>
 	/// Gets or sets the channels.
 	/// </summary>
 	[JsonProperty("channels", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<RestChannelCreatePayload> Channels { get; set; }
 }
 
 /// <summary>
 /// Represents a guild create from template payload.
 /// </summary>
 internal sealed class RestGuildCreateFromTemplatePayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the icon base64.
 	/// </summary>
 	[JsonProperty("icon", NullValueHandling = NullValueHandling.Include)]
 	public Optional<string> IconBase64 { get; set; }
 }
 
 /// <summary>
 /// Represents a guild modify payload.
 /// </summary>
 internal sealed class RestGuildModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name")]
 	public Optional<string> Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the icon base64.
 	/// </summary>
 	[JsonProperty("icon")]
 	public Optional<string> IconBase64 { get; set; }
 
 	/// <summary>
 	/// Gets or sets the verification level.
 	/// </summary>
 	[JsonProperty("verification_level")]
 	public Optional<VerificationLevel> VerificationLevel { get; set; }
 
 	/// <summary>
 	/// Gets or sets the default message notifications.
 	/// </summary>
 	[JsonProperty("default_message_notifications")]
 	public Optional<DefaultMessageNotifications> DefaultMessageNotifications { get; set; }
 
 	/// <summary>
 	/// Gets or sets the owner id.
 	/// </summary>
 	[JsonProperty("owner_id")]
 	public Optional<ulong> OwnerId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the splash base64.
 	/// </summary>
 	[JsonProperty("splash")]
 	public Optional<string> SplashBase64 { get; set; }
 
 	/// <summary>
 	/// Gets or sets the banner base64.
 	/// </summary>
 	[JsonProperty("banner")]
 	public Optional<string> BannerBase64 { get; set; }
 
 
 	/// <summary>
 	/// Gets or sets the discovery splash base64.
 	/// </summary>
 	[JsonProperty("discovery_splash")]
 	public Optional<string> DiscoverySplashBase64 { get; set; }
 
 	/// <summary>
 	/// Gets or sets the afk channel id.
 	/// </summary>
 	[JsonProperty("afk_channel_id")]
 	public Optional<ulong?> AfkChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the afk timeout.
 	/// </summary>
 	[JsonProperty("afk_timeout")]
 	public Optional<int> AfkTimeout { get; set; }
 
 	/// <summary>
 	/// Gets or sets the mfa level.
 	/// </summary>
 	[JsonProperty("mfa_level")]
 	public Optional<MfaLevel> MfaLevel { get; set; }
 
 	/// <summary>
 	/// Gets or sets the explicit content filter.
 	/// </summary>
 	[JsonProperty("explicit_content_filter")]
 	public Optional<ExplicitContentFilter> ExplicitContentFilter { get; set; }
 
 	/// <summary>
 	/// Gets or sets the system channel id.
 	/// </summary>
 	[JsonProperty("system_channel_id", NullValueHandling = NullValueHandling.Include)]
 	public Optional<ulong?> SystemChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the system channel flags.
 	/// </summary>
 	[JsonProperty("system_channel_flags", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<SystemChannelFlags> SystemChannelFlags { get; set; }
 
 	/// <summary>
 	/// Gets or sets the rules channel id.
 	/// </summary>
 	[JsonProperty("rules_channel_id")]
 	public Optional<ulong?> RulesChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the public updates channel id.
 	/// </summary>
 	[JsonProperty("public_updates_channel_id")]
 	public Optional<ulong?> PublicUpdatesChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the preferred locale.
 	/// </summary>
 	[JsonProperty("preferred_locale")]
 	public Optional<string> PreferredLocale { get; set; }
 
 	/// <summary>
 	/// Gets or sets the description.
 	/// </summary>
 	[JsonProperty("description", NullValueHandling = NullValueHandling.Include)]
 	public Optional<string> Description { get; set; }
 
 	/// <summary>
 	/// Gets or sets whether the premium progress bar should be enabled.
 	/// </summary>
 	[JsonProperty("premium_progress_bar_enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<bool> PremiumProgressBarEnabled { get; set; }
 }
 
+/// <summary>
+/// Represents a guild mfa level modify payload.
+/// </summary>
+internal sealed class RestGuildMfaLevelModifyPayload
+{
+	/// <summary>
+	/// Gets or sets the mfa level.
+	/// </summary>
+	[JsonProperty("level")]
+	public MfaLevel Level { get; set; }
+}
+
 /// <summary>
 /// Represents a guild community modify payload.
 /// </summary>
 internal sealed class RestGuildCommunityModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the verification level.
 	/// </summary>
 	[JsonProperty("verification_level", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<VerificationLevel> VerificationLevel { get; set; }
 
 	/// <summary>
 	/// Gets or sets the default message notifications.
 	/// </summary>
 	[JsonProperty("default_message_notifications", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<DefaultMessageNotifications> DefaultMessageNotifications { get; set; }
 
 	/// <summary>
 	/// Gets or sets the explicit content filter.
 	/// </summary>
 	[JsonProperty("explicit_content_filter", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<ExplicitContentFilter> ExplicitContentFilter { get; set; }
 
 	/// <summary>
 	/// Gets or sets the rules channel id.
 	/// </summary>
 	[JsonProperty("rules_channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<ulong?> RulesChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the public updates channel id.
 	/// </summary>
 	[JsonProperty("public_updates_channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<ulong?> PublicUpdatesChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the preferred locale.
 	/// </summary>
 	[JsonProperty("preferred_locale")]
 	public Optional<string> PreferredLocale { get; set; }
 
 	/// <summary>
 	/// Gets or sets the description.
 	/// </summary>
 	[JsonProperty("description", NullValueHandling = NullValueHandling.Include)]
 	public Optional<string> Description { get; set; }
 
 	/// <summary>
 	/// Gets or sets the features.
 	/// </summary>
 	[JsonProperty("features", NullValueHandling = NullValueHandling.Ignore)]
 	public List<string> Features { get; set; }
 }
 
 /// <summary>
 /// Represents a guild member add payload.
 /// </summary>
 internal sealed class RestGuildMemberAddPayload : IOAuth2Payload
 {
 	/// <summary>
 	/// Gets or sets the access token.
 	/// </summary>
 	[JsonProperty("access_token")]
 	public string AccessToken { get; set; }
 
 	/// <summary>
 	/// Gets or sets the nickname.
 	/// </summary>
 	[JsonProperty("nick", NullValueHandling = NullValueHandling.Ignore)]
 	public string Nickname { get; set; }
 
 	/// <summary>
 	/// Gets or sets the roles.
 	/// </summary>
 	[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordRole> Roles { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether mute.
 	/// </summary>
 	[JsonProperty("mute", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Mute { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether deaf.
 	/// </summary>
 	[JsonProperty("deaf", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Deaf { get; set; }
 }
 
 /// <summary>
 /// Represents a guild channel reorder payload.
 /// </summary>
 internal sealed class RestGuildChannelReorderPayload
 {
 	/// <summary>
 	/// Gets or sets the channel id.
 	/// </summary>
 	[JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the position.
 	/// </summary>
 	[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
 	public int Position { get; set; }
 }
 
 /// <summary>
 /// Represents a guild channel new parent payload.
 /// </summary>
 internal sealed class RestGuildChannelNewParentPayload
 {
 	/// <summary>
 	/// Gets or sets the channel id.
 	/// </summary>
 	[JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the position.
 	/// </summary>
 	[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
 	public int Position { get; set; }
 
 	/// <summary>
 	/// Gets or sets the parent id.
 	/// </summary>
 	[JsonProperty("parent_id", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<ulong?> ParentId { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether lock permissions.
 	/// </summary>
 	[JsonProperty("lock_permissions", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? LockPermissions { get; set; }
 }
 
 /// <summary>
 /// Represents a guild channel no parent payload.
 /// </summary>
 internal sealed class RestGuildChannelNoParentPayload
 {
 	/// <summary>
 	/// Gets or sets the channel id.
 	/// </summary>
 	[JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong ChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the position.
 	/// </summary>
 	[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
 	public int Position { get; set; }
 
 	/// <summary>
 	/// Gets or sets the parent id.
 	/// </summary>
 	[JsonProperty("parent_id", NullValueHandling = NullValueHandling.Include)]
 	public Optional<ulong?> ParentId { get; set; }
 }
 
 /// <summary>
 /// Represents a guild role reorder payload.
 /// </summary>
 internal sealed class RestGuildRoleReorderPayload
 {
 	/// <summary>
 	/// Gets or sets the role id.
 	/// </summary>
 	[JsonProperty("id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong RoleId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the position.
 	/// </summary>
 	[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
 	public int Position { get; set; }
 }
 
 /// <summary>
 /// Represents a guild member modify payload.
 /// </summary>
 internal sealed class RestGuildMemberModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the nickname.
 	/// </summary>
 	[JsonProperty("nick")]
 	public Optional<string> Nickname { get; set; }
 
 	/// <summary>
 	/// Gets or sets the role ids.
 	/// </summary>
 	[JsonProperty("roles")]
 	public Optional<IEnumerable<ulong>> RoleIds { get; set; }
 
 	/// <summary>
 	/// Gets or sets the mute.
 	/// </summary>
 	[JsonProperty("mute")]
 	public Optional<bool> Mute { get; set; }
 
 	/// <summary>
 	/// Gets or sets the deafen.
 	/// </summary>
 	[JsonProperty("deaf")]
 	public Optional<bool> Deafen { get; set; }
 
 	/// <summary>
 	/// Gets or sets the voice channel id.
 	/// </summary>
 	[JsonProperty("channel_id")]
 	public Optional<ulong?> VoiceChannelId { get; set; }
 }
 
 /// <summary>
 /// Represents a guild member timeout modify payload.
 /// </summary>
 internal sealed class RestGuildMemberTimeoutModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the date until the member can communicate again.
 	/// </summary>
 	[JsonProperty("communication_disabled_until")]
 	public DateTimeOffset? CommunicationDisabledUntil { get; internal set; }
 }
 
 /// <summary>
 /// Represents a guild role payload.
 /// </summary>
 internal sealed class RestGuildRolePayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the permissions.
 	/// </summary>
 	[JsonProperty("permissions", NullValueHandling = NullValueHandling.Ignore)]
 	public Permissions? Permissions { get; set; }
 
 	/// <summary>
 	/// Gets or sets the color.
 	/// </summary>
 	[JsonProperty("color", NullValueHandling = NullValueHandling.Ignore)]
 	public int? Color { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether hoist.
 	/// </summary>
 	[JsonProperty("hoist", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Hoist { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether mentionable.
 	/// </summary>
 	[JsonProperty("mentionable", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Mentionable { get; set; }
 
 	/// <summary>
 	/// Gets or sets the icon base64.
 	/// </summary>
 	[JsonProperty("icon")]
 	public Optional<string> IconBase64 { get; set; }
 
 	/// <summary>
 	/// Gets or sets the icon base64.
 	/// </summary>
 	[JsonProperty("unicode_emoji")]
 	public Optional<string> UnicodeEmoji { get; set; }
 }
 
 /// <summary>
 /// Represents a guild prune result payload.
 /// </summary>
 internal sealed class RestGuildPruneResultPayload
 {
 	/// <summary>
 	/// Gets or sets the pruned.
 	/// </summary>
 	[JsonProperty("pruned", NullValueHandling = NullValueHandling.Ignore)]
 	public int? Pruned { get; set; }
 }
 
 /// <summary>
 /// Represents a guild integration attach payload.
 /// </summary>
 internal sealed class RestGuildIntegrationAttachPayload
 {
 	/// <summary>
 	/// Gets or sets the type.
 	/// </summary>
 	[JsonProperty("type")]
 	public string Type { get; set; }
 
 	/// <summary>
 	/// Gets or sets the id.
 	/// </summary>
 	[JsonProperty("id")]
 	public ulong Id { get; set; }
 }
 
 /// <summary>
 /// Represents a guild integration modify payload.
 /// </summary>
 internal sealed class RestGuildIntegrationModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the expire behavior.
 	/// </summary>
 	[JsonProperty("expire_behavior", NullValueHandling = NullValueHandling.Ignore)]
 	public int? ExpireBehavior { get; set; }
 
 	/// <summary>
 	/// Gets or sets the expire grace period.
 	/// </summary>
 	[JsonProperty("expire_grace_period", NullValueHandling = NullValueHandling.Ignore)]
 	public int? ExpireGracePeriod { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether enable emoticons.
 	/// </summary>
 	[JsonProperty("enable_emoticons", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? EnableEmoticons { get; set; }
 }
 
 /// <summary>
 /// Represents a guild emoji modify payload.
 /// </summary>
 internal class RestGuildEmojiModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the roles.
 	/// </summary>
 	[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong[] Roles { get; set; }
 }
 
 /// <summary>
 /// Represents a guild emoji create payload.
 /// </summary>
 internal class RestGuildEmojiCreatePayload : RestGuildEmojiModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the image b64.
 	/// </summary>
 	[JsonProperty("image")]
 	public string ImageB64 { get; set; }
 }
 
 /// <summary>
 /// Represents a guild widget settings payload.
 /// </summary>
 internal class RestGuildWidgetSettingsPayload
 {
 	/// <summary>
 	/// Gets or sets a value indicating whether enabled.
 	/// </summary>
 	[JsonProperty("enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Enabled { get; set; }
 
 	/// <summary>
 	/// Gets or sets the channel id.
 	/// </summary>
 	[JsonProperty("channel_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? ChannelId { get; set; }
 }
 
 /// <summary>
 /// Represents a guild template create or modify payload.
 /// </summary>
 internal class RestGuildTemplateCreateOrModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Include)]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the description.
 	/// </summary>
 	[JsonProperty("description", NullValueHandling = NullValueHandling.Include)]
 	public string Description { get; set; }
 }
 
 /// <summary>
 /// Represents a guild membership screening form modify payload.
 /// </summary>
 internal class RestGuildMembershipScreeningFormModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the enabled.
 	/// </summary>
 	[JsonProperty("enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<bool> Enabled { get; set; }
 
 	/// <summary>
 	/// Gets or sets the fields.
 	/// </summary>
 	[JsonProperty("form_fields", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<DiscordGuildMembershipScreeningField[]> Fields { get; set; }
 
 	/// <summary>
 	/// Gets or sets the description.
 	/// </summary>
 	[JsonProperty("description", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<string> Description { get; set; }
 }
 
 /// <summary>
 /// Represents a guild welcome screen modify payload.
 /// </summary>
 internal class RestGuildWelcomeScreenModifyPayload
 {
 	/// <summary>
 	/// Gets or sets the enabled.
 	/// </summary>
 	[JsonProperty("enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<bool> Enabled { get; set; }
 
 	/// <summary>
 	/// Gets or sets the welcome channels.
 	/// </summary>
 	[JsonProperty("welcome_channels", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<IEnumerable<DiscordGuildWelcomeScreenChannel>> WelcomeChannels { get; set; }
 
 	/// <summary>
 	/// Gets or sets the description.
 	/// </summary>
 	[JsonProperty("description", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<string> Description { get; set; }
 }
 
 /// <summary>
 /// Represents a guild update current user voice state payload.
 /// </summary>
 internal class RestGuildUpdateCurrentUserVoiceStatePayload
 {
 	/// <summary>
 	/// Gets or sets the channel id.
 	/// </summary>
 	[JsonProperty("channel_id")]
 	public ulong ChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether suppress.
 	/// </summary>
 	[JsonProperty("suppress", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Suppress { get; set; }
 
 	/// <summary>
 	/// Gets or sets the request to speak timestamp.
 	/// </summary>
 	[JsonProperty("request_to_speak_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset? RequestToSpeakTimestamp { get; set; }
 }
 
 /// <summary>
 /// Represents a guild update user voice state payload.
 /// </summary>
 internal class RestGuildUpdateUserVoiceStatePayload
 {
 	/// <summary>
 	/// Gets or sets the channel id.
 	/// </summary>
 	[JsonProperty("channel_id")]
 	public ulong ChannelId { get; set; }
 
 	/// <summary>
 	/// Gets or sets a value indicating whether suppress.
 	/// </summary>
 	[JsonProperty("suppress", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Suppress { get; set; }
 }
diff --git a/DisCatSharp/Net/Abstractions/Transport/TransportMember.cs b/DisCatSharp/Net/Abstractions/Transport/TransportMember.cs
index 783098d2e..0c2aa4121 100644
--- a/DisCatSharp/Net/Abstractions/Transport/TransportMember.cs
+++ b/DisCatSharp/Net/Abstractions/Transport/TransportMember.cs
@@ -1,121 +1,127 @@
 // 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 DisCatSharp.Enums;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions;
 
 /// <summary>
 /// Represents a transport member.
 /// </summary>
 internal class TransportMember
 {
 	/// <summary>
 	/// Gets the avatar hash.
 	/// </summary>
 	[JsonIgnore]
 	public string AvatarHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild avatar hash.
 	/// </summary>
 	[JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
 	public string GuildAvatarHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild banner hash.
 	/// </summary>
 	[JsonProperty("banner", NullValueHandling = NullValueHandling.Ignore)]
 	public string GuildBannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the guild bio.
 	/// This is not available to bots tho.
 	/// </summary>
 	[JsonProperty("bio", NullValueHandling = NullValueHandling.Ignore)]
 	public string GuildBio { get; internal set; }
 
+	/// <summary>
+	/// Gets the members's pronouns.
+	/// </summary>
+	[JsonProperty("pronouns", NullValueHandling = NullValueHandling.Ignore)]
+	public string GuildPronouns { get; internal set; }
+
 	/// <summary>
 	/// Gets the user.
 	/// </summary>
 	[JsonProperty("user", NullValueHandling = NullValueHandling.Ignore)]
 	public TransportUser User { get; internal set; }
 
 	/// <summary>
 	/// Gets the nickname.
 	/// </summary>
 	[JsonProperty("nick", NullValueHandling = NullValueHandling.Ignore)]
 	public string Nickname { get; internal set; }
 
 	/// <summary>
 	/// Gets the roles.
 	/// </summary>
 	[JsonProperty("roles", NullValueHandling = NullValueHandling.Ignore)]
 	public List<ulong> Roles { get; internal set; }
 
 	/// <summary>
 	/// Gets the joined at.
 	/// </summary>
 	[JsonProperty("joined_at", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTime JoinedAt { get; internal set; }
 
 	/// <summary>
 	/// Whether this member is deafened.
 	/// </summary>
 	[JsonProperty("deaf", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsDeafened { get; internal set; }
 
 	/// <summary>
 	/// Whether this member is muted.
 	/// </summary>
 	[JsonProperty("mute", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsMuted { get; internal set; }
 
 	/// <summary>
 	/// Gets the premium since.
 	/// </summary>
 	[JsonProperty("premium_since", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTime? PremiumSince { get; internal set; }
 
 	/// <summary>
 	/// Whether this member is marked as pending.
 	/// </summary>
 	[JsonProperty("pending", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? IsPending { get; internal set; }
 
 	/// <summary>
 	/// Gets the timeout time.
 	/// </summary>
 	[JsonProperty("communication_disabled_until", NullValueHandling = NullValueHandling.Include)]
 	public DateTime? CommunicationDisabledUntil { get; internal set; }
 
 	/// <summary>
 	/// Gets the members flags.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public MemberFlags MemberFlags { get; internal set; }
 }
diff --git a/DisCatSharp/Net/Abstractions/Transport/TransportUser.cs b/DisCatSharp/Net/Abstractions/Transport/TransportUser.cs
index 4d342da07..3edd1cdc8 100644
--- a/DisCatSharp/Net/Abstractions/Transport/TransportUser.cs
+++ b/DisCatSharp/Net/Abstractions/Transport/TransportUser.cs
@@ -1,156 +1,163 @@
 // 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 Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions;
 
 /// <summary>
 /// Represents a transport user.
 /// </summary>
 internal class TransportUser
 {
 	/// <summary>
 	/// Gets the id.
 	/// </summary>
 	[JsonProperty("id")]
 	public ulong Id { get; internal set; }
 
 	/// <summary>
 	/// Gets the username.
 	/// </summary>
 	[JsonProperty("username", NullValueHandling = NullValueHandling.Ignore)]
 	public string Username { get; internal set; }
 
 	/// <summary>
 	/// Gets or sets the discriminator.
 	/// </summary>
 	[JsonProperty("discriminator", NullValueHandling = NullValueHandling.Ignore)]
 	internal string Discriminator { get; set; }
 
 	/// <summary>
 	/// Gets the username with discriminator.
 	/// </summary>
 	internal string UsernameWithDiscriminator
 		=> $"{this.Username}#{this.Discriminator}";
 
 	/// <summary>
 	/// Gets the avatar hash.
 	/// </summary>
 	[JsonProperty("avatar", NullValueHandling = NullValueHandling.Ignore)]
 	public string AvatarHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the banner hash.
 	/// </summary>
 	[JsonProperty("banner", NullValueHandling = NullValueHandling.Ignore)]
 	public string BannerHash { get; internal set; }
 
 	/// <summary>
 	/// Gets the banner color.
 	/// </summary>
 	[JsonProperty("accent_color")]
 	public int? BannerColor { get; internal set; }
 
 	/// <summary>
 	/// Gets a value indicating whether is bot.
 	/// </summary>
 	[JsonProperty("bot", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsBot { get; internal set; }
 
 	/// <summary>
 	/// Gets a value indicating whether mfa enabled.
 	/// </summary>
 	[JsonProperty("mfa_enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? MfaEnabled { get; internal set; }
 
 	/// <summary>
 	/// Gets a value indicating whether verified.
 	/// </summary>
 	[JsonProperty("verified", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Verified { get; internal set; }
 
 	/// <summary>
 	/// Gets the email.
 	/// </summary>
 	[JsonProperty("email", NullValueHandling = NullValueHandling.Ignore)]
 	public string Email { get; internal set; }
 
 	/// <summary>
 	/// Gets the premium type.
 	/// </summary>
 	[JsonProperty("premium_type", NullValueHandling = NullValueHandling.Ignore)]
 	public PremiumType? PremiumType { get; internal set; }
 
 	/// <summary>
 	/// Gets the locale.
 	/// </summary>
 	[JsonProperty("locale", NullValueHandling = NullValueHandling.Ignore)]
 	public string Locale { get; internal set; }
 
 	/// <summary>
 	/// Gets the OAuth flags.
 	/// </summary>
 	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
 	public UserFlags? OAuthFlags { get; internal set; }
 
 	/// <summary>
 	/// Gets the flags.
 	/// </summary>
 	[JsonProperty("public_flags", NullValueHandling = NullValueHandling.Ignore)]
 	public UserFlags? Flags { get; internal set; }
 
 	/// <summary>
 	/// Gets the users bio.
 	/// This is not available to bots tho.
 	/// </summary>
 	[JsonProperty("bio", NullValueHandling = NullValueHandling.Ignore)]
 	public string Bio { get; internal set; }
 
+	/// <summary>
+	/// Gets the users pronouns.
+	/// </summary>
+	[JsonProperty("pronouns", NullValueHandling = NullValueHandling.Ignore)]
+	public string Pronouns { get; internal set; }
+
 	/// <summary>
 	/// Initializes a new instance of the <see cref="TransportUser"/> class.
 	/// </summary>
 	internal TransportUser() { }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="TransportUser"/> class from an existing <see cref="TransportUser"/>.
 	/// </summary>
 	/// <param name="other">The other transport user.</param>
 	internal TransportUser(TransportUser other)
 	{
 		this.Id = other.Id;
 		this.Username = other.Username;
 		this.Discriminator = other.Discriminator;
 		this.AvatarHash = other.AvatarHash;
 		this.BannerHash = other.BannerHash;
 		this.BannerColor = other.BannerColor;
 		this.IsBot = other.IsBot;
 		this.MfaEnabled = other.MfaEnabled;
 		this.Verified = other.Verified;
 		this.Email = other.Email;
 		this.PremiumType = other.PremiumType;
 		this.Locale = other.Locale;
 		this.Flags = other.Flags;
 		this.OAuthFlags = other.OAuthFlags;
 		this.Bio = other.Bio;
+		this.Pronouns = other.Pronouns;
 	}
 }
diff --git a/DisCatSharp/Net/Models/ChannelEditModel.cs b/DisCatSharp/Net/Models/ChannelEditModel.cs
index ac3941657..b1a80cb40 100644
--- a/DisCatSharp/Net/Models/ChannelEditModel.cs
+++ b/DisCatSharp/Net/Models/ChannelEditModel.cs
@@ -1,119 +1,120 @@
 // 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.IO;
 
 using DisCatSharp.Entities;
+using DisCatSharp.Enums;
 
 namespace DisCatSharp.Net.Models;
 
 /// <summary>
 /// Represents a channel edit model.
 /// </summary>
 public class ChannelEditModel : BaseEditModel
 {
 	/// <summary>
 	/// Sets the channel's new name.
 	/// </summary>
 	public string Name { internal get; set; }
 
 	/// <summary>
 	/// Sets the channel's type.
 	/// This can only be used to convert between text and news channels.
 	/// </summary>
 	public Optional<ChannelType> Type { internal get; set; }
 
 	/// <summary>
 	/// Sets the channel's new position.
 	/// </summary>
 	public int? Position { internal get; set; }
 
 	/// <summary>
 	/// Sets the channel's new topic.
 	/// </summary>
 	public Optional<string> Topic { internal get; set; }
 
 	/// <summary>
 	/// Sets whether the channel is to be marked as NSFW.
 	/// </summary>
 	public bool? Nsfw { internal get; set; }
 
 	/// <summary>
 	/// <para>Sets the parent of this channel.</para>
 	/// <para>This should be channel with <see cref="DisCatSharp.Entities.DiscordChannel.Type"/> set to <see cref="ChannelType.Category"/>.</para>
 	/// </summary>
 	public Optional<DiscordChannel> Parent { internal get; set; }
 
 	/// <summary>
 	/// Sets the voice channel's new bitrate.
 	/// </summary>
 	public int? Bitrate { internal get; set; }
 
 	[Obsolete("Use properly capitalized UserLimit property.")]
 	public int? Userlimit { set => this.UserLimit = value; }
 
 	/// <summary>
 	/// <para>Sets the voice channel's new user limit.</para>
 	/// <para>Setting this to 0 will disable the user limit.</para>
 	/// </summary>
 	public int? UserLimit { internal get; set; }
 
 	/// <summary>
 	/// <para>Sets the channel's new slow mode timeout.</para>
 	/// <para>Setting this to null or 0 will disable slow mode.</para>
 	/// </summary>
 	public Optional<int?> PerUserRateLimit { internal get; set; }
 
 	/// <summary>
 	/// <para>Sets the voice channel's region override.</para>
 	/// <para>Setting this to null will set it to automatic.</para>
 	/// </summary>
 	public Optional<DiscordVoiceRegion> RtcRegion { internal get; set; }
 
 	/// <summary>
 	/// <para>Sets the voice channel's video quality.</para>
 	/// </summary>
 	public VideoQualityMode? QualityMode { internal get; set; }
 
 	/// <summary>
 	/// Sets this channel's default duration for newly created threads, in minutes, to automatically archive the thread after recent activity.
 	/// </summary>
 	public ThreadAutoArchiveDuration? DefaultAutoArchiveDuration { internal get; set; }
 
 	/// <summary>
 	/// Sets the channel's permission overwrites.
 	/// </summary>
 	public IEnumerable<DiscordOverwriteBuilder> PermissionOverwrites { internal get; set; }
 
 	/// <summary>
 	/// The new banner of the channel
 	/// </summary>
 	public Optional<Stream> Banner { get; set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="ChannelEditModel"/> class.
 	/// </summary>
 	internal ChannelEditModel()
 	{ }
 }
diff --git a/DisCatSharp/Net/Models/GuildEditModel.cs b/DisCatSharp/Net/Models/GuildEditModel.cs
index b25d2a3c7..ee5067d3e 100644
--- a/DisCatSharp/Net/Models/GuildEditModel.cs
+++ b/DisCatSharp/Net/Models/GuildEditModel.cs
@@ -1,134 +1,135 @@
 // 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.IO;
 
 using DisCatSharp.Entities;
+using DisCatSharp.Enums;
 
 namespace DisCatSharp.Net.Models;
 
 /// <summary>
 /// Represents a guild edit model.
 /// </summary>
 public class GuildEditModel : BaseEditModel
 {
 	/// <summary>
 	/// The new guild name.
 	/// </summary>
 	public Optional<string> Name { internal get; set; }
 
 	/// <summary>
 	/// The new guild icon.
 	/// </summary>
 	public Optional<Stream> Icon { internal get; set; }
 
 	/// <summary>
 	/// The new guild verification level.
 	/// </summary>
 	public Optional<VerificationLevel> VerificationLevel { internal get; set; }
 
 	/// <summary>
 	/// The new guild default message notification level.
 	/// </summary>
 	public Optional<DefaultMessageNotifications> DefaultMessageNotifications { internal get; set; }
 
 	/// <summary>
 	/// The new guild MFA level.
 	/// </summary>
 	public Optional<MfaLevel> MfaLevel { internal get; set; }
 
 	/// <summary>
 	/// The new guild explicit content filter level.
 	/// </summary>
 	public Optional<ExplicitContentFilter> ExplicitContentFilter { internal get; set; }
 
 	/// <summary>
 	/// The new AFK voice channel.
 	/// </summary>
 	public Optional<DiscordChannel> AfkChannel { internal get; set; }
 
 	/// <summary>
 	/// The new AFK timeout time in seconds.
 	/// </summary>
 	public Optional<int> AfkTimeout { internal get; set; }
 
 	/// <summary>
 	/// The new guild owner.
 	/// </summary>
 	public Optional<DiscordMember> Owner { internal get; set; }
 
 	/// <summary>
 	/// The new guild splash.
 	/// </summary>
 	public Optional<Stream> Splash { internal get; set; }
 
 	/// <summary>
 	/// The new guild system channel.
 	/// </summary>
 	public Optional<DiscordChannel> SystemChannel { internal get; set; }
 
 	/// <summary>
 	/// The guild system channel flags.
 	/// </summary>
 	public Optional<SystemChannelFlags> SystemChannelFlags { internal get; set; }
 
 	/// <summary>
 	/// The guild description.
 	/// </summary>
 	public Optional<string> Description { internal get; set; }
 
 	/// <summary>
 	/// The new guild rules channel.
 	/// </summary>
 	public Optional<DiscordChannel> RulesChannel { internal get; set; }
 
 	/// <summary>
 	/// The new guild public updates channel.
 	/// </summary>
 	public Optional<DiscordChannel> PublicUpdatesChannel { internal get; set; }
 
 	/// <summary>
 	/// The new guild preferred locale.
 	/// </summary>
 	public Optional<string> PreferredLocale { internal get; set; }
 
 	/// <summary>
 	/// The new banner of the guild
 	/// </summary>
 	public Optional<Stream> Banner { get; set; }
 
 	/// <summary>
 	/// The new discovery splash image of the guild
 	/// </summary>
 	public Optional<Stream> DiscoverySplash { get; set; }
 
 	/// <summary>
 	/// Whether the premium progress bar should be enabled
 	/// </summary>
 	public Optional<bool> PremiumProgressBarEnabled { get; set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="GuildEditModel"/> class.
 	/// </summary>
 	internal GuildEditModel()
 	{ }
 }
diff --git a/DisCatSharp/Net/Rest/DiscordApiClient.cs b/DisCatSharp/Net/Rest/DiscordApiClient.cs
index dfa8f2f17..3ac9e83ca 100644
--- a/DisCatSharp/Net/Rest/DiscordApiClient.cs
+++ b/DisCatSharp/Net/Rest/DiscordApiClient.cs
@@ -1,5267 +1,5314 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Net;
 using System.Text;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
+using DisCatSharp.Enums;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.Serialization;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp.Net;
 
 /// <summary>
 /// Represents a discord api client.
 /// </summary>
 public sealed class DiscordApiClient
 {
 	/// <summary>
 	/// The audit log reason header name.
 	/// </summary>
 	private const string REASON_HEADER_NAME = "X-Audit-Log-Reason";
 
 	/// <summary>
 	/// Gets the discord client.
 	/// </summary>
 	internal BaseDiscordClient Discord { get; }
 
 	/// <summary>
 	/// Gets the rest client.
 	/// </summary>
 	internal RestClient Rest { get; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordApiClient"/> class.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	internal DiscordApiClient(BaseDiscordClient client)
 	{
 		this.Discord = client;
 		this.Rest = new RestClient(client);
 	}
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordApiClient"/> class.
 	/// </summary>
 	/// <param name="proxy">The proxy.</param>
 	/// <param name="timeout">The timeout.</param>
 	/// <param name="useRelativeRateLimit">If true, use relative rate limit.</param>
 	/// <param name="logger">The logger.</param>
 	internal DiscordApiClient(IWebProxy proxy, TimeSpan timeout, bool useRelativeRateLimit, ILogger logger) // This is for meta-clients, such as the webhook client
 	{
 		this.Rest = new RestClient(proxy, timeout, useRelativeRateLimit, logger);
 	}
 
 	/// <summary>
 	/// Builds the query string.
 	/// </summary>
 	/// <param name="values">The values.</param>
 	/// <param name="post">Whether this query will be transmitted via POST.</param>
 	private static string BuildQueryString(IDictionary<string, string> values, bool post = false)
 	{
 		if (values == null || values.Count == 0)
 			return string.Empty;
 
 		var valsCollection = values.Select(xkvp =>
 			$"{WebUtility.UrlEncode(xkvp.Key)}={WebUtility.UrlEncode(xkvp.Value)}");
 		var vals = string.Join("&", valsCollection);
 
 		return !post ? $"?{vals}" : vals;
 	}
 
 	/// <summary>
 	/// Prepares the message.
 	/// </summary>
 	/// <param name="msgRaw">The msg_raw.</param>
 	/// <returns>A DiscordMessage.</returns>
 	private DiscordMessage PrepareMessage(JToken msgRaw)
 	{
 		var author = msgRaw["author"].ToObject<TransportUser>();
 		var ret = msgRaw.ToDiscordObject<DiscordMessage>();
 		ret.Discord = this.Discord;
 
 		this.PopulateMessage(author, ret);
 
 		var referencedMsg = msgRaw["referenced_message"];
 		if (ret.MessageType == MessageType.Reply && !string.IsNullOrWhiteSpace(referencedMsg?.ToString()))
 		{
 			author = referencedMsg["author"].ToObject<TransportUser>();
 			ret.ReferencedMessage.Discord = this.Discord;
 			this.PopulateMessage(author, ret.ReferencedMessage);
 		}
 
 		if (ret.Channel != null)
 			return ret;
 
 		var channel = !ret.GuildId.HasValue
 			? new DiscordDmChannel
 			{
 				Id = ret.ChannelId,
 				Discord = this.Discord,
 				Type = ChannelType.Private
 			}
 			: new DiscordChannel
 			{
 				Id = ret.ChannelId,
 				GuildId = ret.GuildId,
 				Discord = this.Discord
 			};
 
 		ret.Channel = channel;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Populates the message.
 	/// </summary>
 	/// <param name="author">The author.</param>
 	/// <param name="ret">The message.</param>
 	private void PopulateMessage(TransportUser author, DiscordMessage ret)
 	{
 		var guild = ret.Channel?.Guild;
 
 		//If this is a webhook, it shouldn't be in the user cache.
 		if (author.IsBot && int.Parse(author.Discriminator) == 0)
 		{
 			ret.Author = new DiscordUser(author) { Discord = this.Discord };
 		}
 		else
 		{
 			if (!this.Discord.UserCache.TryGetValue(author.Id, out var usr))
 			{
 				this.Discord.UserCache[author.Id] = usr = new DiscordUser(author) { Discord = this.Discord };
 			}
 
 			if (guild != null)
 			{
 				if (!guild.Members.TryGetValue(author.Id, out var mbr))
 					mbr = new DiscordMember(usr) { Discord = this.Discord, GuildId = guild.Id };
 				ret.Author = mbr;
 			}
 			else
 			{
 				ret.Author = usr;
 			}
 		}
 
 		ret.PopulateMentions();
 
 		if (ret.ReactionsInternal == null)
 			ret.ReactionsInternal = new List<DiscordReaction>();
 		foreach (var xr in ret.ReactionsInternal)
 			xr.Emoji.Discord = this.Discord;
 	}
 
 	/// <summary>
 	/// Executes a rest request.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="bucket">The bucket.</param>
 	/// <param name="url">The url.</param>
 	/// <param name="method">The method.</param>
 	/// <param name="route">The route.</param>
 	/// <param name="headers">The headers.</param>
 	/// <param name="payload">The payload.</param>
 	/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 	internal Task<RestResponse> DoRequestAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null, string payload = null, double? ratelimitWaitOverride = null)
 	{
 		var req = new RestRequest(client, bucket, url, method, route, headers, payload, ratelimitWaitOverride);
 
 		if (this.Discord != null)
 			this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 		else
 			_ = this.Rest.ExecuteRequestAsync(req);
 
 		return req.WaitForCompletionAsync();
 	}
 
 	/// <summary>
 	/// Executes a multipart rest request for stickers.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="bucket">The bucket.</param>
 	/// <param name="url">The url.</param>
 	/// <param name="method">The method.</param>
 	/// <param name="route">The route.</param>
 	/// <param name="headers">The headers.</param>
 	/// <param name="file">The file.</param>
 	/// <param name="name">The sticker name.</param>
 	/// <param name="tags">The sticker tag.</param>
 	/// <param name="description">The sticker description.</param>
 	/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 	private Task<RestResponse> DoStickerMultipartAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null,
 		DiscordMessageFile file = null, string name = "", string tags = "", string description = "", double? ratelimitWaitOverride = null)
 	{
 		var req = new MultipartStickerWebRequest(client, bucket, url, method, route, headers, file, name, tags, description, ratelimitWaitOverride);
 
 		if (this.Discord != null)
 			this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 		else
 			_ = this.Rest.ExecuteRequestAsync(req);
 
 		return req.WaitForCompletionAsync();
 	}
 
 	/// <summary>
 	/// Executes a multipart request.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="bucket">The bucket.</param>
 	/// <param name="url">The url.</param>
 	/// <param name="method">The method.</param>
 	/// <param name="route">The route.</param>
 	/// <param name="headers">The headers.</param>
 	/// <param name="values">The values.</param>
 	/// <param name="files">The files.</param>
 	/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
 	private Task<RestResponse> DoMultipartAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string> headers = null, IReadOnlyDictionary<string, string> values = null,
 		IReadOnlyCollection<DiscordMessageFile> files = null, double? ratelimitWaitOverride = null)
 	{
 		var req = new MultipartWebRequest(client, bucket, url, method, route, headers, values, files, ratelimitWaitOverride);
 
 		if (this.Discord != null)
 			this.Rest.ExecuteRequestAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing request");
 		else
 			_ = this.Rest.ExecuteRequestAsync(req);
 
 		return req.WaitForCompletionAsync();
 	}
 
 	#region Guild
 
 	/// <summary>
 	/// Searches the members async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="limit">The limit.</param>
 	internal async Task<IReadOnlyList<DiscordMember>> SearchMembersAsync(ulong guildId, string name, int? limit)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}{Endpoints.SEARCH}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 		var querydict = new Dictionary<string, string>
 		{
 			["query"] = name,
 			["limit"] = limit.ToString()
 		};
 		var url = Utilities.GetApiUriFor(path, BuildQueryString(querydict), this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 		var json = JArray.Parse(res.Response);
 		var tms = json.ToObject<IReadOnlyList<TransportMember>>();
 
 		var mbrs = new List<DiscordMember>();
 		foreach (var xtm in tms)
 		{
 			var usr = new DiscordUser(xtm.User) { Discord = this.Discord };
 
 			this.Discord.UserCache.AddOrUpdate(xtm.User.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discord = usr.Discord;
 				old.AvatarHash = usr.AvatarHash;
 
 				return old;
 			});
 
 			mbrs.Add(new DiscordMember(xtm) { Discord = this.Discord, GuildId = guildId });
 		}
 
 		return mbrs;
 	}
 
 	/// <summary>
 	/// Gets the guild ban async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	internal async Task<DiscordBan> GetGuildBanAsync(ulong guildId, ulong userId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, user_id = userId}, out var path);
 		var uri = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, uri, RestRequestMethod.GET, route).ConfigureAwait(false);
 		var json = JObject.Parse(res.Response);
 
 		var ban = json.ToObject<DiscordBan>();
 
 		return ban;
 	}
 
 	/// <summary>
 	/// Creates the guild async.
 	/// </summary>
 	/// <param name="name">The name.</param>
 	/// <param name="regionId">The region_id.</param>
 	/// <param name="iconb64">The iconb64.</param>
 	/// <param name="verificationLevel">The verification_level.</param>
 	/// <param name="defaultMessageNotifications">The default_message_notifications.</param>
 	/// <param name="systemChannelFlags">The system_channel_flags.</param>
 	internal async Task<DiscordGuild> CreateGuildAsync(string name, string regionId, Optional<string> iconb64, VerificationLevel? verificationLevel,
 		DefaultMessageNotifications? defaultMessageNotifications, SystemChannelFlags? systemChannelFlags)
 	{
 		var pld = new RestGuildCreatePayload
 		{
 			Name = name,
 			RegionId = regionId,
 			DefaultMessageNotifications = defaultMessageNotifications,
 			VerificationLevel = verificationLevel,
 			IconBase64 = iconb64,
 			SystemChannelFlags = systemChannelFlags
 
 		};
 
 		var route = $"{Endpoints.GUILDS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var json = JObject.Parse(res.Response);
 		var rawMembers = (JArray)json["members"];
 		var guild = json.ToDiscordObject<DiscordGuild>();
 
 		if (this.Discord is DiscordClient dc)
 			await dc.OnGuildCreateEventAsync(guild, rawMembers, null).ConfigureAwait(false);
 		return guild;
 	}
 
 	/// <summary>
 	/// Creates the guild from template async.
 	/// </summary>
 	/// <param name="templateCode">The template_code.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="iconb64">The iconb64.</param>
 	internal async Task<DiscordGuild> CreateGuildFromTemplateAsync(string templateCode, string name, Optional<string> iconb64)
 	{
 		var pld = new RestGuildCreateFromTemplatePayload
 		{
 			Name = name,
 			IconBase64 = iconb64
 		};
 
 		var route = $"{Endpoints.GUILDS}{Endpoints.TEMPLATES}/:template_code";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {template_code = templateCode }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var json = JObject.Parse(res.Response);
 		var rawMembers = (JArray)json["members"];
 		var guild = json.ToDiscordObject<DiscordGuild>();
 
 		if (this.Discord is DiscordClient dc)
 			await dc.OnGuildCreateEventAsync(guild, rawMembers, null).ConfigureAwait(false);
 		return guild;
 	}
 
 	/// <summary>
 	/// Deletes the guild async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	internal async Task DeleteGuildAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route).ConfigureAwait(false);
 
 		if (this.Discord is DiscordClient dc)
 		{
 			var gld = dc.GuildsInternal[guildId];
 			await dc.OnGuildDeleteEventAsync(gld).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Modifies the guild.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="verificationLevel">The verification level.</param>
 	/// <param name="defaultMessageNotifications">The default message notifications.</param>
 	/// <param name="mfaLevel">The mfa level.</param>
 	/// <param name="explicitContentFilter">The explicit content filter.</param>
 	/// <param name="afkChannelId">The afk channel id.</param>
 	/// <param name="afkTimeout">The afk timeout.</param>
 	/// <param name="iconb64">The iconb64.</param>
 	/// <param name="ownerId">The owner id.</param>
 	/// <param name="splashb64">The splashb64.</param>
 	/// <param name="systemChannelId">The system channel id.</param>
 	/// <param name="systemChannelFlags">The system channel flags.</param>
 	/// <param name="publicUpdatesChannelId">The public updates channel id.</param>
 	/// <param name="rulesChannelId">The rules channel id.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="bannerb64">The banner base64.</param>
 	/// <param name="discoverySplashb64">The discovery base64.</param>
 	/// <param name="preferredLocale">The preferred locale.</param>
 	/// <param name="premiumProgressBarEnabled">Whether the premium progress bar should be enabled.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task<DiscordGuild> ModifyGuildAsync(ulong guildId, Optional<string> name, Optional<VerificationLevel> verificationLevel,
 		Optional<DefaultMessageNotifications> defaultMessageNotifications, Optional<MfaLevel> mfaLevel,
 		Optional<ExplicitContentFilter> explicitContentFilter, Optional<ulong?> afkChannelId,
 		Optional<int> afkTimeout, Optional<string> iconb64, Optional<ulong> ownerId, Optional<string> splashb64,
 		Optional<ulong?> systemChannelId, Optional<SystemChannelFlags> systemChannelFlags,
 		Optional<ulong?> publicUpdatesChannelId, Optional<ulong?> rulesChannelId, Optional<string> description,
 		Optional<string> bannerb64, Optional<string> discoverySplashb64, Optional<string> preferredLocale, Optional<bool> premiumProgressBarEnabled, string reason)
 	{
 		var pld = new RestGuildModifyPayload
 		{
 			Name = name,
 			VerificationLevel = verificationLevel,
 			DefaultMessageNotifications = defaultMessageNotifications,
 			MfaLevel = mfaLevel,
 			ExplicitContentFilter = explicitContentFilter,
 			AfkChannelId = afkChannelId,
 			AfkTimeout = afkTimeout,
 			IconBase64 = iconb64,
 			SplashBase64 = splashb64,
 			BannerBase64 = bannerb64,
 			DiscoverySplashBase64 = discoverySplashb64,
 			OwnerId = ownerId,
 			SystemChannelId = systemChannelId,
 			SystemChannelFlags = systemChannelFlags,
 			RulesChannelId = rulesChannelId,
 			PublicUpdatesChannelId = publicUpdatesChannelId,
 			PreferredLocale = preferredLocale,
 			Description = description,
 			PremiumProgressBarEnabled = premiumProgressBarEnabled
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var json = JObject.Parse(res.Response);
 		var rawMembers = (JArray)json["members"];
 		var guild = json.ToDiscordObject<DiscordGuild>();
 		foreach (var r in guild.RolesInternal.Values)
 			r.GuildId = guild.Id;
 
 		if (this.Discord is DiscordClient dc)
 			await dc.OnGuildUpdateEventAsync(guild, rawMembers).ConfigureAwait(false);
 		return guild;
 	}
 
 
 
 	/// <summary>
 	/// Modifies the guild community settings.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="features">The guild features.</param>
 	/// <param name="rulesChannelId">The rules channel id.</param>
 	/// <param name="publicUpdatesChannelId">The public updates channel id.</param>
 	/// <param name="preferredLocale">The preferred locale.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="defaultMessageNotifications">The default message notifications.</param>
 	/// <param name="explicitContentFilter">The explicit content filter.</param>
 	/// <param name="verificationLevel">The verification level.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task<DiscordGuild> ModifyGuildCommunitySettingsAsync(ulong guildId, List<string> features, Optional<ulong?> rulesChannelId, Optional<ulong?> publicUpdatesChannelId, string preferredLocale, string description, DefaultMessageNotifications defaultMessageNotifications, ExplicitContentFilter explicitContentFilter, VerificationLevel verificationLevel, string reason)
 	{
 		var pld = new RestGuildCommunityModifyPayload
 		{
 			VerificationLevel = verificationLevel,
 			DefaultMessageNotifications = defaultMessageNotifications,
 			ExplicitContentFilter = explicitContentFilter,
 			RulesChannelId = rulesChannelId,
 			PublicUpdatesChannelId = publicUpdatesChannelId,
 			PreferredLocale = preferredLocale,
 			Description = Optional.FromNullable(description),
 			Features = features
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var json = JObject.Parse(res.Response);
 		var rawMembers = (JArray)json["members"];
 		var guild = json.ToDiscordObject<DiscordGuild>();
 		foreach (var r in guild.RolesInternal.Values)
 			r.GuildId = guild.Id;
 
 		if (this.Discord is DiscordClient dc)
 			await dc.OnGuildUpdateEventAsync(guild, rawMembers).ConfigureAwait(false);
 		return guild;
 	}
 
+	/// <summary>
+	/// Enables the guilds mfa requirement.
+	/// </summary>
+	/// <param name="guildId">The guild id.</param>
+	/// <param name="reason">The reason.</param>
+	internal async Task EnableGuildMfaAsync(ulong guildId, string reason)
+	{
+		var pld = new RestGuildMfaLevelModifyPayload
+		{
+			Level = MfaLevel.Enabled
+		};
+
+		var headers = Utilities.GetBaseHeaders();
+		if (!string.IsNullOrWhiteSpace(reason))
+			headers.Add(REASON_HEADER_NAME, reason);
+
+		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MFA}";
+		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id = guildId }, out var path);
+
+		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
+		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
+	}
+
+	/// <summary>
+	/// Disables the guilds mfa requirement.
+	/// </summary>
+	/// <param name="guildId">The guild id.</param>
+	/// <param name="reason">The reason.</param>
+	internal async Task DisableGuildMfaAsync(ulong guildId, string reason)
+	{
+		var pld = new RestGuildMfaLevelModifyPayload
+		{
+			Level = MfaLevel.Disabled
+		};
+
+		var headers = Utilities.GetBaseHeaders();
+		if (!string.IsNullOrWhiteSpace(reason))
+			headers.Add(REASON_HEADER_NAME, reason);
+
+		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MFA}";
+		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { guild_id = guildId }, out var path);
+
+		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
+		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
+	}
+
 	/// <summary>
 	/// Implements https://discord.com/developers/docs/resources/guild#get-guild-bans.
 	/// </summary>
 	internal async Task<IReadOnlyList<DiscordBan>> GetGuildBansAsync(ulong guildId, int? limit, ulong? before, ulong? after)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var urlParams = new Dictionary<string, string>();
 		if (limit != null)
 			urlParams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 		if (before != null)
 			urlParams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 		if (after != null)
 			urlParams["after"] = after.Value.ToString(CultureInfo.InvariantCulture);
 
 		var url = Utilities.GetApiUriFor(path, BuildQueryString(urlParams), this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var bansRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordBan>>(res.Response).Select(xb =>
 		{
 			if (!this.Discord.TryGetCachedUserInternal(xb.RawUser.Id, out var usr))
 			{
 				usr = new DiscordUser(xb.RawUser) { Discord = this.Discord };
 				usr = this.Discord.UserCache.AddOrUpdate(usr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
 			}
 
 			xb.User = usr;
 			return xb;
 		});
 		var bans = new ReadOnlyCollection<DiscordBan>(new List<DiscordBan>(bansRaw));
 
 		return bans;
 	}
 
 	/// <summary>
 	/// Creates the guild ban async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="deleteMessageDays">The delete_message_days.</param>
 	/// <param name="reason">The reason.</param>
 	internal Task CreateGuildBanAsync(ulong guildId, ulong userId, int deleteMessageDays, string reason)
 	{
 		if (deleteMessageDays < 0 || deleteMessageDays > 7)
 			throw new ArgumentException("Delete message days must be a number between 0 and 7.", nameof(deleteMessageDays));
 
 		var urlParams = new Dictionary<string, string>
 		{
 			["delete_message_days"] = deleteMessageDays.ToString(CultureInfo.InvariantCulture)
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, BuildQueryString(urlParams), this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers);
 	}
 
 	/// <summary>
 	/// Removes the guild ban async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="reason">The reason.</param>
 	internal Task RemoveGuildBanAsync(ulong guildId, ulong userId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.BANS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Leaves the guild async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal Task LeaveGuildAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.GUILDS}/:guild_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	/// <summary>
 	/// Adds the guild member async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="accessToken">The access_token.</param>
 	/// <param name="nick">The nick.</param>
 	/// <param name="roles">The roles.</param>
 	/// <param name="muted">If true, muted.</param>
 	/// <param name="deafened">If true, deafened.</param>
 
 	internal async Task<DiscordMember> AddGuildMemberAsync(ulong guildId, ulong userId, string accessToken, string nick, IEnumerable<DiscordRole> roles, bool muted, bool deafened)
 	{
 		var pld = new RestGuildMemberAddPayload
 		{
 			AccessToken = accessToken,
 			Nickname = nick ?? "",
 			Roles = roles ?? new List<DiscordRole>(),
 			Deaf = deafened,
 			Mute = muted
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var tm = JsonConvert.DeserializeObject<TransportMember>(res.Response);
 
 		return new DiscordMember(tm) { Discord = this.Discord, GuildId = guildId };
 	}
 
 	/// <summary>
 	/// Lists the guild members async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="limit">The limit.</param>
 	/// <param name="after">The after.</param>
 
 	internal async Task<IReadOnlyList<TransportMember>> ListGuildMembersAsync(ulong guildId, int? limit, ulong? after)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (limit != null && limit > 0)
 			urlParams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 		if (after != null)
 			urlParams["after"] = after.Value.ToString(CultureInfo.InvariantCulture);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var membersRaw = JsonConvert.DeserializeObject<List<TransportMember>>(res.Response);
 		return new ReadOnlyCollection<TransportMember>(membersRaw);
 	}
 
 	/// <summary>
 	/// Adds the guild member role async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="roleId">The role_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task AddGuildMemberRoleAsync(ulong guildId, ulong userId, ulong roleId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id{Endpoints.ROLES}/:role_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, user_id = userId, role_id = roleId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers);
 	}
 
 	/// <summary>
 	/// Removes the guild member role async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="roleId">The role_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task RemoveGuildMemberRoleAsync(ulong guildId, ulong userId, ulong roleId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id{Endpoints.ROLES}/:role_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, user_id = userId, role_id = roleId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Modifies the guild channel position async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="pld">The pld.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task ModifyGuildChannelPositionAsync(ulong guildId, IEnumerable<RestGuildChannelReorderPayload> pld, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Modifies the guild channel parent async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="pld">The pld.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task ModifyGuildChannelParentAsync(ulong guildId, IEnumerable<RestGuildChannelNewParentPayload> pld, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Detaches the guild channel parent async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="pld">The pld.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DetachGuildChannelParentAsync(ulong guildId, IEnumerable<RestGuildChannelNoParentPayload> pld, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Modifies the guild role position async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="pld">The pld.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task ModifyGuildRolePositionAsync(ulong guildId, IEnumerable<RestGuildRoleReorderPayload> pld, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Gets the audit logs async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="limit">The limit.</param>
 	/// <param name="after">The after.</param>
 	/// <param name="before">The before.</param>
 	/// <param name="responsible">The responsible.</param>
 	/// <param name="actionType">The action_type.</param>
 
 	internal async Task<AuditLog> GetAuditLogsAsync(ulong guildId, int limit, ulong? after, ulong? before, ulong? responsible, int? actionType)
 	{
 		var urlParams = new Dictionary<string, string>
 		{
 			["limit"] = limit.ToString(CultureInfo.InvariantCulture)
 		};
 		if (after != null)
 			urlParams["after"] = after?.ToString(CultureInfo.InvariantCulture);
 		if (before != null)
 			urlParams["before"] = before?.ToString(CultureInfo.InvariantCulture);
 		if (responsible != null)
 			urlParams["user_id"] = responsible?.ToString(CultureInfo.InvariantCulture);
 		if (actionType != null)
 			urlParams["action_type"] = actionType?.ToString(CultureInfo.InvariantCulture);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.AUDIT_LOGS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var auditLogDataRaw = JsonConvert.DeserializeObject<AuditLog>(res.Response);
 
 		return auditLogDataRaw;
 	}
 
 	/// <summary>
 	/// Gets the guild vanity url async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<DiscordInvite> GetGuildVanityUrlAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VANITY_URL}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var invite = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 
 		return invite;
 	}
 
 	/// <summary>
 	/// Gets the guild widget async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<DiscordWidget> GetGuildWidgetAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET_JSON}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var json = JObject.Parse(res.Response);
 		var rawChannels = (JArray)json["channels"];
 
 		var ret = json.ToDiscordObject<DiscordWidget>();
 		ret.Discord = this.Discord;
 		ret.Guild = this.Discord.Guilds[guildId];
 
 		ret.Channels = ret.Guild == null
 			? rawChannels.Select(r => new DiscordChannel
 			{
 				Id = (ulong)r["id"],
 				Name = r["name"].ToString(),
 				Position = (int)r["position"]
 			}).ToList()
 			: rawChannels.Select(r =>
 			{
 				var c = ret.Guild.GetChannel((ulong)r["id"]);
 				c.Position = (int)r["position"];
 				return c;
 			}).ToList();
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets the guild widget settings async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<DiscordWidgetSettings> GetGuildWidgetSettingsAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWidgetSettings>(res.Response);
 		ret.Guild = this.Discord.Guilds[guildId];
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies the guild widget settings async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="isEnabled">If true, is enabled.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordWidgetSettings> ModifyGuildWidgetSettingsAsync(ulong guildId, bool? isEnabled, ulong? channelId, string reason)
 	{
 		var pld = new RestGuildWidgetSettingsPayload
 		{
 			Enabled = isEnabled,
 			ChannelId = channelId
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WIDGET}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWidgetSettings>(res.Response);
 		ret.Guild = this.Discord.Guilds[guildId];
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets the guild templates async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordGuildTemplate>> GetGuildTemplatesAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var templatesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildTemplate>>(res.Response);
 
 		return new ReadOnlyCollection<DiscordGuildTemplate>(new List<DiscordGuildTemplate>(templatesRaw));
 	}
 
 	/// <summary>
 	/// Creates the guild template async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="description">The description.</param>
 
 	internal async Task<DiscordGuildTemplate> CreateGuildTemplateAsync(ulong guildId, string name, string description)
 	{
 		var pld = new RestGuildTemplateCreateOrModifyPayload
 		{
 			Name = name,
 			Description = description
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Syncs the guild template async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="templateCode">The template_code.</param>
 
 	internal async Task<DiscordGuildTemplate> SyncGuildTemplateAsync(ulong guildId, string templateCode)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {guild_id = guildId, template_code = templateCode }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route).ConfigureAwait(false);
 
 		var templateRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 		return templateRaw;
 	}
 
 	/// <summary>
 	/// Modifies the guild template async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="templateCode">The template_code.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="description">The description.</param>
 
 	internal async Task<DiscordGuildTemplate> ModifyGuildTemplateAsync(ulong guildId, string templateCode, string name, string description)
 	{
 		var pld = new RestGuildTemplateCreateOrModifyPayload
 		{
 			Name = name,
 			Description = description
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, template_code = templateCode }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var templateRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 		return templateRaw;
 	}
 
 	/// <summary>
 	/// Deletes the guild template async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="templateCode">The template_code.</param>
 
 	internal async Task<DiscordGuildTemplate> DeleteGuildTemplateAsync(ulong guildId, string templateCode)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.TEMPLATES}/:template_code";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, template_code = templateCode }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route).ConfigureAwait(false);
 
 		var templateRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 		return templateRaw;
 	}
 
 	/// <summary>
 	/// Gets the guild membership screening form async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<DiscordGuildMembershipScreening> GetGuildMembershipScreeningFormAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBER_VERIFICATION}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var screeningRaw = JsonConvert.DeserializeObject<DiscordGuildMembershipScreening>(res.Response);
 
 		return screeningRaw;
 	}
 
 	/// <summary>
 	/// Modifies the guild membership screening form async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="enabled">The enabled.</param>
 	/// <param name="fields">The fields.</param>
 	/// <param name="description">The description.</param>
 
 	internal async Task<DiscordGuildMembershipScreening> ModifyGuildMembershipScreeningFormAsync(ulong guildId, Optional<bool> enabled, Optional<DiscordGuildMembershipScreeningField[]> fields, Optional<string> description)
 	{
 		var pld = new RestGuildMembershipScreeningFormModifyPayload
 		{
 			Enabled = enabled,
 			Description = description,
 			Fields = fields
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBER_VERIFICATION}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var screeningRaw = JsonConvert.DeserializeObject<DiscordGuildMembershipScreening>(res.Response);
 
 		return screeningRaw;
 	}
 
 	/// <summary>
 	/// Gets the guild welcome screen async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<DiscordGuildWelcomeScreen> GetGuildWelcomeScreenAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WELCOME_SCREEN}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var ret = JsonConvert.DeserializeObject<DiscordGuildWelcomeScreen>(res.Response);
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies the guild welcome screen async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="enabled">The enabled.</param>
 	/// <param name="welcomeChannels">The welcome channels.</param>
 	/// <param name="description">The description.</param>
 
 	internal async Task<DiscordGuildWelcomeScreen> ModifyGuildWelcomeScreenAsync(ulong guildId, Optional<bool> enabled, Optional<IEnumerable<DiscordGuildWelcomeScreenChannel>> welcomeChannels, Optional<string> description)
 	{
 		var pld = new RestGuildWelcomeScreenModifyPayload
 		{
 			Enabled = enabled,
 			WelcomeChannels = welcomeChannels,
 			Description = description
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WELCOME_SCREEN}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 		var ret = JsonConvert.DeserializeObject<DiscordGuildWelcomeScreen>(res.Response);
 		return ret;
 	}
 
 	/// <summary>
 	/// Updates the current user voice state async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="suppress">If true, suppress.</param>
 	/// <param name="requestToSpeakTimestamp">The request to speak timestamp.</param>
 
 	internal async Task UpdateCurrentUserVoiceStateAsync(ulong guildId, ulong channelId, bool? suppress, DateTimeOffset? requestToSpeakTimestamp)
 	{
 		var pld = new RestGuildUpdateCurrentUserVoiceStatePayload
 		{
 			ChannelId = channelId,
 			Suppress = suppress,
 			RequestToSpeakTimestamp = requestToSpeakTimestamp
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VOICE_STATES}/@me";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Updates the user voice state async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="suppress">If true, suppress.</param>
 
 	internal async Task UpdateUserVoiceStateAsync(ulong guildId, ulong userId, ulong channelId, bool? suppress)
 	{
 		var pld = new RestGuildUpdateUserVoiceStatePayload
 		{
 			ChannelId = channelId,
 			Suppress = suppress
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.VOICE_STATES}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 	}
 	#endregion
 
 	#region Guild Scheduled Events
 
 	/// <summary>
 	/// Creates a scheduled event.
 	/// </summary>
 	internal async Task<DiscordScheduledEvent> CreateGuildScheduledEventAsync(ulong guildId, ulong? channelId, DiscordScheduledEventEntityMetadata metadata, string name, DateTimeOffset scheduledStartTime, DateTimeOffset? scheduledEndTime, string description, ScheduledEventEntityType type, Optional<string> coverb64, string reason = null)
 	{
 		var pld = new RestGuildScheduledEventCreatePayload
 		{
 			ChannelId = channelId,
 			EntityMetadata = metadata,
 			Name = name,
 			ScheduledStartTime = scheduledStartTime,
 			ScheduledEndTime = scheduledEndTime,
 			Description = description,
 			EntityType = type,
 			CoverBase64 = coverb64
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
 		var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 		var guild = this.Discord.Guilds[guildId];
 
 		scheduledEvent.Discord = this.Discord;
 
 		if (scheduledEvent.Creator != null)
 			scheduledEvent.Creator.Discord = this.Discord;
 
 		if (this.Discord is DiscordClient dc)
 			await dc.OnGuildScheduledEventCreateEventAsync(scheduledEvent, guild);
 
 		return scheduledEvent;
 	}
 
 	/// <summary>
 	/// Modifies a scheduled event.
 	/// </summary>
 	internal async Task<DiscordScheduledEvent> ModifyGuildScheduledEventAsync(ulong guildId, ulong scheduledEventId, Optional<ulong?> channelId, Optional<DiscordScheduledEventEntityMetadata> metadata, Optional<string> name, Optional<DateTimeOffset> scheduledStartTime, Optional<DateTimeOffset> scheduledEndTime, Optional<string> description, Optional<ScheduledEventEntityType> type, Optional<ScheduledEventStatus> status, Optional<string> coverb64, string reason = null)
 	{
 		var pld = new RestGuildScheduledEventModifyPayload
 		{
 			ChannelId = channelId,
 			EntityMetadata = metadata,
 			Name = name,
 			ScheduledStartTime = scheduledStartTime,
 			ScheduledEndTime = scheduledEndTime,
 			Description = description,
 			EntityType = type,
 			Status = status,
 			CoverBase64 = coverb64
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 
 		var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 		var guild = this.Discord.Guilds[guildId];
 
 		scheduledEvent.Discord = this.Discord;
 
 		if (scheduledEvent.Creator != null)
 		{
 			scheduledEvent.Creator.Discord = this.Discord;
 			this.Discord.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 			{
 				old.Username = scheduledEvent.Creator.Username;
 				old.Discriminator = scheduledEvent.Creator.Discriminator;
 				old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 				old.Flags = scheduledEvent.Creator.Flags;
 				return old;
 			});
 		}
 
 		if (this.Discord is DiscordClient dc)
 			await dc.OnGuildScheduledEventUpdateEventAsync(scheduledEvent, guild);
 
 		return scheduledEvent;
 	}
 
 	/// <summary>
 	/// Modifies a scheduled event.
 	/// </summary>
 	internal async Task<DiscordScheduledEvent> ModifyGuildScheduledEventStatusAsync(ulong guildId, ulong scheduledEventId, ScheduledEventStatus status, string reason = null)
 	{
 		var pld = new RestGuildScheduledEventModifyPayload
 		{
 			Status = status
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 
 		var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 		var guild = this.Discord.Guilds[guildId];
 
 		scheduledEvent.Discord = this.Discord;
 
 		if (scheduledEvent.Creator != null)
 		{
 			scheduledEvent.Creator.Discord = this.Discord;
 			this.Discord.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 			{
 				old.Username = scheduledEvent.Creator.Username;
 				old.Discriminator = scheduledEvent.Creator.Discriminator;
 				old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 				old.Flags = scheduledEvent.Creator.Flags;
 				return old;
 			});
 		}
 
 		if (this.Discord is DiscordClient dc)
 			await dc.OnGuildScheduledEventUpdateEventAsync(scheduledEvent, guild);
 
 		return scheduledEvent;
 	}
 
 	/// <summary>
 	/// Gets a scheduled event.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="scheduledEventId">The event id.</param>
 	/// <param name="withUserCount">Whether to include user count.</param>
 	internal async Task<DiscordScheduledEvent> GetGuildScheduledEventAsync(ulong guildId, ulong scheduledEventId, bool? withUserCount)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (withUserCount.HasValue)
 			urlParams["with_user_count"] = withUserCount?.ToString();
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var scheduledEvent = JsonConvert.DeserializeObject<DiscordScheduledEvent>(res.Response);
 		var guild = this.Discord.Guilds[guildId];
 
 		scheduledEvent.Discord = this.Discord;
 
 		if (scheduledEvent.Creator != null)
 		{
 			scheduledEvent.Creator.Discord = this.Discord;
 			this.Discord.UserCache.AddOrUpdate(scheduledEvent.Creator.Id, scheduledEvent.Creator, (id, old) =>
 			{
 				old.Username = scheduledEvent.Creator.Username;
 				old.Discriminator = scheduledEvent.Creator.Discriminator;
 				old.AvatarHash = scheduledEvent.Creator.AvatarHash;
 				old.Flags = scheduledEvent.Creator.Flags;
 				return old;
 			});
 		}
 
 		return scheduledEvent;
 	}
 
 	/// <summary>
 	/// Gets the guilds scheduled events.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="withUserCount">Whether to include the count of users subscribed to the scheduled event.</param>
 	internal async Task<IReadOnlyDictionary<ulong, DiscordScheduledEvent>> ListGuildScheduledEventsAsync(ulong guildId, bool? withUserCount)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (withUserCount.HasValue)
 			urlParams["with_user_count"] = withUserCount?.ToString();
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var events = new Dictionary<ulong, DiscordScheduledEvent>();
 		var eventsRaw = JsonConvert.DeserializeObject<List<DiscordScheduledEvent>>(res.Response);
 		var guild = this.Discord.Guilds[guildId];
 
 		foreach (var ev in eventsRaw)
 		{
 			ev.Discord = this.Discord;
 			if (ev.Creator != null)
 			{
 				ev.Creator.Discord = this.Discord;
 				this.Discord.UserCache.AddOrUpdate(ev.Creator.Id, ev.Creator, (id, old) =>
 				{
 					old.Username = ev.Creator.Username;
 					old.Discriminator = ev.Creator.Discriminator;
 					old.AvatarHash = ev.Creator.AvatarHash;
 					old.Flags = ev.Creator.Flags;
 					return old;
 				});
 			}
 
 			events.Add(ev.Id, ev);
 		}
 
 		return new ReadOnlyDictionary<ulong, DiscordScheduledEvent>(new Dictionary<ulong, DiscordScheduledEvent>(events));
 	}
 
 	/// <summary>
 	/// Deletes a guild scheduled event.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="scheduledEventId">The scheduled event id.</param>
 	/// <param name="reason">The reason.</param>
 	internal Task DeleteGuildScheduledEventAsync(ulong guildId, ulong scheduledEventId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Gets the users who RSVP'd to a scheduled event.
 	/// Optional with member objects.
 	/// This endpoint is paginated.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="scheduledEventId">The scheduled event id.</param>
 	/// <param name="limit">The limit how many users to receive from the event.</param>
 	/// <param name="before">Get results before the given id.</param>
 	/// <param name="after">Get results after the given id.</param>
 	/// <param name="withMember">Whether to include guild member data. attaches guild_member property to the user object.</param>
 	internal async Task<IReadOnlyDictionary<ulong, DiscordScheduledEventUser>> GetGuildScheduledEventRspvUsersAsync(ulong guildId, ulong scheduledEventId, int? limit, ulong? before, ulong? after, bool? withMember)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (limit != null && limit > 0)
 			urlParams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 		if (before != null)
 			urlParams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 		if (after != null)
 			urlParams["after"] = after.Value.ToString(CultureInfo.InvariantCulture);
 		if (withMember != null)
 			urlParams["with_member"] = withMember.Value.ToString(CultureInfo.InvariantCulture);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.SCHEDULED_EVENTS}/:scheduled_event_id{Endpoints.USERS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, scheduled_event_id = scheduledEventId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var rspvUsers = JsonConvert.DeserializeObject<IEnumerable<DiscordScheduledEventUser>>(res.Response);
 		Dictionary<ulong, DiscordScheduledEventUser> rspv = new();
 
 		foreach (var rspvUser in rspvUsers)
 		{
 
 			rspvUser.Discord = this.Discord;
 			rspvUser.GuildId = guildId;
 
 			rspvUser.User.Discord = this.Discord;
 			rspvUser.User = this.Discord.UserCache.AddOrUpdate(rspvUser.User.Id, rspvUser.User, (id, old) =>
 			{
 				old.Username = rspvUser.User.Username;
 				old.Discriminator = rspvUser.User.Discriminator;
 				old.AvatarHash = rspvUser.User.AvatarHash;
 				old.BannerHash = rspvUser.User.BannerHash;
 				old.BannerColorInternal = rspvUser.User.BannerColorInternal;
 				return old;
 			});
 
 			/*if (with_member.HasValue && with_member.Value && rspv_user.Member != null)
                 {
                     rspv_user.Member.Discord = this.Discord;
                 }*/
 
 			rspv.Add(rspvUser.User.Id, rspvUser);
 		}
 
 		return new ReadOnlyDictionary<ulong, DiscordScheduledEventUser>(new Dictionary<ulong, DiscordScheduledEventUser>(rspv));
 	}
 	#endregion
 
 	#region Channel
 	/// <summary>
 	/// Creates the guild channel async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="type">The type.</param>
 	/// <param name="parent">The parent.</param>
 	/// <param name="topic">The topic.</param>
 	/// <param name="bitrate">The bitrate.</param>
 	/// <param name="userLimit">The user_limit.</param>
 	/// <param name="overwrites">The overwrites.</param>
 	/// <param name="nsfw">If true, nsfw.</param>
 	/// <param name="perUserRateLimit">The per user rate limit.</param>
 	/// <param name="qualityMode">The quality mode.</param>
 	/// <param name="defaultAutoArchiveDuration">The default auto archive duration.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task<DiscordChannel> CreateGuildChannelAsync(ulong guildId, string name, ChannelType type, ulong? parent, Optional<string> topic, int? bitrate, int? userLimit, IEnumerable<DiscordOverwriteBuilder> overwrites, bool? nsfw, Optional<int?> perUserRateLimit, VideoQualityMode? qualityMode, ThreadAutoArchiveDuration? defaultAutoArchiveDuration, string reason)
 	{
 		var restOverwrites = new List<DiscordRestOverwrite>();
 		if (overwrites != null)
 			foreach (var ow in overwrites)
 				restOverwrites.Add(ow.Build());
 
 		var pld = new RestChannelCreatePayload
 		{
 			Name = name,
 			Type = type,
 			Parent = parent,
 			Topic = topic,
 			Bitrate = bitrate,
 			UserLimit = userLimit,
 			PermissionOverwrites = restOverwrites,
 			Nsfw = nsfw,
 			PerUserRateLimit = perUserRateLimit,
 			QualityMode = qualityMode,
 			DefaultAutoArchiveDuration = defaultAutoArchiveDuration
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
 		ret.Discord = this.Discord;
 		foreach (var xo in ret.PermissionOverwritesInternal)
 		{
 			xo.Discord = this.Discord;
 			xo.ChannelId = ret.Id;
 		}
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies the channel async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="position">The position.</param>
 	/// <param name="topic">The topic.</param>
 	/// <param name="nsfw">If true, nsfw.</param>
 	/// <param name="parent">The parent.</param>
 	/// <param name="bitrate">The bitrate.</param>
 	/// <param name="userLimit">The user_limit.</param>
 	/// <param name="perUserRateLimit">The per user rate limit.</param>
 	/// <param name="rtcRegion">The rtc region.</param>
 	/// <param name="qualityMode">The quality mode.</param>
 	/// <param name="autoArchiveDuration">The default auto archive duration.</param>
 	/// <param name="type">The type.</param>
 	/// <param name="permissionOverwrites">The permission overwrites.</param>
 	/// <param name="bannerb64">The banner.</param>
 	/// <param name="reason">The reason.</param>
 	internal Task ModifyChannelAsync(ulong channelId, string name, int? position, Optional<string> topic, bool? nsfw, Optional<ulong?> parent, int? bitrate, int? userLimit, Optional<int?> perUserRateLimit, Optional<string> rtcRegion, VideoQualityMode? qualityMode, ThreadAutoArchiveDuration? autoArchiveDuration, Optional<ChannelType> type, IEnumerable<DiscordOverwriteBuilder> permissionOverwrites, Optional<string> bannerb64, string reason)
 	{
 
 		List<DiscordRestOverwrite> restoverwrites = null;
 		if (permissionOverwrites != null)
 		{
 			restoverwrites = new List<DiscordRestOverwrite>();
 			foreach (var ow in permissionOverwrites)
 				restoverwrites.Add(ow.Build());
 		}
 
 		var pld = new RestChannelModifyPayload
 		{
 			Name = name,
 			Position = position,
 			Topic = topic,
 			Nsfw = nsfw,
 			Parent = parent,
 			Bitrate = bitrate,
 			UserLimit = userLimit,
 			PerUserRateLimit = perUserRateLimit,
 			RtcRegion = rtcRegion,
 			QualityMode = qualityMode,
 			DefaultAutoArchiveDuration = autoArchiveDuration,
 			Type = type,
 			PermissionOverwrites = restoverwrites,
 			BannerBase64 = bannerb64
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Gets the channel async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 
 	internal async Task<DiscordChannel> GetChannelAsync(ulong channelId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
 		ret.Discord = this.Discord;
 		foreach (var xo in ret.PermissionOverwritesInternal)
 		{
 			xo.Discord = this.Discord;
 			xo.ChannelId = ret.Id;
 		}
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the channel async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteChannelAsync(ulong channelId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Gets the message async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 
 	internal async Task<DiscordMessage> GetMessageAsync(ulong channelId, ulong messageId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Creates the message async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="content">The content.</param>
 	/// <param name="embeds">The embeds.</param>
 	/// <param name="sticker">The sticker.</param>
 	/// <param name="replyMessageId">The reply message id.</param>
 	/// <param name="mentionReply">If true, mention reply.</param>
 	/// <param name="failOnInvalidReply">If true, fail on invalid reply.</param>
 
 	internal async Task<DiscordMessage> CreateMessageAsync(ulong channelId, string content, IEnumerable<DiscordEmbed> embeds, DiscordSticker sticker, ulong? replyMessageId, bool mentionReply, bool failOnInvalidReply)
 	{
 		if (content != null && content.Length > 2000)
 			throw new ArgumentException("Message content length cannot exceed 2000 characters.");
 
 		if (!embeds?.Any() ?? true)
 		{
 			if (content == null && sticker == null)
 				throw new ArgumentException("You must specify message content, a sticker or an embed.");
 			if (content.Length == 0)
 				throw new ArgumentException("Message content must not be empty.");
 		}
 
 		if (embeds != null)
 			foreach (var embed in embeds)
 				if (embed.Timestamp != null)
 					embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 		var pld = new RestChannelMessageCreatePayload
 		{
 			HasContent = content != null,
 			Content = content,
 			StickersIds = sticker is null ? Array.Empty<ulong>() : new[] {sticker.Id},
 			IsTts = false,
 			HasEmbed = embeds?.Any() ?? false,
 			Embeds = embeds
 		};
 
 		if (replyMessageId != null)
 			pld.MessageReference = new InternalDiscordMessageReference { MessageId = replyMessageId, FailIfNotExists = failOnInvalidReply };
 
 		if (replyMessageId != null)
 			pld.Mentions = new DiscordMentions(Mentions.All, true, mentionReply);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Creates the message async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="builder">The builder.</param>
 
 	internal async Task<DiscordMessage> CreateMessageAsync(ulong channelId, DiscordMessageBuilder builder)
 	{
 		builder.Validate();
 
 		if (builder.Embeds != null)
 			foreach (var embed in builder.Embeds)
 				if (embed?.Timestamp != null)
 					embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 		var pld = new RestChannelMessageCreatePayload
 		{
 			HasContent = builder.Content != null,
 			Content = builder.Content,
 			StickersIds = builder.Sticker is null ? Array.Empty<ulong>() : new[] {builder.Sticker.Id},
 			IsTts = builder.IsTts,
 			HasEmbed = builder.Embeds != null,
 			Embeds = builder.Embeds,
 			Components = builder.Components
 		};
 
 		if (builder.ReplyId != null)
 			pld.MessageReference = new InternalDiscordMessageReference { MessageId = builder.ReplyId, FailIfNotExists = builder.FailOnInvalidReply };
 
 		pld.Mentions = new DiscordMentions(builder.Mentions ?? Mentions.All, builder.Mentions?.Any() ?? false, builder.MentionOnReply);
 
 		if (builder.Files.Count == 0)
 		{
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = this.PrepareMessage(JObject.Parse(res.Response));
 			return ret;
 		}
 		else
 		{
 			ulong fileId = 0;
 			List<DiscordAttachment> attachments = new(builder.Files.Count);
 			foreach (var file in builder.Files)
 			{
 				DiscordAttachment att = new()
 				{
 					Id = fileId,
 					Discord = this.Discord,
 					Description = file.Description,
 					FileName = file.FileName
 				};
 				attachments.Add(att);
 				fileId++;
 			}
 			pld.Attachments = attachments;
 
 			var values = new Dictionary<string, string>
 			{
 				["payload_json"] = DiscordJson.SerializeObject(pld)
 			};
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 
 			var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 			foreach (var file in builder.FilesInternal.Where(x => x.ResetPositionTo.HasValue))
 			{
 				file.Stream.Position = file.ResetPositionTo.Value;
 			}
 
 			return ret;
 		}
 	}
 
 	/// <summary>
 	/// Gets the guild channels async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordChannel>> GetGuildChannelsAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.CHANNELS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var channelsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordChannel>>(res.Response).Select(xc => { xc.Discord = this.Discord; return xc; });
 
 		foreach (var ret in channelsRaw)
 			foreach (var xo in ret.PermissionOverwritesInternal)
 			{
 				xo.Discord = this.Discord;
 				xo.ChannelId = ret.Id;
 			}
 
 		return new ReadOnlyCollection<DiscordChannel>(new List<DiscordChannel>(channelsRaw));
 	}
 
 	/// <summary>
 	/// Creates the stage instance async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="topic">The topic.</param>
 	/// <param name="sendStartNotification">Whether everyone should be notified about the stage.</param>
 	/// <param name="privacyLevel">The privacy_level.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task<DiscordStageInstance> CreateStageInstanceAsync(ulong channelId, string topic, bool sendStartNotification, StagePrivacyLevel privacyLevel, string reason)
 	{
 		var pld = new RestStageInstanceCreatePayload
 		{
 			ChannelId = channelId,
 			Topic = topic,
 			PrivacyLevel = privacyLevel,
 			SendStartNotification = sendStartNotification
 		};
 
 		var route = $"{Endpoints.STAGE_INSTANCES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var stageInstance = JsonConvert.DeserializeObject<DiscordStageInstance>(res.Response);
 
 		return stageInstance;
 	}
 
 	/// <summary>
 	/// Gets the stage instance async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	internal async Task<DiscordStageInstance> GetStageInstanceAsync(ulong channelId)
 	{
 		var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var stageInstance = JsonConvert.DeserializeObject<DiscordStageInstance>(res.Response);
 
 		return stageInstance;
 	}
 
 	/// <summary>
 	/// Modifies the stage instance async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="topic">The topic.</param>
 	/// <param name="privacyLevel">The privacy_level.</param>
 	/// <param name="reason">The reason.</param>
 	internal Task ModifyStageInstanceAsync(ulong channelId, Optional<string> topic, Optional<StagePrivacyLevel> privacyLevel, string reason)
 	{
 		var pld = new RestStageInstanceModifyPayload
 		{
 			Topic = topic,
 			PrivacyLevel = privacyLevel
 		};
 
 		var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId }, out var path);
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Deletes the stage instance async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="reason">The reason.</param>
 	internal Task DeleteStageInstanceAsync(ulong channelId, string reason)
 	{
 		var route = $"{Endpoints.STAGE_INSTANCES}/:channel_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId }, out var path);
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Gets the channel messages async.
 	/// </summary>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="limit">The limit.</param>
 	/// <param name="before">The before.</param>
 	/// <param name="after">The after.</param>
 	/// <param name="around">The around.</param>
 
 	internal async Task<IReadOnlyList<DiscordMessage>> GetChannelMessagesAsync(ulong channelId, int limit, ulong? before, ulong? after, ulong? around)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (around != null)
 			urlParams["around"] = around?.ToString(CultureInfo.InvariantCulture);
 		if (before != null)
 			urlParams["before"] = before?.ToString(CultureInfo.InvariantCulture);
 		if (after != null)
 			urlParams["after"] = after?.ToString(CultureInfo.InvariantCulture);
 		if (limit > 0)
 			urlParams["limit"] = limit.ToString(CultureInfo.InvariantCulture);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var msgsRaw = JArray.Parse(res.Response);
 		var msgs = new List<DiscordMessage>();
 		foreach (var xj in msgsRaw)
 			msgs.Add(this.PrepareMessage(xj));
 
 		return new ReadOnlyCollection<DiscordMessage>(new List<DiscordMessage>(msgs));
 	}
 
 	/// <summary>
 	/// Gets the channel message async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 
 	internal async Task<DiscordMessage> GetChannelMessageAsync(ulong channelId, ulong messageId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Edits the message async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="content">The content.</param>
 	/// <param name="embeds">The embeds.</param>
 	/// <param name="mentions">The mentions.</param>
 	/// <param name="components">The components.</param>
 	/// <param name="suppressEmbed">The suppress_embed.</param>
 	/// <param name="files">The files.</param>
 	/// <param name="attachments">The attachments to keep.</param>
 
 	internal async Task<DiscordMessage> EditMessageAsync(ulong channelId, ulong messageId, Optional<string> content, Optional<IEnumerable<DiscordEmbed>> embeds, Optional<IEnumerable<IMention>> mentions, IReadOnlyList<DiscordActionRowComponent> components, Optional<bool> suppressEmbed, IReadOnlyCollection<DiscordMessageFile> files, Optional<IEnumerable<DiscordAttachment>> attachments)
 	{
 		if (embeds.HasValue && embeds.Value != null)
 			foreach (var embed in embeds.Value)
 				if (embed.Timestamp != null)
 					embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 		var pld = new RestChannelMessageEditPayload
 		{
 			HasContent = content.HasValue,
 			Content = content.ValueOrDefault(),
 			HasEmbed = embeds.HasValue && (embeds.Value?.Any() ?? false),
 			Embeds = embeds.HasValue && (embeds.Value?.Any() ?? false) ? embeds.Value : null,
 			Components = components,
 			Flags = suppressEmbed.HasValue && (bool)suppressEmbed ? MessageFlags.SuppressedEmbeds : null,
 			Mentions = mentions
 			.Map(m => new DiscordMentions(m ?? Mentions.None, false, mentions.Value?.OfType<RepliedUserMention>().Any() ?? false))
 			.ValueOrDefault()
 		};
 
 		if (files?.Count > 0)
 		{
 			ulong fileId = 0;
 			List<DiscordAttachment> attachmentsNew = new();
 			foreach (var file in files)
 			{
 				DiscordAttachment att = new()
 				{
 					Id = fileId,
 					Discord = this.Discord,
 					Description = file.Description,
 					FileName = file.FileName
 				};
 				attachmentsNew.Add(att);
 				fileId++;
 			}
 			if (attachments.HasValue && attachments.Value.Any())
 				attachmentsNew.AddRange(attachments.Value);
 
 			pld.Attachments = attachmentsNew;
 
 			var values = new Dictionary<string, string>
 			{
 				["payload_json"] = DiscordJson.SerializeObject(pld)
 			};
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: files).ConfigureAwait(false);
 
 			var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 			foreach (var file in files.Where(x => x.ResetPositionTo.HasValue))
 			{
 				file.Stream.Position = file.ResetPositionTo.Value;
 			}
 
 			return ret;
 		}
 		else
 		{
 			pld.Attachments = attachments.ValueOrDefault();
 
 			var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 			var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 			var ret = this.PrepareMessage(JObject.Parse(res.Response));
 
 			return ret;
 		}
 	}
 
 	/// <summary>
 	/// Deletes the message async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteMessageAsync(ulong channelId, ulong messageId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Deletes the messages async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageIds">The message_ids.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteMessagesAsync(ulong channelId, IEnumerable<ulong> messageIds, string reason)
 	{
 		var pld = new RestChannelMessageBulkDeletePayload
 		{
 			Messages = messageIds
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}{Endpoints.BULK_DELETE}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Gets the channel invites async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordInvite>> GetChannelInvitesAsync(ulong channelId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.INVITES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var invitesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordInvite>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 		return new ReadOnlyCollection<DiscordInvite>(new List<DiscordInvite>(invitesRaw));
 	}
 
 	/// <summary>
 	/// Creates the channel invite async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="maxAge">The max_age.</param>
 	/// <param name="maxUses">The max_uses.</param>
 	/// <param name="targetType">The target_type.</param>
 	/// <param name="targetApplication">The target_application.</param>
 	/// <param name="targetUser">The target_user.</param>
 	/// <param name="temporary">If true, temporary.</param>
 	/// <param name="unique">If true, unique.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordInvite> CreateChannelInviteAsync(ulong channelId, int maxAge, int maxUses, TargetType? targetType, TargetActivity? targetApplication, ulong? targetUser, bool temporary, bool unique, string reason)
 	{
 		var pld = new RestChannelInviteCreatePayload
 		{
 			MaxAge = maxAge,
 			MaxUses = maxUses,
 			TargetType = targetType,
 			TargetApplication = targetApplication,
 			TargetUserId = targetUser,
 			Temporary = temporary,
 			Unique = unique
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.INVITES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the channel permission async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="overwriteId">The overwrite_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteChannelPermissionAsync(ulong channelId, ulong overwriteId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PERMISSIONS}/:overwrite_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, overwrite_id = overwriteId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Edits the channel permissions async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="overwriteId">The overwrite_id.</param>
 	/// <param name="allow">The allow.</param>
 	/// <param name="deny">The deny.</param>
 	/// <param name="type">The type.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task EditChannelPermissionsAsync(ulong channelId, ulong overwriteId, Permissions allow, Permissions deny, string type, string reason)
 	{
 		var pld = new RestChannelPermissionEditPayload
 		{
 			Type = type,
 			Allow = allow & PermissionMethods.FullPerms,
 			Deny = deny & PermissionMethods.FullPerms
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PERMISSIONS}/:overwrite_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, overwrite_id = overwriteId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers, DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Triggers the typing async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 
 	internal Task TriggerTypingAsync(ulong channelId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.TYPING}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route);
 	}
 
 	/// <summary>
 	/// Gets the pinned messages async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordMessage>> GetPinnedMessagesAsync(ulong channelId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var msgsRaw = JArray.Parse(res.Response);
 		var msgs = new List<DiscordMessage>();
 		foreach (var xj in msgsRaw)
 			msgs.Add(this.PrepareMessage(xj));
 
 		return new ReadOnlyCollection<DiscordMessage>(new List<DiscordMessage>(msgs));
 	}
 
 	/// <summary>
 	/// Pins the message async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 
 	internal Task PinMessageAsync(ulong channelId, ulong messageId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}/:message_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
 	}
 
 	/// <summary>
 	/// Unpins the message async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 
 	internal Task UnpinMessageAsync(ulong channelId, ulong messageId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.PINS}/:message_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	/// <summary>
 	/// Adds the group dm recipient async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="accessToken">The access_token.</param>
 	/// <param name="nickname">The nickname.</param>
 
 	internal Task AddGroupDmRecipientAsync(ulong channelId, ulong userId, string accessToken, string nickname)
 	{
 		var pld = new RestChannelGroupDmRecipientAddPayload
 		{
 			AccessToken = accessToken,
 			Nickname = nickname
 		};
 
 		var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}/:channel_id{Endpoints.RECIPIENTS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Removes the group dm recipient async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="userId">The user_id.</param>
 
 	internal Task RemoveGroupDmRecipientAsync(ulong channelId, ulong userId)
 	{
 		var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}/:channel_id{Endpoints.RECIPIENTS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	/// <summary>
 	/// Creates the group dm async.
 	/// </summary>
 	/// <param name="accessTokens">The access_tokens.</param>
 	/// <param name="nicks">The nicks.</param>
 
 	internal async Task<DiscordDmChannel> CreateGroupDmAsync(IEnumerable<string> accessTokens, IDictionary<ulong, string> nicks)
 	{
 		var pld = new RestUserGroupDmCreatePayload
 		{
 			AccessTokens = accessTokens,
 			Nicknames = nicks
 		};
 
 		var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordDmChannel>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Creates the dm async.
 	/// </summary>
 	/// <param name="recipientId">The recipient_id.</param>
 
 	internal async Task<DiscordDmChannel> CreateDmAsync(ulong recipientId)
 	{
 		var pld = new RestUserDmCreatePayload
 		{
 			Recipient = recipientId
 		};
 
 		var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CHANNELS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordDmChannel>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Follows the channel async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="webhookChannelId">The webhook_channel_id.</param>
 
 	internal async Task<DiscordFollowedChannel> FollowChannelAsync(ulong channelId, ulong webhookChannelId)
 	{
 		var pld = new FollowedChannelAddPayload
 		{
 			WebhookChannelId = webhookChannelId
 		};
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.FOLLOWERS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var response = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		return JsonConvert.DeserializeObject<DiscordFollowedChannel>(response.Response);
 	}
 
 	/// <summary>
 	/// Crossposts the message async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 
 	internal async Task<DiscordMessage> CrosspostMessageAsync(ulong channelId, ulong messageId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.CROSSPOST}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var response = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route).ConfigureAwait(false);
 		return JsonConvert.DeserializeObject<DiscordMessage>(response.Response);
 	}
 
 	#endregion
 
 	#region Member
 	/// <summary>
 	/// Gets the current user async.
 	/// </summary>
 
 	internal Task<DiscordUser> GetCurrentUserAsync()
 		=> this.GetUserAsync("@me");
 
 	/// <summary>
 	/// Gets the user async.
 	/// </summary>
 	/// <param name="userId">The user_id.</param>
 
 	internal Task<DiscordUser> GetUserAsync(ulong userId)
 		=> this.GetUserAsync(userId.ToString(CultureInfo.InvariantCulture));
 
 	/// <summary>
 	/// Gets the user async.
 	/// </summary>
 	/// <param name="userId">The user_id.</param>
 
 	internal async Task<DiscordUser> GetUserAsync(string userId)
 	{
 		var route = $"{Endpoints.USERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var userRaw = JsonConvert.DeserializeObject<TransportUser>(res.Response);
 		var duser = new DiscordUser(userRaw) { Discord = this.Discord };
 
 		return duser;
 	}
 
 	/// <summary>
 	/// Gets the guild member async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 
 	internal async Task<DiscordMember> GetGuildMemberAsync(ulong guildId, ulong userId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var tm = JsonConvert.DeserializeObject<TransportMember>(res.Response);
 
 		var usr = new DiscordUser(tm.User) { Discord = this.Discord };
 		usr = this.Discord.UserCache.AddOrUpdate(tm.User.Id, usr, (id, old) =>
 		{
 			old.Username = usr.Username;
 			old.Discriminator = usr.Discriminator;
 			old.AvatarHash = usr.AvatarHash;
 			return old;
 		});
 
 		return new DiscordMember(tm)
 		{
 			Discord = this.Discord,
 			GuildId = guildId
 		};
 	}
 
 	/// <summary>
 	/// Removes the guild member async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task RemoveGuildMemberAsync(ulong guildId, ulong userId, string reason)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (reason != null)
 			urlParams["reason"] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, BuildQueryString(urlParams), this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	/// <summary>
 	/// Modifies the current user async.
 	/// </summary>
 	/// <param name="username">The username.</param>
 	/// <param name="base64Avatar">The base64_avatar.</param>
 
 	internal async Task<TransportUser> ModifyCurrentUserAsync(string username, Optional<string> base64Avatar)
 	{
 		var pld = new RestUserUpdateCurrentPayload
 		{
 			Username = username,
 			AvatarBase64 = base64Avatar.ValueOrDefault(),
 			AvatarSet = base64Avatar.HasValue
 		};
 
 		var route = $"{Endpoints.USERS}{Endpoints.ME}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var userRaw = JsonConvert.DeserializeObject<TransportUser>(res.Response);
 
 		return userRaw;
 	}
 
 	/// <summary>
 	/// Gets the current user guilds async.
 	/// </summary>
 	/// <param name="limit">The limit.</param>
 	/// <param name="before">The before.</param>
 	/// <param name="after">The after.</param>
 
 	internal async Task<IReadOnlyList<DiscordGuild>> GetCurrentUserGuildsAsync(int limit = 100, ulong? before = null, ulong? after = null)
 	{
 		var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.GUILDS}";
 
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration)
 			.AddParameter($"limit", limit.ToString(CultureInfo.InvariantCulture));
 
 		if (before != null)
 			url.AddParameter("before", before.Value.ToString(CultureInfo.InvariantCulture));
 		if (after != null)
 			url.AddParameter("after", after.Value.ToString(CultureInfo.InvariantCulture));
 
 		var res = await this.DoRequestAsync(this.Discord, bucket, url.Build(), RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		if (this.Discord is DiscordClient)
 		{
 			var guildsRaw = JsonConvert.DeserializeObject<IEnumerable<RestUserGuild>>(res.Response);
 			var glds = guildsRaw.Select(xug => (this.Discord as DiscordClient)?.GuildsInternal[xug.Id]);
 			return new ReadOnlyCollection<DiscordGuild>(new List<DiscordGuild>(glds));
 		}
 		else
 		{
 			return new ReadOnlyCollection<DiscordGuild>(JsonConvert.DeserializeObject<List<DiscordGuild>>(res.Response));
 		}
 	}
 
 	/// <summary>
 	/// Modifies the guild member async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="nick">The nick.</param>
 	/// <param name="roleIds">The role_ids.</param>
 	/// <param name="mute">The mute.</param>
 	/// <param name="deaf">The deaf.</param>
 	/// <param name="voiceChannelId">The voice_channel_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task ModifyGuildMemberAsync(ulong guildId, ulong userId, Optional<string> nick,
 		Optional<IEnumerable<ulong>> roleIds, Optional<bool> mute, Optional<bool> deaf,
 		Optional<ulong?> voiceChannelId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var pld = new RestGuildMemberModifyPayload
 		{
 			Nickname = nick,
 			RoleIds = roleIds,
 			Deafen = deaf,
 			Mute = mute,
 			VoiceChannelId = voiceChannelId
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Modifies the time out of a guild member.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="until">Datetime offset.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task ModifyTimeoutAsync(ulong guildId, ulong userId, DateTimeOffset? until, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var pld = new RestGuildMemberTimeoutModifyPayload
 		{
 			CommunicationDisabledUntil = until
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Modifies the current member nickname async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="nick">The nick.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task ModifyCurrentMemberNicknameAsync(ulong guildId, string nick, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var pld = new RestGuildMemberModifyPayload
 		{
 			Nickname = nick
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.MEMBERS}{Endpoints.ME}{Endpoints.NICK}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, payload: DiscordJson.SerializeObject(pld));
 	}
 	#endregion
 
 	#region Roles
 	/// <summary>
 	/// Gets the guild roles async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordRole>> GetGuildRolesAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var rolesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordRole>>(res.Response).Select(xr => { xr.Discord = this.Discord; xr.GuildId = guildId; return xr; });
 
 		return new ReadOnlyCollection<DiscordRole>(new List<DiscordRole>(rolesRaw));
 	}
 
 	/// <summary>
 	/// Gets the guild async.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="withCounts">If true, with_counts.</param>
 
 	internal async Task<DiscordGuild> GetGuildAsync(ulong guildId, bool? withCounts)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (withCounts.HasValue)
 			urlParams["with_counts"] = withCounts?.ToString();
 
 		var route = $"{Endpoints.GUILDS}/:guild_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route, urlParams).ConfigureAwait(false);
 
 		var json = JObject.Parse(res.Response);
 		var rawMembers = (JArray)json["members"];
 		var guildRest = json.ToDiscordObject<DiscordGuild>();
 		foreach (var r in guildRest.RolesInternal.Values)
 			r.GuildId = guildRest.Id;
 
 		if (this.Discord is DiscordClient dc)
 		{
 			await dc.OnGuildUpdateEventAsync(guildRest, rawMembers).ConfigureAwait(false);
 			return dc.GuildsInternal[guildRest.Id];
 		}
 		else
 		{
 			guildRest.Discord = this.Discord;
 			return guildRest;
 		}
 	}
 
 	/// <summary>
 	/// Modifies the guild role async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="roleId">The role_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="permissions">The permissions.</param>
 	/// <param name="color">The color.</param>
 	/// <param name="hoist">If true, hoist.</param>
 	/// <param name="mentionable">If true, mentionable.</param>
 	/// <param name="iconb64">The icon.</param>
 	/// <param name="emoji">The unicode emoji icon.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task<DiscordRole> ModifyGuildRoleAsync(ulong guildId, ulong roleId, string name, Permissions? permissions, int? color, bool? hoist, bool? mentionable, Optional<string> iconb64, Optional<string> emoji, string reason)
 	{
 		var pld = new RestGuildRolePayload
 		{
 			Name = name,
 			Permissions = permissions & PermissionMethods.FullPerms,
 			Color = color,
 			Hoist = hoist,
 			Mentionable = mentionable,
 		};
 
 		if (emoji.HasValue && !iconb64.HasValue)
 			pld.UnicodeEmoji = emoji;
 
 		if (emoji.HasValue && iconb64.HasValue)
 		{
 			pld.IconBase64 = null;
 			pld.UnicodeEmoji = emoji;
 		}
 
 		if (iconb64.HasValue)
 			pld.IconBase64 = iconb64;
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}/:role_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, role_id = roleId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordRole>(res.Response);
 		ret.Discord = this.Discord;
 		ret.GuildId = guildId;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the role async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="roleId">The role_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteRoleAsync(ulong guildId, ulong roleId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}/:role_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, role_id = roleId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Creates the guild role async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="permissions">The permissions.</param>
 	/// <param name="color">The color.</param>
 	/// <param name="hoist">If true, hoist.</param>
 	/// <param name="mentionable">If true, mentionable.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordRole> CreateGuildRoleAsync(ulong guildId, string name, Permissions? permissions, int? color, bool? hoist, bool? mentionable, string reason)
 	{
 		var pld = new RestGuildRolePayload
 		{
 			Name = name,
 			Permissions = permissions & PermissionMethods.FullPerms,
 			Color = color,
 			Hoist = hoist,
 			Mentionable = mentionable
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.ROLES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordRole>(res.Response);
 		ret.Discord = this.Discord;
 		ret.GuildId = guildId;
 
 		return ret;
 	}
 	#endregion
 
 	#region Prune
 	/// <summary>
 	/// Gets the guild prune count async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="days">The days.</param>
 	/// <param name="includeRoles">The include_roles.</param>
 
 	internal async Task<int> GetGuildPruneCountAsync(ulong guildId, int days, IEnumerable<ulong> includeRoles)
 	{
 		if (days < 0 || days > 30)
 			throw new ArgumentException("Prune inactivity days must be a number between 0 and 30.", nameof(days));
 
 		var urlParams = new Dictionary<string, string>
 		{
 			["days"] = days.ToString(CultureInfo.InvariantCulture)
 		};
 
 		var sb = includeRoles?.Aggregate(new StringBuilder(),
 					 (sb, id) => sb.Append($"&include_roles={id}"))
 				 ?? new StringBuilder();
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PRUNE}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 		var url = Utilities.GetApiUriFor(path, $"{BuildQueryString(urlParams)}{sb}", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var pruned = JsonConvert.DeserializeObject<RestGuildPruneResultPayload>(res.Response);
 
 		return pruned.Pruned.Value;
 	}
 
 	/// <summary>
 	/// Begins the guild prune async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="days">The days.</param>
 	/// <param name="computePruneCount">If true, compute_prune_count.</param>
 	/// <param name="includeRoles">The include_roles.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<int?> BeginGuildPruneAsync(ulong guildId, int days, bool computePruneCount, IEnumerable<ulong> includeRoles, string reason)
 	{
 		if (days < 0 || days > 30)
 			throw new ArgumentException("Prune inactivity days must be a number between 0 and 30.", nameof(days));
 
 		var urlParams = new Dictionary<string, string>
 		{
 			["days"] = days.ToString(CultureInfo.InvariantCulture),
 			["compute_prune_count"] = computePruneCount.ToString()
 		};
 
 		var sb = includeRoles?.Aggregate(new StringBuilder(),
 					 (sb, id) => sb.Append($"&include_roles={id}"))
 				 ?? new StringBuilder();
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PRUNE}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, $"{BuildQueryString(urlParams)}{sb}", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers).ConfigureAwait(false);
 
 		var pruned = JsonConvert.DeserializeObject<RestGuildPruneResultPayload>(res.Response);
 
 		return pruned.Pruned;
 	}
 	#endregion
 
 	#region GuildVarious
 	/// <summary>
 	/// Gets the template async.
 	/// </summary>
 	/// <param name="code">The code.</param>
 
 	internal async Task<DiscordGuildTemplate> GetTemplateAsync(string code)
 	{
 		var route = $"{Endpoints.GUILDS}{Endpoints.TEMPLATES}/:code";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { code }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var templatesRaw = JsonConvert.DeserializeObject<DiscordGuildTemplate>(res.Response);
 
 		return templatesRaw;
 	}
 
 	/// <summary>
 	/// Gets the guild integrations async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordIntegration>> GetGuildIntegrationsAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var integrationsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordIntegration>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 		return new ReadOnlyCollection<DiscordIntegration>(new List<DiscordIntegration>(integrationsRaw));
 	}
 
 	/// <summary>
 	/// Gets the guild preview async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<DiscordGuildPreview> GetGuildPreviewAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.PREVIEW}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordGuildPreview>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Creates the guild integration async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="type">The type.</param>
 	/// <param name="id">The id.</param>
 
 	internal async Task<DiscordIntegration> CreateGuildIntegrationAsync(ulong guildId, string type, ulong id)
 	{
 		var pld = new RestGuildIntegrationAttachPayload
 		{
 			Type = type,
 			Id = id
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordIntegration>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies the guild integration async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="integrationId">The integration_id.</param>
 	/// <param name="expireBehaviour">The expire_behaviour.</param>
 	/// <param name="expireGracePeriod">The expire_grace_period.</param>
 	/// <param name="enableEmoticons">If true, enable_emoticons.</param>
 
 	internal async Task<DiscordIntegration> ModifyGuildIntegrationAsync(ulong guildId, ulong integrationId, int expireBehaviour, int expireGracePeriod, bool enableEmoticons)
 	{
 		var pld = new RestGuildIntegrationModifyPayload
 		{
 			ExpireBehavior = expireBehaviour,
 			ExpireGracePeriod = expireGracePeriod,
 			EnableEmoticons = enableEmoticons
 		};
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, integration_id = integrationId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordIntegration>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the guild integration async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="integration">The integration.</param>
 
 	internal Task DeleteGuildIntegrationAsync(ulong guildId, DiscordIntegration integration)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, integration_id = integration.Id }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, payload: DiscordJson.SerializeObject(integration));
 	}
 
 	/// <summary>
 	/// Syncs the guild integration async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="integrationId">The integration_id.</param>
 
 	internal Task SyncGuildIntegrationAsync(ulong guildId, ulong integrationId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INTEGRATIONS}/:integration_id{Endpoints.SYNC}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId, integration_id = integrationId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route);
 	}
 
 	/// <summary>
 	/// Gets the guild voice regions async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordVoiceRegion>> GetGuildVoiceRegionsAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.REGIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var regionsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordVoiceRegion>>(res.Response);
 
 		return new ReadOnlyCollection<DiscordVoiceRegion>(new List<DiscordVoiceRegion>(regionsRaw));
 	}
 
 	/// <summary>
 	/// Gets the guild invites async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordInvite>> GetGuildInvitesAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.INVITES}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var invitesRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordInvite>>(res.Response).Select(xi => { xi.Discord = this.Discord; return xi; });
 
 		return new ReadOnlyCollection<DiscordInvite>(new List<DiscordInvite>(invitesRaw));
 	}
 	#endregion
 
 	#region Invite
 	/// <summary>
 	/// Gets the invite async.
 	/// </summary>
 	/// <param name="inviteCode">The invite_code.</param>
 	/// <param name="withCounts">If true, with_counts.</param>
 	/// <param name="withExpiration">If true, with_expiration.</param>
 	/// <param name="guildScheduledEventId">The scheduled event id to get.</param>
 
 	internal async Task<DiscordInvite> GetInviteAsync(string inviteCode, bool? withCounts, bool? withExpiration, ulong? guildScheduledEventId)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (withCounts.HasValue)
 			urlParams["with_counts"] = withCounts?.ToString();
 		if (withExpiration.HasValue)
 			urlParams["with_expiration"] = withExpiration?.ToString();
 		if (guildScheduledEventId.HasValue)
 			urlParams["guild_scheduled_event_id"] = guildScheduledEventId?.ToString();
 
 		var route = $"{Endpoints.INVITES}/:invite_code";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {invite_code = inviteCode }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the invite async.
 	/// </summary>
 	/// <param name="inviteCode">The invite_code.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordInvite> DeleteInviteAsync(string inviteCode, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.INVITES}/:invite_code";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {invite_code = inviteCode }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/*
          * Disabled due to API restrictions
          *
          * internal async Task<DiscordInvite> InternalAcceptInvite(string invite_code)
          * {
          *     this.Discord.DebugLogger.LogMessage(LogLevel.Warning, "REST API", "Invite accept endpoint was used; this account is now likely unverified", DateTime.Now);
          *
          *     var url = new Uri($"{Utils.GetApiBaseUri(this.Configuration), Endpoints.INVITES}/{invite_code));
          *     var bucket = this.Rest.GetBucket(0, MajorParameterType.Unbucketed, url, HttpRequestMethod.POST);
          *     var res = await this.DoRequestAsync(this.Discord, bucket, url, HttpRequestMethod.POST).ConfigureAwait(false);
          *
          *     var ret = JsonConvert.DeserializeObject<DiscordInvite>(res.Response);
          *     ret.Discord = this.Discord;
          *
          *     return ret;
          * }
          */
 	#endregion
 
 	#region Connections
 	/// <summary>
 	/// Gets the users connections async.
 	/// </summary>
 
 	internal async Task<IReadOnlyList<DiscordConnection>> GetUserConnectionsAsync()
 	{
 		var route = $"{Endpoints.USERS}{Endpoints.ME}{Endpoints.CONNECTIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var connectionsRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordConnection>>(res.Response).Select(xc => { xc.Discord = this.Discord; return xc; });
 
 		return new ReadOnlyCollection<DiscordConnection>(new List<DiscordConnection>(connectionsRaw));
 	}
 	#endregion
 
 	#region Voice
 	/// <summary>
 	/// Lists the voice regions async.
 	/// </summary>
 
 	internal async Task<IReadOnlyList<DiscordVoiceRegion>> ListVoiceRegionsAsync()
 	{
 		var route = $"{Endpoints.VOICE}{Endpoints.REGIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var regions = JsonConvert.DeserializeObject<IEnumerable<DiscordVoiceRegion>>(res.Response);
 
 		return new ReadOnlyCollection<DiscordVoiceRegion>(new List<DiscordVoiceRegion>(regions));
 	}
 	#endregion
 
 	#region Webhooks
 	/// <summary>
 	/// Creates the webhook async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="base64Avatar">The base64_avatar.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordWebhook> CreateWebhookAsync(ulong channelId, string name, Optional<string> base64Avatar, string reason)
 	{
 		var pld = new RestWebhookPayload
 		{
 			Name = name,
 			AvatarBase64 = base64Avatar.ValueOrDefault(),
 			AvatarSet = base64Avatar.HasValue
 		};
 
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.WEBHOOKS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 		ret.Discord = this.Discord;
 		ret.ApiClient = this;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets the channel webhooks async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordWebhook>> GetChannelWebhooksAsync(ulong channelId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.WEBHOOKS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var webhooksRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordWebhook>>(res.Response).Select(xw => { xw.Discord = this.Discord; xw.ApiClient = this; return xw; });
 
 		return new ReadOnlyCollection<DiscordWebhook>(new List<DiscordWebhook>(webhooksRaw));
 	}
 
 	/// <summary>
 	/// Gets the guild webhooks async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordWebhook>> GetGuildWebhooksAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.WEBHOOKS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var webhooksRaw = JsonConvert.DeserializeObject<IEnumerable<DiscordWebhook>>(res.Response).Select(xw => { xw.Discord = this.Discord; xw.ApiClient = this; return xw; });
 
 		return new ReadOnlyCollection<DiscordWebhook>(new List<DiscordWebhook>(webhooksRaw));
 	}
 
 	/// <summary>
 	/// Gets the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 
 	internal async Task<DiscordWebhook> GetWebhookAsync(ulong webhookId)
 	{
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 		ret.Discord = this.Discord;
 		ret.ApiClient = this;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets the webhook with token async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 
 	internal async Task<DiscordWebhook> GetWebhookWithTokenAsync(ulong webhookId, string webhookToken)
 	{
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 		ret.Token = webhookToken;
 		ret.Id = webhookId;
 		ret.Discord = this.Discord;
 		ret.ApiClient = this;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="base64Avatar">The base64_avatar.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordWebhook> ModifyWebhookAsync(ulong webhookId, ulong channelId, string name, Optional<string> base64Avatar, string reason)
 	{
 		var pld = new RestWebhookPayload
 		{
 			Name = name,
 			AvatarBase64 = base64Avatar.ValueOrDefault(),
 			AvatarSet = base64Avatar.HasValue,
 			ChannelId = channelId
 		};
 
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 		ret.Discord = this.Discord;
 		ret.ApiClient = this;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="base64Avatar">The base64_avatar.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordWebhook> ModifyWebhookAsync(ulong webhookId, string name, string base64Avatar, string webhookToken, string reason)
 	{
 		var pld = new RestWebhookPayload
 		{
 			Name = name,
 			AvatarBase64 = base64Avatar
 		};
 
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordWebhook>(res.Response);
 		ret.Discord = this.Discord;
 		ret.ApiClient = this;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteWebhookAsync(ulong webhookId, string reason)
 	{
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Deletes the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteWebhookAsync(ulong webhookId, string webhookToken, string reason)
 	{
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	/// <summary>
 	/// Executes the webhook async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="builder">The builder.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal async Task<DiscordMessage> ExecuteWebhookAsync(ulong webhookId, string webhookToken, DiscordWebhookBuilder builder, string threadId)
 	{
 		builder.Validate();
 
 		if (builder.Embeds != null)
 			foreach (var embed in builder.Embeds)
 				if (embed.Timestamp != null)
 					embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 		var values = new Dictionary<string, string>();
 		var pld = new RestWebhookExecutePayload
 		{
 			Content = builder.Content,
 			Username = builder.Username.ValueOrDefault(),
 			AvatarUrl = builder.AvatarUrl.ValueOrDefault(),
 			IsTts = builder.IsTts,
 			Embeds = builder.Embeds,
 			Components = builder.Components,
 			ThreadName = builder.ThreadName
 		};
 
 		if (builder.Mentions != null)
 			pld.Mentions = new DiscordMentions(builder.Mentions, builder.Mentions.Any());
 
 		if (builder.Files?.Count > 0)
 		{
 			ulong fileId = 0;
 			List<DiscordAttachment> attachments = new();
 			foreach (var file in builder.Files)
 			{
 				DiscordAttachment att = new()
 				{
 					Id = fileId,
 					Discord = this.Discord,
 					Description = file.Description,
 					FileName = file.FileName,
 					FileSize = null
 				};
 				attachments.Add(att);
 				fileId++;
 			}
 			pld.Attachments = attachments;
 		}
 
 		if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count > 0 || builder.Files?.Count > 0 || builder.IsTts == true || builder.Mentions != null)
 			values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 		if (threadId != null)
 			qub.AddParameter("thread_id", threadId);
 
 		var url = qub.Build();
 
 		var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 		var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 		foreach (var att in ret.Attachments)
 			att.Discord = this.Discord;
 
 		foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 		{
 			file.Stream.Position = file.ResetPositionTo.Value;
 		}
 
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Executes the webhook slack async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="jsonPayload">The json_payload.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal async Task<DiscordMessage> ExecuteWebhookSlackAsync(ulong webhookId, string webhookToken, string jsonPayload, string threadId)
 	{
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.SLACK}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 		if (threadId != null)
 			qub.AddParameter("thread_id", threadId);
 		var url = qub.Build();
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: jsonPayload).ConfigureAwait(false);
 		var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Executes the webhook github async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="jsonPayload">The json_payload.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal async Task<DiscordMessage> ExecuteWebhookGithubAsync(ulong webhookId, string webhookToken, string jsonPayload, string threadId)
 	{
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.GITHUB}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {webhook_id = webhookId, webhook_token = webhookToken }, out var path);
 
 		var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true");
 		if (threadId != null)
 			qub.AddParameter("thread_id", threadId);
 		var url = qub.Build();
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: jsonPayload).ConfigureAwait(false);
 		var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Edits the webhook message async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="builder">The builder.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal async Task<DiscordMessage> EditWebhookMessageAsync(ulong webhookId, string webhookToken, string messageId, DiscordWebhookBuilder builder, string threadId)
 	{
 		builder.Validate(true);
 
 		var pld = new RestWebhookMessageEditPayload
 		{
 			Content = builder.Content,
 			Embeds = builder.Embeds,
 			Mentions = builder.Mentions,
 			Components = builder.Components,
 		};
 
 		if (builder.Files?.Count > 0)
 		{
 			ulong fileId = 0;
 			List<DiscordAttachment> attachments = new();
 			foreach (var file in builder.Files)
 			{
 				DiscordAttachment att = new()
 				{
 					Id = fileId,
 					Discord = this.Discord,
 					Description = file.Description,
 					FileName = file.FileName,
 					FileSize = null
 				};
 				attachments.Add(att);
 				fileId++;
 			}
 			if (builder.Attachments != null && builder.Attachments?.Count() > 0)
 				attachments.AddRange(builder.Attachments);
 
 			pld.Attachments = attachments;
 
 			var values = new Dictionary<string, string>
 			{
 				["payload_json"] = DiscordJson.SerializeObject(pld)
 			};
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 
 			var url = qub.Build();
 			var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, values: values, files: builder.Files);
 
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 			ret.Discord = this.Discord;
 
 			foreach (var att in ret.AttachmentsInternal)
 				att.Discord = this.Discord;
 
 			foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 			{
 				file.Stream.Position = file.ResetPositionTo.Value;
 			}
 
 			return ret;
 		}
 		else
 		{
 			pld.Attachments = builder.Attachments;
 
 			var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 			var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 			var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 			if (threadId != null)
 				qub.AddParameter("thread_id", threadId);
 
 			var url = qub.Build();
 			var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 			var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 			ret.Discord = this.Discord;
 
 			foreach (var att in ret.AttachmentsInternal)
 				att.Discord = this.Discord;
 
 			return ret;
 		}
 	}
 
 	/// <summary>
 	/// Edits the webhook message async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="builder">The builder.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal Task<DiscordMessage> EditWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId, DiscordWebhookBuilder builder, ulong threadId) =>
 		this.EditWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), builder, threadId.ToString());
 
 	/// <summary>
 	/// Gets the webhook message async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal async Task<DiscordMessage> GetWebhookMessageAsync(ulong webhookId, string webhookToken, string messageId, string threadId)
 	{
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 		var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 		if (threadId != null)
 			qub.AddParameter("thread_id", threadId);
 		var url = qub.Build();
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets the webhook message async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="messageId">The message_id.</param>
 
 	internal Task<DiscordMessage> GetWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId) =>
 		this.GetWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), null);
 
 	/// <summary>
 	/// Gets the webhook message async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal Task<DiscordMessage> GetWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId, ulong threadId) =>
 		this.GetWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), threadId.ToString());
 
 	/// <summary>
 	/// Deletes the webhook message async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal async Task DeleteWebhookMessageAsync(ulong webhookId, string webhookToken, string messageId, string threadId)
 	{
 		var route = $"{Endpoints.WEBHOOKS}/:webhook_id/:webhook_token{Endpoints.MESSAGES}/:message_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {webhook_id = webhookId, webhook_token = webhookToken, message_id = messageId }, out var path);
 
 		var qub = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration);
 		if (threadId != null)
 			qub.AddParameter("thread_id", threadId);
 		var url = qub.Build();
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	/// <summary>
 	/// Deletes the webhook message async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="messageId">The message_id.</param>
 
 	internal Task DeleteWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId) =>
 		this.DeleteWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), null);
 
 	/// <summary>
 	/// Deletes the webhook message async.
 	/// </summary>
 	/// <param name="webhookId">The webhook_id.</param>
 	/// <param name="webhookToken">The webhook_token.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="threadId">The thread_id.</param>
 
 	internal Task DeleteWebhookMessageAsync(ulong webhookId, string webhookToken, ulong messageId, ulong threadId) =>
 		this.DeleteWebhookMessageAsync(webhookId, webhookToken, messageId.ToString(), threadId.ToString());
 	#endregion
 
 	#region Reactions
 	/// <summary>
 	/// Creates the reaction async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="emoji">The emoji.</param>
 
 	internal Task CreateReactionAsync(ulong channelId, ulong messageId, string emoji)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji{Endpoints.ME}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 	}
 
 	/// <summary>
 	/// Deletes the own reaction async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="emoji">The emoji.</param>
 
 	internal Task DeleteOwnReactionAsync(ulong channelId, ulong messageId, string emoji)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji{Endpoints.ME}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 	}
 
 	/// <summary>
 	/// Deletes the user reaction async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="userId">The user_id.</param>
 	/// <param name="emoji">The emoji.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteUserReactionAsync(ulong channelId, ulong messageId, ulong userId, string emoji, string reason)
 	{
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId, emoji, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 	}
 
 	/// <summary>
 	/// Gets the reactions async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="emoji">The emoji.</param>
 	/// <param name="afterId">The after_id.</param>
 	/// <param name="limit">The limit.</param>
 
 	internal async Task<IReadOnlyList<DiscordUser>> GetReactionsAsync(ulong channelId, ulong messageId, string emoji, ulong? afterId = null, int limit = 25)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (afterId.HasValue)
 			urlParams["after"] = afterId.Value.ToString(CultureInfo.InvariantCulture);
 
 		urlParams["limit"] = limit.ToString(CultureInfo.InvariantCulture);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, BuildQueryString(urlParams), this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var reactersRaw = JsonConvert.DeserializeObject<IEnumerable<TransportUser>>(res.Response);
 		var reacters = new List<DiscordUser>();
 		foreach (var xr in reactersRaw)
 		{
 			var usr = new DiscordUser(xr) { Discord = this.Discord };
 			usr = this.Discord.UserCache.AddOrUpdate(xr.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				return old;
 			});
 
 			reacters.Add(usr);
 		}
 
 		return new ReadOnlyCollection<DiscordUser>(new List<DiscordUser>(reacters));
 	}
 
 	/// <summary>
 	/// Deletes the all reactions async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteAllReactionsAsync(ulong channelId, ulong messageId, string reason)
 	{
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 	}
 
 	/// <summary>
 	/// Deletes the reactions emoji async.
 	/// </summary>
 	/// <param name="channelId">The channel_id.</param>
 	/// <param name="messageId">The message_id.</param>
 	/// <param name="emoji">The emoji.</param>
 
 	internal Task DeleteReactionsEmojiAsync(ulong channelId, ulong messageId, string emoji)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.MESSAGES}/:message_id{Endpoints.REACTIONS}/:emoji";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, message_id = messageId, emoji }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, ratelimitWaitOverride: this.Discord.Configuration.UseRelativeRatelimit ? null : (double?)0.26);
 	}
 	#endregion
 
 	#region Threads
 
 	/// <summary>
 	/// Creates the thread.
 	/// </summary>
 	/// <param name="channelId">The channel id to create the thread in.</param>
 	/// <param name="messageId">The optional message id to create the thread from.</param>
 	/// <param name="name">The name of the thread.</param>
 	/// <param name="autoArchiveDuration">The auto_archive_duration for the thread.</param>
 	/// <param name="type">Can be either <see cref="ChannelType.PublicThread"/> or <see cref="ChannelType.PrivateThread"/>.</param>
 	/// <param name="rateLimitPerUser">The rate limit per user.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task<DiscordThreadChannel> CreateThreadAsync(ulong channelId, ulong? messageId, string name,
 		ThreadAutoArchiveDuration autoArchiveDuration, ChannelType type, int? rateLimitPerUser, string reason)
 	{
 		var pld = new RestThreadChannelCreatePayload
 		{
 			Name = name,
 			AutoArchiveDuration = autoArchiveDuration,
 			PerUserRateLimit = rateLimitPerUser,
 			Type = type
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id";
 		if (messageId is not null)
 			route += $"{Endpoints.MESSAGES}/:message_id";
 		route += Endpoints.THREADS;
 
 		object param = messageId is null
 			? new {channel_id = channelId}
 			: new {channel_id = channelId, message_id = messageId};
 
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, param, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
 
 		var threadChannel = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
 
 		threadChannel.Discord = this.Discord;
 
 		return threadChannel;
 	}
 
 	/// <summary>
 	/// Gets the thread.
 	/// </summary>
 	/// <param name="threadId">The thread id.</param>
 	internal async Task<DiscordThreadChannel> GetThreadAsync(ulong threadId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:thread_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {thread_id = threadId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var ret = JsonConvert.DeserializeObject<DiscordThreadChannel>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Joins the thread.
 	/// </summary>
 	/// <param name="channelId">The channel id.</param>
 	internal async Task JoinThreadAsync(ulong channelId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}{Endpoints.ME}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
 	}
 
 	/// <summary>
 	/// Leaves the thread.
 	/// </summary>
 	/// <param name="channelId">The channel id.</param>
 	internal async Task LeaveThreadAsync(ulong channelId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}{Endpoints.ME}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	/// <summary>
 	/// Adds a thread member.
 	/// </summary>
 	/// <param name="channelId">The channel id to add the member to.</param>
 	/// <param name="userId">The user id to add.</param>
 	internal async Task AddThreadMemberAsync(ulong channelId, ulong userId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route);
 	}
 
 	/// <summary>
 	/// Gets a thread member.
 	/// </summary>
 	/// <param name="channelId">The channel id to get the member from.</param>
 	/// <param name="userId">The user id to get.</param>
 	internal async Task<DiscordThreadChannelMember> GetThreadMemberAsync(ulong channelId, ulong userId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var threadMember = JsonConvert.DeserializeObject<DiscordThreadChannelMember>(res.Response);
 
 		return threadMember;
 	}
 
 	/// <summary>
 	/// Removes a thread member.
 	/// </summary>
 	/// <param name="channelId">The channel id to remove the member from.</param>
 	/// <param name="userId">The user id to remove.</param>
 	internal async Task RemoveThreadMemberAsync(ulong channelId, ulong userId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREAD_MEMBERS}/:user_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {channel_id = channelId, user_id = userId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	/// <summary>
 	/// Gets the thread members.
 	/// </summary>
 	/// <param name="threadId">The thread id.</param>
 	internal async Task<IReadOnlyList<DiscordThreadChannelMember>> GetThreadMembersAsync(ulong threadId)
 	{
 		var route = $"{Endpoints.CHANNELS}/:thread_id{Endpoints.THREAD_MEMBERS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {thread_id = threadId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var threadMembersRaw = JsonConvert.DeserializeObject<List<DiscordThreadChannelMember>>(res.Response);
 
 		return new ReadOnlyCollection<DiscordThreadChannelMember>(threadMembersRaw);
 	}
 
 	/// <summary>
 	/// Gets the active threads in a guild.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	internal async Task<DiscordThreadResult> GetActiveThreadsAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.THREADS}{Endpoints.THREAD_ACTIVE}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 		return threadReturn;
 	}
 
 	/// <summary>
 	/// Gets the joined private archived threads in a channel.
 	/// </summary>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="before">Get threads before snowflake.</param>
 	/// <param name="limit">Limit the results.</param>
 	internal async Task<DiscordThreadResult> GetJoinedPrivateArchivedThreadsAsync(ulong channelId, ulong? before, int? limit)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (before != null)
 			urlParams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 		if (limit != null && limit > 0)
 			urlParams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.USERS}{Endpoints.ME}{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PRIVATE}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 		return threadReturn;
 	}
 
 	/// <summary>
 	/// Gets the public archived threads in a channel.
 	/// </summary>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="before">Get threads before snowflake.</param>
 	/// <param name="limit">Limit the results.</param>
 	internal async Task<DiscordThreadResult> GetPublicArchivedThreadsAsync(ulong channelId, ulong? before, int? limit)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (before != null)
 			urlParams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 		if (limit != null && limit > 0)
 			urlParams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PUBLIC}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 		return threadReturn;
 	}
 
 	/// <summary>
 	/// Gets the private archived threads in a channel.
 	/// </summary>
 	/// <param name="channelId">The channel id.</param>
 	/// <param name="before">Get threads before snowflake.</param>
 	/// <param name="limit">Limit the results.</param>
 	internal async Task<DiscordThreadResult> GetPrivateArchivedThreadsAsync(ulong channelId, ulong? before, int? limit)
 	{
 		var urlParams = new Dictionary<string, string>();
 		if (before != null)
 			urlParams["before"] = before.Value.ToString(CultureInfo.InvariantCulture);
 		if (limit != null && limit > 0)
 			urlParams["limit"] = limit.Value.ToString(CultureInfo.InvariantCulture);
 
 		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.THREADS}{Endpoints.THREAD_ARCHIVED}{Endpoints.THREAD_PRIVATE}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {channel_id = channelId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, urlParams.Any() ? BuildQueryString(urlParams) : "", this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var threadReturn = JsonConvert.DeserializeObject<DiscordThreadResult>(res.Response);
 
 		return threadReturn;
 	}
 
 	/// <summary>
 	/// Modifies a thread.
 	/// </summary>
 	/// <param name="threadId">The thread to modify.</param>
 	/// <param name="name">The new name.</param>
 	/// <param name="locked">The new locked state.</param>
 	/// <param name="archived">The new archived state.</param>
 	/// <param name="perUserRateLimit">The new per user rate limit.</param>
 	/// <param name="autoArchiveDuration">The new auto archive duration.</param>
 	/// <param name="invitable">The new user invitable state.</param>
 	/// <param name="reason">The reason for the modification.</param>
 	internal Task ModifyThreadAsync(ulong threadId, string name, Optional<bool?> locked, Optional<bool?> archived, Optional<int?> perUserRateLimit, Optional<ThreadAutoArchiveDuration?> autoArchiveDuration, Optional<bool?> invitable, string reason)
 	{
 		var pld = new RestThreadChannelModifyPayload
 		{
 			Name = name,
 			Archived = archived,
 			AutoArchiveDuration = autoArchiveDuration,
 			Locked = locked,
 			PerUserRateLimit = perUserRateLimit,
 			Invitable = invitable
 		};
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.CHANNELS}/:thread_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {thread_id = threadId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Deletes a thread.
 	/// </summary>
 	/// <param name="threadId">The thread to delete.</param>
 	/// <param name="reason">The reason for deletion.</param>
 	internal Task DeleteThreadAsync(ulong threadId, string reason)
 	{
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var route = $"{Endpoints.CHANNELS}/:thread_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {thread_id = threadId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 
 	#endregion
 
 	#region Emoji
 	/// <summary>
 	/// Gets the guild emojis async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 
 	internal async Task<IReadOnlyList<DiscordGuildEmoji>> GetGuildEmojisAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var emojisRaw = JsonConvert.DeserializeObject<IEnumerable<JObject>>(res.Response);
 
 		this.Discord.Guilds.TryGetValue(guildId, out var gld);
 		var users = new Dictionary<ulong, DiscordUser>();
 		var emojis = new List<DiscordGuildEmoji>();
 		foreach (var rawEmoji in emojisRaw)
 		{
 			var xge = rawEmoji.ToObject<DiscordGuildEmoji>();
 			xge.Guild = gld;
 
 			var xtu = rawEmoji["user"]?.ToObject<TransportUser>();
 			if (xtu != null)
 			{
 				if (!users.ContainsKey(xtu.Id))
 				{
 					var user = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 					users[user.Id] = user;
 				}
 
 				xge.User = users[xtu.Id];
 			}
 
 			emojis.Add(xge);
 		}
 
 		return new ReadOnlyCollection<DiscordGuildEmoji>(emojis);
 	}
 
 	/// <summary>
 	/// Gets the guild emoji async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="emojiId">The emoji_id.</param>
 
 	internal async Task<DiscordGuildEmoji> GetGuildEmojiAsync(ulong guildId, ulong emojiId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, emoji_id = emojiId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		this.Discord.Guilds.TryGetValue(guildId, out var gld);
 
 		var emojiRaw = JObject.Parse(res.Response);
 		var emoji = emojiRaw.ToObject<DiscordGuildEmoji>();
 		emoji.Guild = gld;
 
 		var xtu = emojiRaw["user"]?.ToObject<TransportUser>();
 		if (xtu != null)
 			emoji.User = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 
 		return emoji;
 	}
 
 	/// <summary>
 	/// Creates the guild emoji async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="imageb64">The imageb64.</param>
 	/// <param name="roles">The roles.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordGuildEmoji> CreateGuildEmojiAsync(ulong guildId, string name, string imageb64, IEnumerable<ulong> roles, string reason)
 	{
 		var pld = new RestGuildEmojiCreatePayload
 		{
 			Name = name,
 			ImageB64 = imageb64,
 			Roles = roles?.ToArray()
 		};
 
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		this.Discord.Guilds.TryGetValue(guildId, out var gld);
 
 		var emojiRaw = JObject.Parse(res.Response);
 		var emoji = emojiRaw.ToObject<DiscordGuildEmoji>();
 		emoji.Guild = gld;
 
 		var xtu = emojiRaw["user"]?.ToObject<TransportUser>();
 		emoji.User = xtu != null
 			? gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu)
 			: this.Discord.CurrentUser;
 
 		return emoji;
 	}
 
 	/// <summary>
 	/// Modifies the guild emoji async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="emojiId">The emoji_id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="roles">The roles.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal async Task<DiscordGuildEmoji> ModifyGuildEmojiAsync(ulong guildId, ulong emojiId, string name, IEnumerable<ulong> roles, string reason)
 	{
 		var pld = new RestGuildEmojiModifyPayload
 		{
 			Name = name,
 			Roles = roles?.ToArray()
 		};
 
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, emoji_id = emojiId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, headers, DiscordJson.SerializeObject(pld)).ConfigureAwait(false);
 
 		this.Discord.Guilds.TryGetValue(guildId, out var gld);
 
 		var emojiRaw = JObject.Parse(res.Response);
 		var emoji = emojiRaw.ToObject<DiscordGuildEmoji>();
 		emoji.Guild = gld;
 
 		var xtu = emojiRaw["user"]?.ToObject<TransportUser>();
 		if (xtu != null)
 			emoji.User = gld != null && gld.Members.TryGetValue(xtu.Id, out var member) ? member : new DiscordUser(xtu);
 
 		return emoji;
 	}
 
 	/// <summary>
 	/// Deletes the guild emoji async.
 	/// </summary>
 	/// <param name="guildId">The guild_id.</param>
 	/// <param name="emojiId">The emoji_id.</param>
 	/// <param name="reason">The reason.</param>
 
 	internal Task DeleteGuildEmojiAsync(ulong guildId, ulong emojiId, string reason)
 	{
 		var headers = new Dictionary<string, string>();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers[REASON_HEADER_NAME] = reason;
 
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.EMOJIS}/:emoji_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, emoji_id = emojiId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		return this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 	#endregion
 
 	#region Stickers
 
 	/// <summary>
 	/// Gets a sticker.
 	/// </summary>
 	/// <param name="stickerId">The sticker id.</param>
 	internal async Task<DiscordSticker> GetStickerAsync(ulong stickerId)
 	{
 		var route = $"{Endpoints.STICKERS}/:sticker_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {sticker_id = stickerId}, out var path);
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 		var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets the sticker packs.
 	/// </summary>
 	internal async Task<IReadOnlyList<DiscordStickerPack>> GetStickerPacksAsync()
 	{
 		var route = $"{Endpoints.STICKERPACKS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var json = JObject.Parse(res.Response)["sticker_packs"] as JArray;
 		var ret = json.ToDiscordObject<DiscordStickerPack[]>();
 
 		return ret.ToList();
 	}
 
 	/// <summary>
 	/// Gets the guild stickers.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	internal async Task<IReadOnlyList<DiscordSticker>> GetGuildStickersAsync(ulong guildId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId}, out var path);
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 		var json = JArray.Parse(res.Response);
 		var ret = json.ToDiscordObject<DiscordSticker[]>();
 
 		for (var i = 0; i < ret.Length; i++)
 		{
 			var stkr = ret[i];
 			stkr.Discord = this.Discord;
 
 			if (json[i]["user"] is JObject obj) // Null = Missing stickers perm //
 			{
 				var tsr = obj.ToDiscordObject<TransportUser>();
 				var usr = new DiscordUser(tsr) {Discord = this.Discord};
 				usr = this.Discord.UserCache.AddOrUpdate(tsr.Id, usr, (id, old) =>
 				{
 					old.Username = usr.Username;
 					old.Discriminator = usr.Discriminator;
 					old.AvatarHash = usr.AvatarHash;
 					return old;
 				});
 				stkr.User = usr;
 			}
 		}
 
 		return ret.ToList();
 	}
 
 	/// <summary>
 	/// Gets a guild sticker.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="stickerId">The sticker id.</param>
 	internal async Task<DiscordSticker> GetGuildStickerAsync(ulong guildId, ulong stickerId)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {guild_id = guildId, sticker_id = stickerId}, out var path);
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var json = JObject.Parse(res.Response);
 		var ret = json.ToDiscordObject<DiscordSticker>();
 		if (json["user"] is not null) // Null = Missing stickers perm //
 		{
 			var tsr = json["user"].ToDiscordObject<TransportUser>();
 			var usr = new DiscordUser(tsr) {Discord = this.Discord};
 			usr = this.Discord.UserCache.AddOrUpdate(tsr.Id, usr, (id, old) =>
 			{
 				old.Username = usr.Username;
 				old.Discriminator = usr.Discriminator;
 				old.AvatarHash = usr.AvatarHash;
 				return old;
 			});
 			ret.User = usr;
 		}
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Creates the guild sticker.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="tags">The tags.</param>
 	/// <param name="file">The file.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task<DiscordSticker> CreateGuildStickerAsync(ulong guildId, string name, string description, string tags, DiscordMessageFile file, string reason)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {guild_id = guildId}, out var path);
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var res = await this.DoStickerMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, file, name, tags, description);
 
 		var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Modifies the guild sticker.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="stickerId">The sticker id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="tags">The tags.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task<DiscordSticker> ModifyGuildStickerAsync(ulong guildId, ulong stickerId, Optional<string> name, Optional<string> description, Optional<string> tags, string reason)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {guild_id = guildId, sticker_id = stickerId}, out var path);
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		var pld = new RestStickerModifyPayload()
 		{
 			Name = name,
 			Description = description,
 			Tags = tags
 		};
 
 		var values = new Dictionary<string, string>
 		{
 			["payload_json"] = DiscordJson.SerializeObject(pld)
 		};
 
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route);
 		var ret = JObject.Parse(res.Response).ToDiscordObject<DiscordSticker>();
 		ret.Discord = this.Discord;
 
 		return null;
 	}
 
 	/// <summary>
 	/// Deletes the guild sticker async.
 	/// </summary>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="stickerId">The sticker id.</param>
 	/// <param name="reason">The reason.</param>
 	internal async Task DeleteGuildStickerAsync(ulong guildId, ulong stickerId, string reason)
 	{
 		var route = $"{Endpoints.GUILDS}/:guild_id{Endpoints.STICKERS}/:sticker_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {guild_id = guildId, sticker_id = stickerId }, out var path);
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var headers = Utilities.GetBaseHeaders();
 		if (!string.IsNullOrWhiteSpace(reason))
 			headers.Add(REASON_HEADER_NAME, reason);
 
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route, headers);
 	}
 	#endregion
 
 	#region Application Commands
 
 	/// <summary>
 	/// Gets the global application commands.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="withLocalizations">Whether to get the full localization dict.</param>
 	internal async Task<IReadOnlyList<DiscordApplicationCommand>> GetGlobalApplicationCommandsAsync(ulong applicationId, bool withLocalizations = false)
 	{
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId }, out var path);
 
 		var querydict = new Dictionary<string, string>
 		{
 			["with_localizations"] = withLocalizations.ToString().ToLower()
 		};
 		var url = Utilities.GetApiUriFor(path, BuildQueryString(querydict), this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 		foreach (var app in ret)
 			app.Discord = this.Discord;
 		return ret.ToList();
 	}
 
 	/// <summary>
 	/// Bulk overwrites the global application commands.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="commands">The commands.</param>
 	internal async Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGlobalApplicationCommandsAsync(ulong applicationId, IEnumerable<DiscordApplicationCommand> commands)
 	{
 		var pld = new List<RestApplicationCommandCreatePayload>();
 		foreach (var command in commands)
 		{
 			pld.Add(new RestApplicationCommandCreatePayload
 			{
 				Type = command.Type,
 				Name = command.Name,
 				Description = command.Description,
 				Options = command.Options,
 				NameLocalizations = command.NameLocalizations?.GetKeyValuePairs(),
 				DescriptionLocalizations = command.DescriptionLocalizations?.GetKeyValuePairs(),
 				DefaultMemberPermission = command.DefaultMemberPermissions,
-				DmPermission = command.DmPermission,
-				Nsfw = command.IsNsfw
+				DmPermission = command.DmPermission/*,
+				Nsfw = command.IsNsfw*/
 			});
 		}
 
 		this.Discord.Logger.LogDebug(DiscordJson.SerializeObject(pld));
 
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {application_id = applicationId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
 		var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 		foreach (var app in ret)
 			app.Discord = this.Discord;
 		return ret.ToList();
 	}
 
 	/// <summary>
 	/// Creates a global application command.
 	/// </summary>
 	/// <param name="applicationId">The applicationid.</param>
 	/// <param name="command">The command.</param>
 	internal async Task<DiscordApplicationCommand> CreateGlobalApplicationCommandAsync(ulong applicationId, DiscordApplicationCommand command)
 	{
 		var pld = new RestApplicationCommandCreatePayload
 		{
 			Type = command.Type,
 			Name = command.Name,
 			Description = command.Description,
 			Options = command.Options,
 			NameLocalizations = command.NameLocalizations.GetKeyValuePairs(),
 			DescriptionLocalizations = command.DescriptionLocalizations.GetKeyValuePairs(),
 			DefaultMemberPermission = command.DefaultMemberPermissions,
-			DmPermission = command.DmPermission,
-			Nsfw = command.IsNsfw
+			DmPermission = command.DmPermission/*,
+			Nsfw = command.IsNsfw*/
 		};
 
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {application_id = applicationId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 
 		var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets a global application command.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="commandId">The command id.</param>
 	internal async Task<DiscordApplicationCommand> GetGlobalApplicationCommandAsync(ulong applicationId, ulong commandId)
 	{
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, command_id = commandId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Edits a global application command.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="commandId">The command id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="options">The options.</param>
 	/// <param name="nameLocalization">The localizations of the name.</param>
 	/// <param name="descriptionLocalization">The localizations of the description.</param>
 	/// <param name="defaultMemberPermission">The default member permissions.</param>
 	/// <param name="dmPermission">The dm permission.</param>
 	/// <param name="isNsfw">Whether this command is marked as NSFW.</param>
 	internal async Task<DiscordApplicationCommand> EditGlobalApplicationCommandAsync(ulong applicationId, ulong commandId,
 		Optional<string> name, Optional<string> description, Optional<IReadOnlyCollection<DiscordApplicationCommandOption>> options,
 		Optional<DiscordApplicationCommandLocalization> nameLocalization, Optional<DiscordApplicationCommandLocalization> descriptionLocalization,
 		Optional<Permissions> defaultMemberPermission, Optional<bool> dmPermission, Optional<bool> isNsfw)
 	{
 		var pld = new RestApplicationCommandEditPayload
 		{
 			Name = name,
 			Description = description,
 			Options = options,
 			DefaultMemberPermission = defaultMemberPermission,
 			DmPermission = dmPermission,
 			NameLocalizations = nameLocalization.Map(l => l.GetKeyValuePairs()).ValueOrDefault(),
-			DescriptionLocalizations = descriptionLocalization.Map(l => l.GetKeyValuePairs()).ValueOrDefault(),
-			Nsfw = isNsfw
+			DescriptionLocalizations = descriptionLocalization.Map(l => l.GetKeyValuePairs()).ValueOrDefault()/*,
+			Nsfw = isNsfw*/
 		};
 
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {application_id = applicationId, command_id = commandId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 		var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes a global application command.
 	/// </summary>
 	/// <param name="applicationId">The application_id.</param>
 	/// <param name="commandId">The command_id.</param>
 
 	internal async Task DeleteGlobalApplicationCommandAsync(ulong applicationId, ulong commandId)
 	{
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.COMMANDS}/:command_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {application_id = applicationId, command_id = commandId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	/// <summary>
 	/// Gets the guild application commands.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="withLocalizations">Whether to get the full localization dict.</param>
 	internal async Task<IReadOnlyList<DiscordApplicationCommand>> GetGuildApplicationCommandsAsync(ulong applicationId, ulong guildId, bool withLocalizations = false)
 	{
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 		var querydict = new Dictionary<string, string>
 		{
 			["with_localizations"] = withLocalizations.ToString().ToLower()
 		};
 		var url = Utilities.GetApiUriFor(path, BuildQueryString(querydict), this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 		foreach (var app in ret)
 			app.Discord = this.Discord;
 		return ret.ToList();
 	}
 
 	/// <summary>
 	/// Bulk overwrites the guild application commands.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="commands">The commands.</param>
 	internal async Task<IReadOnlyList<DiscordApplicationCommand>> BulkOverwriteGuildApplicationCommandsAsync(ulong applicationId, ulong guildId, IEnumerable<DiscordApplicationCommand> commands)
 	{
 		var pld = new List<RestApplicationCommandCreatePayload>();
 		foreach (var command in commands)
 		{
 			pld.Add(new RestApplicationCommandCreatePayload
 			{
 				Type = command.Type,
 				Name = command.Name,
 				Description = command.Description,
 				Options = command.Options,
 				NameLocalizations = command.NameLocalizations?.GetKeyValuePairs(),
 				DescriptionLocalizations = command.DescriptionLocalizations?.GetKeyValuePairs(),
 				DefaultMemberPermission = command.DefaultMemberPermissions,
-				DmPermission = command.DmPermission,
-				Nsfw = command.IsNsfw
+				DmPermission = command.DmPermission/*,
+				Nsfw = command.IsNsfw*/
 			});
 		}
 		this.Discord.Logger.LogDebug(DiscordJson.SerializeObject(pld));
 
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, payload: DiscordJson.SerializeObject(pld));
 
 		var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationCommand>>(res.Response);
 		foreach (var app in ret)
 			app.Discord = this.Discord;
 		return ret.ToList();
 	}
 
 	/// <summary>
 	/// Creates a guild application command.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="command">The command.</param>
 	internal async Task<DiscordApplicationCommand> CreateGuildApplicationCommandAsync(ulong applicationId, ulong guildId, DiscordApplicationCommand command)
 	{
 		var pld = new RestApplicationCommandCreatePayload
 		{
 			Type = command.Type,
 			Name = command.Name,
 			Description = command.Description,
 			Options = command.Options,
 			NameLocalizations = command.NameLocalizations.GetKeyValuePairs(),
 			DescriptionLocalizations = command.DescriptionLocalizations.GetKeyValuePairs(),
 			DefaultMemberPermission = command.DefaultMemberPermissions,
-			DmPermission = command.DmPermission,
-			Nsfw = command.IsNsfw
+			DmPermission = command.DmPermission/*,
+			Nsfw = command.IsNsfw*/
 		};
 
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 
 		var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets a guild application command.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="commandId">The command id.</param>
 	internal async Task<DiscordApplicationCommand> GetGuildApplicationCommandAsync(ulong applicationId, ulong guildId, ulong commandId)
 	{
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Edits a guild application command.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="commandId">The command id.</param>
 	/// <param name="name">The name.</param>
 	/// <param name="description">The description.</param>
 	/// <param name="options">The options.</param>
 	/// <param name="nameLocalization">The localizations of the name.</param>
 	/// <param name="descriptionLocalization">The localizations of the description.</param>
 	/// <param name="defaultMemberPermission">The default member permissions.</param>
 	/// <param name="dmPermission">The dm permission.</param>
 	/// <param name="isNsfw">Whether this command is marked as NSFW.</param>
 	internal async Task<DiscordApplicationCommand> EditGuildApplicationCommandAsync(ulong applicationId, ulong guildId, ulong commandId,
 		Optional<string> name, Optional<string> description, Optional<IReadOnlyCollection<DiscordApplicationCommandOption>> options,
 		Optional<DiscordApplicationCommandLocalization> nameLocalization, Optional<DiscordApplicationCommandLocalization> descriptionLocalization,
 		Optional<Permissions> defaultMemberPermission, Optional<bool> dmPermission, Optional<bool> isNsfw)
 	{
 		var pld = new RestApplicationCommandEditPayload
 		{
 			Name = name,
 			Description = description,
 			Options = options,
 			DefaultMemberPermission = defaultMemberPermission,
 			DmPermission = dmPermission,
 			NameLocalizations = nameLocalization.Map(l => l.GetKeyValuePairs()).ValueOrDefault(),
-			DescriptionLocalizations = descriptionLocalization.Map(l => l.GetKeyValuePairs()).ValueOrDefault(),
-			Nsfw = isNsfw
+			DescriptionLocalizations = descriptionLocalization.Map(l => l.GetKeyValuePairs()).ValueOrDefault()/*,
+			Nsfw = isNsfw*/
 		};
 
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.PATCH, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PATCH, route, payload: DiscordJson.SerializeObject(pld));
 
 		var ret = JsonConvert.DeserializeObject<DiscordApplicationCommand>(res.Response);
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	/// <summary>
 	/// Deletes a guild application command.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="guildId">The guild id.</param>
 	/// <param name="commandId">The command id.</param>
 	internal async Task DeleteGuildApplicationCommandAsync(ulong applicationId, ulong guildId, ulong commandId)
 	{
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.DELETE, route);
 	}
 
 	#region Permissions 2.1
 
 	/// <summary>
 	/// Gets the guild application command permissions.
 	/// </summary>
 	/// <param name="applicationId">The target application id.</param>
 	/// <param name="guildId">The target guild id.</param>
 	internal async Task<IReadOnlyList<DiscordGuildApplicationCommandPermission>> GetGuildApplicationCommandPermissionsAsync(ulong applicationId, ulong guildId)
 	{
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}{Endpoints.PERMISSIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var ret = JsonConvert.DeserializeObject<IEnumerable<DiscordGuildApplicationCommandPermission>>(res.Response);
 
 		foreach (var app in ret)
 			app.Discord = this.Discord;
 
 		return ret.ToList();
 	}
 
 	/// <summary>
 	/// Gets a guild application command permission.
 	/// </summary>
 	/// <param name="applicationId">The target application id.</param>
 	/// <param name="guildId">The target guild id.</param>
 	/// <param name="commandId">The target command id.</param>
 	internal async Task<DiscordGuildApplicationCommandPermission> GetGuildApplicationCommandPermissionAsync(ulong applicationId, ulong guildId, ulong commandId)
 	{
 		var route = $"{Endpoints.APPLICATIONS}/:application_id{Endpoints.GUILDS}/:guild_id{Endpoints.COMMANDS}/:command_id{Endpoints.PERMISSIONS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId, guild_id = guildId, command_id = commandId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route);
 
 		var ret = JsonConvert.DeserializeObject<DiscordGuildApplicationCommandPermission>(res.Response);
 
 		ret.Discord = this.Discord;
 
 		return ret;
 	}
 
 	#endregion
 
 	/// <summary>
 	/// Creates the interaction response.
 	/// </summary>
 	/// <param name="interactionId">The interaction id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="type">The type.</param>
 	/// <param name="builder">The builder.</param>
 	internal async Task CreateInteractionResponseAsync(ulong interactionId, string interactionToken, InteractionResponseType type, DiscordInteractionResponseBuilder builder)
 	{
 		if (builder?.Embeds != null)
 			foreach (var embed in builder.Embeds)
 				if (embed.Timestamp != null)
 					embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 		RestInteractionResponsePayload pld;
 
 		if (type != InteractionResponseType.AutoCompleteResult)
 		{
 			var data = builder != null ? new DiscordInteractionApplicationCommandCallbackData
 			{
 				Content = builder.Content ?? null,
 				Embeds = builder.Embeds ?? null,
 				IsTts = builder.IsTts,
 				Mentions = builder.Mentions ?? null,
 				Flags = builder.IsEphemeral ? MessageFlags.Ephemeral : null,
 				Components = builder.Components ?? null,
 				Choices = null
 			} : null;
 
 
 			pld = new RestInteractionResponsePayload
 			{
 				Type = type,
 				Data = data
 			};
 
 
 			if (builder != null && builder.Files != null && builder.Files.Count > 0)
 			{
 				ulong fileId = 0;
 				List<DiscordAttachment> attachments = new();
 				foreach (var file in builder.Files)
 				{
 					DiscordAttachment att = new()
 					{
 						Id = fileId,
 						Discord = this.Discord,
 						Description = file.Description,
 						FileName = file.FileName,
 						FileSize = null
 					};
 					attachments.Add(att);
 					fileId++;
 				}
 				pld.Attachments = attachments;
 				pld.Data.Attachments = attachments;
 			}
 		}
 		else
 		{
 			pld = new RestInteractionResponsePayload
 			{
 				Type = type,
 				Data = new DiscordInteractionApplicationCommandCallbackData
 				{
 					Content = null,
 					Embeds = null,
 					IsTts = null,
 					Mentions = null,
 					Flags = null,
 					Components = null,
 					Choices = builder.Choices,
 					Attachments = null
 				},
 				Attachments = null
 			};
 		}
 
 		var values = new Dictionary<string, string>();
 
 		if (builder != null)
 			if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count > 0 || builder.IsTts == true || builder.Mentions != null || builder.Files?.Count > 0)
 				values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 		var route = $"{Endpoints.INTERACTIONS}/:interaction_id/:interaction_token{Endpoints.CALLBACK}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {interaction_id = interactionId, interaction_token = interactionToken }, out var path);
 
 		var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "false").Build();
 		if (builder != null)
 		{
 			await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files);
 
 			foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 			{
 				file.Stream.Position = file.ResetPositionTo.Value;
 			}
 		}
 		else
 		{
 			await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 		}
 	}
 
 	/// <summary>
 	/// Creates the interaction response.
 	/// </summary>
 	/// <param name="interactionId">The interaction id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="type">The type.</param>
 	/// <param name="builder">The builder.</param>
 	internal async Task CreateInteractionModalResponseAsync(ulong interactionId, string interactionToken, InteractionResponseType type, DiscordInteractionModalBuilder builder)
 	{
 		if (builder.ModalComponents.Any(mc => mc.Components.Any(c => c.Type != Enums.ComponentType.InputText)))
 			throw new NotSupportedException("Can't send any other type then Input Text as Modal Component.");
 
 		var pld = new RestInteractionModalResponsePayload
 		{
 			Type = type,
 			Data = new DiscordInteractionApplicationCommandModalCallbackData
 			{
 				Title = builder.Title,
 				CustomId = builder.CustomId,
 				ModalComponents = builder.ModalComponents
 			}
 		};
 
 		var values = new Dictionary<string, string>();
 
 		var route = $"{Endpoints.INTERACTIONS}/:interaction_id/:interaction_token{Endpoints.CALLBACK}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {interaction_id = interactionId, interaction_token = interactionToken }, out var path);
 
 		var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
 		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld));
 	}
 
 	/// <summary>
 	/// Gets the original interaction response.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	internal Task<DiscordMessage> GetOriginalInteractionResponseAsync(ulong applicationId, string interactionToken) =>
 		this.GetWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, null);
 
 	/// <summary>
 	/// Edits the original interaction response.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="builder">The builder.</param>
 	internal Task<DiscordMessage> EditOriginalInteractionResponseAsync(ulong applicationId, string interactionToken, DiscordWebhookBuilder builder) =>
 		this.EditWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, builder, null);
 
 	/// <summary>
 	/// Deletes the original interaction response.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	internal Task DeleteOriginalInteractionResponseAsync(ulong applicationId, string interactionToken) =>
 		this.DeleteWebhookMessageAsync(applicationId, interactionToken, Endpoints.ORIGINAL, null);
 
 	/// <summary>
 	/// Creates the followup message.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="builder">The builder.</param>
 	internal async Task<DiscordMessage> CreateFollowupMessageAsync(ulong applicationId, string interactionToken, DiscordFollowupMessageBuilder builder)
 	{
 		builder.Validate();
 
 		if (builder.Embeds != null)
 			foreach (var embed in builder.Embeds)
 				if (embed.Timestamp != null)
 					embed.Timestamp = embed.Timestamp.Value.ToUniversalTime();
 
 		var values = new Dictionary<string, string>();
 		var pld = new RestFollowupMessageCreatePayload
 		{
 			Content = builder.Content,
 			IsTts = builder.IsTts,
 			Embeds = builder.Embeds,
 			Flags = builder.Flags,
 			Components = builder.Components
 		};
 
 
 		if (builder.Files != null && builder.Files.Count > 0)
 		{
 			ulong fileId = 0;
 			List<DiscordAttachment> attachments = new();
 			foreach (var file in builder.Files)
 			{
 				DiscordAttachment att = new()
 				{
 					Id = fileId,
 					Discord = this.Discord,
 					Description = file.Description,
 					FileName = file.FileName,
 					FileSize = null
 				};
 				attachments.Add(att);
 				fileId++;
 			}
 			pld.Attachments = attachments;
 		}
 
 		if (builder.Mentions != null)
 			pld.Mentions = new DiscordMentions(builder.Mentions, builder.Mentions.Any());
 
 		if (!string.IsNullOrEmpty(builder.Content) || builder.Embeds?.Count > 0 || builder.IsTts == true || builder.Mentions != null || builder.Files?.Count > 0)
 			values["payload_json"] = DiscordJson.SerializeObject(pld);
 
 		var route = $"{Endpoints.WEBHOOKS}/:application_id/:interaction_token";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new {application_id = applicationId, interaction_token = interactionToken }, out var path);
 
 		var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
 		var res = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files).ConfigureAwait(false);
 		var ret = JsonConvert.DeserializeObject<DiscordMessage>(res.Response);
 
 		foreach (var att in ret.AttachmentsInternal)
 		{
 			att.Discord = this.Discord;
 		}
 
 		foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 		{
 			file.Stream.Position = file.ResetPositionTo.Value;
 		}
 
 		ret.Discord = this.Discord;
 		return ret;
 	}
 
 	/// <summary>
 	/// Gets the followup message.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="messageId">The message id.</param>
 	internal Task<DiscordMessage> GetFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId) =>
 		this.GetWebhookMessageAsync(applicationId, interactionToken, messageId);
 
 	/// <summary>
 	/// Edits the followup message.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="messageId">The message id.</param>
 	/// <param name="builder">The builder.</param>
 	internal Task<DiscordMessage> EditFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId, DiscordWebhookBuilder builder) =>
 		this.EditWebhookMessageAsync(applicationId, interactionToken, messageId.ToString(), builder, null);
 
 	/// <summary>
 	/// Deletes the followup message.
 	/// </summary>
 	/// <param name="applicationId">The application id.</param>
 	/// <param name="interactionToken">The interaction token.</param>
 	/// <param name="messageId">The message id.</param>
 	internal Task DeleteFollowupMessageAsync(ulong applicationId, string interactionToken, ulong messageId) =>
 		this.DeleteWebhookMessageAsync(applicationId, interactionToken, messageId);
 	#endregion
 
 	#region Misc
 	/// <summary>
 	/// Gets the current application info async.
 	/// </summary>
 
 	internal Task<TransportApplication> GetCurrentApplicationInfoAsync()
 		=> this.GetApplicationInfoAsync("@me");
 
 	/// <summary>
 	/// Gets the application info async.
 	/// </summary>
 	/// <param name="applicationId">The application_id.</param>
 
 	internal Task<TransportApplication> GetApplicationInfoAsync(ulong applicationId)
 		=> this.GetApplicationInfoAsync(applicationId.ToString(CultureInfo.InvariantCulture));
 
 	/// <summary>
 	/// Gets the application info async.
 	/// </summary>
 	/// <param name="applicationId">The application_id.</param>
 
 	private async Task<TransportApplication> GetApplicationInfoAsync(string applicationId)
 	{
 		var route = $"{Endpoints.OAUTH2}{Endpoints.APPLICATIONS}/:application_id";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new {application_id = applicationId }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		return JsonConvert.DeserializeObject<TransportApplication>(res.Response);
 	}
 
 	/// <summary>
 	/// Gets the application assets async.
 	/// </summary>
 	/// <param name="application">The application.</param>
 
 	internal async Task<IReadOnlyList<DiscordApplicationAsset>> GetApplicationAssetsAsync(DiscordApplication application)
 	{
 		var route = $"{Endpoints.OAUTH2}{Endpoints.APPLICATIONS}/:application_id{Endpoints.ASSETS}";
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { application_id = application.Id }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route).ConfigureAwait(false);
 
 		var assets = JsonConvert.DeserializeObject<IEnumerable<DiscordApplicationAsset>>(res.Response);
 		foreach (var asset in assets)
 		{
 			asset.Discord = application.Discord;
 			asset.Application = application;
 		}
 
 		return new ReadOnlyCollection<DiscordApplicationAsset>(new List<DiscordApplicationAsset>(assets));
 	}
 
 	/// <summary>
 	/// Gets the gateway info async.
 	/// </summary>
 
 	internal async Task<GatewayInfo> GetGatewayInfoAsync()
 	{
 		var headers = Utilities.GetBaseHeaders();
 		var route = Endpoints.GATEWAY;
 		if (this.Discord.Configuration.TokenType == TokenType.Bot)
 			route += Endpoints.BOT;
 		var bucket = this.Rest.GetBucket(RestRequestMethod.GET, route, new { }, out var path);
 
 		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
 		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.GET, route, headers).ConfigureAwait(false);
 
 		var info = JObject.Parse(res.Response).ToObject<GatewayInfo>();
 		info.SessionBucket.ResetAfter = DateTimeOffset.UtcNow + TimeSpan.FromMilliseconds(info.SessionBucket.ResetAfterInternal);
 		return info;
 	}
 	#endregion
 }
diff --git a/DisCatSharp/Net/Rest/Endpoints.cs b/DisCatSharp/Net/Rest/Endpoints.cs
index 07fca1a51..651d9d0e2 100644
--- a/DisCatSharp/Net/Rest/Endpoints.cs
+++ b/DisCatSharp/Net/Rest/Endpoints.cs
@@ -1,476 +1,481 @@
 // 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.
 
 namespace DisCatSharp.Net;
 
 /// <summary>
 /// The discord endpoints.
 /// </summary>
 public static class Endpoints
 {
 	/// <summary>
 	/// The base discord api uri.
 	/// </summary>
 	public const string BASE_URI = "https://discord.com/api/v";
 
 	/// <summary>
 	/// The base discord canary api uri.
 	/// </summary>
 	public const string CANARY_URI = "https://canary.discord.com/api/v";
 
 	/// <summary>
 	/// The base discord ptb api uri.
 	/// </summary>
 	public const string PTB_URI = "https://ptb.discord.com/api/v";
 
 	/// <summary>
 	/// The oauth2 endpoint.
 	/// </summary>
 	public const string OAUTH2 = "/oauth2";
 
 	/// <summary>
 	/// The oauth2 authorize endpoint.
 	/// </summary>
 	public const string AUTHORIZE = "/authorize";
 
 	/// <summary>
 	/// The applications endpoint.
 	/// </summary>
 	public const string APPLICATIONS = "/applications";
 
 	/// <summary>
 	/// The message reactions endpoint.
 	/// </summary>
 	public const string REACTIONS = "/reactions";
 
 	/// <summary>
 	/// The self (@me) endpoint.
 	/// </summary>
 	public const string ME = "/@me";
 
 	/// <summary>
 	/// The @original endpoint.
 	/// </summary>
 	public const string ORIGINAL = "@original";
 
 	/// <summary>
 	/// The permissions endpoint.
 	/// </summary>
 	public const string PERMISSIONS = "/permissions";
 
 	/// <summary>
 	/// The recipients endpoint.
 	/// </summary>
 	public const string RECIPIENTS = "/recipients";
 
 	/// <summary>
 	/// The bulk-delete endpoint.
 	/// </summary>
 	public const string BULK_DELETE = "/bulk-delete";
 
 	/// <summary>
 	/// The integrations endpoint.
 	/// </summary>
 	public const string INTEGRATIONS = "/integrations";
 
 	/// <summary>
 	/// The sync endpoint.
 	/// </summary>
 	public const string SYNC = "/sync";
 
 	/// <summary>
 	/// The prune endpoint.
 	/// Used for user removal.
 	/// </summary>
 	public const string PRUNE = "/prune";
 
 	/// <summary>
 	/// The regions endpoint.
 	/// </summary>
 	public const string REGIONS = "/regions";
 
 	/// <summary>
 	/// The connections endpoint.
 	/// </summary>
 	public const string CONNECTIONS = "/connections";
 
 	/// <summary>
 	/// The icons endpoint.
 	/// </summary>
 	public const string ICONS = "/icons";
 
 	/// <summary>
 	/// The gateway endpoint.
 	/// </summary>
 	public const string GATEWAY = "/gateway";
 
 	/// <summary>
 	/// The oauth2 auth endpoint.
 	/// </summary>
 	public const string AUTH = "/auth";
 
 	/// <summary>
 	/// The oauth2 login endpoint.
 	/// </summary>
 	public const string LOGIN = "/login";
 
 	/// <summary>
 	/// The channels endpoint.
 	/// </summary>
 	public const string CHANNELS = "/channels";
 
 	/// <summary>
 	/// The messages endpoint.
 	/// </summary>
 	public const string MESSAGES = "/messages";
 
 	/// <summary>
 	/// The pinned messages endpoint.
 	/// </summary>
 	public const string PINS = "/pins";
 
 	/// <summary>
 	/// The users endpoint.
 	/// </summary>
 	public const string USERS = "/users";
 
 	/// <summary>
 	/// The guilds endpoint.
 	/// </summary>
 	public const string GUILDS = "/guilds";
 
 	/// <summary>
 	/// The guild discovery splash endpoint.
 	/// </summary>
 	public const string GUILD_DISCOVERY_SPLASHES = "/discovery-splashes";
 
 	/// <summary>
 	/// The guild splash endpoint.
 	/// </summary>
 	public const string SPLASHES = "/splashes";
 
 	/// <summary>
 	/// The search endpoint.
 	/// </summary>
 	public const string SEARCH = "/search";
 
 	/// <summary>
 	/// The invites endpoint.
 	/// </summary>
 	public const string INVITES = "/invites";
 
 	/// <summary>
 	/// The roles endpoint.
 	/// </summary>
 	public const string ROLES = "/roles";
 
 	/// <summary>
 	/// The members endpoint.
 	/// </summary>
 	public const string MEMBERS = "/members";
 
 	/// <summary>
 	/// The typing endpoint.
 	/// Triggers a typing indicator inside a channel.
 	/// </summary>
 	public const string TYPING = "/typing";
 
 	/// <summary>
 	/// The avatars endpoint.
 	/// </summary>
 	public const string AVATARS = "/avatars";
 
 	/// <summary>
 	/// The bans endpoint.
 	/// </summary>
 	public const string BANS = "/bans";
 
 	/// <summary>
 	/// The webhook endpoint.
 	/// </summary>
 	public const string WEBHOOKS = "/webhooks";
 
 	/// <summary>
 	/// The slack endpoint.
 	/// Used for <see cref="Entities.DiscordWebhook"/>.
 	/// </summary>
 	public const string SLACK = "/slack";
 
 	/// <summary>
 	/// The github endpoint.
 	/// Used for <see cref="Entities.DiscordWebhook"/>.
 	/// </summary>
 	public const string GITHUB = "/github";
 
+	/// <summary>
+	/// The guilds mfa endpoint.
+	/// </summary>
+	public const string MFA = "/mfa";
+
 	/// <summary>
 	/// The bot endpoint.
 	/// </summary>
 	public const string BOT = "/bot";
 
 	/// <summary>
 	/// The voice endpoint.
 	/// </summary>
 	public const string VOICE = "/voice";
 
 	/// <summary>
 	/// The audit logs endpoint.
 	/// </summary>
 	public const string AUDIT_LOGS = "/audit-logs";
 
 	/// <summary>
 	/// The acknowledge endpoint.
 	/// Indicates that a message is read.
 	/// </summary>
 	public const string ACK = "/ack";
 
 	/// <summary>
 	/// The nickname endpoint.
 	/// </summary>
 	public const string NICK = "/nick";
 
 	/// <summary>
 	/// The assets endpoint.
 	/// </summary>
 	public const string ASSETS = "/assets";
 
 	/// <summary>
 	/// The embed endpoint.
 	/// </summary>
 	public const string EMBED = "/embed";
 
 	/// <summary>
 	/// The emojis endpoint.
 	/// </summary>
 	public const string EMOJIS = "/emojis";
 
 	/// <summary>
 	/// The vanity url endpoint.
 	/// </summary>
 	public const string VANITY_URL = "/vanity-url";
 
 	/// <summary>
 	/// The guild preview endpoint.
 	/// </summary>
 	public const string PREVIEW = "/preview";
 
 	/// <summary>
 	/// The followers endpoint.
 	/// </summary>
 	public const string FOLLOWERS = "/followers";
 
 	/// <summary>
 	/// The crosspost endpoint.
 	/// </summary>
 	public const string CROSSPOST = "/crosspost";
 
 	/// <summary>
 	/// The guild widget endpoint.
 	/// </summary>
 	public const string WIDGET = "/widget";
 
 	/// <summary>
 	/// The guild widget json endpoint.
 	/// </summary>
 	public const string WIDGET_JSON = "/widget.json";
 
 	/// <summary>
 	/// The guild widget png endpoint.
 	/// </summary>
 	public const string WIDGET_PNG = "/widget.png";
 
 	/// <summary>
 	/// The templates endpoint.
 	/// </summary>
 	public const string TEMPLATES = "/templates";
 
 	/// <summary>
 	/// The member verification gate endpoint.
 	/// </summary>
 	public const string MEMBER_VERIFICATION = "/member-verification";
 
 	/// <summary>
 	/// The slash commands endpoint.
 	/// </summary>
 	public const string COMMANDS = "/commands";
 
 	/// <summary>
 	/// The interactions endpoint.
 	/// </summary>
 	public const string INTERACTIONS = "/interactions";
 
 	/// <summary>
 	/// The interaction/command callback endpoint.
 	/// </summary>
 	public const string CALLBACK = "/callback";
 
 	/// <summary>
 	/// The welcome screen endpoint.
 	/// </summary>
 	public const string WELCOME_SCREEN = "/welcome-screen";
 
 	/// <summary>
 	/// The voice states endpoint.
 	/// </summary>
 	public const string VOICE_STATES = "/voice-states";
 
 	/// <summary>
 	/// The stage instances endpoint.
 	/// </summary>
 	public const string STAGE_INSTANCES = "/stage-instances";
 
 	/// <summary>
 	/// The threads endpoint.
 	/// </summary>
 	public const string THREADS = "/threads";
 
 	/// <summary>
 	/// The public threads endpoint.
 	/// </summary>
 	public const string THREAD_PUBLIC = "/public";
 
 	/// <summary>
 	/// The private threads endpoint.
 	/// </summary>
 	public const string THREAD_PRIVATE = "/private";
 
 	/// <summary>
 	/// The active threads endpoint.
 	/// </summary>
 	public const string THREAD_ACTIVE = "/active";
 
 	/// <summary>
 	/// The archived threads endpoint.
 	/// </summary>
 	public const string THREAD_ARCHIVED = "/archived";
 
 	/// <summary>
 	/// The thread members endpoint.
 	/// </summary>
 	public const string THREAD_MEMBERS = "/thread-members";
 
 	/// <summary>
 	/// The guild scheduled events endpoint.
 	/// </summary>
 	public const string SCHEDULED_EVENTS = "/scheduled-events";
 
 	/// <summary>
 	/// The guild scheduled events cover image endpoint.
 	/// </summary>
 	public const string GUILD_EVENTS = "guild-events";
 
 	/// <summary>
 	/// The stickers endpoint.
 	/// </summary>
 	public const string STICKERS = "/stickers";
 
 	/// <summary>
 	/// The sticker packs endpoint.
 	/// Global nitro sticker packs.
 	/// </summary>
 	public const string STICKERPACKS = "/sticker-packs";
 
 	/// <summary>
 	/// The store endpoint.
 	/// </summary>
 	public const string STORE = "/store";
 
 	/// <summary>
 	/// The app assets endpoint.
 	/// </summary>
 	public const string APP_ASSETS = "/app-assets";
 
 	/// <summary>
 	/// The app icons endpoint.
 	/// </summary>
 	public const string APP_ICONS = "/app-icons";
 
 	/// <summary>
 	/// The team icons endpoint.
 	/// </summary>
 	public const string TEAM_ICONS = "/team-icons";
 
 	/// <summary>
 	/// The channel icons endpoint.
 	/// </summary>
 	public const string CHANNEL_ICONS = "/channel-icons";
 
 	/// <summary>
 	/// The user banners endpoint.
 	/// </summary>
 	public const string BANNERS = "/banners";
 
 	/// <summary>
 	/// The sticker endpoint.
 	/// This endpoint is the static nitro sticker application.
 	/// </summary>
 	public const string STICKER_APPLICATION = "/710982414301790216";
 
 	/// <summary>
 	/// The role subscription endpoint.
 	/// </summary>
 	public const string ROLE_SUBSCRIPTIONS = "/role-subscriptions";
 
 	/// <summary>
 	/// The group listings endpoint.
 	/// </summary>
 	public const string GROUP_LISTINGS = "/group-listings";
 
 	/// <summary>
 	/// The subscription listings endpoint.
 	/// </summary>
 	public const string SUBSCRIPTION_LISTINGS = "/subscription-listings";
 
 	/// <summary>
 	/// The directory entries endpoint.
 	/// </summary>
 	public const string DIRECTORY_ENTRIES = "/directory-entries";
 
 	/// <summary>
 	/// The counts endpoint.
 	/// </summary>
 	public const string COUNTS = "/counts";
 
 	/// <summary>
 	/// The list endpoint.
 	/// </summary>
 	public const string LIST = "/list";
 
 	/// <summary>
 	/// The role icons endpoint.
 	/// </summary>
 	public const string ROLE_ICONS = "/role-icons";
 
 	/// <summary>
 	/// The activities endpoint.
 	/// </summary>
 	public const string ACTIVITIES = "/activities";
 
 	/// <summary>
 	/// The config endpoint.
 	/// </summary>
 	public const string CONFIG = "/config";
 
 	/// <summary>
 	/// The ephemeral attachments endpoint.
 	/// </summary>
 	public const string EPHEMERAL_ATTACHMENTS = "/ephemeral-attachments";
 }
diff --git a/DisCatSharp/Utilities.cs b/DisCatSharp/Utilities.cs
index 20a634b4f..566a79c00 100644
--- a/DisCatSharp/Utilities.cs
+++ b/DisCatSharp/Utilities.cs
@@ -1,469 +1,470 @@
 // 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.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
+using DisCatSharp.Enums;
 using DisCatSharp.Net;
 
 using Microsoft.Extensions.Logging;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// Various Discord-related utilities.
 /// </summary>
 public static class Utilities
 {
 	/// <summary>
 	/// Gets the version of the library
 	/// </summary>
 	internal static string VersionHeader { get; set; }
 
 	/// <summary>
 	/// Gets or sets the permission strings.
 	/// </summary>
 	internal static Dictionary<Permissions, string> PermissionStrings { get; set; }
 
 	/// <summary>
 	/// Gets the utf8 encoding
 	/// </summary>
 	// ReSharper disable once InconsistentNaming
 	internal static UTF8Encoding UTF8 { get; } = new(false);
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="Utilities"/> class.
 	/// </summary>
 	static Utilities()
 	{
 		PermissionStrings = new Dictionary<Permissions, string>();
 		var t = typeof(Permissions);
 		var ti = t.GetTypeInfo();
 		var vals = Enum.GetValues(t).Cast<Permissions>();
 
 		foreach (var xv in vals)
 		{
 			var xsv = xv.ToString();
 			var xmv = ti.DeclaredMembers.FirstOrDefault(xm => xm.Name == xsv);
 			var xav = xmv.GetCustomAttribute<PermissionStringAttribute>();
 
 			PermissionStrings[xv] = xav.String;
 		}
 
 		var a = typeof(DiscordClient).GetTypeInfo().Assembly;
 
 		var vs = "";
 		var iv = a.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
 		if (iv != null)
 			vs = iv.InformationalVersion;
 		else
 		{
 			var v = a.GetName().Version;
 			vs = v.ToString(3);
 		}
 
 		VersionHeader = $"DiscordBot (https://github.com/Aiko-IT-Systems/DisCatSharp, v{vs})";
 	}
 
 	/// <summary>
 	/// Gets the api base uri.
 	/// </summary>
 	/// <param name="config">The config</param>
 	/// <returns>A string.</returns>
 	internal static string GetApiBaseUri(DiscordConfiguration config = null)
 		=> config == null ? Endpoints.BASE_URI + "9" : config.UseCanary ? Endpoints.CANARY_URI + config.ApiVersion : Endpoints.BASE_URI + config.ApiVersion;
 
 	/// <summary>
 	/// Gets the api uri for.
 	/// </summary>
 	/// <param name="path">The path.</param>
 	/// <param name="config">The config</param>
 	/// <returns>An Uri.</returns>
 	internal static Uri GetApiUriFor(string path, DiscordConfiguration config)
 		=> new($"{GetApiBaseUri(config)}{path}");
 
 	/// <summary>
 	/// Gets the api uri for.
 	/// </summary>
 	/// <param name="path">The path.</param>
 	/// <param name="queryString">The query string.</param>
 	/// <param name="config">The config</param>
 	/// <returns>An Uri.</returns>
 	internal static Uri GetApiUriFor(string path, string queryString, DiscordConfiguration config)
 		=> new($"{GetApiBaseUri(config)}{path}{queryString}");
 
 	/// <summary>
 	/// Gets the api uri builder for.
 	/// </summary>
 	/// <param name="path">The path.</param>
 	/// <param name="config">The config</param>
 	/// <returns>A QueryUriBuilder.</returns>
 	internal static QueryUriBuilder GetApiUriBuilderFor(string path, DiscordConfiguration config)
 		=> new($"{GetApiBaseUri(config)}{path}");
 
 	/// <summary>
 	/// Gets the formatted token.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <returns>A string.</returns>
 	internal static string GetFormattedToken(BaseDiscordClient client) => GetFormattedToken(client.Configuration);
 
 	/// <summary>
 	/// Gets the formatted token.
 	/// </summary>
 	/// <param name="config">The config.</param>
 	/// <returns>A string.</returns>
 	internal static string GetFormattedToken(DiscordConfiguration config) =>
 		config.TokenType switch
 		{
 			TokenType.Bearer => $"Bearer {config.Token}",
 			TokenType.Bot => $"Bot {config.Token}",
 			_ => throw new ArgumentException("Invalid token type specified.", nameof(config)),
 		};
 
 	/// <summary>
 	/// Gets the base headers.
 	/// </summary>
 	/// <returns>A Dictionary.</returns>
 	internal static Dictionary<string, string> GetBaseHeaders()
 		=> new();
 
 	/// <summary>
 	/// Gets the user agent.
 	/// </summary>
 	/// <returns>A string.</returns>
 	internal static string GetUserAgent()
 		=> VersionHeader;
 
 	/// <summary>
 	/// Contains the user mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A bool.</returns>
 	internal static bool ContainsUserMentions(string message)
 	{
 		var pattern = @"<@(\d+)>";
 		var regex = new Regex(pattern, RegexOptions.ECMAScript);
 		return regex.IsMatch(message);
 	}
 
 	/// <summary>
 	/// Contains the nickname mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A bool.</returns>
 	internal static bool ContainsNicknameMentions(string message)
 	{
 		var pattern = @"<@!(\d+)>";
 		var regex = new Regex(pattern, RegexOptions.ECMAScript);
 		return regex.IsMatch(message);
 	}
 
 	/// <summary>
 	/// Contains the channel mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A bool.</returns>
 	internal static bool ContainsChannelMentions(string message)
 	{
 		var pattern = @"<#(\d+)>";
 		var regex = new Regex(pattern, RegexOptions.ECMAScript);
 		return regex.IsMatch(message);
 	}
 
 	/// <summary>
 	/// Contains the role mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A bool.</returns>
 	internal static bool ContainsRoleMentions(string message)
 	{
 		var pattern = @"<@&(\d+)>";
 		var regex = new Regex(pattern, RegexOptions.ECMAScript);
 		return regex.IsMatch(message);
 	}
 
 	/// <summary>
 	/// Contains the emojis.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A bool.</returns>
 	internal static bool ContainsEmojis(string message)
 	{
 		var pattern = @"<a?:(.*):(\d+)>";
 		var regex = new Regex(pattern, RegexOptions.ECMAScript);
 		return regex.IsMatch(message);
 	}
 
 	/// <summary>
 	/// Gets the user mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A list of ulong.</returns>
 	internal static IEnumerable<ulong> GetUserMentions(DiscordMessage message)
 	{
 		var regex = new Regex(@"<@!?(\d+)>", RegexOptions.ECMAScript);
 		var matches = regex.Matches(message.Content);
 		return from Match match in matches
 			   select ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
 	}
 
 	/// <summary>
 	/// Gets the role mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A list of ulong.</returns>
 	internal static IEnumerable<ulong> GetRoleMentions(DiscordMessage message)
 	{
 		var regex = new Regex(@"<@&(\d+)>", RegexOptions.ECMAScript);
 		var matches = regex.Matches(message.Content);
 		return from Match match in matches
 			   select ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
 	}
 
 	/// <summary>
 	/// Gets the channel mentions.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A list of ulong.</returns>
 	internal static IEnumerable<ulong> GetChannelMentions(DiscordMessage message)
 	{
 		var regex = new Regex(@"<#(\d+)>", RegexOptions.ECMAScript);
 		var matches = regex.Matches(message.Content);
 		return from Match match in matches
 			   select ulong.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
 	}
 
 	/// <summary>
 	/// Gets the emojis.
 	/// </summary>
 	/// <param name="message">The message.</param>
 	/// <returns>A list of ulong.</returns>
 	internal static IEnumerable<ulong> GetEmojis(DiscordMessage message)
 	{
 		var regex = new Regex(@"<a?:([a-zA-Z0-9_]+):(\d+)>", RegexOptions.ECMAScript);
 		var matches = regex.Matches(message.Content);
 		return from Match match in matches
 			   select ulong.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture);
 	}
 
 	/// <summary>
 	/// Are the valid slash command name.
 	/// </summary>
 	/// <param name="name">The name.</param>
 	/// <returns>A bool.</returns>
 	internal static bool IsValidSlashCommandName(string name)
 	{
 		var regex = new Regex(@"^[\w-]{1,32}$");
 		return regex.IsMatch(name);
 	}
 
 	/// <summary>
 	/// Checks the thread auto archive duration feature.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <param name="taad">The taad.</param>
 	/// <returns>A bool.</returns>
 	internal static bool CheckThreadAutoArchiveDurationFeature(DiscordGuild guild, ThreadAutoArchiveDuration taad)
 		=> true;
 
 	/// <summary>
 	/// Checks the thread private feature.
 	/// </summary>
 	/// <param name="guild">The guild.</param>
 	/// <returns>A bool.</returns>
 	internal static bool CheckThreadPrivateFeature(DiscordGuild guild) => guild.PremiumTier.HasFlag(PremiumTier.TierTwo) || guild.Features.CanCreatePrivateThreads;
 
 	/// <summary>
 	/// Have the message intents.
 	/// </summary>
 	/// <param name="intents">The intents.</param>
 	/// <returns>A bool.</returns>
 	internal static bool HasMessageIntents(DiscordIntents intents)
 		=> intents.HasIntent(DiscordIntents.GuildMessages) || intents.HasIntent(DiscordIntents.DirectMessages);
-	
+
 	/// <summary>
 	/// Have the message intents.
 	/// </summary>
 	/// <param name="intents">The intents.</param>
 	/// <returns>A bool.</returns>
 	internal static bool HasMessageContentIntents(DiscordIntents intents)
 		=> intents.HasIntent(DiscordIntents.MessageContent);
 
 	/// <summary>
 	/// Have the reaction intents.
 	/// </summary>
 	/// <param name="intents">The intents.</param>
 	/// <returns>A bool.</returns>
 	internal static bool HasReactionIntents(DiscordIntents intents)
 		=> intents.HasIntent(DiscordIntents.GuildMessageReactions) || intents.HasIntent(DiscordIntents.DirectMessageReactions);
 
 	/// <summary>
 	/// Have the typing intents.
 	/// </summary>
 	/// <param name="intents">The intents.</param>
 	/// <returns>A bool.</returns>
 	internal static bool HasTypingIntents(DiscordIntents intents)
 		=> intents.HasIntent(DiscordIntents.GuildMessageTyping) || intents.HasIntent(DiscordIntents.DirectMessageTyping);
 
 	// https://discord.com/developers/docs/topics/gateway#sharding-sharding-formula
 	/// <summary>
 	/// Gets a shard id from a guild id and total shard count.
 	/// </summary>
 	/// <param name="guildId">The guild id the shard is on.</param>
 	/// <param name="shardCount">The total amount of shards.</param>
 	/// <returns>The shard id.</returns>
 	public static int GetShardId(ulong guildId, int shardCount)
 		=> (int)(guildId >> 22) % shardCount;
 
 	/// <summary>
 	/// Helper method to create a <see cref="System.DateTimeOffset"/> from Unix time seconds for targets that do not support this natively.
 	/// </summary>
 	/// <param name="unixTime">Unix time seconds to convert.</param>
 	/// <param name="shouldThrow">Whether the method should throw on failure. Defaults to true.</param>
 	/// <returns>Calculated <see cref="System.DateTimeOffset"/>.</returns>
 	public static DateTimeOffset GetDateTimeOffset(long unixTime, bool shouldThrow = true)
 	{
 		try
 		{
 			return DateTimeOffset.FromUnixTimeSeconds(unixTime);
 		}
 		catch (Exception)
 		{
 			if (shouldThrow)
 				throw;
 
 			return DateTimeOffset.MinValue;
 		}
 	}
 
 	/// <summary>
 	/// Helper method to create a <see cref="System.DateTimeOffset"/> from Unix time milliseconds for targets that do not support this natively.
 	/// </summary>
 	/// <param name="unixTime">Unix time milliseconds to convert.</param>
 	/// <param name="shouldThrow">Whether the method should throw on failure. Defaults to true.</param>
 	/// <returns>Calculated <see cref="System.DateTimeOffset"/>.</returns>
 	public static DateTimeOffset GetDateTimeOffsetFromMilliseconds(long unixTime, bool shouldThrow = true)
 	{
 		try
 		{
 			return DateTimeOffset.FromUnixTimeMilliseconds(unixTime);
 		}
 		catch (Exception)
 		{
 			if (shouldThrow)
 				throw;
 
 			return DateTimeOffset.MinValue;
 		}
 	}
 
 	/// <summary>
 	/// Helper method to calculate Unix time seconds from a <see cref="System.DateTimeOffset"/> for targets that do not support this natively.
 	/// </summary>
 	/// <param name="dto"><see cref="System.DateTimeOffset"/> to calculate Unix time for.</param>
 	/// <returns>Calculated Unix time.</returns>
 	public static long GetUnixTime(DateTimeOffset dto)
 		=> dto.ToUnixTimeMilliseconds();
 
 	/// <summary>
 	/// Computes a timestamp from a given snowflake.
 	/// </summary>
 	/// <param name="snowflake">Snowflake to compute a timestamp from.</param>
 	/// <returns>Computed timestamp.</returns>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static DateTimeOffset GetSnowflakeTime(this ulong snowflake)
 		=> DiscordClient.DiscordEpoch.AddMilliseconds(snowflake >> 22);
 
 	/// <summary>
 	/// Converts this <see cref="Permissions"/> into human-readable format.
 	/// </summary>
 	/// <param name="perm">Permissions enumeration to convert.</param>
 	/// <returns>Human-readable permissions.</returns>
 	public static string ToPermissionString(this Permissions perm)
 	{
 		if (perm == Permissions.None)
 			return PermissionStrings[perm];
 
 		perm &= PermissionMethods.FullPerms;
 
 		var strs = PermissionStrings
 			.Where(xkvp => xkvp.Key != Permissions.None && (perm & xkvp.Key) == xkvp.Key)
 			.Select(xkvp => xkvp.Value);
 
 		return string.Join(", ", strs.OrderBy(xs => xs));
 	}
 
 	/// <summary>
 	/// Checks whether this string contains given characters.
 	/// </summary>
 	/// <param name="str">String to check.</param>
 	/// <param name="characters">Characters to check for.</param>
 	/// <returns>Whether the string contained these characters.</returns>
 	public static bool Contains(this string str, params char[] characters)
 	{
 		foreach (var xc in str)
 			if (characters.Contains(xc))
 				return true;
 
 		return false;
 	}
 
 	/// <summary>
 	/// Logs the task fault.
 	/// </summary>
 	/// <param name="task">The task.</param>
 	/// <param name="logger">The logger.</param>
 	/// <param name="level">The level.</param>
 	/// <param name="eventId">The event id.</param>
 	/// <param name="message">The message.</param>
 	internal static void LogTaskFault(this Task task, ILogger logger, LogLevel level, EventId eventId, string message)
 	{
 		if (task == null)
 			throw new ArgumentNullException(nameof(task));
 
 		if (logger == null)
 			return;
 
 		task.ContinueWith(t => logger.Log(level, eventId, t.Exception, message), TaskContinuationOptions.OnlyOnFaulted);
 	}
 
 	/// <summary>
 	/// Deconstructs the.
 	/// </summary>
 	/// <param name="kvp">The kvp.</param>
 	/// <param name="key">The key.</param>
 	/// <param name="value">The value.</param>
 	internal static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> kvp, out TKey key, out TValue value)
 	{
 		key = kvp.Key;
 		value = kvp.Value;
 	}
 }
diff --git a/NuGet.targets b/NuGet.targets
index 67ad58430..5313cd840 100644
--- a/NuGet.targets
+++ b/NuGet.targets
@@ -1,7 +1,26 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <IncludeSymbols>true</IncludeSymbols>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+	  <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <DebugType>Portable</DebugType>
+    <AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(TF_BUILD)' == 'true'">
+    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(CI)' == 'True'">
+    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">
+    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(GITHUB_ACTIONS)' != 'true' And '$(TF_BUILD)' != 'true' And '$(CI)' != 'True'">
+	  <ContinuousIntegrationBuild>false</ContinuousIntegrationBuild>
+  </PropertyGroup>
+  <ItemGroup>
+	<PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All"/>
+  </ItemGroup>
 </Project>
diff --git a/Package.targets b/Package.targets
index fc1a46863..daffb9ed8 100644
--- a/Package.targets
+++ b/Package.targets
@@ -1,13 +1,12 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-	<PropertyGroup>
+  <PropertyGroup>
     <NoWarn>1591;NU5128;DV2001</NoWarn>
-    <LangVersion>10.0</LangVersion>
+    <LangVersion>latest</LangVersion>
     <Optimize>True</Optimize>
     <GenerateDocumentationFile>True</GenerateDocumentationFile>
-    <DebugType>Portable</DebugType>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)' == 'Debug'">
     <Optimize>False</Optimize>
   </PropertyGroup>
 </Project>
diff --git a/README.md b/README.md
index b235c51aa..f0a9d2f43 100644
--- a/README.md
+++ b/README.md
@@ -1,103 +1,103 @@
 # DisCatSharp ![Stable](https://img.shields.io/nuget/v/DisCatSharp?color=%23ebb34b&label=Stable&style=flat-square&logo=nuget) ![Nightly](https://img.shields.io/nuget/vpre/DisCatSharp?color=%23ff1493&label=Nightly&style=flat-square&logo=nuget)
 
 A Discord Bot Library written in C# for .NET.
 
 ![DisCatSharp Logo](https://github.com/Aiko-IT-Systems/DisCatSharp/blob/main/DisCatSharp.Logos/android-chrome-192x192.png?raw=true)
 
 ----
 [![Build](https://github.com/Aiko-IT-Systems/DisCatSharp/actions/workflows/dotnet.yml/badge.svg)](https://github.com/Aiko-IT-Systems/DisCatSharp/actions/workflows/dotnet.yml)
 [![Documentation](https://github.com/Aiko-IT-Systems/DisCatSharp/actions/workflows/docs.yml/badge.svg)](https://github.com/Aiko-IT-Systems/DisCatSharp/actions/workflows/docs.yml)
 [![Typos](https://github.com/Aiko-IT-Systems/DisCatSharp/actions/workflows/typos.yml/badge.svg)](https://github.com/Aiko-IT-Systems/DisCatSharp/actions/workflows/typos.yml)
 [![CodeQL](https://github.com/Aiko-IT-Systems/DisCatSharp/actions/workflows/codeql.yml/badge.svg)](https://github.com/Aiko-IT-Systems/DisCatSharp/actions/workflows/codeql.yml)
 ![Wakatime](https://wakatime.com/badge/github/Aiko-IT-Systems/DisCatSharp.svg)
 
 [![AppVeyor](https://img.shields.io/appveyor/build/AITSYS/DisCatSharp?label=Appveyor&logo=appveyor&style=flat-square)](https://ci.appveyor.com/project/AITSYS/discatsharp)
 [![GitHub last commit](https://img.shields.io/github/last-commit/Aiko-IT-Systems/DisCatSharp?label=Last%20Commit&style=flat-square&logo=github)](https://aitsys.dev/source/DisCatSharp/history/)
 [![GitHub commit activity](https://img.shields.io/github/commit-activity/w/Aiko-IT-Systems/DisCatSharp?label=Commit%20Activity&style=flat-square&logo=github)](https://github.com/Aiko-IT-Systems/DisCatSharp/commits/main)
 [![GitHub pull requests](https://img.shields.io/github/issues-pr/Aiko-IT-Systems/DisCatSharp?label=PRs&style=flat-square&logo=github&logo=gitub)](https://github.com/Aiko-IT-Systems/DisCatSharp/pulls)
 ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/Aiko-IT-Systems/DisCatSharp?label=Size&style=flat-square&logo=github)
 
 ----
 
 ## Why DisCatSharp?
 - You want a library where you get kind and efficient help?
 - You would like to have and use the most recent features of the Discord API?
 - You are ready to build great things?
 
 Then this is the right place for you!
 
 ## Installing
-You can install the library from following source: [NuGet](https://nuget.dcs.aitsys.dev).
+You can install the library from following source: [NuGet](https://www.nuget.org/profiles/DisCatSharp).
 
 ## Documentation
-The documentation for the stable version is available at [docs.dcs.aitsys.dev/lts](https://docs.dcs.aitsys.dev/lts).
+<!--The documentation for the stable version is available at [docs.dcs.aitsys.dev/lts](https://docs.discatsharp.tech/lts).-->
 
-The documentation of the nightly versions is available at [docs.dcs.aitsys.dev](https://docs.dcs.aitsys.dev).
+The documentation of the nightly versions is available at [docs.dcs.aitsys.dev](https://docs.discatsharp.tech).
 
 Fallback docs are available at [docs-alt.dcs.aitsys.dev](https://docs-alt.dcs.aitsys.dev).
 
 ## Bugs or Feature requests?
-Write a mail to [dcs@aitsys.dev](mailto:dcs@aitsys.dev).
+Write a mail to [bugs@aitsys.dev](mailto:bugs@aitsys.dev).
 
 All requests are tracked at [aitsys.dev](https://aitsys.dev).
 
 ## Tutorials
-* [Howto](https://docs.dcs.aitsys.dev/articles/basics/bot_account.html)
+* [Howto](https://docs.discatsharp.tech/articles/basics/bot_account.html)
 * [Examples](https://examples.dcs.aitsys.dev)
 
 ## Snippets
 [Snippets for Visual Studio](https://github.com/Aiko-IT-Systems/DisCatSharp.Snippets)
 
 ----
 
 ## NuGet Packages
 ### Main
 | Package                         | Stable                                                                                                           | Nightly                                                                                                                             |
 | ------------------------------- | ---------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
 | DisCatSharp                     | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.svg?label=&logo=nuget&style=flat-square)                     | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.svg?label=&logo=nuget&style=flat-square&color=%23ff1493)                     |
 | DisCatSharp.ApplicationCommands | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.ApplicationCommands.svg?label=&logo=nuget&style=flat-square) | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.ApplicationCommands.svg?label=&logo=nuget&style=flat-square&color=%23ff1493) |
 | DisCatSharp.CommandsNext        | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.CommandsNext.svg?label=&logo=nuget&style=flat-square)        | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.CommandsNext.svg?label=&logo=nuget&style=flat-square&color=%23ff1493)        |
 | DisCatSharp.Interactivity       | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.Interactivity.svg?label=&logo=nuget&style=flat-square)       | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.Interactivity.svg?label=&logo=nuget&style=flat-square&color=%23ff1493)       |
 
 ### Voice
 | Package                       | Stable                                                                                                         | Nightly                                                                                                                           |
 | ----------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
 | DisCatSharp.Lavalink          | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.Lavalink.svg?label=&logo=nuget&style=flat-square)          | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.Lavalink.svg?label=&logo=nuget&style=flat-square&color=%23ff1493)          |
 | DisCatSharp.VoiceNext         | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.VoiceNext.svg?label=&logo=nuget&style=flat-square)         | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.VoiceNext.svg?label=&logo=nuget&style=flat-square&color=%23ff1493)         |
 | DisCatSharp.VoiceNext.Natives | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.VoiceNext.Natives.svg?label=&logo=nuget&style=flat-square) | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.VoiceNext.Natives.svg?label=&logo=nuget&style=flat-square&color=%23ff1493) |
 
 ### Hosting
 | Package                                 | Stable                                                                                                                   | Nightly                                                                                                                                     |
 | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------- |
 | DisCatSharp.Configuration               | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.Configuration.svg?label=&logo=nuget&style=flat-square)               | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.Configuration.svg?label=&logo=nuget&color=%23ff1493&style=flat-square)               |
 | DisCatSharp.Hosting                     | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.Hosting.svg?label=&logo=nuget&style=flat-square)                     | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.Hosting.svg?label=&logo=nuget&color=%23ff1493&style=flat-square)                     |
 | DisCatSharp.Hosting.DependencyInjection | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.Hosting.DependencyInjection.svg?label=&logo=nuget&style=flat-square) | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.Hosting.DependencyInjection.svg?label=&logo=nuget&color=%23ff1493&style=flat-square) |
 
 ### Templates
 | Package                      | Stable                                                                                                        | Nightly                                                                                                                          |
 | ---------------------------- | ------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
 | DisCatSharp.ProjectTemplates | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.ProjectTemplates.svg?label=&logo=nuget&style=flat-square) | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.ProjectTemplates.svg?label=&logo=nuget&color=%23ff1493&style=flat-square) |
 
 ### Development / Commons
 | Package            | Stable                                                                                              | Nightly                                                                                                                |
 | ------------------ | --------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
 | DisCatSharp.Common | ![NuGet](https://img.shields.io/nuget/v/DisCatSharp.Common.svg?label=&logo=nuget&style=flat-square) | ![NuGet](https://img.shields.io/nuget/vpre/DisCatSharp.Common.svg?label=&logo=nuget&style=flat-square&color=%23ff1493) |
 
 
 ----
 
 ## Sponsors [![Sponsors](https://img.shields.io/github/sponsors/Aiko-IT-Systems?label=&style=flat-square&logo=github)](https://github.com/sponsors/Aiko-IT-Systems)
 - [Deividas Kazakevicius](https://github.com/DeividasKaza)
 - [Will](https://github.com/villChurch)
 
 ## Thanks
 Big thanks goes to the following people who helped us ♥️
 - [Auros Nexus](https://github.com/Auros)
 - [Lunar Starstrum](https://github.com/OoLunar)
 - [Johannes](https://github.com/JMLutra)
 - [Geferon](https://github.com/geferon)
 - [Alice](https://github.com/QuantuChi)
 - [Will](https://github.com/villChurch)
 
 ## Special Thanks
 The special thanks goes to Nagisa. Make sure to check out her [instagram](https://www.instagram.com/nagisaarts_/) ♥️♥️
diff --git a/appveyor.yml b/appveyor.yml
index c1c3cc25e..83ec84cba 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,140 +1,140 @@
 -
   branches:
     only:
     - main
   version: 10.0.1-nightly-{build}
   pull_requests:
     do_not_increment_build_number: true
   skip_tags: true
   max_jobs: 1
   image: Visual Studio 2022
   clone_depth: 1
   build_script:
   - ps: |-
       # Version number
       $BUILD_NUMBER = [int]$Env:APPVEYOR_BUILD_NUMBER
       $BUILD_SUFFIX = "nightly"
 
       # Branch
       $BRANCH = "$Env:APPVEYOR_REPO_BRANCH"
       $Env:DOCFX_SOURCE_BRANCH_NAME = "$BRANCH"
 
       # Output directory
       $Env:ARTIFACT_DIR = ".\artifacts"
       $dir = New-Item -type directory $env:ARTIFACT_DIR
       $dir = $dir.FullName
 
       # Verbosity
       Write-Host "Build: $BUILD_NUMBER / Branch: $BRANCH"
       Write-Host "Artifacts will be placed in: $dir"
 
       # Check if this is a PR
       if (-not $Env:APPVEYOR_PULL_REQUEST_NUMBER)
       {
           Write-Host "Commencing complete build"
           & .\rebuild-all.ps1 -ArtifactLocation "$dir" -Configuration "Release" -VersionSuffix "$BUILD_SUFFIX" -BuildNumber $BUILD_NUMBER
           & Remove-Item "$dir\*.symbols.nupkg"
       }
       else
       {
           Write-Host "Building from PR ($Env:APPVEYOR_PULL_REQUEST_NUMBER)"
           & .\rebuild-all.ps1 -ArtifactLocation "$dir" -Configuration "Release" -VersionSuffix "$BUILD_SUFFIX" -BuildNumber $BUILD_NUMBER
           & Remove-Item "$dir\*.symbols.nupkg"
       }
   artifacts:
   - path: artifacts\*.snupkg
   - path: artifacts\*.nupkg
   - path: artifacts\dcs-docs.tar.xz
   deploy:
   - provider: NuGet
     server:
     api_key:
-      secure: eml4lPttwjBZg7WdwX3tbx34ZDNssgb2zwthatNbolRY0PnaCIswbuPClf9IWrw7
+      secure: RjohrwOJE0RgzgIfe71AH42hRr7aZnEz5So/EKRI1FM7LQ/SLrEwSTDsNEQWMQik
     skip_symbols: false
   - provider: GitHub
     auth_token:
       secure: oMF8sv9mhVjO7pBctQOwlmfd5aHQ4hvMoVCz77bgO9+1zBQSelPHxk0bCVfXNCCp
     prerelease: true
     force_update: true
   - provider: NuGet
     server: https://nuget.pkg.github.com/Aiko-IT-Systems/index.json
     username: lulalaby
     api_key:
       secure: SBGo8KrGJ7t5wwMNHKD0WSzrQ+PLJbqXE3FtDH2yGkSrQewO+kzmwp/xGk5a84He
     skip_symbols: true
   on_success:
     - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
     - ps: ./send.ps1 success $env:WEBHOOK_URL
   on_failure:
     - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
     - ps: ./send.ps1 failure $env:WEBHOOK_URL
 # Releases
 -
   branches:
     only:
     - /release/
   version: 10.0.0
   pull_requests:
     do_not_increment_build_number: true
   skip_tags: true
   max_jobs: 1
   image: Visual Studio 2022
   clone_depth: 1
   build_script:
   - ps: |-
       # Version number
       $BUILD_NUMBER = [int]$Env:APPVEYOR_BUILD_NUMBER
 
       # Branch
       $BRANCH = "$Env:APPVEYOR_REPO_BRANCH"
       $Env:DOCFX_SOURCE_BRANCH_NAME = "$BRANCH"
 
       # Output directory
       $Env:ARTIFACT_DIR = ".\artifacts"
       $dir = New-Item -type directory $env:ARTIFACT_DIR
       $dir = $dir.FullName
 
       # Verbosity
       Write-Host "Build: $BUILD_NUMBER / Branch: $BRANCH"
       Write-Host "Artifacts will be placed in: $dir"
 
       # Check if this is a PR
       if (-not $Env:APPVEYOR_PULL_REQUEST_NUMBER)
       {
           Write-Host "Commencing complete build"
           & .\rebuild-all.ps1 -ArtifactLocation "$dir" -Configuration "Release" -VersionSuffix "$BUILD_SUFFIX" -BuildNumber $BUILD_NUMBER
           & Remove-Item "$dir\*.symbols.nupkg"
       }
       else
       {
           Write-Host "Building from PR ($Env:APPVEYOR_PULL_REQUEST_NUMBER)"
           & .\rebuild-all.ps1 -ArtifactLocation "$dir" -Configuration "Release" -VersionSuffix "$BUILD_SUFFIX" -BuildNumber $BUILD_NUMBER
           & Remove-Item "$dir\*.symbols.nupkg"
       }
   artifacts:
   - path: artifacts\*.snupkg
   - path: artifacts\*.nupkg
   - path: artifacts\dcs-docs.tar.xz
   deploy:
   - provider: NuGet
     server:
     api_key:
-      secure: eml4lPttwjBZg7WdwX3tbx34ZDNssgb2zwthatNbolRY0PnaCIswbuPClf9IWrw7
+      secure: hFr7dmC41bUWKRLZTu5SpkkN8Xv0b69VdkDL/wcsMkI4RmkVW6GKWi1iUMrtz0IT
     skip_symbols: false
   - provider: GitHub
     auth_token:
       secure: oMF8sv9mhVjO7pBctQOwlmfd5aHQ4hvMoVCz77bgO9+1zBQSelPHxk0bCVfXNCCp
     prerelease: false
     force_update: true
   - provider: NuGet
     server: https://nuget.pkg.github.com/Aiko-IT-Systems/index.json
     username: lulalaby
     api_key:
       secure: SBGo8KrGJ7t5wwMNHKD0WSzrQ+PLJbqXE3FtDH2yGkSrQewO+kzmwp/xGk5a84He
     skip_symbols: true
   on_success:
     - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
     - ps: ./send.ps1 success $env:WEBHOOK_URL
   on_failure:
     - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
     - ps: ./send.ps1 failure $env:WEBHOOK_URL