diff --git a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
index 518a9c809..f25c7de47 100644
--- a/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
+++ b/DisCatSharp.ApplicationCommands/ApplicationCommandsExtension.cs
@@ -1,1866 +1,1866 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
 
 using DisCatSharp.ApplicationCommands.Attributes;
 using DisCatSharp.ApplicationCommands.EventArgs;
 using DisCatSharp.Common;
 using DisCatSharp.Common.Utilities;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Exceptions;
 
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.ApplicationCommands;
 
 /// <summary>
 /// A class that handles slash commands for a client.
 /// </summary>
 public sealed class ApplicationCommandsExtension : BaseExtension
 {
 	/// <summary>
 	/// A list of methods for top level commands.
 	/// </summary>
 	private static List<CommandMethod> s_commandMethods { get; set; } = new();
 
 	/// <summary>
 	/// List of groups.
 	/// </summary>
 	private static List<GroupCommand> s_groupCommands { get; set; } = new();
 
 	/// <summary>
 	/// List of groups with subgroups.
 	/// </summary>
 	private static List<SubGroupCommand> s_subGroupCommands { get; set; } = new();
 
 	/// <summary>
 	/// List of context menus.
 	/// </summary>
 	private static List<ContextMenuCommand> s_contextMenuCommands { get; set; } = new();
 
 	/// <summary>
 	/// List of global commands on discords backend.
 	/// </summary>
 	internal static List<DiscordApplicationCommand> GlobalDiscordCommands { get; set; }
 
 	/// <summary>
 	/// List of guild commands on discords backend.
 	/// </summary>
 	internal static Dictionary<ulong, List<DiscordApplicationCommand>> GuildDiscordCommands { get; set; }
 
 	/// <summary>
 	/// Singleton modules.
 	/// </summary>
 	private static List<object> s_singletonModules { get; set; } = new();
 
 	/// <summary>
 	/// List of modules to register.
 	/// </summary>
 	private readonly List<KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>> _updateList = new();
 
 	/// <summary>
 	/// Configuration for Discord.
 	/// </summary>
 	internal static ApplicationCommandsConfiguration Configuration;
 
 	/// <summary>
 	/// Set to true if anything fails when registering.
 	/// </summary>
 	private static bool s_errored { get; set; }
 
 	/// <summary>
 	/// Gets a list of registered commands. The key is the guild id (null if global).
 	/// </summary>
 	public IReadOnlyList<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> RegisteredCommands
 		=> s_registeredCommands;
 	private static readonly List<KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>> s_registeredCommands = new();
 
 	/// <summary>
 	/// Gets a list of registered global commands.
 	/// </summary>
 	public IReadOnlyList<DiscordApplicationCommand> GlobalCommands
 		=> GlobalCommandsInternal;
 	internal static readonly List<DiscordApplicationCommand> GlobalCommandsInternal = new();
 
 	/// <summary>
 	/// Gets a list of registered guild commands mapped by guild id.
 	/// </summary>
 	public IReadOnlyDictionary<ulong, IReadOnlyList<DiscordApplicationCommand>> GuildCommands
 		=> GuildCommandsInternal;
 	internal static readonly Dictionary<ulong, IReadOnlyList<DiscordApplicationCommand>> GuildCommandsInternal = new();
 
 	/// <summary>
 	/// Gets the registration count.
 	/// </summary>
 	private static int s_registrationCount { get; set; }
 
 	/// <summary>
 	/// Gets the expected count.
 	/// </summary>
 	private static int s_expectedCount { get; set; }
 
 	/// <summary>
 	/// Gets the guild ids where the applications.commands scope is missing.
 	/// </summary>
 	private IReadOnlyList<ulong> _missingScopeGuildIds;
 
 	/// <summary>
 	/// Gets whether debug is enabled.
 	/// </summary>
 	internal static bool DebugEnabled { get; set; }
 
 	internal static LogLevel ApplicationCommandsLogLevel
 		=> DebugEnabled ? LogLevel.Debug : LogLevel.Trace;
 
 	/// <summary>
 	/// Gets whether check through all guilds is enabled.
 	/// </summary>
 	internal static bool CheckAllGuilds { get; set; }
 
 	/// <summary>
 	/// Gets whether the registration check should be manually overridden.
 	/// </summary>
 	internal static bool ManOr { get; set; }
 
 	/// <summary>
 	/// Gets whether interactions should be automatically deffered.
 	/// </summary>
 	internal static bool AutoDeferEnabled { get; set; }
 
 	/// <summary>
 	/// Whether this module finished the startup.
 	/// </summary>
 	internal bool StartupFinished { get; set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="ApplicationCommandsExtension"/> class.
 	/// </summary>
 	/// <param name="configuration">The configuration.</param>
 	internal ApplicationCommandsExtension(ApplicationCommandsConfiguration configuration = null)
 	{
 		Configuration = configuration;
 		DebugEnabled = configuration?.DebugStartup ?? false;
 		CheckAllGuilds = configuration?.CheckAllGuilds ?? false;
 		ManOr = configuration?.ManualOverride ?? false;
 		AutoDeferEnabled = configuration?.AutoDefer ?? false;
 	}
 
 	/// <summary>
 	/// Runs setup.
 	/// <note type="caution">DO NOT RUN THIS MANUALLY. DO NOT DO ANYTHING WITH THIS.</note>
 	/// </summary>
 	/// <param name="client">The client to setup on.</param>
 	protected internal override void Setup(DiscordClient client)
 	{
 		if (this.Client != null)
 			throw new InvalidOperationException("What did I tell you?");
 
 		this.Client = client;
 
 		this._slashError = new AsyncEvent<ApplicationCommandsExtension, SlashCommandErrorEventArgs>("SLASHCOMMAND_ERRORED", TimeSpan.Zero, null);
 		this._slashExecuted = new AsyncEvent<ApplicationCommandsExtension, SlashCommandExecutedEventArgs>("SLASHCOMMAND_EXECUTED", TimeSpan.Zero, null);
 		this._contextMenuErrored = new AsyncEvent<ApplicationCommandsExtension, ContextMenuErrorEventArgs>("CONTEXTMENU_ERRORED", TimeSpan.Zero, null);
 		this._contextMenuExecuted = new AsyncEvent<ApplicationCommandsExtension, ContextMenuExecutedEventArgs>("CONTEXTMENU_EXECUTED", TimeSpan.Zero, null);
 		this._applicationCommandsModuleReady = new AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs>("APPLICATION_COMMANDS_MODULE_READY", TimeSpan.Zero, null);
 		this._applicationCommandsModuleStartupFinished = new AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs>("APPLICATION_COMMANDS_MODULE_STARTUP_FINISHED", TimeSpan.Zero, null);
 		this._globalApplicationCommandsRegistered = new AsyncEvent<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs>("GLOBAL_COMMANDS_REGISTERED", TimeSpan.Zero, null);
 		this._guildApplicationCommandsRegistered = new AsyncEvent<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs>("GUILD_COMMANDS_REGISTERED", TimeSpan.Zero, null);
 
 		this.StartupFinished = false;
 		this.Client.GuildDownloadCompleted += async (c, e) => await this.UpdateAsync();
 		this.Client.InteractionCreated += this.CatchInteractionsOnStartup;
 		this.Client.ContextMenuInteractionCreated += this.CatchContextMenuInteractionsOnStartup;
 	}
 
 	private async Task CatchInteractionsOnStartup(DiscordClient sender, InteractionCreateEventArgs e)
 	{
 		if (!this.StartupFinished)
 			await e.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AsEphemeral(true).WithContent("Attention: This application is still starting up. Application commands are unavailable for now."));
 		else
 			await Task.Delay(1);
 	}
 
 	private async Task CatchContextMenuInteractionsOnStartup(DiscordClient sender, ContextMenuInteractionCreateEventArgs e)
 	{
 		if (!this.StartupFinished)
 			await e.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder().AsEphemeral(true).WithContent("Attention: This application is still starting up. Context menu commands are unavailable for now."));
 		else
 			await Task.Delay(1);
 	}
 
 	private void FinishedRegistration()
 	{
 		this.Client.InteractionCreated -= this.CatchInteractionsOnStartup;
 		this.Client.ContextMenuInteractionCreated -= this.CatchContextMenuInteractionsOnStartup;
 
 		this.StartupFinished = true;
 
 		this.Client.InteractionCreated += this.InteractionHandler;
 		this.Client.ContextMenuInteractionCreated += this.ContextMenuHandler;
 	}
 	/// <summary>
 	/// Cleans the module for a new start of the bot.
 	/// DO NOT USE IF YOU DON'T KNOW WHAT IT DOES.
 	/// </summary>
 	public void CleanModule()
 	{
 		this._updateList.Clear();
 		s_singletonModules.Clear();
 		s_errored = false;
 		s_expectedCount = 0;
 		s_registrationCount = 0;
 		s_commandMethods.Clear();
 		s_groupCommands.Clear();
 		s_contextMenuCommands.Clear();
 		s_subGroupCommands.Clear();
 		s_singletonModules.Clear();
 		s_registeredCommands.Clear();
 		GlobalCommandsInternal.Clear();
 		GuildCommandsInternal.Clear();
 	}
 
 	/// <summary>
 	/// Cleans all guild application commands.
 	/// <note type="caution">You normally don't need to execute it.</note>
 	/// </summary>
 	public async Task CleanGuildCommandsAsync()
 	{
 		foreach (var guild in this.Client.Guilds.Values)
 			await this.Client.BulkOverwriteGuildApplicationCommandsAsync(guild.Id, Array.Empty<DiscordApplicationCommand>());
 	}
 
 	/// <summary>
 	/// Cleans the global application commands.
 	/// <note type="caution">You normally don't need to execute it.</note>
 	/// </summary>
 	public async Task CleanGlobalCommandsAsync()
 		=> await this.Client.BulkOverwriteGlobalApplicationCommandsAsync(Array.Empty<DiscordApplicationCommand>());
 
 	/// <summary>
 	/// Registers a command class with optional translation setup for a guild.
 	/// </summary>
 	/// <typeparam name="T">The command class to register.</typeparam>
 	/// <param name="guildId">The guild id to register it on.</param>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGuildCommands<T>(ulong guildId, Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
 		=> this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(typeof(T), translationSetup)));
 
 
 	/// <summary>
 	/// Registers a command class with optional translation setup for a guild.
 	/// </summary>
 	/// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
 	/// <param name="guildId">The guild id to register it on.</param>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGuildCommands(Type type, ulong guildId, Action<ApplicationCommandsTranslationContext> translationSetup = null)
 	{
 		if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
 			throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
 		this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(guildId, new ApplicationCommandsModuleConfiguration(type, translationSetup)));
 	}
 
 	/// <summary>
 	/// Registers a command class with optional translation setup globally.
 	/// </summary>
 	/// <typeparam name="T">The command class to register.</typeparam>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGlobalCommands<T>(Action<ApplicationCommandsTranslationContext> translationSetup = null) where T : ApplicationCommandsModule
 		=> this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(typeof(T), translationSetup)));
 
 	/// <summary>
 	/// Registers a command class with optional translation setup globally.
 	/// </summary>
 	/// <param name="type">The <see cref="System.Type"/> of the command class to register.</param>
 	/// <param name="translationSetup">A callback to setup translations with.</param>
 	public void RegisterGlobalCommands(Type type, Action<ApplicationCommandsTranslationContext> translationSetup = null)
 	{
 		if (!typeof(ApplicationCommandsModule).IsAssignableFrom(type))
 			throw new ArgumentException("Command classes have to inherit from ApplicationCommandsModule", nameof(type));
 		this._updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>(null, new ApplicationCommandsModuleConfiguration(type, translationSetup)));
 	}
 
 	/// <summary>
 	/// Fired when the application commands module is ready.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs> ApplicationCommandsModuleReady
 	{
 		add => this._applicationCommandsModuleReady.Register(value);
 		remove => this._applicationCommandsModuleReady.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleReadyEventArgs> _applicationCommandsModuleReady;
 
 	/// <summary>
 	/// Fired when the application commands modules startup is finished.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs> ApplicationCommandsModuleStartupFinished
 	{
 		add => this._applicationCommandsModuleStartupFinished.Register(value);
 		remove => this._applicationCommandsModuleStartupFinished.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ApplicationCommandsModuleStartupFinishedEventArgs> _applicationCommandsModuleStartupFinished;
 
 
 	/// <summary>
 	/// Fired when guild commands are registered on a guild.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs> GuildApplicationCommandsRegistered
 	{
 		add => this._guildApplicationCommandsRegistered.Register(value);
 		remove => this._guildApplicationCommandsRegistered.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, GuildApplicationCommandsRegisteredEventArgs> _guildApplicationCommandsRegistered;
 
 	/// <summary>
 	/// Fired when the global commands are registered.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs> GlobalApplicationCommandsRegistered
 	{
 		add => this._globalApplicationCommandsRegistered.Register(value);
 		remove => this._globalApplicationCommandsRegistered.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, GlobalApplicationCommandsRegisteredEventArgs> _globalApplicationCommandsRegistered;
 
 	/// <summary>
 	/// Used for RegisterCommands and the <see cref="DisCatSharp.DiscordClient.Ready"/> event.
 	/// </summary>
 	internal async Task UpdateAsync()
 	{
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Request to register commands on shard {shard}", this.Client.ShardId);
 		GlobalDiscordCommands = new();
 		GuildDiscordCommands = new();
 
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Expected Count: {count}", s_expectedCount);
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Shard {shard} has {guilds} guilds.", this.Client.ShardId, this.Client.Guilds?.Count);
 		List<ulong> failedGuilds = new();
 		List<DiscordApplicationCommand> globalCommands = null;
 		globalCommands = (await this.Client.GetGlobalApplicationCommandsAsync(Configuration?.EnableLocalization ?? false)).ToList() ?? null;
 		var updateList = this._updateList;
 		var guilds = CheckAllGuilds ? this.Client.Guilds?.Keys.ToList() : updateList.Where(x => x.Key != null)?.Select(x => x.Key.Value).Distinct().ToList();
 		var wrongShards = guilds.Where(x => !this.Client.Guilds.ContainsKey(x)).ToList();
 		if (wrongShards.Any())
 		{
 			this.Client.Logger.Log(ApplicationCommandsLogLevel, "Some guilds are not on the same shard as the client. Removing them from the update list.");
 			foreach (var guild in wrongShards)
 			{
 				updateList.RemoveAll(x => x.Key == guild);
 				guilds.Remove(guild);
 			}
 		}
 
 		var commandsPending = updateList.Select(x => x.Key).Distinct().ToList();
-		s_expectedCount = commandsPending.Count();
+		s_expectedCount = commandsPending.Count;
 
 		foreach (var guild in guilds)
 		{
 			List<DiscordApplicationCommand> commands = null;
 			var unauthorized = false;
 			try
 			{
 				commands = (await this.Client.GetGuildApplicationCommandsAsync(guild, Configuration?.EnableLocalization ?? false)).ToList() ?? null;
 			}
 			catch (UnauthorizedException)
 			{
 				unauthorized = true;
 			}
 			finally
 			{
 				if (!unauthorized && commands != null && commands.Any())
 					GuildDiscordCommands.Add(guild, commands.ToList());
 				else if (unauthorized)
 					failedGuilds.Add(guild);
 			}
 		}
 
 		//Default should be to add the help and slash commands can be added without setting any configuration
 		//so this should still add the default help
 		if (Configuration is null || (Configuration is not null && Configuration.EnableDefaultHelp))
 		{
 			updateList.Add(new KeyValuePair<ulong?, ApplicationCommandsModuleConfiguration>
 				(null, new ApplicationCommandsModuleConfiguration(typeof(DefaultHelpModule))));
 			commandsPending = updateList.Select(x => x.Key).Distinct().ToList();
 		}
 
 		if (globalCommands != null && globalCommands.Any())
 			GlobalDiscordCommands.AddRange(globalCommands);
 
 		foreach (var key in commandsPending)
 		{
 			this.Client.Logger.Log(ApplicationCommandsLogLevel, key.HasValue ? $"Registering commands in guild {key.Value}" : "Registering global commands.");
 			if (key.HasValue)
 			{
 				this.Client.Logger.Log(ApplicationCommandsLogLevel, "Found guild {guild} in shard {shard}!", key.Value, this.Client.ShardId);
 				this.Client.Logger.Log(ApplicationCommandsLogLevel, "Registering");
 			}
 			await this.RegisterCommands(updateList.Where(x => x.Key == key).Select(x => x.Value).ToList(), key);
 		}
 
 		this._missingScopeGuildIds = failedGuilds;
 
 		await this._applicationCommandsModuleReady.InvokeAsync(this, new ApplicationCommandsModuleReadyEventArgs(Configuration?.ServiceProvider)
 		{
 			GuildsWithoutScope = failedGuilds
 		});
 		this.Client.GuildDownloadCompleted -= async (c, e) => await this.UpdateAsync();
 	}
 
 	/// <summary>
 	/// Method for registering commands for a target from modules.
 	/// </summary>
 	/// <param name="types">The types.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	private async Task RegisterCommands(List<ApplicationCommandsModuleConfiguration> types, ulong? guildId)
 	{
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Registering commands on shard {shard}", this.Client.ShardId);
 		//Initialize empty lists to be added to the global ones at the end
 		var commandMethods = new List<CommandMethod>();
 		var groupCommands = new List<GroupCommand>();
 		var subGroupCommands = new List<SubGroupCommand>();
 		var contextMenuCommands = new List<ContextMenuCommand>();
 		var updateList = new List<DiscordApplicationCommand>();
 
 		var commandTypeSources = new List<KeyValuePair<Type, Type>>();
 
 		//Iterates over all the modules
 		foreach (var config in types)
 		{
 			var type = config.Type;
 			try
 			{
 				var module = type.GetTypeInfo();
 				var classes = new List<TypeInfo>();
 
 				var ctx = new ApplicationCommandsTranslationContext(type, module.FullName);
 				config.Translations?.Invoke(ctx);
 
 				//Add module to classes list if it's a group
 				if (module.GetCustomAttribute<SlashCommandGroupAttribute>() != null)
 				{
 					classes.Add(module);
 				}
 				else
 				{
 					//Otherwise add the nested groups
 					classes = module.DeclaredNestedTypes.Where(x => x.GetCustomAttribute<SlashCommandGroupAttribute>() != null).ToList();
 				}
 
 				List<GroupTranslator> groupTranslations = null;
 
 				if (!string.IsNullOrEmpty(ctx.Translations))
 				{
 					groupTranslations = JsonConvert.DeserializeObject<List<GroupTranslator>>(ctx.Translations);
 				}
 
 				var slashGroupsTuple = await NestedCommandWorker.ParseSlashGroupsAsync(type, classes, guildId, groupTranslations);
 
 				if (slashGroupsTuple.applicationCommands != null && slashGroupsTuple.applicationCommands.Any())
 					updateList.AddRange(slashGroupsTuple.applicationCommands);
 
 				if (slashGroupsTuple.commandTypeSources != null && slashGroupsTuple.commandTypeSources.Any())
 					commandTypeSources.AddRange(slashGroupsTuple.commandTypeSources);
 
 				if (slashGroupsTuple.singletonModules != null && slashGroupsTuple.singletonModules.Any())
 					s_singletonModules.AddRange(slashGroupsTuple.singletonModules);
 
 				if (slashGroupsTuple.groupCommands != null && slashGroupsTuple.groupCommands.Any())
 					groupCommands.AddRange(slashGroupsTuple.groupCommands);
 
 				if (slashGroupsTuple.subGroupCommands != null && slashGroupsTuple.subGroupCommands.Any())
 					subGroupCommands.AddRange(slashGroupsTuple.subGroupCommands);
 
 				//Handles methods and context menus, only if the module isn't a group itself
 				if (module.GetCustomAttribute<SlashCommandGroupAttribute>() == null)
 				{
 					List<CommandTranslator> commandTranslations = null;
 
 					if (!string.IsNullOrEmpty(ctx.Translations))
 					{
 						commandTranslations = JsonConvert.DeserializeObject<List<CommandTranslator>>(ctx.Translations);
 					}
 
 					//Slash commands
 					var methods = module.DeclaredMethods.Where(x => x.GetCustomAttribute<SlashCommandAttribute>() != null);
 
 					var slashCommands = await CommandWorker.ParseBasicSlashCommandsAsync(type, methods, guildId, commandTranslations);
 
 					if (slashCommands.applicationCommands != null && slashCommands.applicationCommands.Any())
 						updateList.AddRange(slashCommands.applicationCommands);
 
 					if (slashCommands.commandTypeSources != null && slashCommands.commandTypeSources.Any())
 						commandTypeSources.AddRange(slashCommands.commandTypeSources);
 
 					if (slashCommands.commandMethods != null && slashCommands.commandMethods.Any())
 						commandMethods.AddRange(slashCommands.commandMethods);
 
 					//Context Menus
 					var contextMethods = module.DeclaredMethods.Where(x => x.GetCustomAttribute<ContextMenuAttribute>() != null);
 
 					var contextCommands = await CommandWorker.ParseContextMenuCommands(type, contextMethods, commandTranslations);
 
 					if (contextCommands.applicationCommands != null && contextCommands.applicationCommands.Any())
 						updateList.AddRange(contextCommands.applicationCommands);
 
 					if (contextCommands.commandTypeSources != null && contextCommands.commandTypeSources.Any())
 						commandTypeSources.AddRange(contextCommands.commandTypeSources);
 
 					if (contextCommands.contextMenuCommands != null && contextCommands.contextMenuCommands.Any())
 						contextMenuCommands.AddRange(contextCommands.contextMenuCommands);
 
 					//Accounts for lifespans
 					if (module.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null && module.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>().Lifespan == ApplicationCommandModuleLifespan.Singleton)
 						s_singletonModules.Add(CreateInstance(module, Configuration?.ServiceProvider));
 				}
 			}
 			catch (Exception ex)
 			{
 				if (ex is BadRequestException brex)
 				{
 					this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.WebResponse.Response}");
 				}
 				else
 				{
 					if (ex.InnerException is not null && ex.InnerException is BadRequestException brex1)
 						this.Client.Logger.LogCritical(brex1, $"There was an error registering application commands: {brex1.WebResponse.Response}");
 					else
 						this.Client.Logger.LogCritical(ex, $"There was an error parsing the application commands");
 				}
 				s_errored = true;
 			}
 		}
 		if (!s_errored)
 		{
 			try
 			{
 				List<DiscordApplicationCommand> commands = new();
 
 				try
 				{
 					if (guildId == null)
 					{
 						if (updateList != null && updateList.Any())
 						{
 							var regCommands = await RegistrationWorker.RegisterGlobalCommandsAsync(this.Client, updateList);
 							var actualCommands = regCommands.Distinct().ToList();
 							commands.AddRange(actualCommands);
 							GlobalCommandsInternal.AddRange(actualCommands);
 						}
 						else
 						{
 							foreach (var cmd in GlobalDiscordCommands)
 							{
 								try
 								{
 									await this.Client.DeleteGlobalApplicationCommandAsync(cmd.Id);
 								}
 								catch (NotFoundException)
 								{
 									this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Could not delete global command {cmd.Id}. Please clean up manually");
 								}
 							}
 						}
 					}
 					else
 					{
 						if (updateList != null && updateList.Any())
 						{
 							var regCommands = await  RegistrationWorker.RegisterGuildCommandsAsync(this.Client, guildId.Value, updateList);
 							var actualCommands = regCommands.Distinct().ToList();
 							commands.AddRange(actualCommands);
 							GuildCommandsInternal.Add(guildId.Value, actualCommands);
 							/*
 							if (client.Guilds.TryGetValue(guildId.Value, out var guild))
 							{
 								guild.InternalRegisteredApplicationCommands = new();
 								guild.InternalRegisteredApplicationCommands.AddRange(actualCommands);
 							}
 							*/
 						}
 						else
 						{
 							foreach (var cmd in GuildDiscordCommands.First(x => x.Key == guildId.Value).Value)
 							{
 								try
 								{
 									await this.Client.DeleteGuildApplicationCommandAsync(guildId.Value, cmd.Id);
 								}
 								catch (NotFoundException)
 								{
 									this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Could not delete guild command {cmd.Id} in guild {guildId.Value}. Please clean up manually");
 								}
 							}
 						}
 					}
 				}
 				catch (UnauthorizedException ex)
 				{
 					this.Client.Logger.LogError($"Could not register application commands for guild {guildId}.\nError: {ex.JsonMessage}");
 					return;
 				}
 				//Creates a guild command if a guild id is specified, otherwise global
 				//Checks against the ids and adds them to the command method lists
 				foreach (var command in commands)
 				{
 					if (commandMethods.GetFirstValueWhere(x => x.Name == command.Name, out var com))
 						com.CommandId = command.Id;
 					else if (groupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var groupCom))
 						groupCom.CommandId = command.Id;
 					else if (subGroupCommands.GetFirstValueWhere(x => x.Name == command.Name, out var subCom))
 						subCom.CommandId = command.Id;
 					else if (contextMenuCommands.GetFirstValueWhere(x => x.Name == command.Name, out var cmCom))
 						cmCom.CommandId = command.Id;
 				}
 
 				//Adds to the global lists finally
 				s_commandMethods.AddRange(commandMethods);
 				s_groupCommands.AddRange(groupCommands);
 				s_subGroupCommands.AddRange(subGroupCommands);
 				s_contextMenuCommands.AddRange(contextMenuCommands);
 
 				s_registeredCommands.Add(new KeyValuePair<ulong?, IReadOnlyList<DiscordApplicationCommand>>(guildId, commands.ToList()));
 
 				foreach (var command in commandMethods)
 				{
 					var app = types.First(t => t.Type == command.Method.DeclaringType);
 				}
 
 				this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Expected Count: {s_expectedCount}\nCurrent Count: {s_registrationCount}");
 
 				if (guildId.HasValue)
 				{
 					await this._guildApplicationCommandsRegistered.InvokeAsync(this, new GuildApplicationCommandsRegisteredEventArgs(Configuration?.ServiceProvider)
 					{
 						Handled = true,
 						GuildId = guildId.Value,
 						RegisteredCommands = GuildCommandsInternal.Any(c => c.Key == guildId.Value) ? GuildCommandsInternal.FirstOrDefault(c => c.Key == guildId.Value).Value : null
 					});
 				}
 				else
 				{
 					await this._globalApplicationCommandsRegistered.InvokeAsync(this, new GlobalApplicationCommandsRegisteredEventArgs(Configuration?.ServiceProvider)
 					{
 						Handled = true,
 						RegisteredCommands = GlobalCommandsInternal
 					});
 				}
 
 				s_registrationCount++;
 				this.CheckRegistrationStartup(ManOr);
 			}
 			catch (Exception ex)
 			{
 				if (ex is BadRequestException brex)
 				{
 					this.Client.Logger.LogCritical(brex, $"There was an error registering application commands: {brex.WebResponse.Response}");
 				}
 				else
 				{
 					if (ex.InnerException is not null && ex.InnerException is BadRequestException brex1)
 						this.Client.Logger.LogCritical(brex1, $"There was an error registering application commands: {brex1.WebResponse.Response}");
 					else
 						this.Client.Logger.LogCritical(ex, $"There was an general error registering application commands");
 				}
 				s_errored = true;
 			}
 		}
 	}
 
 	private async void CheckRegistrationStartup(bool man = false)
 	{
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, $"Checking counts...\n\n" +
 			$"Expected Count: {s_expectedCount}\n" +
 			$"Current Count: {s_registrationCount}");
 
 		if ((s_registrationCount == s_expectedCount) || man)
 		{
 			await this._applicationCommandsModuleStartupFinished.InvokeAsync(this, new ApplicationCommandsModuleStartupFinishedEventArgs(Configuration?.ServiceProvider)
 			{
 				Handled = true,
 				RegisteredGlobalCommands = GlobalCommandsInternal,
 				RegisteredGuildCommands = GuildCommandsInternal,
 				GuildsWithoutScope = this._missingScopeGuildIds
 			});
 
 			this.FinishedRegistration();
 		}
 	}
 
 	/// <summary>
 	/// Interaction handler.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The event args.</param>
 	private Task InteractionHandler(DiscordClient client, InteractionCreateEventArgs e)
 	{
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Got interaction on shard {shard}", this.Client.ShardId);
 		_ = Task.Run(async () =>
 		{
 			if (e.Interaction.Type == InteractionType.ApplicationCommand)
 			{
 				//Creates the context
 				var context = new InteractionContext
 				{
 					Interaction = e.Interaction,
 					Channel = e.Interaction.Channel,
 					Guild = e.Interaction.Guild,
 					User = e.Interaction.User,
 					Client = client,
 					ApplicationCommandsExtension = this,
 					CommandName = e.Interaction.Data.Name,
 					InteractionId = e.Interaction.Id,
 					Token = e.Interaction.Token,
 					Services = Configuration?.ServiceProvider,
 					ResolvedUserMentions = e.Interaction.Data.Resolved?.Users?.Values.ToList(),
 					ResolvedRoleMentions = e.Interaction.Data.Resolved?.Roles?.Values.ToList(),
 					ResolvedChannelMentions = e.Interaction.Data.Resolved?.Channels?.Values.ToList(),
 					ResolvedAttachments = e.Interaction.Data.Resolved?.Attachments?.Values.ToList(),
 					Type = ApplicationCommandType.ChatInput,
 					Locale = e.Interaction.Locale,
 					GuildLocale = e.Interaction.GuildLocale,
 					AppPermissions = e.Interaction.AppPermissions
 				};
 
 				try
 				{
 					if (s_errored)
 						throw new InvalidOperationException("Slash commands failed to register properly on startup.");
 
 					var methods = s_commandMethods.Where(x => x.CommandId == e.Interaction.Data.Id);
 					var groups = s_groupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 					var subgroups = s_subGroupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 					if (!methods.Any() && !groups.Any() && !subgroups.Any())
 						throw new InvalidOperationException("A slash command was executed, but no command was registered for it.");
 
 					if (methods.Any())
 					{
 						var method = methods.First().Method;
 						this.Client.Logger.LogDebug("Executing {cmd}", method.Name);
 						var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options);
 
 						await this.RunCommandAsync(context, method, args);
 					}
 					else if (groups.Any())
 					{
 						var command = e.Interaction.Data.Options.First();
 						var method = groups.First().Methods.First(x => x.Key == command.Name).Value;
 
 						this.Client.Logger.LogDebug("Executing {cmd}", method.Name);
 						var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options.First().Options);
 
 						await this.RunCommandAsync(context, method, args);
 					}
 					else if (subgroups.Any())
 					{
 						var command = e.Interaction.Data.Options.First();
 						var group = subgroups.First().SubCommands.First(x => x.Name == command.Name);
 
 						var method = group.Methods.First(x => x.Key == command.Options.First().Name).Value;
 
 						this.Client.Logger.LogDebug("Executing {cmd}", method.Name);
 						var args = await this.ResolveInteractionCommandParameters(e, context, method, e.Interaction.Data.Options.First().Options.First().Options);
 
 						await this.RunCommandAsync(context, method, args);
 					}
 
 					await this._slashExecuted.InvokeAsync(this, new SlashCommandExecutedEventArgs(this.Client.ServiceProvider) { Context = context });
 				}
 				catch (Exception ex)
 				{
 					this.Client.Logger.LogError(ex.Message);
 					this.Client.Logger.LogError(ex.StackTrace);
 
 					await this._slashError.InvokeAsync(this, new SlashCommandErrorEventArgs(this.Client.ServiceProvider) { Context = context, Exception = ex });
 				}
 			}
 			else if (e.Interaction.Type == InteractionType.AutoComplete)
 			{
 				if (s_errored)
 					throw new InvalidOperationException("Slash commands failed to register properly on startup.");
 
 				var methods = s_commandMethods.Where(x => x.CommandId == e.Interaction.Data.Id);
 				var groups = s_groupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 				var subgroups = s_subGroupCommands.Where(x => x.CommandId == e.Interaction.Data.Id);
 				if (!methods.Any() && !groups.Any() && !subgroups.Any())
 					throw new InvalidOperationException("An autocomplete interaction was created, but no command was registered for it.");
 
 				try
 				{
 					if (methods.Any())
 					{
 						var focusedOption = e.Interaction.Data.Options.First(o => o.Focused);
 						var method = methods.First().Method;
 
 						var option = method.GetParameters().Skip(1).First(p => p.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name);
 						var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
 						var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
 						var providerInstance = Activator.CreateInstance(provider);
 
 						var context = new AutocompleteContext
 						{
 							Interaction = e.Interaction,
 							Client = client,
 							Services = Configuration?.ServiceProvider,
 							ApplicationCommandsExtension = this,
 							Guild = e.Interaction.Guild,
 							Channel = e.Interaction.Channel,
 							User = e.Interaction.User,
 							Options = e.Interaction.Data.Options.ToList(),
 							FocusedOption = focusedOption,
 							Locale = e.Interaction.Locale,
 							GuildLocale = e.Interaction.GuildLocale,
 							AppPermissions = e.Interaction.AppPermissions
 						};
 
 						var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
 						await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
 					}
 					else if (groups.Any())
 					{
 						var command = e.Interaction.Data.Options.First();
 						var group = groups.First().Methods.First(x => x.Key == command.Name).Value;
 
 						var focusedOption = command.Options.First(o => o.Focused);
 						var option = group.GetParameters().Skip(1).First(p => p.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name);
 						var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
 						var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
 						var providerInstance = Activator.CreateInstance(provider);
 
 						var context = new AutocompleteContext
 						{
 							Client = client,
 							Interaction = e.Interaction,
 							Services = Configuration?.ServiceProvider,
 							ApplicationCommandsExtension = this,
 							Guild = e.Interaction.Guild,
 							Channel = e.Interaction.Channel,
 							User = e.Interaction.User,
 							Options = command.Options.ToList(),
 							FocusedOption = focusedOption,
 							Locale = e.Interaction.Locale,
 							GuildLocale = e.Interaction.GuildLocale,
 							AppPermissions = e.Interaction.AppPermissions
 						};
 
 						var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
 						await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
 					}
 					else if (subgroups.Any())
 					{
 						var command = e.Interaction.Data.Options.First();
 						var group = subgroups.First().SubCommands.First(x => x.Name == command.Name).Methods.First(x => x.Key == command.Options.First().Name).Value;
 
 						var focusedOption = command.Options.First().Options.First(o => o.Focused);
 
 						var option = group.GetParameters().Skip(1).First(p => p.GetCustomAttribute<OptionAttribute>().Name == focusedOption.Name);
 						var provider = option.GetCustomAttribute<AutocompleteAttribute>().ProviderType;
 						var providerMethod = provider.GetMethod(nameof(IAutocompleteProvider.Provider));
 						var providerInstance = Activator.CreateInstance(provider);
 
 						var context = new AutocompleteContext
 						{
 							Client = client,
 							Interaction = e.Interaction,
 							Services = Configuration?.ServiceProvider,
 							ApplicationCommandsExtension = this,
 							Guild = e.Interaction.Guild,
 							Channel = e.Interaction.Channel,
 							User = e.Interaction.User,
 							Options = command.Options.First().Options.ToList(),
 							FocusedOption = focusedOption,
 							Locale = e.Interaction.Locale,
 							GuildLocale = e.Interaction.GuildLocale,
 							AppPermissions = e.Interaction.AppPermissions
 						};
 
 						var choices = await (Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>>) providerMethod.Invoke(providerInstance, new[] { context });
 						await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, new DiscordInteractionResponseBuilder().AddAutoCompleteChoices(choices));
 					}
 				}
 				catch (Exception ex)
 				{
 					this.Client.Logger.LogError(ex, "Error in autocomplete interaction");
 				}
 			}
 		});
 		return Task.CompletedTask;
 	}
 
 	/// <summary>
 	/// Context menu handler.
 	/// </summary>
 	/// <param name="client">The client.</param>
 	/// <param name="e">The event args.</param>
 	private Task ContextMenuHandler(DiscordClient client, ContextMenuInteractionCreateEventArgs e)
 	{
 		_ = Task.Run(async () =>
 		{
 			//Creates the context
 			var context = new ContextMenuContext
 			{
 				Interaction = e.Interaction,
 				Channel = e.Interaction.Channel,
 				Client = client,
 				Services = Configuration?.ServiceProvider,
 				CommandName = e.Interaction.Data.Name,
 				ApplicationCommandsExtension = this,
 				Guild = e.Interaction.Guild,
 				InteractionId = e.Interaction.Id,
 				User = e.Interaction.User,
 				Token = e.Interaction.Token,
 				TargetUser = e.TargetUser,
 				TargetMessage = e.TargetMessage,
 				Type = e.Type,
 				Locale = e.Interaction.Locale,
 				GuildLocale = e.Interaction.GuildLocale,
 				AppPermissions = e.Interaction.AppPermissions
 			};
 
 			try
 			{
 				if (s_errored)
 					throw new InvalidOperationException("Context menus failed to register properly on startup.");
 
 				//Gets the method for the command
 				var method = s_contextMenuCommands.FirstOrDefault(x => x.CommandId == e.Interaction.Data.Id);
 
 				if (method == null)
 					throw new InvalidOperationException("A context menu was executed, but no command was registered for it.");
 
 				await this.RunCommandAsync(context, method.Method, new[] { context });
 
 				await this._contextMenuExecuted.InvokeAsync(this, new ContextMenuExecutedEventArgs(this.Client.ServiceProvider) { Context = context });
 			}
 			catch (Exception ex)
 			{
 				await this._contextMenuErrored.InvokeAsync(this, new ContextMenuErrorEventArgs(this.Client.ServiceProvider) { Context = context, Exception = ex });
 			}
 		});
 
 		return Task.CompletedTask;
 	}
 
 	/// <summary>
 	/// Runs a command.
 	/// </summary>
 	/// <param name="context">The base context.</param>
 	/// <param name="method">The method info.</param>
 	/// <param name="args">The arguments.</param>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE0066:Convert switch statement to expression", Justification = "<Pending>")]
 	internal async Task RunCommandAsync(BaseContext context, MethodInfo method, IEnumerable<object> args)
 	{
 		object classInstance;
 
 		this.Client.Logger.Log(ApplicationCommandsLogLevel, "Executing {cmd}", method.Name);
 		//Accounts for lifespans
 		var moduleLifespan = (method.DeclaringType.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>() != null ? method.DeclaringType.GetCustomAttribute<ApplicationCommandModuleLifespanAttribute>()?.Lifespan : ApplicationCommandModuleLifespan.Transient) ?? ApplicationCommandModuleLifespan.Transient;
 		switch (moduleLifespan)
 		{
 			case ApplicationCommandModuleLifespan.Scoped:
 				//Accounts for static methods and adds DI
 				classInstance = method.IsStatic ? ActivatorUtilities.CreateInstance(Configuration?.ServiceProvider.CreateScope().ServiceProvider, method.DeclaringType) : CreateInstance(method.DeclaringType, Configuration?.ServiceProvider.CreateScope().ServiceProvider);
 				break;
 
 			case ApplicationCommandModuleLifespan.Transient:
 				//Accounts for static methods and adds DI
 				classInstance = method.IsStatic ? ActivatorUtilities.CreateInstance(Configuration?.ServiceProvider, method.DeclaringType) : CreateInstance(method.DeclaringType, Configuration?.ServiceProvider);
 				break;
 
 			//If singleton, gets it from the singleton list
 			case ApplicationCommandModuleLifespan.Singleton:
 				classInstance = s_singletonModules.First(x => ReferenceEquals(x.GetType(), method.DeclaringType));
 				break;
 
 			default:
 				throw new Exception($"An unknown {nameof(ApplicationCommandModuleLifespanAttribute)} scope was specified on command {context.CommandName}");
 		}
 
 		ApplicationCommandsModule module = null;
 		if (classInstance is ApplicationCommandsModule mod)
 			module = mod;
 
 		// Slash commands
 		if (context is InteractionContext slashContext)
 		{
 			await this.RunPreexecutionChecksAsync(method, slashContext);
 
 			var shouldExecute = await (module?.BeforeSlashExecutionAsync(slashContext) ?? Task.FromResult(true));
 
 			if (shouldExecute)
 			{
 				if (AutoDeferEnabled)
 					await context.CreateResponseAsync(InteractionResponseType.DeferredChannelMessageWithSource);
 				await (Task)method.Invoke(classInstance, args.ToArray());
 
 				await (module?.AfterSlashExecutionAsync(slashContext) ?? Task.CompletedTask);
 			}
 		}
 		// Context menus
 		if (context is ContextMenuContext contextMenuContext)
 		{
 			await this.RunPreexecutionChecksAsync(method, contextMenuContext);
 
 			var shouldExecute = await (module?.BeforeContextMenuExecutionAsync(contextMenuContext) ?? Task.FromResult(true));
 
 			if (shouldExecute)
 			{
 				if (AutoDeferEnabled)
 					await context.CreateResponseAsync(InteractionResponseType.DeferredChannelMessageWithSource);
 				await (Task)method.Invoke(classInstance, args.ToArray());
 
 				await (module?.AfterContextMenuExecutionAsync(contextMenuContext) ?? Task.CompletedTask);
 			}
 		}
 	}
 
 	/// <summary>
 	/// Property injection
 	/// </summary>
 	/// <param name="t">The type.</param>
 	/// <param name="services">The services.</param>
 	internal static object CreateInstance(Type t, IServiceProvider services)
 	{
 		var ti = t.GetTypeInfo();
 		var constructors = ti.DeclaredConstructors
 			.Where(xci => xci.IsPublic)
 			.ToArray();
 
 		if (constructors.Length != 1)
 			throw new ArgumentException("Specified type does not contain a public constructor or contains more than one public constructor.");
 
 		var constructor = constructors[0];
 		var constructorArgs = constructor.GetParameters();
 		var args = new object[constructorArgs.Length];
 
 		if (constructorArgs.Length != 0 && services == null)
 			throw new InvalidOperationException("Dependency collection needs to be specified for parameterized constructors.");
 
 		// inject via constructor
 		if (constructorArgs.Length != 0)
 			for (var i = 0; i < args.Length; i++)
 				args[i] = services.GetRequiredService(constructorArgs[i].ParameterType);
 
 		var moduleInstance = Activator.CreateInstance(t, args);
 
 		// inject into properties
 		var props = t.GetRuntimeProperties().Where(xp => xp.CanWrite && xp.SetMethod != null && !xp.SetMethod.IsStatic && xp.SetMethod.IsPublic);
 		foreach (var prop in props)
 		{
 			if (prop.GetCustomAttribute<DontInjectAttribute>() != null)
 				continue;
 
 			var service = services.GetService(prop.PropertyType);
 			if (service == null)
 				continue;
 
 			prop.SetValue(moduleInstance, service);
 		}
 
 		// inject into fields
 		var fields = t.GetRuntimeFields().Where(xf => !xf.IsInitOnly && !xf.IsStatic && xf.IsPublic);
 		foreach (var field in fields)
 		{
 			if (field.GetCustomAttribute<DontInjectAttribute>() != null)
 				continue;
 
 			var service = services.GetService(field.FieldType);
 			if (service == null)
 				continue;
 
 			field.SetValue(moduleInstance, service);
 		}
 
 		return moduleInstance;
 	}
 
 	/// <summary>
 	/// Resolves the slash command parameters.
 	/// </summary>
 	/// <param name="e">The event arguments.</param>
 	/// <param name="context">The interaction context.</param>
 	/// <param name="method">The method info.</param>
 	/// <param name="options">The options.</param>
 	private async Task<List<object>> ResolveInteractionCommandParameters(InteractionCreateEventArgs e, InteractionContext context, MethodInfo method, IEnumerable<DiscordInteractionDataOption> options)
 	{
 		var args = new List<object> { context };
 		var parameters = method.GetParameters().Skip(1);
 
 		foreach (var parameter in parameters)
 		{
 			//Accounts for optional arguments without values given
 			if (parameter.IsOptional && (options == null || (!options?.Any(x => x.Name == parameter.GetCustomAttribute<OptionAttribute>().Name.ToLower()) ?? true)))
 				args.Add(parameter.DefaultValue);
 			else
 			{
 				var option = options.Single(x => x.Name == parameter.GetCustomAttribute<OptionAttribute>().Name.ToLower());
 
 				if (parameter.ParameterType == typeof(string))
 					args.Add(option.Value.ToString());
 				else if (parameter.ParameterType.IsEnum)
 					args.Add(Enum.Parse(parameter.ParameterType, (string)option.Value));
 				else if (parameter.ParameterType == typeof(long) || parameter.ParameterType == typeof(long?))
 					args.Add((long?)option.Value);
 				else if (parameter.ParameterType == typeof(bool) || parameter.ParameterType == typeof(bool?))
 					args.Add((bool?)option.Value);
 				else if (parameter.ParameterType == typeof(double) || parameter.ParameterType == typeof(double?))
 					args.Add((double?)option.Value);
 				else if (parameter.ParameterType == typeof(int) || parameter.ParameterType == typeof(int?))
 					args.Add((int?)option.Value);
 				else if (parameter.ParameterType == typeof(DiscordAttachment))
 				{
 					//Checks through resolved
 					if (e.Interaction.Data.Resolved.Attachments != null &&
 						e.Interaction.Data.Resolved.Attachments.TryGetValue((ulong)option.Value, out var attachment))
 						args.Add(attachment);
 					else
 						args.Add(new DiscordAttachment() { Id = (ulong)option.Value, Discord = this.Client.ApiClient.Discord });
 				}
 				else if (parameter.ParameterType == typeof(DiscordUser))
 				{
 					//Checks through resolved
 					if (e.Interaction.Data.Resolved.Members != null &&
 						e.Interaction.Data.Resolved.Members.TryGetValue((ulong)option.Value, out var member))
 						args.Add(member);
 					else if (e.Interaction.Data.Resolved.Users != null &&
 							 e.Interaction.Data.Resolved.Users.TryGetValue((ulong)option.Value, out var user))
 						args.Add(user);
 					else
 						args.Add(await this.Client.GetUserAsync((ulong)option.Value));
 				}
 				else if (parameter.ParameterType == typeof(DiscordChannel))
 				{
 					//Checks through resolved
 					if (e.Interaction.Data.Resolved.Channels != null &&
 						e.Interaction.Data.Resolved.Channels.TryGetValue((ulong)option.Value, out var channel))
 						args.Add(channel);
 					else
 						args.Add(e.Interaction.Guild.GetChannel((ulong)option.Value));
 				}
 				else if (parameter.ParameterType == typeof(DiscordRole))
 				{
 					//Checks through resolved
 					if (e.Interaction.Data.Resolved.Roles != null &&
 						e.Interaction.Data.Resolved.Roles.TryGetValue((ulong)option.Value, out var role))
 						args.Add(role);
 					else
 						args.Add(e.Interaction.Guild.GetRole((ulong)option.Value));
 				}
 				else if (parameter.ParameterType == typeof(SnowflakeObject))
 				{
 					//Checks through resolved
 					if (e.Interaction.Data.Resolved.Channels != null && e.Interaction.Data.Resolved.Channels.TryGetValue((ulong)option.Value, out var channel))
 						args.Add(channel);
 					if (e.Interaction.Data.Resolved.Roles != null && e.Interaction.Data.Resolved.Roles.TryGetValue((ulong)option.Value, out var role))
 						args.Add(role);
 					else if (e.Interaction.Data.Resolved.Members != null && e.Interaction.Data.Resolved.Members.TryGetValue((ulong)option.Value, out var member))
 						args.Add(member);
 					else if (e.Interaction.Data.Resolved.Users != null && e.Interaction.Data.Resolved.Users.TryGetValue((ulong)option.Value, out var user))
 						args.Add(user);
 					else
 						throw new ArgumentException("Error resolving mentionable option.");
 				}
 				else
 					throw new ArgumentException($"Error resolving interaction.");
 			}
 		}
 
 		return args;
 	}
 
 	/// <summary>
 	/// Runs the pre-execution checks.
 	/// </summary>
 	/// <param name="method">The method info.</param>
 	/// <param name="context">The base context.</param>
 	private async Task RunPreexecutionChecksAsync(MethodInfo method, BaseContext context)
 	{
 		if (context is InteractionContext ctx)
 		{
 			//Gets all attributes from parent classes as well and stuff
 			var attributes = new List<SlashCheckBaseAttribute>();
 			attributes.AddRange(method.GetCustomAttributes<SlashCheckBaseAttribute>(true));
 			attributes.AddRange(method.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 			if (method.DeclaringType.DeclaringType != null)
 			{
 				attributes.AddRange(method.DeclaringType.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 				if (method.DeclaringType.DeclaringType.DeclaringType != null)
 				{
 					attributes.AddRange(method.DeclaringType.DeclaringType.DeclaringType.GetCustomAttributes<SlashCheckBaseAttribute>());
 				}
 			}
 
 			var dict = new Dictionary<SlashCheckBaseAttribute, bool>();
 			foreach (var att in attributes)
 			{
 				//Runs the check and adds the result to a list
 				var result = await att.ExecuteChecksAsync(ctx);
 				dict.Add(att, result);
 			}
 
 			//Checks if any failed, and throws an exception
 			if (dict.Any(x => x.Value == false))
 				throw new SlashExecutionChecksFailedException { FailedChecks = dict.Where(x => x.Value == false).Select(x => x.Key).ToList() };
 		}
 		if (context is ContextMenuContext cMctx)
 		{
 			var attributes = new List<ContextMenuCheckBaseAttribute>();
 			attributes.AddRange(method.GetCustomAttributes<ContextMenuCheckBaseAttribute>(true));
 			attributes.AddRange(method.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 			if (method.DeclaringType.DeclaringType != null)
 			{
 				attributes.AddRange(method.DeclaringType.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 				if (method.DeclaringType.DeclaringType.DeclaringType != null)
 				{
 					attributes.AddRange(method.DeclaringType.DeclaringType.DeclaringType.GetCustomAttributes<ContextMenuCheckBaseAttribute>());
 				}
 			}
 
 			var dict = new Dictionary<ContextMenuCheckBaseAttribute, bool>();
 			foreach (var att in attributes)
 			{
 				//Runs the check and adds the result to a list
 				var result = await att.ExecuteChecksAsync(cMctx);
 				dict.Add(att, result);
 			}
 
 			//Checks if any failed, and throws an exception
 			if (dict.Any(x => x.Value == false))
 				throw new ContextMenuExecutionChecksFailedException { FailedChecks = dict.Where(x => x.Value == false).Select(x => x.Key).ToList() };
 		}
 	}
 
 	/// <summary>
 	/// Gets the choice attributes from choice provider.
 	/// </summary>
 	/// <param name="customAttributes">The custom attributes.</param>
 	/// <param name="guildId">The optional guild id</param>
 	private static async Task<List<DiscordApplicationCommandOptionChoice>> GetChoiceAttributesFromProvider(IEnumerable<ChoiceProviderAttribute> customAttributes, ulong? guildId = null)
 	{
 		var choices = new List<DiscordApplicationCommandOptionChoice>();
 		foreach (var choiceProviderAttribute in customAttributes)
 		{
 			var method = choiceProviderAttribute.ProviderType.GetMethod(nameof(IChoiceProvider.Provider));
 
 			if (method == null)
 				throw new ArgumentException("ChoiceProviders must inherit from IChoiceProvider.");
 			else
 			{
 				var instance = Activator.CreateInstance(choiceProviderAttribute.ProviderType);
 
 				// Abstract class offers more properties that can be set
 				if (choiceProviderAttribute.ProviderType.IsSubclassOf(typeof(ChoiceProvider)))
 				{
 					choiceProviderAttribute.ProviderType.GetProperty(nameof(ChoiceProvider.GuildId))
 						?.SetValue(instance, guildId);
 
 					choiceProviderAttribute.ProviderType.GetProperty(nameof(ChoiceProvider.Services))
 						?.SetValue(instance, Configuration.ServiceProvider);
 				}
 
 				//Gets the choices from the method
 				var result = await (Task<IEnumerable<DiscordApplicationCommandOptionChoice>>)method.Invoke(instance, null);
 
 				if (result.Any())
 				{
 					choices.AddRange(result);
 				}
 			}
 		}
 
 		return choices;
 	}
 
 	/// <summary>
 	/// Gets the choice attributes from enum parameter.
 	/// </summary>
 	/// <param name="enumParam">The enum parameter.</param>
 	private static List<DiscordApplicationCommandOptionChoice> GetChoiceAttributesFromEnumParameter(Type enumParam)
 	{
 		var choices = new List<DiscordApplicationCommandOptionChoice>();
 		foreach (Enum enumValue in Enum.GetValues(enumParam))
 		{
 			choices.Add(new DiscordApplicationCommandOptionChoice(enumValue.GetName(), enumValue.ToString()));
 		}
 		return choices;
 	}
 
 	/// <summary>
 	/// Gets the parameter type.
 	/// </summary>
 	/// <param name="type">The type.</param>
 	private static ApplicationCommandOptionType GetParameterType(Type type)
 	{
 		var parameterType = type == typeof(string)
 			? ApplicationCommandOptionType.String
 			: type == typeof(long) || type == typeof(long?) || type == typeof(int) || type == typeof(int?)
 			? ApplicationCommandOptionType.Integer
 			: type == typeof(bool) || type == typeof(bool?)
 			? ApplicationCommandOptionType.Boolean
 			: type == typeof(double) || type == typeof(double?)
 			? ApplicationCommandOptionType.Number
 			: type == typeof(DiscordAttachment)
 			? ApplicationCommandOptionType.Attachment
 			: type == typeof(DiscordChannel)
 			? ApplicationCommandOptionType.Channel
 			: type == typeof(DiscordUser)
 			? ApplicationCommandOptionType.User
 			: type == typeof(DiscordRole)
 			? ApplicationCommandOptionType.Role
 			: type == typeof(SnowflakeObject)
 			? ApplicationCommandOptionType.Mentionable
 			: type.IsEnum
 			? ApplicationCommandOptionType.String
 			: throw new ArgumentException("Cannot convert type! Argument types must be string, int, long, bool, double, DiscordChannel, DiscordUser, DiscordRole, SnowflakeObject, DiscordAttachment or an Enum.");
 		return parameterType;
 	}
 
 	/// <summary>
 	/// Gets the choice attributes from parameter.
 	/// </summary>
 	/// <param name="choiceAttributes">The choice attributes.</param>
 	private static List<DiscordApplicationCommandOptionChoice> GetChoiceAttributesFromParameter(IEnumerable<ChoiceAttribute> choiceAttributes) =>
 		!choiceAttributes.Any()
 			? null
 			: choiceAttributes.Select(att => new DiscordApplicationCommandOptionChoice(att.Name, att.Value)).ToList();
 
 	/// <summary>
 	/// Parses the parameters.
 	/// </summary>
 	/// <param name="parameters">The parameters.</param>
 	/// <param name="guildId">The optional guild id.</param>
 	internal static async Task<List<DiscordApplicationCommandOption>> ParseParametersAsync(IEnumerable<ParameterInfo> parameters, ulong? guildId)
 	{
 		var options = new List<DiscordApplicationCommandOption>();
 		foreach (var parameter in parameters)
 		{
 			//Gets the attribute
 			var optionAttribute = parameter.GetCustomAttribute<OptionAttribute>();
 			if (optionAttribute == null)
 				throw new ArgumentException("Arguments must have the Option attribute!");
 
 			var minimumValue = parameter.GetCustomAttribute<MinimumValueAttribute>()?.Value ?? null;
 			var maximumValue = parameter.GetCustomAttribute<MaximumValueAttribute>()?.Value ?? null;
 			var minimumLength = parameter.GetCustomAttribute<MinimumLengthAttribute>()?.Value ?? null;
 			var maximumLength = parameter.GetCustomAttribute<MaximumLengthAttribute>()?.Value ?? null;
 			var channelTypes = parameter.GetCustomAttribute<ChannelTypesAttribute>()?.ChannelTypes ?? null;
 
 			var autocompleteAttribute = parameter.GetCustomAttribute<AutocompleteAttribute>();
 			if (optionAttribute.Autocomplete && autocompleteAttribute == null)
 				throw new ArgumentException("Autocomplete options must have the Autocomplete attribute!");
 			if (!optionAttribute.Autocomplete && autocompleteAttribute != null)
 				throw new ArgumentException("Setting an autocomplete provider requires the option to have autocomplete set to true!");
 
 			//Sets the type
 			var type = parameter.ParameterType;
 			var parameterType = GetParameterType(type);
 
 			if (parameterType == ApplicationCommandOptionType.String)
 			{
 				minimumValue = null;
 				maximumValue = null;
 			}
 			else if (parameterType == ApplicationCommandOptionType.Integer || parameterType == ApplicationCommandOptionType.Number)
 			{
 				minimumLength = null;
 				maximumLength = null;
 			}
 
 			if (parameterType != ApplicationCommandOptionType.Channel)
 				channelTypes = null;
 
 			//Handles choices
 			//From attributes
 			var choices = GetChoiceAttributesFromParameter(parameter.GetCustomAttributes<ChoiceAttribute>());
 			//From enums
 			if (parameter.ParameterType.IsEnum)
 			{
 				choices = GetChoiceAttributesFromEnumParameter(parameter.ParameterType);
 			}
 			//From choice provider
 			var choiceProviders = parameter.GetCustomAttributes<ChoiceProviderAttribute>();
 			if (choiceProviders.Any())
 			{
 				choices = await GetChoiceAttributesFromProvider(choiceProviders, guildId);
 			}
 
 			options.Add(new DiscordApplicationCommandOption(optionAttribute.Name, optionAttribute.Description, parameterType, !parameter.IsOptional, choices, null, channelTypes, optionAttribute.Autocomplete, minimumValue, maximumValue, minimumLength: minimumLength, maximumLength: maximumLength));
 		}
 
 		return options;
 	}
 	/*
 	/// <summary>
 	/// <para>Refreshes your commands, used for refreshing choice providers or applying commands registered after the ready event on the discord client.</para>
 	/// <para>Not recommended and should be avoided since it can make slash commands be unresponsive for a while.</para>
 	/// </summary>
 	public async Task RefreshCommandsAsync()
 	{
 		s_commandMethods.Clear();
 		s_groupCommands.Clear();
 		s_subGroupCommands.Clear();
 		s_registeredCommands.Clear();
 		s_contextMenuCommands.Clear();
 		GlobalDiscordCommands.Clear();
 		GuildDiscordCommands.Clear();
 		GuildCommandsInternal.Clear();
 		GlobalCommandsInternal.Clear();
 		GlobalDiscordCommands = null;
 		GuildDiscordCommands = null;
 		s_errored = false;
 
 		/*if (Configuration != null && Configuration.EnableDefaultHelp)
 		{
 			this._updateList.RemoveAll(x => x.Value.Type == typeof(DefaultHelpModule));
 		}*/
 	/*
 		await this.UpdateAsync();
 	}*/
 
 	/// <summary>
 	/// Fires when the execution of a slash command fails.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, SlashCommandErrorEventArgs> SlashCommandErrored
 	{
 		add => this._slashError.Register(value);
 		remove => this._slashError.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, SlashCommandErrorEventArgs> _slashError;
 
 	/// <summary>
 	/// Fires when the execution of a slash command is successful.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, SlashCommandExecutedEventArgs> SlashCommandExecuted
 	{
 		add => this._slashExecuted.Register(value);
 		remove => this._slashExecuted.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, SlashCommandExecutedEventArgs> _slashExecuted;
 
 	/// <summary>
 	/// Fires when the execution of a context menu fails.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ContextMenuErrorEventArgs> ContextMenuErrored
 	{
 		add => this._contextMenuErrored.Register(value);
 		remove => this._contextMenuErrored.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ContextMenuErrorEventArgs> _contextMenuErrored;
 
 	/// <summary>
 	/// Fire when the execution of a context menu is successful.
 	/// </summary>
 	public event AsyncEventHandler<ApplicationCommandsExtension, ContextMenuExecutedEventArgs> ContextMenuExecuted
 	{
 		add => this._contextMenuExecuted.Register(value);
 		remove => this._contextMenuExecuted.Unregister(value);
 	}
 	private AsyncEvent<ApplicationCommandsExtension, ContextMenuExecutedEventArgs> _contextMenuExecuted;
 }
 
 /// <summary>
 /// Holds configuration data for setting up an application command.
 /// </summary>
 internal class ApplicationCommandsModuleConfiguration
 {
 	/// <summary>
 	/// The type of the command module.
 	/// </summary>
 	public Type Type { get; }
 
 	/// <summary>
 	/// The translation setup.
 	/// </summary>
 	public Action<ApplicationCommandsTranslationContext> Translations { get; }
 
 	/// <summary>
 	/// Creates a new command configuration.
 	/// </summary>
 	/// <param name="type">The type of the command module.</param>
 	/// <param name="translations">The translation setup callback.</param>
 	public ApplicationCommandsModuleConfiguration(Type type, Action<ApplicationCommandsTranslationContext> translations = null)
 	{
 		this.Type = type;
 		this.Translations = translations;
 	}
 }
 
 /// <summary>
 /// Links a command to its original command module.
 /// </summary>
 internal class ApplicationCommandSourceLink
 {
 	/// <summary>
 	/// The command.
 	/// </summary>
 	public DiscordApplicationCommand ApplicationCommand { get; set; }
 
 	/// <summary>
 	/// The base/root module the command is contained in.
 	/// </summary>
 	public Type RootCommandContainerType { get; set; }
 
 	/// <summary>
 	/// The direct group the command is contained in.
 	/// </summary>
 	public Type CommandContainerType { get; set; }
 }
 
 /// <summary>
 /// The command method.
 /// </summary>
 internal class CommandMethod
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the method.
 	/// </summary>
 	public MethodInfo Method { get; set; }
 }
 
 /// <summary>
 /// The group command.
 /// </summary>
 internal class GroupCommand
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the methods.
 	/// </summary>
 	public List<KeyValuePair<string, MethodInfo>> Methods { get; set; } = null;
 }
 
 /// <summary>
 /// The sub group command.
 /// </summary>
 internal class SubGroupCommand
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the sub commands.
 	/// </summary>
 	public List<GroupCommand> SubCommands { get; set; } = new();
 }
 
 /// <summary>
 /// The context menu command.
 /// </summary>
 internal class ContextMenuCommand
 {
 	/// <summary>
 	/// Gets or sets the command id.
 	/// </summary>
 	public ulong CommandId { get; set; }
 
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the method.
 	/// </summary>
 	public MethodInfo Method { get; set; }
 }
 
 #region Default Help
 /// <summary>
 /// Represents the default help module.
 /// </summary>
 internal class DefaultHelpModule : ApplicationCommandsModule
 {
 	public class DefaultHelpAutoCompleteProvider : IAutocompleteProvider
 	{
 		public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 		{
 			var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 
 			IEnumerable<DiscordApplicationCommand> slashCommands = null;
 			var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 			if (context.Guild != null)
 			{
 				var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 				slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First())
 					.Where(ac => ac.Name.StartsWith(context.Options[0].Value.ToString(), StringComparison.OrdinalIgnoreCase))
 					.ToList();
 			}
 			else
 			{
 				await Task.WhenAll(globalCommandsTask);
 				slashCommands = globalCommandsTask.Result
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First())
 					.Where(ac => ac.Name.StartsWith(context.Options[0].Value.ToString(), StringComparison.OrdinalIgnoreCase))
 					.ToList();
 			}
 
 			foreach (var sc in slashCommands.Take(25))
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice(sc.Name, sc.Name.Trim()));
 			}
 			return options.AsEnumerable();
 		}
 	}
 
 	public class DefaultHelpAutoCompleteLevelOneProvider : IAutocompleteProvider
 	{
 		public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 		{
 			var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 			IEnumerable<DiscordApplicationCommand> slashCommands = null;
 			var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 			if (context.Guild != null)
 			{
 				var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 				slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 			else
 			{
 				await Task.WhenAll(globalCommandsTask);
 				slashCommands = globalCommandsTask.Result
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 
 			var command = slashCommands.FirstOrDefault(ac =>
 				ac.Name.Equals(context.Options[0].Value.ToString().Trim(),StringComparison.OrdinalIgnoreCase));
 			if (command is null || command.Options is null)
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 			}
 			else
 			{
 				var opt = command.Options.Where(c => c.Type is ApplicationCommandOptionType.SubCommandGroup or ApplicationCommandOptionType.SubCommand
 													 && c.Name.StartsWith(context.Options[1].Value.ToString(), StringComparison.InvariantCultureIgnoreCase)).ToList();
 				foreach (var option in opt.Take(25))
 				{
 					options.Add(new DiscordApplicationCommandAutocompleteChoice(option.Name, option.Name.Trim()));
 				}
 			}
 			return options.AsEnumerable();
 		}
 	}
 
 	public class DefaultHelpAutoCompleteLevelTwoProvider : IAutocompleteProvider
 	{
 		public async Task<IEnumerable<DiscordApplicationCommandAutocompleteChoice>> Provider(AutocompleteContext context)
 		{
 			var options = new List<DiscordApplicationCommandAutocompleteChoice>();
 			IEnumerable<DiscordApplicationCommand> slashCommands = null;
 			var globalCommandsTask = context.Client.GetGlobalApplicationCommandsAsync();
 			if (context.Guild != null)
 			{
 				var guildCommandsTask = context.Client.GetGuildApplicationCommandsAsync(context.Guild.Id);
 				await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 				slashCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 			else
 			{
 				await Task.WhenAll(globalCommandsTask);
 				slashCommands = globalCommandsTask.Result
 					.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 					.GroupBy(ac => ac.Name).Select(x => x.First());
 			}
 
 			var command = slashCommands.FirstOrDefault(ac =>
 				ac.Name.Equals(context.Options[0].Value.ToString().Trim(), StringComparison.OrdinalIgnoreCase));
 			if (command.Options is null)
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 				return options.AsEnumerable();
 			}
 			var foundCommand = command.Options.FirstOrDefault(op => op.Name.Equals(context.Options[1].Value.ToString().Trim(), StringComparison.OrdinalIgnoreCase));
 			if (foundCommand is null || foundCommand.Options is null)
 			{
 				options.Add(new DiscordApplicationCommandAutocompleteChoice("no_options_for_this_command", "no_options_for_this_command"));
 			}
 			else
 			{
 				var opt = foundCommand.Options.Where(x => x.Type == ApplicationCommandOptionType.SubCommand &&
 														  x.Name.StartsWith(context.Options[2].Value.ToString(), StringComparison.OrdinalIgnoreCase)).ToList();
 				foreach (var option in opt.Take(25))
 				{
 					options.Add(new DiscordApplicationCommandAutocompleteChoice(option.Name, option.Name.Trim()));
 				}
 			}
 			return options.AsEnumerable();
 		}
 	}
 
 	[SlashCommand("help", "Displays command help")]
 	internal async Task DefaultHelpAsync(InteractionContext ctx,
 		[Autocomplete(typeof(DefaultHelpAutoCompleteProvider))]
 		[Option("option_one", "top level command to provide help for", true)] string commandName,
 		[Autocomplete(typeof(DefaultHelpAutoCompleteLevelOneProvider))]
 		[Option("option_two", "subgroup or command to provide help for", true)] string commandOneName = null,
 		[Autocomplete(typeof(DefaultHelpAutoCompleteLevelTwoProvider))]
 		[Option("option_three", "command to provide help for", true)] string commandTwoName = null)
 	{
 		List<DiscordApplicationCommand> applicationCommands = null;
 		var globalCommandsTask = ctx.Client.GetGlobalApplicationCommandsAsync();
 		if (ctx.Guild != null)
 		{
 			var guildCommandsTask= ctx.Client.GetGuildApplicationCommandsAsync(ctx.Guild.Id);
 			await Task.WhenAll(globalCommandsTask, guildCommandsTask);
 			applicationCommands = globalCommandsTask.Result.Concat(guildCommandsTask.Result)
 				.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 				.GroupBy(ac => ac.Name).Select(x => x.First())
 				.ToList();
 		}
 		else
 		{
 			await Task.WhenAll(globalCommandsTask);
 			applicationCommands = globalCommandsTask.Result
 				.Where(ac => !ac.Name.Equals("help", StringComparison.OrdinalIgnoreCase))
 				.GroupBy(ac => ac.Name).Select(x => x.First())
 				.ToList();
 		}
 
 		if (applicationCommands.Count < 1)
 		{
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder()
 				.WithContent($"There are no slash commands").AsEphemeral(true));
 			return;
 		}
 		if (commandTwoName is not null && !commandTwoName.Equals("no_options_for_this_command"))
 		{
 			var commandsWithSubCommands = applicationCommands.FindAll(ac => ac.Options is not null && ac.Options.Any(op => op.Type == ApplicationCommandOptionType.SubCommandGroup));
 			var subCommandParent = commandsWithSubCommands.FirstOrDefault(cm => cm.Name.Equals(commandName,StringComparison.OrdinalIgnoreCase));
 			var cmdParent = commandsWithSubCommands.FirstOrDefault(cm => cm.Options.Any(op => op.Name.Equals(commandOneName))).Options
 					.FirstOrDefault(opt => opt.Name.Equals(commandOneName,StringComparison.OrdinalIgnoreCase));
 			var cmd = cmdParent.Options.FirstOrDefault(op => op.Name.Equals(commandTwoName,StringComparison.OrdinalIgnoreCase));
 			var discordEmbed = new DiscordEmbedBuilder
 			{
 				Title = "Help",
 				Description = $"{subCommandParent.Mention.Replace(subCommandParent.Name, $"{subCommandParent.Name} {cmdParent.Name} {cmd.Name}")}: {cmd.Description ?? "No description provided."}"
 			};
 			if (cmd.Options is not null)
 			{
 				var commandOptions = cmd.Options.ToList();
 				var sb = new StringBuilder();
 
 				foreach (var option in commandOptions)
 					sb.Append('`').Append(option.Name).Append("`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 				sb.Append('\n');
 				discordEmbed.AddField(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 			}
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 				new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 		}
 		else if (commandOneName is not null && commandTwoName is null && !commandOneName.Equals("no_options_for_this_command"))
 		{
 			var commandsWithOptions = applicationCommands.FindAll(ac => ac.Options is not null && ac.Options.All(op => op.Type == ApplicationCommandOptionType.SubCommand));
 			var subCommandParent = commandsWithOptions.FirstOrDefault(cm => cm.Name.Equals(commandName,StringComparison.OrdinalIgnoreCase));
 			var subCommand = subCommandParent.Options.FirstOrDefault(op => op.Name.Equals(commandOneName,StringComparison.OrdinalIgnoreCase));
 			var discordEmbed = new DiscordEmbedBuilder
 			{
 				Title = "Help",
 				Description = $"{subCommandParent.Mention.Replace(subCommandParent.Name, $"{subCommandParent.Name} {subCommand.Name}")}: {subCommand.Description ?? "No description provided."}"
 			};
 			if (subCommand.Options is not null)
 			{
 				var commandOptions = subCommand.Options.ToList();
 				var sb = new StringBuilder();
 
 				foreach (var option in commandOptions)
 					sb.Append('`').Append(option.Name).Append("`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 				sb.Append('\n');
 				discordEmbed.AddField(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 			}
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 				new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 		}
 		else
 		{
 			var command = applicationCommands.FirstOrDefault(cm => cm.Name.Equals(commandName, StringComparison.OrdinalIgnoreCase));
 			if (command is null)
 			{
 				await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, new DiscordInteractionResponseBuilder()
 						.WithContent($"No command called {commandName} in guild {ctx.Guild.Name}").AsEphemeral(true));
 				return;
 			}
 			var discordEmbed = new DiscordEmbedBuilder
 			{
 				Title = "Help",
 				Description = $"{command.Mention}: {command.Description ?? "No description provided."}"
 			}.AddField(new DiscordEmbedField("Command is NSFW", command.IsNsfw.ToString()));
 			if (command.Options is not null)
 			{
 				var commandOptions = command.Options.ToList();
 				var sb = new StringBuilder();
 
 				foreach (var option in commandOptions)
 					sb.Append('`').Append(option.Name).Append("`: ").Append(option.Description ?? "No description provided.").Append('\n');
 
 				sb.Append('\n');
 				discordEmbed.AddField(new DiscordEmbedField("Arguments", sb.ToString().Trim()));
 			}
 			await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
 				new DiscordInteractionResponseBuilder().AddEmbed(discordEmbed).AsEphemeral(true));
 		}
 	}
 }
 #endregion
diff --git a/DisCatSharp.ApplicationCommands/GlobalSuppressions.cs b/DisCatSharp.ApplicationCommands/GlobalSuppressions.cs
index e2efbeb94..62a4474be 100644
--- a/DisCatSharp.ApplicationCommands/GlobalSuppressions.cs
+++ b/DisCatSharp.ApplicationCommands/GlobalSuppressions.cs
@@ -1,46 +1,37 @@
 // 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.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")]
 [assembly: SuppressMessage("Style", "IDE0018:Inline variable declaration", Justification = "<Pending>", Scope = "member", Target = "~M:DisCatSharp.ApplicationCommands.RegistrationWorker.BuildGuildCreateList(DisCatSharp.DiscordClient,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.BuildGuildOverwriteList(DisCatSharp.DiscordClient,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}}")]
diff --git a/DisCatSharp/Clients/DiscordClient.Dispatch.cs b/DisCatSharp/Clients/DiscordClient.Dispatch.cs
index 94c3415f2..4c0ccbb67 100644
--- a/DisCatSharp/Clients/DiscordClient.Dispatch.cs
+++ b/DisCatSharp/Clients/DiscordClient.Dispatch.cs
@@ -1,3398 +1,3428 @@
 // 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 _resumeGatewayUrl;
 	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"];
 				// Console.WriteLine(dat.ToString()); // Get raw interaction payload.
 				await this.OnInteractionCreateAsync((ulong?)dat["guild_id"], cid, usr, mbr, dat.ToDiscordObject<DiscordInteraction>(), dat.ToString()).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;
+		this._resumeGatewayUrl = ready.ResumeGatewayUrl;
 		var rawGuildIndex = rawGuilds.ToDictionary(xt => (ulong)xt["id"], xt => (JObject)xt);
 
 		this.GuildsInternal.Clear();
 		foreach (var guild in ready.Guilds)
 		{
 			guild.Discord = this;
 
 			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;
 				}
 			}
 
 			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 };
 				}
 			}
 
 			guild.EmojisInternal ??= new ConcurrentDictionary<ulong, DiscordEmoji>();
 
 			foreach (var xe in guild.Emojis.Values)
 				xe.Discord = this;
 
 			guild.StickersInternal ??= new ConcurrentDictionary<ulong, DiscordSticker>();
 
 			foreach (var xs in guild.Stickers.Values)
 				xs.Discord = this;
 
 			guild.VoiceStatesInternal ??= new ConcurrentDictionary<ulong, DiscordVoiceState>();
 
 			foreach (var xvs in guild.VoiceStates.Values)
 				xvs.Discord = this;
 
 			guild.ThreadsInternal ??= new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 
 			foreach (var xt in guild.ThreadsInternal.Values)
 				xt.Discord = this;
 
 			guild.StageInstancesInternal ??= new ConcurrentDictionary<ulong, DiscordStageInstance>();
 
 			foreach (var xsi in guild.StageInstancesInternal.Values)
 				xsi.Discord = this;
 
 			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;
 		}
+		foreach (var xo in channel.AvailableTags)
+		{
+			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,
+				PostCreateUserRateLimit = channelNew.PostCreateUserRateLimit,
 				RtcRegionId = channelNew.RtcRegionId,
 				QualityMode = channelNew.QualityMode,
-				DefaultAutoArchiveDuration = channelNew.DefaultAutoArchiveDuration
+				DefaultAutoArchiveDuration = channelNew.DefaultAutoArchiveDuration,
+				AvailableTags = channelNew.AvailableTags,
+				Template = channelNew.Template,
+				DefaultReactionEmoji = channelNew.DefaultReactionEmoji
 			};
 
 			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.PostCreateUserRateLimit = channel.PostCreateUserRateLimit;
 			channelNew.Type = channel.Type;
 			channelNew.RtcRegionId = channel.RtcRegionId;
 			channelNew.QualityMode = channel.QualityMode;
 			channelNew.DefaultAutoArchiveDuration = channel.DefaultAutoArchiveDuration;
+			channelNew.Template = channel.Template;
+			channelNew.DefaultReactionEmoji = channel.DefaultReactionEmoji;
 
 			channelNew.PermissionOverwritesInternal.Clear();
 
 			foreach (var po in channel.PermissionOverwritesInternal)
 			{
 				po.Discord = this;
 				po.ChannelId = channel.Id;
 			}
 
+			channelNew.AvailableTags.Clear();
+
+			foreach (var fpt in channel.AvailableTags)
+			{
+				fpt.Discord = this;
+				fpt.ChannelId = channel.Id;
+			}
+
+
+			channelNew.AvailableTags.AddRange(channel.AvailableTags);
+
 			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;
 
 		guild.ChannelsInternal ??= new ConcurrentDictionary<ulong, DiscordChannel>();
 		guild.ThreadsInternal ??= new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 		guild.RolesInternal ??= new ConcurrentDictionary<ulong, DiscordRole>();
 		guild.ThreadsInternal ??= new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 		guild.StickersInternal ??= new ConcurrentDictionary<ulong, DiscordSticker>();
 		guild.EmojisInternal ??= new ConcurrentDictionary<ulong, DiscordEmoji>();
 		guild.VoiceStatesInternal ??= new ConcurrentDictionary<ulong, DiscordVoiceState>();
 		guild.MembersInternal ??= new ConcurrentDictionary<ulong, DiscordMember>();
 		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];
 
 		guild.ChannelsInternal ??= new ConcurrentDictionary<ulong, DiscordChannel>();
 		guild.ThreadsInternal ??= new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 		guild.RolesInternal ??= new ConcurrentDictionary<ulong, DiscordRole>();
 		guild.EmojisInternal ??= new ConcurrentDictionary<ulong, DiscordEmoji>();
 		guild.StickersInternal ??= new ConcurrentDictionary<ulong, DiscordSticker>();
 		guild.VoiceStatesInternal ??= new ConcurrentDictionary<ulong, DiscordVoiceState>();
 		guild.StageInstancesInternal ??= new ConcurrentDictionary<ulong, DiscordStageInstance>();
 		guild.MembersInternal ??= new ConcurrentDictionary<ulong, DiscordMember>();
 		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
+				CurrentMember = threadNew.CurrentMember,
+				TotalMessagesSent = threadNew.TotalMessagesSent,
+				AppliedTagIdsInternal = threadNew.AppliedTagIdsInternal
 			};
 
 			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;
 			threadNew.Discord = this;
+			threadNew.TotalMessagesSent = thread.TotalMessagesSent;
+			threadNew.AppliedTagIdsInternal = thread.AppliedTagIdsInternal;
 
 			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, string rawInteraction)
 	{
 		this.Logger.LogTrace("Interaction from {guild} on shard {shard}", guildId.HasValue ? guildId.Value : "dm", this.ShardId);
 		this.Logger.LogTrace("Interaction: {interaction}", rawInteraction);
 		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;
 						try
 						{
 							if (this.Guilds.TryGetValue(guildId.Value, out var guild))
 								if (guild.ChannelsInternal.TryGetValue(c.Key, out var channel) && channel.PermissionOverwritesInternal != null && channel.PermissionOverwritesInternal.Any())
 									c.Value.PermissionOverwritesInternal = channel.PermissionOverwritesInternal;
-						} catch(Exception) { }
+						}
+						catch (Exception) { }
 					}
 				}
 			}
 
 			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 ea = new ContextMenuInteractionCreateEventArgs(this.ServiceProvider)
 				{
 					Interaction = interaction,
 					TargetUser = targetMember ?? targetUser,
 					TargetMessage = targetMessage,
 					Type = interaction.Data.Type
 				};
 				await this._contextMenuInteractionCreated.InvokeAsync(this, ea);
 			}
 			else
 			{
 				var ea = new InteractionCreateEventArgs(this.ServiceProvider)
 				{
 					Interaction = interaction
 				};
 
 				await this._interactionCreated.InvokeAsync(this, ea);
 			}
 		}
 	}
 
 	#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.WebSocket.cs b/DisCatSharp/Clients/DiscordClient.WebSocket.cs
index d48dbc97b..491e548b0 100644
--- a/DisCatSharp/Clients/DiscordClient.WebSocket.cs
+++ b/DisCatSharp/Clients/DiscordClient.WebSocket.cs
@@ -1,588 +1,591 @@
 // 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.IO;
 using System.Threading;
 using System.Threading.Tasks;
 
 using DisCatSharp.Entities;
 using DisCatSharp.EventArgs;
 using DisCatSharp.Net.Abstractions;
 using DisCatSharp.Net.WebSocket;
 
 using Microsoft.Extensions.Logging;
 
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace DisCatSharp;
 
 /// <summary>
 /// Represents a discord websocket client.
 /// </summary>
 public sealed partial class DiscordClient
 {
 	#region Private Fields
 
 	private int _heartbeatInterval;
 	private DateTimeOffset _lastHeartbeat;
 	private Task _heartbeatTask;
 
 	internal static DateTimeOffset DiscordEpoch = new(2015, 1, 1, 0, 0, 0, TimeSpan.Zero);
 
 	private int _skippedHeartbeats;
 	private long _lastSequence;
 
 	internal IWebSocketClient WebSocketClient;
 	private PayloadDecompressor _payloadDecompressor;
 
 	private CancellationTokenSource _cancelTokenSource;
 	private CancellationToken _cancelToken;
 
 	#endregion
 
 	#region Connection Semaphore
 
 	/// <summary>
 	/// Gets the socket locks.
 	/// </summary>
 	private static ConcurrentDictionary<ulong, SocketLock> s_socketLocks { get; } = new();
 
 	/// <summary>
 	/// Gets the session lock.
 	/// </summary>
 	private readonly ManualResetEventSlim _sessionLock  = new(true);
 
 	#endregion
 
 	#region Internal Connection Methods
 
 	/// <summary>
 	/// Reconnects the websocket client.
 	/// </summary>
 	/// <param name="startNewSession">Whether to start a new session.</param>
 	/// <param name="code">The reconnect code.</param>
 	/// <param name="message">The reconnect message.</param>
 	private Task InternalReconnectAsync(bool startNewSession = false, int code = 1000, string message = "")
 	{
 		if (startNewSession)
 			this._sessionId = null;
 
 		_ = this.WebSocketClient.DisconnectAsync(code, message);
 		return Task.CompletedTask;
 	}
 
 	/// <summary>
 	/// Connects the websocket client.
 	/// </summary>
 	internal async Task InternalConnectAsync()
 	{
 		SocketLock socketLock = null;
 		try
 		{
 			if (this.GatewayInfo == null)
 				await this.InternalUpdateGatewayAsync().ConfigureAwait(false);
 			await this.InitializeAsync().ConfigureAwait(false);
 
 			socketLock = this.GetSocketLock();
 			await socketLock.LockAsync().ConfigureAwait(false);
 		}
 		catch
 		{
 			socketLock?.UnlockAfter(TimeSpan.Zero);
 			throw;
 		}
 
 		if (!this.Presences.ContainsKey(this.CurrentUser.Id))
 		{
 			this.PresencesInternal[this.CurrentUser.Id] = new DiscordPresence
 			{
 				Discord = this,
 				RawActivity = new TransportActivity(),
 				Activity = new DiscordActivity(),
 				Status = UserStatus.Online,
 				InternalUser = new TransportUser
 				{
 					Id = this.CurrentUser.Id,
 					Username = this.CurrentUser.Username,
 					Discriminator = this.CurrentUser.Discriminator,
 					AvatarHash = this.CurrentUser.AvatarHash
 				}
 			};
 		}
 		else
 		{
 			var pr = this.PresencesInternal[this.CurrentUser.Id];
 			pr.RawActivity = new TransportActivity();
 			pr.Activity = new DiscordActivity();
 			pr.Status = UserStatus.Online;
 		}
 
 		Volatile.Write(ref this._skippedHeartbeats, 0);
 
 		this.WebSocketClient = this.Configuration.WebSocketClientFactory(this.Configuration.Proxy, this.ServiceProvider);
 		this._payloadDecompressor = this.Configuration.GatewayCompressionLevel != GatewayCompressionLevel.None
 			? new PayloadDecompressor(this.Configuration.GatewayCompressionLevel)
 			: null;
 
 		this._cancelTokenSource = new CancellationTokenSource();
 		this._cancelToken = this._cancelTokenSource.Token;
 
 		this.WebSocketClient.Connected += SocketOnConnect;
 		this.WebSocketClient.Disconnected += SocketOnDisconnect;
 		this.WebSocketClient.MessageReceived += SocketOnMessage;
 		this.WebSocketClient.ExceptionThrown += SocketOnException;
 
 		var gwuri = new QueryUriBuilder(this.GatewayUri)
 			.AddParameter("v", this.Configuration.ApiVersion)
 			.AddParameter("encoding", "json");
 
 		if (this.Configuration.GatewayCompressionLevel == GatewayCompressionLevel.Stream)
 			gwuri.AddParameter("compress", "zlib-stream");
 
+		this.Logger.LogDebug(LoggerEvents.Startup, "Connecting to {gw}", this.GatewayUri.AbsoluteUri);
+
 		await this.WebSocketClient.ConnectAsync(gwuri.Build()).ConfigureAwait(false);
 
 		Task SocketOnConnect(IWebSocketClient sender, SocketEventArgs e)
 			=> this._socketOpened.InvokeAsync(this, e);
 
 		async Task SocketOnMessage(IWebSocketClient sender, SocketMessageEventArgs e)
 		{
 			string msg = null;
 			if (e is SocketTextMessageEventArgs etext)
 			{
 				msg = etext.Message;
 			}
-			else if (e is SocketBinaryMessageEventArgs ebin) // :DDDD
+			else if (e is SocketBinaryMessageEventArgs ebin)
 			{
 				using var ms = new MemoryStream();
 				if (!this._payloadDecompressor.TryDecompress(new ArraySegment<byte>(ebin.Message), ms))
 				{
 					this.Logger.LogError(LoggerEvents.WebSocketReceiveFailure, "Payload decompression failed");
 					return;
 				}
 
 				ms.Position = 0;
 				using var sr = new StreamReader(ms, Utilities.UTF8);
 				msg = await sr.ReadToEndAsync().ConfigureAwait(false);
 			}
 
 			try
 			{
 				this.Logger.LogTrace(LoggerEvents.GatewayWsRx, msg);
 				await this.HandleSocketMessageAsync(msg).ConfigureAwait(false);
 			}
 			catch (Exception ex)
 			{
 				this.Logger.LogError(LoggerEvents.WebSocketReceiveFailure, ex, "Socket handler suppressed an exception");
 			}
 		}
 
 		Task SocketOnException(IWebSocketClient sender, SocketErrorEventArgs e)
 			=> this._socketErrored.InvokeAsync(this, e);
 
 		async Task SocketOnDisconnect(IWebSocketClient sender, SocketCloseEventArgs e)
 		{
 			// release session and connection
 			this._connectionLock.Set();
 			this._sessionLock.Set();
 
 			if (!this._disposed)
 				this._cancelTokenSource.Cancel();
 
 			this.Logger.LogDebug(LoggerEvents.ConnectionClose, "Connection closed ({0}, '{1}')", e.CloseCode, e.CloseMessage);
 			await this._socketClosed.InvokeAsync(this, e).ConfigureAwait(false);
 
 
 
 			if (this.Configuration.AutoReconnect && (e.CloseCode < 4001 || e.CloseCode >= 5000))
 			{
 				this.Logger.LogCritical(LoggerEvents.ConnectionClose, "Connection terminated ({0}, '{1}'), reconnecting", e.CloseCode, e.CloseMessage);
 
 				if (this._status == null)
 					await this.ConnectAsync().ConfigureAwait(false);
 				else
 					if (this._status.IdleSince.HasValue)
 					await this.ConnectAsync(this._status.ActivityInternal, this._status.Status, Utilities.GetDateTimeOffsetFromMilliseconds(this._status.IdleSince.Value)).ConfigureAwait(false);
 				else
 					await this.ConnectAsync(this._status.ActivityInternal, this._status.Status).ConfigureAwait(false);
 			}
 			else
 			{
 				this.Logger.LogCritical(LoggerEvents.ConnectionClose, "Connection terminated ({0}, '{1}')", e.CloseCode, e.CloseMessage);
 			}
 		}
 	}
 
 	#endregion
 
 	#region WebSocket (Events)
 
 	/// <summary>
 	/// Handles the socket message.
 	/// </summary>
 	/// <param name="data">The data.</param>
 	internal async Task HandleSocketMessageAsync(string data)
 	{
 		var payload = JsonConvert.DeserializeObject<GatewayPayload>(data);
 		this._lastSequence = payload.Sequence ?? this._lastSequence;
 		switch (payload.OpCode)
 		{
 			case GatewayOpCode.Dispatch:
 				await this.HandleDispatchAsync(payload).ConfigureAwait(false);
 				break;
 
 			case GatewayOpCode.Heartbeat:
 				await this.OnHeartbeatAsync((long)payload.Data).ConfigureAwait(false);
 				break;
 
 			case GatewayOpCode.Reconnect:
 				await this.OnReconnectAsync().ConfigureAwait(false);
 				break;
 
 			case GatewayOpCode.InvalidSession:
 				await this.OnInvalidateSessionAsync((bool)payload.Data).ConfigureAwait(false);
 				break;
 
 			case GatewayOpCode.Hello:
 				await this.OnHelloAsync((payload.Data as JObject).ToObject<GatewayHello>()).ConfigureAwait(false);
 				break;
 
 			case GatewayOpCode.HeartbeatAck:
 				await this.OnHeartbeatAckAsync().ConfigureAwait(false);
 				break;
 
 			default:
 				this.Logger.LogWarning(LoggerEvents.WebSocketReceive, "Unknown Discord opcode: {0}\nPayload: {1}", payload.OpCode, payload.Data);
 				break;
 		}
 	}
 
 	/// <summary>
 	/// Handles the heartbeat.
 	/// </summary>
 	/// <param name="seq">The sequence.</param>
 	internal async Task OnHeartbeatAsync(long seq)
 	{
 		this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received HEARTBEAT (OP1)");
 		await this.SendHeartbeatAsync(seq).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the reconnect event.
 	/// </summary>
 	internal async Task OnReconnectAsync()
 	{
 		this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received RECONNECT (OP7)");
 		await this.InternalReconnectAsync(code: 4000, message: "OP7 acknowledged").ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the invalidate session event
 	/// </summary>
 	/// <param name="data">Unknown. Please fill documentation.</param>
 	internal async Task OnInvalidateSessionAsync(bool data)
 	{
 		// begin a session if one is not open already
 		if (this._sessionLock.Wait(0))
 			this._sessionLock.Reset();
 
 		// we are sending a fresh resume/identify, so lock the socket
 		var socketLock = this.GetSocketLock();
 		await socketLock.LockAsync().ConfigureAwait(false);
 		socketLock.UnlockAfter(TimeSpan.FromSeconds(5));
 
 		if (data)
 		{
 			this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received INVALID_SESSION (OP9, true)");
 			await Task.Delay(6000).ConfigureAwait(false);
 			await this.SendResumeAsync().ConfigureAwait(false);
 		}
 		else
 		{
 			this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received INVALID_SESSION (OP9, false)");
 			this._sessionId = null;
 			await this.SendIdentifyAsync(this._status).ConfigureAwait(false);
 		}
 	}
 
 	/// <summary>
 	/// Handles the hello event.
 	/// </summary>
 	/// <param name="hello">The gateway hello payload.</param>
 	internal async Task OnHelloAsync(GatewayHello hello)
 	{
 		this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received HELLO (OP10)");
 
 		if (this._sessionLock.Wait(0))
 		{
 			this._sessionLock.Reset();
 			this.GetSocketLock().UnlockAfter(TimeSpan.FromSeconds(5));
 		}
 		else
 		{
 			this.Logger.LogWarning(LoggerEvents.SessionUpdate, "Attempt to start a session while another session is active");
 			return;
 		}
 
 		Interlocked.CompareExchange(ref this._skippedHeartbeats, 0, 0);
 		this._heartbeatInterval = hello.HeartbeatInterval;
 		this._heartbeatTask = Task.Run(this.HeartbeatLoopAsync, this._cancelToken);
 
 		if (string.IsNullOrEmpty(this._sessionId))
 			await this.SendIdentifyAsync(this._status).ConfigureAwait(false);
 		else
 			await this.SendResumeAsync().ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the heartbeat acknowledge event.
 	/// </summary>
 	internal async Task OnHeartbeatAckAsync()
 	{
 		Interlocked.Decrement(ref this._skippedHeartbeats);
 
 		var ping = (int)(DateTime.Now - this._lastHeartbeat).TotalMilliseconds;
 
 		this.Logger.LogTrace(LoggerEvents.WebSocketReceive, "Received HEARTBEAT_ACK (OP11, {0}ms)", ping);
 
 		Volatile.Write(ref this._ping, ping);
 
 		var args = new HeartbeatEventArgs(this.ServiceProvider)
 		{
 			Ping = this.Ping,
 			Timestamp = DateTimeOffset.Now
 		};
 
 		await this._heartbeated.InvokeAsync(this, args).ConfigureAwait(false);
 	}
 
 	/// <summary>
 	/// Handles the heartbeat loop.
 	/// </summary>
 	internal async Task HeartbeatLoopAsync()
 	{
 		this.Logger.LogDebug(LoggerEvents.Heartbeat, "Heartbeat task started");
 		var token = this._cancelToken;
 		try
 		{
 			while (true)
 			{
 				await this.SendHeartbeatAsync(this._lastSequence).ConfigureAwait(false);
 				await Task.Delay(this._heartbeatInterval, token).ConfigureAwait(false);
 				token.ThrowIfCancellationRequested();
 			}
 		}
 		catch (OperationCanceledException) { }
 	}
 
 	#endregion
 
 	#region Internal Gateway Methods
 
 	/// <summary>
 	/// Updates the status.
 	/// </summary>
 	/// <param name="activity">The activity.</param>
 	/// <param name="userStatus">The optional user status.</param>
 	/// <param name="idleSince">Since when is the client performing the specified activity.</param>
 	internal async Task InternalUpdateStatusAsync(DiscordActivity activity, UserStatus? userStatus, DateTimeOffset? idleSince)
 	{
 		if (activity != null && activity.Name != null && activity.Name.Length > 128)
 			throw new Exception("Game name can't be longer than 128 characters!");
 
 		var sinceUnix = idleSince != null ? (long?)Utilities.GetUnixTime(idleSince.Value) : null;
 		var act = activity ?? new DiscordActivity();
 
 		var status = new StatusUpdate
 		{
 			Activity = new TransportActivity(act),
 			IdleSince = sinceUnix,
 			IsAfk = idleSince != null,
 			Status = userStatus ?? UserStatus.Online
 		};
 
 		// Solution to have status persist between sessions
 		this._status = status;
 		var statusUpdate = new GatewayPayload
 		{
 			OpCode = GatewayOpCode.StatusUpdate,
 			Data = status
 		};
 
 		var statusstr = JsonConvert.SerializeObject(statusUpdate);
 
 		await this.WsSendAsync(statusstr).ConfigureAwait(false);
 
 		if (!this.PresencesInternal.ContainsKey(this.CurrentUser.Id))
 		{
 			this.PresencesInternal[this.CurrentUser.Id] = new DiscordPresence
 			{
 				Discord = this,
 				Activity = act,
 				Status = userStatus ?? UserStatus.Online,
 				InternalUser = new TransportUser { Id = this.CurrentUser.Id }
 			};
 		}
 		else
 		{
 			var pr = this.PresencesInternal[this.CurrentUser.Id];
 			pr.Activity = act;
 			pr.Status = userStatus ?? pr.Status;
 		}
 	}
 
 	/// <summary>
 	/// Sends the heartbeat.
 	/// </summary>
 	/// <param name="seq">The sequenze.</param>
 	internal async Task SendHeartbeatAsync(long seq)
 	{
 		var moreThan5 = Volatile.Read(ref this._skippedHeartbeats) > 5;
 		var guildsComp = Volatile.Read(ref this._guildDownloadCompleted);
 		if (guildsComp && moreThan5)
 		{
 			this.Logger.LogCritical(LoggerEvents.HeartbeatFailure, "Server failed to acknowledge more than 5 heartbeats - connection is zombie");
 
 			var args = new ZombiedEventArgs(this.ServiceProvider)
 			{
 				Failures = Volatile.Read(ref this._skippedHeartbeats),
 				GuildDownloadCompleted = true
 			};
 			await this._zombied.InvokeAsync(this, args).ConfigureAwait(false);
 
 			await this.InternalReconnectAsync(code: 4001, message: "Too many heartbeats missed").ConfigureAwait(false);
 			return;
 		}
 		else if (!guildsComp && moreThan5)
 		{
 			var args = new ZombiedEventArgs(this.ServiceProvider)
 			{
 				Failures = Volatile.Read(ref this._skippedHeartbeats),
 				GuildDownloadCompleted = false
 			};
 			await this._zombied.InvokeAsync(this, args).ConfigureAwait(false);
 
 			this.Logger.LogWarning(LoggerEvents.HeartbeatFailure, "Server failed to acknowledge more than 5 heartbeats, but the guild download is still running - check your connection speed");
 		}
 
 		Volatile.Write(ref this._lastSequence, seq);
 		this.Logger.LogTrace(LoggerEvents.Heartbeat, "Sending heartbeat");
 		var heartbeat = new GatewayPayload
 		{
 			OpCode = GatewayOpCode.Heartbeat,
 			Data = seq
 		};
 		var heartbeatStr = JsonConvert.SerializeObject(heartbeat);
 		await this.WsSendAsync(heartbeatStr).ConfigureAwait(false);
 
 		this._lastHeartbeat = DateTimeOffset.Now;
 
 		Interlocked.Increment(ref this._skippedHeartbeats);
 	}
 
 	/// <summary>
 	/// Sends the identify payload.
 	/// </summary>
 	/// <param name="status">The status update payload.</param>
 	internal async Task SendIdentifyAsync(StatusUpdate status)
 	{
 		var identify = new GatewayIdentify
 		{
 			Token = Utilities.GetFormattedToken(this),
 			Compress = this.Configuration.GatewayCompressionLevel == GatewayCompressionLevel.Payload,
 			LargeThreshold = this.Configuration.LargeThreshold,
 			ShardInfo = new ShardInfo
 			{
 				ShardId = this.Configuration.ShardId,
 				ShardCount = this.Configuration.ShardCount
 			},
 			Presence = status,
 			Intents = this.Configuration.Intents,
 			Discord = this
 		};
 		var payload = new GatewayPayload
 		{
 			OpCode = GatewayOpCode.Identify,
 			Data = identify
 		};
 		var payloadstr = JsonConvert.SerializeObject(payload);
 		await this.WsSendAsync(payloadstr).ConfigureAwait(false);
 
 		this.Logger.LogDebug(LoggerEvents.Intents, "Registered gateway intents ({0})", this.Configuration.Intents);
 	}
 
 	/// <summary>
 	/// Sends the resume payload.
 	/// </summary>
 	internal async Task SendResumeAsync()
 	{
 		var resume = new GatewayResume
 		{
 			Token = Utilities.GetFormattedToken(this),
 			SessionId = this._sessionId,
 			SequenceNumber = Volatile.Read(ref this._lastSequence)
 		};
 		var resumePayload = new GatewayPayload
 		{
 			OpCode = GatewayOpCode.Resume,
 			Data = resume
 		};
 		var resumestr = JsonConvert.SerializeObject(resumePayload);
-
+		this.GatewayUri = new Uri(this._resumeGatewayUrl);
+		this.Logger.LogDebug(LoggerEvents.ConnectionClose, "Request to resume via {gw}", this.GatewayUri.AbsoluteUri);
 		await this.WsSendAsync(resumestr).ConfigureAwait(false);
 	}
 	/// <summary>
 	/// Internals the update gateway async.
 	/// </summary>
 	/// <returns>A Task.</returns>
 	internal async Task InternalUpdateGatewayAsync()
 	{
 		var info = await this.GetGatewayInfoAsync().ConfigureAwait(false);
 		this.GatewayInfo = info;
 		this.GatewayUri = new Uri(info.Url);
 	}
 
 	/// <summary>
 	/// Sends a websocket message.
 	/// </summary>
 	/// <param name="payload">The payload to send.</param>
 	internal async Task WsSendAsync(string payload)
 	{
 		this.Logger.LogTrace(LoggerEvents.GatewayWsTx, payload);
 		await this.WebSocketClient.SendMessageAsync(payload).ConfigureAwait(false);
 	}
 
 	#endregion
 
 	#region Semaphore Methods
 
 	/// <summary>
 	/// Gets the socket lock.
 	/// </summary>
 	/// <returns>The added socket lock.</returns>
 	private SocketLock GetSocketLock()
 		=> s_socketLocks.GetOrAdd(this.CurrentApplication.Id, appId => new SocketLock(appId, this.GatewayInfo.SessionBucket.MaxConcurrency));
 
 	#endregion
 }
diff --git a/DisCatSharp/Entities/Channel/DiscordChannel.cs b/DisCatSharp/Entities/Channel/DiscordChannel.cs
index afa552602..4afb69490 100644
--- a/DisCatSharp/Entities/Channel/DiscordChannel.cs
+++ b/DisCatSharp/Entities/Channel/DiscordChannel.cs
@@ -1,1320 +1,1378 @@
 // 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")]
+	[JsonProperty("rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
 	public int? PerUserRateLimit { get; internal set; }
 
+	/// <summary>
+	/// <para>Gets the slow mode delay configured for this channel for post creations.</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("default_thread_rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
+	public int? PostCreateUserRateLimit { 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>
+	/// List of available tags for forum posts.
+	/// </summary>
+	[JsonProperty("default_reaction_emoji", NullValueHandling = NullValueHandling.Ignore)]
+	public ForumReactionEmoji DefaultReactionEmoji { 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>
 	/// <param name="bypassCache">Whether to bypass the message cache</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, bool bypassCache = false) =>
 		this.Discord.Configuration.MessageCacheSize > 0
 		&& !bypassCache
 		&& 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)
 	{
+		if (this.Type == ChannelType.Forum)
+			throw new NotSupportedException("Cannot execute this request on a forum channel.");
+		
 		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);
+			mdl.QualityMode, mdl.DefaultAutoArchiveDuration, mdl.Type, mdl.PermissionOverwrites, mdl.AuditLogReason);
+	}
+
+	/// <summary>
+	/// Modifies the current forum 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 ModifyForumAsync(Action<ForumChannelEditModel> action)
+	{
+		if (this.Type != ChannelType.Forum)
+			throw new NotSupportedException("Cannot execute this request on a non-forum channel.");
+		
+		var mdl = new ForumChannelEditModel();
+		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")}.");
+
+
+		return this.Discord.ApiClient.ModifyForumChannelAsync(this.Id, mdl.Name, mdl.Position, mdl.Topic, mdl.Template, mdl.Nsfw,
+			mdl.Parent.Map(p => p?.Id), mdl.DefaultReactionEmoji, mdl.PerUserRateLimit, mdl.PostCreateUserRateLimit,
+			mdl.DefaultAutoArchiveDuration, mdl.PermissionOverwrites, 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>
+	public ForumPostTag GetForumPostTag(ulong id)
+	{
+		var tag = this.AvailableTags.First(x => x.Id == id);
+		tag.Discord = this.Discord;
+		tag.ChannelId = this.Id;
+		return tag;
+	}
+
+	/// <summary>
+	/// Creates a forum channel tag.
+	/// </summary>
+	/// <param name="name">The name of the tag.</param>
+	/// <param name="emoji">The emoji of the tag. Has to be either a <see cref="DiscordGuildEmoji"/> of the current guild or a <see cref="DiscordUnicodeEmoji"/>.</param>
+	/// <param name="moderated">Whether only moderators should be able to apply this tag.</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.ManageChannels"/> permission.</exception>
+	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the tag 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<ForumPostTag> CreateForumPostTagAsync(string name, DiscordEmoji emoji, bool moderated = false, string reason = null)
+		=> await this.Discord.ApiClient.CreateForumTagAsync(this.Id, name, emoji, moderated, reason);
+
+	/// <summary>
+	/// Deletes a forum channel tag.
+	/// </summary>
+	/// <param name="id">The id of the tag to delete.</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.ManageChannels"/> permission.</exception>
+	/// <exception cref="DisCatSharp.Exceptions.NotFoundException">Thrown when the tag 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 DeleteForumPostTag(ulong id, string reason = null)
+		=> this.Discord.ApiClient.DeleteForumTagAsync(id, this.Id, reason);
+
 	#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/Guild/DiscordGuild.Features.cs b/DisCatSharp/Entities/Guild/DiscordGuild.Features.cs
index 93de48122..6b1312b3c 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.Features.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.Features.cs
@@ -1,302 +1,318 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
+using System;
 using System.Linq;
 
 using DisCatSharp.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>
+	[Obsolete("Store applications are EOL.")]
 	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>
+	[Obsolete("Auto archive duration isn't locked to boosts anymore.")]
 	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>
+	[Obsolete("Auto archive duration isn't locked to boosts anymore.")]
 	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>
+	/// Guild has access to home.
+	/// </summary>
+	public bool GuildHomeTest { get; }
+
+	/// <summary>
+	/// Guild has disabled invites.
+	/// </summary>
+	public bool InvitesDisabled { 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");
+		this.GuildHomeTest = guild.RawFeatures.Contains("GUILD_HOME_TEST");
+		this.InvitesDisabled = guild.RawFeatures.Contains("INVITES_DISABLED");
 
 		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 f65a6246a..89017359c 100644
--- a/DisCatSharp/Entities/Guild/DiscordGuild.cs
+++ b/DisCatSharp/Entities/Guild/DiscordGuild.cs
@@ -1,1960 +1,2027 @@
 // 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 the maximum amount of users allowed per video stage channel.
+	/// </summary>
+	[JsonProperty("max_stage_video_channel_users", NullValueHandling = NullValueHandling.Ignore)]
+	public int? MaxStageVideoChannelUsers { 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>
 	/// <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.UnauthorizedException">Thrown when the client does not have the <see cref="Permissions.Administrator"/> 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)
 		{
 			rfeatures.Add("COMMUNITY");
 		}
 		else if (this.RawFeatures.Contains("COMMUNITY") && !enabled)
 		{
 			rfeatures.Remove("COMMUNITY");
 		}
 		features = rfeatures;
 
 		return await this.Discord.ApiClient.ModifyGuildCommunitySettingsAsync(this.Id, features, rulesChannelId, publicUpdatesChannelId, preferredLocale, description, defaultMessageNotifications, explicitContentFilter, verificationLevel, reason).ConfigureAwait(false);
 	}
 
+	/// <summary>
+	/// Enables invites for the guild.
+	/// </summary>
+	/// <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> EnableInvitesAsync(string reason = null)
+	{
+		List<string> features = new();
+		var rfeatures = this.RawFeatures.ToList();
+		if (this.Features.InvitesDisabled)
+			rfeatures.Remove("INVITES_DISABLED");
+		features = rfeatures;
+
+		return await this.Discord.ApiClient.ModifyGuildFeaturesAsync(this.Id, features, reason);
+	}
+
+	/// <summary>
+	/// Disables invites for the guild.
+	/// </summary>
+	/// <param name="reason"></param>
+	/// <returns></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> DisableInvitesAsync(string reason = null)
+	{
+		List<string> features = new();
+		var rfeatures = this.RawFeatures.ToList();
+		if (!this.Features.InvitesDisabled)
+			rfeatures.Add("INVITES_DISABLED");
+		features = rfeatures;
+
+		return await this.Discord.ApiClient.ModifyGuildFeaturesAsync(this.Id, features, reason);
+	}
+
 	/// <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 forum channel in this guild.
+	/// <note type="note">The field template is not yet released, so it won't applied.</note>
+	/// </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="defaultReactionEmoji">The default reaction emoji for posts.</param>
+	/// <param name="perUserRateLimit">Slow mode timeout for users.</param>
+	/// <param name="postCreateUserRateLimit">Slow mode timeout for user post creations.</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 or the guild does not have the forum channel feature.</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> CreateForumChannelAsync(string name, DiscordChannel parent = null, Optional<string> topic = default, IEnumerable<DiscordOverwriteBuilder> overwrites = null, bool? nsfw = null, Optional<ForumReactionEmoji> defaultReactionEmoji = default, Optional<int?> perUserRateLimit = default, Optional<int?> postCreateUserRateLimit = default, ThreadAutoArchiveDuration defaultAutoArchiveDuration = ThreadAutoArchiveDuration.OneDay, string reason = null)
+		 => this.Discord.ApiClient.CreateForumChannelAsync(this.Id, name, parent?.Id, topic, null, nsfw, defaultReactionEmoji, perUserRateLimit, postCreateUserRateLimit, defaultAutoArchiveDuration, overwrites, 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);
 
 }
diff --git a/DisCatSharp/Entities/Integration/DiscordIntegration.cs b/DisCatSharp/Entities/Integration/DiscordIntegration.cs
index e9c1031ce..ba51523de 100644
--- a/DisCatSharp/Entities/Integration/DiscordIntegration.cs
+++ b/DisCatSharp/Entities/Integration/DiscordIntegration.cs
@@ -1,99 +1,119 @@
 // 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.Enums;
+
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a Discord integration. These appear on the profile as linked 3rd party accounts.
 /// </summary>
 public class DiscordIntegration : SnowflakeObject
 {
 	/// <summary>
 	/// Gets the integration name.
 	/// </summary>
 	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
 	public string Name { get; internal set; }
 
 	/// <summary>
 	/// Gets the integration type.
 	/// </summary>
 	[JsonProperty("type", NullValueHandling = NullValueHandling.Ignore)]
 	public string Type { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this integration is enabled.
 	/// </summary>
 	[JsonProperty("enabled", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsEnabled { get; internal set; }
 
 	/// <summary>
 	/// Gets whether this integration is syncing.
 	/// </summary>
 	[JsonProperty("syncing", NullValueHandling = NullValueHandling.Ignore)]
 	public bool IsSyncing { get; internal set; }
 
 	/// <summary>
 	/// Gets ID of the role this integration uses for subscribers.
 	/// </summary>
 	[JsonProperty("role_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong RoleId { get; internal set; }
 
 	/// <summary>
 	/// Gets the expiration behaviour.
 	/// </summary>
 	[JsonProperty("expire_behavior", NullValueHandling = NullValueHandling.Ignore)]
-	public int ExpireBehavior { get; internal set; }
+	public IntegrationExpireBehavior ExpireBehavior { get; internal set; }
 
 	/// <summary>
 	/// Gets the grace period before expiring subscribers.
 	/// </summary>
 	[JsonProperty("expire_grace_period", NullValueHandling = NullValueHandling.Ignore)]
 	public int ExpireGracePeriod { get; internal set; }
 
 	/// <summary>
 	/// Gets the user that owns this integration.
 	/// </summary>
 	[JsonProperty("user", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordUser User { get; internal set; }
 
 	/// <summary>
 	/// Gets the 3rd party service account for this integration.
 	/// </summary>
 	[JsonProperty("account", NullValueHandling = NullValueHandling.Ignore)]
 	public DiscordIntegrationAccount Account { get; internal set; }
 
 	/// <summary>
 	/// Gets the date and time this integration was last synced.
 	/// </summary>
 	[JsonProperty("synced_at", NullValueHandling = NullValueHandling.Ignore)]
 	public DateTimeOffset SyncedAt { get; internal set; }
 
+	/// <summary>
+	/// Gets the subscriber count.
+	/// </summary>
+	[JsonProperty("subscriber_count", NullValueHandling = NullValueHandling.Ignore)]
+	public int? SubscriberCount { get; internal set; }
+
+	/// <summary>
+	/// Whether the integration is revoked.
+	/// </summary>
+	[JsonProperty("revoked", NullValueHandling = NullValueHandling.Ignore)]
+	public bool? Revoked { get; internal set; }
+
+	[JsonProperty("application", NullValueHandling = NullValueHandling.Ignore)]
+	public DiscordApplication Application { get; internal set; }
+
+	[JsonProperty("scopes", NullValueHandling = NullValueHandling.Ignore)]
+	public string[] Scopes { get; internal set; }
+
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordIntegration"/> class.
 	/// </summary>
 	internal DiscordIntegration()
 	{ }
 }
diff --git a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs b/DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannel.cs
similarity index 97%
rename from DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
rename to DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannel.cs
index d221e4eea..7c09caa7e 100644
--- a/DisCatSharp/Entities/Thread/DiscordThreadChannel.cs
+++ b/DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannel.cs
@@ -1,645 +1,673 @@
 // 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; }
 
+	[JsonProperty("total_message_sent", DefaultValueHandling = DefaultValueHandling.Ignore)]
+	public int TotalMessagesSent { 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.GetForumPostTag(id)).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/ThreadAndForum/DiscordThreadChannelMember.cs
similarity index 100%
rename from DisCatSharp/Entities/Thread/DiscordThreadChannelMember.cs
rename to DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannelMember.cs
diff --git a/DisCatSharp/Entities/Thread/DiscordThreadChannelMetadata.cs b/DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannelMetadata.cs
similarity index 99%
rename from DisCatSharp/Entities/Thread/DiscordThreadChannelMetadata.cs
rename to DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannelMetadata.cs
index a01302f23..a1b628841 100644
--- a/DisCatSharp/Entities/Thread/DiscordThreadChannelMetadata.cs
+++ b/DisCatSharp/Entities/ThreadAndForum/DiscordThreadChannelMetadata.cs
@@ -1,98 +1,100 @@
 // 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 metadata object.
 /// </summary>
 public class DiscordThreadChannelMetadata
 {
 	/// <summary>
 	/// Gets whether the thread is archived or not.
 	/// </summary>
 	[JsonProperty("archived", NullValueHandling = NullValueHandling.Ignore)]
 	public bool Archived { get; internal set; }
 
 	/// <summary>
 	/// Gets ID of the archiver.
 	/// </summary>
 	[JsonProperty("archiver_id", NullValueHandling = NullValueHandling.Ignore)]
 	public ulong? Archiver { get; internal set; }
 
 	/// <summary>
 	/// Gets the time when it will be archived, while there is no action inside the thread (In minutes).
 	/// </summary>
 	[JsonProperty("auto_archive_duration", NullValueHandling = NullValueHandling.Ignore)]
 	public ThreadAutoArchiveDuration AutoArchiveDuration { get; internal set; }
 
 	/// <summary>
 	/// Gets the timestamp when it was archived.
 	/// </summary>
+	[JsonIgnore]
 	public DateTimeOffset? ArchiveTimestamp
 		=> !string.IsNullOrWhiteSpace(this.ArchiveTimestampRaw) && DateTimeOffset.TryParse(this.ArchiveTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets the timestamp when it was archived as raw string.
 	/// </summary>
 	[JsonProperty("archive_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string ArchiveTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Gets whether the thread is locked.
 	/// </summary>
 	[JsonProperty("locked", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Locked { get; internal set; }
 
 	/// <summary>
 	/// Gets whether non-moderators can add other non-moderators to a thread; only available on private threads.
 	/// </summary>
 	[JsonProperty("invitable", NullValueHandling = NullValueHandling.Ignore)]
 	public bool? Invitable { get; internal set; }
 
 	/// <summary>
 	/// Gets the timestamp when the thread was created.
 	/// Only populated for threads created after 2022-01-09.
 	/// </summary>
+	[JsonIgnore]
 	public DateTimeOffset? CreateTimestamp
 		=> !string.IsNullOrWhiteSpace(this.CreateTimestampRaw) && DateTimeOffset.TryParse(this.CreateTimestampRaw, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dto) ?
 			dto : null;
 
 	/// <summary>
 	/// Gets the timestamp when the thread was created as raw string.
 	/// Only populated for threads created after 2022-01-09.
 	/// </summary>
 	[JsonProperty("create_timestamp", NullValueHandling = NullValueHandling.Ignore)]
 	internal string CreateTimestampRaw { get; set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordThreadChannelMetadata"/> class.
 	/// </summary>
 	internal DiscordThreadChannelMetadata()
 	{ }
 }
diff --git a/DisCatSharp/Entities/Thread/DiscordThreadResult.cs b/DisCatSharp/Entities/ThreadAndForum/DiscordThreadResult.cs
similarity index 100%
copy from DisCatSharp/Entities/Thread/DiscordThreadResult.cs
copy to DisCatSharp/Entities/ThreadAndForum/DiscordThreadResult.cs
diff --git a/DisCatSharp/Entities/Thread/ForumPostTag.cs b/DisCatSharp/Entities/ThreadAndForum/ForumPostTag.cs
similarity index 76%
rename from DisCatSharp/Entities/Thread/ForumPostTag.cs
rename to DisCatSharp/Entities/ThreadAndForum/ForumPostTag.cs
index a957103ab..8bc6ebf51 100644
--- a/DisCatSharp/Entities/Thread/ForumPostTag.cs
+++ b/DisCatSharp/Entities/ThreadAndForum/ForumPostTag.cs
@@ -1,110 +1,138 @@
 // 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.Net.Models;
 
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Represents a discord forum post tag.
 /// </summary>
 public class ForumPostTag : SnowflakeObject, IEquatable<ForumPostTag>
 {
+	/// <summary>
+	/// Gets the channel id this tag belongs to.
+	/// </summary>
+	[JsonIgnore]
+	internal ulong ChannelId;
+
 	/// <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;
+	[JsonProperty("emoji_name", NullValueHandling = NullValueHandling.Include)]
+	public string UnicodeEmojiString { get; internal set; }
 
 
 	/// <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.
+	/// Gets the emoji.
+	/// </summary>
+	[JsonIgnore]
+	public DiscordEmoji Emoji
+		=> this.UnicodeEmojiString != null ? DiscordEmoji.FromName(this.Discord, $":{this.UnicodeEmojiString}:", false) : DiscordEmoji.FromGuildEmote(this.Discord, this.EmojiId.Value);
+
+	/// <summary>
+	/// Modifies the tag.
+	/// </summary>
+	/// <exception cref="NotImplementedException">This method is currently not implemented.</exception>
+	public async Task<ForumPostTag> ModifyAsync(Action<ForumPostTagEditModel> action)
+	{
+		var mdl = new ForumPostTagEditModel();
+		action(mdl);
+		return await this.Discord.ApiClient.ModifyForumTagAsync(this.Id, this.ChannelId, mdl.Name.HasValue ? mdl.Name.Value : this.Name, mdl.Emoji.HasValue ? mdl.Emoji.Value : this.Emoji, mdl.Moderated.HasValue ? mdl.Moderated.Value : this.Moderated, mdl.AuditLogReason);
+	}
+
+	/// <summary>
+	/// Deletes the tag.
 	/// </summary>
-	public DiscordEmoji UnicodeEmoji
-		=> this.UnicodeEmojiString != null ? DiscordEmoji.FromName(this.Discord, $":{this.UnicodeEmojiString}:", false) : null;
+	/// <exception cref="NotImplementedException">This method is currently not implemented.</exception>
+	public Task DeleteForumPostTagAsync(string reason = null)
+		=> this.Discord.ApiClient.DeleteForumTagAsync(this.Id, this.ChannelId, reason);
 
 	/// <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/Thread/DiscordThreadResult.cs b/DisCatSharp/Entities/ThreadAndForum/ForumReactionEmoji.cs
similarity index 50%
rename from DisCatSharp/Entities/Thread/DiscordThreadResult.cs
rename to DisCatSharp/Entities/ThreadAndForum/ForumReactionEmoji.cs
index 26e42e810..8c450b8a4 100644
--- a/DisCatSharp/Entities/Thread/DiscordThreadResult.cs
+++ b/DisCatSharp/Entities/ThreadAndForum/ForumReactionEmoji.cs
@@ -1,61 +1,60 @@
 // 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 Newtonsoft.Json;
 
-namespace DisCatSharp.Entities;
-
-/// <summary>
-/// Represents a discord thread result.
-/// </summary>
-public class DiscordThreadResult
+namespace DisCatSharp.Entities
 {
-	/// <summary>
-	/// Gets the returned threads.
-	/// </summary>
-	[JsonIgnore]
-	public Dictionary<ulong, DiscordThreadChannel> ReturnedThreads
-		=> this.Threads == null || !this.Threads.Any() ? new Dictionary<ulong, DiscordThreadChannel>() : this.Threads.Select(t => new { t.Id, t }).ToDictionary(t => t.Id, t => t.t);
-	[JsonProperty("threads", NullValueHandling = NullValueHandling.Ignore)]
-	internal List<DiscordThreadChannel> Threads { get; set; }
+	public class ForumReactionEmoji
+	{
+		/// <summary>
+		/// Creates a new forum reaction emoji.
+		/// Use either <paramref name="emojiId"/> or <paramref name="unicodeEmojiString"/>. Not both.
+		/// </summary>
+		/// <param name="emojiId">The emoji id. Has to be from the same server.</param>
+		/// <param name="unicodeEmojiString">The unicode emoji.</param>
+		public ForumReactionEmoji(ulong? emojiId = null, string unicodeEmojiString = null)
+		{
+			this.EmojiId = emojiId;
+			this.EmojiName = unicodeEmojiString;
+		}
+		
+		/// <summary>
+		/// Gets the emoji id of the forum post tag.
+		/// </summary>
+		[JsonProperty("emoji_id", NullValueHandling = NullValueHandling.Include)]
+		public ulong? EmojiId { get; internal set; }
 
-	/// <summary>
-	/// Gets the active members.
-	/// </summary>
-	[JsonProperty("members", NullValueHandling = NullValueHandling.Ignore)]
-	public List<DiscordThreadChannelMember> ActiveMembers { get; internal set; }
+		/// <summary>
+		/// Gets the unicode emoji of the forum post tag.
+		/// </summary>
+		[JsonProperty("emoji_name", NullValueHandling = NullValueHandling.Include)]
+		public string EmojiName { get; internal set; }
 
-	/// <summary>
-	/// Whether there are more results.
-	/// </summary>
-	public bool HasMore { get; internal set; }
+		/// <summary>
+		/// Gets the emoji.
+		/// </summary>
+		public DiscordEmoji GetEmoji(DiscordClient client)
+			=> this.EmojiName != null ? DiscordEmoji.FromName(client, $":{this.EmojiName}:", false) : DiscordEmoji.FromGuildEmote(client, this.EmojiId.Value);
 
-	/// <summary>
-	/// Initializes a new instance of the <see cref="DiscordThreadResult"/> class.
-	/// </summary>
-	internal DiscordThreadResult()
-		: base()
-	{ }
+	}
 }
diff --git a/DisCatSharp/Entities/User/DiscordConnection.cs b/DisCatSharp/Entities/User/DiscordConnection.cs
index bec1a992f..0097baa3f 100644
--- a/DisCatSharp/Entities/User/DiscordConnection.cs
+++ b/DisCatSharp/Entities/User/DiscordConnection.cs
@@ -1,99 +1,168 @@
 // 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.Enums;
+
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Gets a Discord connection to a 3rd party service.
 /// </summary>
 public class DiscordConnection
 {
 	/// <summary>
 	/// Gets the id of the connection account
 	/// </summary>
 	[JsonProperty("id")]
 	public string Id { get; internal set; }
 
 	/// <summary>
 	/// Gets the username of the connection account.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; internal set; }
 
 	/// <summary>
-	/// Gets the service of the connection (twitch, youtube, steam, twitter, facebook, spotify, leagueoflegends, reddit)
+	/// <para>Gets the service of the connection.</para>
+	/// <list type="table">
+	///		<listheader>
+	///			<term>Type</term>
+	///			<description>Obsolete (Non-assignable)</description>
+	///		</listheader>
+	///		<item>
+	///			<term>twitch</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>steam</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>youtube</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>twitter</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>facebook</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>spotify</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>xbox</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>playstation</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>epicgames</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>reddit</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>battlenet</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>github</term>
+	///			<description>false</description>
+	///		</item>
+	///		<item>
+	///			<term>leagueoflegends</term>
+	///			<description>true</description>
+	///		</item>
+	///		<item>
+	///			<term>skype</term>
+	///			<description>true</description>
+	///		</item>
+	///		<item>
+	///			<term>samsunggalaxy</term>
+	///			<description>true</description>
+	///		</item>
+	/// </list>
 	/// </summary>
 	[JsonProperty("type")]
 	public string Type { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the connection is revoked.
 	/// </summary>
-	[JsonProperty("revoked")]
-	public bool IsRevoked { get; internal set; }
+	[JsonProperty("revoked", NullValueHandling = NullValueHandling.Include)]
+	public bool? IsRevoked { get; internal set; }
 
 	/// <summary>
 	/// Gets a collection of partial server integrations.
 	/// </summary>
 	[JsonProperty("integrations", NullValueHandling = NullValueHandling.Ignore)]
 	public IReadOnlyList<DiscordIntegration> Integrations { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the connection is verified.
 	/// </summary>
 	[JsonProperty("verified", NullValueHandling = NullValueHandling.Ignore)]
-	public bool? Verified { get; internal set; }
+	public bool Verified { get; internal set; }
 
 	/// <summary>
 	/// Gets whether the connection will show a activity.
 	/// </summary>
 	[JsonProperty("show_activity", NullValueHandling = NullValueHandling.Ignore)]
-	public bool? ShowActivity { get; internal set; }
+	public bool ShowActivity { get; internal set; }
 
 	/// <summary>
-	/// Whether the connection will sync friends.
+	/// Whether this connection supports console voice transfer.
+	/// Currently in beta rollout for XBox. Playstation soon.
 	/// </summary>
-	[JsonProperty("friend_sync", NullValueHandling = NullValueHandling.Ignore)]
-	public bool? FriendSync { get; internal set; }
+	[JsonProperty("two_way_link", NullValueHandling = NullValueHandling.Ignore)]
+	public bool TwoWayLink { get; internal set; }
 
 	/// <summary>
 	/// Gets the visibility of the connection.
 	/// </summary>
 	[JsonProperty("visibility", NullValueHandling = NullValueHandling.Ignore)]
-	public long? Visibility { get; internal set; }
+	public ConnectionVisibilityType Visibility { get; internal set; }
 
 	/// <summary>
 	/// Gets the client instance this object is tied to.
 	/// </summary>
 	[JsonIgnore]
 	internal BaseDiscordClient Discord { get; set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="DiscordConnection"/> class.
 	/// </summary>
 	internal DiscordConnection()
 	{ }
 }
diff --git a/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs b/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
index 45cbf86e8..b4418328f 100644
--- a/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
+++ b/DisCatSharp/Entities/Webhook/DiscordWebhookBuilder.cs
@@ -1,441 +1,460 @@
 // 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 System.Linq;
 using System.Threading.Tasks;
 
 namespace DisCatSharp.Entities;
 
 /// <summary>
 /// Constructs ready-to-send webhook requests.
 /// </summary>
 public sealed class DiscordWebhookBuilder
 {
 	/// <summary>
 	/// Username to use for this webhook request.
 	/// </summary>
 	public Optional<string> Username { get; set; }
 
 	/// <summary>
 	/// Avatar url to use for this webhook request.
 	/// </summary>
 	public Optional<string> AvatarUrl { get; set; }
 
 	/// <summary>
 	/// Whether this webhook request is text-to-speech.
 	/// </summary>
 	public bool IsTts { get; set; }
 
 	/// <summary>
 	/// Message to send on this webhook request.
 	/// </summary>
 	public string Content
 	{
 		get => this._content;
 		set
 		{
 			if (value != null && value.Length > 2000)
 				throw new ArgumentException("Content length cannot exceed 2000 characters.", nameof(value));
 			this._content = value;
 		}
 	}
 	private string _content;
 
+	/// <summary>
+	/// Name of the new thread.
+	/// Only works if the webhook is send in a <see cref="ChannelType.Forum"/>.
+	/// </summary>
+	public string ThreadName { get; set; }
+
+
 	/// <summary>
 	/// Whether to keep previous attachments.
 	/// </summary>
 	internal bool? KeepAttachmentsInternal;
 
 	/// <summary>
 	/// Embeds to send on this webhook request.
 	/// </summary>
 	public IReadOnlyList<DiscordEmbed> Embeds => this._embeds;
 	private readonly List<DiscordEmbed> _embeds = new();
 
 	/// <summary>
 	/// Files to send on this webhook request.
 	/// </summary>
 	public IReadOnlyList<DiscordMessageFile> Files => this._files;
 	private readonly List<DiscordMessageFile> _files = new();
 
 	/// <summary>
 	/// Mentions to send on this webhook request.
 	/// </summary>
 	public IReadOnlyList<IMention> Mentions => this._mentions;
 	private readonly List<IMention> _mentions = new();
 
 	/// <summary>
 	/// Gets the components.
 	/// </summary>
 	public IReadOnlyList<DiscordActionRowComponent> Components => this._components;
 	private readonly List<DiscordActionRowComponent> _components = new();
 
 
 	/// <summary>
 	/// Attachments to keep on this webhook request.
 	/// </summary>
 	public IEnumerable<DiscordAttachment> Attachments => this.AttachmentsInternal;
 	internal readonly List<DiscordAttachment> AttachmentsInternal = new();
 
 	/// <summary>
 	/// Constructs a new empty webhook request builder.
 	/// </summary>
 	public DiscordWebhookBuilder() { } // I still see no point in initializing collections with empty collections. //
 
 
 	/// <summary>
 	/// Adds a row of components to the builder, up to 5 components per row, and up to 5 rows per message.
 	/// </summary>
 	/// <param name="components">The components to add to the builder.</param>
 	/// <returns>The current builder to be chained.</returns>
 	/// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
 	public DiscordWebhookBuilder AddComponents(params DiscordComponent[] components)
 		=> this.AddComponents((IEnumerable<DiscordComponent>)components);
 
 
 	/// <summary>
 	/// Appends several rows of components to the builder
 	/// </summary>
 	/// <param name="components">The rows of components to add, holding up to five each.</param>
 	/// <returns></returns>
 	public DiscordWebhookBuilder AddComponents(IEnumerable<DiscordActionRowComponent> components)
 	{
 		var ara = components.ToArray();
 
 		if (ara.Length + this._components.Count > 5)
 			throw new ArgumentException("ActionRow count exceeds maximum of five.");
 
 		foreach (var ar in ara)
 			this._components.Add(ar);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds a row of components to the builder, up to 5 components per row, and up to 5 rows per message.
 	/// </summary>
 	/// <param name="components">The components to add to the builder.</param>
 	/// <returns>The current builder to be chained.</returns>
 	/// <exception cref="System.ArgumentOutOfRangeException">No components were passed.</exception>
 	public DiscordWebhookBuilder AddComponents(IEnumerable<DiscordComponent> components)
 	{
 		var cmpArr = components.ToArray();
 		var count = cmpArr.Length;
 
 		if (!cmpArr.Any())
 			throw new ArgumentOutOfRangeException(nameof(components), "You must provide at least one component");
 
 		if (count > 5)
 			throw new ArgumentException("Cannot add more than 5 components per action row!");
 
 		var comp = new DiscordActionRowComponent(cmpArr);
 		this._components.Add(comp);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the username for this webhook builder.
 	/// </summary>
 	/// <param name="username">Username of the webhook</param>
 	public DiscordWebhookBuilder WithUsername(string username)
 	{
 		this.Username = username;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the avatar of this webhook builder from its url.
 	/// </summary>
 	/// <param name="avatarUrl">Avatar url of the webhook</param>
 	public DiscordWebhookBuilder WithAvatarUrl(string avatarUrl)
 	{
 		this.AvatarUrl = avatarUrl;
 		return this;
 	}
 
 	/// <summary>
 	/// Indicates if the webhook must use text-to-speech.
 	/// </summary>
 	/// <param name="tts">Text-to-speech</param>
 	public DiscordWebhookBuilder WithTts(bool tts)
 	{
 		this.IsTts = tts;
 		return this;
 	}
 
 	/// <summary>
 	/// Sets the message to send at the execution of the webhook.
 	/// </summary>
 	/// <param name="content">Message to send.</param>
 	public DiscordWebhookBuilder WithContent(string content)
 	{
 		this.Content = content;
 		return this;
 	}
 
+	/// <summary>
+	/// Sets the thread name to create at the execution of the webhook.
+	/// Only works for <see cref="ChannelType.Forum"/>.
+	/// </summary>
+	/// <param name="name">The thread name.</param>
+	public DiscordWebhookBuilder WithThreadName(string name)
+	{
+		this.ThreadName = name;
+		return this;
+	}
+
 	/// <summary>
 	/// Adds an embed to send at the execution of the webhook.
 	/// </summary>
 	/// <param name="embed">Embed to add.</param>
 	public DiscordWebhookBuilder AddEmbed(DiscordEmbed embed)
 	{
 		if (embed != null)
 			this._embeds.Add(embed);
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the given embeds to send at the execution of the webhook.
 	/// </summary>
 	/// <param name="embeds">Embeds to add.</param>
 	public DiscordWebhookBuilder AddEmbeds(IEnumerable<DiscordEmbed> embeds)
 	{
 		this._embeds.AddRange(embeds);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds a file to send at the execution of the webhook.
 	/// </summary>
 	/// <param name="filename">Name of the file.</param>
 	/// <param name="data">File data.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <param name="description">Description of the file.</param>
 	public DiscordWebhookBuilder AddFile(string filename, Stream data, bool resetStreamPosition = false, string description = null)
 	{
 		if (this.Files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		if (this._files.Any(x => x.FileName == filename))
 			throw new ArgumentException("A File with that filename already exists");
 
 		if (resetStreamPosition)
 			this._files.Add(new DiscordMessageFile(filename, data, data.Position, description: description));
 		else
 			this._files.Add(new DiscordMessageFile(filename, data, null, description: description));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Sets if the message has files to be sent.
 	/// </summary>
 	/// <param name="stream">The Stream to the file.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	/// <param name="description">Description of the file.</param>
 	/// <returns></returns>
 	public DiscordWebhookBuilder AddFile(FileStream stream, bool resetStreamPosition = false, string description = null)
 	{
 		if (this.Files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		if (this._files.Any(x => x.FileName == stream.Name))
 			throw new ArgumentException("A File with that filename already exists");
 
 		if (resetStreamPosition)
 			this._files.Add(new DiscordMessageFile(stream.Name, stream, stream.Position, description: description));
 		else
 			this._files.Add(new DiscordMessageFile(stream.Name, stream, null, description: description));
 
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the given files to send at the execution of the webhook.
 	/// </summary>
 	/// <param name="files">Dictionary of file name and file data.</param>
 	/// <param name="resetStreamPosition">Tells the API Client to reset the stream position to what it was after the file is sent.</param>
 	public DiscordWebhookBuilder AddFiles(Dictionary<string, Stream> files, bool resetStreamPosition = false)
 	{
 		if (this.Files.Count + files.Count > 10)
 			throw new ArgumentException("Cannot send more than 10 files with a single message.");
 
 		foreach (var file in files)
 		{
 			if (this._files.Any(x => x.FileName == file.Key))
 				throw new ArgumentException("A File with that filename already exists");
 
 			if (resetStreamPosition)
 				this._files.Add(new DiscordMessageFile(file.Key, file.Value, file.Value.Position));
 			else
 				this._files.Add(new DiscordMessageFile(file.Key, file.Value, null));
 		}
 
 
 		return this;
 	}
 
 	/// <summary>
 	/// Modifies the given attachments on edit.
 	/// </summary>
 	/// <param name="attachments">Attachments to edit.</param>
 	/// <returns></returns>
 	public DiscordWebhookBuilder ModifyAttachments(IEnumerable<DiscordAttachment> attachments)
 	{
 		this.AttachmentsInternal.AddRange(attachments);
 		return this;
 	}
 
 	/// <summary>
 	/// Whether to keep the message attachments, if new ones are added.
 	/// </summary>
 	/// <returns></returns>
 	public DiscordWebhookBuilder KeepAttachments(bool keep)
 	{
 		this.KeepAttachmentsInternal = keep;
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the mention to the mentions to parse, etc. at the execution of the webhook.
 	/// </summary>
 	/// <param name="mention">Mention to add.</param>
 	public DiscordWebhookBuilder AddMention(IMention mention)
 	{
 		this._mentions.Add(mention);
 		return this;
 	}
 
 	/// <summary>
 	/// Adds the mentions to the mentions to parse, etc. at the execution of the webhook.
 	/// </summary>
 	/// <param name="mentions">Mentions to add.</param>
 	public DiscordWebhookBuilder AddMentions(IEnumerable<IMention> mentions)
 	{
 		this._mentions.AddRange(mentions);
 		return this;
 	}
 
 	/// <summary>
 	/// Executes a webhook.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <returns>The message sent</returns>
 	public async Task<DiscordMessage> SendAsync(DiscordWebhook webhook) => await webhook.ExecuteAsync(this).ConfigureAwait(false);
 
 	/// <summary>
 	/// Executes a webhook.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <param name="threadId">Target thread id.</param>
 	/// <returns>The message sent</returns>
 	public async Task<DiscordMessage> SendAsync(DiscordWebhook webhook, ulong threadId) => await webhook.ExecuteAsync(this, threadId.ToString()).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends the modified webhook message.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <param name="message">The message to modify.</param>
 	/// <returns>The modified message</returns>
 	public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, DiscordMessage message) => await this.ModifyAsync(webhook, message.Id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends the modified webhook message.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <param name="messageId">The id of the message to modify.</param>
 	/// <returns>The modified message</returns>
 	public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, ulong messageId) => await webhook.EditMessageAsync(messageId, this).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends the modified webhook message.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <param name="message">The message to modify.</param>
 	/// <param name="thread">Target thread.</param>
 	/// <returns>The modified message</returns>
 	public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, DiscordMessage message, DiscordThreadChannel thread) => await this.ModifyAsync(webhook, message.Id, thread.Id).ConfigureAwait(false);
 
 	/// <summary>
 	/// Sends the modified webhook message.
 	/// </summary>
 	/// <param name="webhook">The webhook that should be executed.</param>
 	/// <param name="messageId">The id of the message to modify.</param>
 	/// <param name="threadId">Target thread id.</param>
 	/// <returns>The modified message</returns>
 	public async Task<DiscordMessage> ModifyAsync(DiscordWebhook webhook, ulong messageId, ulong threadId) => await webhook.EditMessageAsync(messageId, this, threadId.ToString()).ConfigureAwait(false);
 
 	/// <summary>
 	/// Clears all message components on this builder.
 	/// </summary>
 	public void ClearComponents()
 		=> this._components.Clear();
 
 	/// <summary>
 	/// Allows for clearing the Webhook Builder so that it can be used again to send a new message.
 	/// </summary>
 	public void Clear()
 	{
 		this.Content = "";
 		this._embeds.Clear();
 		this.IsTts = false;
 		this._mentions.Clear();
 		this._files.Clear();
 		this.AttachmentsInternal.Clear();
 		this._components.Clear();
 		this.KeepAttachmentsInternal = false;
+		this.ThreadName = null;
 	}
 
 	/// <summary>
 	/// Does the validation before we send a the Create/Modify request.
 	/// </summary>
 	/// <param name="isModify">Tells the method to perform the Modify Validation or Create Validation.</param>
 	/// <param name="isFollowup">Tells the method to perform the follow up message validation.</param>
 	/// <param name="isInteractionResponse">Tells the method to perform the interaction response validation.</param>
 	internal void Validate(bool isModify = false, bool isFollowup = false, bool isInteractionResponse = false)
 	{
 		if (isModify)
 		{
 			if (this.Username.HasValue)
 				throw new ArgumentException("You cannot change the username of a message.");
 
 			if (this.AvatarUrl.HasValue)
 				throw new ArgumentException("You cannot change the avatar of a message.");
 		}
 		else if (isFollowup)
 		{
 			if (this.Username.HasValue)
 				throw new ArgumentException("You cannot change the username of a follow up message.");
 
 			if (this.AvatarUrl.HasValue)
 				throw new ArgumentException("You cannot change the avatar of a follow up message.");
 		}
 		else if (isInteractionResponse)
 		{
 			if (this.Username.HasValue)
 				throw new ArgumentException("You cannot change the username of an interaction response.");
 
 			if (this.AvatarUrl.HasValue)
 				throw new ArgumentException("You cannot change the avatar of an interaction response.");
 		}
 		else
 		{
 			if (this.Files?.Count == 0 && string.IsNullOrEmpty(this.Content) && !this.Embeds.Any())
 				throw new ArgumentException("You must specify content, an embed, or at least one file.");
 		}
 	}
 }
diff --git a/DisCatSharp/Net/Abstractions/ReadyPayload.cs b/DisCatSharp/Enums/Integration/IntegrationExpireBehavior.cs
similarity index 53%
copy from DisCatSharp/Net/Abstractions/ReadyPayload.cs
copy to DisCatSharp/Enums/Integration/IntegrationExpireBehavior.cs
index 94dd2a935..1a903c691 100644
--- a/DisCatSharp/Net/Abstractions/ReadyPayload.cs
+++ b/DisCatSharp/Enums/Integration/IntegrationExpireBehavior.cs
@@ -1,65 +1,40 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-using System.Collections.Generic;
-
-using DisCatSharp.Entities;
-
-using Newtonsoft.Json;
-
-namespace DisCatSharp.Net.Abstractions;
-
-/// <summary>
-/// Represents data for websocket ready event payload.
-/// </summary>
-internal class ReadyPayload
+namespace DisCatSharp.Enums
 {
 	/// <summary>
-	/// Gets the gateway version the client is connected to.
-	/// </summary>
-	[JsonProperty("v")]
-	public int GatewayVersion { get; private set; }
-
-	/// <summary>
-	/// Gets the current user.
-	/// </summary>
-	[JsonProperty("user")]
-	public TransportUser CurrentUser { get; private set; }
-
-	/// <summary>
-	/// Gets the guilds available for this shard.
-	/// </summary>
-	[JsonProperty("guilds")]
-	public IReadOnlyList<DiscordGuild> Guilds { get; private set; }
-
-	/// <summary>
-	/// Gets the current session's ID.
-	/// </summary>
-	[JsonProperty("session_id")]
-	public string SessionId { get; private set; }
-
-	/// <summary>
-	/// Gets debug data sent by Discord. This contains a list of servers to which the client is connected.
+	/// Represents the integration expire behavior.
 	/// </summary>
-	[JsonProperty("_trace")]
-	public IReadOnlyList<string> Trace { get; private set; }
+	public enum IntegrationExpireBehavior : int
+	{
+		/// <summary>
+		/// Removes the role from the member.
+		/// </summary>
+		RemoveRole = 0,
+
+		/// <summary>
+		/// Kicks the member.
+		/// </summary>
+		Kick = 1
+	}
 }
diff --git a/DisCatSharp/Net/Abstractions/ReadyPayload.cs b/DisCatSharp/Enums/User/ConnectionVisibilityType.cs
similarity index 53%
copy from DisCatSharp/Net/Abstractions/ReadyPayload.cs
copy to DisCatSharp/Enums/User/ConnectionVisibilityType.cs
index 94dd2a935..7b3e9eb2c 100644
--- a/DisCatSharp/Net/Abstractions/ReadyPayload.cs
+++ b/DisCatSharp/Enums/User/ConnectionVisibilityType.cs
@@ -1,65 +1,40 @@
 // This file is part of the DisCatSharp project, based off DSharpPlus.
 //
 // Copyright (c) 2021-2022 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-using System.Collections.Generic;
-
-using DisCatSharp.Entities;
-
-using Newtonsoft.Json;
-
-namespace DisCatSharp.Net.Abstractions;
-
-/// <summary>
-/// Represents data for websocket ready event payload.
-/// </summary>
-internal class ReadyPayload
+namespace DisCatSharp.Enums
 {
 	/// <summary>
-	/// Gets the gateway version the client is connected to.
-	/// </summary>
-	[JsonProperty("v")]
-	public int GatewayVersion { get; private set; }
-
-	/// <summary>
-	/// Gets the current user.
-	/// </summary>
-	[JsonProperty("user")]
-	public TransportUser CurrentUser { get; private set; }
-
-	/// <summary>
-	/// Gets the guilds available for this shard.
-	/// </summary>
-	[JsonProperty("guilds")]
-	public IReadOnlyList<DiscordGuild> Guilds { get; private set; }
-
-	/// <summary>
-	/// Gets the current session's ID.
-	/// </summary>
-	[JsonProperty("session_id")]
-	public string SessionId { get; private set; }
-
-	/// <summary>
-	/// Gets debug data sent by Discord. This contains a list of servers to which the client is connected.
+	/// The visibility type of user account connections.
 	/// </summary>
-	[JsonProperty("_trace")]
-	public IReadOnlyList<string> Trace { get; private set; }
+	public enum ConnectionVisibilityType : long
+	{
+		/// <summary>
+		/// This connection type is only visible to the owning user.
+		/// </summary>
+		None = 0,
+
+		/// <summary>
+		/// This connection is visible to everyone.
+		/// </summary>
+		Everyone = 1
+	}
 }
diff --git a/DisCatSharp/Net/Abstractions/ReadyPayload.cs b/DisCatSharp/Net/Abstractions/ReadyPayload.cs
index 94dd2a935..1821d3519 100644
--- a/DisCatSharp/Net/Abstractions/ReadyPayload.cs
+++ b/DisCatSharp/Net/Abstractions/ReadyPayload.cs
@@ -1,65 +1,71 @@
 // 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 Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions;
 
 /// <summary>
 /// Represents data for websocket ready event payload.
 /// </summary>
 internal class ReadyPayload
 {
 	/// <summary>
 	/// Gets the gateway version the client is connected to.
 	/// </summary>
 	[JsonProperty("v")]
 	public int GatewayVersion { get; private set; }
 
 	/// <summary>
 	/// Gets the current user.
 	/// </summary>
 	[JsonProperty("user")]
 	public TransportUser CurrentUser { get; private set; }
 
 	/// <summary>
 	/// Gets the guilds available for this shard.
 	/// </summary>
 	[JsonProperty("guilds")]
 	public IReadOnlyList<DiscordGuild> Guilds { get; private set; }
 
 	/// <summary>
 	/// Gets the current session's ID.
 	/// </summary>
 	[JsonProperty("session_id")]
 	public string SessionId { get; private set; }
 
+	/// <summary>
+	/// The gateway url for resuming connections
+	/// </summary>
+	[JsonProperty("resume_gateway_url")]
+	public string ResumeGatewayUrl { get; set; }
+
 	/// <summary>
 	/// Gets debug data sent by Discord. This contains a list of servers to which the client is connected.
 	/// </summary>
 	[JsonProperty("_trace")]
 	public IReadOnlyList<string> Trace { get; private set; }
 }
diff --git a/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs b/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs
index 359df4bd0..8f9b0f492 100644
--- a/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs
+++ b/DisCatSharp/Net/Abstractions/Rest/RestChannelPayloads.cs
@@ -1,505 +1,529 @@
 // 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 template.
+	/// </summary>
+	[JsonProperty("template")]
+	public Optional<string> Template { 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; }
 
+	[JsonProperty("default_thread_rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
+	public Optional<int?> PostCreateUserRateLimit { get; internal 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>
+	/// List of available tags for forum posts.
+	/// </summary>
+	[JsonProperty("default_reaction_emoji", NullValueHandling = NullValueHandling.Ignore)]
+	public Optional<ForumReactionEmoji> DefaultReactionEmoji { get; internal 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 the template.
+	/// </summary>
+	[JsonProperty("template")]
+	public Optional<string> Template { 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; }
+	public Optional<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; }
 
+	[JsonProperty("default_thread_rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
+	public Optional<int?> PostCreateUserRateLimit { get; internal 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.
+	/// List of available tags for forum posts.
 	/// </summary>
-	[JsonProperty("banner")]
-	public Optional<string> BannerBase64 { get; set; }
+	[JsonProperty("default_reaction_emoji", NullValueHandling = NullValueHandling.Ignore)]
+	public Optional<ForumReactionEmoji> DefaultReactionEmoji { get; internal 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/ReadyPayload.cs b/DisCatSharp/Net/Abstractions/Rest/RestForumPostTagPayloads.cs
similarity index 65%
copy from DisCatSharp/Net/Abstractions/ReadyPayload.cs
copy to DisCatSharp/Net/Abstractions/Rest/RestForumPostTagPayloads.cs
index 94dd2a935..809bbbc94 100644
--- a/DisCatSharp/Net/Abstractions/ReadyPayload.cs
+++ b/DisCatSharp/Net/Abstractions/Rest/RestForumPostTagPayloads.cs
@@ -1,65 +1,60 @@
 // 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 data for websocket ready event payload.
+/// Represents the forum tag payload.
 /// </summary>
-internal class ReadyPayload
+public class RestForumPostTagPayloads
 {
 	/// <summary>
-	/// Gets the gateway version the client is connected to.
+	/// Sets the tags's new name.
 	/// </summary>
-	[JsonProperty("v")]
-	public int GatewayVersion { get; private set; }
+	[JsonProperty("name")]
+	public string Name { internal get; set; }
 
 	/// <summary>
-	/// Gets the current user.
+	/// Sets the tags's new emoji.
 	/// </summary>
-	[JsonProperty("user")]
-	public TransportUser CurrentUser { get; private set; }
+	[JsonProperty("emoji_id", NullValueHandling = NullValueHandling.Include)]
+	public Optional<ulong?> Emoji { internal get; set; }
 
 	/// <summary>
-	/// Gets the guilds available for this shard.
+	/// Sets whether the tag should be mod only.
 	/// </summary>
-	[JsonProperty("guilds")]
-	public IReadOnlyList<DiscordGuild> Guilds { get; private set; }
+	[JsonProperty("moderated", NullValueHandling = NullValueHandling.Ignore)]
+	public bool Moderated { internal get; set; }
 
 	/// <summary>
-	/// Gets the current session's ID.
+	/// Gets the unicode emoji of the forum post tag.
 	/// </summary>
-	[JsonProperty("session_id")]
-	public string SessionId { get; private set; }
-
-	/// <summary>
-	/// Gets debug data sent by Discord. This contains a list of servers to which the client is connected.
-	/// </summary>
-	[JsonProperty("_trace")]
-	public IReadOnlyList<string> Trace { get; private set; }
+	[JsonProperty("emoji_name", NullValueHandling = NullValueHandling.Include)]
+	public Optional<string> UnicodeEmojiString { internal get; set; }
 }
diff --git a/DisCatSharp/Net/Abstractions/Rest/RestGuildPayloads.cs b/DisCatSharp/Net/Abstractions/Rest/RestGuildPayloads.cs
index 3b7c2aabb..3daa83b45 100644
--- a/DisCatSharp/Net/Abstractions/Rest/RestGuildPayloads.cs
+++ b/DisCatSharp/Net/Abstractions/Rest/RestGuildPayloads.cs
@@ -1,736 +1,748 @@
 // 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 RestGuildFeatureModifyPayload
+{
+	/// <summary>
+	/// Gets or sets the features.
+	/// </summary>
+	[JsonProperty("features", NullValueHandling = NullValueHandling.Ignore)]
+	public List<string> Features { 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/Rest/RestWebhookPayloads.cs b/DisCatSharp/Net/Abstractions/Rest/RestWebhookPayloads.cs
index 007b3b864..8ccb8e18f 100644
--- a/DisCatSharp/Net/Abstractions/Rest/RestWebhookPayloads.cs
+++ b/DisCatSharp/Net/Abstractions/Rest/RestWebhookPayloads.cs
@@ -1,155 +1,161 @@
 // 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 Newtonsoft.Json;
 
 namespace DisCatSharp.Net.Abstractions;
 
 /// <summary>
 /// Represents a webhook payload.
 /// </summary>
 internal sealed class RestWebhookPayload
 {
 	/// <summary>
 	/// Gets or sets the name.
 	/// </summary>
 	[JsonProperty("name")]
 	public string Name { get; set; }
 
 	/// <summary>
 	/// Gets or sets the avatar base64.
 	/// </summary>
 	[JsonProperty("avatar", NullValueHandling = NullValueHandling.Include)]
 	public string AvatarBase64 { get; set; }
 
 	/// <summary>
 	/// Gets or sets the channel id.
 	/// </summary>
 	[JsonProperty("channel_id")]
 	public ulong ChannelId { get; set; }
 
 	/// <summary>
 	/// Gets whether an avatar is set.
 	/// </summary>
 	[JsonProperty]
 	public bool AvatarSet { get; set; }
 
 	/// <summary>
 	/// Gets whether the avatar should be serialized.
 	/// </summary>
 	public bool ShouldSerializeAvatarBase64()
 		=> this.AvatarSet;
 }
 
 /// <summary>
 /// Represents a webhook execute payload.
 /// </summary>
 internal sealed class RestWebhookExecutePayload
 {
 	/// <summary>
 	/// Gets or sets the content.
 	/// </summary>
 	[JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
 	public string Content { get; set; }
 
 	/// <summary>
 	/// Gets or sets the username.
 	/// </summary>
 	[JsonProperty("username", NullValueHandling = NullValueHandling.Ignore)]
 	public string Username { get; set; }
 
 	/// <summary>
 	/// Gets or sets the avatar url.
 	/// </summary>
 	[JsonProperty("avatar_url", NullValueHandling = NullValueHandling.Ignore)]
 	public string AvatarUrl { get; set; }
 
 	/// <summary>
 	/// Whether this message is tts.
 	/// </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 components.
 	/// </summary>
 	[JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordActionRowComponent> Components { get; set; }
 
 	/// <summary>
 	/// Gets or sets the attachments.
 	/// </summary>
 	[JsonProperty("attachments", NullValueHandling = NullValueHandling.Ignore)]
 	public List<DiscordAttachment> Attachments { get; set; }
+
+	///<summary>
+	/// Gets or sets the thread name.
+	/// </summary>
+	[JsonProperty("thread_name", NullValueHandling = NullValueHandling.Ignore)]
+	public string ThreadName { get; set; }
 }
 
 /// <summary>
 /// Represents a webhook message edit payload.
 /// </summary>
 internal sealed class RestWebhookMessageEditPayload
 {
 	/// <summary>
 	/// Gets or sets the content.
 	/// </summary>
 	[JsonProperty("content", NullValueHandling = NullValueHandling.Ignore)]
 	public Optional<string> Content { 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 IEnumerable<IMention> 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 components.
 	/// </summary>
 	[JsonProperty("components", NullValueHandling = NullValueHandling.Ignore)]
 	public IEnumerable<DiscordActionRowComponent> Components { get; set; }
 }
diff --git a/DisCatSharp/Net/Models/ChannelEditModel.cs b/DisCatSharp/Net/Models/ChannelEditModel.cs
index b1a80cb40..a0cea6dd3 100644
--- a/DisCatSharp/Net/Models/ChannelEditModel.cs
+++ b/DisCatSharp/Net/Models/ChannelEditModel.cs
@@ -1,120 +1,112 @@
 // 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/ChannelEditModel.cs b/DisCatSharp/Net/Models/ForumChannelEditModel.cs
similarity index 75%
copy from DisCatSharp/Net/Models/ChannelEditModel.cs
copy to DisCatSharp/Net/Models/ForumChannelEditModel.cs
index b1a80cb40..5147c846e 100644
--- a/DisCatSharp/Net/Models/ChannelEditModel.cs
+++ b/DisCatSharp/Net/Models/ForumChannelEditModel.cs
@@ -1,120 +1,102 @@
 // 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.
+/// Represents a forum channel edit model.
 /// </summary>
-public class ChannelEditModel : BaseEditModel
+public class ForumChannelEditModel : 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 the channel's new template.
+	/// <note type="warning">This is not yet released and won't be applied by library.</note>
+	/// </summary>
+	public Optional<string> Template { internal get; set; }
+
 	/// <summary>
 	/// Sets whether the channel is to be marked as NSFW.
 	/// </summary>
 	public bool? Nsfw { internal get; set; }
 
+	public Optional<ForumReactionEmoji> DefaultReactionEmoji { 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>
+	/// <para>Sets the channel's new post slow mode timeout.</para>
+	/// <para>Setting this to null or 0 will disable slow mode.</para>
 	/// </summary>
-	public VideoQualityMode? QualityMode { internal get; set; }
+	public Optional<int?> PostCreateUserRateLimit { 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()
+	internal ForumChannelEditModel()
 	{ }
 }
diff --git a/DisCatSharp/Net/Abstractions/ReadyPayload.cs b/DisCatSharp/Net/Models/ForumPostTagEditModel.cs
similarity index 57%
copy from DisCatSharp/Net/Abstractions/ReadyPayload.cs
copy to DisCatSharp/Net/Models/ForumPostTagEditModel.cs
index 94dd2a935..9f86c58fa 100644
--- a/DisCatSharp/Net/Abstractions/ReadyPayload.cs
+++ b/DisCatSharp/Net/Models/ForumPostTagEditModel.cs
@@ -1,65 +1,49 @@
-// This file is part of the DisCatSharp project, based off DSharpPlus.
+// 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;
+namespace DisCatSharp.Net.Models;
 
 /// <summary>
-/// Represents data for websocket ready event payload.
+/// Represents a tag edit model.
 /// </summary>
-internal class ReadyPayload
+public class ForumPostTagEditModel : BaseEditModel
 {
 	/// <summary>
-	/// Gets the gateway version the client is connected to.
-	/// </summary>
-	[JsonProperty("v")]
-	public int GatewayVersion { get; private set; }
-
-	/// <summary>
-	/// Gets the current user.
-	/// </summary>
-	[JsonProperty("user")]
-	public TransportUser CurrentUser { get; private set; }
-
-	/// <summary>
-	/// Gets the guilds available for this shard.
+	/// Sets the tags's new name.
 	/// </summary>
-	[JsonProperty("guilds")]
-	public IReadOnlyList<DiscordGuild> Guilds { get; private set; }
+	public Optional<string> Name { internal get; set; }
 
 	/// <summary>
-	/// Gets the current session's ID.
+	/// Sets the tags's new emoji.
 	/// </summary>
-	[JsonProperty("session_id")]
-	public string SessionId { get; private set; }
+	public Optional<DiscordEmoji> Emoji { internal get; set; }
 
 	/// <summary>
-	/// Gets debug data sent by Discord. This contains a list of servers to which the client is connected.
+	/// Sets whether the tag should be mod only.
 	/// </summary>
-	[JsonProperty("_trace")]
-	public IReadOnlyList<string> Trace { get; private set; }
+	public Optional<bool> Moderated { internal get; set; }
 }
diff --git a/DisCatSharp/Net/Rest/DiscordApiClient.cs b/DisCatSharp/Net/Rest/DiscordApiClient.cs
index 502e719ba..0eeffbb30 100644
--- a/DisCatSharp/Net/Rest/DiscordApiClient.cs
+++ b/DisCatSharp/Net/Rest/DiscordApiClient.cs
@@ -1,5314 +1,5551 @@
 // 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.Channels;
 using System.Threading.Tasks;
+using System.Xml.Linq;
 
 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>
+	/// Modifies the guild features.
+	/// </summary>
+	/// <param name="guildId">The guild id.</param>
+	/// <param name="features">The guild features.</param>
+	/// <param name="reason">The reason.</param>
+	/// <returns></returns>
+	internal async Task<DiscordGuild> ModifyGuildFeaturesAsync(ulong guildId, List<string> features, string reason)
+	{
+		var pld = new RestGuildFeatureModifyPayload
+		{
+			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.
+	/// Creates a guild channel.
 	/// </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>
+	/// Creates a guild forum channel.
+	/// </summary>
+	/// <param name="guildId">The guild_id.</param>
+	/// <param name="name">The name.</param>
+	/// <param name="parent">The parent.</param>
+	/// <param name="topic">The topic.</param>
+	/// <param name="template">The template.</param>
+	/// <param name="defaultReactionEmoji">The default reaction emoji.</param>
+	/// <param name="permissionOverwrites">The overwrites.</param>
+	/// <param name="nsfw">If true, nsfw.</param>
+	/// <param name="perUserRateLimit">The per user rate limit.</param>
+	/// <param name="postCreateUserRateLimit">The per user post create rate limit.</param>
+	/// <param name="defaultAutoArchiveDuration">The default auto archive duration.</param>
+	/// <param name="reason">The reason.</param>
+	internal async Task<DiscordChannel> CreateForumChannelAsync(ulong guildId, string name, ulong? parent,
+		Optional<string> topic, Optional<string> template,
+		bool? nsfw, Optional<ForumReactionEmoji> defaultReactionEmoji,
+		Optional<int?> perUserRateLimit, Optional<int?> postCreateUserRateLimit,
+		ThreadAutoArchiveDuration? defaultAutoArchiveDuration, IEnumerable<DiscordOverwriteBuilder> permissionOverwrites, 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 RestChannelCreatePayload
+		{
+			Name = name,
+			Topic = topic,
+			//Template = template,
+			Nsfw = nsfw,
+			Parent = parent,
+			PerUserRateLimit = perUserRateLimit,
+			PostCreateUserRateLimit = postCreateUserRateLimit,
+			DefaultAutoArchiveDuration = defaultAutoArchiveDuration,
+			DefaultReactionEmoji = defaultReactionEmoji,
+			PermissionOverwrites = restoverwrites
+		};
+
+		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)
+	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, 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
+			PermissionOverwrites = restoverwrites
 		};
 
 		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));
 	}
 
+	internal Task ModifyForumChannelAsync(ulong channelId, string name, int? position,
+		Optional<string> topic, Optional<string> template, bool? nsfw,
+		Optional<ulong?> parent, Optional<ForumReactionEmoji> defaultReactionEmoji,
+		Optional<int?> perUserRateLimit, Optional<int?> postCreateUserRateLimit,
+		ThreadAutoArchiveDuration? defaultAutoArchiveDuration, IEnumerable<DiscordOverwriteBuilder> permissionOverwrites, 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,
+			//Template = template,
+			Nsfw = nsfw,
+			Parent = parent,
+			PerUserRateLimit = perUserRateLimit,
+			PostCreateUserRateLimit = postCreateUserRateLimit,
+			DefaultAutoArchiveDuration = defaultAutoArchiveDuration,
+			DefaultReactionEmoji = defaultReactionEmoji,
+			PermissionOverwrites = restoverwrites
+		};
+
+		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));
+	}
+
+	internal async Task<ForumPostTag> CreateForumTagAsync(ulong channelId, string name, DiscordEmoji emoji, bool moderated, string reason)
+	{
+		var pld = new RestForumPostTagPayloads
+		{
+			Name = name,
+			Moderated = moderated
+		};
+		if (emoji != null)
+			if (emoji.Id == 0)
+			{
+				pld.Emoji = null;
+				pld.UnicodeEmojiString = emoji.Name;
+			}
+			else
+			{
+				pld.Emoji = emoji.Id;
+				pld.UnicodeEmojiString = null;
+			}
+		else
+		{
+			pld.Emoji = null;
+			pld.UnicodeEmojiString = null;
+		}
+
+		var headers = Utilities.GetBaseHeaders();
+		if (!string.IsNullOrWhiteSpace(reason))
+			headers.Add(REASON_HEADER_NAME, reason);
+
+		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.TAGS}";
+		var bucket = this.Rest.GetBucket(RestRequestMethod.POST, route, new { channel_id = channelId }, out var path);
+
+		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
+		var res = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, headers, DiscordJson.SerializeObject(pld));
+		var channel = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
+		channel.Discord = this.Discord;
+		var tag = channel.AvailableTags.First(x => x.Name == name);
+		tag.Discord = this.Discord;
+		return tag;
+	}
+
+	internal async Task<ForumPostTag> ModifyForumTagAsync(ulong id, ulong channelId, string name, DiscordEmoji emoji = null, bool moderated = false, string reason = null)
+	{
+		var pld = new RestForumPostTagPayloads
+		{
+			Name = name,
+			Moderated = moderated
+		};
+		if (emoji != null)
+			if (emoji.Id == 0)
+			{
+				pld.Emoji = null;
+				pld.UnicodeEmojiString = emoji.Name;
+			}
+			else
+			{
+				pld.Emoji = emoji.Id;
+				pld.UnicodeEmojiString = null;
+			}
+		else
+		{
+			pld.Emoji = null;
+			pld.UnicodeEmojiString = null;
+		}
+
+		var headers = Utilities.GetBaseHeaders();
+		if (!string.IsNullOrWhiteSpace(reason))
+			headers.Add(REASON_HEADER_NAME, reason);
+
+		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.TAGS}/:tag_id";
+		var bucket = this.Rest.GetBucket(RestRequestMethod.PUT, route, new { channel_id = channelId, tag_id = id }, out var path);
+
+		var url = Utilities.GetApiUriFor(path, this.Discord.Configuration);
+		var res = await  this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.PUT, route, headers, DiscordJson.SerializeObject(pld));
+		var channel = JsonConvert.DeserializeObject<DiscordChannel>(res.Response);
+		channel.Discord = this.Discord;
+		var tag = channel.AvailableTags.First(x => x.Name == name);
+		tag.Discord = this.Discord;
+		return tag;
+	}
+
+	internal Task DeleteForumTagAsync(ulong id, ulong channelId, string reason)
+	{
+		var headers = Utilities.GetBaseHeaders();
+		if (!string.IsNullOrWhiteSpace(reason))
+			headers.Add(REASON_HEADER_NAME, reason);
+
+		var route = $"{Endpoints.CHANNELS}/:channel_id{Endpoints.TAGS}/:tag_id";
+		var bucket = this.Rest.GetBucket(RestRequestMethod.DELETE, route, new { channel_id = channelId, tag_id = id }, 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 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;
 		}
+		foreach(var xo in ret.AvailableTags)
+		{
+			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
+			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);
 		threadReturn.Threads.ForEach(x => x.Discord = this.Discord);
 
 		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*/
 			});
 		}
 
 		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*/
 		};
 
 		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*/
 		};
 
 		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*/
 			});
 		}
 		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*/
 		};
 
 		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*/
 		};
 
 		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 != ComponentType.InputText && c.Type != ComponentType.Select)))
 			throw new NotSupportedException("Can't send any other type then Input Text or Select 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 651d9d0e2..523f81f5f 100644
--- a/DisCatSharp/Net/Rest/Endpoints.cs
+++ b/DisCatSharp/Net/Rest/Endpoints.cs
@@ -1,481 +1,486 @@
 // 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 tags endpoint.
+	/// </summary>
+	public const string TAGS = "/tags";
+
 	/// <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";
 }